Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdevelop@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

190 files changed, 23284 insertions, 0 deletions

diff --git a/doc/Makefile.am b/doc/Makefile.am
new file mode 100644
index 00000000..2c7c6128
--- /dev/null
+++ b/doc/Makefile.am
@@ -0,0 +1,2 @@
+SUBDIRS = kdevelop std extras kde_app_devel
+
diff --git a/doc/api/Architecture.dox b/doc/api/Architecture.dox
new file mode 100644
index 00000000..ae4ef73d
--- /dev/null
+++ b/doc/api/Architecture.dox
@@ -0,0 +1,315 @@
+/** \file  Architecture.dox
+  * \brief KDevelop architecture
+  */
+
+/** \page architecture KDevelop 3 Architecture
+
+KDevelop uses a plugin based architecture. This will be explained in more
+detail in the next sections. To add a new plugin check the \ref howToAddPlugins page.
+
+\section devteammodel Development Team cooperation model
+
+KDevelop is the result of the work of many people. To help syncronize the effords and to automate
+some tasks, the team uses many tools:
+
+  - CVS servers
+  - KDE Bugzilla
+  - Web servers
+  - Mailing Lists
+  - IRC
+  - Doxygen
+  - docbook
+  - LXR
+  - E-mail :)
+  - Cron Jobs
+  - and of course KDevelop :)
+  .
+
+They get interconnected like this:
+
+\image html Development.png
+
+
+\section overview Source Overview
+
+\subsection source-division Main Source Divisions
+
+The KDevelop 3 source is divided into several parts which correspond to
+subdirectories in the KDevelop project directory. There are several main
+parts to distinguish, mainly:
+
+  - src            = The core part of KDevelop
+  - lib/interfaces = Plugin handler interface classes
+  - parts          = The various parts using the KParts framework ( KDevPlugin children )
+  - languages      = \ref language-parts
+  - buildtools     = \ref buildtool-parts
+  - vcs            = \ref vcs-parts
+  - editors        = \ref editor-parts
+  .
+
+\image html Architecture.png
+
+This image is not complete there are parts that are not displayed. See below for a more detailed description.
+
+\subsection core-part The Core Part of KDevelop
+
+\subsubsection mainwindows Main Window Objects
+
+There are two types of possible main window objects:
+
+ - MainWindow implements standard MDI user interfaces:
+   - Top level mode (see MainWindow::switchToToplevelMode() )
+   - Childframe mode (see MainWindow::switchToChildframeMode() )
+   - Tab page mode (see MainWindow::switchToTabPageMode() )
+   - IDEAl mode (see MainWindow::switchToIDEAlMode() )
+   .
+ - MainWindowIDEAl implements an enhanced MDI main window providing a set of
+   pre-arranged access tabs around user areas.
+ .
+
+Both main window classes inherit from the KDevMainWindow class which provides
+access to common window features.
+
+\subsubsection toplevel The TopLevel Object
+
+There is only one toplevel object of class KDevMainWindow in KDevelop. It can
+be accessed through the static function TopLevel::getInstance() (see the
+TopLevel class).
+
+\subsection parts-overview KDevelop Parts Overview
+
+All parts reside in dedicated subdirectories acording to their function. They can
+be viewed according to their functionalities as follows.
+
+\subsubsection language-parts Programming Language Support Parts
+
+These parts implement a KDevLanguageSupport Class interface.
+To add support for a new programming language check the \ref howToAddProgrammingLanguages page (doc/api/HowToAddProgrammingLanguages.dox file).
+Take a look at \ref LangSupportStatus (doc/api/LangSupportStatus.dox file) to see the current status/features of the programming languages currently supported by KDevelop.
+
+  - languages/ada = Support for Ada
+    - (see AdaSupportPart)
+    .
+  - languages/bash = Support for bash
+    - (see BashSupportPart)
+    .
+  - languages/cpp = Support for C/C++
+    - (see CppSupportPart)
+      - languages/cpp/debugger = GNU Debugger frontend
+        - (see GDBDebugger::DebuggerPart)
+        .
+      .
+    .
+  - languages/fortran = Support for Fortran
+    - (see FortranSupportPart)
+    .
+  - languages/haskell = Support for Haskell
+    - (see HaskellSupportPart)
+    .
+  - languages/java = Support for Java
+    - (see JavaSupportPart)
+      - languages/java/degugger = Java debugger frontend
+        - (JAVADebugger::JavaDebuggerPart)
+        .
+      .
+    .
+  - languages/pascal = Support for Pascal
+    - (see PascalSupportPart)
+    .
+  - languages/perl = Support for Perl
+    - (see PerlSupportPart)
+    .
+  - languages/php = Support for PHP
+    - (see PHPSupportPart)
+    .
+  - languages/python = Support for Python
+    - (see PythonSupportPart)
+    .
+  - languages/ruby = Support for Ruby
+    - (see RubySupportPart)
+    .
+  - languages/sql = Support for SQL
+    - (see SQLSupportPart)
+    .
+  .
+
+\subsubsection buildtool-parts Build tools Parts
+
+These parts implement a KDevProject Class interface.
+
+  - buildtools/ada = Ada build tool
+    - (see AdaProjectPart)
+    .
+  - buildtools/ant = ANT build tool
+    - (see AntProjectPart)
+    .
+  - buildtools/autotools = Autotools build tool
+    - (see AutoProjectPart)
+    .
+  - buildtools/custommakefiles = Custom makefiles build tool
+    - (see CustomProjectPart)
+    .
+  - buildtools/generic = Generic build tool
+    - (see GenericProjectPart)
+    .
+  - buildtools/pascal = Pascal build tool
+    - (see PascalProjectPart)
+    .
+  - buildtools/script = Script build tool
+    - (see ScriptProjectPart)
+    .
+  - buildtools/qmake = QMake based build tool
+    - (see TrollProjectPart)
+    .
+  .
+
+
+\subsubsection vcs-parts VCS (Version Control System) Parts
+
+These parts implement a KDevVersionControl Class interface.
+
+  - vcs/cervisia = Cervisia Support
+    - (see CervisiaPlugin)
+    .
+  - vcs/clearcase = IBM Rational ClearCase Support
+    - (see ClearcasePart)
+    .
+  - vcs/cvs = CVS Support
+    - (see CvsPart)
+    .
+  - vcs/cvsservice = cvsservice Support (Cervisia interface)
+    - (see CvsServicePart)
+    .
+  - vcs/perforce = Version managment system perforce integration
+    - (see PerforcePart)
+    .
+  - vcs/subversion = Subversion integration
+    - (see subversionPart)
+    .
+  .
+
+
+\subsubsection editor-parts editor support Specific Parts
+
+These parts implement a KTextEditor Class interface.
+Take a look at \ref EditorsSupportStatus (doc/api/EditorsSupportStatus.dox file) to see the current status/features of the editors currently supported by KDevelop.
+
+  - editors/editor-chooser = Chooses an internal text editor
+    - (see EditorChooserPart)
+    .
+  - editors/nedit = KTextEditor interface for nedit
+    - (see KNEditFactory, Document, View)
+    .
+  - editors/qeditor = QEditor integration
+    - (see QEditorPart)
+    .
+  .
+
+
+\subsubsection global-parts Global Parts
+
+Some of the parts are considered global - that is, they effect the entire
+operation of KDevelop.
+
+These parts implement a KDevPlugin Class interface.
+
+  - parts/appwizard = New Project Wizard
+    - see AppWizardPart
+    - see \ref howToAddApplicationTemplates (doc/api/HowToAddApplicationTemplates.dox file)
+    .
+  - parts/history = Project history
+    - (see HistoryPart)
+    .
+  - parts/konsole = Embedded Konsole
+    - (see KonsoleViewPart)
+    .
+  - parts/doctreeview = Documentation Viewer
+    - (see DocTreeViewPart)
+    .
+  - parts/openwith = "Open with" menu addon
+    - (see OpenWithPart)
+    .
+  - parts/fileselector = A file selection widget
+    - (see FileSelectorPart)
+    .
+  - parts/uimode = Customize the UI mode
+    - (see UIChooserPart)
+    .
+  - parts/texttools = Additional text tools
+    - (see TextToolsPart)
+    .
+  - parts/tipofday = A tip of the day
+    - (see TipOfDayPart)
+    .
+  - parts/grepview = A graphical grep utility
+    - (see GrepViewPart)
+    .
+  - parts/tools = Toolbar management
+    - (see ToolsPart)
+    .
+  - parts/regexptest = A regular expression tester
+    - (see RegexpTestPart)
+    .
+  - parts/abbrev = Abbreviation Expansion
+    - (see AbbrevPart)
+    .
+  - parts/filter = Shell Filtering and Insertion
+    - (see FilterPart)
+    .
+  - parts/valgrind = A graphical valgrind frontend
+    - (see ValgrindPart)
+    .
+  .
+
+
+\subsubsection project-specific-parts Project Specific Parts
+
+These parts implement a KDevPlugin Class interface.
+
+  - parts/astyle = Source code formatter
+    - (see AStylePart)
+    .
+  - parts/buglist = Bug tracking application
+    - (see BugList)
+    .
+  - parts/classview = Classview Manager
+    - (see ClassViewPart)
+    .
+  - parts/ctags = CTags frontend
+    - (see CTagsPart)
+    .
+  - parts/diff = Difference viewer
+    - (see DiffPart)
+    .
+  - parts/distpart = Aids in building and publishing the final project
+    - (see DistpartPart)
+    .
+  - parts/doxygen = Doxygen integration
+    - (see DoxygenPart)
+    .
+  - parts/filecreate = New file creation
+    - see FileCreatePart
+    - see \ref howToAddFileTemplates (doc/api/HowToAddFileTemplates.dox file)
+    .
+  - parts/fileview = File groups
+    - (see FileViewPart, FileGroupsPart)
+    .
+  - parts/manager = Document manager
+    - (see DocManager, ViewManager)
+    .
+  - parts/outputviews = Application output views
+    - (see AppOutputViewPart, MakeViewPart)
+    .
+  - parts/scripting = Python scripting interface
+    - (see ScriptingPart)
+    .
+  - parts/sourcenav = Source code navigation
+    - (see SourceNavPart)
+    .
+  - parts/visualboyadvance = VisualBoy Advance integration
+    - (see VisualBoyAdvance::VisualBoyAdvancePart)
+    .
+  .
+
+*/
+
diff --git a/doc/api/Architecture.png b/doc/api/Architecture.png
new file mode 100644
index 00000000..306881fa
--- /dev/null
+++ b/doc/api/Architecture.png
diff --git a/doc/api/Architecture.sxd b/doc/api/Architecture.sxd
new file mode 100644
index 00000000..b48f9a36
--- /dev/null
+++ b/doc/api/Architecture.sxd
diff --git a/doc/api/Development.png b/doc/api/Development.png
new file mode 100644
index 00000000..063e63db
--- /dev/null
+++ b/doc/api/Development.png
diff --git a/doc/api/Development.sxd b/doc/api/Development.sxd
new file mode 100644
index 00000000..ff5b06cc
--- /dev/null
+++ b/doc/api/Development.sxd
diff --git a/doc/api/EditorsSupportStatus.dox b/doc/api/EditorsSupportStatus.dox
new file mode 100644
index 00000000..e826471c
--- /dev/null
+++ b/doc/api/EditorsSupportStatus.dox
@@ -0,0 +1,189 @@
+/** \file EditorsSupportStatus.dox
+  * \brief Editors Support Status
+  */
+
+/** \page EditorsSupportStatus Editors Support Status
+
+Kate and Kvim are part of KDE and KDevelop just uses them.
+
+qeditor and Nedit are interfaced via KDevelop's code. You can look at their code at <code>editors/qeditor</code> and <code>editors/nedit</code>.
+
+<table border="1" style="text-align: left; margin-left: auto; margin-right: auto;" cellpadding="2" cellspacing="2">
+    <tr>
+      <th style="text-align: center;">features/editor</th>
+      <th style="text-align: center;">kate</th>
+      <th style="text-align: center;">kvim (KDE 3.2)</th>
+      <th style="text-align: center;"><a href="classQEditor.html">qeditor</a></th>
+      <th style="text-align: center;"><a href="classKNEditFactory.html">Nedit (Disabled)</a></th>
+    </tr>
+    <tr>
+      <td style="background-color: rgb(51, 204, 0);">Advanced text editor</td>
+      <td style="background-color: rgb(51, 204, 0);"></td>
+      <td style="background-color: rgb(51, 204, 0);"></td>
+      <td style="background-color: rgb(51, 204, 0);"></td>
+      <td style="background-color: rgb(51, 204, 0);"></td>
+    </tr>
+    <tr>
+      <td>Open, close and save big text files</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td>Y</td>
+    </tr>
+    <tr>
+      <td>Undo and redo</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Jump in text: next/previous character, word.</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td>Y</td>
+    </tr>
+    <tr>
+      <td>Jump to start or the end of the line/text</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td>Y</td>
+    </tr>
+    <tr>
+      <td>Go to line</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Select text when jumping (character, word, line), </td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Select all the text</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Copy, paste and delete selections of text</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Print</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td style="background-color: rgb(51, 204, 0);">Advanced text view:</td>
+      <td style="background-color: rgb(51, 204, 0);"></td>
+      <td style="background-color: rgb(51, 204, 0);"></td>
+      <td style="background-color: rgb(51, 204, 0);"></td>
+      <td style="background-color: rgb(51, 204, 0);"></td>
+    </tr>
+    <tr>
+      <td>Horizontal and vertical scrolling</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Display selections</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Mouse Wheel support</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Dynamic word wrap</td>
+      <td>Y</td>
+      <td>N</td>
+      <td></td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Line numbers</td>
+      <td>Y</td>
+      <td>N</td>
+      <td></td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Show tabs</td>
+      <td>Y</td>
+      <td>N</td>
+      <td></td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Find in file</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Replace in file</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td style="background-color: rgb(51, 204, 0);">Coding specific properties:</td>
+      <td style="background-color: rgb(51, 204, 0);"><br></td>
+      <td style="background-color: rgb(51, 204, 0);"><br></td>
+      <td style="background-color: rgb(51, 204, 0);"><br></td>
+      <td style="background-color: rgb(51, 204, 0);"><br></td>
+    </tr>
+    <tr>
+      <td>Syntax highlighting</td>
+      <td>Y</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Code folding</td>
+      <td>Y</td>
+      <td>N</td>
+      <td></td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Spell</td>
+      <td>Y</td>
+      <td>N</td>
+      <td></td>
+      <td></td>
+    </tr>
+    <tr>
+      <td>Auto indendt</td>
+      <td>N</td>
+      <td>N</td>
+      <td>Y</td>
+      <td></td>
+    </tr>
+</table>
+
+*/
diff --git a/doc/api/FutureTasks.dox b/doc/api/FutureTasks.dox
new file mode 100644
index 00000000..fbed119a
--- /dev/null
+++ b/doc/api/FutureTasks.dox
@@ -0,0 +1,136 @@
+/** \file FutureTasks.dox
+  * \brief Future tasks and ideas for the next release of KDevelop
+  */
+/** \page FutureTasks Future tasks and ideas for the next release of KDevelop
+
+\section codereftodo Code Refactoring / Improvements:
+
+  - Core
+    - Make sure all lib interfaces are available via DCOP
+    - Find a nicer way to remove dynamic menu entries from context menus
+    - Resolve the path handling mess 
+    - Project name should be able to contain spaces
+    - Import existing directory: Should be named "Import existing project"
+      and more intuitive (wizard-like)
+      - Question from the wizard: "I have found C++ files in your
+        project directory. Should C++ be the primary language of your
+        project?" User: [Yes/No] =&gt; Next Step...
+      - Something intuitive for the binary/-ies (for debugger and
+        execution of program), libtool ([Yes/No] for the debugger), build
+        tool (qmake, automake,...?), etc.., too.
+    - use mimetype to determine code files, not extension
+      (see bug #
+    - Make the help buttons (that we already have) open the KDevelop Handbook on
+      the correct page (or the index if the subject is not covered yet).
+    - New and improved VCS framework (Needs better description)
+    - Another look at the plugin system (Nees better description)
+    - Another look at the project files (shared, non-shared, session)
+    - fix(redesign?) project language switching
+    - editor handling could be made a bit saner if editor plugin switching was an after-restart-only feature
+    
+  - Programming Language Support Parts
+    - Create base classes for language support parts:
+      - AntlrLanguageSupport
+      - AntlrBackgroundParser
+      - AntlrProblemReporter
+    - Same for:
+      - YaccLanguageSupport
+      - YaccBackgroundParser
+      - YaccProblemReporter
+    - There is a possibility to create even something like
+      - LanguageSupportBase
+
+    Look at java, pascal and ada support parts to get more inspiration. 
+    There should be base classes for ada, java and pascal language supports - too much code duplication.
+ 
+    - CppSupportPart
+      - Extended "make member" functionality - run on a .h to implement stubs for all unimplemented non-abstract methods
+      - Code Refactoring
+    - text hint type info tooltips (edit mode)
+    - text hint value info tooltips (debug mode)
+    - Make the language plugin know stuff like what file patterns to look for (for instance, "find in files" needs this)
+    
+  - Build tools Parts
+    - Show .po files in project management
+    - Custom actions for groups, targets and files for project managers:
+      - any menu item should be a KAction plugged into KPopupMenu, also we need to define shortcuts for any such action,
+        also we should make sure those actions are properly executed from a shortcut.
+    - AutoProjectPart
+      - Should be able to DND files from other targets / file list / konq to add to targets
+      - Should loose the experimental crashy and nonstandard "add files" dialog
+      - Update configure.in when sub projects are added and the project doesn't use am_edit
+    - Keep the correctly cased project name and save it to the project file
+
+  - Debugger Parts
+    - Create a debugger support base classes. Make the current GDB support a plugin.
+    - Implement parts for other debuggers i.e. DBX, WDB, Ladebug, JDB, XDB, bashdb, the Perl debugger, or the Python debugger.
+      We can use DDD as inspiration.
+    - General debugger
+      - variable widget
+        - set variable by editing the value in the tree
+        - cast value by editing the type in the tree
+      - disassembly
+        - add breakpoint display
+        - set breakpoint by selecting a line as in the edit window
+        - allow scrolling of disassembled code about and below current limits
+        - add source to disassembled code as comments
+        - basically just re-work the whole disassemble window :)
+      - Bugs
+        - Fix "core file" handling
+        - Fix "attach to" handling
+        - Breakpoints can disappear at odd times
+        - When the target program crashes, the debugger can't be started again. (intermittant?)
+        - Break on method() - could have multiple methods which require a choice. How to handle this?
+
+
+  - Plugins
+    - DocTreeViewPart
+      - Implement plugin system for doctreeview.
+      - improve documentation browsing
+      - Check if a man page exists before offering the context menu item 'Goto manpage'
+      - right click -> set as bookmark in docviewer
+    - ClassViewPart
+      - Implement language-dependant plugin system for classview:
+      - namespaces/classes/functions are not always applicable to a language, we need a way to correctly
+        fill a class view and combo boxes - only a language support can do that properly.
+      - Distinguish vanilla c++ support from c++ + Qt extensions and show signals/slots in the class view only with Qt. (is this still valid?)
+    - KonsoleViewPart
+      - Perhaps use konsole part for the application frontend
+      - cd's when selecting a file, but doesn't when selecting a dir,
+        desired: a menu option to "cd" to that directory
+    - QEditor
+      - Replace editors/qeditor/koReplace.* and editors/qeditor/koFind.* with kdelibs/kutils/kreplace.* and kdelibs/kutils/kfind.*
+
+    
+\section extensiontodo Extensions / New Functionality:
+
+  - Core
+    - implement multiple-views per document (why?)
+    - Document manager (not obviously useful)
+    - Implement Add Plugin 
+    - Show intro page on startup
+  - Programming Language Support Parts
+  - Build tools Parts
+  - Plugins
+    - better sourcenav part (all navigation tools should be supported with at least a "back" action - forward much less important)
+    - Integrate kontact's TODO-List and knotes plugin. (We need something like a
+      server/client system that all the knotes/toto-clients are always synced.)
+    - a generic macro-tool (if possible, probably best implemented as a KTE plugin)
+    - Free grouping of files in file group plugin
+
+
+\section misctodo Miscellaneous (and possibly invalid) items:
+   
+  - UI bugs
+    - Editor options dialog missing when all views are closed (virtually impossible to fix)
+    - If you click an error in the output view, "Next Error"/"Previous
+      Error" should then start from that point (already implemented?)
+    - Messages in status bar would look nicer if they appeared with
+      the same border as other items (impossible)
+    - Browser tool bar should truncate long menu entries so it doesn't
+      take so much space (already implemented?)
+    - Extend KDevPlugin-API in order to have a preferred border for at
+      least the selection parts (Automake Manager, Class Browser, File
+      Groups, etc...)
+
+*/
diff --git a/doc/api/HighPriTasks.dox b/doc/api/HighPriTasks.dox
new file mode 100644
index 00000000..21116342
--- /dev/null
+++ b/doc/api/HighPriTasks.dox
@@ -0,0 +1,36 @@
+/** \file HighPriTasks.dox
+  * \brief High priority tasks
+  */
+/** \page HighPriTasks High priority tasks!
+
+\section fixMajBugs Fixing major/annoying bugs
+
+  - Fix the mess of .kdevelop and .kdevses file.
+    - All project wide setings should go into .kdevelop and
+    - all session (and personal) options should go into .kdevses file
+    .
+    This way the .kdevelop file can be shared in teams of developers.
+
+
+\section KDevelop2compat KDevelop 2 compatibility
+(These are things that must be accomplished before we can say that KDevelop 3
+&gt;= kdevelop 2.x UI-wise and functionality-wise!)
+
+  - general UI issues:
+    - toplevel UI mode broken concerning to the accels
+    - [Modified] missing in mainframe caption
+    - captions missing for toolbar buttons
+    .
+  - build/configuration:
+    - cross-compiling feature missing
+    - make "MIN_VERSION" configurable on new project creation
+    .
+  - doctreeview:
+    - implement "Make User Manual"
+    - use kdoc to update Qt/KDE docs
+    .
+  - Solve the regression bugs. These are the <a href= "http://bugs.kde.org/buglist.cgi?product=kdevelop&bug_status=UNCONFIRMED&bug_status=NEW&priority=HI">ones
+marked with priority "HI" in the bug database</a>
+
+
+*/
diff --git a/doc/api/HowToAddApplicationTemplates.dox b/doc/api/HowToAddApplicationTemplates.dox
new file mode 100644
index 00000000..7eec80c7
--- /dev/null
+++ b/doc/api/HowToAddApplicationTemplates.dox
@@ -0,0 +1,285 @@
+/** \file HowToAddApplicationTemplates.dox
+  * \brief How to add application templates to the application wizard part
+  */
+/** \page howToAddApplicationTemplates How to add application templates to the application wizard part
+
+Project templates provide the developer with a basic application framework.
+This is necessary for rapid application development (RAD) and makes it even possible
+for an inexperienced 3rd party developer to create standard conforming
+applications like kedit as well as plugins for example for kdevelop or noatun.\n\n
+\ref templates_1\n
+    - \ref templates_1_1
+    - \ref templates_1_2
+        - \ref templates_1_2a
+        - \ref templates_1_2b
+        - \ref templates_1_2c
+        - \ref templates_1_2d
+        - \ref templates_1_2e
+        .
+    .
+\ref templates_2\n
+\ref templates_3\n
+\ref templates_4\n
+<!-- @todo <b>Developer information:</b> The documentation for the related
+<code>"Project"->"Import Existing Project..."</code> is available here: \ref appwizard_imports
+-->
+<hr>
+
+\section templates_1 I. Example: How To Create a Simple KDE Application Template "KHello"
+
+You can find this template in <code>$KDEDIR/share/apps/kdevappwizard/template-khello</code>.
+
+\subsection templates_1_1 I.1. Step 1: Basic Skeleton
+
+Create a directory <code>template-khello</code> with the files
+<code><pre>
+    - template-khello/app.cpp
+    - template-khello/app.h
+    - template-khello/app.desktop
+    - template-khello/app.kdevelop
+    - template-khello/appui.rc
+    - template-khello/khello
+    - template-khello/main.cpp
+    - template-khello/preview.png
+    - template-khello/script
+    - template-khello/src-Makefile.am
+    - template-khello/subdirs
+    .
+</pre></code>
+\note The directory name must begin with <code>"template-"</code>.
+
+\subsection templates_1_2 I.2. Step 2: The Files in Detail
+
+Have a look into the files! There are some variables which the application
+wizard will replace:
+<code><pre>
+    - \%{AUTHOR} ...... by the author
+    - \%{EMAIL} ....... by the e-mail address 
+    - \%{VERSION} ..... by the version
+    - \%{APPNAME} ..... by the project name (KHello)
+    - \%{APPNAMELC} ... by the project name in lowercase (khello)
+    - \%{APPNAMEUC} ... by the project name in uppercase (KHELLO)
+    - \%{LICENSE} ..... by the license (GPL, BSD, QPL, LGPL, ...)
+    - \%{LICENSEFILE} . by the licensefile
+    - \%{YEAR} ........ by the year
+    .
+</pre></code>
+All this can be found in <code>$KDEDIR/share/apps/kdevappwizard/template-common/kdevelop.pm</code>.
+\subsubsection templates_1_2a I.2.1. The Source Files
+
+The files <code>template-khello/app.cpp, template-khello/app.h</code> and
+<code>template-khello/main.cpp</code> contain the source code that should not
+be too special so that the user can implement his own ideas.\n
+(There may be variables included - see \ref templates_1_2 "Step 2: The Files in Detail").
+
+\subsubsection templates_1_2b I.2.2. The File template-khello/khello
+
+It may look like this:
+\verbinclude khello/khello
+
+The application wizard looks into this file to get
+    - the information where to integrate the plugin into the the listview (<code>Category=</code>)
+    - the name (<code>Name=</code>) and the comment (<code>Comment=</code>)
+    - the preview image (<code>Icon=</code>)
+    - and the file templates the project uses (<code>FileTemplates=</code>).
+    .
+Further information could be (not required):
+    - <code>Comment=</code> a small comment for the template. Longer comments should go into a README.devel and shown on startup
+    - <code>ShowFilesAfterGeneration=</code> a comma-separated list (without whitespaces) of files that should be opened immediately after the generation, for instance a README.devel or a source file the user has to modify, the path is relative to the project directory (example: <code>ShowFilesAfterGeneration=src/main.cpp,src/plugin.cpp</code>). And
+        - <code>APPNAMEUC</code> will be replaced with the projectname in uppercase,
+        - <code>APPNAMELC</code> will be replaced with the projectname in lowercase,
+        - <code>APPNAME</code> will be replaced with the projectname.
+        .
+    - <code>DefaultDestinatonDir</code> changes the default destination dir for the project (~) to your value, whereas <code>HOMEDIR</code> is a keyword
+    .
+
+\attention The file <code>template-khello/khello</code> must have the same name as
+the right half of the directory! If the directory is <code>template-foobar</code>
+the file must be <code>template-foobar/foobar</code>.
+
+\see AppWizardPart for more information.
+
+\subsubsection templates_1_2c I.2.3. Some Additional Files
+
+The file
+    - <code>template-khello/appui.rc</code> contains information about the toolbar and the menu.
+    - <code>template-khello/preview.png</code> will be shown in the aplication wizard.
+    - <code>template-khello/app.desktop</code> describes the application.
+    - <code>template-khello/subdirs</code> contains a list of the subdirectories (usually <code>doc, po, src</code>) and can be found in the project root directory. It is necessary for the autotools.
+    .
+
+\subsubsection templates_1_2d I.2.4. The File template-khello/src-Makefile.am
+
+This file will be copied to the <code>$PROJECTDIR/src/</code>.
+\verbinclude khello/src-Makefile.am
+
+\subsubsection templates_1_2e I.2.5. The File template-khello/script
+
+The following script is used to install the template and replaces all
+variables by the corresponding value. The result is a hopefully working
+kdevelop project!
+\verbinclude khello/script
+<br>
+\note There are several application templates which use some identical
+files - that's why some files are taken from the <code>"template-common"</code>-directory.
+
+\section templates_2 II. Registration/Installation Of The Application Template
+
+The easiest way to install your template is to provide an "install.sh" shell script.\n
+Example:
+\code
+#!/bin/sh
+
+kde_prefix=`kde-config --prefix`
+if  [ `id -u` = 0 ]; then
+  # we are root so install the template into the global kde directory
+  kde_dir=`kde-config --prefix`
+else
+  # we are a user so install it into $HOME/.kde/share/apps/kdevappwizard directory
+  kde_dir=`kde-config --localprefix`
+  echo "Note: It would be better to install as root. Press CTRL+C to abort"
+fi
+
+# use usual path or another one?
+echo "Install dir [${kde_dir}/share/apps/kdevappwizard]:"
+read newdir
+
+if [ "$newdir"a = a ]; then newdir="${kde_dir}/share/apps/kdevappwizard/"; fi
+
+# make sure the directories exist
+if [ ! -e "${newdir}/template-khello" ]; then mkdir -p "${newdir}/template-khello" ; fi;
+if [ ! -e "${newdir}/templates" ]; then mkdir -p "${newdir}/templates" ; fi;
+if [ ! -e "${newdir}" ]; then mkdir -p "$newdir" ; fi;
+if [ ! -e "${newdir}/template-common" ]; then ln -s "${kde_prefix}/share/apps/kdevappwizard/template-common" "${newdir}/template-common" ; fi;
+
+# install now
+cp -R --target-directory "$newdir" template-khello
+# the file template-khello/khello must go to the "templates" directory that
+# kdevelop knows that it exists
+mv "$newdir/template-khello/khello" "$newdir/templates/"
+echo "done"
+\endcode
+\n
+\attention Please test your template whether it installs and behaves correctly! Test, test and test again! ;)
+
+\section templates_3 III. How To Add The Template To KDevelop CVS HEAD
+
+This section is for kdevelop developers only. Most probably you don't have to read this!.\n
+Move the directory <code>"template-khello"</code> to <code>kdevelop/languages/cpp/app_templates/</code>
+and then add the following files in <code>kdevelop/languages/cpp/app_templates/template-khello/</code>
+(in this example the language is c++ if you use other language replace cpp with the language name):
+    - <code>".kdev_ignore"</code> is an empty file. It prevents KDevelop's
+    C++-parser from parsing the C++ template files. This is necessary because the template files are just code templates and not real code (yet).
+    - <code>".cvsignore"</code> looks like this:
+\code
+Makefile
+Makefile.in
+script.local
+\endcode
+    - <code>"Makefile.am"</code> looks like this:
+    \verbinclude khello/Makefile.am
+    .
+Finally add <code>"template-khello"</code> to "SUBDIRS = " in <code>kdevelop/languages/cpp/app_templates/Makefile.am</code>.\n
+\attention Please test your template whether it installs and behaves correctly!
+Test, test and test again! It works? Well - now talk to the kdevelop guys so
+that they know what's going on and probably you may commit. ;)
+
+\section templates_4 IV. Changes to the template system (VERY IMPORTANT)
+
+The entire app template system described above has been changed.
+To port a template to the new system the
+information from the script file will need to be moved into the ini file.
+The example is as follows:
+\code
+install(
+"${src}/template-chello/app.kdevelop","${dest}/${APPNAMELC}.kdevelop" );
+\endcode
+becomes
+\code
+[PROJECT]
+Type=install
+Source=%{src}/template-chello/app.kdevelop
+Dest=%{dest}/%{APPNAMELC}.kdevelop
+\endcode
+
+Things like <code>installIncAdmin();</code> and <code>installGNU();</code> now involve unpacking
+the tar archives.  This is done by creating a target in the ini file as
+follows:
+\code
+[GNU]
+Type=install archive
+Source=%{src}/template-common/gnu.tar.gz
+Dest=%{dest}
+\endcode
+
+The popular script functions convert as follows:
+\code
+installIncAdmin(); %{src}/template-common/incadmin.tar.gz
+installGNU();  %{src}/template-common/gnu.tar.gz
+installAdmin(); %{src}/template-common/admin.tar.gz
+installGnome(); %{src}/template-common/gnome.tar.gz
+installWX(); %{src}/template-common/wxwidgets.tar.gz
+\endcode
+
+
+To create directories is now:
+\code
+[SRC]
+Type= mkdir
+Dir=%{dest}/src
+\endcode
+
+New additions are as follows:
+\code
+[MGS]
+Type=message
+Comment=A simple C project was created in %{dest}.
+\endcode
+
+Will allow you to display a custom message when the template has
+finished installing.  This is very handy for projects that require
+custom variables to be set.
+
+The concept of custom variables was also introduced.  To create a
+variable that can be edited from the project wizard you need to add an
+entry as follows:
+\code
+[LIBS]
+Type = value
+ValueType=<Qt Data type>
+Value= <Value Name that will be substituted in the code>
+Comment= <The label in the UI>
+Default= <The default value>
+\endcode
+
+One special value can be used to turn targets on and off.  This is done
+by adding a value as follows:
+\code
+[DOCSOPT]
+Type = value
+ValueType=bool
+Value=INSTALL_DOCS
+Comment= Install Docbook documentation templates.
+Default=true
+\endcode
+
+Then in the targets you wish to make optional you add the Option
+property with the value's name as the data. This will look as follows:
+\code
+[DOCSDIREN]
+Type=mkdir
+Dir=%{dest}/doc/en
+Option=INSTALL_DOCS
+\endcode
+
+The Option target is available to the mkdir, install, and install
+archive targets.
+
+The last new addition is the optional post processing of the files as
+they are copied.  For install and install archive you can add a
+<code>Process=true</code> or <code>Process=false</code> to turn the processing on or off.
+
+A note on the UI. its not final, it will get better.  Suggestions or
+bugs should be noted asap.
+
+*/
diff --git a/doc/api/HowToAddFileTemplates.dox b/doc/api/HowToAddFileTemplates.dox
new file mode 100644
index 00000000..fa6e630b
--- /dev/null
+++ b/doc/api/HowToAddFileTemplates.dox
@@ -0,0 +1,30 @@
+/** \file HowToAddFileTemplates.dox
+  * \brief How to add file templates to the file create part
+  */
+/** \page howToAddFileTemplates How to add file templates to the file create part
+
+File templates provide the developer with a basic file.  They are prototypes for both source files of
+the project's language, and for other files that may be useful in the project. For example, a C++
+project may have templates for both .cpp and .h files, plus QT Designer .ui files, and supporting
+files such as XML.
+
+These prototypes are placed in <code>parts/filecreate/file-templates</code> dir or
+<code>languages/YOURLANGUAGE/file_templates</code> and have names equal to the extensions of language
+source files.
+
+Sometimes, different 'flavours' of template are required for a particular file type. In these
+instances, 'subtypes' can be defined to allow several different templates for a file type. An example
+of this are QT designer '.ui' files. KDevelop supplies several different templates for .ui
+files. Subtypes are named by the file type extension followed by a hyphen followed by an identifier
+for the subtype. E.g. ui-widget, ui-dialog
+
+The description of the prototypes is placed in <code>parts/filecreate/template-info.xml</code>. This
+file is fairly self-explanatory if you take a look at it.
+
+Note that templates and templates information can be edited within KDevelop itself. The global
+templates that can be made available to any project can be changed in Settings / Configure KDevelop... / New File
+Wizard; and project related settings can be changed in Project / Project Options / New File Wizard.
+
+That's all! :)
+
+*/
diff --git a/doc/api/HowToAddGenericBuildTools.dox b/doc/api/HowToAddGenericBuildTools.dox
new file mode 100644
index 00000000..b073cf0f
--- /dev/null
+++ b/doc/api/HowToAddGenericBuildTools.dox
@@ -0,0 +1,21 @@
+/** \file HowToAddGenericBuildTools.dox
+  * \brief How to add a generic build tool plugins to the generic build tool part
+  */
+
+/** \page howToAddGenericBuildTools How to add a generic build tool plugins to the generic build tool part
+
+This part offers build tool facilities using project files in xml format (dtd is located in buildtools/generic/kdevxmlproject.dtd).
+Those xml files can be converted into makefiles, ant xml files or simply shell scripts using build system plugins.
+Build system plugin is an object that implements KDevBuildSystem interface.
+Build system plugins are located in buildtools/generic/buildsystem.
+
+\section sectionStep1 Step 1: Make your plugin loadable
+
+For a plugin <code>foo</code>, create a file <code>foo.desktop</code> which contains KDevelop/Part in its list of ServiceTypes.
+
+The rest of this document is to be written.
+
+Document your plugin in the way described at \ref howToDocument (doc/api/HowToDocument.dox file).
+
+*/
+
diff --git a/doc/api/HowToAddPlugins.dox b/doc/api/HowToAddPlugins.dox
new file mode 100644
index 00000000..ce8f259a
--- /dev/null
+++ b/doc/api/HowToAddPlugins.dox
@@ -0,0 +1,204 @@
+/** \file HowToAddPlugins.dox
+  * \brief How to extend KDevelop via plugins
+  */
+
+/** \page howToAddPlugins How to extend KDevelop via plugins
+
+\section createDesktop Step 1: Make your plugin loadable
+
+For a plugin <code>foo</code>, create a file <code>foo.desktop</code> which contains KDevelop/Part in its list of ServiceTypes.
+
+  - See <code>parts/doctreeview/kdevdoctreeview.desktop</code> for an example.
+  .
+
+If you install this file into <code>\$(kde_servicesdir)</code>, your plugin will automatically be loaded.
+
+\subsection changeLoading How to change the default loading
+
+You can change the default loading by changing some settings in your <code>foo.desktop</code> file:
+
+  - Set <code>X-KDevelop-Scope=</code> to <code>Global</code> or
+    <code>Project</code>
+    - <b>Note:</b> This property is <i>not</i> optional
+	.
+  - You can add a list of programming languages which are supported by your
+    plugin
+	- If your plugin works with all languages leave the
+	  <code>X-KDevelop-ProgrammingLanguages=</code> field empty
+	  <i>(optional)</i>
+	.
+  - You can add a list of keywords.
+    - The plugin will only be loaded if all keywords match with the
+	<code>Keywords=</code> field in the projectfile <i>(optional)</i>.
+	.
+  .
+
+An example from the Java Debugger Plugin:
+
+<code><pre>
+    #######################
+    X-KDevelop-Scope=Project
+    X-KDevelop-ProgrammingLanguages=Java
+    Keywords=
+    ##########################
+</pre></code>
+    
+
+\section createFactory Step 2: Make the plugin accessible by the factory
+
+Create a factory class <code>FooFactory</code> which inherits
+<code>KDevFactory</code>. Put a section
+
+<code><pre>
+    extern "C" {
+        void *init_libfoo()
+        {
+            return new FooFactory;
+        }
+    }
+</pre></code>
+
+into the source file, so that the factory can be accessed by KDE's library
+loader. Keep in mind that the name of the method <code>init_libfoo()</code> is
+required for a library with the name <code>libfoo.so</code>.
+
+This may be simplified by the use of the
+<code>K_EXPORT_COMPONENT_FACTORY</code> macro which is defined in
+<code>klibloader.h</code>:
+
+<code>
+K_EXPORT_COMPONENT_FACTORY( libfoo, FooFactory );
+</code>
+
+  - <i>Note:</i> Your factory must reimplement the
+    <code>createPartObject()</code> method of <code>KDevFactory</code> and
+	produce the part there.
+  .
+
+See <code>parts/doctreeview/doctreeviewfactory.cpp</code> for an example.
+
+
+\section implementPart Step 3: Implement your part.
+
+Your part must be derived from <code>KDevPlugin</code>.
+
+  - KDevPlugin takes two arguments:
+    - 1) A <i>parent</i> argument. This also comes from
+	  <code>createPartObject()</code>.
+	- 2) A <i>name</i>, which in turn is given to the <code>QObject</code>
+	  constructor.
+	.
+  .
+
+\subsection accessIDE How to access other IDE components
+
+A part can access other components of the IDE via some accessors
+of <code>KDevPlugin</code>:
+
+  - The <i>application core</i> via <code>core()</code>,
+  - the <i>build tools</i> via <code>project()</code>,
+  - the <i>programming language specific stuff</i> via
+    <code>languageSupport()</code>,
+  - the <i>make frontend</i> via <code>makeFrontend()</code>,
+  - the part which displays <i>appication output</i> via
+    <code>appFrontend()</code>,
+    and finally
+  - the <i>symbol database</i> via <code>classStore()</code>.
+  .
+
+In order to see what these components provide, see <code>lib/interfaces/kdev*.h</code>.
+
+\subsection userPrefs How to store user preferences
+
+Parts can also store user preferences on a per-project basis. To this
+end, they can access a <code>QDomDocument</code> representing the project file
+(which is stored as xml) via <code>document()</code>.
+
+Take attention to the issue that the project file usually is shared in a team of
+developers (e.g. via version control application CVS). So some user preferences might be
+very individual, and some may be valid for all of the team - project-wide so to speak.
+
+That's why the KDevelop architecture makes a difference here and supports two files
+which will be stored in the project root directory. They are the project file (*.kdevelop)
+and the session (*.kdevses) file. The later is for individual settings, not to be thought
+to be shared.
+
+\subsection domProject Project file (*.kdevelop)
+
+For your convenience, you don't have to use the quite complex DOM API. Strings
+can very easily be read from and written to this document using the
+<code>DomUtil</code> class. Here, entries are identified by a 'path' in the
+document. You can think of the DOM document as representing a file system
+rooted in the <code>dom</code> document node.
+
+For example, the <code>autoproject</code> part uses the statement
+
+<code><pre>
+    QString cflags = DomUtil::readEntry( *part->document(),
+                                         "/kdevautoproject/cflags" );
+</pre></code>
+
+to read the <code>CFLAGS</code> variable set by the user, and uses the statement similar to
+
+<code><pre>
+    DomUtil::writeEntry( *part->document(),
+                         "kdevautoproject/cflags",
+                         "--no-exceptions" );
+</pre></code>
+
+to write it back.
+
+  - <i>Note:</i> In order to avoid conflicts between different plugins, you
+    should use your part name as top-level 'directory' in the configuration
+	tree.
+  .
+
+\subsection sessionAccess Project session file (*.kdevses)
+
+The base class of all KDevelop plugins is KDevPlugin. It provides two virtual methods 
+restorePartialProjectSession(..) and savePartialProjectSession(..)
+that you should reimplement in your special plugin to attach to session loading and saving.
+
+When KDevelop loads or closes a project, the program's project session manager
+(class ProjectSession) calls them for each plugin. That manager gives a QDOM node to the
+plugin where it can read out or build up its partial DOM subtree with the session settings.
+That subtree will be stored in the .kdevses file by that session manager.
+
+For example each programmer has set breakpoints in different files than the other ones of
+the team. So the debugger plugin saves them to project session file:
+
+<code><pre>
+void DebuggerPart::savePartialProjectSession(QDomElement* el)
+{
+    gdbBreakpointWidget->savePartialProjectSession(el);
+}
+void GDBBreakpointWidget::savePartialProjectSession(QDomElement* el)
+{
+    QDomDocument domDoc = el->ownerDocument();
+    if (domDoc.isNull()) return;
+    QDomElement breakpointListEl = domDoc.createElement("breakpointList");
+    for ( int row = 0; row < m_table->numRows(); row++ )
+    {
+        BreakpointTableRow* btr = (BreakpointTableRow *) m_table->item(row, Control);
+        Breakpoint* bp = btr->breakpoint();
+        QDomElement breakpointEl = domDoc.createElement("breakpoint"+QString::number(row));
+        breakpointEl.setAttribute("type", bp->type());
+        breakpointEl.setAttribute("location", bp->location(false));
+        breakpointEl.setAttribute("enabled", bp->isEnabled());
+        breakpointEl.setAttribute("condition", bp->conditional());
+        breakpointListEl.appendChild(breakpointEl);
+    }
+    if (!breakpointListEl.isNull()) el->appendChild(breakpointListEl);
+}
+
+}
+</pre></code>
+
+Note that the .kdevses is related to a project. User settings equal for all projects don't
+belong to here. You save them to ~/.kde/share/config/kdeveloprc via class KConfig of the
+kdecore library.
+
+Document your part in the way described at \ref howToDocument (doc/api/HowToDocument.dox file).
+
+*/
+
diff --git a/doc/api/HowToAddProgrammingLanguages.dox b/doc/api/HowToAddProgrammingLanguages.dox
new file mode 100644
index 00000000..5cfa3643
--- /dev/null
+++ b/doc/api/HowToAddProgrammingLanguages.dox
@@ -0,0 +1,252 @@
+/** \file HowToAddProgrammingLanguages.dox
+  * \brief How to add support for a programming language
+  */
+
+/** \page howToAddProgrammingLanguages How to add support for a programming language
+
+\section LSupport List of things to have "complete" support of a given language in KDevelop
+
+  - Implement interface KDevLanguageSupport
+  - \ref sectionClassWizard
+  - \ref sectionAttributeMethodWizard
+  - \ref sectionQtUiSubclassing - (if the language has Qt bindings)
+  - \ref sectionLanguageParser
+  - \ref sectionClassStore
+    - \ref sectionMemoryClassStore
+    - \ref sectionPersistantClassStore
+    .
+  - \ref sectionCodeCompletion
+  - \ref sectionProblemReporter - (parses source on the fly and reports syntax errors)
+  - \ref sectionTemplates
+    - \ref sectionApplicationTemplates
+    - \ref sectionApplicationImportTemplates
+    - \ref sectionSourceFileTemplates
+    - \ref sectionAbbreviationTemplates - (ife expands to an if else statement, etc)
+    .
+  - \ref sectionSourceCodeFormater (prettyprint functionality)
+  - \ref sectionDocumentationTopics
+  - \ref sectionDebugger
+    - (gdb/jdb/??? integration)
+  - \ref sectionCompilerPlugins
+  .
+
+List of optional things to support a given language in KDevelop:
+  - \ref sectionEditor - Syntax highlighter - (add to QEditor if not available elsewhere)
+  - \ref sectionBuildTool (make/ant/etc)
+  .
+
+Take a look at \ref LangSupportStatus (doc/api/LangSupportStatus.dox file) to see the current status/features of the programming languages currently supported by KDevelop.
+
+
+
+
+\section sectionLanguageSupport Language Support
+
+Any language support should be written as a kdevelop part and implement
+KDevLanguageSupport interface (<code>lib/interfaces/kdevlanguagesupport.h</code>).
+
+Implementing methods:
+ - <code>virtual Features features();</code>
+ - <code>virtual KMimeType::List mimeTypes();</code>
+ .
+
+Should be enough for a language support to start working.
+
+KDevelop ships with KDevLang project template. It is a simple language support prototype that can be used when developing language support plugins with KDevelop.
+To use it, start a New Project and select: <code>C++->KDevelop->KDevelop Language Support Plugin</code> in the application wizard.
+The template is located in <code>languages/cpp/app_templates/kdevlang</code>, you can change it there if you need.
+
+
+You should look at <code>languages/ruby</code> for a simple language support
+implementation. For a compilable language support, consult <code>languages/ada</code> or <code>languages/pascal</code> (they are not so complex as <code>languages/cpp</code>).
+
+Pascal would be a good starting place, as it is the smaller of the two by far.
+
+Language support can offer additional features:
+
+\subsection sectionClassWizard Class wizard
+  - new class wizard: (See <code>ada, php, cpp</code> or <code>java</code>)
+    - <code>virtual void addClass();</code>
+    .
+
+\subsection sectionAttributeMethodWizard Attribute/Method wizard
+  - add method dialog: (See <code>cpp</code> or <code>java</code>)
+    - <code>virtual void addMethod(const QString &className);</code>
+    .
+  - add attribute dialog: (See <code>cpp</code> or <code>java</code>)
+    - <code>virtual void addAttribute(const QString &className);</code>
+    .
+  .
+
+\subsection sectionQtUiSubclassing Qt UI subclassing
+
+If there is a Qt bindings for your language and there is a possibility
+to use QtDesigner ui files, you could implement ui subclassing feature:
+  - <code>virtual QStringList subclassWidget(const QString& formName);</code>
+  - <code>virtual QStringList updateWidget(const QString& formName, const QString&
+        fileName);</code>
+  .
+
+See <code>cpp</code> and <code>java</code> for examples.
+
+\subsection sectionLanguageParser Language parser
+
+In general, class stores can be filled with information without specialized
+and complex language parsers (take a look at <code>languages/python</code> that have a very simple python parser) but your language support will surely benefit
+from having such. There is a hand-written c/c++ parser (<code>lib/cppparser</code>) in KDevelop that might be used for ObjC or related C-based languages.
+
+Other (not so complex as c++) languages can be parsed by ANTLR based parsers (library is in lib/antlr).
+Consult www.antlr.org for a ANTLR documentation and look at <code>languages/java</code>, <code>languages/ada</code> and <code>languages/pascal</code> for an example of using such parsers.
+The latest version of ANTLR (2.7.2) has support for Java, C, Pascal, Ada, C++, CIM, HTML, IDL, Verilog, VRML, OCL, ASN.1, and SQL. You can write an ANTLR parser for your own language, of course.
+
+\subsection sectionClassStore Class store
+
+If you write (or have) a language parser, your language support can have
+"class store" (a database containing the information about scopes, classes
+and methods - their names, names of source files, location in source files,
+etc.). Class store libraries can be found at <code>lib/catalog</code> (Catalog) and <code>lib/interfaces</code> (CodeModel).
+
+KDevelop provides class browsers that extract information from a <b>class store</b> and display it in a tree view and toolbar selectors of scopes, classes and methods.
+
+\subsubsection sectionMemoryClassStore Memory class store
+CodeModel is the memory class store. It is very efficient and thus it is recommended for using as a project class store. CodeModel libraries are located in <code>lib/interfaces/codemodel.h</code>. The class browser for a CodeModel based stores is <code>parts/classview</code>.
+
+\subsubsection sectionPersistantClassStore Persistant class store
+Catalog is the persistant class store for KDevelop. Persistant class store can be used as an information storage for code completion but it also can be used as a class store for the project. Take a look at
+<code>languages/cpp</code> for an example of using catalog. Catalog is stored on disk in the database file (Berkeley db) If you use catalog with the project, your class browser will be <code>parts/classbrowser</code>.
+
+\subsection sectionCodeCompletion Code completion
+Class store enables you to write a code completion for the language. At the
+moment (2003-06-25), code completion is available only to cpp so take a
+look at it for an example.
+
+\subsection sectionProblemReporter Problem reporter
+
+If you have a language parser, you can implement <b>problem reporter</b>
+functionality for your language. The problem reporter catches errors
+reported by a parser and displays it in a problem reporter view.
+<code>languages/java</code>, <code>languages/ada</code>, <code>languages/pascal</code> and <code>languages/cpp</code> have problem reporters.
+
+\subsection sectionTemplates Templates
+
+\subsubsection sectionApplicationTemplates Application templates
+
+<b>Application wizard</b> templates should be also written. Appwizard templates are simple to create - consult \ref howToAddApplicationTemplates (HowToAddApplicationTemplates.dox file)
+and look at <code>languages/ruby/app_templates/rubyhello</code>, <code>languages/pascal/app_templates/pascalhello</code>, or <code>languages/ada/app_templates/adahello</code>.
+
+\subsubsection sectionApplicationImportTemplates Application import templates
+
+KDevelop has the ability to <b>create a new project from existing projects or source code</b>.
+It scans for project files ('*.kdevelop, *.kdevprj, *.studio, *.pro) and if
+  - it finds a project it extracts the necessary information
+  - it does not find project files it scans for source files (*.cpp, *.java, *.pl, *.py, ...)
+  .
+and creates a new KDevelop project in the direcotry the user has chosen.
+
+\subsubsection sectionSourceFileTemplates Source file templates
+
+Another thing to do is to create <b>file create templates</b>. They are prototypes for a source files of your language. These prototypes are placed in
+<code>parts/filecreate/file-templates</code> dir or <code>languages/YOURLANGUAGE/file_templates</code> and have names equal to the extensions of language source files.
+The description of the prototypes is placed in <code>parts/filecreate/template-info.xml</code>.
+
+Consult FileCreatePart (parts/filecreate/README.dox file) and \ref howToAddFileTemplates for further information.
+
+\subsubsection sectionAbbreviationTemplates Code abbreviation templates
+
+KDevelop has a support for <b>code abbreviations</b> so you can add some predefined abbreviations to your language support. Take <code>languages/cpp/cpptemplates</code> as an example.
+
+
+\subsection sectionSourceCodeFormater Source code formater
+
+Implement a KDevSourceFormater class interface.
+To obtain source formater functionality (that is already available to
+c-based languages) you can extend astyle library (<code>lib/astyle</code>) that is used by KDevelop to format sources.
+Take a look at AStylePart for an example how to do it.
+
+\subsection sectionDocumentationTopics Documentation topics
+
+Add them to <code>languages/YOURLANGUAGE/doc</code>. For an example see <code>languages/python/doc/python.toc</code> and <code>languages/python/doc/python.index</code>
+In the end you need to edit the <code>languages/YOURLANGUAGE/doc/Makefile.am</code> file to include the .toc and/or .index file.
+
+\subsection sectionDebugger Debugger
+
+The last thing to have a complete language support in KDevelop is to
+write a <b>Debugger </b>. KDevelop already provides GDB support
+(<code>languages/cpp/debugger</code>) and JDB (java debugger) support (<code>languages/java/debugger</code>). Take a look at them to get inspiration.
+
+\subsection sectionCompilerPlugins Compiler plugins
+
+There is an ability to create compiler plugin for KDevelop. Compiler plugin provides the compiler configuration dialog which implements command line compiler options.
+Compiler plugins must implement KDevCompilerOptions interface.
+
+
+\section MiscInf Other Info
+
+In the end you should add the language you implemented to the doc/api/LangSupportStatus.dox file and
+document your language support part in the way described at \ref howToDocument (doc/api/HowToDocument.dox file).
+See also \ref howToAddPlugins (doc/api/HowToAddPlugins.dox file) for an information on how to create a generic KDevelop plugin and how to manage project and global configuration information.
+
+
+
+
+
+\section sectionEditor Language Editor
+
+To edit source files KDevelop uses any editor that supports the KTextEditor
+interface. The current supported editors and their features are listed
+in the \ref EditorsSupportStatus (doc/api/EditorsSupportStatus.dox file) page.
+
+In case none of the editors does support advanced editing of sources
+written in your language (like code folding, syntax highlighting, line
+indentation) you can improve QEditor included in KDevelop (<code>editors/qeditor</code>).
+By creating QEditorIndenter and QSourceColorizer descendants you can provide the support for an automatic indentation and syntax highlighting that will be available for sure in KDevelop.
+
+
+
+
+
+
+\section sectionBuildTool Build Tool
+
+The language support is important, but it is unusable without a <b>build tool</b>
+that can manage projects written on this language. KDevelop
+currently provides several build tools. They are:
+
+  - ANT build tool
+    - see AntProjectPart at <code>buildtools/ant</code>
+    .
+  - Autotools build tool
+    - see AutoProjectPart at <code>buildtools/autotools</code>
+    .
+  - Custom build tool
+    - see CustomProjectPart at <code>buildtools/custommakefiles</code>
+    - (works with custom makefiles, also has ant support)
+    .
+  - Generic build tool
+    - see GenericProjectPart at <code>buildtools/generic</code>
+    - Offers build tool facilities using project files in xml format (dtd is located in <code>buildtools/generic/kdevxmlproject.dtd</code>).
+      Those xml files can be converted into makefiles, ant xml files or simply shell scripts using build system plugins.
+      Build system plugin is an object that implements KDevBuildSystem interface. Build system plugins are located in <code>buildtools/generic/buildsystem</code>.
+    .
+  - QMake build tool
+    - see TrollProjectPart at <code>buildtools/qmake</code>
+    .
+  .
+
+Also available:
+  - Script build tool
+    - <code>buildtools/script</code>
+    - (the generic build tool for all scripting languages).
+    .
+  - <code>buildtools/pascal</code> and
+  - <code>buildtools/ada</code>
+  - <code>buildtools/haskell</code>
+  .
+
+(They are deprecated build tools that will be replaced with the generic build tool).
+
+Choose your build tool and if the existing build tools doesn't fit
+in, extend generic build tool via build system plugin. \ref howToAddGenericBuildTools page (doc/api/HowToAddGenericBuildTools.dox file) helps you to do it.
+
+
+*/
diff --git a/doc/api/HowToDocument.dox b/doc/api/HowToDocument.dox
new file mode 100644
index 00000000..d606a8bf
--- /dev/null
+++ b/doc/api/HowToDocument.dox
@@ -0,0 +1,39 @@
+/** \file HowToDocument.dox
+  * \brief How to document KDevelop parts
+  */
+/** \page howToDocument How to document KDevelop parts
+
+You should add a README and a README.dox file to your part (KDevPlugin).
+
+On the README file put this text:
+\verbatim
+Please read the on-line, automaticaly updated KDevelop API documentation at:
+http://www.kdevelop.org
+or read the README.dox file.
+\endverbatim
+
+On the README.dox file put the mandatory information:
+\verbatim
+/** \class yourPartClassName
+Put a brief description here, the brief description ends at the first dot.
+Put a more detailed description of your part in these lines. It can span
+over several lines. You can even use some html commands in these lines like:
+<code>This is code</code>, html links <a href="http://somelocation">link text</a>,
+and images.
+
+...
+
+/*
+\endverbatim
+
+<b>IMPORTANT:</b> You should replace <code>yourPartClassName</code> with the name of the class that
+implements your part.
+
+On the area marked with <code>...</code> you can add optional informations. Here is an example of that:
+
+\verbinclude languages/cpp/app_templates/kdevpart/README.dox
+
+All these infos are optional and you should only add the link to the bugzilla database if YOUR_COMPONENT_NAME
+has been defined in that database.
+
+*/
diff --git a/doc/api/LangSupportStatus.dox b/doc/api/LangSupportStatus.dox
new file mode 100644
index 00000000..fa08cc67
--- /dev/null
+++ b/doc/api/LangSupportStatus.dox
@@ -0,0 +1,330 @@
+/** \file LangSupportStatus.dox
+  * \brief Programming Languages Support Status
+  */
+
+/** \page LangSupportStatus Programming Languages Support Status
+
+\ref howToAddProgrammingLanguages (doc/api/HowToAddProgrammingLanguages.dox file) for step by step info on how to implement these features.
+
+<table border="1">
+    <tr>
+      <th scope=col>Feature/Language</th>
+      <th scope=col><a href="classAdaSupportPart.html">Ada</a></th>
+      <th scope=col><a href="classBashSupportPart.html">Bash</a></th>
+      <th scope=col><a href="classCppSupportPart.html">C/C++</a></th>
+      <th scope=col><a href="classFortranSupportPart.html">Fortran</a></th>
+      <th scope=col><a href="classHaskellSupportPart.html">Haskell</a></th>
+      <th scope=col><a href="classJavaSupportPart.html">Java</a></th>
+      <th scope=col><a href="classPascalSupportPart.html">Pascal</a></th>
+      <th scope=col><a href="classPerlSupportPart.html">Perl</a></th>
+      <th scope=col><a href="classPHPSupportPart.html">PHP</a></th>
+      <th scope=col><a href="classPythonSupportPart.html">Python</a></th>
+      <th scope=col><a href="classRubySupportPart.html">Ruby</a></th>
+      <th scope=col><a href="classSQLSupportPart.html">SQL</a></th>
+    </tr>
+    <tr>
+      <td>\ref sectionClassWizard</td>
+      <td bgcolor="cyan">Y</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">N/A</td>
+    </tr>
+    <tr>
+      <td>\ref sectionAttributeMethodWizard</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">N/A</td>
+    </tr>
+    <tr>
+      <td>\ref sectionQtUiSubclassing</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="yellow">Y</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">N/A</td>
+    </tr>
+    <tr>
+      <td>  </td>
+    </tr>
+    <tr>
+      <td>\ref sectionLanguageParser</td>
+      <td bgcolor="green">ANTLR</td>
+      <td bgcolor="yellow">Internal</td>
+      <td bgcolor="green">cppparser</td>
+      <td bgcolor="yellow">Internal</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">ANTLR</td>
+      <td bgcolor="yellow">ANTLR</td>
+      <td bgcolor="yellow">Internal</td>
+      <td bgcolor="yellow">Internal</td>
+      <td bgcolor="yellow">Internal</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+    </tr>
+    <tr>
+      <td>\ref sectionMemoryClassStore</td>
+      <td bgcolor="cyan">CodeModel</td>
+      <td bgcolor="green">CodeModel</td>
+      <td bgcolor="green">CodeModel</td>
+      <td bgcolor="green">CodeModel</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="yellow">CodeModel</td>
+      <td bgcolor="cyan">CodeModel</td>
+      <td bgcolor="green">CodeModel</td>
+      <td bgcolor="green">CodeModel</td>
+      <td bgcolor="green">CodeModel</td>
+      <td bgcolor="green">N</td>
+      <td bgcolor="green">Y</td>
+    </tr>
+    <tr>
+      <td>\ref sectionPersistantClassStore</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Catalog</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">N/A</td>
+    </tr>
+    <tr>
+      <td>\ref sectionCodeCompletion</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="cyan">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+    </tr>
+    <tr>
+      <td>\ref sectionProblemReporter</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="yellow">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+    </tr>
+    <tr>
+      <td>  </td>
+    </tr>
+    <tr>
+      <td>\ref sectionApplicationTemplates</td>
+      <td bgcolor="yellow">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="yellow">Y</td>
+    </tr>
+    <tr>
+      <td>\ref sectionApplicationImportTemplates</td>
+      <td bgcolor="yellow">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+    </tr>
+    <tr>
+      <td>\ref sectionSourceFileTemplates</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="yellow">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+    </tr>
+    <tr>
+      <td>\ref sectionAbbreviationTemplates</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="yellow">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+    </tr>
+    <tr>
+      <td>\ref sectionSourceCodeFormater</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+    </tr>
+    <tr>
+      <td>  </td>
+    </tr>
+    <tr>
+      <td>\ref sectionDocumentationTopics</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="yellow">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="cyan">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+    </tr>
+    <tr>
+      <td>  </td>
+    </tr>
+    <tr>
+      <td>\ref sectionDebugger</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="yellow">Y</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">N</td>
+      <td bgcolor="red">N</td>
+    </tr>
+    <tr>
+      <td>\ref sectionCompilerPlugins</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">N/A</td>
+      <td bgcolor="green">gcc</td>
+      <td bgcolor="green">PGHPF, PGF77</td>
+      <td bgcolor="green">Glasgow</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="green">Delphi, Free Pascal</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+      <td bgcolor="red">N</td>
+    </tr>
+</table>
+<br>
+Legend:
+<br>
+<table>
+    <tr>
+      <td bgcolor="red"></td>
+      <td>Feature has not been implemented</td>
+    </tr>
+    <tr>
+      <td bgcolor="cyan"></td>
+      <td>Feature is in alpha state, the development has only been started or the feature is turned off at the moment</td>
+    </tr>
+    <tr>
+      <td bgcolor="yellow"></td>
+      <td>Feature is in beta state or it is unfinished</td>
+    </tr>
+    <tr>
+      <td bgcolor="green"></td>
+      <td>Feature is considered to be complete or complete enough for the release</td>
+    </tr>
+    <tr>
+      <td>N/A</td>
+      <td>Feature is not applicable for given language</td>
+    </tr>
+    <tr>
+      <td>Sourceinfo</td>
+      <td>Deprecated class store that should be replaced by a CodeModel
+      <br>Features implemented with Sourceinfo should not be marked as complete</td>
+    </tr>
+    <tr>
+      <td>CodeModel</td>
+      <td>New memory class store</td>
+    </tr>
+    <tr>
+      <td>Catalog</td>
+      <td>New persistant class store using Berkeley DB storage backend</td>
+    </tr>
+    <tr>
+      <td>ANTLR</td>
+      <td>Language parser is generated by ANTLR parser generator, http://www.antlr.org</td>
+    </tr>
+    <tr>
+      <td>cppparser</td>
+      <td>New c/c++ parser written by Roberto Raggi for KDevelop</td>
+    </tr>
+    <tr>
+      <td>Internal</td>
+      <td>Language parser is included in language support part</td>
+    </tr>
+</table>
+
+*/
+
diff --git a/doc/api/Mainpage.dox b/doc/api/Mainpage.dox
new file mode 100644
index 00000000..9d4b6d4c
--- /dev/null
+++ b/doc/api/Mainpage.dox
@@ -0,0 +1,91 @@
+/** \file Mainpage.dox
+    \brief The main page of the doxygen generated %API Documentation
+*/
+
+/**
+\mainpage The KDevelop %API %Documentation
+
+KDevelop is an easy to use IDE (Integrated Development Environment) for developing applications under X11.
+
+\section intro Introduction
+
+This document is targeted at all those that want to add or improve KDevelop's source code.
+If you are instead looking for a user manual, just go to the help menu of your KDevelop and select KDevelop handbook.
+This documentation contains the KDevelop online class reference for the current
+development version of KDevelop.  Additionally, you
+can subscribe or read the <a href="http://www.kdevelop.org/index.html?filename=mailinglist.html">mailing list</a> for any additions and/or
+modifications to the %API.
+
+An on-line, updated every 24H, html version of this documentation can be found at: http://www.kdevelop.org/HEAD/doc/api/html/index.html
+
+More information about the KDevelop architecture in form of tutorials, HOWTOs,
+and FAQs can be found at
+the <a href="http://www.kdevelop.org">KDevelop website</a>.
+
+
+\section status Current Status
+
+Here you can see the current \ref requirements and the \ref features.
+There is also a \ref LangSupportStatus (doc/api/LangSupportStatus.dox file) page and a \ref EditorsSupportStatus (doc/api/EditorsSupportStatus.dox file) page.
+
+
+\section expand How to expand KDevelop
+
+First of all read the \ref architecture (doc/api/Architecture.dox file) then you can find more information on how to expand KDevelop:
+  - \ref howToAddPlugins (doc/api/HowToAddPlugins.dox file)
+  - \ref howToAddProgrammingLanguages (doc/api/HowToAddProgrammingLanguages.dox file)
+  - \ref howToAddApplicationTemplates (doc/api/HowToAddApplicationTemplates.dox file)
+  - \ref howToAddFileTemplates (doc/api/HowToAddFileTemplates.dox file)
+  - \ref howToAddGenericBuildTools (doc/api/HowToAddGenericBuildTools.dox file)
+
+Additionally you may also want to find out \ref howToDocument (doc/api/HowToDocument.dox file).
+
+\section PlannedTasks Planned tasks
+
+Here is a priority ordered list:
+  -# \ref HighPriTasks (doc/api/HighPriTasks.dox file)
+  -# fix the dispersed \ref fixme
+  -# <a href="http://bugs.kde.org/buglist.cgi?product=kdevelop&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&order=bugs.bug_id">reported bugs in bugzilla database</a>
+  -# fix the bugs in the \ref bug
+  -# fix the dispersed \ref todo all over the code.
+  .
+There are some \ref unmaintained parts in KDevelop. You migth want to "adopt" one. :)\n
+There is also \ref FutureTasks (doc/api/FutureTasks.dox file). Put all ideas for the future KDevelop releases there. It is also a good place to comment on those ideas.
+
+\section misc Misc
+
+  - \ref authors
+  - \ref maintainers
+  - \ref FAQ
+  - \ref deprecated
+
+\section misc_libs Miscellaneous libraries included in KDevelop
+  - \ref PropEditor
+
+\section howTobuildAPIlocalcopy How to build a local copy of this documentation
+
+This documentation is very large and changes with every cvs commit, therefore is not available for download.
+To build your local copy of this documentation you have two choices, depending on your system configuration.
+  - If you have doxygen >= 1.3.4 , PHP >= 4.10 and a local running webserver then
+    - make apidox
+    - make install-apidox (as root)
+    .
+  - If you have an older system then
+    - setenv KDEDIR=/location_of_your_kde_instalation
+    - setenv QTDIR=/location_of_your_qt_instalation
+    - doxygen Doxyfile
+    - make install-apidox (as root)
+    .
+  .
+
+The advantage of the first method is that you'll get a search engine in your documentation if you read your
+documentation using your local webserver.
+
+\section License
+
+Permission is granted to copy, distribute and/or modify this document under
+the terms of the GNU Free %Documentation License, Version 1.2 or any later
+version published by the Free Software Foundation; For details see
+http://www.gnu.org/copyleft/fdl.html .
+
+*/
diff --git a/doc/api/PropEditor.dox b/doc/api/PropEditor.dox
new file mode 100644
index 00000000..b4f4eccc
--- /dev/null
+++ b/doc/api/PropEditor.dox
@@ -0,0 +1,108 @@
+/** \file PropEditor.dox
+    \brief The KDevelop Property Editor library description page
+*/
+
+/** \page PropEditor KDevelop Property Editor library description
+
+\section whatis What is Property Editor?
+
+%Property editor is a collection of facilities to store and edit the
+properties of an object. For example, look at %Qt Designer. Each widget
+has a list of properties that can be edited in a nice table form.
+Same ideology is used to edit properties in Kugar Report Designer
+(from KOffice distribution). In KDevelop project manager can also display
+the properties of currently selected build item in property editor.
+
+\section over Library Overview
+
+This PropertyEditor library is a redesign of Kugar property editing library 
+with the goal to be more generic and extensible.
+
+Library provides a @ref PropertyLib::Property class which stores property name, value and some
+more important information like description or the list of possible values.
+Using @ref PropertyLib::Property class adds more overhead over Q_PROPERTY but provides more
+flexibility. You can subclass @ref PropertyLib::Property and create your custom properties.
+Custom properties can have either predefined type (see @ref PropertyLib::PropertyType) or
+custom type. Custom type should be used if a custom property editor widget is
+necessary.
+
+Properties are organized into lists. @ref PropertyLib::PropertyList is designed
+to store such lists in most efficient manner. It also allows to group
+properties (for example think about "geometrical" properties like "x", "y", etc.).
+
+Property lists can be displayed in @ref PropertyLib::PropertyEditor widget which will
+display them in a table form. Note that @ref PropertyLib::PropertyEditor takes not
+a @ref PropertyLib::PropertyList object, but @ref PropertyLib::PropertyAccessor instead.
+
+@ref PropertyLib::PropertyAccessor is designed to provide a method to access an intersection
+of property lists. For example, let's consider object A with property list a_list
+abd object B with list b_list. Now let's imagine we want to display common properties
+from a_list and b_list in one @ref PropertyLib::PropertyEditor widget. Obviously, we need to
+"intersect" a_list with b_list and display the result of intersection.
+This is why @ref PropertyLib::PropertyAccessor is used for editing. If we change
+the value of a property in the editor, @ref PropertyLib::PropertyAccessor will update
+both properties from underlying a_list and b_list.
+
+@ref PropertyLib::PropertyEditor at the same time shows only one editor for selected
+property in the list. Each @ref PropertyLib::PropertyType has corresponding @ref PropertyLib::PropertyWidget
+which displays property editor or draws a property in the list if it is not edited.
+More exactly, if @ref PropertyLib::PropertyEditor needs to display editor widget, it displays
+@ref PropertyLib::PropertyWidget, else it calls @ref PropertyLib::PropertyWidget::drawViewer function.
+Custom property widgets should be subclasses of @ref PropertyLib::PropertyWidget.
+
+To create property widgets at runtime, a factory is used. Factory class is
+called @ref PropertyLib::PropertyMachineFactory. Static function @ref PropertyLib::PropertyMachineFactory::getInstance
+can be used to obtain the reference to the factory instance. Factory creates and returns
+so-called @ref Machine for each registered property type (either predefined or user defined).
+
+@ref Machine contains @ref PropertyLib::PropertyWidget and a list of "detailed" machines.
+Usually only property widget is necessary for a property but there are 
+complex properties like "Font" for example. We would like to see separate editors
+for font family, size, etc. and a button to choose all of these in the dialog.
+For that "Font" property, a PropertyWidget with a "choose font" button 
+and also number of detailed widgets like "font family" combo, etc. can be created.
+
+\section Examples
+A simple example on how to create a property editor and use it with one property list:
+\code
+    PropertyEditor *m_editor = new PropertyEditor(this);
+    
+    PropertyList *list = new PropertyList;
+    list->addProperty("My Group", new Property(Integer, "First Property",
+        "This is my first property", -5));
+    list->addProperty("My Group", new Property(String, "Second Property",
+        "This is my second property", "Hello"));
+    list->addProperty(new Property(Color, "Third Property",
+        "This is my third property", QColor("green")));
+        
+    m_editor->populateProperties(*list);
+\endcode
+
+More advanced example with property accessors and list intersection:
+\code
+    PropertyEditor *m_editor = new PropertyEditor(this);
+    
+    PropertyList *list = new PropertyList;
+    list->addProperty("My Group", new Property(Integer, "First Property",
+        "This is my first property", -5));
+    list->addProperty("My Group", new Property(String, "Second Property",
+        "This is my second property", "Hello"));
+    list->addProperty(new Property(Color, "Third Property",
+        "This is my third property", QColor("green")));
+
+    PropertyList *list2 = new PropertyList;
+    list2->addProperty("My Group", new Property(Integer, "First Property",
+        "This is my first property", -7));
+    list2->addProperty("My Group", new Property(String, "Second Property",
+        "This is my second property", "Hello"));
+    list2->addProperty(new Property(String, "Third Property",
+        "This is my third property", "green"));
+
+    PropertyAccessor *ac = list->intersect(*list2);
+    
+    m_editor->populateProperties(ac);
+\endcode
+In this example only properties named "First Property" and "Second Property" will be shown in editor.
+"Third Property" has different types in list and list2 and will not be included in intersection. 
+
+*/
diff --git a/doc/api/propeditor1.png b/doc/api/propeditor1.png
new file mode 100644
index 00000000..854b91f6
--- /dev/null
+++ b/doc/api/propeditor1.png
diff --git a/doc/api/propeditor2.png b/doc/api/propeditor2.png
new file mode 100644
index 00000000..66f8a75b
--- /dev/null
+++ b/doc/api/propeditor2.png
diff --git a/doc/extras/Makefile.am b/doc/extras/Makefile.am
new file mode 100644
index 00000000..0e7893c4
--- /dev/null
+++ b/doc/extras/Makefile.am
@@ -0,0 +1,8 @@
+SUBDIRS=w3c
+
+tocdir = ${kde_datadir}/kdevdocumentation/tocs
+toc_DATA = sdl.toc opengl.toc
+
+#indexdir = ${kde_datadir}/devdoctreeview/indices
+#index_DATA = 
+
diff --git a/doc/extras/opengl.toc b/doc/extras/opengl.toc
new file mode 100644
index 00000000..efe104ff
--- /dev/null
+++ b/doc/extras/opengl.toc
@@ -0,0 +1,267 @@
+<!DOCTYPE kdeveloptoc>
+<kdeveloptoc>
+<title>OpenGL</title>
+<tocsect1 name="GL Functions">
+	<tocsect2 name="glAccum" url="man:glAccum"/>
+	<tocsect2 name="glActiveTextureARB" url="man:glActiveTextureARB"/>
+	<tocsect2 name="glAlphaFunc" url="man:glAlphaFunc"/>
+	<tocsect2 name="glAreTexturesResident" url="man:glAreTexturesResident"/>
+	<tocsect2 name="glArrayElement" url="man:glArrayElement"/>
+	<tocsect2 name="glBegin" url="man:glBegin"/>
+	<tocsect2 name="glBindTexture" url="man:glBindTexture"/>
+	<tocsect2 name="glBitmap" url="man:glBitmap"/>
+	<tocsect2 name="glBlendColor" url="man:glBlendColor"/>
+	<tocsect2 name="glBlendEquation" url="man:glBlendEquation"/>
+	<tocsect2 name="glBlendFunc" url="man:glBlendFunc"/>
+	<tocsect2 name="glCallList" url="man:glCallList"/>
+	<tocsect2 name="glCallLists" url="man:glCallLists"/>
+	<tocsect2 name="glClear" url="man:glClear"/>
+	<tocsect2 name="glClearAccum" url="man:glClearAccum"/>
+	<tocsect2 name="glClearColor" url="man:glClearColor"/>
+	<tocsect2 name="glClearDepth" url="man:glClearDepth"/>
+	<tocsect2 name="glClearIndex" url="man:glClearIndex"/>
+	<tocsect2 name="glClearStencil" url="man:glClearStencil"/>
+	<tocsect2 name="glClientActiveTextureARB" url="man:glClientActiveTextureARB"/>
+	<tocsect2 name="glClipPlane" url="man:glClipPlane"/>
+	<tocsect2 name="glColor" url="man:glColor"/>
+	<tocsect2 name="glColorMask" url="man:glColorMask"/>
+	<tocsect2 name="glColorMaterial" url="man:glColorMaterial"/>
+	<tocsect2 name="glColorPointer" url="man:glColorPointer"/>
+	<tocsect2 name="glColorSubTable" url="man:glColorSubTable"/>
+	<tocsect2 name="glColorTable" url="man:glColorTable"/>
+	<tocsect2 name="glColorTableParameter" url="man:glColorTableParameter"/>
+	<tocsect2 name="glConvolutionFilter1D" url="man:glConvolutionFilter1D"/>
+	<tocsect2 name="glConvolutionFilter2D" url="man:glConvolutionFilter2D"/>
+	<tocsect2 name="glConvolutionParameter" url="man:glConvolutionParameter"/>
+	<tocsect2 name="glCopyColorSubTable" url="man:glCopyColorSubTable"/>
+	<tocsect2 name="glCopyColorTable" url="man:glCopyColorTable"/>
+	<tocsect2 name="glCopyConvolutionFilter1D" url="man:glCopyConvolutionFilter1D"/>
+	<tocsect2 name="glCopyConvolutionFilter2D" url="man:glCopyConvolutionFilter2D"/>
+	<tocsect2 name="glCopyPixels" url="man:glCopyPixels"/>
+	<tocsect2 name="glCopyTexImage1D" url="man:glCopyTexImage1D"/>
+	<tocsect2 name="glCopyTexImage2D" url="man:glCopyTexImage2D"/>
+	<tocsect2 name="glCopyTexSubImage1D" url="man:glCopyTexSubImage1D"/>
+	<tocsect2 name="glCopyTexSubImage2D" url="man:glCopyTexSubImage2D"/>
+	<tocsect2 name="glCopyTexSubImage3D" url="man:glCopyTexSubImage3D"/>
+	<tocsect2 name="glCullFace" url="man:glCullFace"/>
+	<tocsect2 name="glDeleteLists" url="man:glDeleteLists"/>
+	<tocsect2 name="glDeleteTextures" url="man:glDeleteTextures"/>
+	<tocsect2 name="glDepthFunc" url="man:glDepthFunc"/>
+	<tocsect2 name="glDepthMask" url="man:glDepthMask"/>
+	<tocsect2 name="glDepthRange" url="man:glDepthRange"/>
+	<tocsect2 name="glDisable" url="man:glDisable"/>
+	<tocsect2 name="glDisableClientState" url="man:glDisableClientState"/>
+	<tocsect2 name="glDrawArrays" url="man:glDrawArrays"/>
+	<tocsect2 name="glDrawBuffer" url="man:glDrawBuffer"/>
+	<tocsect2 name="glDrawElements" url="man:glDrawElements"/>
+	<tocsect2 name="glDrawPixels" url="man:glDrawPixels"/>
+	<tocsect2 name="glDrawRangeElements" url="man:glDrawRangeElements"/>
+	<tocsect2 name="glEdgeFlag" url="man:glEdgeFlag"/>
+	<tocsect2 name="glEdgeFlagPointer" url="man:glEdgeFlagPointer"/>
+	<tocsect2 name="glEnable" url="man:glEnable"/>
+	<tocsect2 name="glEnableClientState" url="man:glEnableClientState"/>
+	<tocsect2 name="glEnd" url="man:glEnd"/>
+	<tocsect2 name="glEndList" url="man:glEndList"/>
+	<tocsect2 name="glEvalCoord" url="man:glEvalCoord"/>
+	<tocsect2 name="glEvalMesh" url="man:glEvalMesh"/>
+	<tocsect2 name="glEvalPoint" url="man:glEvalPoint"/>
+	<tocsect2 name="glFeedbackBuffer" url="man:glFeedbackBuffer"/>
+	<tocsect2 name="glFinish" url="man:glFinish"/>
+	<tocsect2 name="glFlush" url="man:glFlush"/>
+	<tocsect2 name="glFog" url="man:glFog"/>
+	<tocsect2 name="glFrontFace" url="man:glFrontFace"/>
+	<tocsect2 name="glFrustum" url="man:glFrustum"/>
+	<tocsect2 name="glGenLists" url="man:glGenLists"/>
+	<tocsect2 name="glGenTextures" url="man:glGenTextures"/>
+	<tocsect2 name="glGet" url="man:glGet"/>
+	<tocsect2 name="glGetBooleanv" url="man:glGetBooleanv"/>
+	<tocsect2 name="glGetClipPlane" url="man:glGetClipPlane"/>
+	<tocsect2 name="glGetColorTable" url="man:glGetColorTable"/>
+	<tocsect2 name="glGetColorTableParameter" url="man:glGetColorTableParameter"/>
+	<tocsect2 name="glGetConvolutionFilter" url="man:glGetConvolutionFilter"/>
+	<tocsect2 name="glGetConvolutionParameter" url="man:glGetConvolutionParameter"/>
+	<tocsect2 name="glGetDoublev" url="man:glGetDoublev"/>
+	<tocsect2 name="glGetError" url="man:glGetError"/>
+	<tocsect2 name="glGetFloatv" url="man:glGetFloatv"/>
+	<tocsect2 name="glGetHistogram" url="man:glGetHistogram"/>
+	<tocsect2 name="glGetHistogramParameter" url="man:glGetHistogramParameter"/>
+	<tocsect2 name="glGetIntegerv" url="man:glGetIntegerv"/>
+	<tocsect2 name="glGetLight" url="man:glGetLight"/>
+	<tocsect2 name="glGetMap" url="man:glGetMap"/>
+	<tocsect2 name="glGetMaterial" url="man:glGetMaterial"/>
+	<tocsect2 name="glGetMinmax" url="man:glGetMinmax"/>
+	<tocsect2 name="glGetMinmaxParameter" url="man:glGetMinmaxParameter"/>
+	<tocsect2 name="glGetPixelMap" url="man:glGetPixelMap"/>
+	<tocsect2 name="glGetPointerv" url="man:glGetPointerv"/>
+	<tocsect2 name="glGetPolygonStipple" url="man:glGetPolygonStipple"/>
+	<tocsect2 name="glGetSeparableFilter" url="man:glGetSeparableFilter"/>
+	<tocsect2 name="glGetString" url="man:glGetString"/>
+	<tocsect2 name="glGetTexEnv" url="man:glGetTexEnv"/>
+	<tocsect2 name="glGetTexGen" url="man:glGetTexGen"/>
+	<tocsect2 name="glGetTexImage" url="man:glGetTexImage"/>
+	<tocsect2 name="glGetTexLevelParameter" url="man:glGetTexLevelParameter"/>
+	<tocsect2 name="glGetTexParameter" url="man:glGetTexParameter"/>
+	<tocsect2 name="glHint" url="man:glHint"/>
+	<tocsect2 name="glHistogram" url="man:glHistogram"/>
+	<tocsect2 name="glIndex" url="man:glIndex"/>
+	<tocsect2 name="glIndexMask" url="man:glIndexMask"/>
+	<tocsect2 name="glIndexPointer" url="man:glIndexPointer"/>
+	<tocsect2 name="glInitNames" url="man:glInitNames"/>
+	<tocsect2 name="glInterleavedArrays" url="man:glInterleavedArrays"/>
+	<tocsect2 name="glIsEnabled" url="man:glIsEnabled"/>
+	<tocsect2 name="glIsTexture" url="man:glIsTexture"/>
+	<tocsect2 name="glIslist" url="man:glIslist"/>
+	<tocsect2 name="glLight" url="man:glLight"/>
+	<tocsect2 name="glLightModel" url="man:glLightModel"/>
+	<tocsect2 name="glLineStipple" url="man:glLineStipple"/>
+	<tocsect2 name="glLineWidth" url="man:glLineWidth"/>
+	<tocsect2 name="glListBase" url="man:glListBase"/>
+	<tocsect2 name="glLoadIdentity" url="man:glLoadIdentity"/>
+	<tocsect2 name="glLoadMatrix" url="man:glLoadMatrix"/>
+	<tocsect2 name="glLoadName" url="man:glLoadName"/>
+	<tocsect2 name="glLogicOp" url="man:glLogicOp"/>
+	<tocsect2 name="glMap1" url="man:glMap1"/>
+	<tocsect2 name="glMap2" url="man:glMap2"/>
+	<tocsect2 name="glMapGrid" url="man:glMapGrid"/>
+	<tocsect2 name="glMaterial" url="man:glMaterial"/>
+	<tocsect2 name="glMatrixMode" url="man:glMatrixMode"/>
+	<tocsect2 name="glMinmax" url="man:glMinmax"/>
+	<tocsect2 name="glMultMatrix" url="man:glMultMatrix"/>
+	<tocsect2 name="glMultiTexCoordARB" url="man:glMultiTexCoordARB"/>
+	<tocsect2 name="glNewList" url="man:glNewList"/>
+	<tocsect2 name="glNormal" url="man:glNormal"/>
+	<tocsect2 name="glNormalPointer" url="man:glNormalPointer"/>
+	<tocsect2 name="glOrtho" url="man:glOrtho"/>
+	<tocsect2 name="glPassThrough" url="man:glPassThrough"/>
+	<tocsect2 name="glPixelMap" url="man:glPixelMap"/>
+	<tocsect2 name="glPixelStore" url="man:glPixelStore"/>
+	<tocsect2 name="glPixelTransfer" url="man:glPixelTransfer"/>
+	<tocsect2 name="glPixelZoom" url="man:glPixelZoom"/>
+	<tocsect2 name="glPointSize" url="man:glPointSize"/>
+	<tocsect2 name="glPolygonMode" url="man:glPolygonMode"/>
+	<tocsect2 name="glPolygonOffset" url="man:glPolygonOffset"/>
+	<tocsect2 name="glPolygonStipple" url="man:glPolygonStipple"/>
+	<tocsect2 name="glPopAttrib" url="man:glPopAttrib"/>
+	<tocsect2 name="glPopClientAttrib" url="man:glPopClientAttrib"/>
+	<tocsect2 name="glPopMatrix" url="man:glPopMatrix"/>
+	<tocsect2 name="glPopName" url="man:glPopName"/>
+	<tocsect2 name="glPrioritizeTextures" url="man:glPrioritizeTextures"/>
+	<tocsect2 name="glPushAttrib" url="man:glPushAttrib"/>
+	<tocsect2 name="glPushClientAttrib" url="man:glPushClientAttrib"/>
+	<tocsect2 name="glPushMatrix" url="man:glPushMatrix"/>
+	<tocsect2 name="glPushName" url="man:glPushName"/>
+	<tocsect2 name="glRasterPos" url="man:glRasterPos"/>
+	<tocsect2 name="glReadBuffer" url="man:glReadBuffer"/>
+	<tocsect2 name="glReadPixels" url="man:glReadPixels"/>
+	<tocsect2 name="glRect" url="man:glRect"/>
+	<tocsect2 name="glRenderMode" url="man:glRenderMode"/>
+	<tocsect2 name="glResetHistogram" url="man:glResetHistogram"/>
+	<tocsect2 name="glResetMinmax" url="man:glResetMinmax"/>
+	<tocsect2 name="glRotate" url="man:glRotate"/>
+	<tocsect2 name="glScale" url="man:glScale"/>
+	<tocsect2 name="glScissor" url="man:glScissor"/>
+	<tocsect2 name="glSelectBuffer" url="man:glSelectBuffer"/>
+	<tocsect2 name="glSeparableFilter2D" url="man:glSeparableFilter2D"/>
+	<tocsect2 name="glShadeModel" url="man:glShadeModel"/>
+	<tocsect2 name="glStencilFunc" url="man:glStencilFunc"/>
+	<tocsect2 name="glStencilMask" url="man:glStencilMask"/>
+	<tocsect2 name="glStencilOp" url="man:glStencilOp"/>
+	<tocsect2 name="glTexCoord" url="man:glTexCoord"/>
+	<tocsect2 name="glTexCoordPointer" url="man:glTexCoordPointer"/>
+	<tocsect2 name="glTexEnv" url="man:glTexEnv"/>
+	<tocsect2 name="glTexGen" url="man:glTexGen"/>
+	<tocsect2 name="glTexImage1D" url="man:glTexImage1D"/>
+	<tocsect2 name="glTexImage2D" url="man:glTexImage2D"/>
+	<tocsect2 name="glTexImage3D" url="man:glTexImage3D"/>
+	<tocsect2 name="glTexParameter" url="man:glTexParameter"/>
+	<tocsect2 name="glTexSubImage1D" url="man:glTexSubImage1D"/>
+	<tocsect2 name="glTexSubImage2D" url="man:glTexSubImage2D"/>
+	<tocsect2 name="glTexSubImage3D" url="man:glTexSubImage3D"/>
+	<tocsect2 name="glTranslate" url="man:glTranslate"/>
+	<tocsect2 name="glVertex" url="man:glVertex"/>
+	<tocsect2 name="glVertexPointer" url="man:glVertexPointer"/>
+	<tocsect2 name="glViewport" url="man:glViewport"/>
+</tocsect1>
+<tocsect1 name="GLU Functions">
+	<tocsect2 name="gluBeginCurve" url="man:gluBeginCurve"/>
+	<tocsect2 name="gluBeginPolygon" url="man:gluBeginPolygon"/>
+	<tocsect2 name="gluBeginSurface" url="man:gluBeginSurface"/>
+	<tocsect2 name="gluBeginTrim" url="man:gluBeginTrim"/>
+	<tocsect2 name="gluBuild1DMipmaps" url="man:gluBuild1DMipmaps"/>
+	<tocsect2 name="gluBuild2DMipmaps" url="man:gluBuild2DMipmaps"/>
+	<tocsect2 name="gluCylinder" url="man:gluCylinder"/>
+	<tocsect2 name="gluDeleteNurbsRenderer" url="man:gluDeleteNurbsRenderer"/>
+	<tocsect2 name="gluDeleteQuadric" url="man:gluDeleteQuadric"/>
+	<tocsect2 name="gluDeleteTess" url="man:gluDeleteTess"/>
+	<tocsect2 name="gluDisk" url="man:gluDisk"/>
+	<tocsect2 name="gluEndCurve" url="man:gluEndCurve"/>
+	<tocsect2 name="gluEndPolygon" url="man:gluEndPolygon"/>
+	<tocsect2 name="gluEndSurface" url="man:gluEndSurface"/>
+	<tocsect2 name="gluEndTrim" url="man:gluEndTrim"/>
+	<tocsect2 name="gluErrorString" url="man:gluErrorString"/>
+	<tocsect2 name="gluGetNurbsProperty" url="man:gluGetNurbsProperty"/>
+	<tocsect2 name="gluGetString" url="man:gluGetString"/>
+	<tocsect2 name="gluGetTessProperty" url="man:gluGetTessProperty"/>
+	<tocsect2 name="gluLoadSamplingMatrices" url="man:gluLoadSamplingMatrices"/>
+	<tocsect2 name="gluLookAt" url="man:gluLookAt"/>
+	<tocsect2 name="gluNewNurbsRenderer" url="man:gluNewNurbsRenderer"/>
+	<tocsect2 name="gluNewQuadric" url="man:gluNewQuadric"/>
+	<tocsect2 name="gluNewTess" url="man:gluNewTess"/>
+	<tocsect2 name="gluNextContour" url="man:gluNextContour"/>
+	<tocsect2 name="gluNurbsCallback" url="man:gluNurbsCallback"/>
+	<tocsect2 name="gluNurbsCallbackDataEXT" url="man:gluNurbsCallbackDataEXT"/>
+	<tocsect2 name="gluNurbsCurve" url="man:gluNurbsCurve"/>
+	<tocsect2 name="gluNurbsProperty" url="man:gluNurbsProperty"/>
+	<tocsect2 name="gluNurbsSurface" url="man:gluNurbsSurface"/>
+	<tocsect2 name="gluOrtho2D" url="man:gluOrtho2D"/>
+	<tocsect2 name="gluPartialDisk" url="man:gluPartialDisk"/>
+	<tocsect2 name="gluPerspective" url="man:gluPerspective"/>
+	<tocsect2 name="gluPickMatrix" url="man:gluPickMatrix"/>
+	<tocsect2 name="gluProject" url="man:gluProject"/>
+	<tocsect2 name="gluPwlCurve" url="man:gluPwlCurve"/>
+	<tocsect2 name="gluQuadricCallback" url="man:gluQuadricCallback"/>
+	<tocsect2 name="gluQuadricDrawStyle" url="man:gluQuadricDrawStyle"/>
+	<tocsect2 name="gluQuadricNormals" url="man:gluQuadricNormals"/>
+	<tocsect2 name="gluQuadricOrientation" url="man:gluQuadricOrientation"/>
+	<tocsect2 name="gluQuadricTexture" url="man:gluQuadricTexture"/>
+	<tocsect2 name="gluScaleImage" url="man:gluScaleImage"/>
+	<tocsect2 name="gluSphere" url="man:gluSphere"/>
+	<tocsect2 name="gluTessBeginContour" url="man:gluTessBeginContour"/>
+	<tocsect2 name="gluTessBeginPolygon" url="man:gluTessBeginPolygon"/>
+	<tocsect2 name="gluTessCallback" url="man:gluTessCallback"/>
+	<tocsect2 name="gluTessEndContour" url="man:gluTessEndContour"/>
+	<tocsect2 name="gluTessEndPolygon" url="man:gluTessEndPolygon"/>
+	<tocsect2 name="gluTessNormal" url="man:gluTessNormal"/>
+	<tocsect2 name="gluTessProperty" url="man:gluTessProperty"/>
+	<tocsect2 name="gluTessVertex" url="man:gluTessVertex"/>
+	<tocsect2 name="gluUnProject" url="man:gluUnProject"/>
+</tocsect1>
+<tocsect1 name="GLX Functions">
+	<tocsect2 name="glXChooseVisual" url="man:glXChooseVisual"/>
+	<tocsect2 name="glXCopyContext" url="man:glXCopyContext"/>
+	<tocsect2 name="glXCreateContext" url="man:glXCreateContext"/>
+	<tocsect2 name="glXCreateGLXPixmap" url="man:glXCreateGLXPixmap"/>
+	<tocsect2 name="glXDestroyContext" url="man:glXDestroyContext"/>
+	<tocsect2 name="glXDestroyGLXPixmap" url="man:glXDestroyGLXPixmap"/>
+	<tocsect2 name="glXFreeContextEXT" url="man:glXFreeContextEXT"/>
+	<tocsect2 name="glXGetClientString" url="man:glXGetClientString"/>
+	<tocsect2 name="glXGetConfig" url="man:glXGetConfig"/>
+	<tocsect2 name="glXGetContextIDEXT" url="man:glXGetContextIDEXT"/>
+	<tocsect2 name="glXGetCurrentContext" url="man:glXGetCurrentContext"/>
+	<tocsect2 name="glXGetCurrentDisplay" url="man:glXGetCurrentDisplay"/>
+	<tocsect2 name="glXGetCurrentDrawable" url="man:glXGetCurrentDrawable"/>
+	<tocsect2 name="glXImportContextEXT" url="man:glXImportContextEXT"/>
+	<tocsect2 name="glXIntro" url="man:glXIntro"/>
+	<tocsect2 name="glXIsDirect" url="man:glXIsDirect"/>
+	<tocsect2 name="glXMakeCurrent" url="man:glXMakeCurrent"/>
+	<tocsect2 name="glXQueryContextInfoEXT" url="man:glXQueryContextInfoEXT"/>
+	<tocsect2 name="glXQueryExtension" url="man:glXQueryExtension"/>
+	<tocsect2 name="glXQueryExtensionsString" url="man:glXQueryExtensionsString"/>
+	<tocsect2 name="glXQueryServerString" url="man:glXQueryServerString"/>
+	<tocsect2 name="glXQueryVersion" url="man:glXQueryVersion"/>
+	<tocsect2 name="glXSwapBuffers" url="man:glXSwapBuffers"/>
+	<tocsect2 name="glXUseXFont" url="man:glXUseXFont"/>
+	<tocsect2 name="glXWaitGL" url="man:glXWaitGL"/>
+	<tocsect2 name="glXWaitX" url="man:glXWaitX"/>
+</tocsect1>
+</kdeveloptoc>
diff --git a/doc/extras/sdl.toc b/doc/extras/sdl.toc
new file mode 100644
index 00000000..947dd09a
--- /dev/null
+++ b/doc/extras/sdl.toc
@@ -0,0 +1,219 @@
+<!DOCTYPE kdeveloptoc>
+<kdeveloptoc>
+<title>SDL</title>
+<base href="http://sdldoc.csn.ul.ie"/>
+<tocsect1 name="I. SDL Guide" url="guide.php">
+	<tocsect2 name="Preface" url="guidepreface.php">
+		<tocsect3 name="About SDL" url="guidepreface.php#GUIDEABOUTSDL" />
+		<tocsect3 name="About SDLdoc" url="guideaboutsdldoc.php" />
+		<tocsect3 name="Credits" url="guidecredits.php" />
+	</tocsect2>
+	<tocsect2 name="1. The Basics" url="guidethebasics.php">
+		<tocsect3 name="Introduction" url="guidethebasics.php#GUIDEINTRODUCTION" />
+		<tocsect3 name="Initializing SDL" url="guidebasicsinit.php" />
+	</tocsect2>
+	<tocsect2 name="2. Graphics and Video" url="guidevideo.php">
+		<tocsect3 name="Introduction to SDL Video" url="guidevideo.php#GUIDEVIDEOINTRO" />
+		<tocsect3 name="Using OpenGL With SDL" url="guidevideoopengl.php" />
+	</tocsect2>
+	<tocsect2 name="3. Input handling" url="guideinput.php">
+		<tocsect3 name="Handling Joysticks" url="guideinput.php#GUIDEINPUTJOYSTICK" />
+		<tocsect3 name="Handling the Keyboard" url="guideinputkeyboard.php" />
+	</tocsect2>
+	<tocsect2 name="4. Examples" url="guideexamples.php">
+		<tocsect3 name="Introduction" url="guideexamples.php#AEN369" />
+		<tocsect3 name="Event Examples" url="guideeventexamples.php" />
+		<tocsect3 name="Audio Examples" url="guideaudioexamples.php" />
+		<tocsect3 name="CDROM Examples" url="guidecdromexamples.php" />
+		<tocsect3 name="Time Examples" url="guidetimeexamples.php" />
+	</tocsect2>
+</tocsect1>
+<tocsect1 name="II. SDL Reference" url="reference.php">
+	<tocsect2 name="5. General" url="general.php">
+		<tocsect3 name="SDL_Init" url="sdlinit.php" />
+		<tocsect3 name="SDL_InitSubSystem" url="sdlinitsubsystem.php" />
+		<tocsect3 name="SDL_QuitSubSystem" url="sdlquitsubsystem.php" />
+		<tocsect3 name="SDL_Quit" url="sdlquit.php" />
+		<tocsect3 name="SDL_WasInit" url="sdlwasinit.php" />
+		<tocsect3 name="SDL_GetError" url="sdlgeterror.php" />
+	</tocsect2>
+	<tocsect2 name="6. Video" url="video.php">
+		<tocsect3 name="SDL_GetVideoSurface" url="sdlgetvideosurface.php" />
+		<tocsect3 name="SDL_GetVideoInfo" url="sdlgetvideoinfo.php" />
+		<tocsect3 name="SDL_VideoDriverName" url="sdlvideodrivername.php" />
+		<tocsect3 name="SDL_ListModes" url="sdllistmodes.php" />
+		<tocsect3 name="SDL_VideoModeOK" url="sdlvideomodeok.php" />
+		<tocsect3 name="SDL_SetVideoMode" url="sdlsetvideomode.php" />
+		<tocsect3 name="SDL_UpdateRect" url="sdlupdaterect.php" />
+		<tocsect3 name="SDL_UpdateRects" url="sdlupdaterects.php" />
+		<tocsect3 name="SDL_Flip" url="sdlflip.php" />
+		<tocsect3 name="SDL_SetColors" url="sdlsetcolors.php" />
+		<tocsect3 name="SDL_SetPalette" url="sdlsetpalette.php" />
+		<tocsect3 name="SDL_SetGamma" url="sdlsetgamma.php" />
+		<tocsect3 name="SDL_GetGammaRamp" url="sdlgetgammaramp.php" />
+		<tocsect3 name="SDL_SetGammaRamp" url="sdlsetgammaramp.php" />
+		<tocsect3 name="SDL_MapRGB" url="sdlmaprgb.php" />
+		<tocsect3 name="SDL_MapRGBA" url="sdlmaprgba.php" />
+		<tocsect3 name="SDL_GetRGB" url="sdlgetrgb.php" />
+		<tocsect3 name="SDL_GetRGBA" url="sdlgetrgba.php" />
+		<tocsect3 name="SDL_CreateRGBSurface" url="sdlcreatergbsurface.php" />
+		<tocsect3 name="SDL_CreateRGBSurfaceFrom" url="sdlcreatergbsurfacefrom.php" />
+		<tocsect3 name="SDL_FreeSurface" url="sdlfreesurface.php" />
+		<tocsect3 name="SDL_LockSurface" url="sdllocksurface.php" />
+		<tocsect3 name="SDL_UnlockSurface" url="sdlunlocksurface.php" />
+		<tocsect3 name="SDL_LoadBMP" url="sdlloadbmp.php" />
+		<tocsect3 name="SDL_SaveBMP" url="sdlsavebmp.php" />
+		<tocsect3 name="SDL_SetColorKey" url="sdlsetcolorkey.php" />
+		<tocsect3 name="SDL_SetAlpha" url="sdlsetalpha.php" />
+		<tocsect3 name="SDL_SetClipRect" url="sdlsetcliprect.php" />
+		<tocsect3 name="SDL_GetClipRect" url="sdlgetcliprect.php" />
+		<tocsect3 name="SDL_ConvertSurface" url="sdlconvertsurface.php" />
+		<tocsect3 name="SDL_BlitSurface" url="sdlblitsurface.php" />
+		<tocsect3 name="SDL_FillRect" url="sdlfillrect.php" />
+		<tocsect3 name="SDL_DisplayFormat" url="sdldisplayformat.php" />
+		<tocsect3 name="SDL_DisplayFormatAlpha" url="sdldisplayformatalpha.php" />
+		<tocsect3 name="SDL_WarpMouse" url="sdlwarpmouse.php" />
+		<tocsect3 name="SDL_CreateCursor" url="sdlcreatecursor.php" />
+		<tocsect3 name="SDL_FreeCursor" url="sdlfreecursor.php" />
+		<tocsect3 name="SDL_SetCursor" url="sdlsetcursor.php" />
+		<tocsect3 name="SDL_GetCursor" url="sdlgetcursor.php" />
+		<tocsect3 name="SDL_ShowCursor" url="sdlshowcursor.php" />
+		<tocsect3 name="SDL_GL_LoadLibrary" url="sdlglloadlibrary.php" />
+		<tocsect3 name="SDL_GL_GetProcAddress" url="sdlglgetprocaddress.php" />
+		<tocsect3 name="SDL_GL_GetAttribute" url="sdlglgetattribute.php" />
+		<tocsect3 name="SDL_GL_SetAttribute" url="sdlglsetattribute.php" />
+		<tocsect3 name="SDL_GL_SwapBuffers" url="sdlglswapbuffers.php" />
+		<tocsect3 name="SDL_CreateYUVOverlay" url="sdlcreateyuvoverlay.php" />
+		<tocsect3 name="SDL_LockYUVOverlay" url="sdllockyuvoverlay.php" />
+		<tocsect3 name="SDL_UnlockYUVOverlay" url="sdlunlockyuvoverlay.php" />
+		<tocsect3 name="SDL_DisplayYUVOverlay" url="sdldisplayyuvoverlay.php" />
+		<tocsect3 name="SDL_FreeYUVOverlay" url="sdlfreeyuvoverlay.php" />
+		<tocsect3 name="SDL_GLattr" url="sdlglattr.php" />
+		<tocsect3 name="SDL_Rect" url="sdlrect.php" />
+		<tocsect3 name="SDL_Color" url="sdlcolor.php" />
+		<tocsect3 name="SDL_Palette" url="sdlpalette.php" />
+		<tocsect3 name="SDL_PixelFormat" url="sdlpixelformat.php" />
+		<tocsect3 name="SDL_Surface" url="sdlsurface.php" />
+		<tocsect3 name="SDL_VideoInfo" url="sdlvideoinfo.php" />
+		<tocsect3 name="SDL_Overlay" url="sdloverlay.php" />
+	</tocsect2>
+	<tocsect2 name="7. Window Management" url="wm.php">
+		<tocsect3 name="SDL_WM_SetCaption" url="sdlwmsetcaption.php" />
+		<tocsect3 name="SDL_WM_GetCaption" url="sdlwmgetcaption.php" />
+		<tocsect3 name="SDL_WM_SetIcon" url="sdlwmseticon.php" />
+		<tocsect3 name="SDL_WM_IconifyWindow" url="sdlwmiconifywindow.php" />
+		<tocsect3 name="SDL_WM_ToggleFullScreen" url="sdlwmtogglefullscreen.php" />
+		<tocsect3 name="SDL_WM_GrabInput" url="sdlwmgrabinput.php" />
+	</tocsect2>
+	<tocsect2 name="8. Events" url="event.php">
+		<tocsect3 name="Introduction" url="event.php#AEN3307" />
+		<tocsect3 name="SDL Event Structures." url="eventstructures.php" />
+		<tocsect3 name="Event Functions." url="eventfunctions.php" />
+	</tocsect2>
+	<tocsect2 name="9. Joystick" url="joystick.php">
+		<tocsect3 name="SDL_NumJoysticks" url="sdlnumjoysticks.php" />
+		<tocsect3 name="SDL_JoystickName" url="sdljoystickname.php" />
+		<tocsect3 name="SDL_JoystickOpen" url="sdljoystickopen.php" />
+		<tocsect3 name="SDL_JoystickOpened" url="sdljoystickopened.php" />
+		<tocsect3 name="SDL_JoystickIndex" url="sdljoystickindex.php" />
+		<tocsect3 name="SDL_JoystickNumAxes" url="sdljoysticknumaxes.php" />
+		<tocsect3 name="SDL_JoystickNumBalls" url="sdljoysticknumballs.php" />
+		<tocsect3 name="SDL_JoystickNumHats" url="sdljoysticknumhats.php" />
+		<tocsect3 name="SDL_JoystickNumButtons" url="sdljoysticknumbuttons.php" />
+		<tocsect3 name="SDL_JoystickUpdate" url="sdljoystickupdate.php" />
+		<tocsect3 name="SDL_JoystickGetAxis" url="sdljoystickgetaxis.php" />
+		<tocsect3 name="SDL_JoystickGetHat" url="sdljoystickgethat.php" />
+		<tocsect3 name="SDL_JoystickGetButton" url="sdljoystickgetbutton.php" />
+		<tocsect3 name="SDL_JoystickGetBall" url="sdljoystickgetball.php" />
+		<tocsect3 name="SDL_JoystickClose" url="sdljoystickclose.php" />
+	</tocsect2>
+	<tocsect2 name="10. Audio" url="audio.php">
+		<tocsect3 name="SDL_AudioSpec" url="sdlaudiospec.php" />
+		<tocsect3 name="SDL_OpenAudio" url="sdlopenaudio.php" />
+		<tocsect3 name="SDL_PauseAudio" url="sdlpauseaudio.php" />
+		<tocsect3 name="SDL_GetAudioStatus" url="sdlgetaudiostatus.php" />
+		<tocsect3 name="SDL_LoadWAV" url="sdlloadwav.php" />
+		<tocsect3 name="SDL_FreeWAV" url="sdlfreewav.php" />
+		<tocsect3 name="SDL_AudioCVT" url="sdlaudiocvt.php" />
+		<tocsect3 name="SDL_BuildAudioCVT" url="sdlbuildaudiocvt.php" />
+		<tocsect3 name="SDL_ConvertAudio" url="sdlconvertaudio.php" />
+		<tocsect3 name="SDL_MixAudio" url="sdlmixaudio.php" />
+		<tocsect3 name="SDL_LockAudio" url="sdllockaudio.php" />
+		<tocsect3 name="SDL_UnlockAudio" url="sdlunlockaudio.php" />
+		<tocsect3 name="SDL_CloseAudio" url="sdlcloseaudio.php" />
+	</tocsect2>
+	<tocsect2 name="11. CD-ROM" url="cdrom.php">
+		<tocsect3 name="SDL_CDNumDrives" url="sdlcdnumdrives.php" />
+		<tocsect3 name="SDL_CDName" url="sdlcdname.php" />
+		<tocsect3 name="SDL_CDOpen" url="sdlcdopen.php" />
+		<tocsect3 name="SDL_CDStatus" url="sdlcdstatus.php" />
+		<tocsect3 name="SDL_CDPlay" url="sdlcdplay.php" />
+		<tocsect3 name="SDL_CDPlayTracks" url="sdlcdplaytracks.php" />
+		<tocsect3 name="SDL_CDPause" url="sdlcdpause.php" />
+		<tocsect3 name="SDL_CDResume" url="sdlcdresume.php" />
+		<tocsect3 name="SDL_CDStop" url="sdlcdstop.php" />
+		<tocsect3 name="SDL_CDEject" url="sdlcdeject.php" />
+		<tocsect3 name="SDL_CDClose" url="sdlcdclose.php" />
+		<tocsect3 name="SDL_CD" url="sdlcd.php" />
+		<tocsect3 name="SDL_CDtrack" url="sdlcdtrack.php" />
+	</tocsect2>
+	<tocsect2 name="12. Multi-threaded Programming" url="thread.php">
+		<tocsect3 name="SDL_CreateThread" url="sdlcreatethread.php" />
+		<tocsect3 name="SDL_ThreadID" url="sdlthreadid.php" />
+		<tocsect3 name="SDL_GetThreadID" url="sdlgetthreadid.php" />
+		<tocsect3 name="SDL_WaitThread" url="sdlwaitthread.php" />
+		<tocsect3 name="SDL_KillThread" url="sdlkillthread.php" />
+		<tocsect3 name="SDL_CreateMutex" url="sdlcreatemutex.php" />
+		<tocsect3 name="SDL_DestroyMutex" url="sdldestroymutex.php" />
+		<tocsect3 name="SDL_mutexP" url="sdlmutexp.php" />
+		<tocsect3 name="SDL_mutexV" url="sdlmutexv.php" />
+		<tocsect3 name="SDL_CreateSemaphore" url="sdlcreatesemaphore.php" />
+		<tocsect3 name="SDL_DestroySemaphore" url="sdldestroysemaphore.php" />
+		<tocsect3 name="SDL_SemWait" url="sdlsemwait.php" />
+		<tocsect3 name="SDL_SemTryWait" url="sdlsemtrywait.php" />
+		<tocsect3 name="SDL_SemWaitTimeout" url="sdlsemwaittimeout.php" />
+		<tocsect3 name="SDL_SemPost" url="sdlsempost.php" />
+		<tocsect3 name="SDL_SemValue" url="sdlsemvalue.php" />
+		<tocsect3 name="SDL_CreateCond" url="sdlcreatecond.php" />
+		<tocsect3 name="SDL_DestroyCond" url="sdldestroycond.php" />
+		<tocsect3 name="SDL_CondSignal" url="sdlcondsignal.php" />
+		<tocsect3 name="SDL_CondBroadcast" url="sdlcondbroadcast.php" />
+		<tocsect3 name="SDL_CondWait" url="sdlcondwait.php" />
+		<tocsect3 name="SDL_CondWaitTimeout" url="sdlcondwaittimeout.php" />
+	</tocsect2>
+	<tocsect2 name="13. Time" url="time.php">
+		<tocsect3 name="SDL_GetTicks" url="sdlgetticks.php" />
+		<tocsect3 name="SDL_Delay" url="sdldelay.php" />
+		<tocsect3 name="SDL_AddTimer" url="sdladdtimer.php" />
+		<tocsect3 name="SDL_RemoveTimer" url="sdlremovetimer.php" />
+		<tocsect3 name="SDL_SetTimer" url="sdlsettimer.php" />
+	</tocsect2>
+</tocsect1>
+<tocsect1 name="List of Tables">
+	<tocsect2 name="8-1. SDL Keysym definitions" url="sdlkey.php#AEN4336" />
+	<tocsect2 name="8-2. SDL modifier definitions" url="sdlkey.php#SDLMOD" />
+</tocsect1>
+	<tocsect1 name="List of Examples">
+	<tocsect2 name="1-1. Initializing SDL" url="guidebasicsinit.php#AEN60" />
+	<tocsect2 name="2-1. Initializing the Video Display" url="guidevideo.php#AEN71" />
+	<tocsect2 name="2-2. Initializing the Best Video Mode" url="guidevideo.php#AEN77" />
+	<tocsect2 name="2-3. Loading and Displaying a BMP File" url="guidevideo.php#AEN83" />
+	<tocsect2 name="2-4. getpixel()" url="guidevideo.php#AEN90" />
+	<tocsect2 name="2-5. putpixel()" url="guidevideo.php#AEN93" />
+	<tocsect2 name="2-6. Using putpixel()" url="guidevideo.php#AEN97" />
+	<tocsect2 name="2-7. Initializing SDL with OpenGL" url="guidevideoopengl.php#AEN114" />
+	<tocsect2 name="2-8. SDL and OpenGL" url="guidevideoopengl.php#AEN128" />
+	<tocsect2 name="3-1. Initializing SDL with Joystick Support" url="guideinput.php#AEN141" />
+	<tocsect2 name="3-2. Querying the Number of Available Joysticks" url="guideinput.php#AEN154" />
+	<tocsect2 name="3-3. Opening a Joystick" url="guideinput.php#AEN183" />
+	<tocsect2 name="3-4. Joystick Axis Events" url="guideinput.php#AEN191" />
+	<tocsect2 name="3-5. More Joystick Axis Events" url="guideinput.php#AEN195" />
+	<tocsect2 name="3-6. Joystick Button Events" url="guideinput.php#AEN203" />
+	<tocsect2 name="3-7. Joystick Ball Events" url="guideinput.php#AEN217" />
+	<tocsect2 name="3-8. Joystick Hat Events" url="guideinput.php#AEN244" />
+	<tocsect2 name="3-9. Querying Joystick Characteristics" url="guideinput.php#AEN265" />
+	<tocsect2 name="3-10. Reading Keyboard Events" url="guideinputkeyboard.php#AEN334" />
+	<tocsect2 name="3-11. Interpreting Key Event Information" url="guideinputkeyboard.php#AEN351" />
+	<tocsect2 name="3-12. Proper Game Movement" url="guideinputkeyboard.php#AEN363" />
+</tocsect1>
+</kdeveloptoc>
diff --git a/doc/extras/w3c/Makefile.am b/doc/extras/w3c/Makefile.am
new file mode 100644
index 00000000..19518e8d
--- /dev/null
+++ b/doc/extras/w3c/Makefile.am
@@ -0,0 +1,3 @@
+tocdir = ${kde_datadir}/kdevdocumentation/tocs
+toc_DATA = w3c-dom-level2-html.toc w3c-svg.toc w3c-uaag10.toc
+
diff --git a/doc/extras/w3c/w3c-dom-level2-html.toc b/doc/extras/w3c/w3c-dom-level2-html.toc
new file mode 100644
index 00000000..f3540ff1
--- /dev/null
+++ b/doc/extras/w3c/w3c-dom-level2-html.toc
@@ -0,0 +1,70 @@
+<!DOCTYPE kdeveloptoc>
+<kdeveloptoc>
+<title>Document Object Model (DOM) Level 2 HTML Specification</title>
+<base href="http://www.w3.org/TR/DOM-Level-2-HTML" />
+ <tocsect1 name="1. Document Object Model HTML" url="html.html">
+ <tocsect2 name="1.1. Introduction" url="html.html#ID-1176245063">
+ </tocsect2>
+ <tocsect2 name="1.2. HTML Application of Core DOM" url="html.html#ID-535378264">
+ <tocsect3 name="1.2.1. Naming Conventions" url="html.html#ID-2041995112">
+ </tocsect3>
+ </tocsect2>
+ <tocsect2 name="1.3. XHTML and the HTML DOM" url="html.html#ID-5353782642">
+ </tocsect2>
+ <tocsect2 name="1.4. Miscellaneous Object Definitions" url="html.html#ID-1019015399">
+ </tocsect2>
+ <tocsect2 name="1.5. Objects related to HTML documents" url="html.html#ID-1006298752">
+ </tocsect2>
+ <tocsect2 name="1.6. HTML Elements" url="html.html#ID-882764350">
+ <tocsect3 name="1.6.1. Property Attributes" url="html.html#ID-642250288">
+ </tocsect3>
+ <tocsect3 name="1.6.2. Naming Exceptions" url="html.html#ID-213157251">
+ </tocsect3>
+ <tocsect3 name="1.6.3. Exposing Element Type Names (tagName, (nodeName))" url="html.html#ID-822762427">
+ </tocsect3>
+ <tocsect3 name="1.6.4. The HTMLElement interface" url="html.html#ID-011100101">
+ </tocsect3>
+ <tocsect3 name="1.6.5. Object definitions" url="html.html#ID-798055546">
+ </tocsect3>
+ </tocsect2>
+ </tocsect1>
+ <tocsect1 name="Appendix A: Changes" url="changes.html">
+ <tocsect2 name="A.1. Changes between DOM Level 1 and DOM Level 2" url="changes.html#DOMLevel1to2Changes">
+ <tocsect3 name="A.1.1. Changes to DOM Level 1 interfaces and exceptions" url="changes.html#DOMLevel1Changes">
+ </tocsect3>
+ <tocsect3 name="A.1.2. New Interfaces" url="changes.html#DOMLevel2Addons">
+ </tocsect3>
+ </tocsect2>
+ </tocsect1>
+ <tocsect1 name="Appendix B: IDL Definitions" url="idl-definitions.html">
+ </tocsect1>
+ <tocsect1 name="Appendix C: Java language Binding" url="java-binding.html">
+ </tocsect1>
+ <tocsect1 name="Appendix D: ECMAScript Language Binding" url="ecma-script-binding.html">
+ </tocsect1>
+ <tocsect1 name="Appendix E: Acknowledgments" url="acknowledgements.html">
+ <tocsect2 name="E.1. Production Systems" url="acknowledgements.html#Productions">
+ </tocsect2>
+ <tocsect2 name="E.2. DOM Level 1" url="acknowledgements.html#dom_level_1">
+ </tocsect2>
+ </tocsect1>
+ <tocsect1 name="Glossary" url="glossary.html">
+ </tocsect1>
+ <tocsect1 name="References" url="references.html">
+ <tocsect2 name="1. Normative references" url="references.html#References-Normative">
+ </tocsect2>
+ <tocsect2 name="2. Informative references" url="references.html#References-Informative">
+ </tocsect2>
+ </tocsect1>
+ <tocsect1 name="Index" url="def-index.html">
+ </tocsect1>         
+ <tocsect1 name="Expanded Table of Contents" url="expanded-toc.html">
+ </tocsect1>
+ <tocsect1 name="Copyright Notice" url="copyright-notice.html">
+ <tocsect2 name="W3C Document Copyright Notice and License" url="copyright-notice.html#Copyright-notice-document">
+ </tocsect2>
+ <tocsect2 name="W3C Software Copyright Notice and License" url="copyright-notice.html#Copyright-notice-software">
+ </tocsect2>
+ </tocsect1>
+</kdeveloptoc>
+ 
diff --git a/doc/extras/w3c/w3c-svg.toc b/doc/extras/w3c/w3c-svg.toc
new file mode 100644
index 00000000..a53e34fc
--- /dev/null
+++ b/doc/extras/w3c/w3c-svg.toc
@@ -0,0 +1,1446 @@
+<!DOCTYPE kdeveloptoc>
+<kdeveloptoc>
+<title>Scalable Vector Graphics (SVG) 1.1 Specification</title>
+<base href="http://www.w3.org/TR/SVG11" url="index.html"/>
+ 
+<tocsect1 name="1 Introduction" url="intro.html">
+ 
+ 
+ <tocsect2 name="1.1 About SVG" url="intro.html#AboutSVG">
+ 
+ 
+ <tocsect3 name="1.1.1 Modularization" url="intro.html#Modularization">
+ </tocsect3>
+ 
+ <tocsect3 name="1.1.2 Element and Attribute Collections" url="intro.html#ElementAndAttributeCollections">
+ </tocsect3>
+ 
+ <tocsect3 name="1.1.3 Profiling the SVG specification" url="intro.html#Profiling">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="1.2 SVG MIME type, file name extension and Macintosh file type" url="intro.html#MIMEType">
+ </tocsect2>
+ 
+ <tocsect2 name="1.3 SVG Namespace, Public Identifier and System Identifier" url="intro.html#Namespace">
+ </tocsect2>
+ 
+ <tocsect2 name="1.4 Compatibility with Other Standards Efforts" url="intro.html#W3CCompatibility">
+ </tocsect2>
+ 
+ <tocsect2 name="1.5 Terminology" url="intro.html#Terminology">
+ </tocsect2>
+ 
+ <tocsect2 name="1.6 Definitions" url="intro.html#Definitions">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="2 Concepts" url="concepts.html">
+ 
+ 
+ <tocsect2 name="2.1 Explaining the name: SVG" url="concepts.html#Intro">
+ </tocsect2>
+ 
+ <tocsect2 name="2.2 Important SVG concepts" url="concepts.html#Concepts">
+ </tocsect2>
+ 
+ <tocsect2 name="2.3 Options for using SVG in Web pages" url="concepts.html#UsageOptions">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="3 Rendering Model" url="render.html">
+ 
+ 
+ <tocsect2 name="3.1 Introduction" url="render.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="3.2 The painters model" url="render.html#PaintersModel">
+ </tocsect2>
+ 
+ <tocsect2 name="3.3 Rendering Order" url="render.html#RenderingOrder">
+ </tocsect2>
+ 
+ <tocsect2 name="3.4 How groups are rendered" url="render.html#Grouping">
+ </tocsect2>
+ 
+ <tocsect2 name="3.5 How elements are rendered" url="render.html#Elements">
+ </tocsect2>
+ 
+ <tocsect2 name="3.6 Types of graphics elements" url="render.html#TypesOfGraphicsElements">
+ 
+ 
+ <tocsect3 name="3.6.1 Painting shapes and text" url="render.html#PaintingShapesAndText">
+ </tocsect3>
+ 
+ <tocsect3 name="3.6.2 Painting raster images" url="render.html#PaintingRasterImages">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="3.7 Filtering painted regions" url="render.html#FilteringPaintRegions">
+ </tocsect2>
+ 
+ <tocsect2 name="3.8 Clipping, masking and object opacity" url="render.html#ClippingMaskingObjectOpacity">
+ </tocsect2>
+ 
+ <tocsect2 name="3.9 Parent Compositing" url="render.html#ParentCompositing">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="4 Basic Data Types and Interfaces" url="types.html">
+ 
+ 
+ <tocsect2 name="4.1 Basic data types" url="types.html#BasicDataTypes">
+ </tocsect2>
+ 
+ <tocsect2 name="4.2 Recognized color keyword names" url="types.html#ColorKeywords">
+ </tocsect2>
+ 
+ <tocsect2 name="4.3 Basic DOM interfaces" url="types.html#BasicDOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="5 Document Structure" url="struct.html">
+ 
+ 
+ <tocsect2 name="5.1 Defining an SVG document fragment: the 'svg' element" url="struct.html#NewDocument">
+ 
+ 
+ <tocsect3 name="5.1.1 Overview" url="struct.html#NewDocumentOverview">
+ </tocsect3>
+ 
+ <tocsect3 name="5.1.2 The 'svg' element" url="struct.html#SVGElement">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="5.2 Grouping: the 'g' element" url="struct.html#Groups">
+ 
+ 
+ <tocsect3 name="5.2.1 Overview" url="struct.html#GroupsOverview">
+ </tocsect3>
+ 
+ <tocsect3 name="5.2.2 The 'g' element" url="struct.html#GElement">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="5.3 References and the 'defs' element" url="struct.html#Head">
+ 
+ 
+ <tocsect3 name="5.3.1 Overview" url="struct.html#HeadOverview">
+ </tocsect3>
+ 
+ <tocsect3 name="5.3.2 URI reference attributes" url="struct.html#xlinkRefAttrs">
+ </tocsect3>
+ 
+ <tocsect3 name="5.3.3 The 'defs' element" url="struct.html#DefsElement">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="5.4 The 'desc' and 'title' elements" url="struct.html#DescriptionAndTitleElements">
+ </tocsect2>
+ 
+ <tocsect2 name="5.5 The 'symbol' element" url="struct.html#SymbolElement">
+ </tocsect2>
+ 
+ <tocsect2 name="5.6 The 'use' element" url="struct.html#UseElement">
+ </tocsect2>
+ 
+ <tocsect2 name="5.7 The 'image' element" url="struct.html#ImageElement">
+ </tocsect2>
+ 
+ <tocsect2 name="5.8 Conditional processing" url="struct.html#ConditionalProcessing">
+ 
+ 
+ <tocsect3 name="5.8.1 Conditional processing overview" url="struct.html#ConditionalProcessingOverview">
+ </tocsect3>
+ 
+ <tocsect3 name="5.8.2 The 'switch' element" url="struct.html#SwitchElement">
+ </tocsect3>
+ 
+ <tocsect3 name="5.8.3 The requiredFeatures attribute" url="struct.html#RequiredFeaturesAttribute">
+ </tocsect3>
+ 
+ <tocsect3 name="5.8.4 The requiredExtensions attribute" url="struct.html#RequiredExtensionsAttribute">
+ </tocsect3>
+ 
+ <tocsect3 name="5.8.5 The systemLanguage attribute" url="struct.html#SystemLanguageAttribute">
+ </tocsect3>
+ 
+ <tocsect3 name="5.8.6 Applicability of test attributes" url="struct.html#ApplicabilityOfTestAttributes">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="5.9 Specifying whether external resources are required for proper rendering" url="struct.html#ExternalResourcesRequired">
+ </tocsect2>
+ 
+ <tocsect2 name="5.10 Common attributes" url="struct.html#CommonAttributes">
+ 
+ 
+ <tocsect3 name="5.10.1 Attributes common to all elements: id and xml:base" url="struct.html#Core.attrib">
+ </tocsect3>
+ 
+ <tocsect3 name="5.10.2 The xml:lang and xml:space attributes" url="struct.html#LangSpaceAttrs">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="5.11 Core Attribute Module" url="struct.html#core-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="5.12 Structure Module" url="struct.html#structure-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="5.13 Basic Structure Module" url="struct.html#basic-structure-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="5.14 Container Attribute Module" url="struct.html#container-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="5.15 Conditional Processing Module" url="struct.html#conditional-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="5.16 Image Module" url="struct.html#image-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="5.17 DOM interfaces" url="struct.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="6 Styling" url="styling.html">
+ 
+ 
+ <tocsect2 name="6.1 SVG's styling properties" url="styling.html#SVGStylingProperties">
+ </tocsect2>
+ 
+ <tocsect2 name="6.2 Usage scenarios for styling" url="styling.html#StylingScenarios">
+ </tocsect2>
+ 
+ <tocsect2 name="6.3 Alternative ways to specify styling properties" url="styling.html#AlternativesForStyling">
+ </tocsect2>
+ 
+ <tocsect2 name="6.4 Specifying properties using the presentation attributes" url="styling.html#UsingPresentationAttributes">
+ </tocsect2>
+ 
+ <tocsect2 name="6.5 Entity definitions for the presentation attributes" url="styling.html#EntityDefinitionsPresentationAttributes">
+ </tocsect2>
+ 
+ <tocsect2 name="6.6 Styling with XSL" url="styling.html#StylingWithXSL">
+ </tocsect2>
+ 
+ <tocsect2 name="6.7 Styling with CSS" url="styling.html#StylingWithCSS">
+ </tocsect2>
+ 
+ <tocsect2 name="6.8 Case sensitivity of property names and values" url="styling.html#CaseSensitivity">
+ </tocsect2>
+ 
+ <tocsect2 name="6.9 Facilities from CSS and XSL used by SVG" url="styling.html#SVGUseOfCSS">
+ </tocsect2>
+ 
+ <tocsect2 name="6.10 Referencing external style sheets" url="styling.html#ReferencingExternalStyleSheets">
+ </tocsect2>
+ 
+ <tocsect2 name="6.11 The 'style' element" url="styling.html#StyleElement">
+ </tocsect2>
+ 
+ <tocsect2 name="6.12 The class attribute" url="styling.html#ClassAttribute">
+ </tocsect2>
+ 
+ <tocsect2 name="6.13 The style attribute" url="styling.html#StyleAttribute">
+ </tocsect2>
+ 
+ <tocsect2 name="6.14 Specifying the default style sheet language" url="styling.html#DefaultStyleSheetLanguage">
+ </tocsect2>
+ 
+ <tocsect2 name="6.15 Property inheritance" url="styling.html#Inheritance">
+ </tocsect2>
+ 
+ <tocsect2 name="6.16 The scope/range of styles" url="styling.html#Scope">
+ </tocsect2>
+ 
+ <tocsect2 name="6.17 User agent style sheet" url="styling.html#UAStyleSheet">
+ </tocsect2>
+ 
+ <tocsect2 name="6.18 Aural style sheets" url="styling.html#AuralStyleSheets">
+ </tocsect2>
+ 
+ <tocsect2 name="6.19 Style Module" url="styling.html#style-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="6.20 DOM interfaces" url="styling.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="7 Coordinate Systems, Transformations and Units" url="coords.html">
+ 
+ 
+ <tocsect2 name="7.1 Introduction" url="coords.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="7.2 The initial viewport" url="coords.html#ViewportSpace">
+ </tocsect2>
+ 
+ <tocsect2 name="7.3 The initial coordinate system" url="coords.html#InitialCoordinateSystem">
+ </tocsect2>
+ 
+ <tocsect2 name="7.4 Coordinate system transformations" url="coords.html#EstablishingANewUserSpace">
+ </tocsect2>
+ 
+ <tocsect2 name="7.5 Nested transformations" url="coords.html#NestedTransformations">
+ </tocsect2>
+ 
+ <tocsect2 name="7.6 The transform attribute" url="coords.html#TransformAttribute">
+ </tocsect2>
+ 
+ <tocsect2 name="7.7 The viewBox attribute" url="coords.html#ViewBoxAttribute">
+ </tocsect2>
+ 
+ <tocsect2 name="7.8 The preserveAspectRatio attribute" url="coords.html#PreserveAspectRatioAttribute">
+ </tocsect2>
+ 
+ <tocsect2 name="7.9 Establishing a new viewport" url="coords.html#EstablishingANewViewport">
+ </tocsect2>
+ 
+ <tocsect2 name="7.10 Units" url="coords.html#Units">
+ </tocsect2>
+ 
+ <tocsect2 name="7.11 Object bounding box units" url="coords.html#ObjectBoundingBox">
+ </tocsect2>
+ 
+ <tocsect2 name="7.12 Geographic Coordinate Systems" url="coords.html#GeographicCoordinates">
+ </tocsect2>
+ 
+ <tocsect2 name="7.13 Viewport Attribute Module" url="coords.html#viewport-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="7.14 DOM interfaces" url="coords.html#DOMInterfaces">
+ </tocsect2>
+
+</tocsect1> 
+
+<tocsect1 name="8 Paths" url="paths.html">
+ 
+ <tocsect2 name="8.1 Introduction" url="paths.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="8.2 The 'path' element" url="paths.html#PathElement">
+ </tocsect2>
+ 
+ <tocsect2 name="8.3 Path Data" url="paths.html#PathData">
+ 
+ 
+ <tocsect3 name="8.3.1 General information about path data" url="paths.html#PathDataGeneralInformation">
+ </tocsect3>
+ 
+ <tocsect3 name="8.3.2 The &quot;moveto&quot; commands" url="paths.html#PathDataMovetoCommands">
+ </tocsect3>
+ 
+ <tocsect3 name="8.3.3 The &quot;closepath&quot; command" url="paths.html#PathDataClosePathCommand">
+ </tocsect3>
+ 
+ <tocsect3 name="8.3.4 The &quot;lineto&quot; commands" url="paths.html#PathDataLinetoCommands">
+ </tocsect3>
+ 
+ <tocsect3 name="8.3.5 The curve commands" url="paths.html#PathDataCurveCommands">
+ </tocsect3>
+ 
+ <tocsect3 name="8.3.6 The cubic Bézier curve commands" url="paths.html#PathDataCubicBezierCommands">
+ </tocsect3>
+ 
+ <tocsect3 name="8.3.7 The quadratic Bézier curve commands" url="paths.html#PathDataQuadraticBezierCommands">
+ </tocsect3>
+ 
+ <tocsect3 name="8.3.8 The elliptical arc curve commands" url="paths.html#PathDataEllipticalArcCommands">
+ </tocsect3>
+ 
+ <tocsect3 name="8.3.9 The grammar for path data" url="paths.html#PathDataBNF">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="8.4 Distance along a path" url="paths.html#DistanceAlongAPath">
+ </tocsect2>
+ 
+ <tocsect2 name="8.5 DOM interfaces" url="paths.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="9 Basic Shapes" url="shapes.html">
+ 
+ 
+ <tocsect2 name="9.1 Introduction" url="shapes.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="9.2 The 'rect' element" url="shapes.html#RectElement">
+ </tocsect2>
+ 
+ <tocsect2 name="9.3 The 'circle' element" url="shapes.html#CircleElement">
+ </tocsect2>
+ 
+ <tocsect2 name="9.4 The 'ellipse' element" url="shapes.html#EllipseElement">
+ </tocsect2>
+ 
+ <tocsect2 name="9.5 The 'line' element" url="shapes.html#LineElement">
+ </tocsect2>
+ 
+ <tocsect2 name="9.6 The 'polyline' element" url="shapes.html#PolylineElement">
+ </tocsect2>
+ 
+ <tocsect2 name="9.7 The 'polygon' element" url="shapes.html#PolygonElement">
+ </tocsect2>
+ 
+ <tocsect2 name="9.8 The grammar for points specifications in 'polyline' and 'polygon' elements" url="shapes.html#PointsBNF">
+ </tocsect2>
+ 
+ <tocsect2 name="9.9 Shape Module" url="shapes.html#shape-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="9.10 DOM interfaces" url="shapes.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="10 Text" url="text.html">
+ 
+ 
+ <tocsect2 name="10.1 Introduction" url="text.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="10.2 Characters and their corresponding glyphs" url="text.html#CharactersAndGlyphs">
+ </tocsect2>
+ 
+ <tocsect2 name="10.3 Fonts, font tables and baselines" url="text.html#FontsTablesBaselines">
+ </tocsect2>
+ 
+ <tocsect2 name="10.4 The 'text' element" url="text.html#TextElement">
+ </tocsect2>
+ 
+ <tocsect2 name="10.5 The 'tspan' element" url="text.html#TSpanElement">
+ </tocsect2>
+ 
+ <tocsect2 name="10.6 The 'tref' element" url="text.html#TRefElement">
+ </tocsect2>
+ 
+ <tocsect2 name="10.7 Text layout" url="text.html#TextLayout">
+ 
+ 
+ <tocsect3 name="10.7.1 Text layout introduction" url="text.html#TextLayoutIntroduction">
+ </tocsect3>
+ 
+ <tocsect3 name="10.7.2 Setting the inline-progression-direction" url="text.html#SettingInlineProgressionDirection">
+ </tocsect3>
+ 
+ <tocsect3 name="10.7.3 Glyph orientation within a text run" url="text.html#GlyphOrientation">
+ </tocsect3>
+ 
+ <tocsect3 name="10.7.4 Relationship with bidirectionality" url="text.html#RelationshipWithBiDirectionality">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="10.8 Text rendering order" url="text.html#TextRenderingOrder">
+ </tocsect2>
+ 
+ <tocsect2 name="10.9 Alignment properties" url="text.html#AlignmentProperties">
+ 
+ 
+ <tocsect3 name="10.9.1 Text alignment properties" url="text.html#TextAlignmentProperties">
+ </tocsect3>
+ 
+ <tocsect3 name="10.9.2 Baseline alignment properties" url="text.html#BaselineAlignmentProperties">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="10.10 Font selection properties" url="text.html#FontPropertiesUsedBySVG">
+ </tocsect2>
+ 
+ <tocsect2 name="10.11 Spacing properties" url="text.html#SpacingProperties">
+ </tocsect2>
+ 
+ <tocsect2 name="10.12 Text decoration" url="text.html#TextDecorationProperties">
+ </tocsect2>
+ 
+ <tocsect2 name="10.14 Text on a path" url="text.html#TextOnAPath">
+ 
+ 
+ <tocsect3 name="10.14.1 Introduction to text on a path" url="text.html#TextOnAPathIntroduction">
+ </tocsect3>
+ 
+ <tocsect3 name="10.14.2 The 'textPath' element" url="text.html#TextPathElement">
+ </tocsect3>
+ 
+ <tocsect3 name="10.14.3 Text on a path layout rules" url="text.html#TextpathLayoutRules">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="10.14 Alternate glyphs" url="text.html#AlternateGlyphs">
+ </tocsect2>
+ 
+ <tocsect2 name="10.15 White space handling" url="text.html#WhiteSpace">
+ </tocsect2>
+ 
+ <tocsect2 name="10.16 Text selection and clipboard operations" url="text.html#TextSelection">
+ </tocsect2>
+ 
+ <tocsect2 name="10.17 Text Module" url="text.html#text-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="10.18 Basic Text Module" url="text.html#basic-text-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="10.19 DOM interfaces" url="text.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="11 Painting: Filling, Stroking and Marker Symbols" url="painting.html">
+ 
+ 
+ <tocsect2 name="11.1 Introduction" url="painting.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="11.2 Specifying paint" url="painting.html#SpecifyingPaint">
+ </tocsect2>
+ 
+ <tocsect2 name="11.3 Fill Properties" url="painting.html#FillProperties">
+ </tocsect2>
+ 
+ <tocsect2 name="11.4 Stroke Properties" url="painting.html#StrokeProperties">
+ </tocsect2>
+ 
+ <tocsect2 name="11.5 Controlling visibility" url="painting.html#VisibilityControl">
+ </tocsect2>
+ 
+ <tocsect2 name="11.6 Markers" url="painting.html#Markers">
+ 
+ 
+ <tocsect3 name="11.6.1 Introduction" url="painting.html#MarkersIntroduction">
+ </tocsect3>
+ 
+ <tocsect3 name="11.6.2 The 'marker' element" url="painting.html#MarkerElement">
+ </tocsect3>
+ 
+ <tocsect3 name="11.6.3 Marker properties" url="painting.html#MarkerProperties">
+ </tocsect3>
+ 
+ <tocsect3 name="11.6.4 Details on how markers are rendered" url="painting.html#MarkerAlgorithm">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="11.7 Rendering properties" url="painting.html#RenderingProperties">
+ 
+ 
+ <tocsect3 name="11.7.1 Color interpolation properties: 'color-interpolation' and 'color-interpolation-filters'" url="painting.html#ColorInterpolationProperties">
+ </tocsect3>
+ 
+ <tocsect3 name="11.7.2 The 'color-rendering' property" url="painting.html#ColorRenderingProperty">
+ </tocsect3>
+ 
+ <tocsect3 name="11.7.3 The 'shape-rendering' property" url="painting.html#ShapeRenderingProperty">
+ </tocsect3>
+ 
+ <tocsect3 name="11.7.4 The 'text-rendering' property" url="painting.html#TextRenderingProperty">
+ </tocsect3>
+ 
+ <tocsect3 name="11.7.5 The 'image-rendering' property" url="painting.html#ImageRenderingProperty">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="11.8 Inheritance of painting properties" url="painting.html#InheritanceOfPaintingProperties">
+ </tocsect2>
+ 
+ <tocsect2 name="11.9 Paint Attribute Module" url="painting.html#paint-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="11.10 Basic Paint Attribute Module" url="painting.html#basic-paint-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="11.11 Opacity Attribute Module" url="painting.html#opacity-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="11.12 Graphics Attribute Module" url="painting.html#graphics-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="11.13 Basic Graphics Attribute Module" url="painting.html#basic-graphics-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="11.14 Marker Module" url="painting.html#marker-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="11.15 DOM interfaces" url="painting.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="12 Color" url="color.html">
+ 
+ <tocsect2 name="12.1 Introduction" url="color.html#ColorIntroduction">
+ </tocsect2>
+ 
+ <tocsect2 name="12.2 The 'color' property" url="color.html#ColorProperty">
+ </tocsect2>
+ 
+ <tocsect2 name="12.3 Color profile descriptions" url="color.html#ColorProfileDescriptions">
+ 
+ 
+ <tocsect3 name="12.3.1 Overview of color profile descriptions" url="color.html#ColorProfileDescriptionsOverview">
+ </tocsect3>
+ 
+ <tocsect3 name="12.3.2 Alternative ways for defining a color profile description" url="color.html#ColorProfileAlternatives">
+ </tocsect3>
+ 
+ <tocsect3 name="12.3.3 The 'color-profile' element" url="color.html#ColorProfileElement">
+ </tocsect3>
+ 
+ <tocsect3 name="12.3.4 @color-profile when using CSS styling" url="color.html#ColorProfileAtRule">
+ </tocsect3>
+ 
+ <tocsect3 name="12.3.5 'color-profile' property" url="color.html#ColorProfileProperty">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="12.4 Color Profile Module" url="color.html#color-profile-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="12.7 DOM interfaces" url="color.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="13 Gradients and Patterns" url="pservers.html">
+ 
+ 
+ <tocsect2 name="13.1 Introduction" url="pservers.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="13.2 Gradients" url="pservers.html#Gradients">
+ 
+ 
+ <tocsect3 name="13.2.1 Introduction" url="pservers.html#GradientsIntroduction">
+ </tocsect3>
+ 
+ <tocsect3 name="13.2.2 Linear gradients" url="pservers.html#LinearGradients">
+ </tocsect3>
+ 
+ <tocsect3 name="13.2.3 Radial gradients" url="pservers.html#RadialGradients">
+ </tocsect3>
+ 
+ <tocsect3 name="13.2.4 Gradient stops" url="pservers.html#GradientStops">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="13.3 Patterns" url="pservers.html#Patterns">
+ </tocsect2>
+ 
+ <tocsect2 name="13.4 Gradient Module" url="pservers.html#gradient-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="13.5 Pattern Module" url="pservers.html#pattern-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="13.6 DOM interfaces" url="pservers.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="14 Clipping, Masking and Compositing" url="masking.html">
+ 
+ 
+ <tocsect2 name="14.1 Introduction" url="masking.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="14.2 Simple alpha compositing" url="masking.html#SimpleAlphaBlending">
+ </tocsect2>
+ 
+ <tocsect2 name="14.3 Clipping paths" url="masking.html#ClippingPaths">
+ 
+ 
+ <tocsect3 name="14.3.1 Introduction" url="masking.html#ClippingPathsIntro">
+ </tocsect3>
+ 
+ <tocsect3 name="14.3.2 The initial clipping path" url="masking.html#InitialClippingPath">
+ </tocsect3>
+ 
+ <tocsect3 name="14.3.3 The 'overflow' and 'clip' properties" url="masking.html#OverflowAndClipProperties">
+ </tocsect3>
+ 
+ <tocsect3 name="14.3.4 Clip to viewport vs. clip to viewBox" url="masking.html#AutoClipAtViewportNotViewBox">
+ </tocsect3>
+ 
+ <tocsect3 name="14.3.5 Establishing a new clipping path" url="masking.html#EstablishingANewClippingPath">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="14.4 Masking" url="masking.html#Masking">
+ </tocsect2>
+ 
+ <tocsect2 name="14.5 Object and group opacity: the 'opacity' property" url="masking.html#ObjectAndGroupOpacityProperties">
+ </tocsect2>
+ 
+ <tocsect2 name="14.6 Clip Module" url="masking.html#clip-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="14.7 Basic Clip Module" url="masking.html#basic-clip-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="14.8 Mask Module" url="masking.html#mask-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="14.9 DOM interfaces" url="masking.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="15 Filter Effects" url="filters.html">
+ 
+ 
+ <tocsect2 name="15.1 Introduction" url="filters.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="15.2 An example" url="filters.html#AnExample">
+ </tocsect2>
+ 
+ <tocsect2 name="15.3 The 'filter' element" url="filters.html#FilterElement">
+ </tocsect2>
+ 
+ <tocsect2 name="15.4 The 'filter' property" url="filters.html#FilterProperty">
+ </tocsect2>
+ 
+ <tocsect2 name="15.5 Filter effects region" url="filters.html#FilterEffectsRegion">
+ </tocsect2>
+ 
+ <tocsect2 name="15.6 Accessing the background image" url="filters.html#AccessingBackgroundImage">
+ </tocsect2>
+ 
+ <tocsect2 name="15.7 Filter primitives overview" url="filters.html#FilterPrimitivesOverview">
+ 
+ 
+ <tocsect3 name="15.7.1 Overview" url="filters.html#FilterPrimitivesOverviewIntro">
+ </tocsect3>
+ 
+ <tocsect3 name="15.7.2 Common attributes" url="filters.html#CommonAttributes">
+ </tocsect3>
+ 
+ <tocsect3 name="15.7.3 Filter primitive subregion" url="filters.html#FilterPrimitiveSubRegion">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="15.8 Light source elements and properties" url="filters.html#LightSourceDefinitions">
+ 
+ 
+ <tocsect3 name="15.8.1 Introduction" url="filters.html#LightSourceIntro">
+ </tocsect3>
+ 
+ <tocsect3 name="15.8.2 Light source 'feDistantLight'" url="filters.html#feDistantLight">
+ </tocsect3>
+ 
+ <tocsect3 name="15.8.3 Light source 'fePointLight'" url="filters.html#fePointLight">
+ </tocsect3>
+ 
+ <tocsect3 name="15.8.4 Light source 'feSpotLight'" url="filters.html#feSpotLight">
+ </tocsect3>
+ 
+ <tocsect3 name="15.8.5 The 'lighting-color' property" url="filters.html#LightingColorProperty">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="15.9 Filter primitive 'feBlend'" url="filters.html#feBlend">
+ </tocsect2>
+ 
+ <tocsect2 name="15.10 Filter primitive 'feColorMatrix'" url="filters.html#feColorMatrix">
+ </tocsect2>
+ 
+ <tocsect2 name="15.11 Filter primitive 'feComponentTransfer'" url="filters.html#feComponentTransfer">
+ </tocsect2>
+ 
+ <tocsect2 name="15.12 Filter primitive 'feComposite'" url="filters.html#feComposite">
+ </tocsect2>
+ 
+ <tocsect2 name="15.13 Filter primitive 'feConvolveMatrix'" url="filters.html#feConvolveMatrix">
+ </tocsect2>
+ 
+ <tocsect2 name="15.14 Filter primitive 'feDiffuseLighting'" url="filters.html#feDiffuseLighting">
+ </tocsect2>
+ 
+ <tocsect2 name="15.15 Filter primitive 'feDisplacementMap'" url="filters.html#feDisplacementMap">
+ </tocsect2>
+ 
+ <tocsect2 name="15.16 Filter primitive 'feFlood'" url="filters.html#feFlood">
+ </tocsect2>
+ 
+ <tocsect2 name="15.17 Filter primitive 'feGaussianBlur'" url="filters.html#feGaussianBlur">
+ </tocsect2>
+ 
+ <tocsect2 name="15.18 Filter primitive 'feImage'" url="filters.html#feImage">
+ </tocsect2>
+ 
+ <tocsect2 name="15.19 Filter primitive 'feMerge'" url="filters.html#feMerge">
+ </tocsect2>
+ 
+ <tocsect2 name="15.20 Filter primitive 'feMorphology'" url="filters.html#feMorphology">
+ </tocsect2>
+ 
+ <tocsect2 name="15.21 Filter primitive 'feOffset'" url="filters.html#feOffset">
+ </tocsect2>
+ 
+ <tocsect2 name="15.22 Filter primitive 'feSpecularLighting'" url="filters.html#feSpecularLighting">
+ </tocsect2>
+ 
+ <tocsect2 name="15.23 Filter primitive 'feTile'" url="filters.html#feTile">
+ </tocsect2>
+ 
+ <tocsect2 name="15.24 Filter primitive 'feTurbulence'" url="filters.html#feTurbulence">
+ </tocsect2>
+ 
+ <tocsect2 name="15.25 Filter Module" url="filters.html#filter-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="15.26 Basic Filter Module" url="filters.html#basic-filter-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="15.27 DOM interfaces" url="filters.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="16 Interactivity" url="interact.html">
+ 
+ 
+ <tocsect2 name="16.1 Introduction" url="interact.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="16.2 Complete list of supported events" url="interact.html#SVGEvents">
+ </tocsect2>
+ 
+ <tocsect2 name="16.3 User interface events" url="interact.html#UIEvents">
+ </tocsect2>
+ 
+ <tocsect2 name="16.4 Pointer events" url="interact.html#PointerEvents">
+ </tocsect2>
+ 
+ <tocsect2 name="16.5 Processing order for user interface events" url="interact.html#UIEventProcessing">
+ </tocsect2>
+ 
+ <tocsect2 name="16.6 The 'pointer-events' property" url="interact.html#PointerEventsProperty">
+ </tocsect2>
+ 
+ <tocsect2 name="16.7 Magnification and panning" url="interact.html#EnableZoomAndPanControls">
+ </tocsect2>
+ 
+ <tocsect2 name="16.8 Cursors" url="interact.html#Cursors">
+ 
+ 
+ <tocsect3 name="16.8.1 Introduction to cursors" url="interact.html#CursorIntro">
+ </tocsect3>
+ 
+ <tocsect3 name="16.8.2 The 'cursor' property" url="interact.html#CursorProperty">
+ </tocsect3>
+ 
+ <tocsect3 name="16.8.3 The 'cursor' element" url="interact.html#CursorElement">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="16.9 Document Events Attribute Module" url="interact.html#document-events-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="16.10 Graphical Events Attribute Module" url="interact.html#graphical-events-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="16.11 Animation Events Attribute Module" url="interact.html#animation-events-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="16.12 Cursor Module" url="interact.html#cursor-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="16.13 DOM interfaces" url="interact.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="17 Linking" url="linking.html">
+ 
+ 
+ <tocsect2 name="17.1 Links out of SVG content: the 'a' element" url="linking.html#Links">
+ </tocsect2>
+ 
+ <tocsect2 name="17.2 Linking into SVG content: URI fragments and SVG views" url="linking.html#LinksIntoSVG">
+ 
+ 
+ <tocsect3 name="17.2.1 Introduction: URI fragments and SVG views" url="linking.html#IntroFragmentsViews">
+ </tocsect3>
+ 
+ <tocsect3 name="17.2.2 SVG fragment identifiers" url="linking.html#SVGFragmentIdentifiers">
+ </tocsect3>
+ 
+ <tocsect3 name="17.2.3 Predefined views: the 'view' element" url="linking.html#ViewElement">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="17.3 Hyperlinking Module" url="linking.html#hyperlinking-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="17.4 Xlink Attribute Module" url="linking.html#xlink-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="17.5 ExternalResourcesRequired Attribute Module" url="linking.html#err-att-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="17.6 View Module" url="linking.html#view-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="17.7 DOM interfaces" url="linking.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="18 Scripting" url="script.html">
+ 
+ 
+ <tocsect2 name="18.1 Specifying the scripting language" url="script.html#ScriptingLanguage">
+ 
+ 
+ <tocsect3 name="18.1.1 Specifying the default scripting language" url="script.html#DefaultScriptingLanguage">
+ </tocsect3>
+ 
+ <tocsect3 name="18.1.2 Local declaration of a scripting language" url="script.html#SpecifiedScriptingLanguage">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="18.2 The 'script' element" url="script.html#ScriptElement">
+ </tocsect2>
+ 
+ <tocsect2 name="18.3 Event handling" url="script.html#EventHandling">
+ </tocsect2>
+ 
+ <tocsect2 name="18.4 Event attributes" url="script.html#EventAttributes">
+ </tocsect2>
+ 
+ <tocsect2 name="18.5 Scripting Module" url="script.html#scripting-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="18.6 DOM interfaces" url="script.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="19 Animation" url="animate.html">
+ 
+ 
+ <tocsect2 name="19.1 Introduction" url="animate.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="19.2 Animation elements" url="animate.html#Animation.class">
+ 
+ 
+ <tocsect3 name="19.2.1 Overview" url="animate.html#AnimateElementsIntro">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.2 Relationship to SMIL Animation" url="animate.html#RelationshipToSMILAnimation">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.3 Animation elements example" url="animate.html#Animation.classExample">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.4 Attributes to identify the target element for an animation" url="animate.html#TargetElement">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.5 Attributes to identify the target attribute or property for an animation" url="animate.html#TargetAttributes">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.6 Attributes to control the timing of the animation" url="animate.html#TimingAttributes">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.7 Attributes that define animation values over time" url="animate.html#ValueAttributes">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.8 Attributes that control whether animations are additive" url="animate.html#AdditionAttributes">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.9 Inheritance" url="animate.html#Inheritance">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.10 The 'animate' element" url="animate.html#AnimateElement">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.11 The 'set' element" url="animate.html#SetElement">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.12 The 'animateMotion' element" url="animate.html#AnimateMotionElement">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.13 The 'animateColor' element" url="animate.html#AnimateColorElement">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.14 The 'animateTransform' element" url="animate.html#AnimateTransformElement">
+ </tocsect3>
+ 
+ <tocsect3 name="19.2.15 Elements, attributes and properties that can be animated" url="animate.html#AnimationAttributesAndProperties">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="19.3 Animation using the SVG DOM" url="animate.html#DOMAnimationExample">
+ </tocsect2>
+ 
+ <tocsect2 name="19.4 Animation Module" url="animate.html#animation-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="19.5 DOM interfaces" url="animate.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="20 Fonts" url="fonts.html">
+ 
+ 
+ <tocsect2 name="20.1 Introduction" url="fonts.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="20.2 Overview of SVG fonts" url="fonts.html#SVGFontsOverview">
+ </tocsect2>
+ 
+ <tocsect2 name="20.3 The 'font' element" url="fonts.html#FontElement">
+ </tocsect2>
+ 
+ <tocsect2 name="20.4 The 'glyph' element" url="fonts.html#GlyphElement">
+ </tocsect2>
+ 
+ <tocsect2 name="20.5 The 'missing-glyph' element" url="fonts.html#MissingGlyphElement">
+ </tocsect2>
+ 
+ <tocsect2 name="20.6 Glyph selection rules" url="fonts.html#GlyphSelectionRules">
+ </tocsect2>
+ 
+ <tocsect2 name="20.7 The 'hkern' and 'vkern' elements" url="fonts.html#KernElements">
+ </tocsect2>
+ 
+ <tocsect2 name="20.8 Describing a font" url="fonts.html#FontDescriptions">
+ 
+ 
+ <tocsect3 name="20.8.1 Overview of font descriptions" url="fonts.html#FontDescriptionsOverview">
+ </tocsect3>
+ 
+ <tocsect3 name="20.8.2 Alternative ways for providing a font description" url="fonts.html#FontDescriptionsAlternatives">
+ </tocsect3>
+ 
+ <tocsect3 name="20.8.3 The 'font-face' element" url="fonts.html#FontFaceElement">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="20.9 Full Font Module" url="fonts.html#font-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="20.10 Basic Font Module" url="fonts.html#basic-font-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="20.11 DOM interfaces" url="fonts.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="21 Metadata" url="metadata.html">
+ 
+ 
+ <tocsect2 name="21.1 Introduction" url="metadata.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="21.2 The 'metadata' element" url="metadata.html#MetadataElement">
+ </tocsect2>
+ 
+ <tocsect2 name="21.3 An example" url="metadata.html#Example">
+ </tocsect2>
+ 
+ <tocsect2 name="21.4 DOM interfaces" url="metadata.html#DOMInterfaces">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="22 Backwards Compatibility" url="backward.html">
+</tocsect1>
+ 
+<tocsect1 name="23 Extensibility" url="extend.html">
+ 
+ 
+ <tocsect2 name="23.1 Foreign namespaces and private data" url="extend.html#PrivateData">
+ </tocsect2>
+ 
+ <tocsect2 name="23.2 Embedding foreign object types" url="extend.html#EmbeddingForeignObjects">
+ </tocsect2>
+ 
+ <tocsect2 name="23.3 The 'foreignObject' element" url="extend.html#ForeignObjectElement">
+ </tocsect2>
+ 
+ <tocsect2 name="23.4 An example" url="extend.html#AnExample">
+ </tocsect2>
+ 
+ <tocsect2 name="23.5 Adding private elements and attributes to the DTD" url="extend.html#PrivateElementsAndAttribute">
+ </tocsect2>
+ 
+ <tocsect2 name="23.6 Extensibility Module" url="extend.html#extensibility-mod">
+ </tocsect2>
+ 
+ <tocsect2 name="23.7 DOM interfaces" url="extend.html#DOMInterfaces">
+ 
+ </tocsect2>
+
+</tocsect1>
+ 
+<tocsect1 name="Appendix A: DTD" url="svgdtd.html">
+ <tocsect2 name="A.1 SVG 1.1 DTD Module Implementations" url="svgdtd.html#DTD.1">
+
+ <tocsect3 name="A.1.1 Modular Framework Module" url="svgdtd.html#DTD.1.1">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.2 Datatypes Module" url="svgdtd.html#DTD.1.2">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.3 Qualified Name Module" url="svgdtd.html#DTD.1.3">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.4 Core Attribute Module" url="svgdtd.html#DTD.1.4">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.5 Container Attribute Module" url="svgdtd.html#DTD.1.5">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.6 Viewport Attribute Module" url="svgdtd.html#DTD.1.6">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.7 Paint Attribute Module" url="svgdtd.html#DTD.1.7">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.8 Basic Paint Attribute Module" url="svgdtd.html#DTD.1.8">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.9 Paint Opacity Attribute Module" url="svgdtd.html#DTD.1.9">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.10 Graphics Attribute Module" url="svgdtd.html#DTD.1.10">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.11 Basic Graphics Attribute Module" url="svgdtd.html#DTD.1.11">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.12 Document Events Attribute Module" url="svgdtd.html#DTD.1.12">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.13 Graphical Element Events Attribute Module" url="svgdtd.html#DTD.1.13">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.14 Animation Events Attribute Module" url="svgdtd.html#DTD.1.14">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.15 XLink Attribute Module" url="svgdtd.html#DTD.1.15">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.16 External Resources Attribute Module" url="svgdtd.html#DTD.1.16">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.17 Structure Module" url="svgdtd.html#DTD.1.17">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.18 Basic Structure Module" url="svgdtd.html#DTD.1.18">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.19 Conditional Processing Module" url="svgdtd.html#DTD.1.19">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.20 Image Module" url="svgdtd.html#DTD.1.20">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.21 Style Module" url="svgdtd.html#DTD.1.21">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.22 Shape Module" url="svgdtd.html#DTD.1.22">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.23 Text Module" url="svgdtd.html#DTD.1.23">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.24 Basic Text Module" url="svgdtd.html#DTD.1.24">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.25 Marker Module" url="svgdtd.html#DTD.1.25">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.26 Color Profile Module" url="svgdtd.html#DTD.1.26">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.27 Gradient Module" url="svgdtd.html#DTD.1.27">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.28 Pattern Module" url="svgdtd.html#DTD.1.28">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.29 Clip Module" url="svgdtd.html#DTD.1.29">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.30 Basic Clip Module" url="svgdtd.html#DTD.1.30">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.31 Mask Module" url="svgdtd.html#DTD.1.31">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.32 Filter Module" url="svgdtd.html#DTD.1.32">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.33 Basic Filter Module" url="svgdtd.html#DTD.1.33">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.34 Cursor Module" url="svgdtd.html#DTD.1.34">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.35 Hyperlinking Module" url="svgdtd.html#DTD.1.35">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.36 View Module" url="svgdtd.html#DTD.1.36">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.37 Scripting Module" url="svgdtd.html#DTD.1.37">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.38 Animation Module" url="svgdtd.html#DTD.1.38">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.39 Font Module" url="svgdtd.html#DTD.1.39">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.40 Basic Font Module" url="svgdtd.html#DTD.1.40">
+ </tocsect3>
+ 
+ <tocsect3 name="A.1.41 Extensibility Module" url="svgdtd.html#DTD.1.41">
+ </tocsect3>
+ </tocsect2>
+ 
+ <tocsect2 name="A.2 SVG 1.1 Document Type Definition" url="svgdtd.html#DTD.2">
+ 
+ 
+ <tocsect3 name="A.2.1 SVG 1.1 DTD Driver" url="svgdtd.html#DTD.2.1">
+ </tocsect3>
+ 
+ <tocsect3 name="A.2.2 SVG 1.1 Document Model" url="svgdtd.html#DTD.2.2">
+ </tocsect3>
+ 
+ <tocsect3 name="A.2.3 SVG 1.1 Attribute Collection" url="svgdtd.html#DTD.2.3">
+ </tocsect3>
+ </tocsect2>
+</tocsect1>
+ 
+<tocsect1 name="Appendix B: SVG Document Object Model (DOM)" url="svgdom.html">
+ 
+ 
+ <tocsect2 name="B.1 SVG DOM Overview" url="svgdom.html#SVGDOMOverview">
+ </tocsect2>
+ 
+ <tocsect2 name="B.2 Naming Conventions" url="svgdom.html#SVGDOMNamingConventions">
+ </tocsect2>
+ 
+ <tocsect2 name="B.3 Interface SVGException" url="svgdom.html#InterfaceSVGException">
+ </tocsect2>
+ 
+ <tocsect2 name="B.4 Feature strings for the hasFeature method call" url="svgdom.html#FeatureStrings">
+ </tocsect2>
+ 
+ <tocsect2 name="B.5 Relationship with DOM2 events" url="svgdom.html#RelationShipWithDOM2Events">
+ </tocsect2>
+ 
+ <tocsect2 name="B.6 Relationship with DOM2 CSS object model (CSS OM)" url="svgdom.html#RelationShipWithCSSOM">
+ 
+ 
+ <tocsect3 name="B.6.1 Introduction" url="svgdom.html#CSSDOMIntro">
+ </tocsect3>
+ 
+ <tocsect3 name="B.6.2 User agents that do not support styling with CSS" url="svgdom.html#CSSDOMFeaturesNoCSSSupport">
+ </tocsect3>
+ 
+ <tocsect3 name="B.6.3 User agents that support styling with CSS" url="svgdom.html#CSSDOMFeaturesWithCSSSupport">
+ </tocsect3>
+ 
+ <tocsect3 name="B.6.4 Extended interfaces" url="svgdom.html#ExtendedInterfaces">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="B.7 Invalid values" url="svgdom.html#InvalidValues">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="Appendix C: IDL Definitions" url="idl.html">
+</tocsect1>
+ 
+<tocsect1 name="Appendix D: Java Language Binding" url="java.html">
+ 
+ 
+ <tocsect2 name="D.1 Using SVG with Java" url="java.html#UsingSVGWithJava">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="Appendix E: ECMAScript Language Binding" url="escript.html">
+</tocsect1>
+ 
+<tocsect1 name="Appendix F: Implementation Requirements" url="implnote.html">
+ 
+ 
+ <tocsect2 name="F.1 Introduction" url="implnote.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="F.2 Error processing" url="implnote.html#ErrorProcessing">
+ </tocsect2>
+ 
+ <tocsect2 name="F.3 Version control" url="implnote.html#VersionControl">
+ </tocsect2>
+ 
+ <tocsect2 name="F.4 Clamping values which are restricted to a particular range" url="implnote.html#RangeClamping">
+ </tocsect2>
+ 
+ <tocsect2 name="F.5 'path' element implementation notes" url="implnote.html#PathElementImplementationNotes">
+ </tocsect2>
+ 
+ <tocsect2 name="F.6 Elliptical arc implementation notes" url="implnote.html#ArcImplementationNotes">
+ 
+ 
+ <tocsect3 name="F.6.1 Elliptical arc syntax" url="implnote.html#ArcSyntax">
+ </tocsect3>
+ 
+ <tocsect3 name="F.6.2 Out-of-range parameters" url="implnote.html#ArcOutOfRangeParameters">
+ </tocsect3>
+ 
+ <tocsect3 name="F.6.3 Parameterization alternatives" url="implnote.html#ArcParameterizationAlternatives">
+ </tocsect3>
+ 
+ <tocsect3 name="F.6.4 Conversion from center to endpoint parameterization" url="implnote.html#ArcConversionCenterToEndpoint">
+ </tocsect3>
+ 
+ <tocsect3 name="F.6.5 Conversion from endpoint to center parameterization" url="implnote.html#ArcConversionEndpointToCenter">
+ </tocsect3>
+ 
+ <tocsect3 name="F.6.6 Correction of out-of-range radii" url="implnote.html#ArcCorrectionOutOfRangeRadii">
+ </tocsect3>
+ 
+ </tocsect2>
+ 
+ <tocsect2 name="F.7 Text selection implementation notes" url="implnote.html#TextSelectionImplementationNotes">
+ </tocsect2>
+ 
+ <tocsect2 name="F.8 Printing implementation notes" url="implnote.html#PrintingImplementationNotes">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="Appendix G: Conformance Criteria" url="conform.html">
+ 
+ 
+ <tocsect2 name="G.1 Introduction" url="conform.html#Introduction">
+ </tocsect2>
+ 
+ <tocsect2 name="G.2 Conforming SVG Document Fragments" url="conform.html#ConformingSVGDocuments">
+ </tocsect2>
+ 
+ <tocsect2 name="G.3 Conforming SVG Stand-Alone Files" url="conform.html#ConformingSVGStandAloneFiles">
+ </tocsect2>
+ 
+ <tocsect2 name="G.4 Conforming SVG Included Document Fragments" url="conform.html#ConformingSVGIncludedDocuments">
+ </tocsect2>
+ 
+ <tocsect2 name="G.5 Conforming SVG Generators" url="conform.html#ConformingSVGGenerators">
+ </tocsect2>
+ 
+ <tocsect2 name="G.6 Conforming SVG Interpreters" url="conform.html#ConformingSVGInterpreters">
+ </tocsect2>
+ 
+ <tocsect2 name="G.7 Conforming SVG Viewers" url="conform.html#ConformingSVGViewers">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="Appendix H: Accessibility Support" url="access.html">
+ 
+ 
+ <tocsect2 name="H.1 WAI Accessibility Guidelines" url="access.html#AccessibilityAndSVG">
+ </tocsect2>
+ 
+ <tocsect2 name="H.2 SVG Content Accessibility Guidelines" url="access.html#SVGAccessibilityGuidelines">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="Appendix I: Internationalization Support" url="i18n.html">
+ 
+ 
+ <tocsect2 name="I.1 Introduction" url="i18n.html#Intro">
+ </tocsect2>
+ 
+ <tocsect2 name="I.2 Internationalization and SVG" url="i18n.html#InternationalizationAndSVG">
+ </tocsect2>
+ 
+ <tocsect2 name="I.3 SVG Internationalization Guidelines" url="i18n.html#SVGInternationalizationGuidelines">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="Appendix J: Minimizing SVG File Sizes" url="minimize.html">
+</tocsect1>
+ 
+<tocsect1 name="Appendix K: References" url="refs.html">
+ 
+ 
+ <tocsect2 name="K.1 Normative references" url="refs.html#q1">
+ </tocsect2>
+ 
+ <tocsect2 name="K.2 Informative references" url="refs.html#q2">
+ </tocsect2>
+ 
+</tocsect1>
+ 
+<tocsect1 name="Appendix L: Element Index" url="eltindex.html">
+</tocsect1>
+ 
+<tocsect1 name="Appendix M: Attribute Index" url="attindex.html">
+</tocsect1>
+ 
+<tocsect1 name="Appendix N: Property Index" url="propidx.html">
+</tocsect1>
+ 
+<tocsect1 name="Appendix O: Feature Strings" url="propidx.html">
+</tocsect1>
+ 
+<tocsect1 name="Appendix P: Index" url="indexlist.html">
+</tocsect1>
+
+<tocsect1 name="Expanded Table of Contents" url="expanded-toc.html">
+</tocsect1>
+<tocsect1 name="Copyright notice" url="copyright-notice.html">
+ <tocsect2 name="W3C Document Copyright Notice and License" url="copyright-notice.html#Copyright-notice-document">
+ </tocsect2>
+ <tocsect2 name="W3C Software Copyright Notice and License" url="copyright-notice.html#Copyright-notice-software">
+ </tocsect2>
+</tocsect1>
+
+</kdeveloptoc>
+ 
diff --git a/doc/extras/w3c/w3c-uaag10.toc b/doc/extras/w3c/w3c-uaag10.toc
new file mode 100644
index 00000000..08f90cc9
--- /dev/null
+++ b/doc/extras/w3c/w3c-uaag10.toc
@@ -0,0 +1,69 @@
+<!DOCTYPE kdeveloptoc>
+<kdeveloptoc>
+<title>User Agent Accessibility Guidelines 1.0</title>
+<base href="http://www.w3.org/TR/UAAG10" url="cover.html"/>
+ <tocsect1 name="Abstract" url="cover.html#abstract">
+ </tocsect1>
+ <tocsect1 name="Status of this document" url="cover.html#status">
+ </tocsect1>
+ <tocsect1 name="1. Introduction" url="intro.html#introduction">
+ <tocsect2 name="1.1 Relation to WAI accessibility guidelines" url="intro.html#context">
+ </tocsect2>
+ <tocsect2 name="1.2 Target user agents" url="intro.html#target">
+ </tocsect2>
+ <tocsect2 name="1.3 Known limitations of this document" url="intro.html#limitations">
+ </tocsect2>
+ <tocsect2 name="1.4 Relation to general software design guidelines and other specifications" url="intro.html#general-design">
+ </tocsect2>
+ <tocsect2 name="1.5 Security considerations" url="intro.html#security-considerations">
+ </tocsect2>
+ <tocsect2 name="1.6 User control" url="intro.html#user-control">
+ </tocsect2>
+ </tocsect1>
+ <tocsect1 name="2. The user agent accessibility guidelines" url="guidelines.html#Guidelines">
+ <tocsect2 name="1. Support input and output device-independence" url="guidelines.html#gl-device-independence">
+ </tocsect2>
+ <tocsect2 name="2. Ensure user access to all content" url="guidelines.html#gl-content-access">
+ </tocsect2>
+ <tocsect2 name="3. Allow configuration not to render some content that may reduce accessibility" url="guidelines.html#gl-feature-on-off">
+ </tocsect2>
+ <tocsect2 name="4. Ensure user control of rendering" url="guidelines.html#gl-user-control-styles">
+ </tocsect2>
+ <tocsect2 name="5. Ensure user control of user interface behavior" url="guidelines.html#gl-user-control-ui">
+ </tocsect2>
+ <tocsect2 name="6. Implement interoperable application programming interfaces" url="guidelines.html#gl-accessible-interface">
+ </tocsect2>
+ <tocsect2 name="7. Observe operating environment conventions" url="guidelines.html#gl-conventions">
+ </tocsect2>
+ <tocsect2 name="8. Implement specifications that benefit accessibility" url="guidelines.html#gl-implement-access-features">
+ </tocsect2>
+ <tocsect2 name="9. Provide navigation mechanisms" url="guidelines.html#gl-navigation">
+ </tocsect2>
+ <tocsect2 name="10. Orient the user" url="guidelines.html#gl-orientation">
+ </tocsect2>
+ <tocsect2 name="11. Allow configuration and customization" url="guidelines.html#gl-configuration">
+ </tocsect2>
+ <tocsect2 name="12. Provide accessible user agent documentation and help" url="guidelines.html#gl-documentation">
+ </tocsect2>
+ </tocsect1>
+ <tocsect1 name="3. Conformance" url="conformance.html#Conformance">
+ <tocsect2 name="3.1 Conformance profiles" url="conformance.html#conformance-profiles">
+ </tocsect2>
+ <tocsect2 name="3.2 Conformance claims" url="conformance.html#conformance-claims">
+ </tocsect2>
+ <tocsect2 name="3.3 UAAG 1.0 requirements in other specifications" url="conformance.html#include-uaag-reqs">
+ </tocsect2>
+ </tocsect1>
+ <tocsect1 name="4. Glossary" url="glossary.html#terms">
+ </tocsect1>
+ <tocsect1 name="5. References" url="references.html#References">
+ <tocsect2 name="5.1 How to refer to this document" url="references.html#this-doc-ref">
+ </tocsect2>
+ <tocsect2 name="5.2 Normative references" url="references.html#Normative-ref">
+ </tocsect2>
+ <tocsect2 name="5.3 Informative references" url="references.html#Informative-ref">
+ </tocsect2>
+ </tocsect1>
+ <tocsect1 name="6. Acknowledgments" url="acks.html#Acknowledgments">
+ </tocsect1>
+</kdeveloptoc>
diff --git a/doc/kde_app_devel/Makefile.am b/doc/kde_app_devel/Makefile.am
new file mode 100644
index 00000000..41691557
--- /dev/null
+++ b/doc/kde_app_devel/Makefile.am
@@ -0,0 +1,3 @@
+KDE_LANG = en
+KDE_DOCS = AUTO
+
diff --git a/doc/kde_app_devel/appwizard.png b/doc/kde_app_devel/appwizard.png
new file mode 100644
index 00000000..adbadb35
--- /dev/null
+++ b/doc/kde_app_devel/appwizard.png
diff --git a/doc/kde_app_devel/index.docbook b/doc/kde_app_devel/index.docbook
new file mode 100644
index 00000000..5b721135
--- /dev/null
+++ b/doc/kde_app_devel/index.docbook
@@ -0,0 +1,1549 @@
+<?xml version="1.0" ?>
+<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.1.2-Based Variant V1.1//EN" "dtd/kdex.dtd" [
+  <!ENTITY kdevelop "<application>KDevelop</application>">
+  <!ENTITY kappname "&kdevelop;">
+  <!ENTITY % addindex "INCLUDE">
+  <!ENTITY % English "INCLUDE" > <!-- change language only here -->
+]>
+
+<book lang="&language;">
+
+<bookinfo>
+<title>The &kdevelop; Programming Handbook</title>
+
+<date>2002-12-05</date>
+<releaseinfo>2.0</releaseinfo>
+
+<authorgroup>
+<author>
+<firstname>Ralf</firstname>
+<surname>Nolden</surname>
+<affiliation><address><email>Ralf.Nolden@post.rwth-aachen.de</email></address></affiliation>
+</author>
+<author>
+<firstname>Caleb</firstname>
+<surname>Tennis</surname>
+<affiliation><address><email>caleb@aei-tech.com</email></address></affiliation>
+</author>
+</authorgroup>
+
+<copyright>
+<year>1999</year>
+<holder>Ralf Nolden</holder>
+</copyright>
+<copyright>
+<year>2002</year>
+<holder>Caleb Tennis</holder>
+</copyright>
+
+<!-- ROLES_OF_TRANSLATORS -->
+
+<legalnotice>&FDLNotice;</legalnotice>
+
+<abstract>
+<para>The User Guide to C++ Application Design for the K Desktop Environment (KDE) with
+the &kdevelop; IDE</para>
+</abstract>
+
+<keywordset>
+<keyword>KDE</keyword>
+<keyword>KDevelop</keyword>
+<keyword>IDE</keyword>
+<keyword>development</keyword>
+<keyword>programming</keyword>
+</keywordset>
+
+</bookinfo>
+
+<chapter id="chapter1">
+<title>Introduction</title>
+<para>
+As Unix Systems are becoming more and more popular to even beginners working with computer machines 
+due to its advantages in regards of stability and functionality, most are somehow disappointed, because 
+those applications don't have a consistent look and each one behaves different from another. With KDE, 
+developers have an almost perfect way to create first-class applications for Unix desktop systems to get 
+a wider user community by the mere quality their applications have to offer. Therefore, KDE becomes more 
+and more popular as a base for programming design, and developers want to take advantage of the 
+possibilities that the system has to offer.
+</para>
+
+<sect1 id="c1s1">
+<title>What you should know already</title>
+<para>
+For making the best use of this programming handbook, we assume that you already know about the 
+C++ programming language; if not, you should make yourself familiar with that first. Information about 
+C++ is available through various sources either in printed form at your local bookstore or by tutorials 
+found on the Internet. Knowledge about the design of Graphical User Interfaces is not required, as this 
+handbook tries to cover the application design for KDE programs, which also includes an introduction into 
+the Qt toolkit as well as the KDE libraries and the design of User Interfaces. Also, you should have made 
+yourself comfortable with &kdevelop; by reading The User Manual to &kdevelop;, which contains a descriptive 
+review of the functionality provided by the IDE. 
+</para>
+</sect1>
+
+<sect1 id="c1s2">
+<title>About this Handbook</title>
+<para>
+This handbook has been written to give developers an introduction into KDE application development by 
+using the KDevelop Integrated Development Environment. 
+</para>
+<para>
+The following chapters therefore give an introduction on how to create projects, explains the sourcecode 
+already generated and shows how to extend the given sources on various topics such as toolbars, menu bars 
+and view areas. 
+</para>
+<para>
+Then the dialogeditor is discussed in detail, explaining how widgets are created and covers widget 
+properties settings in detail for all provided widgets. 
+</para>
+<para>
+Finally, you will learn about several topics that will complete your knowledge in regards of project design
+and helps you work out additional issues besides coding such as adding API documentation and extending 
+online-manuals.
+</para>
+<sect2 id="c1s2s1">
+<title>In the next chapter</title>
+<para>
+We'll take a look at the Qt and KDE libraries, showing basic concepts and why things are the way they are. 
+Also, we will discuss how to create the tutorial applications provided with the Qt toolkit by using 
+kdevelop;, so beginners can already see first results with a few steps, and thereby will learn how to make 
+use of some of &kdevelop;'s best features. 
+</para>
+</sect2>
+
+<sect2 id="c1s2s2">
+<title>In the following chapters</title>
+<para>
+You will learn how to:
+<itemizedlist>
+<listitem><para>create an application with the KAppWizard</para></listitem>
+<listitem><para>What the project skeleton already provides</para></listitem>
+<listitem><para>What the code already create means</para></listitem>
+<listitem><para>How to create your own views</para></listitem>
+<listitem><para>How to extend your application's functionality by dialog, menu bars, and toolbars</para></listitem>
+<listitem><para>How to make your application user friendly by providing help functions</para></listitem>
+<listitem><para>How to write online documentation</para></listitem>
+</itemizedlist>
+</para>
+</sect2>
+
+</sect1>
+
+<sect1 id="c1s3">
+<title>Additional Information</title>
+<para>
+Additional information about Qt/KDE programming is available by various sources:
+<itemizedlist>
+<listitem><para>Programming with Qt by Matthias Kalle Dalheimer</para></listitem>
+<listitem><para><ulink url="www.kdevelop.org">The User Manual to KDevelop, provided with the KDevelop IDE</ulink></para></listitem>
+<listitem><para><ulink url="doc.trolltech.com">The Online Reference to the Qt library</ulink></para></listitem>
+<listitem><para><ulink url="developer.kde.org">The KDE Developer web site</ulink></para></listitem>
+</itemizedlist>
+</para>
+<para>
+Additionally, you should look for help by subscribing to the various mailing lists, whose addresses 
+are available on the mentioned web sites, and on the Usenet newsgroups dedicated to users of KDE and 
+Unix Systems as well as about the C and C++ programming language. 
+</para>
+<para>
+For obtaining help about the KDevelop IDE, you should send requests to our mailinglist at 
+<email>kdevelop@kdevelop.org</email>. Mind that the KDevelop team is dedicated to provide the means to enable you to 
+program applications and therefore is not intended as a technical support team in cases where the 
+applications you're developing don't work due to implementation errors or misconfigurations of your 
+operating system. By this, we ask all users to take advantage of the mailinglist in any case you're running 
+into problems with the use of the IDE itself, as well as for bug reports and suggestions for improving the 
+functionality of the development environment. 
+</para>
+</sect1>
+
+</chapter>
+
+<chapter id="chapter2">
+<title>The KDE and Qt Libraries</title>
+<para>
+The Norwegian company TrollTech (<ulink url="http://www.trolltech.com">http://www.trolltech.com</ulink>) 
+provides a so-called GUI toolkit, named Qt. GUI means "Graphical User Interface", and therefore, Qt-based 
+applications represent themselves with buttons, windows etc, allowing user input by visualizing the functions 
+an application provides. Such a toolkit is needed for developing graphical applications that run on the X-Window 
+interface on Unix Systems, because X does not contain a pre-defined user interface itself. Although other 
+toolkits are also available to create User Interfaces, Qt offers some technical advantages that make 
+application design very easy. Additionally, the Qt toolkit is also available for Microsoft Windows systems, 
+which allows developers to provide their applications for both platforms. 
+</para>
+<para>
+The KDE Team (<ulink url="http://www.kde.org">http://www.kde.org</ulink>) joined together with the goal 
+to make using Unix Systems more friendly, and decided to use the Qt toolkit for the development of a window
+manager on X-Windows, plus a variety of tools included with the KDE packages. The K Desktop Environment 
+therefore contains the window manager kwm, the file manager kfm and the launch panel kpanel as the main 
+components plus a variety of first-class utilities and applications. After KDE was out, a lot of developers 
+turned their eyes towards the new environment and what it has to offer them. The KDE libraries are providing
+essential methods and classes that make all applications designed with them look similar and consistent, 
+so the user has the great advantage that he only has to get accustomed with an application's specific 
+usage, not with handling dialogs or buttons. Also, KDE programs integrate themselves into the desktop and 
+are able to interact with the file manager via drag'n drop, offer session management and many more, if all 
+features offered by the KDE libraries are used.  Both, the Qt toolkit and the KDE libraries, are implemented
+in the C++ programming language; therefore applications that make use of these libraries are also mostly 
+written in C++. In the following chapter, we'll make a short trip through the libraries to see what already
+is provided and how Qt and KDE applications are created in general. 
+</para>
+<para>
+Both, the Qt toolkit and the KDE libraries, are implemented in the C++ programming language; 
+therefore applications that make use of these libraries are also mostly written in C++. In the following 
+chapter, we'll make a short trip through the libraries to see what already is provided and how Qt and KDE 
+applications are created in general. 
+</para>
+
+<sect1 id="c2s1">
+<title>The Qt GUI Toolkit</title>
+<para>
+As said, the Qt library is a toolkit that offers graphical elements that are used for creating GUI 
+applications and are needed for X-Window programming. Additionally, the toolkit offers: 
+<itemizedlist>
+<listitem><para>A complete set of classes and methods ready to use even for non-graphical programming issues</para></listitem>
+<listitem><para>A good solution towards user interaction by virtual methods and the signal/slot mechanism</para></listitem>
+<listitem><para>A set of predefined GUI-elements, called "widgets", that can be used easily for creating the visible elements</para></listitem>
+<listitem><para>Additional completely pre-defined dialogs that are often used in applications such as progress and file dialogs</para></listitem>
+</itemizedlist>
+</para>
+<para>
+Therefore knowing the Qt classes is very essential, even if you only want to program KDE-applications. 
+To have an impression on the basic concept how GUI-applications are constructed and compiled, we'll first
+have a look at a sample Qt-only program; then we'll extend it to a KDE program.
+</para>
+
+<sect2 id="c2s1s1">
+<title>The first Qt Application</title>
+<para>
+As usual, programs in C++ have to contain a <function>main()</function> function, which is the starting point for application
+execution. As we want them to be graphically visible in windows and offering user interaction, 
+we first have to know, how they can show themselves to the user. For an example, we'll have a look
+at the first tutorial included with the Qt Online Reference Documentation and explain the basic execution
+steps; also why and how the application window appears: 
+<programlisting>
+#include &lt;qapplication.h>
+#include &lt;qpushbutton.h>
+
+int main( int argc, char **argv )
+{
+QApplication a( argc, argv );
+
+QPushButton hello( "Hello world!", 0 );
+hello.resize( 100, 30 );
+
+a.setMainWidget( &amp;hello );
+hello.show();
+return a.exec();
+}
+</programlisting>
+</para>
+<para>
+This application merely paints a window containing a button with "Hello world" as its text. As for 
+all Qt-based applications, you first have to create an instance of the class <classname>QApplication</classname>, represented by
+variable a. 
+</para>
+<para>
+Next, the program creates an instance of the class <classname>QPushButton</classname> called hello, this will be the button. 
+The constructor of hello gets a string as a parameter, which is the contents of the widget visible as 
+the buttons text.
+</para>
+<para>
+Then the <methodname>resize()</methodname> method is called on the hello button. This changes the default size a widget 
+(which is in this case the <classname>QPushButton</classname>) has when created to the length of 100 pixels and the height of 
+30 pixels. Finally, the setMainWidget() method is called for a and the show() method for hello. The 
+QApplication is finally executed by <methodname>a.exec()</methodname>, enters the main event loop and waits until it has to return 
+an integer value to the overlaying Operating System signaling that the application is exited. 
+</para>
+</sect2>
+
+<sect2 id="c2s1s2">
+<title>The Reference Documentation for Qt</title>
+<para>
+Now, let's have a quick look at the reference documentation of the Qt library. To do this, start 
+&kdevelop; and select "Qt" from the tree in the Documentation tab. The documentation browser opens 
+and shows you the start page of the Qt reference. This will be your first place to get information 
+about Qt, it's classes and the available functions they provide. Also, the above program is the first 
+that is included in the tutorials section. To get to the classes we want to have a look at, 
+<classname>QApplication</classname> and <classname>QPushButton</classname>, select "Alphabetical Class List" 
+and search for the according names. Follow either of them to have a look at the class documentation.
+</para>
+<para>
+Alternatively, you can use the online documentation from Trolltech's <ulink url="doc.trolltech.com">Qt Documentation</ulink>
+</para>
+<para>
+For <classname>QApplication</classname>, you will see the constructor and all other methods that this 
+class provides. If you follow a link, you will get more information about the usage and meaning of the 
+methods, which is very useful when you sometimes can't detect the correct use or want to have an example. 
+This also counts for the KDE library documentation, which uses a similar documentation type; therefore 
+this is almost all you have to know about using the class-references with the documentation browser. 
+</para>
+<sect3 id="c2s1s2s1">
+<title>Interpretation of the Sample</title>
+<para>
+Starting with <classname>QApplication</classname>, you will find all the methods used in our first example: 
+<itemizedlist>
+<listitem><para>the constructor <methodname>QApplication()</methodname></para></listitem>
+<listitem><para>the <methodname>setMainWidget()</methodname> method</para></listitem>
+<listitem><para>the <methodname>exec()</methodname> method</para></listitem>
+</itemizedlist>
+</para>
+<para>
+The interpretation why we use these methods is very simple: 
+<orderedlist>
+<listitem><para>Create an instance of the class <classname>QApplication</classname> with the constructor,
+so we can make use of the GUI elements provided by Qt</para></listitem>
+<listitem><para>Create a widget which will be the contents of our program window</para></listitem>
+<listitem><para>Set the widget as the main widget for a</para></listitem>
+<listitem><para>Execute the a instance of <classname>QApplication</classname></para></listitem>
+</orderedlist> 
+</para>
+<para>
+The second object of our program is the pushbutton, an instance of the class <classname>QPushButton</classname>. 
+From the two constructors given to create an instance, we used the second: this accepts a text, 
+which is the label contents of the button; here, it is the string "Hello world!". Then we called the 
+<methodname>resize()</methodname> method to change the size of the button according to it's contents - 
+the button has to be larger to make the string completely visible. 
+</para>
+<para>
+But what about the <methodname>show()</methodname> method? Now, you see that like most other widgets, 
+<classname>QPushButton</classname> is based on a single inheritance, the documentation says, Inherits 
+<classname>QButton</classname>. Follow the link to the <classname>QButton</classname> class. 
+This shows you a lot of other widgets that are inherited by <classname>QPushButton</classname>, 
+which we'll use later to explain the signal/slot mechanism. Anyway, the <methodname>show()</methodname> 
+method is not listed, therefore, it must be a method that is provided by inheritance as well. The class 
+that <classname>QButton</classname> inherits is <classname>QWidget</classname>. Just follow the link
+again, and you will see a whole bunch of methods that the QWidget class provides; including 
+the <methodname>show()</methodname> method. Now we understand what was done in the sample with the button: 
+<orderedlist>
+<listitem><para>Create an instance of <classname>QPushButton</classname>, use the second constructor to set the button text</para></listitem>
+<listitem><para>Resize the widget to its contents</para></listitem>
+<listitem><para>Set the widget as the main widget of the <classname>QApplication</classname> instance a</para></listitem>
+<listitem><para>Tell the widget to display itself on the screen by calling <methodname>show()</methodname>, an inherited method from <classname>QWidget</classname></para></listitem>
+</orderedlist>
+</para>
+<para>
+After calling the <methodname>exec()</methodname> method, the application is visible to the user, 
+showing a window with the button showing "Hello world!". Note: GUI programs behave somewhat differently
+than procedural applications. The main thing here is that the application enters a so-called 
+"main event loop". This means that the program has to wait for user actions and then react to it, also
+that for a Qt application, the program has to be in the main event loop to start the event handling.
+The next section tells you in short what this means to the programmer and what Qt offers to process
+user events.
+</para>
+<note><para>
+For already advanced users: The button has no parent declared in the constructor, therefore it
+is a top-level widget alone and runs in a local event loop which doesn't need to wait for the main
+event loop.  See the QWidget class documentation and The KDE Library Reference Guide</para>
+</note> 
+
+</sect3>
+</sect2>
+
+<sect2 id="c2s1s3">
+<title>User Interaction</title>
+<para>
+After reading the last sections, you should already know: 
+<itemizedlist>
+<listitem><para>What the Qt-library provides in terms of GUI applications</para></listitem>
+<listitem><para>How a program using Qt is created and</para></listitem>
+<listitem><para>Where and how to find information about classes that you want to use with the documentation browser</para></listitem>
+</itemizedlist> 
+</para>
+<para>
+Now we'll turn to give the application "life" by processing user events. Generally, the user has two ways
+to interact with a program: the mouse and the keyboard. For both ways, a graphical user interface has to
+provide methods that detect actions and methods that do something as a reaction to these actions.
+</para> 
+<para>
+The Window system therefore sends all interaction events to the according application. The 
+<classname>QApplication</classname> then sends them to the active window as a <classname>QEvent</classname>
+and the widgets themselves have to decide what to do with them. A widget receives the event and processes
+<methodname>QWidget::event(QEvent*)</methodname>, which then decides which event has been executed
+and how to react; <methodname>event()</methodname> is therefore the main event handler. Then, 
+the <methodname>event()</methodname> method passes the event to so-called event filters 
+that determine what happened and what to do with the event. If no filter signs responsible for the 
+event, the specialized event handlers are called. Thereby we can decide between: 
+<itemizedlist>
+<listitem><para>
+Keyboard events -- TAB and Shift-TAB keys:</para>
+<itemizedlist>
+<listitem><para><methodname>virtual void focusInEvent(QFocusEvent *)</methodname></para></listitem>
+<listitem><para><methodname>virtual void focusOutEvent(QFocusEvent *)</methodname></para></listitem>
+</itemizedlist>
+</listitem>
+
+<listitem><para>
+All other keyboard input:</para>
+<itemizedlist>
+<listitem><para><methodname>virtual void keyPressEvent(QKeyEvent *)</methodname></para></listitem>
+<listitem><para><methodname>virtual void keyReleaseEvent(QKeyEvent *)</methodname></para></listitem>
+</itemizedlist>
+</listitem>
+
+<listitem><para>
+Mouse movements:</para>
+<itemizedlist>
+<listitem><para><methodname>virtual void mouseMoveEvent(QMouseEvent *)</methodname></para></listitem>
+<listitem><para><methodname>virtual void enterEvent(QEvent *)</methodname></para></listitem>
+<listitem><para><methodname>virtual void leaveEvent(QEvent *)</methodname></para></listitem>
+</itemizedlist>
+</listitem>
+
+<listitem><para>
+Mouse button actions</para>
+<itemizedlist>
+<listitem><para><methodname>virtual void mousePressEvent(QMouseEvent *)</methodname></para></listitem>
+<listitem><para><methodname>virtual void mouseReleaseEvent(QMouseEvent *)</methodname></para></listitem>
+<listitem><para><methodname>virtual void mouseDoubleClickEvent(QMouseEvent *)</methodname></para></listitem>
+</itemizedlist>
+</listitem>
+
+<listitem><para>
+Window events containing the widget</para>
+<itemizedlist>
+<listitem><para><methodname>virtual void moveEvent(QMoveEvent *)</methodname></para></listitem>
+<listitem><para><methodname>virtual void resizeEvent(QResizeEvent *)</methodname></para></listitem>
+<listitem><para><methodname>virtual void closeEvent(QCloseEvent *)</methodname></para></listitem>
+</itemizedlist>
+</listitem>
+
+</itemizedlist>
+</para>
+<para>
+Note that all event functions are virtual and protected; therefore you can re-implement the events 
+that you need in your own widgets and specify how your widget has to react. <classname>QWidget</classname>
+also contains some other virtual methods that can be useful in your programs; anyway, it is sufficient
+to know about <classname>QWidget</classname> very well. 
+</para>
+</sect2>
+<sect2 id="c1s2s4">
+<title>Object Interaction by Signals and Slots</title>
+<para>
+Now we're coming to the most obvious advantages of the Qt toolkit: the signal/slot mechanism. 
+This offers a very handy and useful solution to object interaction, which usually is solved by 
+callback functions for X-Window toolkits. As this communication requires a strict programming and 
+sometimes makes user interface creation very difficult (as referred by the Qt documentation and explained 
+in Programming with Qt by K.Dalheimer), Troll Tech invented a new system where objects can emit signals
+that can be connected to methods declared as slots. For the C++ part of the programmer, he only has to know 
+some things about this mechanism: 
+<itemizedlist>
+<listitem><para>
+the class declaration of a class using signals/slots has to contain the Q_OBJECT macro at the beginning
+(without a semicolon); and have to be derved from the <classname>QObject</classname> class
+</para></listitem>
+<listitem><para>
+a signal can be emitted by the keyword emit, e.g. emit signal(parameters); from within any member function
+of a class that allows signals/slots
+</para></listitem>
+
+<listitem><para>
+all signals used by the classes that are not inherited have to be added to the class declaration by a
+signals section
+</para></listitem>
+<listitem><para>
+all methods that can be connected with a signal are declared in sections with the additional keyword slot,
+e.g. public slots: within the class declaration
+</para></listitem>
+<listitem><para>
+the meta-object compiler moc has to run over the header file to expand the macros and to produce the
+implementation (which is not necessary to know).  The output files of moc are compiled also by the C++ compiler.
+</para></listitem>
+</itemizedlist>
+</para>
+<para>
+Another way to use signals without deriving from <classname>QObject</classname> is to use the 
+<classname>QSignal</classname> class- see the reference documentation for more information and example
+usage. In the following, we assume you're deriving from <classname>QObject</classname>. 
+</para>
+<para>
+This way, your class is able to send signals anywhere and to provide slots that signals can connect 
+to. By using the signals, you don't have to care about who's receiving it- you just have to emit the 
+signal and whatever slot you want to connect to it can react to the emission. Also the slots can be used 
+as normal methods during implementation. 
+</para>
+<para>
+Now, to connect a signal to a slot, you have to use the <methodname>connect()</methodname> methods that 
+are provided by <classname>QObject</classname> or, where available, special methods that objects provide 
+to set the connection for a certain signal. 
+</para>
+
+<sect3 id="c1s2s4s1">
+<title>Sample Usage</title>
+<para>
+To explain the way how to set up object-interaction, we'll take our first example again and extend it by a
+simple connection:
+<programlisting>
+#include &lt;qapplication.h>
+#include &lt;qpushbutton.h>
+
+int main( int argc, char **argv )
+{
+QApplication a( argc, argv );
+
+QPushButton hello( "Hello world!" , 0);
+hello.resize( 100, 30 );
+
+a.setMainWidget( &amp;hello );
+
+QObject::connect(&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ));
+
+hello.show();
+return a.exec();
+}
+</programlisting>
+</para>
+<para>
+You see, the only addition to give the button more interaction is to use a <methodname>connect()
+</methodname> method: <methodname>connect(&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ))</methodname>;
+is all you have to add. What is the meaning now? The class declaration of QObject says about the 
+<methodname>connect()</methodname> method: 
+</para>
+<para><methodname>
+bool connect ( const QObject * sender, const char * signal, const QObject * receiver, const char * member ) 
+</methodname></para>
+<para>
+This means you have to specify a <classname>QObject</classname> instance pointer that is the sender 
+of the signal, meaning that it can emit this signal as first parameter; then you have to specify the signal 
+that you want to connect to. The last two parameters are the receiver object that provides a slot, followed 
+by the member function which actually is the slot that will be executed on signal emission. 
+</para>
+<para>
+By using signals and slots, your program's objects can interact with each other easily without explicitly 
+depending on the type of the receiver object. You will learn more about using this mechanism for productive 
+usage later in this handbook. More information about the Signals/Slot mechanism can also be found in 
+<ulink url="developer.kde.org/documentation/library/libraryref.html">The KDE Library Reference Guide</ulink> 
+and the <ulink url="doc.trolltech.com">Qt online reference</ulink>.
+</para>
+</sect3>
+</sect2>
+</sect1>
+
+<sect1 id="c2s3">
+<title>What KDE provides</title>
+<sect2 id="c2s3s1">
+<title>The KDE 3.x libraries</title>
+<para>
+The main KDE libraries you'll be using for creating your own KDE applications are:
+<itemizedlist>
+<listitem><para>
+the kdecore library, containing all classes that are non-visible elements to provide application functionality
+</para></listitem>
+<listitem><para>
+the kdeui library, containing user interface elements like menubars, toolbars, etc.
+</para></listitem>
+<listitem><para>
+the kfile library, containing the file selection dialogs
+</para></listitem>
+</itemizedlist>
+</para>
+<para>
+Additionally, for specific solutions KDE offers the following libraries:
+<itemizedlist>
+<listitem><para>
+the kdefx library, containing pixmaps, image effects the KStyle extension to QStyle
+</para></listitem>
+<listitem><para>
+the khtml library, containing KDE's html component
+</para></listitem>
+<listitem><para>
+the kjs library, containing KDE's Javascript support
+</para></listitem>
+<listitem><para>
+the kio library, containing low level access to network files
+</para></listitem>
+<listitem><para>
+the kparts library, containing support for re-usable embeddable extendable applications
+</para></listitem>
+</itemizedlist>
+</para>
+<para>
+Next we'll have a look at what is needed to turn out first Qt Application into a KDE one.
+</para>
+</sect2>
+<sect2 id="c2s3s2">
+<title>Example KDE Application</title>
+<para>
+In the following, you will see that writing a KDE application is not much more difficult than a 
+Qt application. For the use of KDE's features, you just have to use some other classes, and you're almost 
+done. As an example, we'll discuss the changed version of the Qt example from above: 
+<programlisting>
+#include &lt;kapplication.h>
+#include &lt;qpushbutton.h>
+
+int main( int argc, char **argv )
+{
+KApplication a( argc, argv );
+
+QPushButton hello( "Hello world!", 0 );
+hello.resize( 100, 30 );
+
+a.setTopWidget( &amp;hello );
+
+QObject::connect(&amp;hello, SIGNAL( clicked() ), &amp;a, SLOT( quit() ));
+
+hello.show();
+return a.exec();
+}
+</programlisting>
+</para> 
+<para>
+You see that first we have changed from <classname>QApplication</classname> to <classname>KApplication
+</classname>. Further, we had to change the previously used <methodname>setMainWidget()</methodname> method 
+to <methodname>setTopWidget</methodname>, which <classname>KApplication</classname> uses to set the main 
+widget. That's it! Your first KDE application is ready - you only have to tell the compiler the KDE 
+include path and the linker to link in the kdecore library with -lkdecore. 
+</para>
+<para>
+As you now know what at least the <function>main()</function> function provides generally and how an 
+application gets visible and allows user and object interaction, we'll go on with the next chapter, 
+where our first application is made with &kdevelop;.  There you can also test everything which was 
+mentioned before and see the effects. 
+</para>
+<para>
+What you should have looked into additionally until now is the reference documentation for Qt, 
+especially the <classname>QApplication</classname>, <classname>QWidget</classname> and <classname>QObject
+</classname> class and the kdecore library documentation for the <classname>KApplication</classname> class. 
+The <ulink url="developer.kde.org/documentation/library/libraryref.html">KDE Library Reference handbook</ulink> 
+also covers a complete description about the invocation of the <classname>QApplication</classname> and 
+<classname>KApplication</classname> constructors including command-line argument processing. 
+</para>
+</sect2>
+</sect1>
+
+</chapter>
+
+<chapter id="chapter3">
+<title>Creating New Applications</title>
+
+<sect1 id="c3s1">
+<title>The Application Wizard</title>
+<para>
+&kdevelop;'s Application Wizard is intended to let you start working on new project with &kdevelop;.  Therefore 
+all of your projects are first created by the wizard, and then you can start building them and extend what is 
+already provided by the source skeleton.  You can choose from several project types according to your project goals:
+<itemizedlist>
+<listitem><para>
+KDE Application Framework: includes source code for a complete frame structre of a standard KDE application
+</para></listitem>
+<listitem><para>
+QMake Project: Creates an application framework based around Trolltech's qmake configuration system
+</para></listitem>
+<listitem><para>
+Simple hello world program: Creates a C++ terminal based program with no GUI support
+</para></listitem>
+<listitem><para>
+A multitude of other program skeletons
+</para></listitem>
+</itemizedlist>
+</para>
+<para>
+In this chapter we'll see how the Application Wizard can be invoked and what has to be done to generate 
+a KDE application project.  This will also be the initial step of our coverage, where we will create the 
+initial version of a sample project.  For all other project types the steps are usualyl the same, but you 
+may not have as many options available.
+</para>
+</sect1>
+
+<sect1 id="c3s2">
+<title>Invoking the Application Wizard and Project Generation</title>
+<sect2 id="c3s2s1">
+<title>Starting the Application Wizard and the First Page</title>
+<para>
+To start with your KDE application, open &kdevelop;.  From the Project menu, selection New Project.  The 
+Application Wizard starts, and you'll see the selection tree on the first page containing available project 
+types that can be created.  Choose the C++ subtree, then KDE, then Application Framework.
+</para>
+<para>
+For our sample project, we are going to create the application KScribble.  Enter this as the application 
+name, and change any other information at the bottom of this screen that may need it.  Then, select Next.
+<screenshot><mediaobject><imageobject>
+<imagedata fileref="appwizard.png" format="PNG"/>
+</imageobject><textobject><phrase>Application Wizard</phrase></textobject>
+</mediaobject></screenshot>
+</para>
+</sect2>
+<sect2 id="c3s2s2">
+<title>Version control information</title>
+<para>
+On this screen you have the ability to decide if your project will use a version control system like
+CVS.  For our sample project we will not use source control, so make sure the selection box reads None 
+and select Next.
+</para>
+</sect2>
+<sect2 id="c3s2s3">
+<title>Header and Source Templates</title>
+<para>
+The next two pages show example headers that will go at the top of each of the header and source files that 
+you create using &kdevelop;.  For now, just leave these as the default, and select Next, then Finish.  If the
+Finish button is not activated, you haven't set all of the options correct.  Use the Back button to return
+to earlier menus and correct any mistakes.
+</para>
+</sect2>
+<sect2 id="c3s2s4">
+<title>Finishing Up</title>
+<para>
+Upon completion, the Application Wizard should close and the messages window should popup displaying
+information about the tasks that &kdevelop; is currently doing.  At the end of all of the tasks, you
+should see **** Success *****.  This means the application framework was successfully loaded.
+</para>
+</sect2>
+</sect1>
+
+<sect1 id="c3s3">
+<title>The First Build</title>
+<para>
+After our project is generated, we'll first make a trip through the source code to get a general understanding
+of how the application framework looks.  This won't only help us get started, but we'll know where to change 
+what in later steps.
+</para>
+<para>
+This chapter makes the assumption that you understand the basic navigation of &kdevelop;.  Consult the
+KDevelop User Manual for information if you need it.
+</para>
+<para>
+The Automake manager shows the project files as follows:
+<screenshot><mediaobject><imageobject>
+<imagedata fileref="kscribblefiles.png" format="PNG"/>
+</imageobject><textobject><phrase>Files in our project</phrase></textobject>
+</mediaobject></screenshot>
+</para>
+<para>
+Before diving into the sources, we'll let &kdevelop; build an run our new application.  To do this, select
+Build Project from the Build menu, or press F8.  The output window opens and displays output messages during
+the compilation phase.
+<programlisting>
+1 cd /home/caleb/kscribble &amp;&amp; WANT_AUTOCONF_2_5=1 WANT_AUTOMAKE_1_6=1 gmake k
+2 gmake all-recursive
+3 gmake[1]: Entering directory `/home/caleb/kscribble'
+4 Making all in doc
+5 gmake[2]: Entering directory `/home/caleb/kscribble/doc'
+6 Making all in .
+7 gmake[3]: Entering directory `/home/caleb/kscribble/doc'
+8 gmake[3]: Nothing to be done for `all-am'.
+9 gmake[3]: Leaving directory `/home/caleb/kscribble/doc'
+10 Making all in en
+11 gmake[3]: Entering directory `/home/caleb/kscribble/doc/en'
+12 /usr/local/kde3/bin/meinproc --check --cache index.cache.bz2 /home/caleb/kscribble/doc/en/index.docbook
+13 gmake[3]: Leaving directory `/home/caleb/kscribble/doc/en'
+14 gmake[2]: Leaving directory `/home/caleb/kscribble/doc'
+15 Making all in po
+16 gmake[2]: Entering directory `/home/caleb/kscribble/po'
+17 gmake[2]: Nothing to be done for `all'.
+18 gmake[2]: Leaving directory `/home/caleb/kscribble/po'
+19 Making all in src
+20 gmake[2]: Entering directory `/home/caleb/kscribble/src'
+21 source='main.cpp' object='main.o' libtool=no \
+22 depfile='.deps/main.Po' tmpdepfile='.deps/main.TPo' \
+23 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
+24 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include 
+   -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor 
+   -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings 
+   -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new 
+   -c -o main.o `test -f 'main.cpp' || echo '/home/caleb/kscribble/src/'`main.cpp
+25 /usr/lib/qt/bin/moc /home/caleb/kscribble/src/kscribble.h -o kscribble.moc
+26 source='kscribble.cpp' object='kscribble.o' libtool=no \
+27 depfile='.deps/kscribble.Po' tmpdepfile='.deps/kscribble.TPo' \
+28 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
+29 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include 
+   -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor 
+   -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings 
+   -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new 
+   -c -o kscribble.o `test -f 'kscribble.cpp' || echo '/home/caleb/kscribble/src/'`kscribble.cpp
+30 kscribble.cpp: In member function `void KScribble::setupActions()'
+31 kscribble.cpp:107: warning: unused variable `KAction*custom'
+32 /usr/lib/qt/bin/moc /home/caleb/kscribble/src/kscribbleview.h -o kscribbleview.moc
+33 source='kscribbleview.cpp' object='kscribbleview.o' libtool=no \
+34 depfile='.deps/kscribbleview.Po' tmpdepfile='.deps/kscribbleview.TPo' \
+35 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
+36 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include 
+   -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor 
+   -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -ansi 
+   -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new -c 
+   -o kscribbleview.o `test -f 'kscribbleview.cpp' || echo '/home/caleb/kscribble/src/'`kscribbleview.cpp
+37 kscribbleview.cpp: In member function `void KScribbleView::print(QPainter*,
+38  int, int)':
+39 kscribbleview.cpp:79: warning: unused parameter `QPainter*p'
+40 kscribbleview.cpp:79: warning: unused parameter `int height'
+41 kscribbleview.cpp:79: warning: unused parameter `int width'
+42 /usr/lib/qt/bin/moc /home/caleb/kscribble/src/pref.h -o pref.moc
+43 source='pref.cpp' object='pref.o' libtool=no \
+44 depfile='.deps/pref.Po' tmpdepfile='.deps/pref.TPo' \
+45 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
+46 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include 
+   -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor 
+   -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings 
+   -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new 
+   -c -o pref.o `test -f 'pref.cpp' || echo '/home/caleb/kscribble/src/'`pref.cpp
+47 /usr/local/kde3/bin/dcopidl /home/caleb/kscribble/src/kscribbleiface.h > kscribbleiface.kidl || 
+   ( rm -f kscribbleiface.kidl ; /bin/false )
+48 /usr/local/kde3/bin/dcopidl2cpp --c++-suffix cpp --no-signals --no-stub kscribbleiface.kidl
+49 source='kscribbleiface_skel.cpp' object='kscribbleiface_skel.o' libtool=no \
+50 depfile='.deps/kscribbleiface_skel.Po' tmpdepfile='.deps/kscribbleiface_skel.TPo' \
+51 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
+52 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include 
+   -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor 
+   -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings 
+   -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new 
+   -c -o kscribbleiface_skel.o `test -f 'kscribbleiface_skel.cpp' || 
+   echo '/home/caleb/kscribble/src/'`kscribbleiface_skel.cpp
+53 /bin/sh ../libtool --silent --mode=link --tag=CXX g++ -Wnon-virtual-dtor -Wno-long-long -Wundef -Wall 
+   -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -ansi -D_XOPEN_SOURCE=500 
+   -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new -o kscribble -R 
+   /usr/local/kde3/lib -R /usr/lib/qt/lib -R /usr/X11R6/lib -L/usr/X11R6/lib -L/usr/lib/qt/lib 
+   -L/usr/local/kde3/lib main.o kscribble.o kscribbleview.o pref.o kscribbleiface_skel.o -lkio 
+54 source='kscribble_client.cpp' object='kscribble_client.o' libtool=no \
+55 depfile='.deps/kscribble_client.Po' tmpdepfile='.deps/kscribble_client.TPo' \
+56 depmode=gcc3 /bin/sh /home/caleb/kscribble/admin/depcomp \
+57 g++ -DHAVE_CONFIG_H -I. -I/home/caleb/kscribble/src -I.. -I/usr/local/kde3/include 
+   -I/usr/lib/qt/include -I/usr/X11R6/include -DQT_THREAD_SUPPORT -D_REENTRANT -Wnon-virtual-dtor 
+   -Wno-long-long -Wundef -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings 
+   -ansi -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new 
+   -c -o kscribble_client.o `test -f 'kscribble_client.cpp' || echo 
+   '/home/caleb/kscribble/src/'`kscribble_client.cpp
+58 /bin/sh ../libtool --silent --mode=link --tag=CXX g++ -Wnon-virtual-dtor -Wno-long-long -Wundef 
+   -Wall -pedantic -W -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -ansi -D_XOPEN_SOURCE=500 
+   -D_BSD_SOURCE -Wcast-align -Wconversion -O2 -fno-exceptions -fno-check-new -o kscribble_client -R 
+   /usr/local/kde3/lib -R /usr/lib/qt/lib -R /usr/X11R6/lib -L/usr/X11R6/lib -L/usr/lib/qt/lib 
+   -L/usr/local/kde3/lib kscribble_client.o -lkdecore 
+59 gmake[2]: Leaving directory `/home/caleb/kscribble/src'
+60 gmake[2]: Entering directory `/home/caleb/kscribble'
+61 gmake[2]: Nothing to be done for `all-am'.
+62 gmake[2]: Leaving directory `/home/caleb/kscribble'
+63 gmake[1]: Leaving directory `/home/caleb/kscribble'
+64 *** Success ***
+</programlisting>
+</para>
+<para>
+As you can see, we've put line numbers in front of each line which won't appear on your output but it makes it
+easier to describe what is happening during the build.  First of all, gmake works recursively.  This means
+that it starts from the directory it is invoked and goes into the subdirectories first, one at a time, then
+returns to the directory it was started, processes it, then finishes.
+</para>
+<para>
+Our first line of interest is 24.  Notice on this line that g++, which is our C++ compiler, gets called by make
+to compile the first source code file in our project - in this case main.cpp.  Many extra command line options
+are also being used with the g++ compiler; some of which are defaults and some of which can be configured 
+via &kdevelop;.
+</para>
+<para>
+Before the next file (kscribble.cpp, line 29) is compiled, the moc (meta object compiler) is first
+invoked on kscribble.h (line 25).  This is because KScribble classes use signals/slots, so the 
+Q_OBJECT macro must be expanded, and the moc does this for us.  The resultant file, kscribble.moc, is
+used by kscribble.cpp via an #include statement inside of the file.
+</para>
+</sect1>
+
+<sect1 id="c3s4">
+<title>The source skeleton</title>
+<para>
+To conceptualize how a KDE application works, we'll first have a very close look at the source 
+skeleton already provided by the Application Wizard. As we already saw, we're having a set of source 
+and header files that build the initial code for the application and make it ready-to-run. Therefore, 
+the easiest way to explain the code is to follow the implementation line by line as it is processed 
+during executing the program until it enters the main event loop and is ready to accept user input. 
+Then, we'll have a look at the functionality that enables user interaction and how certain things work. 
+This is probably the best way to explain the framework and, as it is similar to almost all KDE 
+applications, will enable you to read source codes from other projects as well; additionally, you will 
+know where to change what part of the code to make your applications behave the way they are designed for. 
+</para>
+
+<sect2 id="c3s4s1">
+<title>The main() function</title>
+<para>
+As the application begins its execution with entering the <function>main()</function> function, 
+this will be the start for our code examination. The <function>main()</function> function of 
+KScribble is implemented in the file main.cpp and can also be found using the Class Browser 
+by selecting the "Global Functions" folder.
+<programlisting>
+1  int main(int argc, char **argv)
+2  {
+3      KAboutData about("kscribble", I18N_NOOP("KScribble"), version, description,
+4                       KAboutData::License_GPL, "(C) 2002 Your Name", 0, 0, "you@you.com");
+5      about.addAuthor( "Your Name", 0, "you@you.com" );
+6      KCmdLineArgs::init(argc, argv, &amp;about);
+7      KCmdLineArgs::addCmdLineOptions(options);
+8      KApplication app;
+9  
+10    // register ourselves as a dcop client
+11    app.dcopClient()->registerAs(app.name(), false);
+12 
+13    // see if we are starting with session management
+14    if (app.isRestored())
+15        RESTORE(KScribble)
+16    else
+17    {
+18        // no session.. just start up normally
+19        KCmdLineArgs *args = KCmdLineArgs::parsedArgs();
+20        if (args->count() == 0)
+21        {
+22            KScribble *widget = new KScribble;
+23            widget->show();
+24        }
+25        else
+26        {
+27            int i = 0;
+28            for (; i &lt; args->count(); i++)
+29            {
+30                KScribble *widget = new KScribble;
+31                widget->show();
+32                widget->load(args->url(i));
+33            }
+34        }
+35        args->clear();
+36    }
+37
+38    return app.exec();
+39 }
+</programlisting>
+</para> 
+<para>
+Now, what happens first is the usual creation of a <classname>KApplication</classname> object, but we've
+added some KDE methods that set program and author information for this application.
+</para>
+</sect2>
+<sect2>
+<title>User Application Start</title>
+
+<para>... (not written yet)</para>
+
+</sect2>
+<sect2>
+<title>The Constructor</title>
+<para>
+Let's have a look at the constructor and see how this instance is called
+<programlisting>
+1  KScribble::KScribble()
+2      : KMainWindow( 0, "KScribble" ),
+3        m_view(new KScribbleView(this)),
+4        m_printer(0)
+5  {
+6      // accept dnd
+7      setAcceptDrops(true);
+8  
+9      // tell the KMainWindow that this is indeed the main widget
+10     setCentralWidget(m_view);
+11 
+12     // then, setup our actions
+13     setupActions();
+14 
+15     // and a status bar
+16     statusBar()->show();
+17 
+18     // allow the view to change the statusbar and caption
+19     connect(m_view, SIGNAL(signalChangeStatusbar(const QString&amp;)),
+20             this,   SLOT(changeStatusbar(const QString&amp;)));
+21     connect(m_view, SIGNAL(signalChangeCaption(const QString&amp;)),
+22             this,   SLOT(changeCaption(const QString&amp;)));
+23
+24  }
+</programlisting>
+</para>
+<para>
+Notice that <classname>KScribble</classname> inherits the <classname>KMainWindow</classname> class - a 
+commonly used base class for KDE applications.  We initialize a class called <classname>KScribbleView</classname>
+as our central widget, create a <classname>KStatusBar</classname> via the <methodname>statusBar()</methodname>
+method (line 16), and connect some signals and slots together.
+</para>
+</sect2>
+</sect1>
+</chapter>
+
+
+<chapter id="chapter4">
+<title>Application View Design</title>
+<sect1 id="c4s1">
+<title>Introduction</title>
+<para>
+When developing an application with a graphical user interface, the main work takes place in 
+providing a so-called "view" for the application. A view generally is a widget that displays the data 
+of a document and provides methods to manipulate the document contents. This can be done by the user via
+the events he emits by the keyboard or the mouse; more complex operations are often processed by toolbars
+and menubars which interact with the view and the document. The statusbar then provides information about
+the document, view or application status. As an example, we look at how an editor is constructed and where
+we can find which part. 
+</para>
+<para>
+An editor generally is supposed to provide an interface to view and/or change the contents of a text
+document for the user. If you start Kate, you see the visual interface as the following: 
+<itemizedlist>
+<listitem><para>
+The menubar: providing complex operations as well as opening, saving and closing files and 
+exiting the application.
+</para></listitem>
+<listitem><para>
+The toolbar: offers icons which allow quicker access for most needed functions,
+</para></listitem>
+<listitem><para>
+The statusbar: displays the status of the cursor position by the current row and column,
+</para></listitem>
+<listitem><para>
+The view in the center of the window, displaying a document and offering a cursor connected to 
+the keyboard and the mouse to operate on the data.
+</para></listitem>
+</itemizedlist>
+</para>
+<para>
+Now it's easy to understand that a view is the most unique part of the application and the design
+of the view decides about the usability and acceptability of an application. This means that one of
+the first steps in development is to determine the purpose of the application and what kind of view
+design would match best to allow any user to work with the application with a minimum of work 
+learning how to handle the user interface. 
+</para>
+<para>
+For some purposes like text editing and displaying HTML files, views are provided by the Qt and KDE
+libraries; we will discuss certain aspects of these high-level widgets in the next section. 
+But for most applications new widgets have to be designed and implemented. It is that what makes a 
+programmer also a designer and where his abilities on creativity are asked. Nevertheless, you should 
+watch for intuitivity first. Remember, a lot of users won't accept an application that isn't:
+<itemizedlist>
+<listitem><para>
+graphically nice.
+</para></listitem>
+<listitem><para>
+offering a lot of features
+</para></listitem>
+<listitem><para>
+easy to handle
+</para></listitem>
+<listitem><para>
+fast to learn how to use it
+</para></listitem>
+</itemizedlist>
+</para>
+<para>
+Needless to say that stability is a major design goal. Nobody can prevent bugs, but a minimum can
+be reached at least by clever design goals and wide use of object-oriented design. C++ makes programming
+a joy if you know how to exploit it's capabilities- inheritance, information hiding and reusablitity of
+already existing code. 
+</para>
+<para>
+When creating a KDE or Qt project, you always have to have a view that inherits QWidget, either by 
+direct inheritance or because the library widget you want to use inherits QWidget. Therefore, the 
+Application Wizard already constructed a view that is an instance of a class yourappView, which 
+inherits QWidget already.
+</para>
+<para>
+This chapter therefore describes how to use library widgets for creating views of KDE or 
+Qt applications that are generated with &kdevelop;, then we look at the libraries and what kind of 
+views are already offered. 
+</para>
+</sect1>
+<sect1 id="c4s2">
+<title>Using Library Views</title>
+<para>
+When your application design has been set up, you first should look for already existing code that 
+will make your life a lot easier. A part of this search is to look for a widget that can be used as 
+a view or at least as a part of it; either directly or by inheritance. The KDE and Qt libraries already 
+contain a set of widgets that can be used for this purpose. To use them, you have two options: 
+<orderedlist>
+<listitem><para>
+Remove the new view class and create an instance of a library widget; then set this as the view,
+</para></listitem>
+<listitem><para>
+Change the inheritance of the provided view class to the class of the library widget to use.
+</para></listitem>
+</orderedlist>
+</para>
+<para>
+In either way, it is important to know that if the application framework is currently not linked 
+against the library that contains the widget, the linker will fail. After you decided to use a 
+certain widget, look for the library to link to; then open "Project"->"Options" from the &kdevelop; 
+menubar. Switch to the "Linker Options" page and look for the checkmarks indicating the libraries 
+that are currently used. If the library of your view widget is already checked, you can leave the 
+project options untouched and start doing the necessary changes due to your choice. If not, and the 
+linker options offer to add the library by a check box, check it and press "OK" to leave the project 
+options dialog again. In any other case, add the library in the edit line below with the -l option. 
+For libraries that your application has to search for before preparing the Makefiles by the 
+configure script on the end-user machine, add the according search macro to the configure.in file 
+located at the root directory of your project and add the macro to the edit line. Mind that you have 
+to run "Build"->"Autoconf and automake" and "Build"->"Configure" before the Makefiles contain the 
+correct expansion for the library macro. 
+</para>
+<para>
+Also, if the include files for the library to add are not in the current include path 
+(which can be seen by the -I options in the output window on "Make"), you have to add the path to the 
+Project Options dialog -"Compiler Options" page with the -I option or the according automake macro at 
+the edit line for "Additional Options". 
+</para>
+<sect2 id="c4s3s1">
+<title>Qt Views</title>
+<para>
+Looking at the first page of the Qt online documentation, you will find a link to 
+"Widget Screenshots" where you can have a look at how the widgets Qt contains look like. 
+These are ready to use and can be combined together to form complex widgets to create application 
+views or dialogs. In the following, we'll discuss some of these which are very usable for creating 
+application views, but keep in mind that the KDE libraries sometimes contain other widgets for the 
+same purpose; those will be reviewed in the next section. 
+</para>
+<para>
+Here are a set of hints for what purpose you could use which Qt component: 
+<orderedlist>
+<listitem><para>
+If your view area isn't big enough to display all your data, the user must be enabled to scroll
+over the document with bars on the left and bottom of the view. For this, Qt provides the class
+<classname>QScrollView</classname>, which offers a scrollable child area. As explained, you could 
+inherit your own widget from <classname>QScrollView</classname> or use an instance to manage your 
+document's view widget.
+</para></listitem> 
+<listitem><para>
+to create a ScrollView yourself, inherit the View widget from  <classname>QWidget</classname> 
+and add vertical and horizontal  <classname>QScrollBars </classname>. 
+(This is done by KDE`s KHTMLView widget.)
+</para></listitem> 
+<listitem><para> 
+For text processing, use <classname>QTextEdit</classname>. This class provides a complete 
+text editor widget that is already capable to cut, copy and paste text and is managed by a scrollview.
+</para></listitem> 
+<listitem><para> 
+Use <classname>QTable</classname> to display data that is arranged in a table. 
+As <classname>QTable</classname> is managed by scrollbars as well, it offers a good solution for 
+table calculation applications.
+</para></listitem> 
+<listitem><para> 
+To display two different widgets or two widget instances at the same time, use <classname>QSplitter
+</classname>. This allows to tile views by horizontal or vertical dividers. 
+KMail is a good example what this would look like- the main view is separated by a
+splitter vertically, the right window then is divided again horizontally.
+</para></listitem> 
+<listitem><para> 
+<classname>QListView</classname> displays information in a list and tree. 
+This is useful for creating file trees or any other hierarchical information you want to interact with.
+</para></listitem> 
+</orderedlist>
+</para>
+<para>
+You see that Qt alone offers a whole set of widgets which are ready to use so you don't have to invent
+new solutions if these match your needs. The sideffect when using standard widgets is that users already
+know how to handle them and only have to concentrate on the displayed data.
+</para>
+</sect2>
+<sect2 id="c4s3s2">
+<title>KDE Views</title>
+<para>
+The KDE libraries were invented to make designing applications for the K Desktop Environment easier
+and capable of more functionality than what Qt alone is offering. The kdeui library offers: 
+<orderedlist>
+<listitem><para>
+KListView: a more powerful version of <classname>QListView</classname>
+</para></listitem>
+<listitem><para>
+KIconView: a graphical viewer of icon files
+</para></listitem>
+</orderedlist>
+</para>
+<para>
+The khtml library, on the other hand, offers a complete HTML-interpreting widget that is ready to use.
+It is scrollable already, so you don't even have to take care for that. A possible use could be to
+integrate it as a preview widget for an HTML editor; used by applications such as Konqueror to display HTML files. 
+</para>
+</sect2>
+</sect1>
+<sect1 id="c4s4">
+<title>Creating your own Views</title>
+<para>
+Not yet written
+</para>
+</sect1>
+</chapter>
+
+<chapter id="chapter5">
+<title>Configuring Menubars and Toolbars</title>
+<sect1 id="c5s1">
+<title>Introduction</title>
+<para>
+Menubars and toolbars are one of the most important parts of an application to provide methods to
+work with a document structure. As a general rule, you should make all functions available by the menubar.
+Those methods that should not be available at a current stage of the application process should be
+disabled. 
+</para>
+<para>
+Further, an application can only contain one menubar, but several toolbars. 
+Toolbars on the other hand should contain only the most frequently used commands by pixmap 
+icons or provide quick access methods like combos to select values.
+</para>
+</sect1>
+<sect1 id="c5s2">
+<title>How does it work?</title>
+<para>
+Our application inherits the <classname>KMainWindow</classname> class, which automatically handles creating
+a menu bar and tool bars for us.  In the <methodname>KScribble::setupActions()</methodname> method there is
+a call to <methodname>KMainWindow::createGUI()</methodname>.  This method loads a resource file, in this
+case kscribbleui.rc, to initialize menus at startup.  Note that kscribbleui.rc is listed as one of the
+project files in the Automake Manager.  Opening that file up reveals this:
+<programlisting>
+1 &lt;!DOCTYPE kpartgui SYSTEM "kpartgui.dtd">
+2 &lt;kpartgui name="kscribble" version="1">
+3 &lt;MenuBar>
+4   &lt;Menu name="custom">&lt;text>C&amp;ustom&lt;/text>
+5     &lt;Action name="custom_action" />
+6   &lt;/Menu>
+7 &lt;/MenuBar>
+8 &lt;/kpartgui>
+</programlisting>
+</para>
+<para>
+Explanation...
+</para>
+<para>
+Another way to modify the contents of the menu and tool bars is to directly manipulate them through the
+methods provided by their class.  For example, the <methodname>menuBar()</methodname> method returns the
+<classname>KMenuBar</classname> widget that the menubar for our program.  Looking at the documentation for
+<classname>KMenuBar</classname> and its inheritor class <classname>QMenuBar</classname>, you will find
+a large number of <methodname>insertItem()</methodname> methods which allow you to add items to the
+menu bar.
+</para>
+<para>
+<classname>KMainWindow</classname>'s methods <methodname>statusBar()</methodname> and <methodname>
+toolBar()</methodname> will also provide you with applicable widgets.
+</para>
+</sect1>
+<sect1 id="c5s3">
+<title>Keyboard Accelerator Configuration</title>
+<para>
+A very professional thing you should always add to your application are keyboard accelerators.
+Those are mainly used by experienced users that want to work fast with their applications and 
+are willing to learn shortcuts. For this, the KDE libraries provide the class <classname>
+KAction</classname>, which provides the keyboard accelerator keys and access to global configured
+standard keyboard accelerators. 
+</para>
+<para>
+By default, frame applications generated by &kdevelop; only use standard keyboard accelerators
+such as F1 for accessing online-help, Ctrl+N for New File etc.
+</para>
+<para>
+If your application contains a lot of accelerators, you should make them configurable
+by an Options-menu; either it could be combined with other application configuration in a QWidget
+or stand alone. The KDE library already provides a <classname>KKeyChooser</classname>
+for use in tab dialogs, whereas <classname>KKeyDialog</classname> provides a ready-to use 
+key-configuration dialog. 
+</para>
+
+</sect1>
+</chapter>
+
+<!-- 
+<chapter id="chapter6">
+<title>Other Features</title>
+</chapter>
+
+<chapter id="chapter7">
+<title>Printing Support</title>
+</chapter>
+-->
+<chapter id="chapter8">
+<title>Help Functions</title>
+<sect1 id="c8s1">
+<title>Introduction</title>
+<para>
+A very important part of the development process is to provide help functionality to the user
+wherever possible. Most developers tend to delay this, but you should remember that a normal user
+isn't necessarily a Unix expert. He may come from the the dark side of computer software usage offering
+all sweets that a user may need to work himself into using an application even without ever touching the
+manuals. Therefore, the KDE and Qt library provide all means usually considered making an application
+professional in the eyes of the normal user by help functions that are ready to use. 
+Within the application, those are:</para>
+<itemizedlist>
+<listitem><para>Tool-Tips</para></listitem>
+<listitem><para>Statusbar help</para></listitem>
+<listitem><para>What's this...? buttons</para></listitem>
+</itemizedlist>
+<para>
+Additionally, the application should provide means to access a HTML-based online manual directly
+using the standard help key F1.  This context based help system is provided automatically through the
+<classname>KMainWindow</classname> class, though as the author you must provide the content.
+</para>
+<para>
+As &kdevelop; also offers all types of help as well as the KDE framework generated by the 
+application wizard already contains support for this, this chapter will help you find out where 
+and how to add your help functionality. </para>
+<para>
+During the development of your application you should try to be consistent whatever you're doing;
+therefore you should do the necessary steps directly while extending the code. This will prevent you
+from diving into the code again and figuring out what your application does or what you intended by 
+certain parts of the code. 
+</para>
+</sect1>
+
+<sect1 id="c8s2">
+<title>Tool-Tips</title>
+<para>
+A very easy means of providing help are tool-tips. Those are small help messages popping up while
+the user moves the mouse over a widget that provides a tool-tip and disappears when the mouse moves away.
+The most popular usage of tool-tips is made in toolbars where your tool-tips should be kept as small
+as possible because toolbars can be configured to display their contents in various ways: 
+either displaying the button, button with text on the right, button with text below, text only. 
+This possibility should be made configurable by the user, but isn't a must-be. The text is shown
+as a tool-tip anyway and a toolbar usually consists of buttons and other widgets like lineedits and 
+combo boxes. For a complete reference, see the <classname>KToolBar</classname> class reference located 
+in the kdeui library. 
+</para>
+<para>
+As an example, we have a look at the "New File" button in a generic application:
+</para>
+<para>
+There, the part i18n("New File") provides a tool-tip message. It is enclosed by the i18n()
+macro provided by kapp.h to translate the tool-tip towards the currently selected language. 
+</para>
+<para>
+Tool-tips can also be added to any custom widget by using the <classname>QToolTip</classname> 
+provided by Qt. An example of that would be:
+</para>
+</sect1>
+<sect1 id="c8s3">
+<title>Extending the Statusbar</title>
+<para>
+As the applications that inherit <classname>KMainWindow</classname> contain a statusbar as well, 
+it also offers a set of statusbar messages already for all menu and toolbar items. A statusbar 
+help message is a short message that extends the meaning of a tool-tip or can be seen as a replacement 
+for a tool-tip over menubar items and is (as the name suggests) displayed in the statusbar when the user 
+enters a menu and highlights the menu entry.
+</para>
+</sect1>
+<sect1 id="c8s4">
+<title>The <guibutton>What's This...?</guibutton> Button</title>
+<para>
+The <guibutton>What's This...?</guibutton> button provides help windows with the intention 
+that the user wants to get help about a certain widget within the working view or a toolbar item. 
+It is placed in the toolbar and gets activated once the user hits the button. The cursor changes 
+to an arrow cursor with a question mark like the button itself looks like. The the user can press on 
+a visible widget item and gets a help window. As an exercise, you could try this behavior with the 
+<guibutton>What's this...?</guibutton> button within &kdevelop;. 
+</para>
+<para>
+To add the What's This...? help to one of your widgets, use the static method 
+<methodname>QWhatsThis::add(QWidget *widget, const QString &amp;text)</methodname> 
+</para>
+</sect1>
+</chapter>
+
+<chapter id="chapter9">
+<title>Documentation</title>
+<sect1 id="c9s1">
+<title>Introduction</title>
+<para>
+Due to the fact that projects often lack a complete set of user documentation, 
+all &kdevelop; projects contain a pre-build handbook that can be easily adapted; 
+therefore fulfiling another goal of KDE: providing enough online-help to support users that 
+are not familiar with an application. This chapter therefore introduces you on how to extend 
+the provided documentation template and what you have to do to make it available to the user. 
+</para>
+</sect1>
+<sect1 id="c9s2">
+<title>User Documentation</title>
+<para>
+The documentation for your project lies in projectdir/doc/en, or perhaps another directory if English
+isn't your native language.  Therein lies a file, index.docbook, in which the documentation is stored.
+The format for editing this file is explained on 
+<ulink url="http://i18n.kde.org/doc/markup/">KDE's documentation website</ulink>.
+</para>
+</sect1>
+<sect1 id="c9s3">
+<title>Programmer Documentation</title>
+<para>
+Another important part of the documentation is including a descriptive help for your class interfaces. 
+This will allow you and other programmers to use your classes by reading the HTML class documentation 
+that can be created with KDoc. &kdevelop; supports the use of KDoc completely by creating the 
+KDE-library documentation, also your application frameworks are already documented. To work yourself 
+into the provided code, it would be a good start to read the included documentation online. 
+The following describes what to do to get the API documentation, where &kdevelop; helps you add it 
+and what kind of special tags KDoc provides.
+</para>
+</sect1>
+</chapter>
+
+<chapter id="chapter10">
+<title>Internationalization</title>
+<sect1 id="c10s1">
+<title>Introdction</title>
+<para>
+i18n is an internationalization system that is used to offer internationalized versions of an 
+application or project. The difficulty with writing applications is that they only support the 
+language they originally are composed with; visually this can be seen on labels, menu entries and the 
+like. The goal of the internationalization is to provide applications and library functions in the 
+language of the user; therefore enabling users that are not native speakers the original language to make 
+use of the provided functionality and feel more comfortable.
+</para>
+</sect1>
+<!-- 
+<sect1 id="c10s2">
+<title>How KDE support Internationalization</title>
+<para>
+</para>
+</sect1> -->
+</chapter>
+<!-- 
+<chapter id="chapter11">
+<title>Finding Errors</title>
+</chapter>
+
+<chapter id="chapter12">
+<title>Licensing</title>
+</chapter>
+
+<chapter id="chapter13">
+<title>References</title>
+</chapter>
+-->
+<chapter id="credits">
+<title>Credits</title>
+
+<para>
+(... to be written ...)
+</para>
+
+<!--CREDITS_FOR_TRANSLATORS-->
+
+</chapter> <!-- credits -->
+
+<appendix id="bibliography">
+<title>Bibliography</title>
+<bibliography>
+
+<biblioentry>
+<title><ulink url="info://make/Top">GNU Make Manual</ulink></title>
+<authorgroup>
+<author><firstname>Richard M.</firstname><surname>Stallman</surname></author>
+<author><firstname>Roland</firstname><surname>McGrath</surname></author>
+</authorgroup>
+</biblioentry>
+
+<biblioentry>
+<title><ulink url="info://automake/Top">GNU Automake</ulink></title>
+<authorgroup>
+<author><firstname>David</firstname><surname>MacKenzie</surname></author>
+<author><firstname>Tom</firstname><surname>Tromey</surname></author>
+</authorgroup>
+</biblioentry>
+
+<biblioentry>
+<title><ulink url="info://autoconf/Top">GNU Autoconf</ulink></title>
+<authorgroup>
+<author><firstname>David</firstname><surname>MacKenzie</surname></author>
+<author><firstname>Ben</firstname><surname>Elliston</surname></author>
+</authorgroup>
+</biblioentry>
+
+<biblioentry>
+<title><ulink url="info://gcc/Top">Using the GNU Compiler Collection</ulink></title>
+<author><firstname>Richard M.</firstname><surname>Stallman</surname></author>
+</biblioentry>
+
+<biblioentry>
+<title><ulink url="info://libtool/Top">GNU Libtool</ulink></title>
+<authorgroup>
+<author><firstname>Gordon</firstname><surname>Matzigkeit</surname></author>
+<author><firstname>Alexandre</firstname><surname>Oliva</surname></author>
+<author><firstname>Thomas</firstname><surname>Tanner</surname></author>
+<author><firstname>Gary V.</firstname><surname>Vaughan</surname></author>
+</authorgroup>
+</biblioentry>
+
+<biblioentry>
+<title>GNU Autoconf, Automake, and Libtool</title>
+<edition>1st edition</edition>
+<pubdate>October 2000</pubdate>
+<authorgroup>
+<author><firstname>Gary V.</firstname><surname>Vaughan</surname></author>
+<author><firstname>Ben</firstname><surname>Elliston</surname></author>
+<author><firstname>Tom</firstname><surname>Tromey</surname></author>
+<author><firstname>Ian Lance</firstname><surname>Taylor</surname></author>
+</authorgroup>
+<publisher><publishername>New Riders Publishing</publishername></publisher>
+<isbn>ISBN 1578701902</isbn>
+</biblioentry>
+
+
+<biblioentry>
+<title>Advanced Programming in the UNIX(R) Environment</title>
+<edition>1st edition</edition>
+<pubdate>June 1992</pubdate>
+<author><firstname>W. Richard</firstname><surname>Stevens</surname></author>
+<publisher><publishername>Addison-Wesley Pub Co</publishername></publisher>
+<isbn>ISBN 0201563177</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Thinking in C++, Volume 1: Introduction to Standard C++</title>
+<edition>2nd Edition</edition>
+<pubdate>April 15, 2000</pubdate>
+<author><firstname>Bruce</firstname><surname>Eckel</surname></author>
+<publisher><publishername>Prentice Hall</publishername></publisher>
+<isbn>ISBN 0139798099</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Open Source Development with CVS</title>
+<edition>2nd Edition</edition>
+<pubdate>October 12, 2001</pubdate>
+<authorgroup>
+<author><firstname>Karl</firstname><surname>Fogel</surname></author>
+<author><firstname>Moshe</firstname><surname>Bar</surname></author>
+</authorgroup>
+<publisher><publishername>The Coriolis Group</publishername></publisher>
+<isbn>ISBN 158880173X</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Programming PHP</title>
+<edition>1st edition</edition>
+<pubdate>March 2002</pubdate>
+<authorgroup>
+<author><firstname>Rasmus</firstname><surname>Lerdorf</surname></author>
+<author><firstname>Kevin</firstname><surname>Tatroe</surname></author>
+</authorgroup>
+<publisher><publishername>O'Reilly &amp; Associates</publishername></publisher>
+<isbn>ISBN 1565926102</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Programming Python</title>
+<edition>2nd Edition</edition>
+<pubdate>March 2001</pubdate>
+<author><firstname>Mark</firstname><surname>Lutz</surname></author>
+<publisher><publishername>O'Reilly &amp; Associates</publishername></publisher>
+<isbn>ISBN 0596000855</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Gui Programming With Python : Using the Qt Toolkit</title>
+<edition>Bk&amp;Cd-r edition</edition>
+<pubdate>January 2002</pubdate>
+<author><firstname>Boudewijn</firstname><surname>Rempt</surname></author>
+<publisher><publishername>Opendocs Llc</publishername></publisher>
+<isbn>ISBN 0970033044</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Programming Perl</title>
+<subtitle>The Camel book</subtitle>
+<edition>3rd Edition</edition>
+<pubdate>July 2000</pubdate>
+<authorgroup>
+<author><firstname>Larry</firstname><surname>Wall</surname></author>
+<author><firstname>Tom</firstname><surname>Christiansen</surname></author>
+<author><firstname>Jon</firstname><surname>Orwant</surname></author>
+</authorgroup>
+<publisher><publishername>O'Reilly &amp; Associates</publishername></publisher>
+<isbn>ISBN 0596000278</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Learning Perl</title>
+<subtitle>The Lama book</subtitle>
+<edition>3rd Edition</edition>
+<pubdate>July 15, 2001</pubdate>
+<authorgroup>
+<author><firstname>Randal L.</firstname><surname>Schwartz</surname></author>
+<author><firstname>Tom</firstname><surname>Phoenix</surname></author>
+</authorgroup>
+<publisher><publishername>O'Reilly &amp; Associates</publishername></publisher>
+<isbn>ISBN 0596001320</isbn>
+</biblioentry>
+
+</bibliography>
+
+&underFDL;
+
+
+</appendix>
+
+</book>
diff --git a/doc/kde_app_devel/kscribblefiles.png b/doc/kde_app_devel/kscribblefiles.png
new file mode 100644
index 00000000..1591b3cf
--- /dev/null
+++ b/doc/kde_app_devel/kscribblefiles.png
diff --git a/doc/kdearch/Makefile.am b/doc/kdearch/Makefile.am
new file mode 100644
index 00000000..171f575c
--- /dev/null
+++ b/doc/kdearch/Makefile.am
@@ -0,0 +1,2 @@
+KDE_LANG = en
+KDE_DOCS = AUTO
diff --git a/doc/kdearch/affine-general.png b/doc/kdearch/affine-general.png
new file mode 100644
index 00000000..8e59d5e5
--- /dev/null
+++ b/doc/kdearch/affine-general.png
diff --git a/doc/kdearch/affine-rotate.png b/doc/kdearch/affine-rotate.png
new file mode 100644
index 00000000..7192ed9c
--- /dev/null
+++ b/doc/kdearch/affine-rotate.png
diff --git a/doc/kdearch/affine-scale.png b/doc/kdearch/affine-scale.png
new file mode 100644
index 00000000..0b52fd4c
--- /dev/null
+++ b/doc/kdearch/affine-scale.png
diff --git a/doc/kdearch/affine-shear.png b/doc/kdearch/affine-shear.png
new file mode 100644
index 00000000..1ed5fbd8
--- /dev/null
+++ b/doc/kdearch/affine-shear.png
diff --git a/doc/kdearch/affine-translate.png b/doc/kdearch/affine-translate.png
new file mode 100644
index 00000000..87265e30
--- /dev/null
+++ b/doc/kdearch/affine-translate.png
diff --git a/doc/kdearch/brushstyles.png b/doc/kdearch/brushstyles.png
new file mode 100644
index 00000000..b6df50ca
--- /dev/null
+++ b/doc/kdearch/brushstyles.png
diff --git a/doc/kdearch/canvas.png b/doc/kdearch/canvas.png
new file mode 100644
index 00000000..dd83dae9
--- /dev/null
+++ b/doc/kdearch/canvas.png
diff --git a/doc/kdearch/capflat.png b/doc/kdearch/capflat.png
new file mode 100644
index 00000000..5e1c92ce
--- /dev/null
+++ b/doc/kdearch/capflat.png
diff --git a/doc/kdearch/capround.png b/doc/kdearch/capround.png
new file mode 100644
index 00000000..0e66eaac
--- /dev/null
+++ b/doc/kdearch/capround.png
diff --git a/doc/kdearch/capsquare.png b/doc/kdearch/capsquare.png
new file mode 100644
index 00000000..35724a72
--- /dev/null
+++ b/doc/kdearch/capsquare.png
diff --git a/doc/kdearch/index.docbook b/doc/kdearch/index.docbook
new file mode 100644
index 00000000..b1a40091
--- /dev/null
+++ b/doc/kdearch/index.docbook
@@ -0,0 +1,3337 @@
+<?xml version="1.0" ?>
+<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.1.2-Based Variant V1.1//EN" "dtd/kdex.dtd" [
+  <!ENTITY % addindex "INCLUDE">
+  <!ENTITY % English "INCLUDE" > <!-- change language only here -->
+]>
+
+<book lang="&language;">
+
+<bookinfo>
+<title>KDE Architecture Overview</title>
+
+<date></date>
+<releaseinfo></releaseinfo>
+
+<authorgroup>
+<author>
+<firstname>Bernd</firstname>
+<surname>Gehrmann</surname>
+<affiliation><address><email>bernd@kdevelop.org</email></address></affiliation>
+</author>
+</authorgroup>
+
+<copyright>
+<year>2001</year>
+<year>2002</year>
+<holder>Bernd Gehrmann</holder>
+</copyright>
+
+<legalnotice>&FDLNotice;</legalnotice>
+
+<abstract>
+<para>This documentation gives an overview of the KDE Development Platform</para>
+</abstract>
+
+<keywordset>
+<keyword>KDE</keyword>
+<keyword>architecture</keyword>
+<keyword>development</keyword>
+<keyword>programming</keyword>
+</keywordset>
+
+</bookinfo>
+
+<chapter id="structure">
+<title>Library structure</title>
+
+<simplesect id="structure-byname">
+<title>Libraries by name</title>
+
+<variablelist>
+
+<varlistentry>
+<term><ulink url="kdeapi:kdecore/index.html">kdecore</ulink></term>
+<listitem><para>
+The kdecore library is the basic application framework for every KDE based
+program. It provides access to the configuration system, command line
+handling, icon loading and manipulation, some special kinds inter-process
+communication, file handling and various other utilities.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><ulink url="kdeapi:kdeui/index.html">kdeui</ulink></term>
+<listitem><para>
+The <literal>kdeui</literal> library provides many widgets and standard
+dialogs which Qt doesn't have or which have more features than their Qt
+counterparts. It also includes several widgets which are subclassed
+from Qt ones and are better integrated with the KDE desktop by
+respecting user preferences.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><ulink url="kdeapi:kio/index.html">kio</ulink></term>
+<listitem><para>
+The <literal>kio</literal> library contains facilities for asynchronous,
+network transparent I/O and access to mimetype handling. It also provides the
+KDE file dialog and its helper classes.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><ulink url="kdeapi:kjs/index.html">kjs</ulink></term>
+<listitem><para>
+The <literal>kjs</literal> library provides an implementation of JavaScript.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><ulink url="kdeapi:khtml/index.html">khtml</ulink></term>
+<listitem><para>
+The <literal>khtml</literal> library contains the KHTML part, a HTML browsing
+widget, DOM API and parser, including interfaces to Java and JavaScript.
+</para></listitem>
+</varlistentry>
+
+</variablelist>
+
+</simplesect>
+
+
+<simplesect id="structure-grouped">
+<title>Grouped classes</title>
+
+<para>
+Core application skeleton - classes needed by almost every application.
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara>
+<title><ulink url="kdeapi:kdecore/KApplication">KApplication</ulink></title>
+<para>
+Initializes and controls a KDE application.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara>
+<title><ulink url="kdeapi:kdecore/KUniqueApplication">KUniqueApplication</ulink></title>
+<para>
+Makes sure only one instance of an application can run simultaneously.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KAboutData">KAboutData</ulink></title>
+<para>
+Holds information for the about box.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KCmdLineArgs">KCmdLineArgs</ulink></title>
+<para>
+Command line argument processing.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Configuration settings - access to KDE's hierarchical configuration
+database, global settings and application resources.
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KConfig">KConfig</ulink></title>
+<para>
+Provides access to KDE's configuration database.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KSimpleConfig">KSimpleConfig</ulink></title>
+<para>
+Access to simple, non-hierarchical configuration files.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KDesktopFile">KDesktopFile</ulink></title>
+<para>
+Access to <literal>.desktop</literal> files.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KGlobalSettings">KGlobalSettings</ulink></title>
+<para>
+Convenient access to not application-specific settings.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+File and URL handling - decoding of URLs, temporary files etc.
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KURL">KURL</ulink></title>
+<para>
+Represents and parses URLs.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KTempFile">KTempFile</ulink></title>
+<para>
+Creates unique files for temporary data.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KSaveFile">KSaveFile</ulink></title>
+<para>
+Allows to save files atomically.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Interprocess communication - DCOP helper classes and subprocess invocation.
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KProcess">KProcess</ulink></title>
+<para>
+Invokes and controls child processes.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KShellProcess">KShellProcess</ulink></title>
+<para>
+Invokes child processes via a shell.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdesu/PtyProcess">PtyProcess</ulink></title>
+<para>
+Communication with a child processes through a pseudo terminal.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KIPC">KIPC</ulink></title>
+<para>
+Simple IPC mechanism using X11 ClientMessages.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:dcop/DCOPClient">DCOPClient</ulink></title>
+<para>
+DCOP messaging.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KDCOPPropertyProxy">KDCOPPropertyProxy</ulink></title>
+<para>
+A proxy class publishing Qt properties through DCOP.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KDCOPActionProxy">KDCOPActionProxy</ulink></title>
+<para>
+A proxy class publishing a DCOP interface for actions.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Utility classes - memory management, regular expressions, string manipulation,
+random numbers
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KRegExp">KRegExp</ulink></title>
+<para>
+POSIX regular expression matching.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KStringHandler">KStringHandler</ulink></title>
+<para>
+An extravagant interface for string manipulation.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KZoneAllocator">KZoneAllocator</ulink></title>
+<para>
+Efficient memory allocator for large groups of small objects.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KRandomSequence">KRandomSequence</ulink></title>
+<para>
+Pseudo random number generator.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Keyboard accelerators - classes helping to establish consistent key bindings
+throughout the desktop.
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KAccel">KAccel</ulink></title>
+<para>
+Collection of keyboard shortcuts.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KStdAccel">KStdAccel</ulink></title>
+<para>
+Easy access to the common keyboard shortcut keys.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KGlobalAccel"></ulink></title>
+<para>
+Collection of system-wide keyboard shortcuts.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Image processing - icon loading and manipulating.
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KIconLoader">KIconLoader</ulink></title>
+<para>
+Loads icons in a theme-conforming way.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KIconTheme">KIconTheme</ulink></title>
+<para>
+Helper classes for KIconLoader.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KPixmap">KPixmap</ulink></title>
+<para>
+A pixmap class with extended dithering capabilities.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KPixmapEffect">KPixmapEffect</ulink></title>
+<para>
+Pixmap effects like gradients and patterns.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KPixmapIO">KPixmapIO</ulink></title>
+<para>
+Fast <classname>QImage</classname> to <classname>QPixmap</classname> conversion.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Drag and Drop - drag objects for colors and URLs.
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KURLDrag">KURLDrag</ulink></title>
+<para>
+A drag object for URLs.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KColorDrag">KColorDrag</ulink></title>
+<para>
+A drag object for colors.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KMultipleDrag">KMultipleDrag</ulink></title>
+<para>
+Allows to construct drag objects from several others.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Auto-Completion
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KCompletion">KCompletion</ulink></title>
+<para>
+Generic auto-completion of strings.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kio/KURLCompletion">KURLCompletion</ulink></title>
+<para>
+Auto-completion of URLs.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kio/KShellCompletion">KShellCompletion</ulink></title>
+<para>
+Auto-completion of executables.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Widgets - widget classes for list views, rules, color selection etc.
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KListView">KListView</ulink></title>
+<para>
+A variant of <classname>QListView</classname> that honors KDE's system-wide settings.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KListView">KListBox</ulink></title>
+<para>
+A variant of <classname>QListBox</classname> that honors KDE's system-wide settings.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KListView">KIconView</ulink></title>
+<para>
+A variant of <classname>QIconView</classname> that honors KDE's system-wide settings.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KListView">KLineEdit</ulink></title>
+<para>
+A variant of <classname>QLineEdit</classname> with completion support.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KComboBox">KComboBox</ulink></title>
+<para>
+A variant of <classname>QComboBox</classname> with completion support.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KFontCombo">KFontCombo</ulink></title>
+<para>
+A combo box for selecting fonts.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KColorCombo">KColorCombo</ulink></title>
+<para>
+A combo box for selecting colors.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KColorButton">KColorButton</ulink></title>
+<para>
+A button for selecting colors.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KURLCombo">KURLCombo</ulink></title>
+<para>
+A combo box for selecting file names and URLs.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kfile/KURLRequester">KURLRequester</ulink></title>
+<para>
+A line edit for selecting file names and URLs.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KRuler">KRuler</ulink></title>
+<para>
+A ruler widget.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink
+url="kdeapi:kdeui/KAnimWidget">KAnimWidget</ulink></title>
+<para>
+animations.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KNumInput">KNumInput</ulink></title>
+<para>
+A widget for inputting numbers.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KPasswordEdit">KPasswordEdit</ulink></title>
+<para>
+A widget for inputting passwords.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Dialogs - full-featured dialogs for file, color and font selection.
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kfile/KFileDialog">KFileDialog</ulink></title>
+<para>
+A file selection dialog.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KColorDialog">KColorDialog</ulink></title>
+<para>
+A color selection dialog.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KFontDialog">KFontDialog</ulink></title>
+<para>
+A font selection dialog.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kfile/KIconDialog">KIconDialog</ulink></title>
+<para>
+An icon selection dialog.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KKeyDialog">KKeyDialog</ulink></title>
+<para>
+A dialog for editing keyboard bindings.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KEditToolBar">KEditToolBar</ulink></title>
+<para>
+A dialog for editing toolbars.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KTipDialog">KTipDialog</ulink></title>
+<para>
+A Tip-of-the-day dialog.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KAboutDialog">KAboutDialog</ulink></title>
+<para>
+An about dialog.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KLineEditDlg">KLineEditDlg</ulink></title>
+<para>
+A simple dialog for entering text.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kfile/KURLRequesterDlg">KURLRequesterDlg</ulink></title>
+<para>
+A simple dialog for entering URLs.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KMessageBox">KMessageBox</ulink></title>
+<para>
+A dialog for signaling errors and warnings.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KPasswordDialog">KPasswordDialog</ulink></title>
+<para>
+A dialog for inputting passwords.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Actions and XML GUI
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KAction">KAction</ulink></title>
+<para>
+Abstraction for an action that can be plugged into menu bars and tool bars.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KActionCollection">KActionCollection</ulink></title>
+<para>
+A set of actions.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdeui/KXMLGUIClient">KXMLGUIClient</ulink></title>
+<para>
+A GUI fragment consisting of an action collection and a DOM tree representing their location in the GUI.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kparts/KPartManager">KPartManager</ulink></title>
+<para>
+Manages the activation of XMLGUI clients.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+<para>
+Plugins and Components
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KLibrary">KLibrary</ulink></title>
+<para>
+Represents a dynamically loaded library.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KLibrary">KLibLoader</ulink></title>
+<para>
+Shared library loading.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kdecore/KLibFactory">KLibFactory</ulink></title>
+<para>
+Object factory in plugins.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kio/KServiceType">KServiceType</ulink></title>
+<para>
+Represents a service type.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kio/KService">KService</ulink></title>
+<para>
+Represents a service.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kio/KMimeType">KMimeType</ulink></title>
+<para>
+Represents a MIME type.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kio/KServiceTypeProfile">KServiceTypeProfile</ulink></title>
+<para>
+User preferences for MIME type mappings.
+</para>
+</formalpara></listitem>
+
+<listitem><formalpara><title><ulink url="kdeapi:kio/KServiceTypeProfile">KTrader</ulink></title>
+<para>
+Querying for services.
+</para>
+</formalpara></listitem>
+
+</itemizedlist>
+
+</simplesect>
+
+</chapter>
+
+
+
+<chapter id="graphics">
+<title>Graphics</title>
+
+<sect1 id="graphics-qpainter">
+<title>Low-level graphics with QPainter</title>
+
+<simplesect id="qpainter-rendering">
+<title>Rendering with QPainter</title>
+
+<para>
+Qt's low level imaging model is based on the capabilities provided by X11 and
+other windowing systems for which Qt ports exist. But it also extends these by
+implementing additional features such as arbitrary affine transformations for
+text and pixmaps.
+</para>
+
+<para>
+The central graphics class for 2D painting with Qt is 
+<ulink url="kdeapi:qt/QPainter">QPainter</ulink>. It can
+draw on a
+<ulink url="kdeapi:qt/QPaintDevice">QPaintDevice</ulink>.
+There are three possible paint devices implemented: One is 
+<ulink url="kdeapi:qt/QWidget">QWidget</ulink>
+which represents a widget on the screen. The second is 
+<ulink url="kdeapi:qt/QPrinter">QPrinter</ulink> which
+represents a printer and produces Postscript output. The third it
+the class
+<ulink url="kdeapi:qt/QPicture">QPicture</ulink> which
+records paint commands and can save them on disk and play them back
+later. A possible storage format for paint commands is the W3C standard
+SVG.
+</para>
+
+<para>
+So, it is possible to reuse the rendering code you use for displaying a
+widget for printing, with the same features supported. Of course, in
+practice, the code is used in a slightly different context. Drawing
+on a widget is almost exclusively done in the paintEvent() method
+of a widget class.
+</para>
+
+<programlisting>
+void FooWidget::paintEvent()
+{
+    QPainter p(this);
+    // Setup painter
+    // Use painter
+}
+</programlisting>
+
+<para>
+When drawing on a printer, you have to make sure to use QPrinter::newPage()
+to finish with a page and begin a new one - something that naturally is not
+relevant for painting widgets. Also, when printing, you may want to use the
+<ulink url="kdeapi:qt/QPaintDeviceMetrics">device metrics</ulink>
+in order to compute coordinates.
+</para>
+
+</simplesect>
+
+
+<simplesect id="qpainter-transformations">
+<title>Transformations</title>
+
+<para>
+By default, when using QPainter, it draws in the natural coordinate
+system of the device used. This means, if you draw a line along the horizontal
+axis with a length of 10 units, it will be painted as a horizontal line
+on the screen with a length of 10 pixels. However, QPainter can apply arbitrary
+affine transformations before actually rendering shapes and curves. An
+affine transformation maps the x and y coordinates linearly into x' and
+y' according to
+</para>
+
+<mediaobject>
+<imageobject><imagedata fileref="affine-general.png"/></imageobject>
+</mediaobject>
+
+<para>
+The 3x3 matrix in this equation can be set with QPainter::setWorldMatrix() and
+is of type <ulink url="kdeapi:qt/QWMatrix">QWMatrix</ulink>.
+Normally, this is the identity matrix, i.e. m11 and m22 are one, and the
+other parameters are zero. There are basically three different groups of
+transformations:
+</para>
+
+<itemizedlist>
+
+<listitem><formalpara>
+<title>Translations</title>
+<para>
+These move all points of an object by a fixed amount in
+some direction. A translation matrix can be obtained by calling
+method m.translate(dx, dy) for a QWMatrix. This corresponds to the
+matrix
+</para>
+</formalpara>
+
+<mediaobject>
+<imageobject><imagedata fileref="affine-translate.png"/></imageobject>
+</mediaobject>
+
+</listitem>
+
+<listitem><formalpara>
+<title>Scaling</title>
+<para>
+These stretch or shrink the coordinates of an object, making
+it bigger or smaller without distorting it. A scaling transformation
+can be applied to a QWMatrix by calling m.scale(sx, sy). This corresponds
+to the matrix
+</para>
+</formalpara>
+
+<mediaobject>
+<imageobject><imagedata fileref="affine-scale.png"/></imageobject>
+</mediaobject>
+
+<para>
+By setting one of the parameters to a negative value, one can
+achieve a mirroring of the coordinate system.
+</para>
+
+</listitem>
+
+<listitem><formalpara>
+<title>Shearing</title>
+<para>
+A distortion of the coordinate system with two
+parameters. A shearing transformation can be applied by calling
+m.shear(sh, sv), corresponding to the matrix
+</para>
+</formalpara>
+
+<mediaobject>
+    <imageobject><imagedata fileref="affine-shear.png"/></imageobject>
+</mediaobject>
+
+</listitem>
+
+<listitem><formalpara>
+<title>Rotating</title>
+<para>
+This rotates an object. A rotation transformation can be 
+applied by calling m.rotate(alpha). Note that the angle has to be given
+in degrees, not as mathematical angle! The corresponding matrix is
+</para>
+</formalpara>
+
+<mediaobject>
+<imageobject><imagedata fileref="affine-rotate.png"/></imageobject>
+</mediaobject>
+
+<para>
+Note that a rotation is equivalent with a combination of
+scaling and shearing.
+</para>
+
+</listitem>
+
+</itemizedlist>
+
+<para>
+Here are some pictures that show the effect of the elementary
+transformation to our masquot:
+</para>
+
+<informaltable frame="none">
+<tgroup cols="3">
+<tbody>
+<row>
+<entry><mediaobject>
+    <imageobject><imagedata fileref="konqi-normal.png"/></imageobject>
+</mediaobject></entry>
+<entry><mediaobject>
+    <imageobject><imagedata fileref="konqi-rotated.png"/></imageobject>
+</mediaobject></entry>
+<entry><mediaobject>
+    <imageobject><imagedata fileref="konqi-sheared.png"/></imageobject>
+</mediaobject></entry>
+<entry><mediaobject>
+   <imageobject><imagedata fileref="konqi-mirrored.png"/></imageobject>
+</mediaobject></entry>
+</row>
+<row>
+<entry>a) Normal</entry>
+<entry>b) Rotated by 30 degrees</entry>
+<entry>c) Sheared by 0.4</entry>
+<entry>d) Mirrored</entry>
+</row>
+</tbody>
+</tgroup>
+</informaltable>
+
+<para>
+Transformations can be combined by multiplying elementary matrices. Note that 
+matrix operations are not commutative in general, and therefore the combined 
+effect of of a concatenation depends on the order in which the matrices are
+multiplied.
+</para>
+
+</simplesect>
+
+
+<simplesect id="qpainter-strokeattributes">
+<title>Setting stroking attributes</title>
+
+<para>
+The rendering of lines, curves and outlines of polygons can be modified by 
+setting a special pen with QPainter::setPen(). The argument of this function is a 
+<ulink url="kdeapi:qt/QPen">QPen</ulink> object. The properties
+stored in it are a style, a color, a join style and a cap style.
+</para>
+
+<para>
+The pen style is member of the enum
+<ulink url="kdeapi:qt/Qt#PenStyle-enum">Qt::PenStyle</ulink>. 
+and can take one of the following values:
+</para>
+
+<mediaobject>
+    <imageobject><imagedata fileref="penstyles.png"/></imageobject>
+</mediaobject>
+
+<para>
+The join style is a member of the enum
+<ulink url="kdeapi:qt/Qt#PenJoinStyle-enum">Qt::PenJoinStyle</ulink>. 
+It specifies how the junction between multiple lines which are attached to each 
+other is drawn. It takes one of the following values:
+</para>
+
+<informaltable frame="none">
+<tgroup cols="3">
+<tbody>
+<row>
+<entry><mediaobject>
+    <imageobject><imagedata fileref="joinmiter.png"/></imageobject>
+</mediaobject></entry>
+<entry><mediaobject>
+    <imageobject><imagedata fileref="joinbevel.png"/></imageobject>
+</mediaobject></entry>
+<entry><mediaobject>
+    <imageobject><imagedata fileref="joinround.png"/></imageobject>
+</mediaobject></entry>
+</row>
+<row>
+<entry>a) MiterJoin</entry>
+<entry>c) BevelJoin</entry>
+<entry>b) RoundJoin</entry>
+</row>
+</tbody>
+</tgroup>
+</informaltable>
+
+<para>
+The cap style is a member of the enum 
+<ulink url="kdeapi:qt/Qt#PenCapStyle-enum">Qt::PenCapStyle</ulink>and specifies how the end points of lines are drawn. It takes one of the values 
+from the following table:
+</para>
+
+<informaltable frame="none">
+<tgroup cols="3">
+<tbody>
+<row>
+<entry><mediaobject>
+    <imageobject><imagedata fileref="capflat.png"/></imageobject>
+</mediaobject></entry>
+<entry><mediaobject>
+    <imageobject><imagedata fileref="capsquare.png"/></imageobject>
+</mediaobject></entry>
+<entry><mediaobject>
+    <imageobject><imagedata fileref="capround.png"/></imageobject>
+</mediaobject></entry>
+</row>
+<row>
+<entry>a) FlatCap</entry>
+<entry>b) SquareCap</entry>
+<entry>c) RoundCap</entry>
+</row>
+</tbody>
+</tgroup>
+</informaltable>
+
+</simplesect>
+
+
+<simplesect id="qpainter-fillattributes">
+<title>Setting fill attributes</title>
+
+<para>
+The fill style of polygons, circles or rectangles can be modified by setting
+a special brush with QPainter::setBrush(). This function takes a
+<ulink url="kdeapi:qt/QBrush">QBrush</ulink> object as argument. 
+Brushes can be constructed in four different ways:
+</para>
+
+<itemizedlist>
+<listitem>
+<para>QBrush::QBrush() - This creates a brush that does not fill shapes.</para>
+</listitem>
+<listitem>
+<para>QBrush::QBrush(BrushStyle) - This creates a black brush with one of the default
+patterns shown below.</para>
+</listitem>
+<listitem>
+<para>QBrush::QBrush(const QColor &amp;, BrushStyle) - This creates a colored brush
+with one of the patterns shown below.</para>
+</listitem>
+<listitem>
+<para>QBrush::QBrush(const QColor &amp;, const QPixmap) - This creates a colored
+brush with the custom pattern you give as second parameter.</para>
+</listitem>
+</itemizedlist>
+
+<para>
+A default brush style is from the enum
+<ulink url="kdeapi:qt/Qt#BrushStyle-enum">Qt::BrushStyle</ulink>.
+Here is a picture of all predefined patterns:
+</para>
+
+<mediaobject>
+    <imageobject><imagedata fileref="brushstyles.png"/></imageobject>
+</mediaobject>
+
+<para>
+A further way to customize the brush behavior is to use the function
+QPainter::setBrushOrigin().
+</para>
+
+</simplesect>
+
+
+<simplesect id="qpainter-color">
+<title>Color</title>
+
+<para>
+Colors play a role both when stroking curves and when filling shapes. In Qt, 
+colors are represented by the class 
+<ulink url="kdeapi:qt/QColor">QColor</ulink>. Qt does not support 
+advanced graphics features like ICC color profiles and color correction. Colors 
+are usually constructed by specifying their red, green and blue components, as 
+the RGB model is the way pixels are composed of on a monitor. 
+</para>
+
+<para>
+It is also possible to use hue, saturation and value. This HSV representation is 
+what you use in the Gtk color dialog, e.g. in GIMP. There, the hue corresponds
+to the angle on the color wheel, while the saturation corresponds to the 
+distance from the center of the circle. The value can be chosen with a separate
+slider.
+</para>
+
+</simplesect>
+
+
+<simplesect id="qpainter-paintsettings">
+<title>Other settings</title>
+
+<para>
+Normally, when you paint on a paint device, the pixels you draw replace those
+that were there previously. This means, if you paint a certain region with
+a red color and paint the same region with a blue color afterwards, only
+the blue color will be visible. Qt's imaging model does not support 
+transparency, i.e. a way to blend the painted foreground with the background.
+However, there is a simple way to combine background and foreground with
+boolean operators. The method QPainter::setRasterOp() sets the used operator,
+which comes from the enum 
+<ulink url="kdeapi:qt/Qt#RasterOp-enum">RasterOp</ulink>.
+</para>
+
+<para>
+The default is CopyROP which ignores the background. Another popular choice is
+XorROP. If you paint a black line with this operator on a colored image, then 
+the covered area will be inverted. This effect is for example used to create
+the rubberband selections in image manipulation programs known as 
+"marching ants".
+</para>
+
+</simplesect>
+
+
+<simplesect id="qpainter-primitives">
+<title>Drawing graphics primitives</title>
+
+<para>
+In the following we list the elementary graphics elements supported by 
+QPainter. Most of them exist in several overloaded versions which take a 
+different number of arguments. For example, methods that deal with rectangles
+usually either take a 
+<ulink url="kdeapi:qt/QRect">QRect</ulink> as argument or a set
+of four integers.
+</para>
+
+<itemizedlist>
+<listitem>
+<para>Drawing a single point - drawPoint().</para>
+</listitem>
+<listitem>
+<para>Drawing lines - drawLine(), drawLineSegments() and drawPolyLine().</para>
+</listitem>
+<listitem>
+<para>Drawing and filling rectangles - drawRect(), drawRoundRect(),
+fillRect() and eraseRect().</para>
+</listitem>
+<listitem>
+<para>Drawing and filling circles, ellipses and parts or them -
+drawEllipse(), drawArc(), drawPie and drawChord().</para>
+</listitem>
+<listitem>
+<para>Drawing and filling general polygons - drawPolygon().</para>
+</listitem>
+<listitem>
+<para>Drawing bezier curves - drawQuadBezier() [drawCubicBezier in Qt 3.0].</para>
+</listitem>
+</itemizedlist>
+
+</simplesect>
+
+
+<simplesect id="qpainter-pixmaps">
+<title>Drawing pixmaps and images</title>
+
+<para>
+Qt provides two very different classes to represent images. 
+</para>
+
+<para>
+<ulink url="kdeapi:qt/QPixmap">QPixmap</ulink> directly corresponds
+to the pixmap objects in X11. Pixmaps are server-side objects and may - on a
+modern graphics card - even be stored directly in the card's memory. This makes
+it <emphasis>very</emphasis> efficient to transfer pixmaps to the screen. Pixmaps also act as
+an off-screen equivalent of widgets - the QPixmap class is a subclass of 
+QPaintDevice, so you can draw on it with a QPainter. Elementary drawing 
+operations are usually accelerated by modern graphics. Therefore, a common usage
+pattern is to use pixmaps for double buffering. This means, instead of painting
+directly on a widget, you paint on a temporary pixmap object and use the
+<ulink url="kdeapi:qt/QPaintDevice#bitBlt-1">bitBlt</ulink>
+function to transfer the pixmap to the widget. For complex repaints, this helps
+to avoid flicker.
+</para>
+
+<para>
+In contrast, <ulink url="kdeapi:qt/QImage">QImage</ulink> objects 
+live on the client side. Their emphasis in on providing direct access to the
+pixels of the image. This makes them of use for image manipulation, and things
+like loading and saving to disk (QPixmap's load() method takes QImage as 
+intermediate step). On the other hand, painting an image on a widget is a
+relatively expensive operation, as it implies a transfer to the X server,
+which can take some time, especially for large images and for remote servers.
+Depending on the color depth, the conversion from QImage to QPixmap may also 
+require dithering.
+</para>
+
+</simplesect>
+
+
+<simplesect id="qpainter-drawingtext">
+<title>Drawing text</title>
+
+<para>
+Text can be drawn with one of the overloaded variants of the method 
+QPainter::drawText(). These draw a QString either at a given point or in a given
+rectangle, using the font set by QPainter::setFont(). There is also a parameter
+which takes an ORed combination of some flags from the enums
+<ulink url="kdeapi:qt/Qt#AlignmentFlags-enum">Qt::AlignmentFlags</ulink>
+and
+<ulink url="kdeapi:qt/Qt#TextFlags-enum">Qt::TextFlags</ulink>
+</para>
+
+<para>
+Beginning with version 3.0, Qt takes care of the complete text layout even for
+languages written from right to left.
+</para>
+
+<para>
+A more advanced way to display marked up text is the 
+<ulink url="kdeapi:qt/QSimpleRichText">QSimpleRichText</ulink> 
+class. Objects of this class can be constructed with a piece of text using
+a subset of the HTML tags, which is quite rich and provides even tables.
+The text style can be customized by using a 
+<ulink url="kdeapi/qt/QStyleSheet">QStyleSheet</ulink> (the
+documentation of the tags can also be found here). Once the rich text object has
+been constructed, it can be rendered on a widget or another paint device with
+the QSimpleRichText::draw() method.
+</para>
+
+</simplesect>
+
+</sect1>
+
+
+<sect1 id="graphics-qcanvas">
+<title>Structured graphics with QCanvas</title>
+
+<para>
+QPainter offers a powerful imaging model for painting on widgets and pixmaps.
+However, it can also be cumbersome to use. Each time your widget receives
+a paint event, it has to analyze the QPaintEvent::region() or 
+QPaintEvent::rect() which has to be redrawn. Then it has to setup a
+QPainter and paint all objects which overlap with that region. For example,
+image a vector graphics program which allows to drag objects like polygons,
+circles and groups of them around. Each time those objects move a bit, the
+widget's mouse event handler triggers a paint event for the whole area covered 
+by the objects in their old position and in their new position. Figuring
+out the necessary redraws and doing them in an efficient way can be difficult,
+and it may also conflict with the object-oriented structure of the program's
+source code.
+</para>
+
+<para>
+As an alternative, Qt contains the class 
+<ulink url="kdeapi:qt/QCanvas">QCanvas</ulink> in which
+you put graphical objects like polygons, text, pixmaps. You may also provide
+additional items by subclassing 
+<ulink url="kdeapi:qt/QCanvasItem">QCanvasItem</ulink> or
+one of its more specialized subclasses. A canvas can be shown on the screen by
+one or more widgets of the class
+<ulink url="kdeapi:qt/QCanvas">QCanvasView</ulink> which
+you have to subclass in order to handle user interactions. Qt takes care of
+all repaints of objects in the view, whether they are caused by the widget
+being exposed, new objects being created or modified or other things. By using
+double buffering, this can be done in an efficient and flicker-free way.
+</para>
+
+<para>
+Canvas items can overlap each other. In this case, the visible one depends on
+the z order which can be assigned by QCanvasItem::setZ(). Items can also be
+made visible or invisible. You can also provide a background to be drawn 
+"behind" all items and a foreground. For associating mouse events with objects,
+in the canvas, there is the method QCanvas::collisions() which returns a list
+of items overlapping with a given point. Here we show a screenshot of a canvas
+view in action:
+</para>
+
+<mediaobject>
+<imageobject><imagedata fileref="canvas.png"/></imageobject>
+</mediaobject>
+
+<para>
+Here, the mesh is drawn in the background. Furthermore, there is a
+QCanvasText item and a violet QCanvasPolygon. The butterfly is a
+QCanvasPixmap. It has transparent areas, so you can see the underlying
+items through it.
+</para>
+
+<para>
+A tutorial on using QCanvas for writing sprite-based games can be
+found <ulink url="http://zez.org/article/articleview/2/1/">here</ulink>.
+</para>
+
+</sect1>
+
+
+<sect1 id="graphics-qglwidget">
+<title>3D graphics with OpenGL</title>
+
+<simplesect id="qglwidget-lowlevel">
+<title>Low-level interface</title>
+
+<para>
+The de facto standard for rendering 3D graphics today is 
+<ulink url="http://www.opengl.org">OpenGL</ulink>. Implementations of this
+specification come with Microsoft Windows, Mac OS X and XFree86 and often
+support the hardware acceleration features offered by modern graphics cards.
+OpenGL itself only deals with rendering on a specified area of the framebuffer
+through a <emphasis>GL context</emphasis> and does not have any interactions
+with the toolkit of the environment
+</para>
+
+<para>
+Qt offers the widget <ulink url="kdeapi:qt/QGLWidget">QGLWidget</ulink>
+which encapsulates a window with an associated GL context. Basically, you use it
+by subclassing it and reimplementing some methods.
+</para>
+
+<itemizedlist>
+
+<listitem><para>
+Instead of reimplementing paintEvent() and using QPainter to draw the widget's
+contents, you override paintGL() and use GL commands to render a scene. QLWidget
+will take care of making its GL context the current one before paintGL() is
+called, and it will flush afterwards.
+</para></listitem>
+
+<listitem><para>
+The virtual method initializeGL() is called once before the first time resizeGL()
+or paintGL() are called. This can be used to construct display lists for objects,
+and make any initializations.
+</para></listitem>
+
+<listitem><para>
+Instead of reimplementing resizeEvent(), you override resizeGL(). This can
+be used to set the viewport appropriately.
+</para></listitem>
+
+<listitem><para>
+Instead of calling update() when the state of the scene has changed - for example
+when you animate it with a timer -, you should call updateGL(). This will trigger
+a repaint.
+</para></listitem>
+
+</itemizedlist>
+
+<para>
+In general, QGLWidget behaves just like any other widget, i.e. for example
+you can process mouse events as usual, resize the widget and combine it with
+others in a layout.
+</para>
+
+<mediaobject>
+<imageobject><imagedata fileref="opengl.png"/></imageobject>
+</mediaobject>
+
+<para>
+Qt contains some examples of QGLWidget usage in its <literal>demo</literal>
+example. A collection of tutorials can be found 
+<ulink url="http://www.libsdl.org/opengl/intro.html">here</ulink>,
+and more information and a reference of OpenGL is available on the
+<ulink url="http://www.opengl.org">OpenGL homepage</ulink>.
+</para>
+
+</simplesect>
+
+
+<simplesect id="qglwidget-highlevel">
+<title>High-level interfaces</title>
+
+<para>
+OpenGL is a relatively low-level interface for drawing 3D graphics. In the same
+way QCanvas gives the programmer a higher-level interface which details with
+objects and their properties, there are also high-level interfaces for 3D graphics.
+One of the most popular is Open Inventor. Originally a technology developed by SGI,
+there is today also the open source implementation 
+<ulink url="http://www.coin3d.org">Coin</ulink>, complemented by a toolkit binding to Qt
+called SoQt. 
+</para>
+
+<para>
+The basic concept of Open Inventor is that of a <emphasis>scene</emphasis>.
+A scene can be loaded from disk and saved in a special format closely related
+to <ulink url="http://www.vrml.org">VRML</ulink>. A scene consists of a
+collection of objects called <emphasis>nodes</emphasis>. Inventor already 
+provides a rich collection of reusable nodes, such as cubes, cylinders and
+meshes, furthermore light sources, materials, cameras etc. Nodes are 
+represented by C++ classes and can be combined and subclassed.
+</para>
+
+<para>
+An introduction to Inventor can be found 
+<ulink url="http://www.motifzone.com/tmd/articles/OpenInventor/OpenInventor.html">here</ulink>
+(in general, you can substitute all mentions of SoXt by SoQt in this article).
+</para>
+
+</simplesect>
+
+</sect1>
+
+</chapter>
+
+
+
+<chapter id="userinterface">
+<title>User interface</title>
+
+<sect1 id="userinterface-actionpattern">
+<title>The action pattern</title>
+
+<para></para>
+
+</sect1>
+
+
+<sect1 id="userinterface-xmlgui">
+<title>Defining menus and toolbars in XML</title>
+
+<simplesect id="xmlgui-intro">
+<title>Introduction</title>
+
+<para>
+While the <link linkend="userinterface-actionpattern">action pattern</link>
+allows to encapsulate  actions triggered by the user in an object which can be
+"plugged" somewhere in the menu bars or toolbars, it does not by itself solve
+the problem of  constructing the menus themselves. In particular, you have to
+build all popup menus in C++ code and explicitly insert the actions in a
+certain order, under consideration of the style guide for standard actions.
+This makes it pretty difficult to allow the user to customize the menus or
+change shortcuts to fit his needs, without changing the source code.
+</para>
+
+<para>
+This problem is solved by a set of classes called <literal>XMLGUI</literal>.
+Basically, this separates actions (coded in C++) from their appearance in menu
+bars and tool bars (coded in XML). Without modifying any source code, menus
+can be simply customized by adjusting an XML file. Furthermore, it helps
+to make sure that standard actions (such as
+<menuchoice><guimenu>File</guimenu><guimenuitem>Open</guimenuitem></menuchoice>
+or <menuchoice><guimenu>Help</guimenu><guimenuitem>About</guimenuitem></menuchoice>)
+appear in the locations suggested by the style guide. XMLGUI is especially
+important for modular programs, where the items appearing in the menu bar may
+come from many different plugins or parts.
+</para>
+
+<para>
+KDE's class for toplevel windows, 
+<ulink url="kdeapi:kdeui/KMainWindow.html">KMainWindow</ulink>,
+inherits 
+<ulink url="kdeapi:kdeui/KXMLGUIClient.html">KXMLGUIClient</ulink>
+and therefore supports XMLGUI out of the box. All actions created within it must
+have the client's <literal>actionCollection()</literal> as parent. A call to
+<literal>createGUI()</literal> will then build the whole set of menu and tool
+bars defined the applications XML file  (conventionally with the suffix
+<literal>ui.rc</literal>). 
+</para>
+
+</simplesect>
+
+
+<simplesect id="xmlgui-kviewexample">
+<title>An example: Menu in KView</title>
+
+<para>
+In the following, we take KDE's image view <application>KView</application> as
+example. It has a <literal>ui.rc</literal> file named
+<filename>kviewui.rc</filename> which is installed with the 
+<filename>Makefile.am</filename> snippet
+</para>
+
+<programlisting>
+rcdir = $(kde_datadir)/kview
+rc_DATA = kviewui.rc
+</programlisting>
+
+<para>
+Here is an excerpt from the <filename>kviewui.rc</filename> file. For
+simplicity, we show only the definition of the <guimenu>View</guimenu> menu.
+</para>
+
+<programlisting>
+&lt;!DOCTYPE kpartgui&gt;
+&lt;kpartgui name="kview"&gt;
+  &lt;MenuBar&gt;
+    &lt;Menu name="view" &gt;
+      &lt;Action name="zoom50" /&gt;
+      &lt;Action name="zoom100" /&gt;
+      &lt;Action name="zoom200" /&gt;
+      &lt;Action name="zoomMaxpect" /&gt;
+      &lt;Separator/&gt;
+      &lt;Action name="fullscreen" /&gt;
+    &lt;/Menu&gt;
+  &lt;/MenuBar&gt;
+&lt;/kpartgui&gt;
+</programlisting>
+
+<para>
+The corresponding part of the setup in C++ is:
+</para>
+
+<programlisting>
+  KStdAction::zoomIn    ( this, SLOT(slotZoomIn()), actionCollection() );
+  KStdAction::zoomOut   ( this, SLOT(slotZoomOut()), actionCollection() );
+  KStdAction::zoom      ( this, SLOT(slotZoom()), actionCollection() );
+  new KAction           ( i18n("&amp;Half size"), ALT+Key_0, 
+                          this, SLOT(slotHalfSize()), 
+                          actionCollection(), "zoom50" );
+  new KAction           ( i18n("&amp;Normal size"), ALT+Key_1,
+                          this, SLOT(slotDoubleSize()), 
+                          actionCollection(), "zoom100" );
+  new KAction           ( i18n("&amp;Double size"), ALT+Key_2, 
+                          this, SLOT(slotDoubleSize()), 
+                          actionCollection(), "zoom200" );
+  new KAction           ( i18n("&amp;Fill Screen"), ALT+Key_3, 
+                          this, SLOT(slotFillScreen()), 
+                          actionCollection(), "zoomMaxpect" );
+  new KAction           ( i18n("Fullscreen &amp;Mode"), CTRL+SHIFT+Key_F, 
+                          this, SLOT(slotFullScreen()), 
+                          actionCollection(), "fullscreen" );
+</programlisting>
+
+<para>
+The <guimenu>View</guimenu> menu resulting from this GUI definition looks like
+in this screenshot:
+</para>
+
+<mediaobject>
+<imageobject><imagedata fileref="kview-menu.png"/></imageobject>
+</mediaobject>
+
+<para>
+The XML file begins with a document type declaration. The DTD for kpartgui can
+be found in the kdelibs sources in <filename>kdeui/kpartgui.dtd</filename>. The
+outermost element of the file contains the instance name of the application as
+attribute. It can also contain a version number in the form "version=2". This
+is useful when you release new versions of an application with a changed menu
+structure, e.g. with more features. If you bump up the version number of the
+<literal>ui.rc</literal> file, KDE makes sure that any customized version of
+the file is discarded and the new  file is used instead.
+</para>
+
+<para>
+The next line, <literal>&lt;MenuBar&gt;</literal>, contains a declaration of a
+menu bar. You can also insert any number of <literal>&lt;ToolBar&gt;</literal>
+declarations in order to create some tool bars. The menu contains a submenu
+with the name "view". This name is already predefined, and thus you see a
+translated version of the word "View" in the screenshot. If you declare your
+own submenus, you have to add the title explicitly. For example,
+<application>KView</application> has a submenu with the title "Image" which is
+declared as follows:
+</para>
+
+<programlisting>
+&lt;Menu name="image" &gt;
+   &lt;text&gt;&amp;amp;Image&lt;/text&gt;
+   ...
+&lt;/Menu&gt;
+</programlisting>
+
+<para>
+In KDE's automake framework, such titles are automatically extracted and put
+into the application's <ulink url="kde-i18n-howto.html"><literal>.po</literal></ulink>
+file , so it is considered by translators. Note that you have to write the
+accelerator marker "&amp;" in the form XML compliant form "&amp;amp;".
+</para>
+
+<para>
+Let us come back to the example. <application>KView</application>'s
+<guimenu>View</guimenu> menu contains a couple of custom actions:
+<literal>zoom50</literal>, <literal>zoom100</literal>,
+<literal>zoom200</literal>, <literal>zoomMaxpect</literal> and
+<literal>fullscreen</literal>, declared with a
+<literal>&lt;Action&gt;</literal> element. The separator in the
+screenshots corresponds to the <literal>&lt;Separator&gt;</literal> element. 
+</para>
+
+<para>
+You will note that some menu items do not not have a corresponding element in 
+the XML file. These are <emphasis>standard actions</emphasis>. Standard
+actions are created by the class 
+<ulink url="kdeapi:kdeui/KStdAction.html">KStdAction</ulink>.
+When you create such actions in your application (such as in the C++ example
+above), they will automatically be inserted in a prescribed position, and
+possibly with an icon and a shortcut key. You can look up these locations in
+the file <filename>kdeui/ui_standards.rc</filename> in the kdelibs sources.
+</para>
+
+</simplesect>
+
+
+<simplesect id="xmlgui-konqexample">
+<title>An example: Toolbars in Konqueror</title>
+
+<para>
+For the discussion of toolbars, we switch to
+<application>Konqueror</application>'s GUI definition. This excerpt defines
+the location bar, which contains the input field for URLs.
+</para>
+
+<programlisting>
+&lt;ToolBar name="locationToolBar" fullWidth="true" newline="true" &gt;
+  &lt;text&gt;Location Toolbar&lt;/text&gt;
+  &lt;Action name="clear_location" /&gt;
+  &lt;Action name="location_label" /&gt;
+  &lt;Action name="toolbar_url_combo" /&gt;
+  &lt;Action name="go_url" /&gt;
+&lt;/ToolBar&gt;
+</programlisting>
+
+<para>
+The first thing we notice is that there are a lot more attributes than for
+menu bars. These include:
+</para>
+
+<itemizedlist>
+
+<listitem><para>
+<literal>fullWidth</literal>: Tells XMLGUI that the toolbar has the same width as the
+    toplevel window. Af this is "false", the toolbar only takes as much space as
+    necessary, and further toolbars are put in the same row.
+</para></listitem>
+
+<listitem><para>
+<literal>newline</literal>: This is related to the option above. If newline is "true",
+the toolbar starts a new row. Otherwise it may be put in the row together
+with the previous toolbar.
+</para></listitem>
+
+<listitem><para>
+<literal>noEdit</literal>: Normally toolbars can be customized by the user,
+e.g. in <menuchoice><guimenu>Settings</guimenu><guimenuitem>Configure
+Toolbars</guimenuitem></menuchoice> in
+<application>Konqueror</application>. Setting this option to "true" marks this
+toolbar as not editable. This is important for toolbars which are filled with
+items at runtime, e.g. <application>Konqueror</application>'s bookmark toolbar.
+</para></listitem>
+
+<listitem><para>
+<literal>iconText</literal>: Tells XMLGUI to show the text of the action next to the
+icon. Normally, the text is only shown as a tooltip when the mouse cursor
+remains over the icon for a while. Possible values for this attribute are
+"icononly" (shows only the icon), "textonly" (shows only the text),
+"icontextright" (shows the text on the right side of the icon) and 
+"icontextbottom" (shows the text beneath the icon).
+</para></listitem>
+
+
+<listitem><para>
+<literal>hidden</literal>: If this is "true", the toolbar is not visible initially
+and must be activated by some menu item.
+</para></listitem>
+
+
+<listitem><para>
+<literal>position</literal>: The default for this attribute is "top", meaning that the
+toolbar is positioned under the menu bar. For programs with many tools,
+such as graphics programs, it may be interesting to replace this with
+"left", "right" or "bottom".
+</para></listitem>
+
+</itemizedlist>
+
+</simplesect>
+
+
+<simplesect id="xmlgui-dynamical">
+<title>Dynamical menus</title>
+
+<para>
+Obviously, an XML can only contain a static description of a user interface.
+Often, there are menus which change at runtime. For example,
+<application>Konqueror</application>'s <guimenu>Location</guimenu> menu
+contains a set of items <guimenuitem>Open with Foo</guimenuitem> with the
+applications able to load a file with a given MIME type. Each time the
+document shown changes, the list of menu items is updated. XMLGUI is prepared
+to handle such cases with the notion of <emphasis>action lists</emphasis>.
+An action list is declared as one item in the XML file, but consists of
+several actions which are plugged into the menu at runtime. The above example
+is implemented with the following declaration in
+<application>Konqueror</application>'s XML file:
+</para>
+
+<programlisting>
+&lt;Menu name="file"&gt;
+  &lt;text&gt;&amp;amp;Location&lt;/text&gt;
+  ...
+  &lt;ActionList name="openwith"&gt;
+  ...
+&lt;/Menu&gt;
+</programlisting>
+
+<para>
+The function <function>KXMLGUIClient::plugActionList()</function> is then used
+to add actions to be displayed, whereas the function
+<function>KXMLGuiClient::unplugActionList()</function> removes all
+plugged actions. The routine responsible for updating looks as follows:
+</para>
+
+<programlisting>
+void MainWindow::updateOpenWithActions()
+{
+    unplugActionList("openwith");
+    openWithActions.clear();
+    for ( /* iterate over the relevant services */ ) {
+        KAction *action = new KAction( ...);
+        openWithActions.append(action);
+    }
+    plugActionList("openwith", openWithActions);
+}
+</programlisting>
+
+<para>
+Note that in contrast to the static actions, the ones created here are 
+<emphasis>not</emphasis> constructed with the action collection as parent, and
+you are responsible for deleting them for yourself. The simplest way to achievethis
+is by using <literal>openWithActions.setAutoDelete(true)</literal> in the above
+example.
+</para>
+
+</simplesect>
+
+
+<simplesect id="xmlgui-contextmenus">
+<title>Context menus</title>
+
+<para>
+The examples above only contained cases where a main window's menubar and 
+toolbars were created. In the cases, the processes of constructing these
+containers is completely hidden from you behind the
+<function>createGUI()</function> call (except if you have custom containers).
+However, there are cases, where you want to construct other containers and
+populate them with GUI definitions from the XML file. One such example are
+context menus. In order to get a pointer to a context menu, you have to
+ask the client's factory for it:
+</para>
+
+<programlisting>
+void MainWindow::popupRequested()
+{
+    QWidget *w = factory()->container("context_popup", this);
+    QPopupMenu *popup = static_cast&lt;QPopupMenu *&gt;(w);
+    popup->exec(QCursor::pos());
+}
+</programlisting>
+
+<para>
+The method <function>KXMLGUIFactory::container()</function> used above looks
+whether it finds a container in the XML file with the given name. Thus, a
+possible definition could look as follows:
+</para>
+
+<programlisting>
+...
+&lt;Menu name="context_popup"&gt;
+  &lt;Action name="file_add"/&gt;
+  &lt;Action name="file_remove"/&gt;
+&lt;/Menu&gt;
+...
+</programlisting>
+
+</simplesect>
+
+</sect1>
+
+
+<sect1 id="help">
+<title>Providing online help</title>
+
+<para>
+Making a program easy and intuitive to use involves a wide range of
+facilities which are usually called online help. Online help has several,
+partially conflicting goals: on the one, it should give the user answers
+to the question "How can I do a certain task?", on the other hand it
+should help the user exploring the application and finding features he
+doesn't yet know about. It is important to recognize that this can only
+be achieved by offering several levels of help:
+</para>
+
+<itemizedlist>
+
+<listitem><para>
+Tooltips are tiny labels that pop up over user interface elements when
+the mouse remains there longer. They are especially important for tool-
+bars, where icons are not always sufficient to explain the purpose of
+a button. 
+</para></listitem>
+
+<listitem><para>
+"What's this?" help is usually a longer and richer explanation of a widget
+or a menu item. It is also more clunky to use: In dialogs, it can be invoked
+in two ways: either by pressing
+<keycombo><keycap>Shift</keycap><keycap>F1</keycap></keycombo> or by clicking
+on the question mark in the title bar (where the support of the latter depends
+on the window manager). The mouse pointer then turns into an arrow with a
+question mark, and the help window appears when a user interfact element has
+been clicked. "What's this?" help for menu items is usually activated by a
+button in the toolbar which contains an arrow and a question mark. 
+</para></listitem>
+
+<listitem><para>
+The problem with this approach is that the user can't see whether a widget
+provides help or not. When the user activates the question mark button and
+doesn't get any  help window when clicking on a user interface element, he
+will get frustrated very quickly.
+</para>
+
+<para>
+The advantage of "What's this?" help windows as provided by Qt and KDE is that
+they can contain <ulink url="kdeapi:qt/QStyleSheet">rich text</ulink>, 
+i.e. the may contain different fonts, bold and italic text and even images and tables.
+</para>
+
+<para>
+An example of "What's this?" help:
+</para>
+
+<mediaobject>
+<imageobject><imagedata fileref="whatsthis.png"/></imageobject>
+</mediaobject>
+
+</listitem>
+
+<listitem><para>
+Finally, every program should have a manual. A manual is normally viewed in
+<application>KHelpCenter</application> by activating the
+<guimenu>Help</guimenu> menu. That means, a complete additional application
+pops up and diverts the user from his work. Consequently, consulting the
+manual should only be necessary if other facilities like tooltips and what's
+this help are not sufficient. Of course, a manual has the advantage that it
+does not explain single, isolated aspects of the user interface. Instead, it
+can explain aspects of the application in a greater context. Manuals for KDE
+are written using the <ulink url="http://i18n.kde.org">DocBook</ulink> markup
+language.
+</para></listitem>
+
+</itemizedlist>
+
+<para>
+From the programmer's point of view, Qt provides an easy to use API for online
+help. To assign a tooltip to widget, use the 
+<ulink url="kdeapi:qt/QToolTip">QToolTip</ulink> class.
+</para>
+
+<programlisting>
+QToolTip::add(w, i18n("This widget does something."))
+</programlisting>
+
+<para>
+If the menu bars and tool bars are created using the <ulink url="actionpattern.html">
+action pattern</ulink>, the string used as tooltip is derived from the first argument
+of the <ulink url="kdeapi:kdeui/KAction.html">KAction</ulink> constructor:
+</para>
+
+<programlisting>
+action = new KAction(i18n("&amp;Delete"), "editdelete", 
+                     SHIFT+Key_Delete, actionCollection(), "del")
+</programlisting>
+
+<para>
+Here it is also possible to assign a text which is shown in the status bar when the 
+respective menu item is highlighted:
+</para>
+
+<programlisting>
+action->setStatusText(i18n("Deletes the marked file"))
+</programlisting>
+
+<para>
+The API for "What's this?' help is very similar. In dialogs, use the following
+code:
+</para>
+
+<programlisting>
+QWhatsThis::add(w, i18n("&lt;qt&gt;This demonstrates &lt;b&gt;Qt&lt;/b&gt;'s"
+                        " rich text engine.&lt;ul&gt;"
+                        "&lt;li&gt;Foo&lt;/li&gt;"
+                        "&lt;li&gt;Bar&lt;/li&gt;"
+                        "&lt;/ul&gt;&lt;/qt&gt;"))
+</programlisting>
+
+<para>
+For menu items, use
+</para>
+
+<programlisting>
+action->setWhatsThis(i18n("Deletes the marked file"))
+</programlisting>
+
+<para>
+The invocation of <application>KHelpCenter</application> is encapsulated in the
+<ulink url="kdeapi:kdecore/KApplication">KApplication</ulink>
+class. In order to show the manual of your application, just use 
+</para>
+
+<programlisting>
+kapp->invokeHelp()
+</programlisting>
+
+<para>
+This displays the first page with the table of contents. When you want to
+display only a certain section of the manual, you can give an additional
+argument to <function>invokeHelp()</function> determining the anchor which
+the browser jumps to.
+</para>
+
+</sect1>
+
+</chapter>
+
+
+
+<chapter id="components">
+<title>Components and services</title>
+
+<sect1 id="components-services">
+<title>KDE services</title>
+
+<simplesect id="services-whatarekdeservices">
+<title>What are KDE services?</title>
+
+<para>
+The notion of a <emphasis>service</emphasis> is a central concept in KDE's
+modular architecture. There is no strict technical implementation connected
+with this term - services can be plugins in the form of shared libraries,
+or they can be programs controlled via <ulink url="dcop.html">DCOP</ulink>.
+By claiming to be of a certain <emphasis>service type</emphasis>, a service
+promises to implement certain APIs or features. In C++ terms, one can think
+of a service type as an abstract class, and a service as an implementation
+of that interface.
+</para>
+
+<para>
+The advantage of this separation is clear: An application utilizing a service
+type does not have to know about possible implementations of it. It just uses
+the APIs associated with the service type. In this way, the used service can be
+changed without affecting the application. Also, the user can configure which
+services he prefers for certain features.
+</para>
+
+<para>
+Some examples:
+</para>
+
+<itemizedlist>
+
+<listitem><para>
+The HTML rendering engine used in <application>Konqueror</application> is an
+embedable component that implements the service types
+<literal>KParts/ReadOnlyPart</literal> and <literal>Browser/View</literal>.
+</para></listitem>
+<listitem><para>
+In <application>KDevelop</application> HEAD, most functionality is packaged in
+plugins with the service type <literal>KDevelop/Part</literal>. At startup,
+all services with this type are loaded, such that you can extend the IDE in a
+very flexible way.
+</para></listitem>
+<listitem><para>
+In the icon view, <application>Konqueror</application> displays - if enabled -
+thumbnail pictures of images, HTML pages, PDF and text files. This ability can
+be extended. If you want it to display preview pictures of your own data files
+with some MIME type, you can implement a service with service type
+<classname>ThumbCreator</classname>.
+</para></listitem>
+
+</itemizedlist>
+
+<para>
+Obviously, a service is not only characterized by the service types it
+implements, but also by some <emphasis>properties</emphasis>. For example, a
+ThumbCreator does not only claim to implement the C++ class with the type
+<classname>ThumbCreator</classname>, it also has a list of MIME types it is
+responsible for. Similarly, KDevelop parts have the programming language they
+support as a property. When an application requests a service type, it can
+also list constraints on the properties of the service. In the above example,
+when KDevelop loads the plugins for a Java project, it asks only for the
+plugins which have Java as the programming language property. For this 
+purpose, KDE contains a full-blown CORBA-like <emphasis>trader</emphasis> with
+a complex query language.
+</para>
+
+</simplesect>
+
+
+<simplesect id="services-definingservicetypes">
+<title>Defining service types</title>
+
+<para>
+New service types are added by installing a description of them into the
+directory <filename>KDEDIR/share/servicetypes</filename>. In an automake
+framework, this can be done with this <filename>Makefile.am</filename>
+snippet:
+</para>
+
+<programlisting>
+kde_servicetypesdir_DATA = kdeveloppart.desktop
+EXTRA_DIST = $(kde_servicetypesdir_DATA)
+</programlisting>
+
+<para>
+The definition <filename>kdeveloppart.desktop</filename> of a
+<application>KDevelop</application> part looks as follows:
+</para>
+
+<programlisting>
+[Desktop Entry]
+Type=ServiceType
+X-KDE-ServiceType=KDevelop/Part
+Name=KDevelop Part
+
+[PropertyDef::X-KDevelop-Scope]
+Type=QString
+
+[PropertyDef::X-KDevelop-ProgrammingLanguages]
+Type=QStringList
+
+[PropertyDef::X-KDevelop-Args]
+Type=QString
+</programlisting>
+
+<para>
+In addition to the usual entries, this example demonstrates how you declare
+that a service has some properties. Each property definition corresponds
+to a group <literal>[PropertyDef::name]</literal> in the configuration file. In
+this group, the <literal>Type</literal> entry declares the type of the property.
+Possible types are everything that can be stored in a 
+<ulink url="kdeapi:qt/QVariant">QVariant</ulink>.
+</para>
+
+</simplesect>
+
+
+<simplesect id="services-defininglibraryservices">
+<title>Defining shared library services</title>
+
+<para>
+Service definitions are stored in the directory
+<filename>KDEDIR/share/services</filename>:
+</para>
+
+<programlisting>
+kde_servicesdir_DATA = kdevdoxygen.desktop
+EXTRA_DIST = $(kde_servicesdir_DATA)
+</programlisting>
+
+<para>
+The content of the following example file
+<filename>kdevdoxygen.desktop</filename> defines the
+<literal>KDevDoxygen</literal> plugin with the service type
+<literal>KDevelop/Part</literal>:
+</para>
+
+<programlisting>
+[Desktop Entry]
+Type=Service
+Comment=Doxygen
+Name=KDevDoxygen
+ServiceTypes=KDevelop/Part
+X-KDE-Library=libkdevdoxygen
+X-KDevelop-ProgrammingLanguages=C,C++,Java
+X-KDevelop-Scope=Project
+</programlisting>
+
+<para>
+In addition to the usual declarations, an important entry is 
+<literal>X-KDE-Library</literal>. This contains the name of the libtool
+library (without the <literal>.la</literal> extension). It also fixes
+(with the prefix <literal>init_</literal> prepended) the name of the exported
+symbol in the library which returns an object factory. For the above example,
+the library must contain the following function:
+</para>
+
+<programlisting>
+extern "C" {
+    void *init_libkdevdoxygen()
+    {
+        return new DoxygenFactory;
+    }
+};
+</programlisting>
+
+<para>
+The type of the factory class <classname>DoxygenFactory</classname> depends on
+the specific service type the service implements. In our example of a KDevelop
+plugin, the factory must be a <classname>KDevFactory</classname> (which
+inherits <classname>KLibFactory</classname>). More common examples are
+<ulink url="kdeapi:kparts/KParts::Factory">KParts::Factory</ulink>
+which is supposed to produce 
+<ulink url="kdeapi:kparts/KParts::ReadOnlyPart">KParts::ReadOnlyPart</ulink>
+objects or in most cases the generic
+<ulink url="kdeapi:kdecore/KLibFactory">KLibFactory</ulink>.
+</para>
+
+</simplesect>
+
+
+<simplesect id="services-usinglibraryservices">
+<title>Using shared library services</title>
+
+<para>
+In order to use a shared library service in an application, you need to obtain a
+<ulink url="kdeapi:kio/KService.html">KService</ulink> object
+representing it. This is discussed in the 
+<ulink url="mime.html">section about MIME types</ulink> (and in a section about the
+trader to be written :-)
+</para>
+
+<para>
+With the <classname>KService</classname> object at hand, you can very simply
+load the library and get a pointer to its factory object:
+</para>
+
+<programlisting>
+KService *service = ...
+QString libName = QFile::encodeName(service->library());
+KLibFactory *factory = KLibLoader::self()->factory(libName);
+if (!factory) {
+    QString name = service->name();
+    QString errorMessage = KLibLoader::self()->lastErrorMessage();
+    KMessageBox::error(0, i18n("There was an error loading service %1.\n"
+                               "The diagnostics from libtool is:\n%2")
+                          .arg(name).arg(errorMessage);
+}
+</programlisting>
+
+<para>
+From this point, the further proceeding depends again on the service type. For
+generic plugins, you create objects with the method
+<ulink url="kdeapi:kdecore/KLibFactory.html#ref3">KLibFactory::create()</ulink>.
+For KParts, you must cast the factory pointer to the more specific KParts::Factory and use
+its create() method:
+</para>
+
+<programlisting>
+if (factory->inherits("KParts::Factory")) {
+    KParts::Factory *partFactory = static_cast&lt;KParts::Factory*&gt;(factory);
+    QObject *obj = partFactory->createPart(parentWidget, widgetName, 
+                                           parent, name, "KParts::ReadOnlyPart");
+    ...
+} else {
+    cout &lt;&lt; "Service does not implement the right factory" &lt;&lt; endl;
+}
+</programlisting>
+
+</simplesect>
+
+
+<simplesect id="services-definingdcopservices">
+<title>Defining DCOP services</title>
+
+<para>
+A DCOP service is usually implemented as a program that is started up when it is
+needed. It then goes into a loop and listens for DCOP connections. The program 
+may be an interactive one, but it may also run completely or for a part of its
+lifetime as a daemon in the background without the user noticing it. An example 
+for such a daemon is <literal>kio_uiserver</literal>, which implements user interaction 
+such as progress dialog for the KIO library. The advantage of such a centralized 
+daemon in this context is that e.g. the download progress for several different 
+files can be shown in one window, even if those downloads were initiated from 
+different applications.
+</para>
+
+<para>
+A DCOP service is defined differently from a shared library service. Of course,
+it doesn't specify a library, but instead an executable. Also, DCOP services 
+do not specify a ServiceType line, because usually they are started by their
+name. As additional properties, it contains two lines: 
+</para>
+
+<para>
+<literal>X-DCOP-ServiceType</literal> specifies the way the service is
+started. The value <literal>Unique</literal> says that the service must not be
+started more than once. This means, if you try to start this service (e.g. via 
+<ulink url="kdeapi:kdecore/KApplication.html#startServiceByName">
+KApplication::startServiceByName()</ulink>, KDE looks whether it is already 
+registered with DCOP and uses the running service. If it is not registered yet, 
+KDE will start it up and wait until is registered. Thus, you can immediately 
+send DCOP calls to the service. In such a case, the service should be implemented
+as a 
+<ulink url="kdeapi:kdecore/KUniqueApplication.html">KUniqueApplication</ulink>.
+</para>
+
+<para>
+The value <literal>Multi</literal> for <literal>X-DCOP-ServiceType</literal> says that multiple
+instances of the service can coexist, so every attempt to start the service
+will create another process. As a last possibility the value <literal>None</literal>
+can be used. In this case, a start of the service will not wait until it
+is registered with DCOP.
+</para>
+
+<para>
+<literal>X-KDE-StartupNotify</literal> should normally be set to false. Otherwise, when
+the program is started, the task bar will show a startup notification, or, depending
+on the user's settings, the cursor will be changed.
+</para>
+
+<para>
+Here is the definition of <literal>kio_uiserver</literal>:
+</para>
+
+<programlisting>
+[Desktop Entry]
+Type=Service
+Name=kio_uiserver
+Exec=kio_uiserver
+X-DCOP-ServiceType=Unique
+X-KDE-StartupNotify=false
+</programlisting>
+
+</simplesect>
+
+
+<simplesect id="services-usingdcopservices">
+<title>Using DCOP services</title>
+
+<para>
+A DCOP service is started with one of several methods in the KApplication
+class:
+</para>
+
+<programlisting>
+DCOPClient *client = kapp->dcopClient();
+client->attach();
+if (!client->isApplicationRegistered("kio_uiserver")) {
+    QString error;
+    if (KApplication::startServiceByName("kio_uiserver", QStringList(), &amp;error))
+        cout &lt;&lt; "Starting kioserver failed with message " &lt;&lt; error &lt;&lt; endl;
+}
+...
+QByteArray data, replyData;
+QCString replyType;
+QDataStream arg(data, IO_WriteOnly);
+arg &lt;&lt; true;
+if (!client->call("kio_uiserver", "UIServer", "setListMode(bool)", 
+                  data, replyType, replyData))
+    cout &lt;&lt; "Call to kio_uiserver failed" &lt;&lt; endl;
+...
+</programlisting>
+
+<para>
+Note that the example of a DCOP call given here uses explicit marshalling
+of arguments. Often you will want to use a stub generated by dcopidl2cpp
+instead, because it is much simpler and less error prone.
+</para>
+
+<para>
+In the example given here, the service was started "by name", i.e. the
+first argument to <function>KApplication::startServiceByName()</function> is
+the name is appearing in the <literal>Name</literal> line of the desktop
+file. An alternative is to use
+<function>KApplication::startServiceByDesktopName()</function>, which takes
+the file name of its desktop file as argument, i.e. in this case
+<literal>"kio_uiserver.desktop"</literal>.
+</para>
+
+<para>
+All these calls take a list of URLs as a second argument, which is given
+to the service on the command line. The third argument is a pointer to a
+<classname>QString</classname>. If starting the service fails, this argument
+is set to a translated error message.
+</para>
+
+</simplesect>
+
+</sect1>
+
+
+<sect1 id="components-mime">
+<title>MIME types</title>
+
+<simplesect id="mime-whataremimetypes">
+<title>What are MIME types?</title>
+
+<para>
+MIME types are used to describe the content type of files or data
+chunks. Originally they were introduced in order to allow sending around image
+or sound files etc. by e-mail (MIME stands for "Multipurpose Internet Mail
+Extensions"). Later this system was also used by web browsers to determine how
+to present data sent by a web server to the user. For example, an HTML page
+has a MIME type "text/html", a postscript file "application/postscript".  In
+KDE, this concept is used at a variety of places:
+</para>
+
+<itemizedlist>
+
+<listitem><para>
+In <application>Konqueror</application>'s icon view, files are represented by
+icons. Each MIME type has a certain associated icon shown here.
+</para></listitem>
+
+<listitem><para>
+When you click onto a file icon or a file name in
+<application>Konqueror</application>, either the file is shown in an embedded
+view, or an application associated with the file type is opened.  
+</para></listitem>
+
+<listitem><para>
+When you drag and drop some data from one application to another (or
+within the same application), the drop target may choose to accept only
+certain data types. Furthermore, it will handle image data different
+from textual data.
+</para></listitem>
+
+<listitem><para>
+Clipboard data has a MIME type. Traditionally, X programs only handle 
+pixmaps or texts, but with Qt, there are no restrictions on the data type.
+</para></listitem>
+
+</itemizedlist>
+
+<para>
+From the above examples, it is clear that MIME handling is a complex issue.
+First, it is necessary to establish a mapping from file names to MIME types.
+KDE goes one step further in allowing even file contents to be mapped to
+MIME types, for cases in which the file name is not available. Second, it
+is necessary to map MIME types to applications or libraries which can view
+or edit a file with a certain type, or create a thumbnail picture for it.
+</para>
+
+<para>
+There is a variety of APIs to figure out the MIME type of data or files. In 
+general, there is a certain speed/reliability trade-off you have to make. You 
+can find out the type of a file by examining only its file name (i.e. in most 
+cases the file name extension). For example, a file
+<filename>foo.jpg</filename> is normally "image/jpeg". In cases where the
+extension is stripped off this is not safe, and you actually  have to look at
+the contents of the file. This is of course slower, in  particular for files
+that have to be downloaded via HTTP first. The content-based method is based
+on the file <filename>KDEDIR/share/mimelnk/magic</filename> and therefore
+difficult to extend. But in general, MIME type information can easily be made
+available to the system by installing a <literal>.desktop</literal> file, and
+it is efficiently and conveniently available through the KDE libraries.
+</para>
+
+</simplesect>
+
+
+<simplesect id="mime-definingmimetypes">
+<title>Defining MIME types</title>
+
+<para>
+Let us define a type <literal>"application/x-foo"</literal> for our new
+<application>foobar</application> program. To this end, you have to write a
+file <filename>foo.desktop</filename> and install it into
+<filename>KDEDIR/share/mimelnk/application</filename>. (This is the usual
+location, which may differ between distributions). This can be done by adding
+this to the <filename>Makefile.am</filename>:
+</para>
+
+<programlisting>
+mimedir = $(kde_mimedir)/application
+mime_DATA = foo.desktop
+EXTRA_DIST = $(mime_DATA)
+</programlisting>
+
+<para>
+The file <filename>foo.desktop</filename> should look as follows:
+</para>
+
+<programlisting>
+[Desktop Entry]
+Type=MimeType
+MimeType=application/x-foo
+Icon=fooicon
+Patterns=*.foo;
+DefaultApp=foobar
+Comment=Foo Data File
+Comment[de]=Foo Datei
+</programlisting>
+
+<para>
+The <literal>"Comment"</literal> entry is supposed to be translated. Since the
+<filename>.desktop</filename> file  specifies an icon, you should also install
+an icon <filename>fooicon.png</filename>, which represents the file e.g. in
+<application>Konqueror</application>.
+</para>
+
+<para>
+In the KDE libraries, such a type definition is mapped to an instance of the 
+class <ulink url="kdeapi:kio/KMimeType.html">KMimeType</ulink>.
+Use this like in the following example:
+</para>
+
+<programlisting>
+KMimeType::Ptr type = KMimeType::mimeType("application/x-foo");
+cout &lt;&lt; "Type:    " &lt;&lt; type->name() &lt; endl;
+cout &lt;&lt; "Icon:    " &lt;&lt; type->icon() &lt; endl;
+cout &lt;&lt; "Comment: " &lt;&lt; type->icon() &lt; endl;
+QStringList patterns = type->patterns();
+QStringList::ConstIterator it;
+for (it = patterns.begin(); it != patterns.end(); ++it)
+  cout &lt;&lt; "Pattern: " &lt;&lt; (*it) &lt;&lt; endl;
+</programlisting>
+
+</simplesect>
+
+
+<simplesect id="mime-determiningmimetypes">
+<title>Determining the MIME type of data</title>
+
+<para>
+The fast method for determining the type of a file is
+<function>KMimeType::findByURL()</function>. This looks for the URL string and
+in most cases determines the type from the extension. For certain protocols
+(e.g. http, man, info), this mechanism is not used. For example, CGI scripts
+on web servers written in Perl often have the extension
+<literal>.pl</literal>, which would indicate a
+<literal>"text/x-perl"</literal> type. However, we file delivered by the
+server is the output of this script, which is normally HTML. For such a case,
+<function>KMimeType::findByURL()</function> returns the MIME type
+<literal>"application/octet-stream"</literal> (available through
+<function>KMimeType::defaultMimeType()</function>), which indicates a failure
+to find out the type.
+</para>
+
+<programlisting>
+KMimeType::Ptr type = KMimeType::findByURL("/home/bernd/foobar.jpg");
+if (type->name() == KMimeType::defaultMimeType())
+    cout &lt;&lt; "Could not find out type" &lt;&lt; endl;
+else
+    cout &lt;&lt; "Type: " &lt;&lt; type->name() &lt;&lt; endl;
+</programlisting>
+
+<para>
+(this method has some more arguments, but these are undocumented, so simply
+forget about them.)
+</para>
+
+<para>
+You may want to find out a MIME from the contents of file instead of
+the file name. This is more reliable, but also slower, as it requires
+reading a part of the file. This is done with the 
+<ulink url="kdeapi:kio/KMimeMagic.html">KMimeMagic</ulink> 
+class, which has different error handling:
+</para>
+
+<programlisting>
+KMimeMagicResult *result = KMimeMagic::self()->findFileType("/home/bernd/foobar.jpg");
+if (!result || !result->isValid())
+    cout &lt;&lt; "Could not find out type" &lt;&lt; endl;
+else
+    cout &lt;&lt; "Type: " &lt;&lt; result->mimeType() &lt;&lt; endl;
+</programlisting>
+
+<para>
+As a variant of this function, you can also determine the type of a memory
+chunk. This is e.g. used in <application>Kate</application> in order to find
+out the highlighting mode:
+</para>
+
+<programlisting>
+QByteArray array;
+...
+KMimeMagicResult *result = KMimeMagic::self()->findBufferType(array);
+if (!result || !result->isValid())
+    cout &lt;&lt; "Could not find out type" &lt;&lt; endl;
+else
+    cout &lt;&lt; "Type: " &lt;&lt; result->mimeType() &lt;&lt; endl;
+</programlisting>
+
+<para>
+Of course, even KMimeMagic is only able to determine a file type from the
+contents of a local file. For remote files, there is a further possibility:
+</para>
+
+<programlisting>
+KURL url("http://developer.kde.org/favicon.ico");
+QString type = KIO::NetAccess::mimetype(url);
+if (type == KMimeType::defaultMimeType())
+    cout &lt;&lt; "Could not find out type" &lt;&lt; endl;
+else
+    cout &lt;&lt; "Type: " &lt;&lt; type &lt;&lt; endl;
+</programlisting>
+
+<para>
+This starts a KIO job to download a part of the file and check this.
+Note that this function is perhaps quite slow and blocks the program. Normally
+you will only want to use this if <function>KMimeType::findByURL()</function>
+has returned <literal>"application/octet-stream"</literal>.
+</para>
+
+<para>
+On the other hand, if you do not want to block your application, you can also 
+explicitly start the KIO job and connect to some of its signals:
+</para>
+
+<programlisting>
+void FooClass::findType()
+{
+    KURL url("http://developer.kde.org/favicon.ico");
+    KIO::MimetypeJob *job = KIO::mimetype(url);
+    connect( job, SIGNAL(result(KIO::Job*)),
+             this, SLOT(mimeResult(KIO::Job*)) );
+}
+
+void FooClass::mimeResult(KIO::Job *job)
+{
+    if (job->error())
+        job->showErrorDialog();
+    else
+        cout &lt;&lt; "MIME type: " &lt;&lt; ((KIO::MimetypeJob *)job)->mimetype() &lt;&lt; endl;
+}
+</programlisting>
+
+</simplesect>
+
+
+<simplesect id="mime-mappingmimetypes">
+<title>Mapping a MIME type to an application or service</title>
+
+<para>
+When an application is installed, it installs a <literal>.desktop</literal>
+file which contains a list of MIME types this application can load. Similarly,
+components like KParts make this information available by their service
+<literal>.desktop</literal> files. So in general, there are several programs
+and components which can process a given MIME type. You can obtain such a list
+from the class <classname>KServiceTypeProfile</classname>:
+</para>
+
+<programlisting>
+KService::OfferList offers = KServiceTypeProfile::offers("text/html", "Application");
+KService::OfferList::ConstIterator it;
+for (it = offers.begin(); it != offers.end(); ++it) {
+    KService::Ptr service = (*it);
+    cout &lt;&lt; "Name: " &lt;&lt; service->name() &lt;&lt; endl;
+}
+</programlisting>
+
+<para>
+The return value of this function is a list of service offers. A
+<classname>KServiceOffer</classname> object packages a KService::Ptr together
+with a preference number. The list returned by
+<function>KServiceTypeProfile::offers()</function> is ordered by the user's
+preference. The user can change this by calling <command>"keditfiletype
+text/html"</command> or choosing <guimenuitem>Edit File Type</guimenuitem> on
+<application>Konqueror</application>'s context menu on a HTML file.
+</para>
+
+<para>
+In the above example, an offer list of the applications supporting
+<literal>text/html</literal> was requested. This will - among others - contain
+HTML editors like <application>Quanta Plus</application>. You can also replace
+the second argument <literal>"Application"</literal> by
+<literal>"KParts::ReadOnlyPart"</literal>. In that case, you get a list of
+embedable components for presenting HTML content, for example KHTML. 
+</para>
+
+<para>
+In most cases, you are not interested in the list of all service offers
+for a combination of MIME type and service type. There is a convenience
+function which gives you only the service offer with the highest preference:
+</para>
+
+<programlisting>
+KService::Ptr offer = KServiceTypeProfile::preferredService("text/html", "Application");
+if (offer)
+    cout &lt;&lt; "Name: " &lt;&lt; service->name() &lt;&lt; endl;
+else
+    cout &lt;&lt; "No appropriate service found" &lt;&lt; endl;
+</programlisting>
+
+<para>
+For even more complex queries, there is a full-blown CORBA-like
+<ulink url="kdeapi:kio/KTrader.html">trader</ulink>.
+</para>
+
+<para>
+In order to run an application service with some URLs, use 
+<ulink url="kdeapi:kio/KRun.html">KRun</ulink>:
+</para>
+
+<programlisting>
+KURL::List urlList;
+urlList &lt;&lt; "http://www.ietf.org/rfc/rfc1341.txt?number=1341";
+urlList &lt;&lt; "http://www.ietf.org/rfc/rfc2046.txt?number=2046";
+KRun::run(offer.service(), urlList);
+</programlisting>
+
+</simplesect>
+
+
+<simplesect id="mime-misc">
+<title>Miscellaneous</title>
+
+<para>
+In this section, we want to list some APIs which are loosely related
+to the previous discussion.
+</para>
+
+<para>
+Getting an icon for a URL. This looks for the type of the URL
+and returns the associated icon.
+</para>
+
+<programlisting>
+KURL url("ftp://ftp.kde.org/pub/incoming/wibble.c");
+QString icon = KMimeType::iconForURL(url);
+</programlisting>
+
+<para>
+Running a URL. This looks for the type of the URL and starts the
+user's preferred program associated with this type.
+</para>
+
+<programlisting>
+KURL url("http://dot.kde.org");
+new KRun(url);
+</programlisting>
+
+</simplesect>
+
+</sect1>
+
+
+<sect1 id="nettransparency">
+<title>Network transparency</title>
+
+<simplesect id="nettransparency-intro">
+<title>Introduction</title>
+
+<para>
+In the age of the world wide web, it is of essential importance that desktop
+applications can access resources over the internet: they should be able to
+download files from a web server, write files to an ftp server or read mails
+from a web server. Often, the ability to access files regardless of their
+location is called <emphasis>network transparency</emphasis>.
+</para>
+
+<para>
+In the past, different approaches to this goals were implemented. The old NFS
+file system is an attempt to implement network transparency on the level of
+the POSIX API. While this approach works quite well in local, closely coupled
+networks, it does not scale for resources to which access is unreliable and
+possibly slow. Here, <emphasis>asynchronicity</emphasis> is important. While
+you are waiting for your web browser to download a page, the user interface
+should not block. Also, the page rendering should not begin when the page is
+completely available, but should updated regularly as data comes in.
+</para>
+
+<para>
+In the KDE libraries, network transparency is implemented in the KIO API. The
+central concept of this architecture is an IO <emphasis>job</emphasis>. A job
+may copy, or delete files or similar things. Once a job is started, it works
+in the background and does not block the application. Any communication from
+the job back to the application - like delivering data or progress information
+- is done integrated with the Qt event loop.
+</para>
+
+<para>
+Background operation is achieved by starting <emphasis>ioslaves</emphasis> to
+perform certain tasks. ioslaves are started as separate processes and are
+communicated with through UNIX domain sockets. In this way, no multi-threading
+is necessary and unstable slaves can not crash the application that uses them.
+</para>
+
+<para>
+File locations are expressed by the widely used URLs. But in KDE, URLs do not
+only expand the range of addressable files beyond the local file system. It
+also goes in the opposite direction - e.g. you can browse into tar archives.
+This is achieved by nesting URLs. For example, a file in a tar archive on 
+a http server could have the URL
+</para>
+
+<programlisting>
+http://www-com.physik.hu-berlin.de/~bernd/article.tgz#tar:/paper.tex
+</programlisting>
+
+</simplesect>
+
+
+<simplesect id="nettransparency-usingkio">
+<title>Using KIO</title>
+
+<para>
+In most cases, jobs are created by calling functions in the KIO namespace.
+These functions take one or two URLs as arguments, and possible other
+necessary parameters. When the job is finished, it emits the signal
+<literal>result(KIO::Job*)</literal>. After this signal has been emitted, the job
+deletes itself. Thus, a typical use case will look like this:
+</para>
+
+<programlisting>
+void FooClass::makeDirectory()
+{
+    SimpleJob *job = KIO::mkdir(KURL("file:/home/bernd/kiodir"));
+    connect( job, SIGNAL(result(KIO::Job*)), 
+             this, SLOT(mkdirResult(KIO::Job*)) );
+}
+
+void FooClass::mkdirResult(KIO::Job *job)
+{
+    if (job->error())
+        job->showErrorDialog();
+    else
+        cout &lt;&lt; "mkdir went fine" &lt;&lt; endl;
+}
+</programlisting>
+
+<para>
+Depending on the type of the job, you may connect also to other
+signals.
+</para>
+
+<para>
+Here is an overview over the possible functions:
+</para>
+
+<variablelist>
+
+<varlistentry><term>KIO::mkdir(const KURL &amp;url, int permission)</term>
+<listitem><para>
+Creates a directory, optionally with certain permissions.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::rmdir(const KURL &amp;url)</term>
+<listitem><para>
+Removes a directory.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::chmod(const KURL &amp;url, int permissions)</term>
+<listitem><para>
+Changes the permissions of a file.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::rename(const KURL &amp;src, const KURL &amp;dest, 
+                                bool overwrite)</term>
+<listitem><para>
+Renames a file.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::symlink(const QString &amp;target, const KURL &amp;dest, 
+                                 bool overwrite, bool showProgressInfo)</term>
+<listitem><para>
+Creates a symbolic link.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::stat(const KURL &amp;url, bool showProgressInfo)</term>
+<listitem><para>
+Finds out certain information about the file, such as size, modification 
+time and permissions. The information can be obtained from 
+KIO::StatJob::statResult() after the job has finished.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::get(const KURL &amp;url, bool reload, bool showProgressInfo)</term>
+<listitem><para>
+Transfers data from a URL.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::put(const KURL &amp;url, int permissions, bool overwrite, 
+                             bool resume, bool showProgressInfo)</term>
+<listitem><para>
+Transfers data to a URL.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::http_post(const KURL &amp;url, const QByteArray &amp;data, 
+                                    bool showProgressInfo)</term>
+<listitem><para>Posts data. Special for HTTP.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::mimetype(const KURL &amp;url, bool showProgressInfo)</term>
+<listitem><para>
+Tries to find the MIME type of the URL. The type can be obtained from 
+KIO::MimetypeJob::mimetype() after the job has finished.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::file_copy(const KURL &amp;src, const KURL &amp;dest, int permissions,
+                                   bool overwrite, bool resume, bool showProgressInfo)</term>
+<listitem><para>
+Copies a single file.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::file_move(const KURL &amp;src, const KURL &amp;dest, int permissions,
+                                   bool overwrite, bool resume, bool showProgressInfo)</term>
+<listitem><para>
+Renames or moves a single file.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::file_delete(const KURL &amp;url, bool showProgressInfo)</term>
+<listitem><para>
+Deletes a single file.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::listDir(const KURL &amp;url, bool showProgressInfo)</term>
+<listitem><para>
+Lists the contents of a directory. Each time some new entries are known, the
+signal KIO::ListJob::entries() is emitted.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::listRecursive(const KURL &amp;url, bool showProgressInfo)</term>
+<listitem><para>
+Similar to the listDir() function, but this one is recursive.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::copy(const KURL &amp;src, const KURL &amp;dest, bool showProgressInfo)</term>
+<listitem><para>
+Copies a file or directory. Directories are copied recursively.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::move(const KURL &amp;src, const KURL &amp;dest, bool showProgressInfo)</term>
+<listitem><para>
+Moves or renames a file or directory.
+</para></listitem>
+</varlistentry>
+
+<varlistentry><term>KIO::del(const KURL &amp;src, bool shred, bool showProgressInfo)</term>
+<listitem><para>
+Deletes a file or directory.
+</para></listitem>
+</varlistentry>
+
+</variablelist>
+
+</simplesect>
+
+
+<simplesect id="nettransparency-direntries">
+<title>Directory entries</title>
+
+<para>
+Both the KIO::stat() and KIO::listDir() jobs return their results as a type
+UDSEntry, UDSEntryList resp. The latter is defined as QValueList&lt;UDSEntry&gt;.
+The acronym UDS stands for "Universal directory service". The principle behind 
+it is that the a directory entry only carries the information which an ioslave
+can provide, not more. For example, the http slave does not provide any 
+information about access permissions or file owners.
+Instead, a UDSEntry is a list of UDSAtoms. Each atom provides a specific piece
+of information. It consists of a type stored in m_uds and either an integer
+value in m_long or a string value in m_str, depending on the type.
+</para>
+
+<para>
+The following types are currently defined:
+</para>
+
+<itemizedlist>
+
+<listitem><para>
+UDS_SIZE (integer) - Size of the file.
+</para></listitem>
+
+<listitem><para>
+UDS_USER (string) - User owning the file.
+</para></listitem>
+
+<listitem><para>
+UDS_GROUP (string) - Group owning the file.
+</para></listitem>
+
+<listitem><para>
+UDS_NAME (string) - File name.
+</para></listitem>
+
+<listitem><para>
+UDS_ACCESS (integer) - Permission rights of the file, as e.g. stored
+by the libc function stat() in the st_mode field.
+</para></listitem>
+
+<listitem><para>
+UDS_FILE_TYPE (integer) - The file type, as e.g. stored by stat() in the 
+st_mode field. Therefore you can use the usual libc macros like S_ISDIR to 
+test this value. Note that the data provided by ioslaves corresponds to 
+stat(), not lstat(), i.e. in case of symbolic links, the file type here is 
+the type of the file pointed to by the link, not the link itself.
+</para></listitem>
+
+<listitem><para>
+UDS_LINK_DEST (string) - In case of a symbolic link, the name of the file 
+pointed to.
+</para></listitem>
+
+<listitem><para>
+UDS_MODIFICATION_TIME (integer) - The time (as in the type time_t)  when the
+file was last modified, as e.g. stored by stat() in the st_mtime field.
+</para></listitem>
+
+<listitem><para>
+UDS_ACCESS_TIME (integer) - The time when the file was last accessed, as 
+e.g. stored by stat() in the st_atime field.
+</para></listitem>
+
+<listitem><para>
+UDS_CREATION_TIME (integer) - The time when the file was created, as e.g. 
+stored by stat() in the st_ctime field. 
+</para></listitem>
+
+<listitem><para>
+UDS_URL (string) - Provides a URL of a file, if it is not simply the
+the concatenation of directory URL and file name.
+</para></listitem>
+
+<listitem><para>
+UDS_MIME_TYPE (string) - MIME type of the file
+</para></listitem>
+
+<listitem><para>
+UDS_GUESSED_MIME_TYPE (string) - MIME type of the file as guessed by the 
+slave. The difference to the previous type is that the one provided here
+should not be taken as reliable (because determining it in a reliable way
+would be too expensive). For example, the KRun class explicitly checks the
+MIME type if it does not have reliable information.
+</para></listitem>
+
+</itemizedlist>
+
+<para>
+Although the way of storing information about files in a
+<classname>UDSEntry</classname> is flexible and practical from the ioslave
+point of view, it is a mess to use for the application programmer. For
+example, in order to find out the MIME type of the file, you have to iterate
+over all atoms and test whether <literal>m_uds</literal> is
+<literal>UDS_MIME_TYPE</literal>. Fortunately, there is an API which is a lot
+easier to use: the class <classname>KFileItem</classname>.
+</para>
+
+</simplesect>
+
+
+<simplesect id="nettransparency-syncuse">
+<title>Synchronous usage</title>
+
+<para>
+Often, the asynchronous API of KIO is too complex to use and therefore 
+implementing full asynchronicity is not a priority. For example, in a program 
+that can only handle one document file at a time, there is little that can be
+done while the program is downloading a file anyway. For these simple cases, 
+there is a mucher simpler API in the form of a set of static functions in
+KIO::NetAccess. For example, in order to copy a file, use
+</para>
+
+<programlisting>
+KURL source, target;
+source = ...;
+target = ...
+KIO::NetAccess::copy(source, target);
+</programlisting>
+
+<para>
+The function will return after the complete copying process has finished. Still,
+this method provides a progress dialog, and it makes sure that the application
+processes repaint events.
+</para>
+
+<para>
+A particularly interesting combination of functions is
+<function>download()</function> in combination with
+<function>removeTempFile()</function>. The former downloads a file from given
+URL and stores it in a temporary file with a unique name. The name is stored
+in the second argument. <emphasis>If</emphasis> the URL is local, the file is
+not downloaded, and instead the second argument is set to the local file
+name. The function <function>removeTempFile()</function> deletes the file
+given by its argument if the file is the result of a former download. If that
+is not the case, it does nothing. Thus, a very easy to use way of loading
+files regardless of their location is the following code snippet:
+</para>
+
+<programlisting>
+KURL url;
+url = ...;
+QString tempFile;
+if (KIO::NetAccess::download(url, tempFile) {
+    // load the file with the name tempFile
+    KIO::NetAccess::removeTempFile(tempFile);
+}
+</programlisting>
+
+</simplesect>
+
+
+<simplesect id="nettransparency-metadata">
+<title>Meta data</title>
+
+<para>
+As can be seen above, the interface to IO jobs is quite abstract and does not
+consider any exchange of information between application and IO slave that
+is protocol specific. This is not always appropriate. For example, you may give
+certain parameters to the HTTP slave to control its caching behavior or
+send a bunch of cookies with the request. For this need, the concept of meta
+data has been introduced. When a job is created, you can configure it by adding
+meta data to it. Each item of meta data consists of a key/value pair. For
+example, in order to prevent the HTTP slave from loading a web page from its
+cache, you can use:
+</para>
+ 
+<programlisting>
+void FooClass::reloadPage()
+{
+    KURL url("http://www.kdevelop.org/index.html");
+    KIO::TransferJob *job = KIO::get(url, true, false);
+    job->addMetaData("cache", "reload");
+    ...
+}
+</programlisting>
+
+<para>
+The same technique is used in the other direction, i.e. for communication from
+the slave to the application. The method
+<function>Job::queryMetaData()</function> asks for the value of the certain
+key delivered by the slave. For the HTTP slave, one such example is the key
+<literal>"modified"</literal>, which contains a (stringified representation of)
+the date when the web page was last modified. An example how you can use this
+is the following:
+</para>
+ 
+<programlisting>
+void FooClass::printModifiedDate()
+{
+    KURL url("http://developer.kde.org/documentation/kde2arch/index.html");
+    KIO::TransferJob *job = KIO::get(url, true, false);
+    connect( job, SIGNAL(result(KIO::Job*)),
+             this, SLOT(transferResult(KIO::Job*)) );
+}
+
+void FooClass::transferResult(KIO::Job *job)
+{
+    QString mimetype;
+    if (job->error())
+        job->showErrorDialog();
+    else {
+        KIO::TransferJob *transferJob = (KIO::TransferJob*) job;
+        QString modified = transferJob->queryMetaData("modified");
+        cout &lt;&lt; "Last modified: " &lt;&lt; modified &lt;&lt; endl;
+}
+</programlisting>
+
+</simplesect>
+
+
+<simplesect id="nettransparency-scheduling">
+<title>Scheduling</title>
+
+<para>
+When using the KIO API, you usually do not have to cope with the details of
+starting IO slaves and communicating with them. The normal use case is to
+start a job and with some parameters and handle the signals the jobs emits.
+</para>
+
+<para>
+Behind the curtains, the scenario is a lot more complicated. When you create a
+job, it is put in a queue. When the application goes back to the event loop,
+KIO allocates slave processes for the jobs in the queue.  For the first jobs
+started, this is trivial: an IO slave for the appropriate protocol is started.
+However, after the job (like a download from an http server) has finished, it
+is not immediately killed. Instead, it is put in a pool of idle slaves and
+killed after a certain time of inactivity (current 3 minutes). If a new request
+for the same protocol and host arrives, the slave is reused. The obvious 
+advantage is that for a series of jobs for the same host, the cost for creating
+new processes and possibly going through an authentication handshake is saved.
+</para>
+
+<para>
+Of course, reusing is only possible when the existing slave has already finished
+its previous job. when a new request arrives while an existing slave process is 
+still running, a new process must be started and used. In the API usage in the
+examples above, there are no limitation for creating new slave processes: if you
+start a consecutive series of downloads for 20 different files, then KIO will 
+start 20 slave processes. This scheme of assigning slaves to jobs is called 
+<emphasis>direct</emphasis>. It  not always the most appropriate scheme, as it
+may need much memory and put a high load on both the client and server machines.
+</para>
+
+<para>
+So there is a different way. You can <emphasis>schedule</emphasis> jobs. If
+you do this, only a limited number (currently 3) of slave processes for a
+protocol will be created. If you create more jobs than that, they are put in a
+queue and are processed when a slave process becomes idle. This is done as
+follows:
+</para>
+
+<programlisting>
+KURL url("http://developer.kde.org/documentation/kde2arch/index.html");
+KIO::TransferJob *job = KIO::get(url, true, false);
+KIO::Scheduler::scheduleJob(job);
+</programlisting>
+
+<para>
+A third possibility is <emphasis>connection oriented</emphasis>. For example,
+for the IMAP slave, it does not make any sense to start multiple processes for
+the same server. Only one IMAP connection at a time should be enforced. In
+this case, the application must explicitly deal with the notion of a slave. It
+has to deallocate a slave for a certain connection and then assign all jobs
+which should go through the same connection to the same slave. This can again
+be easily achieved by using the KIO::Scheduler:
+</para>
+
+<programlisting>
+KURL baseUrl("imap://bernd@albert.physik.hu-berlin.de");
+KIO::Slave *slave = KIO::Scheduler::getConnectedSlave(baseUrl);
+
+KIO::TransferJob *job1 = KIO::get(KURL(baseUrl, "/INBOX;UID=79374"));
+KIO::Scheduler::assignJobToSlave(slave, job1);
+
+KIO::TransferJob *job2 = KIO::get(KURL(baseUrl, "/INBOX;UID=86793"));
+KIO::Scheduler::assignJobToSlave(slave, job2);
+
+...
+
+KIO::Scheduler::disconnectSlave(slave);
+</programlisting>
+
+<para>
+You may only disconnect the slave after all jobs assigned to it are guaranteed
+to be finished.
+</para>
+
+</simplesect>
+
+
+<simplesect id="nettransparency-definingslaves">
+<title>Defining an ioslave</title>
+
+<para>
+In the following we discuss how you can add a new ioslave to the system.
+In analogy to services, new ioslaves are advertised to the system by
+installing a little configuration file. The following Makefile.am
+snippet installs the ftp protocol:
+</para>
+
+<programlisting>
+protocoldir = $(kde_servicesdir)
+protocol_DATA = ftp.protocol
+EXTRA_DIST = $(mime_DATA)
+</programlisting>
+
+<para>
+The contents of the file ftp.protocol is as follows:
+</para>
+
+<programlisting>
+[Protocol]
+exec=kio_ftp
+protocol=ftp
+input=none
+output=filesystem
+listing=Name,Type,Size,Date,Access,Owner,Group,Link,
+reading=true
+writing=true
+makedir=true
+deleting=true
+Icon=ftp
+</programlisting>
+
+<para>
+The <literal>"protocol"</literal> entry defines for which protocol this slave
+is responsible. <literal>"exec"</literal> is (in contrast what you would
+expect naively) the name of the library that implements the slave. When the
+slave is supposed to start, the <command>"kdeinit"</command> executable is
+started which in turn loads this library into its address space. So in
+practice, you can think of the running slave as a separate process although it
+is implemented as library. The advantage of this mechanism is that it saves a
+lot of memory and  reduces the time needed by the runtime linker.
+</para>
+
+<para>
+The "input" and "output" lines are not used currently.
+</para>
+
+<para>
+The remaining lines in the <literal>.protocol</literal> file define which
+abilities the slave has. In general, the features a slave must implement are
+much simpler than the features the KIO API provides for the application. The
+reason for this is that complex jobs are scheduled to a couple of subjobs. For
+example, in order to list a directory recursively, one job will be started for
+the toplevel directory. Then for each subdirectory reported back, new subjobs
+are started. A scheduler in KIO makes sure that not too many jobs are active
+at the same time. Similarly, in order to copy a file within a protocol that
+does not support copying directly (like the <literal>ftp:</literal> protocol),
+KIO can read the source file and then write the data to the destination
+file. For this to work, the <literal>.protocol</literal> must advertise the
+actions its slave supports.
+</para>
+
+<para>
+Since slaves are loaded as shared libraries, but constitute standalone programs,
+their code framework looks a bit different from normal shared library plugins.
+The function which is called to start the slave is called
+<function>kdemain()</function>. This function does some initializations and
+then goes into an event loop and waits for requests by the application using
+it. This looks as follows:
+</para>
+
+<programlisting>
+extern "C" { int kdemain(int argc, char **argv); }
+
+int kdemain(int argc, char **argv)
+{
+    KLocale::setMainCatalogue("kdelibs");
+    KInstance instance("kio_ftp");
+    (void) KGlobal::locale();
+
+    if (argc != 4) {
+        fprintf(stderr, "Usage: kio_ftp protocol "
+                        "domain-socket1 domain-socket2\n");
+        exit(-1);
+    }
+
+    FtpSlave slave(argv[2], argv[3]);
+    slave.dispatchLoop();
+    return 0;
+}
+</programlisting>
+
+</simplesect>
+
+
+<simplesect id="nettransparency-implementingslaves">
+<title>Implementing an ioslave</title>
+
+<para>
+Slaves are implemented as subclasses of <classname>KIO::SlaveBase</classname>
+(FtpSlave in the above example). Thus, the actions listed in the
+<literal>.protocol</literal> correspond to certain virtual functions in
+<classname>KIO::SlaveBase</classname> the slave implementation must
+reimplement. Here is a list of possible actions and the corresponding virtual
+functions:
+</para>
+
+<variablelist>
+
+<varlistentry><term>reading - Reads data from a URL</term>
+<listitem><para>void get(const KURL &amp;url)</para></listitem></varlistentry>
+
+<varlistentry><term>writing - Writes data to a URL and create the file if it does not exist yet.</term>
+<listitem><para>void put(const KURL &amp;url, int permissions, bool overwrite, bool resume)</para></listitem></varlistentry>
+
+<varlistentry><term>moving - Renames a file.</term>
+<listitem><para>void rename(const KURL &amp;src, const KURL &amp;dest, bool overwrite)</para></listitem></varlistentry>
+
+<varlistentry><term>deleting - Deletes a file or directory.</term>
+<listitem><para>void del(const KURL &amp;url, bool isFile)</para></listitem></varlistentry>
+
+<varlistentry><term>listing - Lists the contents of a directory.</term>
+<listitem><para>void listDir(const KURL &amp;url)</para></listitem></varlistentry>
+
+<varlistentry><term>makedir - Creates a directory.</term>
+<listitem><para>void mkdir(const KURL &amp;url, int permissions)</para></listitem></varlistentry>
+
+</variablelist>
+
+<para>
+Additionally, there are reimplementable functions not listed in the <literal>.protocol</literal>
+file. For these operations, KIO automatically determines whether they are supported
+or not (i.e. the default implementation returns an error).
+</para>
+
+<variablelist>
+
+<varlistentry><term>Delivers information about a file, similar to the C function stat().</term>
+<listitem><para>void stat(const KURL &amp;url)</para></listitem></varlistentry>
+
+<varlistentry><term>Changes the access permissions of a file.</term>
+<listitem><para>void chmod(const KURL &amp;url, int permissions)</para></listitem></varlistentry>
+
+<varlistentry><term>Determines the MIME type of a file.</term>
+<listitem><para>void mimetype(const KURL &amp;url)</para></listitem></varlistentry>
+
+<varlistentry><term>Copies a file.</term>
+<listitem><para>copy(const KURL &amp;url, const KURL &amp;dest, int permissions, bool overwrite)</para></listitem></varlistentry>
+
+<varlistentry><term>Creates a symbolic link.</term>
+<listitem><para>void symlink(const QString &amp;target, const KURL &amp;dest, bool overwrite)</para></listitem></varlistentry>
+
+</variablelist>
+
+<para>
+All these implementation should end with one of two calls: If the operation
+was successful, they should call <literal>finished()</literal>. If an error has occurred,
+<literal>error()</literal> should be called with an error code as first argument and a
+string in the second. Possible error codes are listed as enum
+<type>KIO::Error</type>. The second argument is usually the URL in
+question. It is used e.g. in <function>KIO::Job::showErrorDialog()</function>
+in order to parameterize the human-readable error message.
+</para>
+
+<para>
+For slaves that correspond to network protocols, it might be interesting to 
+reimplement the method <function>SlaveBase::setHost()</function>. This is
+called to tell the slave process about the host and port, and the user name
+and password to log in. In general, meta data set by the application can be
+queried by <function>SlaveBase::metaData()</function>. You can check for the
+existence of meta data of a certain key with
+<function>SlaveBase::hasMetaData()</function>.
+</para>
+
+</simplesect>
+
+
+<simplesect id="nettransparency-communication">
+<title>Communicating back to the application</title>
+
+<para>
+Various actions implemented in a slave need some way to communicate data back
+to the application using the slave process:
+</para>
+
+<itemizedlist>
+
+<listitem><para>
+<function>get()</function> sends blocks of data. This is done with
+<function>data()</function>, which takes a <classname>QByteArray</classname>
+as argument. Of course, you do not need to send all data at once. If you send
+a large file, call <function>data()</function> with smaller data blocks, so
+the application can process them. Call <function>finished()</function> when
+the transfer is finished.
+</para></listitem>
+    
+<listitem><para>
+<function>listDir()</function> reports information about the entries of a
+directory. For this purpose, call <function>listEntries()</function> with a
+<classname>KIO::UDSEntryList</classname> as argument. Analogously to
+<function>data()</function>, you can call this several times. When you are
+finished, call <function>listEntry()</function> with the second argument set
+to true. You may also call <function>totalSize()</function> to report the
+total number of directory entries, if known.
+</para></listitem>
+
+<listitem><para>
+<function>stat()</function> reports information about a file like size, MIME
+type, etc. Such information is packaged in a
+<classname>KIO::UDSEntry</classname>, which will be discussed below. Use
+<function>statEntry()</function> to send such an item to the application.
+</para></listitem>
+
+<listitem><para>
+<function>mimetype()</function> calls <function>mimeType()</function> with a
+string argument.
+</para></listitem>
+
+<listitem><para>
+<function>get()</function> and <function>copy()</function> may want to provide
+progress information. This is done with the methods
+<function>totalSize()</function>, <function>processedSize()</function>,
+<function>speed()</function>. The total size and processed size are reported
+as bytes, the speed as bytes per second.
+</para></listitem>
+
+<listitem><para>
+You can send arbitrary key/value pairs of meta data with
+<function>setMetaData()</function>.
+</para></listitem>
+
+</itemizedlist>
+
+</simplesect>
+
+
+<simplesect id="nettransparency-interacting">
+<title>Interacting with the user</title>
+
+<para>
+Sometimes a slave has to interact with the user. Examples include informational
+messages, authentication dialogs and confirmation dialogs when a file is about
+to be overwritten.
+</para>
+
+<itemizedlist>
+
+<listitem><para>
+<function>infoMessage()</function> - This is for informational feedback, such
+as the message "Retrieving data from &lt;host&gt;" from the http slave, which
+is often displayed in the status bar of the program. On the application side,
+this method corresponds to the signal
+<function>KIO::Job::infoMessage()</function>.
+</para></listitem>
+
+<listitem><para>
+<function>warning()</function> - Displays a warning in a message box with
+<function>KMessageBox::information()</function>. If a message box is still
+open from a former call of warning() from the same slave process, nothing
+happens.
+</para></listitem>
+
+<listitem><para>
+<function>messageBox()</function> - This is richer than the previous
+method. It allows to open a message box with text and caption and some
+buttons. See the enum <type>SlaveBase::MessageBoxType</type> for reference.
+</para></listitem>
+
+<listitem><para>
+<function>openPassDlg()</function> - Opens a dialog for the input of user name
+and password.
+</para></listitem>
+
+</itemizedlist>
+
+</simplesect>
+
+</sect1>
+
+</chapter>
+
+
+
+<appendix id="misc">
+<title>Licensing</title>
+
+&underFDL;
+&underGPL;
+
+</appendix>
+
+</book>
diff --git a/doc/kdearch/joinbevel.png b/doc/kdearch/joinbevel.png
new file mode 100644
index 00000000..584b6bd4
--- /dev/null
+++ b/doc/kdearch/joinbevel.png
diff --git a/doc/kdearch/joinmiter.png b/doc/kdearch/joinmiter.png
new file mode 100644
index 00000000..e5d94b13
--- /dev/null
+++ b/doc/kdearch/joinmiter.png
diff --git a/doc/kdearch/joinround.png b/doc/kdearch/joinround.png
new file mode 100644
index 00000000..9a8bbe93
--- /dev/null
+++ b/doc/kdearch/joinround.png
diff --git a/doc/kdearch/konqi-mirrored.png b/doc/kdearch/konqi-mirrored.png
new file mode 100644
index 00000000..5145c0ee
--- /dev/null
+++ b/doc/kdearch/konqi-mirrored.png
diff --git a/doc/kdearch/konqi-normal.png b/doc/kdearch/konqi-normal.png
new file mode 100644
index 00000000..c16e1475
--- /dev/null
+++ b/doc/kdearch/konqi-normal.png
diff --git a/doc/kdearch/konqi-rotated.png b/doc/kdearch/konqi-rotated.png
new file mode 100644
index 00000000..157e82dd
--- /dev/null
+++ b/doc/kdearch/konqi-rotated.png
diff --git a/doc/kdearch/konqi-sheared.png b/doc/kdearch/konqi-sheared.png
new file mode 100644
index 00000000..ee645f87
--- /dev/null
+++ b/doc/kdearch/konqi-sheared.png
diff --git a/doc/kdearch/kview-menu.png b/doc/kdearch/kview-menu.png
new file mode 100644
index 00000000..0e57e721
--- /dev/null
+++ b/doc/kdearch/kview-menu.png
diff --git a/doc/kdearch/opengl.png b/doc/kdearch/opengl.png
new file mode 100644
index 00000000..2489777d
--- /dev/null
+++ b/doc/kdearch/opengl.png
diff --git a/doc/kdearch/penstyles.png b/doc/kdearch/penstyles.png
new file mode 100644
index 00000000..7e976bcd
--- /dev/null
+++ b/doc/kdearch/penstyles.png
diff --git a/doc/kdearch/whatsthis.png b/doc/kdearch/whatsthis.png
new file mode 100644
index 00000000..4bdba093
--- /dev/null
+++ b/doc/kdearch/whatsthis.png
diff --git a/doc/kdevelop/Makefile.am b/doc/kdevelop/Makefile.am
new file mode 100644
index 00000000..41691557
--- /dev/null
+++ b/doc/kdevelop/Makefile.am
@@ -0,0 +1,3 @@
+KDE_LANG = en
+KDE_DOCS = AUTO
+
diff --git a/doc/kdevelop/SF-general.png b/doc/kdevelop/SF-general.png
new file mode 100644
index 00000000..0824c835
--- /dev/null
+++ b/doc/kdevelop/SF-general.png
diff --git a/doc/kdevelop/SF-indent.png b/doc/kdevelop/SF-indent.png
new file mode 100644
index 00000000..d84cd469
--- /dev/null
+++ b/doc/kdevelop/SF-indent.png
diff --git a/doc/kdevelop/SF-other.png b/doc/kdevelop/SF-other.png
new file mode 100644
index 00000000..750f112b
--- /dev/null
+++ b/doc/kdevelop/SF-other.png
diff --git a/doc/kdevelop/adv-build-management.docbook b/doc/kdevelop/adv-build-management.docbook
new file mode 100644
index 00000000..e589a007
--- /dev/null
+++ b/doc/kdevelop/adv-build-management.docbook
@@ -0,0 +1,128 @@
+<chapter id="adv-build-management">
+<title>Advanced Build Management</title>
+<indexterm zone="adv-build-management"><primary>&automake;</primary></indexterm>
+
+<sect1 id="buildconfigurations">
+<title>Multiple Build Configurations</title>
+<indexterm zone="buildconfigurations"><primary>build configurations</primary><secondary>multiple</secondary></indexterm>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect1> <!-- buildconfigurations -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="crosscompiling">
+<title>Cross-Compiling</title>
+<indexterm zone="crosscompiling"><primary>cross compiling</primary></indexterm>
+<indexterm zone="crosscompiling"><primary>compiling</primary><secondary>cross</secondary></indexterm>
+<indexterm zone="crosscompiling"><primary><option>--host</option></primary></indexterm>
+
+<para>
+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 <ulink url="info://gcc/Cross-Compiler">GCC info pages</ulink> for
+more information. Some &Linux; distributions also provide binary packages.
+</para>
+
+<para>
+An <application>automake</application> based package can easily be
+cross-compiled by specifying the <option>--host</option> option to the
+configure script and setting the <envar>CC</envar> and <envar>CXX</envar>
+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 <xref linkend="buildconfigurations"/>. Once you have created a
+new build configuration for cross-compiling in the
+<menuchoice><guimenu>Project</guimenu><guimenuitem>Project
+Options...</guimenuitem></menuchoice> dialog, add the option
+</para>
+
+<screen><option>--host=</option><replaceable>platform</replaceable></screen>
+
+<para>
+to the configure options. The <replaceable>platform</replaceable> name
+is a tuple of the form
+</para>
+
+<programlisting>cpu-vendor-os</programlisting>
+<para>or</para>
+<programlisting>cpu-vendor-kernel-os</programlisting>
+
+<para>
+For many combinations, you can use a short form, for instance
+<wordasword>i386-linux</wordasword> or <wordasword>arm-elf</wordasword>.
+</para>
+
+</sect1> <!-- crosscompiling -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="qtembedded">
+<title>Qt/Embedded</title>
+<indexterm zone="qtembedded"><primary>embedded</primary><secondary>Qt</secondary></indexterm>
+<indexterm zone="qtembedded"><primary>Qt/Embedded</primary></indexterm>
+<indexterm zone="qtembedded"><primary>Qtopia</primary></indexterm>
+<indexterm zone="qtembedded"><primary>framebuffer</primary></indexterm>
+
+<para>
+&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.
+</para>
+
+<para>
+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
+<option>--enable-embedded</option> to the configure script. You can set
+this in the <menuchoice><guimenu>Project</guimenu>
+<guimenuitem>Project Options...</guimenuitem></menuchoice> dialog under
+<guilabel>Configure Options</guilabel>. With the option
+<option>--with-qt-dir=DIR</option> you set the directory in which &qte;
+is installed.
+</para>
+
+<para>
+After configuring and compiling your application with these options, it will
+link with the <filename>libqpe.so</filename> 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 <application>qvfb</application>
+(&Qt; Virtual Frame Buffer). This is done by starting
+<application>qvfb</application> and then starting your application with
+</para>
+
+<screen><command>app <option>-qws</option> <option>-display QVFb:0</option></command></screen>
+
+<para>
+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.
+</para>
+
+<para>
+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 <classname>QPEApplication</classname> and linking to the
+library <filename>libqpe.so</filename>. If you develop your application with
+the autoproject project management, you have to add
+<option>--enable-qtopia</option> to the configure options.
+</para>
+
+</sect1> <!-- qtembedded -->
+
+</chapter> <!-- adv-build-management -->
diff --git a/doc/kdevelop/app-changelog.docbook b/doc/kdevelop/app-changelog.docbook
new file mode 100644
index 00000000..50e8f4ee
--- /dev/null
+++ b/doc/kdevelop/app-changelog.docbook
@@ -0,0 +1,69 @@
+<appendix id="app-changelog">
+<title>Changes</title>
+<sect1 id="changes">
+<title>Changes to This Document</title>
+
+<itemizedlist>
+  <listitem>
+    <para>2003-01-03 Bernd Gehrmann, Caleb Tennis
+      <itemizedlist>
+        <listitem>
+          <para>initial manual layout</para>
+        </listitem>
+        <listitem>
+          <para>many chapter contents sketched</para>
+        </listitem>
+      </itemizedlist>
+    </para>
+  </listitem>
+  
+  
+  <listitem>
+    <para>2004-08-01 Bernd Pol, Ian Wadham
+      <itemizedlist>
+        <listitem>
+          <para>manual slightly reorganized</para>
+        </listitem>
+        <listitem>
+          <para>some missing chapters written</para>
+        </listitem>
+      </itemizedlist>
+    </para>
+  </listitem>
+  
+  <listitem>
+    <para>2005-05-02 Volker Paul &mdash; Many changes, including:
+      <itemizedlist>
+        <listitem>
+          <para>split into one file per chapter/appendix</para>
+        </listitem>
+        <listitem>
+          <para>added command reference sorted by menu (descriptions not yet complete)</para>
+        </listitem>
+        <listitem>
+          <para>AppWizard tutorial in getting-started.docbook</para>
+        </listitem>
+        <listitem>
+          <para>reorganized chapters, guided by Konqueror manual</para>
+        </listitem>
+        <listitem>
+          <para>moved installation, Unix development, <quote>In a Nutshell</quote> to the appendix</para>
+        </listitem>
+        <listitem>
+          <para>rewrote plugin appendix, incl. plugin list generator listplugins.sh</para>
+        </listitem>
+      </itemizedlist>
+    </para>
+    <para>Still far from complete, but a small step forward.</para>
+  </listitem>
+  
+  <listitem>
+    <para>2006-05-20 Bernd Pol &mdash; Filling in some more <quote>to be written</quote> holes:</para>
+  </listitem>
+  
+</itemizedlist>
+
+</sect1> <!-- changes -->
+</appendix> <!-- app-changelog -->
+
+<!-- ====================================================================== -->
diff --git a/doc/kdevelop/app-files.docbook b/doc/kdevelop/app-files.docbook
new file mode 100644
index 00000000..210e1469
--- /dev/null
+++ b/doc/kdevelop/app-files.docbook
@@ -0,0 +1,425 @@
+<appendix id="app-files">
+<!-- LWatts (2005-04-30): A lot of this might be better as variable lists, -->
+<!-- but  it's not that big a deal.  Something to be done only when there's -->
+<!-- a lot of textual changes needed here (e.g., maybe never ) -->
+
+<appendixinfo>
+  <authorgroup>
+    <author><firstname>Bernd</firstname><surname>Pol</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</appendixinfo>
+
+<title>Configuration Files Used by &kdevelop;</title>
+
+<para>
+&kdevelop; uses a series of configuration files which are distributed amongst several directories. There are two main groups of configuration files to distinguish:
+</para>
+<simplelist>
+  <member>
+    <link linkend="app-files-default">&kdevelop; Default Configuration</link> &mdash; files set up when &kdevelop; was installed.
+  </member>
+  <member>
+    <link linkend="app-files-user">User Oriented Configuration</link> &mdash; files which contain user modifications of the defaults as well as settings made by the &kdevelop; application itself and its plugins.
+  </member>
+</simplelist>
+
+<sect1 id="app-files-default">
+<title>&kdevelop; Default Configuration</title>
+
+<para>
+On installation, &kdevelop; writes some default information files for setup and configuration purposes into subdirectories of the <filename class="directory">$<envar>KDEDIR</envar></filename> installation directory (usually something like <filename class="directory">/opt/kde</filename>, <filename class="directory">/usr/local/kde</filename>, or some other user-defined installation directory, see <link linkend="kdevelop-install">Installing &kdevelop;</link>).
+</para>
+
+<sect2 id="app-files-default-config">
+<title>Default &kdevelop; Configuration</title>
+
+<para>
+There is only one &kdevelop; specific default configuration file in the <filename class="directory">$<envar>KDEDIR</envar>/share/config/</filename> directory:
+</para>
+<variablelist>
+  <varlistentry>
+  <term><filename>kdeveloprc</filename></term>
+  <listitem><para>
+  This file contains the basic settings &kdevelop; needs to start. It will be copied to the user's <filename class="directory">$<envar>KDEHOME</envar>/share/config</filename> directory when &kdevelop; does not find a <filename>kdeveloprc</filename> file there on startup.
+  </para></listitem>
+  </varlistentry>
+</variablelist>
+
+</sect2> <!-- app-files-default-config -->
+
+<sect2 id="app-files-default-apps">
+<title>Application Specific Defaults</title>
+
+<para>
+Most &kdevelop; features are provided by KParts. These are basically applications specially designed to run in the &kdevelop; framework (see the overview in the <link linkend="plugin-tools">Plugin Tools</link> appendix). Each KPart application has its own set of configuration files whose defaults will be stored in several subdirectories of the <filename class="directory">$<envar>KDEDIR</envar>/share/apps/</filename> installation directory.
+</para>
+
+<para>
+There are quite a lot of default configuration subdirectories in <filename class="directory">$<envar>KDEDIR</envar>/share/apps/</filename> whose names all start with a <filename>kdev</filename> sequence. Most of them are for &kdevelop; internal use only. They might be deliberately grouped for readability as:
+<simplelist>
+  <member><link linkend="app-files-default-apps-stdalone">Stand-alone Applications</link></member>
+  <member><link linkend="app-files-default-apps-task">Task Specific Parts</link></member>
+  <member><link linkend="app-files-default-apps-project">Project Generation Parts</link></member>
+  <member><link linkend="app-files-default-apps-lang">Language Specific Parts</link></member>
+</simplelist>
+</para>
+
+<itemizedlist>
+  <listitem id="app-files-default-apps-stdalone"><itemizedlist>
+    <title>Stand-alone Applications</title>
+    <listitem>
+      <para><filename class="directory">kdevelop/</filename> &mdash; contains files to configure the &kdevelop; &IDE;:</para>
+      <itemizedlist>
+        <listitem><para><filename class="directory">licenses/</filename> &mdash; contains various licenses texts.</para></listitem>
+        <listitem><para><filename class="directory">pics/</filename> &mdash; contains the picture files used for the &kdevelop;, &kdevelop; Assistant, and &kdevelop; Designer splash screens.</para></listitem>
+        <listitem><para><filename class="directory">profiles/</filename> &mdash; contains default plugin profile settings. (Currently there is only a <filename>tiny</filename> profile provided which defines a minimum set of active &kdevelop; plugins.)</para></listitem>
+        <listitem><para><filename>eventsrc</filename> &mdash; holds a lot of <quote>Process successful</quote> localization strings.</para></listitem>
+        <listitem><para><filename>kdevelopui.rc</filename> &mdash; provides the basic menu and tool bar entries &kdevelop; uses.</para></listitem>
+        <listitem><para><filename>kdevhtml_partui.rc</filename> &mdash; provides a <guimenuitem>Print...</guimenuitem> entry in the <guimenu>File</guimenu> menu, a <guimenuitem>Copy</guimenuitem> entry in the <guimenu>Edit</guimenu> menu, and <guilabel>Back</guilabel> and <guilabel>Forward</guilabel> arrows in the <guilabel>Browser Toolbar</guilabel> in case a &HTML; file is browsed from the <guilabel>Documentation</guilabel> plugin.</para></listitem>
+      </itemizedlist>
+    </listitem>
+    <listitem><para><filename class="directory">kdevassistant/</filename> &mdash; provides the menu and tool bars of the stand-alone &kdevelop; Assistant documentation browser.</para></listitem>
+    <listitem><para><filename class="directory">kdevdesigner/</filename> and <filename class="directory">kdevdesignerpart/</filename> &mdash; provide menu bar and tool bars of the stand-alone &kdevelop; user interface designer.</para></listitem>
+  </itemizedlist></listitem>
+
+  <listitem><itemizedlist id="app-files-default-apps-task">
+    <title>Task Specific Parts</title>
+    <listitem id="app-files-default-abbrev">
+      <para><filename class="directory">kdevabbrev/</filename> &mdash; contains files used by the <guilabel>Abbreviation Expansion</guilabel> plugin:</para>
+      <itemizedlist>
+        <listitem><para><filename class="directory">sources/</filename> &mdash; contains keyword definition files used by the <guilabel>Expand Text</guilabel> command.</para></listitem>
+        <listitem><para><filename class="directory">templates/</filename> &mdash; contains template definition files used by the <guilabel>Expand Abbreviation</guilabel> command.</para></listitem>
+        <listitem><para><filename>kdevabbrev.rc</filename> &mdash; provides the <guimenuitem>Expand Text</guimenuitem> and <guimenuitem>Expand Abbreviation</guimenuitem> entries in the <guimenu>Edit</guimenu> menu.</para></listitem>
+</itemizedlist>
+    </listitem>
+    <listitem id="app-files-default-appwizard">
+      <para><filename class="directory">kdevappwizard/</filename> &mdash; contains files used by the &appwizard; part:</para>
+      <itemizedlist>
+        <listitem><para><filename class="directory">importfiles/</filename> &mdash; contains <filename>.kdevelop</filename> project files which control the initialization of a new project.</para></listitem>
+        <listitem><para><filename class="directory">imports/</filename> &mdash; contains templates to set up project specific <filename>.desktop</filename> files.</para></listitem>
+        <listitem><para><filename class="directory">template-common/</filename> &mdash; contains various files commonly included in the project source directories.</para></listitem>
+        <listitem><para><filename class="directory">templates/</filename> &mdash; contains configuration files which describe the information to be included in a given project source directory.</para></listitem>
+        <listitem><para><filename>*.png</filename> &mdash; project preview images used by the &appwizard;.</para></listitem>
+        <listitem><para><filename>*.tar.gz</filename> &mdash; tarballs containing the source files to be included in a new generated project directory.</para></listitem>
+      </itemizedlist>
+    </listitem>
+    <listitem><para><filename class="directory">kdevastyle/</filename> &mdash; provides the <guimenuitem>Reformat Source</guimenuitem> entry in the <guimenu>Edit</guimenu> menu.</para></listitem>
+    <listitem><para><filename class="directory">kdevautoproject/</filename> &mdash; provides most of the entries in the <guimenu>Build</guimenu> menu and the <guilabel>Build Toolbar (&kdevelop;)</guilabel> toolbar.</para></listitem>
+    <listitem>
+      <para><filename class="directory">kdevclassview/</filename> &mdash; contains files used by the <guilabel>Class View</guilabel> project plugin:</para>
+      <itemizedlist>
+        <listitem><para><filename class="directory">pics/</filename> &mdash; contains the icons used in the <guilabel>Classes</guilabel> classview tree.</para></listitem>
+        <listitem><para><filename>kdevclassview.tc</filename> &mdash; provides the <guimenuitem>Class Inheritance Diagram</guimenuitem> entry in the <guimenu>Projects</guimenu> menu as well as the classes navigation combo box in the <guilabel>Browser Toolbar</guilabel>.</para></listitem>
+      </itemizedlist>
+    </listitem>
+    <listitem><para><filename class="directory">kdevcloser/</filename> &mdash; provides the <guimenu>Windows</guimenu> menu close entries.</para></listitem>
+    <listitem><para><filename class="directory">kdevctags/</filename> &mdash; provides the <guimenuitem>CTags</guimenuitem> entry in the <guimenu>Tools</guimenu> menu for the <guilabel>CTags Frontend</guilabel> project plugin.</para></listitem>
+    <listitem><para><filename class="directory">kdevcvsservice/</filename> &mdash; provides the icon used by the <guilabel>CvsService</guilabel> tab and a short shell script used to add a new entry to the &cvs; repository, both used by the <guilabel>CVS Integration</guilabel> project plugin.</para></listitem>
+    <listitem><para><filename class="directory">kdevdebugger/</filename> &mdash; provides the <guimenu>Debug</guimenu> menu entries for the <guilabel>Debugger Frontend</guilabel> project plugin.</para></listitem>
+    <listitem><para><filename class="directory">kdevdiff/</filename> &mdash; provides the <guimenuitem>Difference Viewer</guimenuitem> entry in the <guimenu>Tools</guimenu> menu.</para></listitem>
+    <listitem><para><filename class="directory">kdevdistpart/</filename> &mdash; provides the <guimenuitem>Distribution &amp; Publishing</guimenuitem> entry in the <guimenu>Project</guimenu> menu for the <guilabel>Final Packaging Support</guilabel> project plugin.</para></listitem>
+    <listitem id="app-files-default-kdevdoc">
+      <para><filename class="directory">kdevdocumentation/</filename> &mdash; contains files used by the <guilabel>Documentation</guilabel> plugin:</para>
+      <itemizedlist>
+        <listitem><para><filename class="directory">en/</filename> and <filename class="directory">pics/</filename> &mdash; contain files used by the <application>htdig</application> search tool.</para></listitem>
+        <listitem><para><filename class="directory">tocs/</filename> &mdash; contain the default &kdevelop; documentation content description files (see the description in <link linkend="toc-file-structure">Basic Structure of &kdevelop; TOC Files</link>).</para></listitem>
+        <listitem><para><filename>kdevpart_documentation.rc</filename> &mdash; provides the search related entries in the <guimenu>Help</guimenu> menu.</para></listitem>
+      </itemizedlist>
+    </listitem>
+    <listitem><para><filename class="directory">kdevdoxygen/</filename> &mdash; provides the menu entries for the <guilabel>Doxygen Support</guilabel> project plugin.</para></listitem>
+    <listitem id="app-files-default-filecreate">
+      <para><filename class="directory">kdevfilecreate/</filename> &mdash; contains files used by the <guilabel>New File Wizard:</guilabel>
+      <itemizedlist>
+        <listitem><para><filename class="directory">file-templates/</filename> &mdash; provides the initial text contents to be put into the new source file of a given type.</para></listitem>
+        <listitem><para><filename>kdevpart_filecreate.rc</filename> &mdash; provides the <guimenuitem>New</guimenuitem> entry in the <guimenu>File</guimenu> menu.</para></listitem>
+        <listitem><para><filename>template-info.xml</filename> &mdash; contains descriptions of the available file types to be displayed in the <guilabel>New File</guilabel> tool view.</para></listitem>
+      </itemizedlist>
+    </para></listitem>
+    <listitem><para><filename class="directory">kdevfilter/</filename> &mdash; provides the <guimenuitem>Execute Command...</guimenuitem> and <guimenuitem>Filter Selection Through Command...</guimenuitem> entries in the <guimenu>Tools</guimenu> menu used by the <guilabel>Shell Filtering and Insertion</guilabel> plugin.</para></listitem>
+    <listitem><para><filename class="directory">kdevfullscreen/</filename> &mdash; provides the <guimenuitem>Full Screen Mode</guimenuitem> entry in the <guimenu>View</guimenu> menu and the according tool bar icon.</para></listitem>
+    <listitem><para><filename class="directory">kdevgrepview/</filename> &mdash; provides the <guimenuitem>Find in Files...</guimenuitem>entry in the <guimenu>Edit</guimenu> menu used by the <guilabel>Grep Frontend</guilabel> plugin.</para></listitem>
+    <listitem><para><filename class="directory">kdevhistory/</filename> &mdash; provides the <guimenuitem>Back</guimenuitem> and <guimenuitem>Forward</guimenuitem> entries in the <guimenu>View</guimenu> menu.</para></listitem>
+    <listitem><para><filename class="directory">kdevjavadebugger/</filename> &mdash; provides a <guimenu>Java Debug</guimenu> menu in order to debug a &Java; application.</para></listitem>
+    <listitem><para><filename class="directory">kdevoutputviews/</filename> &mdash; provides the <guimenuitem>Next Error</guimenuitem> and <guimenuitem>Previous Error</guimenuitem> entries in the <guimenu>View</guimenu> menu.</para></listitem>
+    <listitem><para><filename class="directory">kdevpartexplorer/</filename> &mdash; provides the <guimenuitem>Part Explorer</guimenuitem> entry in the <guimenu>Tools</guimenu> menu used by the <guilabel>Part Explorer Tool</guilabel> plugin.</para></listitem>
+    <listitem><para><filename class="directory">kdevquickopen/</filename> &mdash; provides the <guimenuitem>Quick Open File..</guimenuitem> entry in the <guimenu>File</guimenu> menu and the <guimenuitem>Quick Open Class...</guimenuitem> and <guimenuitem>Quick Open Method</guimenuitem> entries in the <guimenu>Tools</guimenu> menu used by the <guilabel>Quick Open</guilabel> project plugin.</para></listitem>
+    <listitem><para><filename class="directory">kdevregexptest/</filename> &mdash; provides the <guimenuitem>Debug Regular Expression...</guimenuitem> entry in the <guimenu>Tools</guimenu> menu used by the <guilabel>Regular Expression Tester</guilabel> plugin.</para></listitem>
+    <listitem><para><filename class="directory">kdevreplace/</filename> &mdash; provides the <guimenuitem>Find-Select-Replace...</guimenuitem> entry in the <guimenu>Edit</guimenu> menu used by the <guilabel>Replace Part</guilabel> plugin.</para></listitem>
+    <listitem id="app-files-default-tips"><para><filename class="directory">kdevtipofday/</filename> &mdash; provides the <guimenuitem>Tip of the Day</guimenuitem> entry in the <guimenu>Help</guimenu> menu as well as a HTML-File containing the available tips.</para></listitem>
+    <listitem><para><filename class="directory">kdevtools/</filename> &mdash; controls various menu entries ceated by <guimenu>Tools Menu</guimenu> and <guilabel>External Tools Menu</guilabel> settings provided by the <guilabel>Tools Menu Addition</guilabel> plugin.</para></listitem>
+    <listitem><para><filename class="directory">kdevvalgrind/</filename> &mdash; provides the <guimenuitem>Valgrind Memory Leak Check</guimenuitem> and <guimenuitem>Profile with KCachegrind</guimenuitem> entries in the <guimenu>Debug</guimenu> menu used by the <guilabel>Valgrind Frontend</guilabel> plugin.</para></listitem>
+  </itemizedlist></listitem>
+
+  <listitem><itemizedlist id="app-files-default-apps-project">
+    <title>Project Generation Parts</title>
+    <listitem><para><filename class="directory">kdevadaproject/</filename> &mdash; provides entries for the <guimenu>Build</guimenu> menu and according tool bar icons to build an Ada application.</para></listitem>
+    <listitem><para><filename class="directory">kdevantproject/</filename> &mdash; provides entries for the <guimenu>Build</guimenu> menu when the Ant project generator is used.</para></listitem>
+    <listitem><para><filename class="directory">kdevautoproject/</filename> &mdash;  provides entries for the <guimenu>Build</guimenu> menu and according tool bar icons when working with the &GNU; Tools based &automake; project generator. Additionally provides the <guimenuitem>Add Translation</guimenuitem> and <guimenuitem>Build Configuration</guimenuitem> entries to the <guimenu>Project</guimenu> menu.</para></listitem>
+    <listitem><para><filename class="directory">kdevcustomproject/</filename> &mdash; provides entries for the <guimenu>Build</guimenu> menu and according tool bar icons when the project is based on custom Makefils.</para></listitem>
+    <listitem><para><filename class="directory">kdevgenericproject/</filename> &mdash; contains menu definitions for an experimental generic project generator. Currently (version 3.1.0) unused.</para></listitem>
+    <listitem><para><filename class="directory">kdevhaskellproject/</filename> &mdash; provides entries for the <guimenu>Build</guimenu> menu and according tool bar icons to build a Haskell application.</para></listitem>
+    <listitem><para><filename class="directory">kdevpascalproject/</filename> &mdash; provides entries for the <guimenu>Build</guimenu> menu and according tool bar icons to build a Pascal application.</para></listitem>
+    <listitem><para><filename class="directory">kdevtrollproject/</filename> &mdash; provides entries for the <guimenu>Build</guimenu> menu and according tool bar icons to build an application using the &Qt; QMake project manager.</para></listitem>
+  </itemizedlist></listitem>
+
+  <listitem><itemizedlist id="app-files-default-apps-lang">
+    <title>Language Specific Parts</title>
+    <listitem><para><filename class="directory">kdevadasupport/</filename> &mdash; provides entries in the <guimenu>Tools</guimenu> menu and according tool bar icons needed to develop Ada applications.</para></listitem>
+    <listitem><para><filename class="directory">kdevbashsupport/</filename> &mdash; provides entries in the <guimenu>Build</guimenu> menu and according tool bar icons needed to develop Bash scripts.</para></listitem>
+    <listitem id="app-files-default-apps-lang-cpp">
+      <para><filename class="directory">kdevcppsupport/</filename> &mdash; contains files used by the &appwizard; to build C++ applications:</para>
+      <itemizedlist>
+        <listitem><para><filename class="directory">newclass/</filename> &mdash; contains header and source templates from which the &appwizard; builds the according source files.</para></listitem>
+        <listitem><para><filename class="directory">subclassing/</filename> &mdash; contains templates which the &appwizard; uses to set up initial class declarations/definitions in the source files.</para></listitem>
+        <listitem><para><filename class="directory">templates</filename> &mdash; contains templates from which the &appwizard; sets up the default header and source template files to be used by the &nfwizard;. </para></listitem>
+        <listitem><para><filename>configuration</filename> &mdash; dummy template to add macros.</para></listitem>
+        <listitem><para><filename>kdevcppsupport.rc</filename> &mdash; provides the <guimenuitem>Complete Text</guimenuitem> and <guimenuitem>Make Member</guimenuitem> entries fo the <guimenu>Edit</guimenu> menu, the <guimenuitem>Switch Header/Implementation</guimenuitem> entry for the <guimenu>View</guimenu> menu, and the <guimenuitem>New Class</guimenuitem> entry for the <guimenu>Project</guimenu> menu as well as a <guiicon>New Class</guiicon> icon for the <guilabel>Browser Toolbar</guilabel>.</para></listitem>
+      </itemizedlist>
+    </listitem>
+    <listitem><para><filename class="directory">kdevfortransupport/</filename> &mdash; provides entries in the <guimenu>Build</guimenu> menu needed to develop Fortran applications.</para></listitem>
+    <listitem><para><filename class="directory">kdevhaskellsupport/</filename> &mdash; provides entries in the <guimenu>Build</guimenu> menu and according tool bar icons needed to develop Haskell applications.</para></listitem>
+     <listitem><para><filename class="directory">kdevjavasupport/</filename> &mdash; contains the UI definition needed to develop &Java; applications.</para></listitem>
+    <listitem><para><filename class="directory">kdevpascalsupport/</filename> &mdash;  contains the UI definition needed to develop Pascal applications.</para></listitem>
+    <listitem><para><filename class="directory">kdevperlsupport/</filename> &mdash; provides <guimenu>Project</guimenu> and <guimenu>Help</guimenu> menu entries needed to develop Perl scripts.</para></listitem>
+    <listitem><para><filename class="directory">kdevphpsupport/</filename> &mdash; contains UI and PHP function definition files needed to develop PHP scripts.</para></listitem>
+    <listitem><para><filename class="directory">kdevpythonsupport/</filename> &mdash; provides <guimenu>Build</guimenu> and <guimenu>Help</guimenu> menu entries and according tool bar icons needed to develop Python scripts.</para></listitem>
+    <listitem><para><filename class="directory">kdevrubysupport/</filename> &mdash; provides <guimenu>Build</guimenu> menu entries and according tool bar icons needed to develop Ruby scripts.</para></listitem>
+    <listitem><para><filename class="directory">kdevscriptproject/</filename> &mdash; provides th UI definitions needed to develop custom projects. Currently (version 3.1.0) unused.</para></listitem>
+    <listitem><para><filename class="directory">kdevsqlsupport/</filename> &mdash; provides th UI definitions needed to develop SQL projects. Currently (version 3.1.0) unused.</para></listitem>
+  </itemizedlist></listitem>
+
+</itemizedlist>
+
+</sect2> <!-- app-files-default-apps -->
+
+</sect1> <!-- app-files-default -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="app-files-user">
+<title>User Oriented Configuration</title>
+
+<para>
+All information about user defined settings is kept in two subdirectories of <filename class="directory">$<envar>KDEHOME</envar></filename>, namely:
+<simplelist>
+  <member><link linkend="app-files-user-apps">Application Specific Configuration</link> in the <filename class="directory">$<envar>KDEHOME</envar>/share/apps/</filename> directory, and</member>
+  <member><link linkend="app-files-user-config">Resource Configuration File</link> in the <filename class="directory">$<envar>KDEHOME</envar>/share/config/</filename> directory.</member>
+</simplelist>
+</para>
+
+<sect2 id="app-files-user-apps">
+<title>Application Specific Configuration</title>
+
+<para>
+Any user changes to the <link linkend="app-files-default">&kdevelop; Default Configuration</link> settings as well as user specific settings which are not kept in any of the <link linkend="app-files-user-config">Resource Configuration Files</link> are found in <filename>kdev...</filename> subdirectories of the <filename class="directory">$<envar>KDEHOME</envar>/share/apps/</filename> directory.
+</para>
+<para>
+Most of these configuration files are however used by various &kdevelop; plugins in order to provide some specific menu and/or toolbar entries. Thus they are of interest only in case something went really wrong with the user interface.
+</para>
+<note><para>
+In case the contents of these directories mirror those of the Default Configuration settings, &kdevelop; will have copied them from <filename class="directory">$<envar>KDEDIR</envar>/apps/</filename> into the <filename class="directory">$<envar>KDEHOME</envar>/apps/</filename> directory on its initial start. Any subsequent changes will be made to these copies only. The Default Configuration settings remain unchanged in any case.
+</para></note>
+
+<itemizedlist>
+  <listitem>
+    <para><filename class="directory">kdevabbrev/</filename> &mdash;  contains files used by the <guilabel>Abbreviation Expansion</guilabel> plugin:</para>
+    <itemizedlist>
+      <listitem><para><filename class="directory">sources/</filename> &mdash; currently empty; &kdevelop; uses the <link linkend="app-files-default-abbrev">default keyword definition</link> files for <guilabel>Expand Text</guilabel> commands.</para></listitem>
+      <listitem><para><filename class="directory">templates/</filename> &mdash; contains the user modified template definition files used by the <guilabel>Expand Abbreviation</guilabel> command.</para></listitem>
+      <listitem><para><filename>kdevabbrev.rc</filename> &mdash; provides the <guimenuitem>Expand Text</guimenuitem> and <guimenuitem>Expand Abbreviation</guimenuitem> entries in the <guimenu>Edit</guimenu> menu.</para></listitem>
+    </itemizedlist>    
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevappwizard/</filename> &mdash; only provides the <guimenuitem>New Project...</guimenuitem> and <guimenuitem>Import Existing Project...</guimenuitem> entries in the <guimenu>Projects</guimenu> menu. The &appwizard; will use the <link linkend="app-files-default-appwizard">default configuration settings</link> for its actual works.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevastyle/</filename> &mdash; provides the actual <guimenuitem>Reformat Source</guimenuitem> entry in the <guimenu>Edit</guimenu> menu.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevautoproject/</filename> &mdash; provides the actual entries in the <guimenu>Build</guimenu> menu and the <guilabel>Build Toolbar (KDevelop)</guilabel> toolbar.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevclassview/</filename> &mdash; provides the <guimenuitem>Class Inheritance Diagram</guimenuitem> entry in the <guimenu>Project</guimenu> menu and the class browser combo box in the <guilabel>Browser Toolbar</guilabel> by the <guilabel>Class View</guilabel> project plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevcloser/</filename> &mdash; provides the <guimenuitem>Close Selected Windows...</guimenuitem> entry in the <guimenu>Windows</guimenu> menu.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevcppsupport/</filename> &mdash; holds the acual configuration used by the &appwizard; to build C++ applications. The &appwizard; however uses its main bulk of configuration information directly from the <link linkend="app-files-default-apps-lang-cpp">default configuration directory</link>. See there for more detail.</para>
+    <itemizedlist>
+      <listitem>
+        <para><filename class="directory">newclass/</filename> &mdash; contains the actual header and source templates from which the &appwizard; builds the according source files.</para>
+      </listitem>
+      <listitem>
+        <para><filename class="directory">pcs/</filename> &mdash; contains database files &kdevelop; uses build the actual Persistent Code Store (<filename>.pcs</filename>) file of a &kde; C++ project.</para>
+      </listitem>
+      <listitem>
+        <para><filename>kdevcppsupport.rc</filename> &mdash; provides the <guimenuitem>Complete Text</guimenuitem> and <guimenuitem>Make Member</guimenuitem> entries fo the <guimenu>Edit</guimenu> menu, the <guimenuitem>Switch Header/Implementation</guimenuitem> entry for the <guimenu>View</guimenu> menu, and the <guimenuitem>New Class</guimenuitem> entry for the <guimenu>Project</guimenu> menu as well as a <guiicon>New Class</guiicon> icon for the <guilabel>Browser Toolbar</guilabel>.</para>
+      </listitem>
+    </itemizedlist>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevctags/</filename> &mdash; provides the <guimenuitem>CTags</guimenuitem> entry in the <guimenu>Tools</guimenu> menu for the <guilabel>CTags Frontend</guilabel> project plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevdebugger/</filename> &mdash; provides the <guimenu>Debug</guimenu> menu entries for the <guilabel>Debugger Frontend</guilabel> project plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevdiff/</filename> &mdash; provides the <guimenuitem>Difference Viewer</guimenuitem> entry in the <guimenu>Tools</guimenu> menu.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevdocumentation/</filename> &mdash; contains the actual files used by the <guilabel>Documentation</guilabel> plugin in addition to the <link linkend="app-files-default-kdevdoc"> default configuration files</link>. See there for more detail.</para>
+    <para>The directories in <filename class="directory">kdevdocumentation/</filename> mainly hold actual bookkeeping information. The actually set up documentation files are kept in <link linkend="app-files-user-config-doc"> <quote><filename>doc...pluginrc</filename></quote> files</link> in the <filename class="directory">$<envar>KDEHOME</envar>/share/config/</filename> directory.</para>
+    <itemizedlist>
+      <listitem>
+        <para><filename class="directory">bookmarks/</filename> &mdash; maintains the entries in the <guilabel>Bookmarks</guilabel> tab of the &kdevelop; <guilabel>Documentation</guilabel> plugin.</para>
+      </listitem>
+      <listitem>
+        <para><filename class="directory">index/</filename> &mdash; holds various cache files &kdevelop; uses to speed up indexed documentation searches in the <guilabel>Index</guilabel> tab of the <guilabel>Documentation</guilabel> plugin.</para>
+      </listitem>
+      <listitem>
+        <para><filename class="directory">search/</filename> &mdash; contains files used by the <application>htdig</application> search tool which serves search calls from the <guilabel>Search</guilabel> tab of the <guilabel>Documentation</guilabel> plugin.</para>
+      </listitem>
+      <listitem>
+        <para><filename>kdevpart_documentation.rc</filename> &mdash; provides the search related entries in the <guimenu>Help</guimenu> menu.</para>
+      </listitem>
+    </itemizedlist>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevdoxygen/</filename> &mdash; provides the menu entries for the <guilabel>Doxygen Support</guilabel> project plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevelop/</filename> &mdash; contains some actual settings &kdevelop; uses for its basic setup:</para>
+    <itemizedlist>
+      <listitem><para><filename class="directory">profiles/</filename> &mdash; provides actual plugin profile setting. (Initially there is only a <filename>FullIDE</filename> profile which defines a full set of initially active &kdevelop; plugins.)</para></listitem>
+      <listitem><para><filename>kdevelopui.rc</filename> &mdash; provides the basic menu and tool bar entries &kdevelop; uses.</para></listitem>
+    </itemizedlist>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevfilecreate/</filename> &mdash; contains files used by the <guilabel>New File Wizard:</guilabel></para>
+      <itemizedlist>
+        <listitem><para><filename class="directory">file-templates/</filename> &mdash; provides the actually used text contents to be put into the new source file of a given type. More file templates are found in the <link linkend="app-files-default-filecreate">default configuration files</link> directory.</para></listitem>
+        <listitem><para><filename>kdevpart_filecreate.rc</filename> &mdash; provides the <guimenuitem>New</guimenuitem> entry in the <guimenu>File</guimenu> menu.</para></listitem>
+        <listitem><para><filename>template-info.xml</filename> &mdash; contains descriptions of the available file types to be displayed in the <guilabel>New File</guilabel> tool view.</para></listitem>
+      </itemizedlist>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevfilter/</filename> &mdash; provides the <guimenuitem>Execute Command...</guimenuitem> and <guimenuitem>Filter Selection Through Command...</guimenuitem> entries in the <guimenu>Tools</guimenu> menu used by the <guilabel>Shell Filtering and Insertion</guilabel> plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevfullscreen/</filename> &mdash; provides the <guimenuitem>Full Screen Mode</guimenuitem> entry in the <guimenu>View</guimenu> menu and the according tool bar icon.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevgrepview/</filename> &mdash; provides the <guimenuitem>Find in Files...</guimenuitem>entry in the <guimenu>Edit</guimenu> menu used by the <guilabel>Grep Frontend</guilabel> plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevoutputviews/</filename> &mdash; provides the <guimenuitem>Next Error</guimenuitem> and <guimenuitem>Previous Error</guimenuitem> entries in the <guimenu>View</guimenu> menu.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevpartexplorer/</filename> &mdash; provides the <guimenuitem>Part Explorer</guimenuitem> entry in the <guimenu>Tools</guimenu> menu used by the <guilabel>Part Explorer Tool</guilabel> plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevquickopen/</filename> &mdash; provides the <guimenuitem>Quick Open File..</guimenuitem> entry in the <guimenu>File</guimenu> menu and the <guimenuitem>Quick Open Class...</guimenuitem> and <guimenuitem>Quick Open Method</guimenuitem> entries in the <guimenu>Tools</guimenu> menu used by the <guilabel>Quick Open</guilabel> project plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevregexptest/</filename> &mdash; provides the <guimenuitem>Debug Regular Expression...</guimenuitem> entry in the <guimenu>Tools</guimenu> menu used by the <guilabel>Regular Expression Tester</guilabel> plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevreplace/</filename> &mdash; provides the <guimenuitem>Find-Select-Replace...</guimenuitem> entry in the <guimenu>Edit</guimenu> menu used by the <guilabel>Replace Part</guilabel> plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevtipofday/</filename> &mdash;provides the <guimenuitem>Tip of the Day</guimenuitem> entry in the <guimenu>Help</guimenu> menu. The HTML-File containing the available tips is provided as a <link linkend="app-files-default-tips">default configuration file</link> only.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevtools/</filename> &mdash; controls various menu entries ceated by <guimenu>Tools Menu</guimenu> and <guilabel>External Tools Menu</guilabel> settings provided by the <guilabel>Tools Menu Addition</guilabel> plugin.</para>
+  </listitem>
+  <listitem>
+    <para><filename class="directory">kdevvalgrind/</filename> &mdash; provides the <guimenuitem>Valgrind Memory Leak Check</guimenuitem> and <guimenuitem>Profile with KCachegrind</guimenuitem> entries in the <guimenu>Debug</guimenu> menu used by the <guilabel>Valgrind Frontend</guilabel> plugin.</para>
+  </listitem>
+</itemizedlist>
+
+</sect2> <!-- app-files-user-apps -->
+
+<sect2 id="app-files-user-config">
+<title>Resource Configuration Files</title>
+
+<para>
+There are two groups of &kdevelop; configuration files in the <filename class="directory">$<envar>KDEHOME</envar>/share/config/</filename> directory, distiguished by their surrounding character sequences:
+<simplelist>
+  <member><quote><filename>doc...pluginrc</filename></quote> denotes <link linkend="app-files-user-config-doc">files used by the documentation plugin.</link></member>
+  <member><quote><filename>kdev...rc</filename></quote> denotes configuration <link linkend="app-files-user-config-kdev">files used by &kdevelop;</link> itself and its available plugins.</member>
+</simplelist>
+</para>
+
+<itemizedlist id="app-files-user-config-kdev">
+<title>Configuration Files Used by &kdevelop;</title>
+  <listitem>
+    <para><filename>kdevabbrevrc</filename> &mdash; holds the current state of the <guilabel>Abbreviations</guilabel> configuration provided by the <guilabel>Abbreviation Expansion</guilabel> plugin.</para>
+    <note><para>This only records whether the abbreviations will be used or not. The actual definitions of new abbreviations will go into the <filename>$<envar>KDEHOME</envar>/share/apps/kdevabbrev/templates/templates</filename> file.</para></note>
+  </listitem>
+  <listitem>
+    <para><filename>kdevassistantrc</filename> &mdash; holds some configuration states specific of the stand-alone  &kdevelop; Assistant documentation browser.</para>
+    <note><para>Most common configuration settings are shared with the &kdevelop; IDE <filename>kdeveloprc</filename> file.</para></note>
+  </listitem>
+  <listitem><para><filename>kdevassistantuimode4rc</filename> &mdash; holds the current MDI configuration states (dock positions &etc;) of the stand-alone  &kdevelop; Assistant documentation browser.</para></listitem>
+  <listitem>
+    <para><filename>kdevclassviewrc</filename> &mdash; holds the <guilabel>View Mode</guilabel> setting of the <guilabel>Classes</guilabel> class browser tab provided by the <guilabel>Class View</guilabel> project plugin.</para>
+    <note><para>This is a global setting, although the <guilabel>Class View</guilabel> plugin may be disabled on a per project basis. Any change in this setting will be globally updated whenever the current project is closed and thus affect all subsequently loaded projects.</para></note>
+  </listitem>
+  <listitem><para><filename>kdevcppsupportrc</filename> &mdash; holds some settings used to set up CPP source files. In particular you will find the settings made on the <guilabel>C++ Class Generator</guilabel> configuration dialog in here.</para></listitem>
+  <listitem><para><filename>kdevdocumentationrc</filename> &mdash; holds actual settings the <guilabel>Documentation</guilabel> plugin uses.</para></listitem>
+  <listitem><para><filename>kdeveloprc</filename> &mdash; holds the global settings the &kdevelop; IDE and the &kdevelop; Assistant stand-alone documentation browser will use.</para></listitem>
+  <listitem><para><filename>kdevelopuimode4rc</filename> &mdash;  holds the current MDI configuration states (dock positions &etc;) of the  &kdevelop; IDE.</para></listitem>
+  <listitem><para><filename>kdevfileselectorrc</filename> &mdash; holds actual settings the <guilabel>File Selector</guilabel> plugin uses.</para></listitem>
+  <listitem><para><filename>kdevfileviewrc</filename> &mdash; holds the actual filename color settings the <guilabel>CVS Integration (Cervisia)</guilabel> project plugin uses for display.</para></listitem>
+  <listitem><para><filename>kdevfilterrc</filename> &mdash; holds actual settings the <guilabel>Shell Filtering and Insertion</guilabel> plugin uses.</para></listitem>
+  <listitem><para><filename>kdevgrepviewrc</filename> &mdash; holds actual settings the <guilabel>Grep Frontend</guilabel> plugin uses.</para></listitem>
+  <listitem><para><filename>kdevsnippetrc</filename> &mdash; holds actual settings the <guilabel>Code Snippets</guilabel> plugin uses.</para></listitem>
+  <listitem><para><filename>kdevtoolsrc</filename> &mdash; holds actual settings the <guilabel>Tools Menu Addition</guilabel> plugin uses.</para></listitem>
+</itemizedlist>
+
+<itemizedlist id="app-files-user-config-doc">
+<title>Configuration Files Used by the Documentation Plugin</title>
+  <listitem><para><filename>docchmpluginrc</filename> &mdash; holds information about the actual &Microsoft; CHM help files as defined on the <guilabel>CHM Documentation Collection</guilabel> configuration page.</para></listitem>
+  <listitem><para><filename>doccustompluginrc</filename> &mdash; holds information about any custom documentation file defined on the <guilabel>Custom Documentation Collection</guilabel> configuration page.</para></listitem>
+  <listitem><para><filename>docdevhelppluginrc</filename> &mdash; holds information about the actual GNOME 2 DevHelp documentation files as defined on the <guilabel>Devhelp Documentation Collection</guilabel> configuration page.</para></listitem>
+  <listitem><para><filename>docdoxygenpluginrc</filename> &mdash; holds information about the actual Doxygen generated API documentations as defined on the <guilabel>Doxygen Documentation Collection</guilabel> configuration page.</para></listitem>
+  <listitem><para><filename>dockdevtocpluginrc</filename> &mdash; holds information about the actual KDevelopTOC structured documentation files as defined on the <guilabel>KDevelopTOC Documentation Collection</guilabel> configuration page.</para></listitem>
+  <listitem><para><filename>docqtpluginrc</filename> &mdash; holds information about the QT documentation files actually included on the <guilabel> Documentation Collection</guilabel>Qt configuration page.</para></listitem>
+</itemizedlist>
+
+</sect2> <!-- app-files-user-config -->
+
+</sect1> <!-- app-files-user -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="app-files-project">
+<title>Project Dependent Configuration</title>
+
+<para>
+Most project dependend configuration is kept in the <filename>&lt;project-name&gt;.kdevelop</filename> and <filename>&lt;project-name&gt;.kdevses</filename> &kdevelop; project configuration files rather than in separate files as the other, more global, configuration settings. In short, those files are meant for:
+</para>
+<simplelist>
+  <member><filename>&lt;project-name&gt;.kdevelop</filename> &mdash; global project configuration information.</member>
+  <member><filename>&lt;project-name&gt;.kdevses</filename> &mdash; configuration information needed to restore the specific behaviours of the running session.</member>
+</simplelist>
+<para>
+Both are &XML; coded files. They can be viewed and (cautiously) altered using any text editor.
+</para>
+
+<sect2>
+<title>Persistent Code Store Files</title>
+
+<para>There is a third project dependend configuration file, the <filename>&lt;project-name&gt;.kdevelop.pcs</filename> Persistant Code Store. This is a binary coded file holding an internal parser cache for the most part in order to speed up the loading sequence of the project. Additionally, this Persistant Code Store keeps information use by the <guilabel>Code Completion</guilabel> facility of &kdevelop;.
+</para>
+
+<note><para>
+There can be additional Persistant Code Store files be set up on the <guilabel>Code Completion</guilabel> tab of the <guilabel>C++ Specific</guilabel> project configuration page. Information about these additional <filename>.pcs</filename> is kept globally in the <filename class="directory">$<envar>KDEHOME</envar>/share/apps/kdevcppsupport/pcs/</filename> directory.
+</para></note>
+</sect2>
+
+</sect1> <!-- app-files-project -->
+
+</appendix> <!-- app-files -->
diff --git a/doc/kdevelop/app-menu.docbook b/doc/kdevelop/app-menu.docbook
new file mode 100644
index 00000000..954b65f2
--- /dev/null
+++ b/doc/kdevelop/app-menu.docbook
@@ -0,0 +1,61 @@
+<appendix id="app-menus">
+
+<appendixinfo>
+  <authorgroup>
+    <author><firstname>Bernd</firstname><surname>Pol</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</appendixinfo>
+
+<title>Menus and Toolbars Overview</title>
+
+<para>
+(... to be written ...)
+</para>
+
+<sect1 id="app-menus-menu">
+<title>Menus</title>
+
+<para>
+(... to be written ...)
+</para>
+
+<sect2 id="app-menus-menu-common">
+<title>Commonly Available Menus</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect2> <!-- app-menus-menu-common -->
+
+<sect2 id="app-menus-menu-project">
+<title>Project Specific Menus</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect2> <!-- app-menus-menu-project -->
+
+<sect2 id="app-menus-menu-specific">
+<title>Plugin Tools Specific Menus</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect2> <!-- app-menus-menu-specific -->
+
+</sect1> <!-- app-menus-menu -->
+
+<sect1 id="app-menus-tool">
+<title>Toolbars</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect1> <!-- app-menus-tool -->
+
+</appendix> <!-- app-menus -->
diff --git a/doc/kdevelop/app-misc-info.docbook b/doc/kdevelop/app-misc-info.docbook
new file mode 100644
index 00000000..308be579
--- /dev/null
+++ b/doc/kdevelop/app-misc-info.docbook
@@ -0,0 +1,24 @@
+<appendix id="app-misc-info">
+<title>Further Information</title>
+<sect1 id="gettinginformation">
+<title>Getting Information</title>
+<para>
+(... to be written ...)
+</para>
+</sect1> <!-- gettinginformation -->
+
+<sect1 id="app-reporting-bugs">
+<title>Reporting Bugs</title>
+<para>
+(... to be written ...)
+</para>
+</sect1> <!-- app-reporting-bugs -->
+
+<sect1 id="app-licensing">
+<title>Licensing</title>
+&underFDL;
+&underGPL;
+</sect1> <!-- app-licensing -->
+</appendix> <!-- app-misc-info -->
+
+<!-- ====================================================================== -->
diff --git a/doc/kdevelop/app-uimodes-examples.docbook b/doc/kdevelop/app-uimodes-examples.docbook
new file mode 100644
index 00000000..24b93c61
--- /dev/null
+++ b/doc/kdevelop/app-uimodes-examples.docbook
@@ -0,0 +1,125 @@
+<appendix id="app-uimodes-examples">
+<title>&kdevelop; User Interface Mode Examples</title>
+
+<sect1 id="ideal-desc">
+<title>IDEAl Mode</title>
+
+<para>
+Click <link linkend="uimodes-survey">here</link> to return to the modes overview.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="kdevelop-ideal-mode.png" format="PNG"/>
+    </imageobject>
+    <textobject><phrase>Screenshot</phrase></textobject>
+    <caption><para>&kdevelop; IDEAl mode</para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+Click <link linkend="uimodes-survey">here</link> to return to the modes overview.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="kdevelop-ideal-mode-0.png" format="PNG"/>
+    </imageobject>
+    <textobject><phrase>Screenshot</phrase></textobject>
+    <caption><para>&kdevelop; IDEAl mode, closed tabs</para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+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.
+</para>
+<para>
+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 <quote>Automake Manager</quote> tool tip is shown as an example. It describes the lower tab in the right tab bar.
+</para>
+
+<para>
+Click <link linkend="uimodes-survey">here</link> to return to the modes overview.
+</para>
+
+</sect1> <!-- ideal-desc -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="mdi-desc">
+<title>Child Frame Windows Mode</title>
+
+<para>
+Click <link linkend="uimodes-survey">here</link> to return to the modes overview.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+    <imagedata fileref="kdevelop-mdi-mode.png" format="PNG"/>
+    </imageobject>
+    <textobject><phrase>Screenshot</phrase></textobject>
+    <caption><para>&kdevelop; child frame windows mode</para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+Click <link linkend="uimodes-survey">here</link> to return to the modes overview.
+</para>
+
+</sect1> <!-- mdi-desc -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="tabbed-desc">
+<title>Tabbed Pages Mode</title>
+
+<para>
+Click <link linkend="uimodes-survey">here</link> to return to the modes overview.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="kdevelop-tabbed-mode.png" format="PNG"/>
+    </imageobject>
+    <textobject><phrase>Screenshot</phrase></textobject>
+    <caption><para>&kdevelop; tabbed pages mode</para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+Click <link linkend="uimodes-survey">here</link> to return to the modes overview.
+</para>
+
+</sect1> <!-- tabbed-desc -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="toplevel-desc">
+<title>Toplevel Windows Mode</title>
+
+<para>
+Click <link linkend="uimodes-survey">here</link> to return to the modes overview.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="kdevelop-toplevel-mode.png" format="PNG"/>
+    </imageobject>
+    <textobject><phrase>Screenshot</phrase></textobject>
+    <caption><para>&kdevelop; toplevel windows mode</para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+Click <link linkend="uimodes-survey">here</link> to return to the modes overview.
+</para>
+
+</sect1> <!-- toplevel-desc -->
+
+</appendix> <!-- app-uimodes-examples -->
+
+<!-- ====================================================================== -->
diff --git a/doc/kdevelop/applicationwizard.docbook b/doc/kdevelop/applicationwizard.docbook
new file mode 100644
index 00000000..ee732a78
--- /dev/null
+++ b/doc/kdevelop/applicationwizard.docbook
@@ -0,0 +1,820 @@
+<chapter id="applicationwizard">
+
+<chapterinfo>
+  <authorgroup>
+    <author><firstname>Bernd</firstname><surname>Pol</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</chapterinfo>
+
+<title>Getting Started &mdash; the &appwizard;</title>
+<!-- FIXME (bp, 2006-06-18) This is a misnomer. It should be something like -->
+<!-- Working With Projects -->
+<!-- featuring the application manager as part of the New Projects section. -->
+
+<indexterm zone="applicationwizard">
+  <primary>&appwizard;</primary></indexterm>
+
+<para>
+In &kdevelop; software development work is organized in <emphasis>projects</emphasis>. Such a project keeps everything together which belongs to a complete programming task: source files, additional data files, any actually needed management facilities as the make system as well as access to all components and any additional tools needed to get the application up and running.
+</para>
+<para>
+Organizing all development work in projects allows you to easily switch between the global tasks at hand. This is quite handy if you &eg; work on several applications at the same time as is often the case. Tell &kdevelop; to open the project you want to work at and you may proceed in the environment just where you left.
+</para>
+
+<sect1 id="new-projects">
+<title>New Projects</title>
+
+<!-- TODO (bp, 2006-06-18) This whole section must be completely rewritten. -->
+<!-- There is no need for a tutorial habit anymore. -->
+
+<indexterm zone="new-projects">
+  <primary>project</primary>
+  <secondary>new</secondary></indexterm>
+
+<para>
+Whenever you want to initiate a new programming project quite a lot of formal setup procedures need to be done. An initial directory structure has to be set up, initial header and source files must be provided, the make system has to be initialized, &etc;
+</para>
+<para>
+&kdevelop; provides an easy way to initiate a new programming project&mdash;the <emphasis>&appwizard;</emphasis>. You will find the &appwizard; at menu entry <menuchoice><guimenu>Project</guimenu> <guimenuitem>New Project</guimenuitem></menuchoice>.
+</para>
+<para>
+Only a short series of steps is necessary to start a new programming project, using the &appwizard;:
+</para>
+<orderedlist>
+  <listitem><para>
+  <link linkend="new-projects-start-type">Select the programming language</link> you want to use and the type of the application you want to build from a set of predefined templates.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="new-projects-start-general">Supply some general information</link> as application name, directory where the application shall be built, &etc;
+  </para></listitem>
+  <listitem><para>
+  Decide whether you want to use a <link linkend="new-projects-start-cvs">version control system</link>, like &eg; CVS, and supply the necessary data if needed.
+  </para></listitem>
+  <listitem><para>
+  Set up some templates for <link linkend="new-projects-start-templates">initial header and source files</link> (if applicable).
+  </para></listitem>
+  <listitem><para>
+  Finally tell &appwizard; to <link linkend="new-projects-start-build">set up all initial stuff</link>, directory structure, starting header/source file templates, and management tools, like &eg; an initial make skeleton, &etc;
+  </para></listitem>
+</orderedlist>
+<para>
+Voil&agrave;&mdash;that's all. &appwizard; will have provided you with a primary functional set of programming files, where you can readily start working.
+</para>
+<para>
+Let's look at all this in more detail now ...
+</para>
+
+<sect2 id="new-projects-start">
+<title>Initial Steps</title>
+
+<indexterm zone="new-projects-start">
+  <primary>dialog</primary>
+  <secondary>create new project</secondary></indexterm>
+<indexterm zone="new-projects-start">
+  <primary>project</primary>
+  <secondary>create new project</secondary>
+  <tertiary>dialog</tertiary></indexterm>
+<indexterm zone="new-projects-start">
+  <primary>project</primary>
+  <secondary>templates</secondary></indexterm>
+<indexterm zone="new-projects-start">
+  <primary>templates</primary>
+  <secondary>project</secondary></indexterm>
+
+<para>
+To create a new project in &kdevelop;, select <guimenuitem>New Project</guimenuitem> from the <guimenu>Project</guimenu> menu.  The <guilabel>Create New Project</guilabel> dialog will pop up showing an initial <guilabel>General</guilabel> page:
+</para>
+
+<screenshot id="screenshot-newprojectwizard">
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="create-new-project.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    Initial dialog to set up a new project
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+As you see, this dialog is divided into an upper and a lower part. In the upper part you can decide on the programming language and application type, the lower part holds some general information.
+</para>
+
+<sect3 id="new-projects-start-type">
+<title>Select Programming Language and Application Type</title>
+
+<indexterm zone="new-projects-start-type">
+  <primary>project</primary>
+  <secondary>application type</secondary></indexterm>
+<indexterm zone="new-projects-start-type">
+  <primary>project</primary>
+  <secondary>programming language</secondary></indexterm>
+<indexterm zone="new-projects-start-type">
+  <primary>project</primary>
+  <secondary>language</secondary></indexterm>
+<indexterm zone="new-projects-start-type">
+  <primary>language</primary></indexterm>
+<indexterm zone="new-projects-start-type">
+  <primary>programming language</primary></indexterm>
+<indexterm zone="new-projects-start-type">
+  <primary>application</primary>
+  <secondary>type</secondary></indexterm>
+
+<para>
+The left hand side of the upper part in this dialog is where you do the selection work. When it shows up, you'll find there a list of folders each labeled with a programming language, as there are:
+</para>
+
+<itemizedlist>
+  <listitem><para>
+    Ada
+    <indexterm>
+      <primary>Ada</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    C
+    <indexterm>
+      <primary>C</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    C++
+    <indexterm>
+      <primary>C++</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    Database (SQL Projects)
+    <indexterm>
+      <primary>SQL</primary>
+      <secondary>new project</secondary></indexterm>
+    <indexterm>
+      <primary>Database</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    Fortran
+    <indexterm>
+      <primary>Fortran</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    Haskell
+    <indexterm>
+      <primary>Haskell</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    Java
+    <indexterm>
+      <primary>Java</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    PHP
+    <indexterm>
+      <primary>PHP</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    Pascal
+    <indexterm>
+      <primary>Pascal</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    Perl
+    <indexterm>
+      <primary>Perl</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    Python
+    <indexterm>
+      <primary>Python</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    Ruby
+    <indexterm>
+      <primary>Ruby</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    Shell (Scripts for the Bash Shell)
+    <indexterm>
+      <primary>Bash</primary>
+      <secondary>new project</secondary></indexterm>
+    <indexterm>
+      <primary>shell</primary>
+      <secondary>new project</secondary></indexterm>
+  </para></listitem>
+</itemizedlist>
+
+<para>
+To be precise, these folders do not contain real programming tools actually. They do lead to pre-defined <emphasis>templates</emphasis> you can use as a starting point for development in that language. To get an idea of what is provided, just open the folders one after the other. There will be a series of subfolders on some, one or more simple entries only on others. The subfolders you see organize the available templates according to some tasks, the simple entries name the templates you may select.
+</para>
+<para>
+We cannot go into detail here on which tasks each template provides, but it's easy to find out. Whenever you select a template entry some information is displayed in the fields to the right. In the lower field you will find a <emphasis>short description</emphasis> on what the template is supposed to do. In the field above that a picture will be shown, if available, about the outcome of the application this template produces if you compile and run it unmodified. Usually this is a <emphasis>screenshot</emphasis> of the main window the application will display.
+</para>
+<para>
+Select the template which best fits your application's goals as a starting point. Then enter the general properties information in the lower field as shown in the next chapter.
+</para>
+
+<formalpara>
+<title>Selecting a Project Management System</title>
+<para>
+Each template is bound to a specific <link linkend="makesystems">Project Management System</link>. Currently there is no direct means to freely select such a Project Management System. You have to find a template which suits your needs or alter your project accordingly after creation.
+</para>
+</formalpara>
+
+</sect3> <!-- new-projects-start-type -->
+
+<sect3 id="new-projects-start-general">
+<title>Provide General Information</title>
+
+<indexterm zone="new-projects-start-general">
+  <primary>project</primary>
+  <secondary>properties</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>properties</primary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>application</primary>
+  <secondary>name</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>name</primary>
+  <secondary>application</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>project</primary>
+  <secondary>directory</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>directory</primary>
+  <secondary>project</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>path</primary>
+  <secondary>new project</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>project</primary>
+  <secondary>author</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>project</primary>
+  <secondary>email</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>author</primary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>email</primary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>project</primary>
+  <secondary>main.cpp</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>main.cpp</primary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>project</primary>
+  <secondary>license</secondary></indexterm>
+<indexterm zone="new-projects-start-general">
+  <primary>license</primary></indexterm>
+
+<para>
+The lower part of the <guilabel>Create New Project</guilabel> dialog <guilabel>General</guilabel> page is a framed field labeled <guilabel>Properties</guilabel>. You must provide some general information about your project here so that the &appwizard; knows how to build the initial structure.
+</para>
+<formalpara>
+<title>Application Name</title>
+<para>
+Your application needs a name of course. Enter this in the uppermost <guilabel>Properties</guilabel> field, called <guilabel>Application Name</guilabel>. We use <quote>MyApp</quote> as an example.
+</para>
+</formalpara>
+<para>
+When you do so, you will notice that the &appwizard; refuses to accept special characters of any kind. The only characters accepted are:
+<itemizedlist>
+  <listitem><para>upper and lower case characters</para></listitem>
+  <listitem><para>numbers</para></listitem>
+  <listitem><para>the underline character</para></listitem>
+</itemizedlist>
+</para>
+<para>
+One prominent cause of this restriction is that the &appwizard; will use this application name as the <emphasis>basis of some class names</emphasis> it will construct when it sets up an initial project. Thus the name of the application must stick to the rules of the programming language you use.
+</para>
+<formalpara>
+<title>The Project Directory</title>
+<para>
+The other prominent cause of this restriction you can see at the bottom line of the <guilabel>Properties</guilabel> area. It is labeled <guilabel>Final location</guilabel> and shows the directory where the &appwizard;  will create the application.
+</para>
+</formalpara>
+<para>
+As you type the application name you will notice that the &appwizard; repeats your input at the end of the <guilabel>Final location</guilabel> line, using lower case only characters.
+</para>
+<para>
+Thus you must select the name of your new application with care.  If you end up with an already used directory the &appwizard; will not allow you to continue to the next step, keeping the <guibutton>Next &gt;</guibutton> button deactivated (grayed). Yet, it will <emphasis>warn</emphasis> you in this case by appending <quote>(dir/file already exist)</quote> to the <guilabel>Final location</guilabel> line.
+</para>
+
+<formalpara>
+<title>The Starting Path</title>
+<para>
+There are two ways to select another path for your new application. One is to select another name. Yet, this is not always feasible (you might &eg; set up for another version of an already existing application). As an alternative you may select another path to the application directory.
+</para>
+</formalpara>
+<para>
+This is done in the second row input field of the <guilabel>Properties</guilabel>, named <guilabel>Location</guilabel>. What you enter here is the <emphasis>starting path</emphasis> of the new application development directory. The &appwizard; appends the application name to this path when it initializes the new project. The result is shown in the <guilabel>Final location</guilabel> line to give you better control on what is going on.
+</para>
+<para>
+&appwizard; will copy an <emphasis>initial value</emphasis> to the <guilabel>Location</guilabel> field on start-up. This is taken from what you have chosen in the <guilabel>Default projects directory</guilabel> field during the <link linkend="setup-general">general configuration steps</link>. In our case we have &kdevelop; set up to use <filename class="directory">/home/devel/projects/</filename> as initial path for new projects.
+</para>
+<para>
+Alter the <guilabel>Location</guilabel> field contents so that the application development directory shown in the <guilabel>Final location</guilabel> line will be unique.
+</para>
+<!--TODO add tab description Project Options -->
+<note><para>
+Take care that the path you enter in the <guilabel>Location</guilabel> field already exists. Otherwise you will not be able to continue to the next step. The &appwizard; will <emphasis>warn</emphasis> you about non-existing paths by appending <quote>(invalid)</quote> to the <guilabel>Final location</guilabel> line.
+</para></note>
+
+<screenshot id="screenshot-createnewprojectoptions">
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="createnewprojectoptions.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    Set new project up for CVS
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<formalpara>
+<title>Personal Information</title>
+<para>
+The fields following this are not so critical. Just supply your name (&ie; the name of the person who is responsible for the application) in the <guilabel>Author</guilabel> field, and a valid e-mail address in the <guilabel>Email</guilabel> field, so that users can give you feedback on the application.
+</para>
+</formalpara>
+
+<note>
+<orderedlist>
+  <listitem><para>
+  The &appwizard; fills these fields with some default values, taken from
+  the Email presets in the &kcontrolcenter;. If these defaults in the <guilabel>Create New Project</guilabel> <guilabel>Author</guilabel> and <guilabel>Email</guilabel> fields do not suit, you may want to have a look at your mail configuration in the &kcontrolcenter;.
+  </para></listitem>
+  <listitem><para>
+  The &appwizard; will integrate this information into the starting program templates if applicable. In &kde; C++ programs for instance you will find it near the beginning of the <filename>main.cpp</filename> source file.
+  </para></listitem>
+  <listitem><para>
+  Of all fields, the <guilabel>Email</guilabel> is <emphasis>optional</emphasis>, reflecting the fact that not every developer may have access to the internet. You may keep this field empty if you wish and proceed nevertheless.
+  </para></listitem>
+</orderedlist>
+</note>
+
+<formalpara>
+<title>Version and License Info</title>
+<para>
+Finally enter a starting version number for your new application in the <guilabel>Version</guilabel> field, and select the license under which you want your application be put from the <guilabel>License</guilabel> tab.
+</para>
+</formalpara>
+
+<para>
+If you select an application type for which the &appwizard; provides common source template texts (&eg; C/C++), you may view the license notification text on the third page of this <guilabel>Create New Project</guilabel> dialog (see the <link linkend="new-projects-start-templates">Supply header/source templates</link> chapter below).
+</para>
+<para>
+If you selected <quote>Custom</quote> from the <guilabel>License</guilabel> tab you must provide a license text on your own.
+</para>
+
+<note><para>
+Both version and license information will as well be integrated into the starting templates in a suiting format the application type you selected does provide.
+</para></note>
+
+<para>
+Once you have correctly entered all this information stuff, press the <guibutton>Next &gt;</guibutton> button to proceed as shown in the following chapters.
+</para>
+</sect3> <!-- new-projects-start-general -->
+
+</sect2> <!-- new-projects-start -->
+
+<sect2 id="new-projects-start-cvs">
+<title>Supply Version System Information</title>
+
+<indexterm zone="new-projects-start-cvs">
+  <primary>CVS</primary>
+  <secondary>new project</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs">
+  <primary>project</primary>
+  <secondary>CVS</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs">
+  <primary>database</primary>
+  <secondary>CVS</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs">
+  <primary>version</primary>
+  <secondary>database</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs">
+  <primary>version</primary>
+  <secondary>CVS</secondary></indexterm>
+
+<para>
+In a second step the &appwizard; will lead you to the <guilabel>Version Control System</guilabel> page where you can decide which version control system you want to use.
+</para>
+
+<note><para>
+This discussion concentrates on the needs for project creation only. For more information on &CVS; see the <link linkend="cvs">Using &CVS;</link> chapter below.
+</para></note>
+
+<formalpara>
+<title>No Version Control System Wanted</title>
+<para>
+Initially there is <quote>None</quote> selected in the <guilabel>Version control system</guilabel> tab, and the page will be empty otherwise. If you don't want to use a version control system, just click the <guibutton>Next ></guibutton> button and go on.
+</para>
+</formalpara>
+
+<formalpara>
+<title>Using &CVS;</title>
+<para>
+Otherwise you must reselect the version control system you want to use from the <guilabel>Version control system</guilabel> tab. We use <quote>&cvs;</quote> for our example. If you select this, the &appwizard; will redisplay the page, now showing a series of fields you must fill in.
+</para>
+</formalpara>
+
+<screenshot id="screenshot-newproject-cvs">
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="create-new-project-cvs.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    Set new project up for CVS
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+A version control system such as &CVS; (which means <quote>Concurrent Versions System</quote>) stores copies of selected project files in some sort of a database. If you use &CVS; you can amongst others upload (<quote>commit</quote>) those files or load them back into your project directory (<quote>checkout</quote>, or <quote>update</quote>). The special thing about this is that the files in the versioning database are stored in a structured way which allows you to always revert to an earlier development state if you need so. And &CVS; allows multiple designers to fairly easily collaborate on a big project (such as &kdevelop;) without disturbing each others work.
+</para>
+
+<indexterm zone="new-projects-start-cvs-root">
+  <primary>CVS</primary>
+  <secondary>root</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs-root">
+  <primary>root</primary>
+  <secondary>CVS</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs-root">
+  <primary>CVS</primary>
+  <secondary>local</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs-root">
+  <primary>CVS</primary>
+  <secondary>remote</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs-root">
+  <primary>local CVS</primary></indexterm>
+<indexterm zone="new-projects-start-cvs-root">
+  <primary>:local:</primary></indexterm>
+<indexterm zone="new-projects-start-cvs-root">
+  <primary>CVS</primary>
+  <secondary>:local:</secondary></indexterm>
+
+<formalpara id="new-projects-start-cvs-root">
+<title>&CVS; Root</title>
+<para>
+&CVS; needs to <emphasis>manage</emphasis> the versioning database it keeps from your project files. To accomplish this it keeps some special database information in an own directory, called the <emphasis>&CVS; root</emphasis>. The first step on setting up &CVS; for your new project thus is to tell &kdevelop; where this root is located.
+</para>
+</formalpara>
+
+<para>
+<emphasis>Local &CVS; root.</emphasis> There are two basic possibilities. Either you want to use a <emphasis>local</emphasis> &CVS; database or you use a database which is held on a <emphasis>remote server</emphasis>. If you develop for your own, you may want use the &CVS; database as some sort of a backup system on your own computer. Usually this is set up in your home directory root and given the name <filename>cvsroot</filename>. This may look as follows:
+</para>
+<para><userinput><filename class="directory">/home/devel/cvsroot</filename></userinput> (where <filename>devel</filename> simply denotes the <quote>developing</quote> user, just for example)
+</para>
+
+<note><para>
+In fact, this is a short form. Exactly, the local &CVS; root should be addressed using the <computeroutput>:local:</computeroutput> prefix. The short form is only allowed in cases where the filename starts with a slash (<computeroutput>/</computeroutput>). The full name for our example local &CVS; root would exactly look like: <filename class="directory">:local:/home/devel/cvsroot</filename>
+</para></note>
+
+<para>
+Enter the name of the &CVS; root directory your system has been set up for in the <guilabel>CVS root</guilabel> field. In principle you can select any name, even use multiple &CVS; databases, but it is advisable that you stick to the &CVS; root once set up.
+</para>
+<para>
+<emphasis>Initialize a new &CVS; root.</emphasis> If there does not exist a &CVS; root yet, &kdevelop; can command the &CVS; system to create one for you in the given directory. Just check the <guilabel>Init root</guilabel> checkbox below the <guilabel>CVS root</guilabel> field.
+</para>
+<note><para>
+As said, &kdevelop; only <emphasis>commands</emphasis> the &CVS; system to initialize a new &CVS; root. It does nothing by itself to this directory. Fortunately &CVS; is clever enough to check whether the &CVS; root directory already exists. Hence it does no harm if you should have inadvertently checked <guilabel>Init root</guilabel> on an already existing &CVS; root directory.
+</para></note>
+
+<para>
+<emphasis>Remote &CVS; root.</emphasis> There are occasions where the &CVS; database is to be kept on a remote server, especially when several developers work at the same project. Then you must enter the &CVS; root &URL; of this server in the <guilabel>CVS root</guilabel> field. For example, if you want access to the &kde; &CVS; server:
+</para>
+<para>
+<userinput><filename class="directory">:pserver:<replaceable>mylogin</replaceable>@cvs.kde.org:/home/kde</filename></userinput> (where <replaceable>mylogin</replaceable> denotes the login name set up in your &kde; &CVS; account)
+</para>
+
+<indexterm zone="new-projects-start-cvs-remote">
+  <primary>remote CVS</primary></indexterm>
+<indexterm zone="new-projects-start-cvs-remote">
+  <primary>:pserver:</primary></indexterm>
+<indexterm zone="new-projects-start-cvs-remote">
+  <primary>:ext:</primary></indexterm>
+<indexterm zone="new-projects-start-cvs-remote">
+  <primary>CVS</primary>
+  <secondary>:local:</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs-remote">
+  <primary>CVS</primary>
+  <secondary>:pserver:</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs-remote">
+  <primary>CVS</primary>
+  <secondary>:ext:</secondary></indexterm>
+
+<formalpara id="new-projects-start-cvs-remote">
+<title>Remote &CVS; Server Types</title>
+<para>
+Basically there are two widely used remote &CVS; server types, the
+<emphasis>pserver</emphasis> which uses a password-secured non-encrypted
+protocol, and the <emphasis>ext</emphasis> server which uses an rsh or ssh
+encrypted data transfer. They are distinguished by the &URL; prefix they use:
+</para>
+</formalpara>
+<para>
+<filename>:pserver:</filename>
+</para>
+<para>
+for the <quote>password protected server</quote> non-encrypted type, and
+</para>
+<para>
+<filename>:ext:</filename>
+</para>
+<para>
+for an rsh or ssh encrypted server type. For example
+</para>
+<para>
+<userinput><filename class="directory">:ext:<replaceable>mylogin</replaceable>@cvs.cervisia.sourceforge.net:/cvsroot/cervisia</filename></userinput>
+</para>
+<para>
+accesses the &CVS; root of the widely used <application>Cervisia</application> &CVS; management tool on the SourceForge server.
+</para>
+<para>
+If you want to use an rsh or ssh encrypted server for &CVS; access you must tell &kdevelop; the encryption protocol to be used. Just enter <userinput>rsh</userinput> or <userinput>ssh</userinput> in the <guilabel>CVS_RSH</guilabel> field of the <guilabel>Create New Project</guilabel> <guilabel>Version Control System</guilabel> page.
+</para>
+
+<note><para>
+There is a caveat if you use an encrypted server for &CVS; from within &kdevelop;. See the <link linkend="cvs">Using &CVS;</link> chapter for details.
+</para></note>
+
+<indexterm zone="new-projects-start-cvs-repository">
+  <primary>CVS</primary>
+  <secondary>repository</secondary></indexterm>
+<indexterm zone="new-projects-start-cvs-repository">
+  <primary>repository</primary>
+  <secondary>CVS</secondary></indexterm>
+
+<formalpara id="new-projects-start-cvs-repository">
+<title>The &CVS; Repository</title>
+<para>
+So far you have told &kdevelop; where the &CVS; root resides which manages the versioning database and how to access it. Now you need to tell &kdevelop; under which name you want &CVS; save your project files in that database. Such a place your project files will be held in &CVS; is called a <emphasis>repository</emphasis>.
+</para>
+</formalpara>
+<para>
+In principle you can use any name for the &CVS; repository of your project files as long as it adheres to the specifications of naming a file. Yet, most developers simply use the name of the application itself. &CVS; will build a directory with this name in the &CVS; root, hence it is more easily found if you keep the application name for it.
+</para>
+<para>
+Just enter the repository name you want to use in the <guilabel>CVS repository</guilabel> field of the <guilabel>Create New Project</guilabel> <guilabel>Version Control System</guilabel> page. In our example this is: <userinput>MyApp</userinput>
+</para>
+
+<warning><para>
+<emphasis>Take care not to use a repository which already exists!</emphasis> The &CVS; system does not warn about duplicate files but will shovel everything in which does not produce a formal conflict. You will mess up everything!
+</para></warning>
+
+<formalpara>
+<title>The Remaining Fields</title>
+<para>
+There is not much work left to do. &appwizard; has already set up the remaining fields for you. In detail:
+</para>
+</formalpara>
+<para>
+The <guilabel>Vendor</guilabel> field is used for compatibility reasons only. You can stick to the <quote>vendor</quote> default the &appwizard; puts in here.
+</para>
+<para>
+The <guilabel>Message</guilabel> field allows you to comment the initial &CVS; contents. Use any text you like or just stick to the <quote>new project</quote> default the &appwizard; did put in.
+</para>
+<para>
+The <guilabel>Release tag</guilabel> holds the name which tags the initial state of your project. Such a <emphasis>tag</emphasis> names a certain point within the &CVS; repository by which you can later access this state of your development. (See more in  the <link linkend="cvs">Using &CVS;</link> chapter.)
+</para>
+<para>
+The &appwizard; has put a default <quote>start</quote> tag in here which is a worthy proposal. Just stick to it.
+</para>
+
+<note>
+<para>
+When any information of all these is wrong &kdevelop; usually will not know about until project construction time. It is the &CVS; system which will figure out those errors when it tries to build the repository. Hence you must keep an eye to the <guilabel>Messages</guilabel> window of &kdevelop; when the project is created in the final setup step. If anything was in error with &CVS; you will in most cases see an error message like this:
+</para>
+
+<screen><computeroutput>
+* cd '/home/devel/test' &amp;&amp; cvs -d '/home/devel/mycvsroot' \
+  import -m 'new project' '' 'vendor' 'start' &amp;&amp;\
+  sh /opt/kde3/share/apps/kdevcvs/buildcvs.sh . '' \
+  '/home/devel/mycvsroot'
+* cvs [import aborted]: /home/devel/mycvsroot/CVSROOT: No such file or
+  directory
+* *** Exited with status: 1 ***
+</computeroutput></screen>
+
+<para>
+If this happens you will have to either manually set up &CVS; (&kdevelop; should have successfully initialized your project files at this time) or delete the project directory and start over again with <guimenuitem>New Project</guimenuitem> from the <guimenu>Project</guimenu> menu.
+</para>
+</note>
+
+<para>
+After you have entered all &CVS; related information, click the <guibutton>Next &gt;</guibutton> to go on.
+</para>
+
+<note><para>
+If you want to correct an error on the previous <guilabel>Create New Project</guilabel> page, just press the <guibutton>&lt; Back</guibutton> button. The &appwizard; will remember your settings on the current page, so you can easily proceed when you come back.
+</para></note>
+
+</sect2> <!-- new-projects-start-cvs -->
+
+<sect2 id="new-projects-start-templates">
+<title>Supply Header/Source Templates</title>
+
+<para>
+The next step brings you to a series of pages where you can set up common information you want to include in your source and header files, if the task at hand allows.
+</para>
+<para>
+Both header and source templates are provided for C and C++ applications, each on its own page. For other languages there may be source templates only. And in some cases you will even find this template page empty.
+</para>
+<para>
+If the page is used, &appwizard; will fill in some common header comment which for a C++ based application might look like:
+</para>
+
+<screen><computeroutput><literal>
+/***************************************************************************
+ *   Copyright (C) 2003 by Your Name                                       *
+ *   you@you.com                                                           *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
+ ***************************************************************************/
+</literal></computeroutput></screen>
+
+<para>
+Other templates will provide similar information in a format according to the definitions of the programming language you want to use.
+</para>
+<para>
+As you might have noticed, the applications manager did readily fill in some information you provided on the first <guilabel>General</guilabel> page of the <guilabel>Create New Project</guilabel> dialog, namely the contents of the <guilabel>Author</guilabel> and <guilabel>Email</guilabel> fields. Also proper license information will have been inserted according to your selection in the <guilabel>License</guilabel> tab.
+</para>
+
+<sect3 id="new-projects-start-templates-edit">
+<title>How to Edit the Templates</title>
+
+<indexterm zone="new-projects-start-templates-edit">
+  <primary>templates</primary>
+  <secondary>project</secondary>
+  <tertiary>edit</tertiary></indexterm>
+<indexterm zone="new-projects-start-templates-edit">
+  <primary>project</primary>
+  <secondary>templates</secondary>
+  <tertiary>edit</tertiary></indexterm>
+
+<para>
+The templates you set up in the <guilabel>Create New Project</guilabel> dialog will later be processed whenever you command &kdevelop; to set up a new source and/or header file. The information you provided here will be included at top as a documentation header, before the code parts begin.
+</para>
+<para>
+You are not restricted to plain text however. &kdevelop; knows of several variables which allow you to include actual information in the file. The &appwizard; did in fact use some such variables to insert the <guilabel>Author</guilabel>, <guilabel>Email</guilabel>, and <guilabel>License</guilabel> informations into the initial template text.
+</para>
+
+<variablelist>
+<varlistentry>
+<term>Include &doxygen; File Information</term>
+<listitem>
+<para>
+If, for example, you want the &doxygen;-built &API; documentation to display some further information about the file's contents in its filenames list, you may include the following lines in the source file template:
+</para>
+<screen><computeroutput>
+/**
+ * \file $MODULE$.cpp
+ * \brief (put some short descripion here).
+ **/
+</computeroutput></screen>
+<para>
+Whenever you create a new source file, &kdevelop; will replace the <varname>$MODULE$</varname> variable by the name body of the newly created file. For example, if you created a new C++ class named <classname>ASimpleTest</classname> you will see the following lines in the <filename>asimpletest.cpp</filename> file:
+</para>
+<screen><computeroutput>
+/**
+ * \file asimpletest.cpp
+ * \brief (put some short descripion here).
+ **/
+</computeroutput></screen>
+<para>
+You will still have to provide the short description after the <quote>\brief</quote> keyword, but part of the job is automatically done for you.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>The License Text File</term>
+<listitem>
+<para>
+As another example you could include an explicit hint to the license text you want to use into the template. Use the <varname>$LICENSEFILE$</varname> variable for this and add for example this line:
+</para>
+
+<screen><computeroutput>
+//   See $LICENSEFILE$ for the full license text.
+</computeroutput></screen>
+<para>
+The &appwizard; will replace the <varname>$LICENSEFILE$</varname> with the name of the file where the full license text is to be found, namely:
+</para>
+<screen><computeroutput>
+//   See COPYING for the full license text.
+</computeroutput></screen>
+<para>
+for the <acronym>GPL</acronym> license, or
+</para>
+<screen><computeroutput>
+//   See LICENSE.BSD for the full license text.
+</computeroutput></screen>
+<para>
+if you decided to put your application under the <acronym>BSD</acronym> license.
+</para>
+<para>
+Thee are of course more variables &kdevelop; knows of. See the <link linkend="newfiles-edittemplates">Editing the templates</link> section in the <link linkend="editing">Editing tools</link> chapter for what is possible.
+</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<note><para>
+The templates you define here will come in effect only after the &appwizard; has created the new project. You will find this information on top of the files you created yourself in the development process. When creating the initial files the &appwizard; will use some predefined standard templates. You will have to manually adapt those initial files to your needs.
+</para></note>
+
+</sect3> <!-- new-projects-start-templates-edit -->
+</sect2> <!-- new-projects-start-templates -->
+
+<sect2 id="new-projects-start-build">
+<title>Build the Initial Project Files</title>
+
+<indexterm zone="new-projects-start-build">
+  <primary>project</primary>
+  <secondary>new</secondary>
+  <tertiary>build</tertiary></indexterm>
+<indexterm zone="new-projects-start-build">
+  <primary>project</primary>
+  <secondary>initial build</secondary></indexterm>
+
+<para>
+Almost everything is done now. On the last templates page the <guibutton>Next &gt;</guibutton> button will have changed to read <guibutton>Finish</guibutton> now.
+</para>
+<para>
+<emphasis>Think twice before you click on it!</emphasis> You still have the option to revise everything by repeatedly using the <guibutton>&lt; Back</guibutton> button. As the &appwizard; remembers all information you did input so far, it may be advisable for you to take the time and look back once again. In case you use local &CVS;, do not forget to double-check the <emphasis>&CVS; repository</emphasis> name (there should be no subdirectory with that name in the &CVS; root directory already&mdash;if it does, try another repository name).
+</para>
+<para>
+If ever you don't want the new project be built, abort the <guilabel>Create New Project</guilabel> dialog by the <guibutton>Cancel</guibutton> button. Otherwise click <guibutton>Finish</guibutton> and watch in the <guilabel>Messages</guilabel> window how the &appwizard; initiates the project.
+</para>
+<para>
+If you want to use a versioning system (&CVS;) there will be two runs actually. &appwizard; will first build the project directories and files and then call up the &CVS; program which restarts the <guilabel>Messages</guilabel> window with its own contents. If any error occurs in either of these runs, the process will stop showing you an according error message in the window.
+</para>
+
+<note><para>
+In many cases when your new project has been set up this way, &kdevelop; will automatically load the source file(s) of one or more basically important modules so you can readily start work. (Which source modules will be displayed&mdash;if any at all&mdash;however depends on the template initially selected in the &appwizard;.)
+</para></note>
+
+<para>
+Do not forget to initially check what the &appwizard; has provided. For example you may want to change the initial heading informations according to your own templates. Usually you will find these in a <filename class="directory">templates</filename> subdirectory in your project directory. Some simple copy operations will mostly suffice.
+</para>
+<para>
+Then it is advisable that you <emphasis>compile the initial project</emphasis> before you attempt to change any code. In most cases this initial compilation should be possible. Thus you can make up whether the project really was set up according to your needs. If it was not, simply remove the project directory (in your local &CVS; root as well if you use one) and start over again.
+</para>
+
+<warning id="defaultbuild-warning"> <!-- ### remove this when "default" works again -->
+
+  <indexterm zone="defaultbuild-warning">
+    <primary>default build configuration</primary>
+    <secondary>warning</secondary></indexterm>
+  <indexterm zone="defaultbuild-warning">
+    <primary>build configurations</primary>
+    <secondary>default build warning</secondary></indexterm>
+  <indexterm zone="defaultbuild-warning">
+    <primary>warning</primary>
+    <secondary>default build configuration</secondary></indexterm>
+
+  <para>
+  Before you compile your new project the first time, have a look at <menuchoice><guimenu>Project</guimenu> <guimenuitem>Build Configuration</guimenuitem></menuchoice>. If there are three selections displayed: <guimenuitem>default</guimenuitem>, <guimenuitem>optimized</guimenuitem>, and <guimenuitem>debug</guimenuitem>, with <guimenuitem>debug</guimenuitem> selected, by all means stick to this, or use <guimenuitem>optimized</guimenuitem> instead.
+  </para>
+  <para>
+  Due to some limitations in the current autoconf/automake setup you should <emphasis>by no means</emphasis> build in the <guimenuitem>default</guimenuitem> configuration. This will corrupt some internal directory settings, thus making <command>configure</command> complain when you try to use it in the <guimenuitem>optimized</guimenuitem>, or <guimenuitem>debug</guimenuitem> build configuration afterwards.
+  </para>
+  <para>
+  (This applies to these multiselection capabilities only. If the application type you selected provides a <guimenuitem>default</guimenuitem> build configuration only, you should of course use this one.)
+  </para>
+</warning>
+
+</sect2> <!-- new-projects-start-build -->
+
+</sect1> <!-- new-projects -->
+
+<sect1 id="projects-configure">
+<title>Configuring Projects</title>
+
+<para>(... to be written ...)</para>
+
+</sect1>
+
+</chapter> <!-- applicationwizard -->
diff --git a/doc/kdevelop/automake-file-popup.png b/doc/kdevelop/automake-file-popup.png
new file mode 100644
index 00000000..e40f7108
--- /dev/null
+++ b/doc/kdevelop/automake-file-popup.png
diff --git a/doc/kdevelop/automake-manager.png b/doc/kdevelop/automake-manager.png
new file mode 100644
index 00000000..5e3a9907
--- /dev/null
+++ b/doc/kdevelop/automake-manager.png
diff --git a/doc/kdevelop/automake-subproject-popup.png b/doc/kdevelop/automake-subproject-popup.png
new file mode 100644
index 00000000..e795be9b
--- /dev/null
+++ b/doc/kdevelop/automake-subproject-popup.png
diff --git a/doc/kdevelop/automake-target-popup.png b/doc/kdevelop/automake-target-popup.png
new file mode 100644
index 00000000..a561e4cc
--- /dev/null
+++ b/doc/kdevelop/automake-target-popup.png
diff --git a/doc/kdevelop/automakemanager.png b/doc/kdevelop/automakemanager.png
new file mode 100644
index 00000000..89891748
--- /dev/null
+++ b/doc/kdevelop/automakemanager.png
diff --git a/doc/kdevelop/build-commands.png b/doc/kdevelop/build-commands.png
new file mode 100644
index 00000000..a6ed86e9
--- /dev/null
+++ b/doc/kdevelop/build-commands.png
diff --git a/doc/kdevelop/build-configurations.png b/doc/kdevelop/build-configurations.png
new file mode 100644
index 00000000..6194255e
--- /dev/null
+++ b/doc/kdevelop/build-configurations.png
diff --git a/doc/kdevelop/build-menu-automake.png b/doc/kdevelop/build-menu-automake.png
new file mode 100644
index 00000000..e468bb78
--- /dev/null
+++ b/doc/kdevelop/build-menu-automake.png
diff --git a/doc/kdevelop/build-menu.png b/doc/kdevelop/build-menu.png
new file mode 100644
index 00000000..20353cb5
--- /dev/null
+++ b/doc/kdevelop/build-menu.png
diff --git a/doc/kdevelop/class-browsers.docbook b/doc/kdevelop/class-browsers.docbook
new file mode 100644
index 00000000..7c251ee1
--- /dev/null
+++ b/doc/kdevelop/class-browsers.docbook
@@ -0,0 +1,90 @@
+<chapter id="class-browsers">
+<title>The Class Browsers</title>
+<indexterm zone="class-browsers"><primary>class browser</primary></indexterm>
+
+<para>
+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.
+</para>
+
+<sect1 id="classview">
+<title>Class View</title>
+
+<para>
+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.
+</para>
+
+<figure id="screenshot-classview" float="1">
+<title>A Screenshot of the Class View</title>
+<mediaobject>
+<imageobject><imagedata fileref="classview.png"/></imageobject>
+</mediaobject>
+</figure>
+
+<para>
+The class view works in two different modes. By default, all symbols are
+grouped into <quote>Classes</quote>, <quote>Structs</quote>,
+<quote>Functions</quote>, <quote>Variables</quote> and
+<quote>Namespaces</quote>.  In the context menu of the view, you can choose
+<guimenuitem>List by Namespaces</guimenuitem>. 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.
+</para>
+
+<para>
+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
+<guimenuitem>Full Identifier scopes</guimenuitem> from the context menu.
+</para>
+
+<para>
+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
+<guimenuitem>Go to declaration</guimenuitem> from the context menu. In the
+context menu for classes are also the items
+<guimenuitem>Add method...</guimenuitem> and
+<guimenuitem>Add attribute...</guimenuitem>. This opens dialogs where you can
+generate new method and variable declaration in the respective class, together
+with an empty implementation.
+</para>
+
+</sect1> <!-- classview -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="classtools">
+<title>Class Tools</title>
+
+<para>
+The class tool dialog is activated by right clicking on a class in the class
+view and choosing <guimenuitem>Class tool...</guimenuitem>.
+</para>
+
+</sect1> <!-- classtools -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="classhierarchy">
+<title>Class Hierarchy</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect1> <!-- classhierarchy -->
+
+</chapter> <!-- class-browsers -->
+
+<!-- ====================================================================== -->
diff --git a/doc/kdevelop/classview.png b/doc/kdevelop/classview.png
new file mode 100644
index 00000000..34e3707d
--- /dev/null
+++ b/doc/kdevelop/classview.png
diff --git a/doc/kdevelop/commands.docbook b/doc/kdevelop/commands.docbook
new file mode 100644
index 00000000..31fff849
--- /dev/null
+++ b/doc/kdevelop/commands.docbook
@@ -0,0 +1,1989 @@
+<chapter id="commands">
+
+<!-- TODO
+- CAUTION: Check everything against actual KDevelp behaviour. Do not rely on tool tips etc.
+- Summarize menu entries, like in getting-started.
+- Complete descriptions, e.g. from What's This.
+- Link to more detailed description, e.g. in plugin chapter.	 
+-->
+
+<chapterinfo>
+  <authorgroup>
+    <author><firstname>Volker</firstname> <surname>Paul</surname></author>
+    <!-- TRANS:ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+  
+  <date>2005-04-03</date>
+</chapterinfo>
+
+<title>Command Reference</title>
+
+<note><para>
+    The shortcut key combinations shown in this chapter are the default ones. They can be changed.
+</para></note>
+
+
+
+<sect1 id="menubar">
+<title>The Menubar</title> <para>Note that some menu entries only appear when
+they are applicable. Especially, some entries are linked to
+<link linkend="plugin-tools">plugin</link>
+functionality which is only available when the plugin is enabled.</para>
+
+
+
+
+
+
+<!--  =======================   F I L E    ============================= -->
+
+<sect2 id="menu-file">
+<title>The <guimenu>File</guimenu> Menu</title>
+
+<variablelist>
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>N</keycap></keycombo>
+</shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>New</guimenuitem>
+</menuchoice></term>
+<listitem><para>Create a new file. 
+The user is prompted to select the directory (default: the current project's
+source directory) and enter a file name. The file type can be selected from a list.
+Also, the user can choose whether the file is to be added to the project.
+Then the Automake Manager asks which target to add the new file to.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>O</keycap></keycombo>
+</shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>Open</guimenuitem>
+</menuchoice></term>
+<listitem><para>Open an existing file in a simple dialog
+box.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>O</keycap></keycombo>
+</shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>Open Recent</guimenuitem>
+</menuchoice></term>
+<listitem><para>Displays a submenu showing the files recently opened.
+Selecting one of these will make KDevelop open that file.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;&Ctrl;<keycap>O</keycap></keycombo>
+</shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>Quick Open</guimenuitem>
+</menuchoice></term>
+<listitem><para>Presents a list of files in the current project's
+source directory. The user can select from this list
+or type a filename. That file is then opened.
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>S</keycap></keycombo>
+</shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>Save</guimenuitem>
+</menuchoice></term>
+<listitem><para>Saves the current file.</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>S</keycap></keycombo>
+</shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>Save As...</guimenuitem>
+</menuchoice></term>
+<listitem><para>Uses the
+<guilabel>Save As...</guilabel> dialog box to let you save a copy
+under a new name.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>File</guimenu>
+<guimenuitem>Save All</guimenuitem>
+</menuchoice></term>
+<listitem><para>Saves all open files.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut><keycap>F5</keycap></shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>Reload</guimenuitem>
+</menuchoice></term>
+<listitem><para>Reloads current file to show changes 
+made by different programs.
+(Note that such changes are normally detected automatically
+and the user is prompted whether the file is to be reloaded.)
+.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>File</guimenu>
+<guimenuitem>Revert all</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Reverts all changes in opened files.
+Prompts to save changes so the
+reversion can be canceled for each
+modified file.
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>P</keycap></keycombo>
+</shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>Print...</guimenuitem>
+</menuchoice></term>
+<listitem><para>Print.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>File</guimenu>
+<guimenuitem>Export</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Export
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>F4</keycap></keycombo>
+</shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>Close</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Closes current file.
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>File</guimenu>
+<guimenuitem>Close All</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Closes all open files.
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>File</guimenu>
+<guimenuitem>Close All Others</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Closes all files except the current one.
+Very useful if you opened a lot of files and you want 
+to concentrate on the current one.
+Without this, you would have to close them all
+and re-open the current one.
+</para>
+<para>Note there is a similar command in the Window menu.
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>Q</keycap></keycombo>
+</shortcut>
+<guimenu>File</guimenu>
+<guimenuitem>Quit</guimenuitem>
+</menuchoice></term>
+<listitem><para>Close KDevelop.</para></listitem>
+</varlistentry>
+
+</variablelist>
+
+</sect2>
+
+
+
+<!--  =======================   E D I T    ============================= -->
+
+
+<sect2 id="menu-edit">
+<title>The <guimenu>Edit</guimenu> Menu</title>
+
+
+<variablelist>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>Z</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Undo</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Undo
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;&Shift;<keycap>Z</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Redo</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Redo
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>X</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Cut</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Cut
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>C</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Copy</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Copy
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>V</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Paste</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Paste
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>A</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Select All</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Select All
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;&Shift;<keycap>A</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Deselect</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Deselect
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;&Shift;<keycap>B</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Block Selection Mode</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Block Selection Mode
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>Insert</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Overwrite Mode</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Overwrite Mode
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>F</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Find</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Find
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F3</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Find Next</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Find Next
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Shift;<keycap>F3</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Find Previous</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Find Previous
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>R</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Replace</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Replace
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>G</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Go to Line</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Go to Line
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;&Ctrl;<keycap>F</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Find in Files</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Find in Files
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Shift;<keycap>R</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Find-Select-Replace</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Find-Select-Replace
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Edit</guimenu>
+<guimenuitem>Reformat Source</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Reformat Source
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>J</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Expand Text</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Expand Text
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>L</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Expand Abbreviation</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Expand Abbreviation
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>Space</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Complete Text</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Complete Text
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F2</keycap></keycombo>
+</shortcut>
+<guimenu>Edit</guimenu>
+<guimenuitem>Make Member</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Make Member
+</para></listitem>
+</varlistentry>
+
+
+</variablelist>
+
+</sect2>
+
+
+
+<!--  =======================   V I E W   ============================= -->
+
+
+<sect2 id="menu-view">
+
+<title>The <guimenu>View</guimenu> Menu</title>
+
+<variablelist>
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Back</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Back
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Forward</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Forward
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>/</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Switch to...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Switch to...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;<keycap>C</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Raise Editor</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Raise Editor
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F4</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Next Error</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Next Error
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Shift;<keycap>F4</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Previous Error</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Previous Error
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Shift;<keycap>F</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Full Screen Mode</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Full Screen Mode
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>F12</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Switch Header/Implementation</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Switch Header/Implementation
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Tool Views</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Tool Views
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Tool Docks</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Tool Docks
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F7</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Switch to Command Line</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Switch to Command Line
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Schema</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Schema
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F10</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Dynamic Word Wrap</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Dynamic Word Wrap
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Dynamic Word Wrap Indicators</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Dynamic Word Wrap Indicators
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Show/Hide Static Word Wrap Marker</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Show/Hide Static Word Wrap Marker
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F6</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Show/Hide Icon Border</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Show/Hide Icon Border
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F11</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Show/Hide Line Numbers</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Show/Hide Line Numbers
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Show/Hide Scrollbar Marks</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Show/Hide Scrollbar Marks
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F9</keycap></keycombo>
+</shortcut>
+<guimenu>View</guimenu>
+<guimenuitem>Show/Hide Folding Marks</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Show/Hide Folding Marks
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Code Folding</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Code Folding
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>View</guimenu>
+<guimenuitem>Set Encoding</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Set Encoding
+</para></listitem>
+</varlistentry>
+
+
+
+</variablelist>
+
+</sect2>
+
+
+
+
+<!--  =======================   P R O J E C T    ============================= -->
+
+
+<sect2 id="menu-project">
+<title>The <guimenu>Project</guimenu> Menu</title>
+
+<variablelist>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>New Project...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+New Project...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Open Project...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Open Project...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Open Recent Project</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Open Recent Project
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Active Language</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Active Language
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Import Existing Project...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Import Existing Project...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>New Class...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+New Class...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Class Inheritance Diagram</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Class Inheritance Diagram
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Add Translation...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Add Translation...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Build Configuration</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Build Configuration
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Distribution &amp; Publishing</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Distribution &amp; Publishing
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Project Options...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Project Options...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Project</guimenu>
+<guimenuitem>Close Project</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Close Project
+</para></listitem>
+</varlistentry>
+
+
+
+
+</variablelist>
+
+</sect2>
+
+
+<!--  =======================   B U I L D    ============================= -->
+
+
+<sect2 id="menu-build">
+<title>The <guimenu>Project</guimenu> Menu</title>
+
+<variablelist>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F8</keycap></keycombo>
+</shortcut>
+<guimenu>Build</guimenu>
+<guimenuitem>Build Project</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Build Project
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>F7</keycap></keycombo>
+</shortcut>
+<guimenu>Build</guimenu>
+<guimenuitem>Build Active Target</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Build Active Target
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Compile File</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Compile File
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Run Configure</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Run Configure
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Run automake &amp; friends</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Run automake &amp; friends
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Install</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Install
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Install (as root user)</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Install (as root user)
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Clean project</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Clean project
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Distclean</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Distclean
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Shift;<keycap>F9</keycap></keycombo>
+</shortcut>
+<guimenu>Build</guimenu>
+<guimenuitem>Make Messages &amp; Merge</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Make Messages &amp; Merge
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Execute Program</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Execute Program
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Build API Documentation</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Build API Documentation
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Build</guimenu>
+<guimenuitem>Clean API Documentation</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Clean API Documentation
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul"><keycap>Escape</keycap></keycombo>
+</shortcut>
+<guimenu>Build</guimenu>
+<guimenuitem>Stop</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Stop
+</para></listitem>
+</varlistentry>
+
+
+
+
+</variablelist>
+
+</sect2>
+
+
+
+<!--  =======================   D E B U G    ============================= -->
+
+
+<sect2 id="menu-debug">
+<title>The <guimenu>Project</guimenu> Menu</title>
+
+<variablelist>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Start</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Start
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Stop</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Stop
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Interrupt</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Interrupt
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Run to Cursor</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Run to Cursor
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Step Over</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Step Over
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Step over Instruction</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Step over Instruction
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Step Into</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Step Into
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Step into Instruction</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Step into Instruction
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Step Out</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Step Out
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Toggle Breakpoint</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Toggle Breakpoint
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Viewers</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Viewers
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Examine Core File...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Examine Core File...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Attach to Process</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Attach to Process
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Valgrind Memory Leak Check</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Valgrind Memory Leak Check
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Debug</guimenu>
+<guimenuitem>Profile with KCachegrind</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Profile with KCachegrind
+</para></listitem>
+</varlistentry>
+
+
+
+
+</variablelist>
+
+</sect2>
+
+
+
+
+
+<!--  =======================   B O O K M A R K S   ============================= -->
+
+
+
+<sect2 id="menu-bookmarks">
+<title>The <guimenu>Bookmarks</guimenu> Menu</title>
+
+<variablelist>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>B</keycap></keycombo>
+</shortcut>
+<guimenu>Bookmarks</guimenu>
+<guimenuitem>Set Bookmark</guimenuitem>
+</menuchoice></term>
+<listitem><para>Add current selection to your
+bookmarks.</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Bookmarks</guimenu>
+<guimenuitem>Clear All Bookmarks</guimenuitem>
+</menuchoice></term>
+<listitem><para>Clear All Bookmarks.</para></listitem>
+</varlistentry>
+</variablelist>
+
+</sect2>
+
+
+
+
+<!--  =======================   W I N D O W   ============================= -->
+
+
+<sect2 id="menu-window">
+<title>The <guimenu>Window</guimenu> Menu</title>
+
+<variablelist>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;<keycap>W</keycap></keycombo></shortcut>
+<guimenu>Window</guimenu>
+<guimenuitem>Close Selected Windows...</guimenuitem>
+</menuchoice></term>
+<listitem><para>Close Selected Windows...</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>F4</keycap></keycombo></shortcut>
+<guimenu>Window</guimenu>
+<guimenuitem>Close</guimenuitem>
+</menuchoice></term>
+<listitem><para>Close</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Window</guimenu>
+<guimenuitem>Close All</guimenuitem>
+</menuchoice></term>
+<listitem><para>Close All</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Window</guimenu>
+<guimenuitem>Close All Others</guimenuitem>
+</menuchoice></term>
+<listitem><para>Close All Others</para></listitem>
+</varlistentry>
+
+
+</variablelist>
+
+</sect2>
+
+
+
+
+
+
+<!--  =======================   T O O L S   ============================= -->
+
+
+<sect2 id="menu-tools">
+<title>The <guimenu>Tools</guimenu> Menu</title>
+
+<variablelist>
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Read Only Mode</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Read Only Mode
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Filetype Mode</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Filetype Mode
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Highlight Mode</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Highlight Mode
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>End of Line</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+End of Line
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Spelling</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Spelling
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>I</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Indent</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Indent
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;&Shift;<keycap>I</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>unindent</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+unindent
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Clean Indentation</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Clean Indentation
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>Tab</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Align</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Align
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>D</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Comment</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Comment
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;&Shift;<keycap>D</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Uncomment</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Uncomment
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>U</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Uppercase</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Uppercase
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;&Shift;<keycap>U</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Lowercase</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Lowercase
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;&Ctrl;<keycap>U</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Capitalize</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Capitalize
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>J</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Join Lines</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Join Lines
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Word Wrap Document</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Word Wrap Document
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Difference Viewer...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Difference Viewer...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Execute Command...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Execute Command...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Filter Selection Through Command...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Filters selection through external command using 
+<link linkend="KDevFilter">the Filter plugin</link>.
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Debug Regular Expression...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Debug Regular Expression...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Tools</guimenu>
+<guimenuitem>Part Explorer</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Part Explorer
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;&Ctrl;<keycap>C</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Quick Open Class...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Quick Open Class...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;&Ctrl;<keycap>M</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Quick Open Method...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Quick Open Method...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;&Ctrl;<keycap>P</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Preview Doxygen Output</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Preview Doxygen Output
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;&Shift;<keycap>S</keycap></keycombo>
+</shortcut>
+<guimenu>Tools</guimenu>
+<guimenuitem>Document Current Function</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Document Current Function
+</para></listitem>
+</varlistentry>
+
+
+
+</variablelist>
+
+</sect2>
+
+
+
+
+<!--  =======================   S E T T I N G S   ============================= -->
+
+
+<sect2 id="menu-settings">
+<title>The <guimenu>Settings</guimenu> Menu</title>
+
+
+<variablelist>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Ctrl;<keycap>M</keycap></keycombo></shortcut>
+<guimenu>Settings</guimenu>
+<guimenuitem>Show/Hide Menubar</guimenuitem>
+</menuchoice></term>
+<listitem><para>Show/Hide the menubar.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Settings</guimenu>
+<guimenuitem>Toolbars</guimenuitem>
+</menuchoice></term>
+<listitem><para>Opens a sub menu where you can choose to show or hide 
+the various Toolbars.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Settings</guimenu>
+<guimenuitem>Show Statusbar</guimenuitem>
+</menuchoice></term>
+<listitem><para>Show the Statusbar.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Settings</guimenu>
+<guimenuitem>Configure Shortcuts...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Configure Shortcuts...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Settings</guimenu>
+<guimenuitem>Configure Toolbar...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Configure Toolbar...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Settings</guimenu>
+<guimenuitem>Configure Notifications...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Configure Notifications...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Settings</guimenu>
+<guimenuitem>Configure Editor...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Configure Editor...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Settings</guimenu>
+<guimenuitem>Configure KDevelop...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Configure KDevelop...
+</para></listitem>
+</varlistentry>
+
+
+
+
+</variablelist>
+
+</sect2>
+
+
+<!--  =======================   H E L P   ============================= -->
+
+
+<sect2 id="menu-help">
+<title>The <guimenu>Help</guimenu> Menu</title>
+
+<variablelist>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Help</guimenu>
+<guimenuitem>KDevelop Handbook</guimenuitem>
+</menuchoice></term>
+<listitem><para>View this document.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo
+ action="simul">&Shift;<keycap>F1</keycap></keycombo></shortcut>
+<guimenu>Help</guimenu>
+<guimenuitem>What's This?</guimenuitem>
+</menuchoice></term>
+<listitem><para>Draws a question mark (?) beside the mouse
+pointer, clicking on a window item such as the
+<guiicon>Stop</guiicon> button will then display a brief explanation. 
+<!-- See
+<link linkend="bubble">Tooltips and What's This?</link>.-->
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Help</guimenu>
+<guimenuitem>Tip of the Day</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Tip of the Day
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;&Ctrl;<keycap>I</keycap></keycombo>
+</shortcut>
+<guimenu>Help</guimenu>
+<guimenuitem>Look in Documentation Index...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Look in Documentation Index...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<shortcut>
+<keycombo action="simul">&Alt;&Ctrl;<keycap>S</keycap></keycombo>
+</shortcut>
+<guimenu>Help</guimenu>
+<guimenuitem>Search in Documentation...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Search in Documentation...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Help</guimenu>
+<guimenuitem>Man Page...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Man Page...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Help</guimenu>
+<guimenuitem>Info Page...</guimenuitem>
+</menuchoice></term>
+<listitem><para>
+Info Page...
+</para></listitem>
+</varlistentry>
+
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Help</guimenu>
+<guimenuitem>Report Bug...</guimenuitem>
+</menuchoice></term>
+<listitem><para>Report bug.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Help</guimenu>
+<guimenuitem>About KDevelop...</guimenuitem>
+</menuchoice></term>
+<listitem><para>Display some brief information about
+KDevelop's version number, authors and license agreement.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><menuchoice>
+<guimenu>Help</guimenu>
+<guimenuitem>About KDE...</guimenuitem>
+</menuchoice></term>
+<listitem><para>Show some information about the version of &kde; that
+you are running.</para></listitem>
+</varlistentry>
+
+</variablelist>
+
+</sect2>
+
+
+
+</sect1>
+
+
+
+
+</chapter>
diff --git a/doc/kdevelop/configure-adddialog-baselibs.png b/doc/kdevelop/configure-adddialog-baselibs.png
new file mode 100644
index 00000000..6d97097c
--- /dev/null
+++ b/doc/kdevelop/configure-adddialog-baselibs.png
diff --git a/doc/kdevelop/configure-adddialog-qt.png b/doc/kdevelop/configure-adddialog-qt.png
new file mode 100644
index 00000000..3138d416
--- /dev/null
+++ b/doc/kdevelop/configure-adddialog-qt.png
diff --git a/doc/kdevelop/configure-adddialog.png b/doc/kdevelop/configure-adddialog.png
new file mode 100644
index 00000000..6ebd62d5
--- /dev/null
+++ b/doc/kdevelop/configure-adddialog.png
diff --git a/doc/kdevelop/configure-doctree-DevHelp.png b/doc/kdevelop/configure-doctree-DevHelp.png
new file mode 100644
index 00000000..0cf26aeb
--- /dev/null
+++ b/doc/kdevelop/configure-doctree-DevHelp.png
diff --git a/doc/kdevelop/configure-doctree-TOC.png b/doc/kdevelop/configure-doctree-TOC.png
new file mode 100644
index 00000000..cec94cd6
--- /dev/null
+++ b/doc/kdevelop/configure-doctree-TOC.png
diff --git a/doc/kdevelop/configure-doctree-bookmark.png b/doc/kdevelop/configure-doctree-bookmark.png
new file mode 100644
index 00000000..152ee605
--- /dev/null
+++ b/doc/kdevelop/configure-doctree-bookmark.png
diff --git a/doc/kdevelop/configure-doctree-general.png b/doc/kdevelop/configure-doctree-general.png
new file mode 100644
index 00000000..abf8be8c
--- /dev/null
+++ b/doc/kdevelop/configure-doctree-general.png
diff --git a/doc/kdevelop/configure-doctree-textsearch.png b/doc/kdevelop/configure-doctree-textsearch.png
new file mode 100644
index 00000000..680f5137
--- /dev/null
+++ b/doc/kdevelop/configure-doctree-textsearch.png
diff --git a/doc/kdevelop/configure-docu-chm.png b/doc/kdevelop/configure-docu-chm.png
new file mode 100644
index 00000000..6456580a
--- /dev/null
+++ b/doc/kdevelop/configure-docu-chm.png
diff --git a/doc/kdevelop/configure-docu-custom.png b/doc/kdevelop/configure-docu-custom.png
new file mode 100644
index 00000000..25e3bb6d
--- /dev/null
+++ b/doc/kdevelop/configure-docu-custom.png
diff --git a/doc/kdevelop/configure-docu-devhelp.png b/doc/kdevelop/configure-docu-devhelp.png
new file mode 100644
index 00000000..b7db6634
--- /dev/null
+++ b/doc/kdevelop/configure-docu-devhelp.png
diff --git a/doc/kdevelop/configure-docu-dox.png b/doc/kdevelop/configure-docu-dox.png
new file mode 100644
index 00000000..916e32b8
--- /dev/null
+++ b/doc/kdevelop/configure-docu-dox.png
diff --git a/doc/kdevelop/configure-docu-edit.png b/doc/kdevelop/configure-docu-edit.png
new file mode 100644
index 00000000..bc904327
--- /dev/null
+++ b/doc/kdevelop/configure-docu-edit.png
diff --git a/doc/kdevelop/configure-docu-general.png b/doc/kdevelop/configure-docu-general.png
new file mode 100644
index 00000000..0feaef99
--- /dev/null
+++ b/doc/kdevelop/configure-docu-general.png
diff --git a/doc/kdevelop/configure-docu-indexgen.png b/doc/kdevelop/configure-docu-indexgen.png
new file mode 100644
index 00000000..4315b6c3
--- /dev/null
+++ b/doc/kdevelop/configure-docu-indexgen.png
diff --git a/doc/kdevelop/configure-docu-toc.png b/doc/kdevelop/configure-docu-toc.png
new file mode 100644
index 00000000..5f5bfb65
--- /dev/null
+++ b/doc/kdevelop/configure-docu-toc.png
diff --git a/doc/kdevelop/configure-editor.png b/doc/kdevelop/configure-editor.png
new file mode 100644
index 00000000..2e4b80fa
--- /dev/null
+++ b/doc/kdevelop/configure-editor.png
diff --git a/doc/kdevelop/configure-file-selector.png b/doc/kdevelop/configure-file-selector.png
new file mode 100644
index 00000000..7ddcb044
--- /dev/null
+++ b/doc/kdevelop/configure-file-selector.png
diff --git a/doc/kdevelop/configure-file-templates.png b/doc/kdevelop/configure-file-templates.png
new file mode 100644
index 00000000..b49fbc77
--- /dev/null
+++ b/doc/kdevelop/configure-file-templates.png
diff --git a/doc/kdevelop/configure-general.png b/doc/kdevelop/configure-general.png
new file mode 100644
index 00000000..b8c7268c
--- /dev/null
+++ b/doc/kdevelop/configure-general.png
diff --git a/doc/kdevelop/configure-project-buildconfig.png b/doc/kdevelop/configure-project-buildconfig.png
new file mode 100644
index 00000000..a0236cd8
--- /dev/null
+++ b/doc/kdevelop/configure-project-buildconfig.png
diff --git a/doc/kdevelop/configure-project-configure.png b/doc/kdevelop/configure-project-configure.png
new file mode 100644
index 00000000..c918a48b
--- /dev/null
+++ b/doc/kdevelop/configure-project-configure.png
diff --git a/doc/kdevelop/configure-project-cpp.png b/doc/kdevelop/configure-project-cpp.png
new file mode 100644
index 00000000..7d29091c
--- /dev/null
+++ b/doc/kdevelop/configure-project-cpp.png
diff --git a/doc/kdevelop/configure-project-cppoptions.png b/doc/kdevelop/configure-project-cppoptions.png
new file mode 100644
index 00000000..2f51ec88
--- /dev/null
+++ b/doc/kdevelop/configure-project-cppoptions.png
diff --git a/doc/kdevelop/configure-project-doc.png b/doc/kdevelop/configure-project-doc.png
new file mode 100644
index 00000000..05b29e6d
--- /dev/null
+++ b/doc/kdevelop/configure-project-doc.png
diff --git a/doc/kdevelop/configure-project-make.png b/doc/kdevelop/configure-project-make.png
new file mode 100644
index 00000000..17b5f426
--- /dev/null
+++ b/doc/kdevelop/configure-project-make.png
diff --git a/doc/kdevelop/configure-project-run.png b/doc/kdevelop/configure-project-run.png
new file mode 100644
index 00000000..6bbef8c6
--- /dev/null
+++ b/doc/kdevelop/configure-project-run.png
diff --git a/doc/kdevelop/configure-select.png b/doc/kdevelop/configure-select.png
new file mode 100644
index 00000000..1c272a65
--- /dev/null
+++ b/doc/kdevelop/configure-select.png
diff --git a/doc/kdevelop/configure-snippets.png b/doc/kdevelop/configure-snippets.png
new file mode 100644
index 00000000..64a2ca00
--- /dev/null
+++ b/doc/kdevelop/configure-snippets.png
diff --git a/doc/kdevelop/create-new-project-cvs.png b/doc/kdevelop/create-new-project-cvs.png
new file mode 100644
index 00000000..a4955ae5
--- /dev/null
+++ b/doc/kdevelop/create-new-project-cvs.png
diff --git a/doc/kdevelop/create-new-project.png b/doc/kdevelop/create-new-project.png
new file mode 100644
index 00000000..140d5ebb
--- /dev/null
+++ b/doc/kdevelop/create-new-project.png
diff --git a/doc/kdevelop/createnewproject.png b/doc/kdevelop/createnewproject.png
new file mode 100644
index 00000000..965a14d1
--- /dev/null
+++ b/doc/kdevelop/createnewproject.png
diff --git a/doc/kdevelop/createnewprojectoptions.png b/doc/kdevelop/createnewprojectoptions.png
new file mode 100644
index 00000000..1d515bc3
--- /dev/null
+++ b/doc/kdevelop/createnewprojectoptions.png
diff --git a/doc/kdevelop/credits.docbook b/doc/kdevelop/credits.docbook
new file mode 100644
index 00000000..77712cc4
--- /dev/null
+++ b/doc/kdevelop/credits.docbook
@@ -0,0 +1,24 @@
+<chapter id="credits">
+<title>Credits</title>
+
+<sect1 id="credits-contributions">
+<title>Contributions</title>
+
+<para>
+<itemizedlist>
+  <listitem><para>
+  The initial contents of this manual were witten by Bernd Gehrmann <email>bernd@kdevelop.org</email> and Caleb Tennis <email>caleb@aei-tech.com</email>.
+  </para></listitem>
+  <listitem><para>
+  The <link linkend="automake-manager-summary">Summary of &automanag;</link> and <link linkend="automake-manager-operation">Automake Manager Operation</link> chapters were written by Ian Wadham, <email>ianw@netspace.net.au</email>).
+  </para></listitem>
+</itemizedlist>
+</para>
+
+</sect1> <!-- credits-contributions -->
+
+<!--CREDITS_FOR_TRANSLATORS-->
+
+</chapter> <!-- credits -->
+
+<!-- ====================================================================== -->
diff --git a/doc/kdevelop/cvs.docbook b/doc/kdevelop/cvs.docbook
new file mode 100644
index 00000000..ccdce4e6
--- /dev/null
+++ b/doc/kdevelop/cvs.docbook
@@ -0,0 +1,139 @@
+<chapter id="cvs">
+<title>Using &CVS;</title>
+<indexterm zone="cvs"><primary>CVS</primary></indexterm>
+<indexterm zone="cvs"><primary>revision control</primary></indexterm>
+
+<sect1 id="cvs-basics">
+<title>&CVS; Basics</title>
+
+<para>
+&CVS; is the revision control system which many open source projects -
+including &kde; &mdash; are using. It stores all sources codes in a central place,
+called the <emphasis>repository</emphasis>.  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 <emphasis>lock</emphasis> files one wants to work on. So
+development can be highly parallelized.
+</para>
+
+<para>
+Whenever a developer has finished a task, he <emphasis>commits</emphasis> 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.
+</para>
+
+<para>
+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 (&eg; &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;
+</para>
+
+<para>
+&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; (<ulink
+url="http://cervisia.sf.net"/>) or <application>TkCVS</application> (<ulink
+url="http://tkcvs.sf.net"/>).  In &kdevelop;, only a small part of the &cvs;
+functionality which is important for your daily work can be used directly.
+</para>
+
+<para>
+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 <quote>Open Source Development With &CVS;</quote> by Karl Fogel which is freely
+distributed (except for the non-technical chapters). See
+<ulink url="http://cvsbook.red-bean.com/cvsbook.html"/>.
+</para>
+
+</sect1> <!-- cvs-basics -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="cvs-commands">
+<title>&CVS; Commands in &kdevelop;</title>
+
+<para>
+In the file views, the following context menu items are available:
+</para>
+
+<variablelist>
+<varlistentry>
+<term>Add to Repository</term>
+<listitem>
+<para>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.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Remove from Repository</term>
+<listitem>
+<para>
+Prepares a file for removal from the repository. This also deletes
+the file on the local file system, so use this feature with care!
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Update</term>
+<listitem>
+<para>
+Runs <command>cvs update</command> 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 <filename>.cvsrc</filename>.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Commit</term>
+<listitem>
+<para>
+Runs <command>cvs commit</command> 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.
+</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<para>
+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 <filename>sourceforge.net</filename>. Workarounds for this
+problem are described on the &CVS;/SSH FAQ which you can find in the
+SourceForge documentation.
+</para>
+
+</sect1> <!-- cvs-basics -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="cvs-behind">
+<title>Behind the Scenes</title>
+
+<sect2 id="cvs-behind-workdir">
+<title>What &CVS; Records in the Working Directory</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- cvs-behind-workdir -->
+
+</sect1> <!-- cvs-behind -->
+
+</chapter> <!-- cvs -->
diff --git a/doc/kdevelop/debugger.docbook b/doc/kdevelop/debugger.docbook
new file mode 100644
index 00000000..a06f2c83
--- /dev/null
+++ b/doc/kdevelop/debugger.docbook
@@ -0,0 +1,242 @@
+<chapter id="debugger">
+<title>The Debugger Interface</title>
+<indexterm zone="debugger"><primary>debugger</primary></indexterm>
+
+<para>
+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 <application>gdb</application> through
+a pipe. The debugger can be started in several ways:
+</para>
+
+<itemizedlist>
+<listitem>
+<para>
+With <menuchoice><guimenu>Debug</guimenu><guimenuitem>Start</guimenuitem></menuchoice>,
+the main program of your project is loaded into the debugger.
+</para>
+</listitem>
+
+<listitem>
+<para>
+Using <menuchoice><guimenu>Debug</guimenu>
+<guimenuitem>Start (other)</guimenuitem>
+<guimenuitem>Examine core file</guimenuitem></menuchoice> 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 <application>ulimit(1)</application>). This is useful for a
+post-mortem analysis of a program.
+</para>
+</listitem>
+
+<listitem>
+<para>
+With <menuchoice><guimenu>Debug</guimenu>
+<guimenuitem>Start (other)</guimenuitem>
+<guimenuitem>Attach to process</guimenuitem></menuchoice> 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.
+</para>
+</listitem>
+
+<listitem>
+<para>
+Note that debugging is only possible if your project has been compiled with
+debugging information enabled. It can be activated in the
+<guibutton>Compiler options</guibutton> 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.
+</para>
+</listitem>
+</itemizedlist>
+
+<para>
+The debugger frontend offers several views <quote>into</quote> the process:
+</para>
+
+<para>If you try to debug a project without debugging information, you get
+the message <computeroutput>No source...</computeroutput> in the status
+bar.If you try to set a breakpoint, it is shown as <computeroutput>Pending
+(add)</computeroutput> in the breakpoint window (see below).
+</para>
+
+<variablelist>
+<varlistentry>
+<term>Variables</term>
+<listitem>
+<indexterm zone="debugger"><primary>watch variables</primary></indexterm>
+<para>
+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 <function>main()</function> function.
+</para>
+
+<para>
+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
+<guibutton>Add</guibutton> button or pressing <keycap>Return</keycap> while
+the <guilabel>Watch</guilabel> item is selected. They can be removed again
+via the context menu.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Frame Stack</term>
+<listitem>
+<indexterm zone="debugger"><primary>frame stack</primary></indexterm>
+<para>
+(... to be written ...)
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Breakpoints</term>
+<listitem>
+<indexterm zone="debugger"><primary>breakpoints</primary></indexterm>
+<para>
+This window allows you to see and manipulate the breakpoints.  Remember that
+&kdevelop; uses <application>GDB</application>, so to fully understand the
+&kdevelop; debugging features, you should know a little bit about the <ulink
+url="http://www.gnu.org/software/gdb">GDB</ulink>.
+</para>
+
+<para>If you want to look at the source code, breakpoints are defined in
+<filename>kdevelop/languages/cpp/debugger/breakpoint.h</filename>.
+</para>
+
+<para>At the left edge, the window has buttons to:</para>
+
+<itemizedlist>
+<listitem><para>Add an empty breakpoint</para></listitem>
+<listitem><para>Edit the selected breakpoint</para></listitem>
+ <listitem><para>Delete the selected breakpoint</para></listitem>
+<listitem><para>Remove all breakpoints</para></listitem>
+</itemizedlist>
+
+<para>The main part of the window is a table with 7 columns.  Each line in
+the table is a breakpoint.  The columns are:</para>
+
+<orderedlist>
+<listitem><para>Selection checkbox</para></listitem>
+<listitem><para>Type: one of: Invalid, File:Line, Watchpoint, Address, Function</para></listitem>
+<listitem><para>Status. Values are:</para>
+<itemizedlist>
+  <listitem><para>Active</para></listitem>
+  <listitem><para>Disabled: Each breakpoint may be <quote>enabled</quote> or
+  <quote>disabled</quote>; if disabled, it has no effect on your program until
+  you enable it again.</para></listitem>
+  <listitem><para>Pending (add): a breakpoint is marked like this if no
+  debugging information is available. From GDB Info page:
+  <blockquote><para>If a specified breakpoint location cannot be found, it may be due to
+  the fact that the location is in a shared library that is yet to be
+  loaded.  In such a case, you may want GDB to create a special
+  breakpoint (known as a <quote>pending breakpoint</quote>) that attempts to resolve
+  itself in the future when an appropriate shared library gets loaded.</para>
+  </blockquote>
+  </para></listitem>
+</itemizedlist>
+</listitem>
+<listitem><para>Pending (clear)</para></listitem>
+<listitem><para>Pending (modify)</para></listitem>
+<listitem><para>Location in the format filename:linenumber</para></listitem>
+<listitem><para>Condition</para></listitem>
+<listitem><para>Ignore Count: If this is a number <varname>COUNT</varname>
+greater than zero, the next <varname>COUNT</varname> times the breakpoint is
+reached, your program's execution does not stop; other than to decrement the
+ignore count, <application>gdb</application> takes no action.</para></listitem>
+<listitem><para>Hits: counts how many times a breakopint has been hit.</para></listitem>
+</orderedlist>
+
+
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Disassemble</term>
+<listitem>
+<indexterm zone="debugger"><primary>disassemble</primary></indexterm>
+<para>(... to be written ...)</para>
+
+</listitem>
+</varlistentry>
+</variablelist>
+
+
+<sect1 id="settingbreakpoints">
+<title>Setting Breakpoints</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect1> <!-- settingbreakpoints -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id ="debuggeroptions">
+<title>Options</title>
+
+<variablelist>
+<varlistentry>
+<term>Display Mangled Names</term>
+<listitem>
+<indexterm zone="debugger"><primary>name mangling</primary></indexterm>
+<indexterm zone="debugger"><primary>mangling</primary><secondary>name</secondary></indexterm>
+
+<para>
+In C++, function names in the executable are <quote>mangled</quote>, &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.
+</para>
+
+<para>
+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.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Try Setting Breakpoints on Lib Load</term>
+<listitem>
+<indexterm zone="debugger"><primary>lazy breakpoints</primary></indexterm>
+<indexterm zone="debugger"><primary>breakpoints</primary><secondary>lazy</secondary></indexterm>
+
+<para>
+The debugger backend <application>gdb</application> 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 <function>dlopen(3)</function>), 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 <application>gdb</application>
+notifies that a library is loaded, &kdevelop; tries to set the pending
+breakpoints.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Enable Floating Toolbar</term>
+<listitem>
+<indexterm zone="debugger"><primary>debugger toolbar</primary></indexterm>
+<indexterm zone="debugger"><primary>toolbar</primary><secondary>debugger</secondary></indexterm>
+
+<para>
+(... to be written ...)
+</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+</sect1> <!-- debuggeroptions -->
+
+</chapter> <!-- debugger -->
diff --git a/doc/kdevelop/doctree-add-bookmark.png b/doc/kdevelop/doctree-add-bookmark.png
new file mode 100644
index 00000000..090c93f9
--- /dev/null
+++ b/doc/kdevelop/doctree-add-bookmark.png
diff --git a/doc/kdevelop/doctree-reduced.png b/doc/kdevelop/doctree-reduced.png
new file mode 100644
index 00000000..30c22e79
--- /dev/null
+++ b/doc/kdevelop/doctree-reduced.png
diff --git a/doc/kdevelop/doctree.png b/doc/kdevelop/doctree.png
new file mode 100644
index 00000000..26264828
--- /dev/null
+++ b/doc/kdevelop/doctree.png
diff --git a/doc/kdevelop/doctreeview.png b/doc/kdevelop/doctreeview.png
new file mode 100644
index 00000000..64031238
--- /dev/null
+++ b/doc/kdevelop/doctreeview.png
diff --git a/doc/kdevelop/documentation.docbook b/doc/kdevelop/documentation.docbook
new file mode 100644
index 00000000..eed065b0
--- /dev/null
+++ b/doc/kdevelop/documentation.docbook
@@ -0,0 +1,57 @@
+<chapter id="documentation">
+<title>Documentation</title>
+
+<para>
+Documention unfortunately belongs to the most-overlooked programming
+issues. Yet, once properly set up and maintained internal and external
+documentation provides most valuable help.
+</para>
+
+<para>
+Documentation has multiple facets. There is
+<itemizedlist>
+  <listitem><para>
+  <emphasis>project internal documentation</emphasis>, mainly consisting of
+  <itemizedlist>
+    <listitem><para>
+    <emphasis>comments</emphasis> in header/source files
+    </para></listitem>
+    <listitem><para>
+    <emphasis>internal &API; documentation</emphasis> of your project
+    generated from the program file by special tools, &eg; &doxygen;
+    </para></listitem>
+  </itemizedlist>
+  </para></listitem>
+  <listitem><para>
+  <emphasis>project external documentation</emphasis>, comprising among others
+  <itemizedlist>
+    <listitem><para>
+    <emphasis>external &API; documentation</emphasis> of &eg; common system libraries (&kde;, &Qt;, &etc;)
+    </para></listitem>
+    <listitem><para>
+    any other documentation (programming language manuals, general system information, how-to articles and the like)
+    </para></listitem>
+  </itemizedlist>
+  </para></listitem>
+</itemizedlist>
+</para>
+<para>
+All this documentation should be easily maintainable and ready at hand whenever you need it. &kdevelop; has provisions for just this.
+</para>
+
+<!-- ### doc browser, notes on internal documentation, how to profit from Doxygen -->
+
+<sect1 id="docbrowser">
+<title>The Documentation Browser</title>
+
+
+<figure id="screenshot-doctreeview" float="1">
+<title>A Screenshot of the Documentation Tree</title>
+<mediaobject>
+<imageobject><imagedata fileref="doctreeview.png"/></imageobject>
+</mediaobject>
+</figure>
+
+</sect1> <!-- docbrowser -->
+
+</chapter> <!-- documentation -->
diff --git a/doc/kdevelop/documents-contents.png b/doc/kdevelop/documents-contents.png
new file mode 100644
index 00000000..9adb1699
--- /dev/null
+++ b/doc/kdevelop/documents-contents.png
diff --git a/doc/kdevelop/documents-search.png b/doc/kdevelop/documents-search.png
new file mode 100644
index 00000000..f1e23048
--- /dev/null
+++ b/doc/kdevelop/documents-search.png
diff --git a/doc/kdevelop/edit-doctree-TOC-entry.png b/doc/kdevelop/edit-doctree-TOC-entry.png
new file mode 100644
index 00000000..f0d56685
--- /dev/null
+++ b/doc/kdevelop/edit-doctree-TOC-entry.png
diff --git a/doc/kdevelop/editing.docbook b/doc/kdevelop/editing.docbook
new file mode 100644
index 00000000..54074bdb
--- /dev/null
+++ b/doc/kdevelop/editing.docbook
@@ -0,0 +1,401 @@
+<chapter id="editing">
+<title>Editing Tools</title>
+
+<sect1 id="editing-snippets">
+<title>Code Snippets</title>
+
+<itemizedlist>
+  <title>Features (preliminary overview)</title>
+  <listitem><para>
+  SnippetPart adds a tool-view which by default docks to the right
+  </para></listitem>
+  <listitem><para>
+  Adding, editing and removing of snippets is available via a popup-menu
+  </para></listitem>
+  <listitem><para>
+  Double-clicking a snippet form the list inserts it into to the active view at the current cursor position
+  </para></listitem>
+  <listitem><para>
+  Tool tips show the content of a snippet
+  </para></listitem>
+  <listitem><para>
+  Snippets are stored in the users home-directory, so every user can have his own snippets
+  </para></listitem>
+  <listitem><para>
+  Snippets can contain variables in the style of $<varname>VARNAME</varname>$. On using the snippet the user is prompted to enter replacement value for the variables
+  </para></listitem>
+</itemizedlist>
+</sect1> <!-- editing-snippets -->
+
+<sect1 id="keyboardmapping">
+<title>Keyboard Mapping</title>
+<indexterm zone="keyboardmapping"><primary>keybindings</primary></indexterm>
+
+<para>
+In the following, we will list the default keybindings of the
+default editor. You can configure them as you like (how?)
+</para>
+
+<informaltable>
+<tgroup cols="2">
+<tbody>
+
+<row><entry><para><keycap>
+  Left
+</keycap></para></entry>
+<entry><para>
+  Moves one character left
+</para></entry></row>
+
+<row><entry><para><keycap>
+  Right
+</keycap></para></entry>
+<entry><para>
+  Moves one character right
+</para></entry></row>
+
+<row><entry><para><keycombo>
+&Ctrl;<keycap>
+  Left
+</keycap></keycombo></para></entry>
+<entry><para>
+  Moves one word left
+</para></entry></row>
+
+<row><entry><para><keycombo>
+&Ctrl;<keycap>
+  Right
+</keycap></keycombo></para></entry>
+<entry><para>
+  Moves one word right
+</para></entry></row>
+
+<row><entry><para><keycap>
+  Up
+</keycap></para></entry>
+<entry><para>
+  Moves up one line
+</para></entry></row>
+
+<row><entry><para><keycap>
+  Down
+</keycap></para></entry>
+<entry><para>
+  Moves down one line
+</para></entry></row>
+
+<row><entry><para><keycap>
+  Page Up
+</keycap></para></entry>
+<entry><para>
+  Moves up one page
+</para></entry></row>
+
+<row><entry><para><keycap>
+    Page Down
+</keycap></para></entry>
+<entry><para>
+  Moves down one page
+</para></entry></row>
+
+<row><entry><para><keycombo>&Ctrl;<keycap>
+  Page Down
+</keycap></keycombo></para></entry>
+<entry><para>
+  Moves to the beginning of the file
+</para></entry></row>
+
+<row><entry><para><keycombo>&Ctrl;
+<keycap>
+  Page Down
+</keycap></keycombo></para></entry>
+<entry><para>
+  Moves to the end of the file
+</para></entry></row>
+
+<row><entry><para><keycap>
+    Home
+</keycap></para></entry>
+<entry><para>
+  Moves to the beginning of the line
+</para></entry></row>
+
+<row><entry><para><keycap>
+    End
+</keycap></para></entry>
+<entry><para>
+  Moves to the end of the line
+</para></entry></row>
+
+</tbody>
+</tgroup>
+</informaltable>
+
+<para>
+For all the keys above, the &Shift; key can be pressed additionally,
+to mark from the current cursor position to the one afterwards.
+</para>
+
+<informaltable>
+<tgroup cols="2">
+<tbody>
+
+<row><entry><para><keycap>
+  Backspace
+</keycap></para></entry>
+<entry><para>
+  Deletes one character left
+</para></entry></row>
+
+<row><entry><para><keycap>
+  Delete
+</keycap></para></entry>
+<entry><para>
+  Deletes the character under the cursor
+</para></entry></row>
+
+<row><entry><para><keycombo>
+&Ctrl;
+<keycap>
+  C
+</keycap></keycombo></para></entry>
+<entry><para>
+  Copies the selected text to the clipboard
+</para></entry></row>
+
+<row><entry><para><keycombo>&Ctrl;<keycap>
+  V
+</keycap></keycombo></para></entry>
+<entry><para>
+  Pastes the selected text from the clipboard
+</para></entry></row>
+
+<row><entry><para><keycombo>&Ctrl;<keycap>
+  X
+</keycap></keycombo></para></entry>
+<entry><para>
+  Deletes the selected text and puts it into the clipboard
+</para></entry></row>
+
+<row><entry><para><keycombo>&Ctrl;<keycap>
+  Z
+</keycap></keycombo></para></entry>
+<entry><para>
+  Undo
+</para></entry></row>
+
+<row><entry><para><keycombo>&Shift;&Ctrl;<keycap>
+  Z
+</keycap></keycombo></para></entry>
+<entry><para>
+Redo
+</para></entry></row>
+
+</tbody>
+</tgroup>
+</informaltable>
+
+</sect1> <!-- keyboardmapping -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="editing-reporter">
+<title>The Problem Reporter</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect1> <!-- editing-reporter -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="searchinggrepping">
+<title>Searching and Grepping</title>
+<indexterm zone="searchinggrepping"><primary>searching</primary></indexterm>
+<indexterm zone="searchinggrepping"><primary>finding</primary></indexterm>
+
+<sect2 id="searching">
+<title>Searching for Text</title>
+
+<para>
+<keycombo>&Ctrl;<keycap>F</keycap></keycombo>- Find
+<keycombo>&Ctrl;<keycap>R</keycap></keycombo>- Replace
+</para>
+
+</sect2> <!-- searching -->
+
+
+<sect2 id="isearch">
+<title>ISearch</title>
+<indexterm zone="isearch"><primary>isearch</primary></indexterm>
+<indexterm zone="isearch"><primary>incremental search</primary></indexterm>
+<indexterm zone="isearch"><primary>search</primary><secondary>incremental</secondary></indexterm>
+
+<para>
+The conventional search with <menuchoice><guimenu>Edit</guimenu>
+<guimenuitem>Find</guimenuitem></menuchoice> 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
+<guilabel>ISearch</guilabel> 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.
+</para>
+
+</sect2> <!-- isearch -->
+
+
+<sect2 id="grep">
+<title>Grep</title>
+<indexterm zone="grep"><primary>search</primary><secondary>in files</secondary></indexterm>
+
+<para>
+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
+<guimenuitem>Search in Files...</guimenuitem> item in the
+<guimenu>Edit</guimenu> menu. It is basically a frontend for the
+&grep;(1) program.
+</para>
+
+<para>
+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
+<guibutton>Recursive</guibutton> box, the search iterates through all
+directories in the hierarchy below this one.
+</para>
+
+<para>
+The search term is in general a regular expression following POSIX syntax.
+For example, you can use the term <literal>"\&lt;K.*"</literal> if you want to
+find all words which begin with the letter K. The following characters
+are interpreted in a special way:
+</para>
+
+<informaltable>
+<tgroup cols="2">
+<tbody>
+
+<row><entry>
+  <literal>.</literal>
+</entry><entry>
+  Matches any character
+</entry></row>
+<row><entry>
+  <literal>^</literal>
+</entry><entry>
+Matches the beginning of a line
+</entry></row>
+<row><entry>
+  <literal>$</literal>
+</entry><entry>
+  Matches the end of a line
+</entry></row>
+<row><entry>
+  <literal>\&lt;</literal>
+</entry><entry>
+  Matches the beginning of a word
+</entry></row>
+<row><entry>
+  <literal>\&gt;</literal>
+</entry><entry>
+  Matches the end of a word
+</entry></row>
+<row><entry>
+  <literal>?</literal>
+</entry><entry>
+  The preceding item matches less than once
+</entry></row>
+<row><entry>
+  <literal>*</literal>
+</entry><entry>
+  The preceding item is matched zero or more times
+</entry></row>
+<row><entry>
+  <literal>+</literal>
+</entry><entry>
+  The preceding item is matched once or more times
+</entry></row>
+<row><entry>
+  <literal>{n}</literal>
+</entry><entry>
+  The preceding item is matched exactly n times
+</entry></row>
+<row><entry>
+  <literal>{n,}</literal>
+</entry><entry>
+  The preceding item is matched n or more times
+</entry></row>
+<row><entry>
+  <literal>{,n}</literal>
+</entry><entry>
+  The preceding item matches less than n times
+</entry></row>
+<row><entry>
+  <literal>{n,m}</literal>
+</entry><entry>
+  The preceding item matches at least <literal>n</literal> times but less
+than <literal>m</literal> times
+</entry></row>
+
+</tbody>
+</tgroup>
+</informaltable>
+
+<para>
+Backreferences to bracketed subexpressions are also available by the notation
+<literal>\n</literal>.
+</para>
+
+<para>
+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.
+</para>
+
+<para>
+Once you start the search by clicking on the <guibutton>Search</guibutton>
+button, it will be performed by an external, asynchronous process. All found
+items will appear in the view called <guilabel>Grep</guilabel>. 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.
+</para>
+
+</sect2> <!-- grep -->
+
+</sect1> <!-- searchinggrepping -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="code-completion">
+<title>Code Completion</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect1> <!-- code-completion -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="newfiles">
+<title>Creating New Files and Classes</title>
+
+<para>
+(... to be written ...)
+</para>
+
+<sect2 id="newfiles-edittemplates">
+<title>Editing the Templates</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- newfiles-edittemplates -->
+
+</sect1> <!-- newfiles -->
+
+</chapter> <!-- editing -->
+<!-- ====================================================================== -->
diff --git a/doc/kdevelop/editor-ctags-lookup.png b/doc/kdevelop/editor-ctags-lookup.png
new file mode 100644
index 00000000..f07a1348
--- /dev/null
+++ b/doc/kdevelop/editor-ctags-lookup.png
diff --git a/doc/kdevelop/editor-ctags-menu.png b/doc/kdevelop/editor-ctags-menu.png
new file mode 100644
index 00000000..b128b69b
--- /dev/null
+++ b/doc/kdevelop/editor-ctags-menu.png
diff --git a/doc/kdevelop/editor-ctags-regenerate.png b/doc/kdevelop/editor-ctags-regenerate.png
new file mode 100644
index 00000000..b29cb352
--- /dev/null
+++ b/doc/kdevelop/editor-ctags-regenerate.png
diff --git a/doc/kdevelop/editor-find-menu.png b/doc/kdevelop/editor-find-menu.png
new file mode 100644
index 00000000..e71c6d00
--- /dev/null
+++ b/doc/kdevelop/editor-find-menu.png
diff --git a/doc/kdevelop/editor-search-doc.png b/doc/kdevelop/editor-search-doc.png
new file mode 100644
index 00000000..ad91da28
--- /dev/null
+++ b/doc/kdevelop/editor-search-doc.png
diff --git a/doc/kdevelop/editor-switch-header.png b/doc/kdevelop/editor-switch-header.png
new file mode 100644
index 00000000..76d95c29
--- /dev/null
+++ b/doc/kdevelop/editor-switch-header.png
diff --git a/doc/kdevelop/empty-ide.png b/doc/kdevelop/empty-ide.png
new file mode 100644
index 00000000..3cf19981
--- /dev/null
+++ b/doc/kdevelop/empty-ide.png
diff --git a/doc/kdevelop/file-browsers.docbook b/doc/kdevelop/file-browsers.docbook
new file mode 100644
index 00000000..f8b37735
--- /dev/null
+++ b/doc/kdevelop/file-browsers.docbook
@@ -0,0 +1,79 @@
+<chapter id="file-browsers">
+<title>The File Browsers</title>
+
+<para>
+On the left side of the main window, &kdevelop; can display various kinds of
+lists and trees for the selection of files:
+</para>
+
+<variablelist>
+<varlistentry>
+<term>File Tree</term>
+<listitem>
+<para>
+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.
+</para>
+
+<para>
+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.
+</para>
+
+<para>
+The file tree hides files which are usually not interesting, like object
+files. In the <guimenuitem>Project options</guimenuitem> under
+<guibutton>File views</guibutton>, you can configure (as a comma separated
+list of wildcards) which patterns are used to filter out irrelevant files.
+</para>
+
+<para>
+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.
+</para>
+
+<figure id="screenshot-filetree" float="1">
+<title>A Screenshot of the File Tree</title>
+<mediaobject>
+<imageobject><imagedata fileref="filetree.png"/></imageobject>
+<textobject><phrase>A Screenshot of the File Tree</phrase></textobject>
+</mediaobject>
+</figure>
+
+</listitem>
+</varlistentry>
+<varlistentry>
+<term>File Groups</term>
+<listitem>
+<para>
+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 &LMB;.
+</para>
+
+<para>
+The groups shown in this view can be configured under
+<guibutton>File views</guibutton> in the
+<guimenuitem>Project options</guimenuitem> 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
+<guilabel>Other</guilabel> group should  be the last pattern.
+</para>
+
+</listitem>
+</varlistentry>
+</variablelist>
+
+</chapter> <!-- file-browsers -->
+
+<!-- ====================================================================== -->
diff --git a/doc/kdevelop/file-list-close-selected.png b/doc/kdevelop/file-list-close-selected.png
new file mode 100644
index 00000000..18ff8b9b
--- /dev/null
+++ b/doc/kdevelop/file-list-close-selected.png
diff --git a/doc/kdevelop/file-list-session-create.png b/doc/kdevelop/file-list-session-create.png
new file mode 100644
index 00000000..a80fa37c
--- /dev/null
+++ b/doc/kdevelop/file-list-session-create.png
diff --git a/doc/kdevelop/file-list-session-default.png b/doc/kdevelop/file-list-session-default.png
new file mode 100644
index 00000000..1eaf565c
--- /dev/null
+++ b/doc/kdevelop/file-list-session-default.png
diff --git a/doc/kdevelop/file-selector.png b/doc/kdevelop/file-selector.png
new file mode 100644
index 00000000..8a357851
--- /dev/null
+++ b/doc/kdevelop/file-selector.png
diff --git a/doc/kdevelop/filetree.png b/doc/kdevelop/filetree.png
new file mode 100644
index 00000000..1e731402
--- /dev/null
+++ b/doc/kdevelop/filetree.png
diff --git a/doc/kdevelop/find-in-files.png b/doc/kdevelop/find-in-files.png
new file mode 100644
index 00000000..17dae505
--- /dev/null
+++ b/doc/kdevelop/find-in-files.png
diff --git a/doc/kdevelop/folded-tabs.png b/doc/kdevelop/folded-tabs.png
new file mode 100644
index 00000000..1218421f
--- /dev/null
+++ b/doc/kdevelop/folded-tabs.png
diff --git a/doc/kdevelop/getting-started.docbook b/doc/kdevelop/getting-started.docbook
new file mode 100644
index 00000000..11a08253
--- /dev/null
+++ b/doc/kdevelop/getting-started.docbook
@@ -0,0 +1,3221 @@
+
+<!--
+Please keep the formatting simple.
+Do not indent XML constructs.
+Keep lines at 80 characters length maximum.
+-->
+
+<chapter id="getting-started">
+
+<chapterinfo>
+<authorgroup>
+<author><firstname>Bernd</firstname><surname>Pol</surname></author>
+<!-- TRANS:ROLES_OF_TRANSLATORS -->
+</authorgroup>
+</chapterinfo>
+
+<title>Getting Started with &kdevelop; &mdash; a Guided Tour</title>
+
+<para>Now that you have got your new &kdevelop; &IDE;, how are you going to make
+good use of it? As this is a complex application, the learning curve may be
+somewhat steep, especially if you are not already used to this type of an
+Integrated Development Environment.</para>
+
+<para>We will try to soften this learning curve a bit by stepping through the
+makings of a simple KDE C++ application. Thereby we will have a (cursory) look
+at:</para>
+
+<simplelist>
+<member><link linkend="gettingstarted-overview">A first look &mdash; the user
+interface elements of the &kdevelop; &IDE;.</link></member>
+<member><link linkend="gettingstarted-configure">Doing some initial
+configuration.</link></member>
+<member><link linkend="gettingstarted-new">How to create a new project.</link>
+</member>
+<member><link linkend="gettingstarted-edit">Some tips about dealing with
+documents.</link></member>
+<member><link linkend="gettingstarted-compile">How to compile the application in
+this project.</link></member>
+<member><link linkend="gettingstarted-extend">How to add classes and other
+detail to your project.</link></member>
+<member><link linkend="gettingstarted-debug">What to do to debug the
+application.</link></member>
+<member><link linkend="gettingstarted-doc">Some basic tools to build program or
+user documentation.</link></member>
+<member><link linkend="gettingstarted-keys">Last but not least, keyboard
+shortcuts</link></member>
+</simplelist>
+
+<para>Before we start, one important concept should be made clear.</para>
+
+<formalpara>
+<title>What to expect?</title>
+<para>As said, &kdevelop; is an <emphasis>Integrated Development
+Environment</emphasis>. That means in essence that &kdevelop; is no development
+tool by itself but rather a graphical front end to easily access a wide range of
+development tools, many of which actually would require complex keyboard
+commands run from a text console.</para>
+</formalpara>
+
+<para>While &kdevelop; eases many of those programming tasks, much of the
+complexity from this bundle of tools still remains which means that in order to
+fully understand the &kdevelop; &IDE; you will still need to comprehend these
+tools actually running beneath the surface.</para>
+
+<para>Hence, we cannot teach you how to build software, but rather introduce you
+to some of the ways &kdevelop; was designed to ease such a software building
+process. If you want to learn more about what an Integrated Development
+Environment is meant for, you might want to have a look at the <link
+linkend="unixdev">Development on &UNIX;</link> historical overview and there
+especially at the <link linkend="unixdev-ide">Integrating Concepts and
+Tools</link> chapter.</para>
+
+<note>
+<para>The following discussions apply to the default case, where &kdevelop;
+starts up in the <guilabel>Simplified IDEAl Window Mode</guilabel>. If you
+already did switch to another user interface mode some items may not be there as
+described or will behave slightly different. If in doubt which user interface
+mode your &kdevelop; currently uses, check with the
+<menuchoice><guimenu>Settings</guimenu> <guimenuitem>Configure
+KDevelop...</guimenuitem> <guimenuitem>User Interface</guimenuitem></menuchoice>
+dialog.</para>
+</note>
+
+<sect1 id="gettingstarted-overview">
+<title>A Very First Look at &kdevelop;</title>
+
+<para>This is all about what you will see when you first started &kdevelop;.
+You will find preliminary information about:</para>
+
+<simplelist>
+<member><link linkend="gettingstarted-overview-basic">What is there on the
+surface?</link></member>
+<member><link linkend="gettingstarted-overview-help">How to get some
+help.</link></member>
+<member><link linkend="gettingstarted-overview-menu">What is in the
+menus?</link></member>
+<member><link linkend="gettingstarted-overview-tools">What are those tool views
+for?</link></member>
+</simplelist>
+
+<sect2 id="gettingstarted-overview-basic">
+<title>On the Surface</title>
+
+<para>When you start &kdevelop; for the first time you will get a display
+similar to this one:</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="empty-ide.png" format="PNG"/>
+</imageobject>
+<caption>
+<para>The &kdevelop; initial layout</para>
+<para>(Actually the initial &kdevelop; window will be larger, but the elements
+you see are the same.)</para>
+</caption>
+</mediaobject>
+</screenshot>
+
+<formalpara>
+<title>Workspace Area and Tool View Tabs</title>
+<para>In this initial case &kdevelop; uses the so-called <link
+linkend="uimodes-survey">IDEAl user interface mode</link>. A workspace area of
+maximum possible size is surrounded left, bottom, and right by a series of
+buttons which act similar to tabs on a tabbed display. If you click on one of
+those tabs, a so-called <emphasis>tool view window</emphasis> will open which
+allows you to work on a specific task.</para>
+</formalpara>
+
+<formalpara>
+<title>Menu and Toolbars</title>
+<para>On top there is the usual menubar, followed by several rows of toolbars,
+some being initially empty. They will get populated once there is a project open
+for actual work.</para>
+</formalpara>
+
+<formalpara>
+<title>Status Bar</title>
+<para>Finally, there is a status bar on the bottom of the window where short
+informations on several tasks will be shown.</para>
+</formalpara>
+</sect2>
+
+<sect2 id="gettingstarted-overview-help">
+<title>How to Get Some Help</title>
+
+<para>Besides the <guimenu>Help</guimenu> menu which offers answers to specific
+questions, the status bar and two kinds of tool tips provide some quick
+information.</para>
+
+<formalpara>
+<title>What Does This Menu Entry Do?</title>
+<para>When you place the mouse cursor on a menu entry, there will usually some
+short information be displayed in the status bar. While in most cases this
+repeats just the name of the selection, in some cases it will provide additional
+information about the purpose of the menu command.</para>
+</formalpara>
+
+<formalpara>
+<title>What Is the Name of This Item?</title>
+<para>On many items a short function name tool tip will pop up when you place
+the cursor on it for a few seconds. This is useful for quick orientation on
+toolbar or tool view tabs in IDEAl mode when the &IDE; has been set up to
+display icons only on these buttons.</para>
+</formalpara>
+
+<formalpara>
+<title>What Does This Item Do?</title>
+<para>More information is available through expanded tool tip help for many
+items on the &IDE;. Select <menuchoice><guimenu>Help</guimenu>
+<guimenuitem>What&apos;s This?</guimenuitem></menuchoice> or press
+<keycombo><keycap>&Shift;</keycap><keycap>F1</keycap></keycombo>, then with the
+question mark cursor select the item you want to know more of. You can as well
+open any menu this way and click on a specific menu entry (active as well as
+greyed disabled ones) to see if more information is available.</para>
+</formalpara>
+</sect2>
+
+<sect2 id="gettingstarted-overview-menu">
+<title>What is in the menus?</title>
+
+<para>There are ten menus selectable on the menubar. Most of them get fully
+populated once a project is open for actual work while others require at least
+one document be open in an editor window. In short, they will allow the
+following action types.</para>
+
+<note>
+<para>This is only a preliminary overview. For a detailed menu description see
+the <link linkend="commands">Command Reference</link>.</para>
+</note>
+
+<variablelist>
+<varlistentry>
+<term><guimenu>File</guimenu></term>
+<listitem>
+<formalpara>
+<title>Usual Actions</title>
+<para>This is pretty standard. It allows to create, open, save, print, and close
+document files as well as quitting the &kdevelop; application as usual.</para>
+</formalpara>
+
+<formalpara>
+<title>Revert All</title>
+<para>This allows to revert all recent, yet unsaved changes by reloading the
+file from the disk. This works on any file you edit, not only on those which are
+part of a project.</para>
+</formalpara>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>Edit</guimenu></term>
+<listitem>
+<para>This menu is useful only if a document is opened.</para>
+
+<formalpara>
+<title>Usual Actions</title>
+<para>It provides the usual undo/redo and cut/copy/paste actions.
+Furthermore it allows to select text blocks in various ways.</para>
+</formalpara>
+
+<formalpara>
+<title>Search and Replace</title>
+<para>There are two very powerful search facility available,
+<menuchoice><guimenu>Edit</guimenu> <guimenuitem>Find in
+Files...</guimenuitem></menuchoice>, and <menuchoice><guimenu>Edit</guimenu>
+<guimenuitem>Find-Select-Replace...</guimenuitem></menuchoice>. These allow, in
+addition to the usual search and replace actions limited to the the current
+document, to conduct global search or search-and-replace actions in one single
+turn.</para>
+</formalpara>
+
+<formalpara>
+<title>Advanced Text Edit</title>
+<para>There are provisions to reformat the current document and to automatically
+complete partially typed texts in various ways.</para>
+</formalpara>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>View</guimenu></term>
+<listitem>
+<para>Like the <guimenu>Edit</guimenu> menu, this menu is useful only if there
+is an open project. I this case there will be the following actions available
+(amongst others):</para>
+
+<formalpara>
+<title>Navigation History</title>
+<para>Switch back and forth through the documents &etc; you visited.</para>
+</formalpara>
+
+<formalpara>
+<title>Error Tracking</title>
+<para>Navigate to the source lines of the errors encountered in the most recent
+compilation/build process.</para>
+</formalpara>
+
+<formalpara>
+<title>Editor Related Actions</title>
+<para>Some entries in the <guimenu>View</guimenu> menu control the look and view
+of the editor you use. In case of the &kate; Part (Embedded Advanced Text
+Editor) there will be the following controls available:</para>
+</formalpara>
+
+<itemizedlist>
+<listitem>
+<para>Control the word wrap behavior in the document window.</para>
+</listitem>
+<listitem>
+<para>Show or hide several border displays in the document windows: line
+numbers, icons, and, additionally, bookmark marks in the scroll bar.</para>
+</listitem>
+<listitem>
+<para>Control the display of folded (temporarily hidden) sections in a source
+text.</para>
+</listitem>
+</itemizedlist>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>Project</guimenu></term>
+<listitem>
+<para>All work of &kdevelop; is based on <emphasis>projects</emphasis> which
+basically collect source files, build management files, and other information in
+one project directory. In this menu you control which project to use, which
+properties it has, and some other managing actions.
+In particular:</para>
+
+<formalpara>
+<title>Open a Project</title>
+<para>Allows to create new projects, open existing ones, and import projects
+from other environments.</para>
+</formalpara>
+
+<formalpara>
+<title>Project Options</title>
+<para>Allows to define a whole bunch of different project properties.</para>
+</formalpara>
+
+<formalpara>
+<title>Classes Management</title>
+<para>Add new classes to the project and traverse the inheritance tree of a
+class.</para>
+</formalpara>
+
+<formalpara>
+<title>Distribute Project</title>
+<para>Helps to build distribution packages of the project.</para>
+</formalpara>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>Build</guimenu></term>
+<listitem>
+<para>This menu is all about compiling and documenting the project. Thus it is
+of use only when a project is actually open. In this case it provides the
+following actions:</para>
+
+<formalpara>
+<title>Compile, Link, Execute</title>
+<para>Allows to compile and link the whole project or parts of it as well as run
+the application from within the &IDE;.</para>
+</formalpara>
+
+<formalpara>
+<title>Prepare Build Operations</title>
+<para>This actually depends on the make system you use for this project. In the
+case of automake projects it allows to run <filename>Makefile.cvs</filename> and
+<filename>configure</filename> on their own. There are also provisions to remove
+translated files from the project in various stages of intensity.</para>
+</formalpara>
+
+<formalpara>
+<title>Install the Application</title>
+<para>Allows to install the application both in local directories as well as in
+system directories only accessible to the root user.</para>
+</formalpara>
+
+<formalpara>
+<title>API Documentation</title>
+<para>Build or remove a doxygen-based API documentation of the project as
+defined in the project options.</para>
+</formalpara>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>Debug</guimenu></term>
+<listitem>
+<para>Although this menu will be filled once a project is active, it of course
+is useful only if the actual project has been previously compiled with debugging
+information (this is basically set up in <menuchoice><guimenu>Project</guimenu>
+<guimenuitem>Project Options..</guimenuitem></menuchoice>). There are the
+following actions available in this case:</para>
+
+<formalpara>
+<title>Usual Debugger Actions</title>
+<para>The first section in the <guimenu>Debug</guimenu> provides a graphical
+interface to the GDB &GNU; symbolic debugger. It allows to start and stop your
+application in the debugger and step through it in various ways.</para>
+</formalpara>
+
+<formalpara>
+<title>Breakpoints</title>
+<para>&kdevelop; provides several means to set breakpoints in your application
+sources. One is through the use of the <guimenuitem>Toggle
+Breakpoint</guimenuitem> menu entry.</para>
+</formalpara>
+
+<formalpara>
+<title>Advanced Debugging</title>
+<para>Other <guimenu>Debug</guimenu> menu entries allow more sophisticated
+program analysis. Use
+<keycombo><keycap>&Shift;</keycap><keycap>F1</keycap></keycombo> to get more
+information about their purpose.</para>
+</formalpara>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>Scripts</guimenu></term>
+<listitem>
+<para>You can call various scripts from this menu to more easily accomplish
+tedious actions on the text in the currently selected editor window. The
+available actions depend on the selected script, however.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>Window</guimenu></term>
+<listitem>
+<para>This is fairly standard. You may select any open document window as well
+as close one or more documents windows in here. You may even select a set of
+document windows to be closed in one single turn.</para>
+
+<para>Depending on the editor plugin you use may there be other menu items as
+well. So will the default Kate editor plugin additionally allow to split the
+editor window horizontally as well as vertically.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>Tools</guimenu></term>
+<listitem>
+<para>&kdevelop; is highly customizable.
+You may select a favorite editor for your documents as well as provide external
+and plugged-in tools to extend the basic &IDE; capabilities. The
+<guimenu>Tools</guimenu> menu reflects most of this setup.</para>
+
+<formalpara>
+<title>Advanced Editing</title>
+<para>The upper set of <guimenu>Tools</guimenu> menu entries will be provided by
+the editor plugin which is in use. You may select your favorite editor via
+<menuchoice><guimenu>Settings</guimenu> <guimenuitem>Configure
+KDevelop...</guimenuitem> <guilabel>Editor</guilabel></menuchoice>. Once an
+editable document file is selected, the upper part of the 
+<guimenu>Tools</guimenu> menu will provide advanced editing commands specific to
+the editor part in use.</para>
+</formalpara>
+
+<formalpara>
+<title>Web Side Handling</title>
+<para>In case the active document window contains a HTML page (&eg; displayed
+from a <guilabel>Documentation</guilabel> selection), the
+<guimenu>Tools</guimenu> will show additional menu entries which provide various
+means to handle Web pages.</para>
+</formalpara>
+
+<formalpara>
+<title>Other Tools</title>
+<para>Usually there will be a bunch of other entries according to the currently
+available tools. Use <keycombo><keycap>&Shift;</keycap>
+<keycap>F1</keycap></keycombo> to get more information about their
+purposes.</para>
+</formalpara>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>Settings</guimenu></term>
+<listitem>
+<para>This menu allows you to show and hide menubar, toolbars and statusbar.
+Also, you can configure shortcuts, toolbars, notifications, the editor and
+&kdevelop;&apos;s general behavior.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenu>Help</guimenu></term>
+<listitem>
+<para>Here you can open this KDevelop manual, look up terms in various
+documentation files, open man pages (the traditional UNIX manual format) and
+info pages (the GNU manual format). Furthermore you can report bugs here or get
+some info about your current KDevelop version and its authors.</para>
+</listitem>
+</varlistentry>
+</variablelist>
+</sect2>
+
+<sect2 id="gettingstarted-overview-tools">
+<title>What are those tool views for?</title>
+
+<para>In the IDEAl user interface mode the workspace will be surrounded by three
+areas of buttons, so-called <emphasis>tool view tabs</emphasis>. They provide
+access to <emphasis>tool view windows</emphasis> which accomplish main tasks
+during software development. Each of these three tool view areas serves a
+different main purpose.</para>
+
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>Left Side</title>
+<para>Provides access to navigation and selection tools</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Bottom</title>
+<para>These views display messages produced by various tools.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Right Side</title>
+<para>Provides access to documentation and source management tools.</para>
+</formalpara>
+</listitem>
+</itemizedlist>
+
+<para>The number of tool view tabs shown will change once a project is open for
+actual work. More tools to work on that project will be available then. The
+actual number of tool views depends on the <link linkend="plugin-tools">Plugin
+Tools</link> being currently available to &kdevelop;. You will find more on this
+topic in the <link linkend="setup">Configuring KDevelop</link> chapter.</para>
+
+<para>Currently, with no project open and the default number of plugin tools
+loaded, you will find the following tool views. Clicking on a tab will open
+respectively close its tool view window.</para>
+
+<variablelist>
+<varlistentry>
+<term>Navigation and Selection</term>
+<listitem>
+<formalpara>
+<title>File Selector</title>
+<para>Provides a panel to navigate the directory tree and select files for work
+just like you do in the &konqueror;. Clicking a file will open it in an
+appropriate editor window in the workspace area. A right click in the file
+selector area will pop up a navigation and file manipulation menu.</para>
+</formalpara>
+
+<formalpara>
+<title>File List</title>
+<para>Lists the currently open files. Clicking on a file will usually select its
+editor window in the workspace area. Use this to quickly navigate in a large
+number of open files. Furthermore this view provides a means to organize the
+open files into different <emphasis>sessions</emphasis>. This is particularly
+useful in very large and complex projects to help the developer concentrate on
+different tasks. Right clicking a file will pop up a file manipulation
+menu.</para>
+</formalpara>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Messages Displays</term>
+<listitem>
+<formalpara>
+<title>Application</title>
+<para>Displays the output from an application started from within
+&kdevelop;.</para>
+</formalpara>
+
+<formalpara>
+<title>Diff</title>
+<para>Used to display patch file contents.
+Displays the output from the difference viewer tool started from the
+<menuchoice><guimenu>Tools</guimenu> <guimenuitem>Difference
+Viewer...</guimenuitem></menuchoice> menu.</para>
+</formalpara>
+
+<formalpara>
+<title>Messages</title>
+<para>Displays messages produced by the build tools called from within
+&kdevelop;, usually from the <guimenu>Build</guimenu> menu.</para>
+</formalpara>
+
+<formalpara>
+<title>Find in Files</title>
+<para>Displays the list of items found by the global search operation started
+from the <menuchoice><guimenu>Edit</guimenu> <guimenuitem>Find in
+Files...</guimenuitem></menuchoice> menu. Clicking on a line here will
+automatically open that file at the specified position in an editor
+window.</para>
+</formalpara>
+
+<formalpara>
+<title>Replace</title>
+<para>Lists the results of the global search-and-replace operation issued from
+the <menuchoice><guimenu>Edit</guimenu>
+<guimenuitem>Find-Select-Replace...</guimenuitem></menuchoice> menu. In this
+view you can decide on every found item whether you really want it be replaced
+or not.</para>
+</formalpara>
+<note>
+<para>This global search-and-replace facility is actually available only after a
+project has been loaded into &kdevelop;. Otherwise the global replace tool in
+the <menuchoice><guimenu>Edit</guimenu>
+<guimenuitem>Find-Select-Replace...</guimenuitem> </menuchoice> menu will in
+fact be be disabled.</para>
+</note>
+
+<formalpara>
+<title>Konsole</title>
+<para>Opens a &kde; <application>Konsole</application> like terminal emulator
+window where you can use keyboard commands in a traditional &UNIX; command line
+interface.</para>
+</formalpara>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Documentation and Source Manipulation</term>
+<listitem>
+<formalpara>
+<title>Documentation</title>
+<para>&kdevelop; provides access to a whole bunch of documentation through this
+tool. You may here access document files, usually online from remote locations,
+in a structured way. And there are several ways available to directly access
+valuable information from &kde; or &Qt; manuals.</para>
+</formalpara>
+
+<para>See the <link linkend="documentation">Documentation</link> and <link
+linkend="setup-docu">Configuring the Documentation</link> chapters for more
+details.</para>
+
+<formalpara>
+<title>Code Snippets</title>
+<para>This tool allows you to permanently store selected texts for later use in
+other editing cycles. It is a very flexible tool, as any text snipped stored
+here may contain a set of variables which will get their actual values at the
+time when you insert such a snippet in some other text.</para>
+</formalpara>
+<para>More information on this is available in the <link
+linkend="editing-snippets">Code Snippets</link> and <link
+linkend="setup-snippets">Setting Up the Code Snippets Tool</link>
+chapters.</para>
+</listitem>
+</varlistentry>
+</variablelist>
+</sect2>
+</sect1>
+
+<sect1 id="gettingstarted-configure">
+<title>A Bit of Configuration</title>
+
+<para>Before we actually start a first example project, we should tailor the
+&kdevelop; behavior to our needs. Although most of the default settings will be
+appropriate for now, there are a few places which better should be
+adjusted.</para>
+
+<note>
+<para>If you want to know more about &kdevelop; configuration, have a look at
+the <link linkend="setup">Configuring KDevelop</link> chapter.</para>
+</note>
+
+<sect2 id="gettingstarted-configure-general">
+<title>Some General Settings</title>
+
+<para>To configure &kdevelop;, click the
+<menuchoice><guimenu>Settings</guimenu></menuchoice> menu and select
+<menuchoice><guimenuitem>Configure KDevelop...</guimenuitem></menuchoice>. The
+<guilabel>Configure KDevelop</guilabel> dialog will pop up, showing the
+following <guilabel>General</guilabel> settings page to the right.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="configure-general.png" format="PNG"/>
+</imageobject>
+<caption>
+<para>The &kdevelop; general configuration dialog</para>
+</caption>
+</mediaobject>
+</screenshot>
+
+<para>Most of the defaults will be o.k.
+But you will probably want to change two of those settings.</para>
+
+<formalpara>
+<title>Default projects directory</title>
+<para>At first start of &kdevelop; this will most likely be preset to your home
+directory. Most people however prefer a dedicated projects directory for
+software development. Change the text box to your preferred parent development
+directory. You may select it from the directory tree if you press the
+<guilabel>Open file dialog</guilabel> button labeled with a folder icon to the
+right of it.</para>
+</formalpara>
+
+<para>In our examples we will assume a (somewhat artificial) user called
+<filename class="directory">devel</filename>.
+Thus always replace this <quote>devel</quote> by your user name. Our devel user
+will utilize the <filename class="directory">/home/devel/projects</filename>
+parent directory for actual development. Again, replace <filename
+class="directory">projects</filename> with your development directory name.
+</para>
+
+<para>&kdevelop; will by default set up an own subdirectory below this parent
+for every new project you create. So will &eg; all files of a project named
+<quote>Hello</quote> in our case be located in the <filename
+class="directory">/home/devel/projects/hello</filename> directory.</para>
+
+<para>You may of course temporarily override these directory settings if you
+need to. See the <link linkend="applicationwizard">&appwizard;</link> chapter
+for more info on this.</para>
+
+<formalpara>
+<title>Compiler output</title>
+<para>Whenever &kdevelop; compiles some source, it will display the messages of
+the <application>make</application>, etc. build tools in the
+<guilabel>Messages</guilabel> window in the lower part of the workspace area.
+Usually these messages will be overwhelmingly wordy. To keep a better overview
+of what happens, &kdevelop; has some means of shortening those messages built
+in.</para>
+</formalpara>
+
+<para>Depending on the &kdevelop; version you use, the <guilabel>Compiler
+output</guilabel> selection may be preset to <quote>Long</quote>, which will
+cause all message contents be fully shown. You may probably want to change this
+to the far more convenient <quote>Very Short</quote> setting. Just select this
+from the drop down box.</para>
+
+<caution>
+<para>Be aware that only <emphasis>most basic</emphasis> information will be
+shown in the <guilabel>Messages</guilabel> window this way. In case of errors
+during &eg; a build run you will most likely want to see more, if not all, of
+the message texts. They are not lost, however. Just right click into the
+<guilabel>Messages</guilabel> window and select &eg; <quote>Full Compiler
+Output</quote> from the popup menu.</para>
+</caution>
+</sect2>
+
+<sect2 id="gettingstarted-configure-search">
+<title>Initializing Documentation Search Indexes</title>
+
+<para>There is another, not so obvious, item which preferably should be
+initialized before you start actual development work. This is because you will
+want to perform documentation search regularly during development. &kdevelop;
+requires some search indexes be created before such search operations can be
+performed. So let&apos;s initialize them before we attempt our first steps
+toward actual &kdevelop; work.</para>
+
+<para>Open the <guilabel>Documentation</guilabel> tool view at the right side of
+the &kdevelop; main window. There open the <guilabel>Search</guilabel> dialog
+page.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="documents-search.png" format="PNG"/>
+</imageobject>
+<caption><para>Where to generate the search indexes.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Now press the <guibutton>Update Config</guibutton> button to make sure the
+basic search tools are properly set up. A dialog should pop up, telling
+<quote>Configuration file updated</quote>. Click <guibutton>OK</guibutton> to
+make it disappear.</para>
+
+<para>This done, &kdevelop; will be ready to parse the documentation it knows of
+and build some useful search indexes from it. Press the <guibutton>Update
+Index</guibutton> button to the right. Now the <guilabel>Generating Search
+Index</guilabel> dialog will pop up showing the progress of the index build
+operations.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="configure-docu-indexgen.png" format="PNG"/>
+</imageobject>
+<caption><para>&kdevelop; is generating documentation search
+indexes.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>This will take some time depending on the size of documentation and the
+speed of your machine. But finally the <guibutton>Cancel</guibutton> will make
+place to <guibutton>OK</guibutton>. Just press this button to proceed.</para>
+
+<note>
+<itemizedlist>
+<listitem>
+<para>This usually should work out of the box. In some cases the
+<application>htdig</application> application &kdevelop; uses to perform its full
+text searches might not be properly set up. Refer to the <link
+linkend="setup-docu-textsearch">Setting Up Text Search Indexes</link> chapter
+for more help in this case.</para>
+</listitem>
+<listitem>
+<para>To be able to look up &kde; and &Qt; specific API documentation, it is
+mandatory that the <emphasis>KDELibs Apidocs</emphasis> were present when
+&kdevelop; was installed. If you experience problems building the indexes or
+perform the  <link linkend="gettingstarted-edit-defs">identifier lookup
+examples</link> later in this chapter, make sure that this documentation exists
+and is accessible to &kdevelop;. See <link linkend="kdevelop-install">Installing
+KDevelop</link> fore more detail.</para>
+</listitem>
+</itemizedlist>
+</note>
+</sect2>
+</sect1>
+
+
+<sect1 id="gettingstarted-new">
+<title>Starting a New Project</title>
+
+<para>Almost any application will consist of dozens, hundreds, even thousands of
+files which need kept structured and maintainable. To accomplish this,
+&kdevelop; organizes software development tasks in
+<emphasis>projects</emphasis>. Thus the first practical step to develop software
+in &kdevelop; usually is to create a new project.</para>
+
+<para>Fortunately this is fairly easily accomplished. &kdevelop; provides the
+so-called &appwizard; tool for this. (See the <link
+linkend="applicationwizard">Getting Started &mdash; the &appwizard;</link>
+chapter for more.)</para>
+
+<para>We will now start a simple &kde; application project to illustrate how
+easily this is accomplished and which files and tools &kdevelop; will have
+provided. Thereby we will have a short look at:</para>
+
+<simplelist>
+<member><link linkend="gettingstarted-new-setup">How to create a new project
+with the help of the &appwizard;.</link></member>
+<member><link linkend="gettingstarted-new-files">Which files the &appwizard;
+initially did set up.</link></member>
+<member><link linkend="gettingstarted-new-toolviews">What about the additional
+tool view shown with the project?</link></member>
+</simplelist>
+
+<sect2 id="gettingstarted-new-setup">
+<title>How to Create a New Project</title>
+
+<para>Let us create a rather simple <quote>Hello World</quote> &kde; project.
+Just follow these steps.</para>
+
+<procedure>
+<step>
+<para>To start the &appwizard; click the <menuchoice><guimenu>Project</guimenu>
+<guimenuitem>New Project...</guimenuitem></menuchoice> menu.</para>
+</step>
+
+<step>
+<para>The <guilabel>Create New Project</guilabel> dialog will pop up. In the
+upper left <guilabel>All Projects</guilabel> window there will be a number of
+programming languages listed.</para>
+
+<substeps>
+<step>
+<para>We want to build a &kde; C++ application as usual, thus click on the
+<guilabel>+</guilabel> label left of the <guilabel>C++</guilabel> label to open
+this branch.</para>
+</step>
+
+<step>
+<para>A series of possible application targets will be displayed. We will build
+a &kde; application, thus open the next sub-branch via the
+<guilabel>+</guilabel> label next to <guilabel>KDE</guilabel></para>
+</step>
+
+<step>
+<para>Now you will be offered a series of possible <emphasis>project
+templates</emphasis>. Navigate down to the end of this branch and click
+<guilabel>Simple KDE Application</guilabel>.</para>
+
+<para>A preview and short description of the application this project template
+will produce pops up in the two windows to the right.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="tutorial-new-project.png" format="PNG"/>
+</imageobject>
+<caption>
+<para>Selecting a <quote>Hello World</quote> project template</para>
+</caption>
+</mediaobject></screenshot>
+</step>
+
+<step>
+<para>Our application will need a name. Find the <guilabel>Properties</guilabel>
+area on the dialog bottom and enter a suitable name into the
+<guilabel>Application name</guilabel> input field.</para>
+
+<para>We use <quote>Hello</quote> in our example, but you can use whatever you
+like, provided the name consists of letters, number digits, and underlines only.
+You will find that the &appwizard; rejects any other character.</para>
+</step>
+
+<step>
+<para>Make sure the <guilabel>Location</guilabel> text box below the input field
+shows the name of your top project directory as set up in the <link
+linkend="gettingstarted-configure">A Bit of Configuration</link> chapter above.
+If it does not do so, enter a suitable directory name or select one from the
+directory list provided by the folder labeled button to the right.</para>
+
+<para>If all went well, the <guilabel>Final location</guilabel> line at the
+bottom will show the directory path your new project will use. In case there was
+an <quote>(invalid)</quote> suffix appended, try another name for your project
+and/or make sure the top project directory in the <guilabel>Location</guilabel>
+text box really exists and is writable.</para>
+</step>
+
+<step>
+<para>Once everything is right, the <guibutton>Next</guibutton> button in the
+bottom row of the dialog will be enabled. Click it to proceed.</para>
+</step>
+</substeps>
+</step>
+
+<step>
+<para>This will lead you to the <guilabel>Project Options</guilabel> dialog
+page. Make sure the <guilabel>Author</guilabel> and <guilabel>Email</guilabel>
+text boxes are properly filled in. Usually they will default to your general
+&kde; user settings as given in the <guilabel>Password &amp; User
+Account</guilabel> dialog of the &kde; Control Center. If not, change them to
+some settings you prefer for your application.</para>
+
+<screenshot id="gettingstarted-new-setup-options">
+<mediaobject>
+<imageobject>
+<imagedata fileref="tutorial-hello-options.png" format="PNG"/>
+</imageobject>
+<caption>
+<para>Provide your name and (optionally) email address.</para>
+</caption>
+</mediaobject>
+</screenshot>
+
+<note>
+<para>You must provide an <guilabel>Author</guilabel> name at least. This is
+mandatory for the application files setup.</para>
+</note>
+
+<para>If all is right, the <guibutton>Next</guibutton> button will be enabled.
+Click it to further proceed.</para>
+</step>
+
+<step>
+<para>The following <guilabel>Version Control System</guilabel>,
+<guilabel>Template for .h Files</guilabel>, and <guilabel>Template for .cpp
+Files</guilabel> dialog pages are not of interest for now. Skip them by clicking
+the <guibutton>Next</guibutton> buttons and, finally, the
+<guibutton>Finish</guibutton> button.</para>
+</step>
+</procedure>
+
+<para>That was all!
+The &appwizard; will take over and construct a series of initial files in the
+<guilabel>Final location</guilabel> directory you provided in step 2c
+above.</para>
+
+<para>Once this file creation phase is finished, &kdevelop; will open an editor
+window for the <emphasis>application main window</emphasis> implementation file
+(which is <filename>hello.cpp</filename> in our example), so you can readily
+proceed.</para>
+</sect2>
+
+<sect2 id="gettingstarted-new-files">
+<title>Initial Project Files</title>
+
+<para>Even if our sample Hello project is fairly simple, the &appwizard; did
+create a whole bunch of source and project management files. You will most
+easily list them if you open the <guilabel>File Tree</guilabel> tool view on the
+bottom left. This will open a file list similar to the one below.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="tutorial-hello-new.png" format="PNG"/>
+</imageobject>
+<caption>
+<para>Initial files in our <quote>Hello World</quote> project</para>
+</caption>
+</mediaobject>
+</screenshot>
+
+<para>To demonstrate the main bunch of files the &appwizard; produced, we did
+open most of the directory branches in the left-hand <guilabel>File
+Tree</guilabel> tool view window. Just click the branch names in the tree to see
+for yourself.</para>
+
+<para>Additionally, just for demonstration, we did as well open most of the
+branches the <guilabel>Automake Manager</guilabel> tool view window to the right
+where some of the project sources are listed, too.</para>
+
+<sect3 id="gettingstarted-new-files-copyright">
+<title>Copyright Issues</title>
+
+<para>All &GNU; conformant applications must be copyrighted. There are two
+levels which require copyright notices, <emphasis>individual source
+files</emphasis> and <emphasis>run-time application level</emphasis>. The
+&appwizard; did already put appropriate copyright and licensing information into
+the project files.</para>
+
+<formalpara>
+<title>Source File Level Copyrights</title>
+<para>Do you remember the <link linkend="gettingstarted-new-setup-options">
+<guilabel>Project Options</guilabel></link> dialog page in the new project
+setup? You had to provide your (the developer&apos;s) name and optionally an
+email address there. Now refer to the top of the <guilabel>hello.cpp</guilabel>
+editor window currently displayed in the workspace area. The &appwizard; did
+enter these statements on top of the licensing header of every source file it
+created.</para>
+</formalpara>
+
+<programlisting>
+/***************************************************************************
+ *   Copyright (C) 2006 by Joe User   *
+ *   joe@user.com   *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+</programlisting>
+
+<para>You will find exactly the same text headers in every source file you will
+create inside &kdevelop; (provided you use the proper built in tools for file
+creation). &kdevelop; remembers these settings in some template files you may
+find in the <filename class="directory">templates</filename> directory.</para>
+
+<formalpara>
+<title>Application Run-Time Copyrights</title>
+<para>Once your &kde; application runs, the user may display some
+<guilabel>About</guilabel> data, usually from the <guimenu>Help</guimenu> menu.
+The &appwizard; did also take care of this. If you have a look at the
+<filename>main.cpp</filename> file, you will find an entry similar to the one
+below.</para>
+</formalpara>
+
+<programlisting>
+int main(int argc, char **argv)
+{
+    KAboutData about("hello", I18N_NOOP("Hello"), version, description,
+		     KAboutData::License_GPL, "(C) 2006 Joe User", 0, 0,
+                     "joe@user.com");
+    about.addAuthor( "Joe User", 0, "joe@user.com" );
+</programlisting>
+
+<para>This will put the main developer&apos;s name (<quote>Joe User</quote> in
+our case) and email address into the <guilabel>About</guilabel> copyright page
+in the display and list this name and address on the
+<guilabel>Authors</guilabel> page there as well.</para>
+
+<important>
+<para>Whenever you make substantial changes to an existing project, be sure to
+enter your name and email address to the copyright notices on every file you
+changed and to the run-time copyright display as well. Don&apos;t be shy, you
+help the open source society considerably if you do so.</para>
+</important>
+</sect3>
+
+<sect3 id="gettingstarted-new-files-source">
+<title>Initial Source Files</title>
+
+<para>The &appwizard; did put the source files into the <filename
+class="directory">src</filename> sub-directory of the project&apos;s directory.
+You will find the <filename>main.cpp</filename>, <filename>hello.h</filename>,
+and <filename>hello.cpp</filename> files there as you may have possibly
+expected.</para>
+
+<para>There are some additional files you usually will find in a typical &kde;
+application, namely</para>
+
+<itemizedlist>
+<listitem>
+<para><filename>hello.desktop</filename> contains some meta data used by
+&kdevelop; to maintain and start the application.</para>
+</listitem>
+
+<listitem>
+<para><filename>hi16-app-hello.png</filename>, and
+<filename>hi32-app-hello.png</filename> contain some initial default icons,
+&kdevelop; will use for application display.</para>
+</listitem>
+
+<listitem>
+<para>Finally, <filename>helloui.rc</filename> contains a description of the
+application&apos;s user interface, currently the menus the application will
+provide.</para>
+</listitem>
+</itemizedlist>
+</sect3>
+
+<sect3 id="gettingstarted-new-files-doc">
+<title>Initial Application Documentation</title>
+
+<para>In the <filename class="directory">doc/en</filename> subdirectory of the
+project you will find the <filename>index.docbook</filename> file. This is a
+default template from where you can start to write a suitable user
+documentation.</para>
+</sect3>
+
+<sect3 id="gettingstarted-new-files-project">
+<title>Project and Auxiliary Files</title>
+
+<para>You will have noted that the files we introduced so far are listed in
+boldface in the <guilabel>File Tree</guilabel> tool view while most of the other
+files are not. This depicts the substantially different tasks these files are
+used for. The contents of those bold listed files directly influence the
+application. Source files will produce the code to be run, others will provide
+necessary data or documentation. These files must be maintained and orderly
+processed in the build stages by the project, hence they are called
+<emphasis>project files</emphasis>.</para>
+
+<para>If you have a look at the lower <guilabel>Automake Manager</guilabel>
+window to the right of the workspace area you will find all project files listed
+as well. The &automanag; tool uses this knowledge to take care of the build
+control as we shortly will see.</para>
+
+<para>The other, non-bold listed files are of more auxiliary nature. They belong
+to several distinctive classes as follows:</para>
+
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>Project Build Control</title>
+<para>These files control the compile, install, documentation building, &etc;
+processes. If the project utilizes the &GNU;
+<application>autotools</application> machinery as our example does, you will
+find a <filename>Makefile.am</filename> file in each project directory. These
+are kind of basic make core files which contain build control commands and will
+be processed in conjunction with various <filename>configure</filename> files
+during the build stages. Such a build produces a final
+<filename>Makefile</filename> in every directory. And from these in turn the
+<application>make</application> utility will finally build the binaries of the
+application.</para>
+</formalpara>
+
+<para>Those <filename>Makefile.am</filename> files need to be maintained
+throughout the development process. Luckily, &kdevelop; relieves you of most of
+this burden by the &automanag; tool, which basically is a graphical front end to
+maintain <filename>Makefile.am</filename> contents.</para>
+
+<para>Other project build control files currently listed are
+<filename>configure.in.in</filename> and <filename>subdirs</filename> in the
+project root directory. They will be processed by some of the files in the
+<filename class="directory">admin</filename> &kde; specific administration
+directory to produce more <filename>configure</filename> and
+<filename>Makefile</filename> type files and finally the application&apos;s
+binaries.</para>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>&kdevelop; Control Files</title>
+<para>&kdevelop; needs some control and administration data on its own. These
+are located in the project root directory, in our example
+<filename>hello.kdevelop</filename>, <filename>hello.kdevelop.pcs</filename>,
+and <filename>hello.kdevses</filename>.</para>
+</formalpara>
+
+<para>Of particular importance in each project is the
+<filename>xxx.kdevelop</filename> (where <quote>xxx</quote> denotes the project
+name) file. It is the main <emphasis>KDevelop 3 Project File</emphasis> and
+needed if you later want load this project into the &IDE;.</para>
+
+<warning>
+<para>Never do manually modify, rename, or even delete any of these &kdevelop;
+control files! The &IDE; will most likely not function properly on your project
+afterwards.</para>
+</warning>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>GNU Project Description Files</title>
+<para>Some files in the project root directory are mandatory in any &GNU;
+conformant application. These are: <filename>AUTHORS</filename>,
+<filename>ChangeLog</filename>, <filename>INSTALL</filename>,
+<filename>COPYING</filename> (which contains the GNU GENERAL PUBLIC LICENSE),
+<filename>INSTALL</filename>, <filename>NEWS</filename>,
+<filename>README</filename>, and <filename>TODO</filename>.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Other Files</title>
+<para>A few more files, not mentioned yet, are:</para>
+</formalpara>
+
+<itemizedlist>
+<listitem>
+<para><filename>Doxyfile</filename> controls the creation of the project
+specific &API; internal programming interface documentation.</para>
+</listitem>
+
+<listitem>
+<para>The <filename class="directory">templates</filename> directory containes
+file templates the &IDE; uses as stubs to create new source files.
+You may at any time edit these templates. The new contents will be reflected in
+the next source files you create of the related types.</para>
+
+<para>You may &eg; want to realign the right hand stars in the copyright lines
+the &appwizard; inserted into the <filename>cpp</filename> and
+<filename>h</filename> template files, so the source files created from them
+will look less awkward.</para>
+</listitem>
+
+<listitem>
+<para>The <filename class="directory">po</filename> directory will be used for
+localization purposes. It is essentially part of the project files (contains a
+<filename>Makefile.am</filename>) but will mainly be used in translation
+processing. Not of main interest to the application developer, however.</para>
+</listitem>
+
+<listitem>
+<para>Finally, the <filename class="directory">admin</filename> directory is
+specially needed in &kde; oriented applications. It provides a whole bunch of
+files necessary to maintain the application&apos;s sources and binaries so they
+will integrate properly into the &kde; environment.</para>
+</listitem>
+</itemizedlist>
+
+</listitem>
+</itemizedlist>
+</sect3>
+</sect2>
+
+<sect2 id="gettingstarted-new-toolviews">
+<title>Additional Tool Views</title>
+
+<para>As you will have noticed, as soon as the &appwizard; had the new project
+ready, several additional tool views were provided. These make sense during
+project development only and, in short, provide the following
+functionality.</para>
+
+<note>
+<para>The tool views actually visible depend on the plugins currently loaded
+into &kdevelop;. There are ways to control this. See the <link
+linkend="setup-plugins">Plugin Tools</link> chapter for instructions.</para>
+</note>
+
+<sect3 id="gettingstarted-new-toolviews-left">
+<title>Navigation and Selection Tools (left side)</title>
+
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>Bookmarks</title>
+<para>You can mark any text file line in order to quickly return to this
+position from everywhere. &kdevelop; will remember all those
+<emphasis>bookmarks</emphasis>, even if you close the editor window afterwards.
+The <guilabel>Bookmarks</guilabel> tool view lists all those bookmarks by file
+name and line number. You need only click such an entry to open the editor
+window accordingly and position the cursor on that line.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Classes</title>
+<para>Lists classes, methods, &etc; known in the project. Clicking the entry
+opens the appropriate header or source file in an editor window and positions
+the cursor at the respective declaration or definition.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>File Groups</title>
+<para>Sorts the files in the projects into various utility groups, &ie; Sources,
+User Interface, Icons, Translations, and Others. Clicking an entry opens that
+file in an editor window.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Variables</title>
+<para>This is used by the debugger tool to display, evaluate, and watch
+variables during debug runs.</para>
+</formalpara>
+</listitem>
+</itemizedlist>
+</sect3>
+
+<sect3 id="gettingstarted-new-toolviews-bottom">
+<title>Messages (bottom)</title>
+
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>Valgrind</title>
+<para><application>Valgrind</application> is a run-time program analyzer. This
+tool view lists the results of such an analyze run. It is used &eg; to find
+memory leaks.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Security Problems</title>
+<para>There is a <guilabel>Security Checker</guilabel> plugin tool for
+&kdevelop;. It analyzes the currently edited source file for several common
+security problems which may occur in the application and notifies the user in
+this tool view window.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Breakpoints</title>
+<para>This tool view allows to explicitly set, clear, and manage debug
+breakpoints in the application source files. It is used in conjunction with the
+debugger.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>CTags</title>
+<para>Allows to create a database of identifier indexes using the popular
+<application>CTags</application> application. This tags database may then be
+used from out this tool view window to look up any needed identifier in the
+project sources. Clicking a thus found item line will open an editor window and
+position the cursor on the appropriate identifier there.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Problems</title>
+<para>&kdevelop; keeps track of common programming problems in the currently
+edited source file and notifies the user in this tool view window.</para>
+</formalpara>
+</listitem>
+</itemizedlist>
+</sect3>
+  
+<sect3 id="gettingstarted-new-toolviews-right">
+<title>Source Management (right side)</title>
+      
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>Automake Manager</title>
+<para>The &automanag; tool is basically a graphical front end to maintain the
+contents of the <filename>Makefile.am</filename> files located in each project
+directory. This tool view uses two windows to control its work. The upper window
+mirrors part of the project subdirectories, namely those which explicitly
+contain <emphasis>project files</emphasis>. Each subdirectory of this kind must
+contain a <filename>Makefile.am</filename> file and is termed a
+<emphasis>subproject</emphasis> in the &automanag; context.</para>
+</formalpara>
+
+<para>Clicking a subproject entry opens a suitable display of the project files
+in this subproject in the lower window. The files listed there will be grouped
+according to their <filename>Makefile.am</filename> functionality in this
+subproject.</para>
+
+<para>The &automanag; is a very powerful tool to manage the project and its
+subprojects as well as the roles project files play in building the application.
+We will have a short look at a few major details <link
+linkend="gettingstarted-extend-automake">below</link>. See the <link
+linkend="project-management">Building and Project Management</link> chapter for
+a more extensive description.</para>
+</listitem>
+</itemizedlist>
+</sect3>
+</sect2>
+</sect1>
+
+
+<sect1 id="gettingstarted-edit">
+<title>Some Tips About Dealing With Documents</title>
+
+<para>In our example project the &appwizard; did leave the
+<filename>hello.cpp</filename> file open in an editor window, so you can
+immediately start working. Now, we may well assume your are knowledgeable about
+using an editor, so we do not need talk much about this here. But there are some
+handy &kdevelop; specifics about dealing with such tabbed editor windows and the
+documents you are working on. We will have a short look at some of them,
+namely:</para>
+
+<simplelist>
+<member><link linkend="gettingstarted-edit-headers">How to easily switch between
+header and implementation files.</link></member>
+<member><link linkend="gettingstarted-edit-defs">How to quickly access
+declarations and definitions.</link></member>
+<member><link linkend="gettingstarted-edit-arrange">How to arrange editor
+windows to your current needs.</link></member>
+<member><link linkend="gettingstarted-edit-problems">How to keep an eye on
+common problems.</link></member>
+</simplelist>
+
+<sect2 id="gettingstarted-edit-headers">
+<title>Switching Between Header and Implementation Files</title>
+
+<para>&kdevelop; provides a quick and easy way to switch from a given
+implementation (<filename>.cpp</filename>) file to the corresponding header
+(<filename>.h</filename>) file and vice versa. Just right click into the editor
+window you want to switch. A menu similar to the following will pop up.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="editor-switch-header.png" format="PNG"/>
+</imageobject>
+<caption><para>How to switch between implementation and header
+files.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Find the <guimenuitem>Switch header/implementation</guimenuitem> entry and
+select it. &kdevelop; will look up the corresponding header or implementation
+file and open it in another editor window. In our example, if you did right
+click into the <filename>hello.cpp</filename> source, the
+<filename>hello.h</filename> file will be displayed and the cursor positioned
+there.</para>
+
+<para>There is even more. If you do right click inside the text of a class
+implementation, &kdevelop; will position the cursor on the corresponding
+declaration line in the header file. And vice versa, right clicking on a
+declaration line will bring you to the corresponding class
+implementation.</para>
+
+<para>If the editor window with the file to be switched to already exists,
+&kdevelop; will of course activate this one and reposition the cursor there if
+necessary.</para>
+</sect2>
+
+<sect2 id="gettingstarted-edit-defs">
+<title>How to Access Declarations and Definitions</title>
+
+<para>But what if you are working on a source file and want to look up the
+declaration or definition of an identifier you just found there? Well, this is
+equally easily accomplished. Basically all you need to do is to right click on
+the identifier in question.</para>
+
+<para>There are two different cases to consider, however, namely:</para>
+<simplelist>
+<member><link linkend="gettingstarted-edit-defs-external">Accessing externally
+defined identifiers</link>, and</member>
+<member><link linkend="gettingstarted-edit-defs-project">dealing with project
+internal text items</link>.</member>
+</simplelist>
+
+<sect3 id="gettingstarted-edit-defs-external">
+<title>External Declarations and Definitions</title>
+
+<para>In a most common case you want to look up an identifier which was defined
+externally to your project. In &kde; projects such identifiers are most likely
+documented in various &kde; or &Qt; libraries. If &kde; and &kdevelop; were
+properly installed, &kdevelop; will be able to access such so-called API
+documentation and be able to search it for identifiers of this kind.</para>
+
+<para>Let us look at an example. In the <filename>hello.cpp</filename> editor
+window find the following lines.</para>
+
+<programlisting>
+Hello::Hello()
+    : KMainWindow( 0, "Hello" )
+{
+</programlisting>
+
+<para>Right click on <classname>KMainWindow</classname>.
+A menu will pop up. There select the <guimenuitem>Search in Documentation:
+KMainWindow</guimenuitem> entry and release the mouse button. Now the
+<guilabel>Documentation</guilabel> tool view will open, showing the
+<classname>KMainWindow</classname> entry as search item on the
+<guilabel>Search</guilabel> sub-page. And a short while after another editor
+window will open in the workspace area, showing the KDE API Reference page of
+the <classname>KMainWindow</classname> class.</para>
+
+<para>This all will look like the following. (We deliberately opened the
+<guilabel>Documentation</guilabel>, <guilabel>Search</guilabel> page already to
+illustrate the result of the menu selection.)</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="editor-search-doc.png" format="PNG"/>
+</imageobject>
+<caption><para>How to look up an externally documented
+identifier.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>You might as well select <guimenuitem>Find Documentation:
+KMainWindow</guimenuitem>. In this case the <guilabel>Finder</guilabel> sub-page
+of the <guilabel>Documentation</guilabel> tool view will show up, usually
+providing a selection of pages containing the search term. (In our example this
+will probably be the <classname>KMainWindow</classname> and
+<classname>KMainWindowInterface</classname> classes. Select the one you are
+interested in and the corresponding documentation will be displayed in an editor
+window.</para>
+
+<note>
+<para>If this did not work, then there is probably no documents index yet. Did
+you initialize the indexes as shown <link
+linkend="gettingstarted-configure-search">above</link>? If not, please do so,
+then come back here and try again.</para>
+</note>
+</sect3>
+
+<sect3 id="gettingstarted-edit-defs-project">
+<title>Project Internal Declarations and Definitions</title>
+
+<para>Such search facilities in external documentation have their limitations,
+however. Of course one cannot look up an identifier externally if it is only
+defined and used inside the current project. But there is help. &kdevelop; can
+use indexes built by the <application>CTags</application> application to search
+the sources in your project.</para>
+
+<para>Before we can use this on our Hello example project, we must however first
+generate a suitable index. This is done by the <guilabel>CTags</guilabel> tool
+view at the bottom of the workspace area.</para>
+
+<para>When you click the <guibutton>CTags</guibutton> tab, a dialog window will
+open where you will find the following key in the lower right corner.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="editor-ctags-regenerate.png" format="PNG"/>
+</imageobject>
+<caption><para>Build a CTags index with the <guibutton>Regenerate</guibutton>
+key.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Press the <guibutton>Regenerate</guibutton> button and wait a few seconds.
+Then the <guilabel>No CTags Database Found</guilabel> will be replaced by the
+current date. Now you are ready to perform some identifier look ups in your
+project source.</para>
+
+<tip>
+<para>The date next to the <guilabel>Regenerate</guilabel> button is there to
+remind you of possibly too old indexes. Whenever you are obviously not able to
+look up some identifier in your project, consider regenerating the index. On
+large projects this might take considerable time, but you should make it a habit
+to regenerate the index regularly after extensive source file changes.</para>
+</tip>
+
+<para>To look up an identifier in your project sources there are several
+possibilities.</para>
+
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>Use the CTags tool view</title>
+<para>This is easy.
+Just start typing the identifier name you are interested in into the
+<guilabel>Lookup</guilabel> input field in the bottom left. &kdevelop; will try
+to complete the word you have typed so far and show all occurrences of those
+identifiers which start with this character sequence.</para>
+</formalpara>
+
+<para>If for example you want to know wherever the <quote>Hello</quote>
+identifier was used in our example project, type an "H" into the
+<guilabel>Lookup</guilabel> input field. &kdevelop; will immediately start
+working and present you a result like this:</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="editor-ctags-lookup.png" format="PNG"/>
+</imageobject>
+<caption><para>How to look up an identifier in the <guilabel>CTags</guilabel>
+tool view.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>If you click one of the listed entries, &kdevelop; will open an editor
+window with this file and position the cursor on the appropriate place.</para>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Use a context menu in a source file</title>
+<para>This is handy while you are working on a certain source file.
+Assume you are studying the <filename>main.cpp</filename> file of our Hello
+example project. There you find the following line</para>
+</formalpara>
+<programlisting>
+    Hello *mainWin = 0;
+</programlisting>
+<para>and wonder whatever the <quote>Hello</quote> was used for in the program.
+To find out, simply right click on this Hello identifier. A menu will pop up in
+response to this right mouse click, featuring the following lines near the
+bottom.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="editor-ctags-menu.png" format="PNG"/>
+</imageobject>
+<caption><para>Getting <application>CTags</application> information on a project
+internal identifier.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Click what you are interested in, say <guilabel>CTags - Go to Definition:
+Hello</guilabel>, and &kdevelop; will immediately open the
+<filename>hello.cpp</filename> editor window and position the cursor right in
+front of this class definition:</para>
+<programlisting>
+Hello::Hello()
+    : KMainWindow( 0, "Hello" )
+{
+</programlisting>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Do a global search</title>
+<para>This is especially useful if you want to look up arbitrary text in your
+project source. There are two possibilities to start a global search from within
+&kdevelop;.</para>
+</formalpara>
+<itemizedlist>
+<listitem>
+<para>Start a global search from the <menuchoice><guimenu>Edit</guimenu>
+<guimenuitem>Find in Files...</guimenuitem></menuchoice> menu.
+Or</para>
+</listitem>
+<listitem>
+<para>Directly make use of the context menu with a right mouse click in the
+editor window.</para>
+</listitem>
+</itemizedlist>
+
+<para>We will illustrate the second possibility on our Hello example project.
+The outcome of the menu call will essentially be the same. Let us assume you are
+studying the <filename>hello.cpp</filename> source file and have the cursor
+positioned on the first Hello occurrence there. Now you wonder, where this one
+word <quote>Hello</quote> was used in the project source and how many
+occurrences there are. This is a typical case where to use &kdevelop;&apos;s
+global search facilities.</para>
+
+<para>Now, still keeping the cursor somewhere on this <quote>Hello</quote> in
+the source text, click the right mouse button. The now well known context menu
+will pop up, where you should select the <guilabel>Grep: Hello</guilabel>
+line.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="editor-find-menu.png" format="PNG"/>
+</imageobject>
+<caption><para>Initiating a global search from within an editor
+window.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>This will pop up the following <guilabel>Find in Files</guilabel> dialog
+(exactly the same as if you did use the <menuchoice><guimenu>Edit</guimenu>
+<guimenuitem>Find in Files...</guimenuitem></menuchoice> menu).</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="find-in-files.png" format="PNG"/>
+</imageobject>
+<caption><para>A versatile graphical front end to perform global searches in the
+project.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>As you see, this is a very versatile tool to initiate
+<application>find</application>-and-<application>grep</application> searches
+throughout your project. We won&apos;t delve further into details here, but you
+may want to experiment with this facility on your own. For the moment, there
+should be our <quote>Hello</quote> be preselected in the
+<guilabel>Pattern</guilabel> field. If it is not, just type it in, then press
+the <guibutton>Search</guibutton> button at the bottom right.</para>
+
+<para>Now the <guilabel>Find in Files</guilabel> tool view will open at the
+bottom, showing you file names and lines of all literal occurrences of
+<quote>Hello</quote> in our example project. As usual, if you click an entry,
+&kdevelop; will get you to exactly that position in an editor window in the
+workspace area.</para>
+
+<para>There are two lines of special interest in the tool view window.</para>
+<itemizedlist>
+<listitem>
+<para>Right on top you will find the command sequences &kdevelop; did actually
+use to perform the search. This will be useful to more precisely control the
+search outcome.</para>
+</listitem>
+
+<listitem>
+<para>On bottom the number of occurrences found in these search run will be
+listed. In our example this should read <quote>*** 11 matches found
+***</quote>.</para>
+</listitem>
+</itemizedlist>
+
+<para>&kdevelop; will remember these search results throughout the currently
+running session. If you initiate another global search, its results will display
+in another tabbed window in the <guilabel>Find in Files</guilabel> tool view
+window.</para>
+</listitem>
+</itemizedlist>
+</sect3>
+</sect2>
+
+<sect2 id="gettingstarted-edit-arrange">
+<title>Arranging Editor Windows</title>
+
+<para>When your work with large complex projects you will often end up with
+quite a lot of tabbed editor windows residing on the tab bar. This makes
+specific facilities to clean up, order, and group all those editor tabs
+necessary. &kdevelop; provides several means for this. We will have a short look
+at some of them.</para>
+<simplelist>
+<member><link linkend="gettingstarted-edit-arrange-clean">How to remove unneeded
+tabs.</link></member>
+<member><link linkend="gettingstarted-edit-arrange-tabs">How to rearrange the
+tabs.</link></member>
+<member><link linkend="gettingstarted-edit-arrange-split">How to view several
+files simultaneously in the workspace area.</link></member>
+<member><link
+linkend="gettingstarted-edit-arrange-sourceheader">How to edit
+C++ source and header files simultaneously</link></member>
+<member><link linkend="gettingstarted-edit-arrange-group">How to group source
+files into development sessions.</link></member>
+</simplelist>
+
+<sect3 id="gettingstarted-edit-arrange-clean">
+<title>Cleaning up the Tabs Row</title>
+
+<para>If the vast amount of editor window tabs becomes badly arranged at all,
+you usually may want to close all those tabs you really do not need any more.
+&kdevelop; provides several facilities to do so, the usual way of bulk closing
+open editor windows and a more specific approach where you can expressly command
+which ones to close and which to keep open.</para>
+
+<formalpara>
+<title>Closing Several Tabs At Once</title>
+<para>This is kind of a bulk approach to close unnecessarily open tabs which you
+may find in other &kde; applications as well. You can use the
+<guimenu>Window</guimenu> menu or right click on a tab to either</para>
+</formalpara>
+<itemizedlist>
+<listitem>
+<para>close the currently selected editor window,</para>
+</listitem>
+<listitem>
+<para>close all other open editor windows, or</para>
+</listitem>
+<listitem>
+<para>close all editor windows at once (available from the
+<guimenu>Window</guimenu> menu only).</para>
+</listitem>
+</itemizedlist>
+
+<formalpara>
+<title>Closing Selected Sets of Tabs</title>
+<para>The step-by-step approach of closing individual editor window tabs can
+become awkward if there are a great number of tabs from which you want to still
+keep several open. Instead of searching and closing one editor window tab after
+another &kdevelop; provides a means to select the candidates from a list and
+close those, and only those, with one single mouse click.</para>
+</formalpara>
+
+<para>Let us illustrate this on a simple example.
+In our Hello example project let us assume there were several files open for
+edit: <filename>hello.cpp</filename>, <filename>hello.h</filename>,
+<filename>helloui.rc</filename>, <filename>hello.desktop</filename>, and
+<filename>main.cpp</filename>. Now you want to close all of them except
+<filename>hello.cpp</filename> and <filename>hello.h</filename>. The easiest way
+to do so is with the <guilabel>File List</guilabel> tool view. Because this list
+of open files is alphabetically ordered you can more easily find the ones you
+want to be closed. Proceed as follows:</para>
+
+<procedure>
+<step>
+<para>Open <guilabel>File List</guilabel> and, with the <keycap>Ctrl</keycap>
+key held down, click the files you want to be closed in the list.</para>
+</step>
+<step>
+<para>Then, keeping the mouse pointer on a file name in the list, click the
+right mouse button.</para>
+</step>
+<step>
+<para>From the <guimenu>File List</guimenu> popup menu select <guimenuitem>Close
+Selected</guimenuitem>.</para>
+</step>
+</procedure>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="file-list-close-selected.png" format="PNG"/>
+</imageobject>
+<caption><para>How to close selected editor windows in one
+step.</para></caption>
+</mediaobject>
+</screenshot>
+<para>That was all.
+&kdevelop; will have closed all editor windows at your wish, and you are ready
+to proceed with a clean tab bar again.</para>
+</sect3>
+
+<sect3 id="gettingstarted-edit-arrange-tabs">
+<title>How to Rearrange Edit Window Tabs</title>
+
+<para>Even if you have only the really necessary editor windows open you may
+still want to have their tabs arranged in some logical way. &kdevelop; provides
+some common means to do so, in short:</para>
+
+<formalpara>
+<title>Basic Setup &mdash; Where to Position New Tabs</title>
+
+<para>By default, when you open a new editor window, its tab will be inserted to
+the right of the editor window tab currently in use. This can be changed so that
+the new tab will open to the far right on the tab bar.</para>
+</formalpara>
+<para>You must change a basic user interface setting in &kdevelop; to enable
+this behavior.</para>
+<procedure>
+<step>
+<para>Select <menuchoice><guimenu>Settings</guimenu> <guimenuitem>Configure
+KDevelop...</guimenuitem></menuchoice></para>
+</step>
+<step>
+<para>In the left hand icon bar on the dialog popup click the <guilabel>User
+Interface</guilabel> icon. The <guilabel>User Interface</guilabel> dialog page
+will be now shown.</para>
+</step>
+<step>
+<para>In the left bottom corner there find the section labeled <guilabel>Tabbed
+Browsing</guilabel>. Remove the check mark on the <guilabel>Open new tab after
+current tab</guilabel> line.</para>
+</step>
+<step>
+<para>Close &kdevelop; and restart it again. Now the new editor window tabs will
+open at the far right end of the current tabs row.</para>
+</step>
+</procedure>
+
+<para>Unfortunately, this setting cannot be changed on the fly during a
+development session. You must make up your mind which behavior you prefer in the
+long run and then stick to it, at least until the next start of
+&kdevelop;.</para>
+
+<formalpara>
+<title>How to Rearrange the Tabs</title>
+<para>As development tasks do vary over time, the need to rearrange the tabbed
+editor windows will more or less often arise. This is easily accomplished in
+&kdevelop;.</para>
+</formalpara>
+<para>
+Just click the tab you want to move with the middle mouse button and move the
+mouse a short distance. The cursor will change to a crossed-arrow pattern. You
+can now drag this tab, holding the middle mouse button down, until it did skip
+into the place where you want it to be.</para>
+</sect3>
+
+<sect3 id="gettingstarted-edit-arrange-split">
+<title>Viewing Several Files Simultaneously</title>
+
+<para>At first sight there is always at most one single editor window open to
+work on a source file. Although you may fast switch the tabbed windows, there
+are times where you want have several files open at once, &eg; for reference
+purposes or to keep complex tasks under better control. To accomplish this,
+&kdevelop; provides a way to split the workspace area into different,
+simultaneously visible sections which each can hold their own series of tabbed
+windows.</para>
+
+<para>There are two split commands which you can reach either through the
+<guimenu>Window</guimenu> menu or by right clicking either into a tabbed window
+or on the window tab itself. We will illustrate this splitting behavior again
+with our Hello example project.</para>
+
+<para>Assume there are two source files open on the tab bar,
+<filename>hello.cpp</filename> and <filename>hello.h</filename>. Now, while
+working on the <filename>hello.cpp</filename> source, you often need to refer to
+the declarations in the <filename>hello.h</filename> headers file, so you want
+to keep both files open simultaneously.</para>
+
+<para>To get this done, right click on the tab of, say,
+<filename>hello.h</filename>. The following menu will then pop up.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="split-workspace.png" format="PNG"/>
+</imageobject>
+<caption><para>How to split the current workspace area into two
+parts.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Select the <guimenuitem>Split Horizontal</guimenuitem> entry. This will
+split the current workspace area in the middle and move the tabbed editor window
+holding the <filename>hello.h</filename> file into the lower part.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="split-windows.png"/>
+</imageobject>
+<caption><para>The workspace has been split horizontally.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Note the dotted separator line between both windows. You can grab it with
+the mouse and adjust the heights of the editor windows according to your
+needs.</para>
+
+<para>There are a few points to note.</para>
+<itemizedlist>
+<listitem>
+<para>The split workspace areas are fully functional at their own. This means,
+new tabbed windows will open in the workspace which contains the currently
+active editor window. And you can split any sub-area again to your wish, thus
+keeping as much windows open simultaneously as you need.</para>
+</listitem>
+
+<listitem>
+<para>Any split will move the currently active editor window into the new
+workspace sub-area, either downward or to the right. The other tabbed windows
+all remain where they were. You cannot directly move tabbed windows between
+split areas, instead you need to explicitly close the window in one workspace
+area and reopen it in another to regroup.</para>
+</listitem>
+
+<listitem>
+<para>Also, there is no direct way to close a split area again.
+It closes automatically, once the last tabbed window in it was closed.</para>
+</listitem>
+</itemizedlist>
+</sect3>
+
+<sect3 id="gettingstarted-edit-arrange-sourceheader">
+<title>Edit C++ Source and Header Files Simultaneously</title>
+
+<para>There is a neat application of the above mentioned workspace split
+feature built into &kdevelop;. It allows to automatically keep a
+<filename>.cpp</filename> source and its accompanying
+<filename>.h</filename> header file side by side open in the workspace area.
+And, optionally, it allows to work on both files synchronously, such that if
+you select a declaration in the header file &kdevelop; will navigate to the
+respective definition in the source file and vice versa.</para>
+
+<para>This feature is however deactivated by default. If you want to use it in
+your project you need to activate it.</para>
+
+<para>Select <menuchoice><guibutton>Project</guibutton>
+<guimenuitem>Project Options</guimenuitem></menuchoice>. The
+<guilabel>Project Options</guilabel> dialog will pop up. In the left hand icon
+bar there select <guiicon>C++ Support</guiicon> and subsequently the
+<guilabel>Navigation</guilabel> tab on the dialog page which will display on
+the right side.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="split-source-header.png" format="PNG"/>
+</imageobject>
+<caption><para>Have C++ source and header files be displayed side by
+side.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Now check the <guilabel>Enable split of Header/Source files</guilabel>
+box. This will enable <guilabel>Automatic Synchronize</guilabel>
+and <guilabel>Vertical</guilabel> by default. Keep these settings for now and
+press <guibutton>OK</guibutton>.</para>
+
+<para>To illustrate this feature, now close in our example Hello project
+both the <filename>hello.cpp</filename> and <filename>hello.h</filename> editor
+windows, if necessary. Then select <filename>hello.cpp</filename> again from the
+<filename class="directory">src</filename> subdirectory of the project. The
+editor window will open as usual. But if you now open the
+<filename>hello.h</filename> belonging to it, &kdevelop; will automatically
+split the workspace and open this header file editor window just beneath the
+<filename>hello.cpp</filename> window.</para>
+
+<para>There is even more, as we mentioned already. In the
+<filename>hello.cpp</filename> editor find &eg; this constructor definition
+line:</para>
+<programlisting>
+Hello::Hello()
+</programlisting>
+<para>and put the cursor there. Then look at the <filename>hello.h</filename>
+window below and note how &kdevelop; did navigate to the corresponding default
+constructor declaration line.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="split-source-header-navigate.png" format="PNG"/>
+</imageobject>
+<caption><para>&kdevelop; automatically navigated to the constructor
+declaration.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>This works vice versa as well. Whenever you put the cursor somewhere into
+a construct in one editor window, &kdevelop; will navigate to the corresponding
+construct in the other.</para>
+</sect3>
+
+<sect3 id="gettingstarted-edit-arrange-group">
+<title>Grouping Source Files Into Development Sessions</title>
+
+<para>When your project grows larger, and the development tasks become more and
+more complex and force you to often switch between different, even distinct sets
+of files, it is about time to organize your development work into distinct
+sessions. The <guilabel>File List</guilabel> tool view of &kdevelop; allows you
+do to just this.</para>
+
+<para>On top of the <guilabel>File List</guilabel> tool view window there is a
+tool bar where you can create, save, select, and remove such sessions. Or
+alternatively use the <menuchoice><guimenu>View</guimenu> <guimenuitem>View
+Sessions</guimenuitem></menuchoice> sub-menu.</para>
+
+<para>We will illustrate this facility again with our Hello example project.
+Assume you want to always open the <filename>hello.cpp</filename>,
+<filename>hello.h</filename>, and <filename>main.cpp</filename> files all in one
+step, no matter what development task you just did perform in the project. To
+accomplish this, you first need to create a new development session named, say,
+<quote>sources</quote>.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="file-list-session-create.png" format="PNG"/>
+</imageobject>
+<caption><para>Use development sessions to remember groups of
+files.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>This is a multiple step approach as follows.</para>
+<procedure>
+<step>
+<para>Create a new session</para>
+<substeps>
+<step>
+<para>Click the <guiicon>New Session</guiicon> icon top left in the
+<guilabel>File List</guilabel> tool view window.</para>
+</step>
+<step>
+<para>A dialog will pop up. In the <guilabel>Enter the name of the
+session</guilabel> input field give your new session a name, &eg;
+<quote>sources</quote>.</para>
+</step>
+<step>
+<para>Close the dialog with <guibutton>OK</guibutton>. The new session will now
+be listed in the drop down box on the toolbar.</para>
+</step>
+</substeps>
+</step>
+<step>
+<para>This new session will initially be empty. You must populate it with the
+files you want to be kept there.</para>
+<substeps>
+<step>
+<para>Open all files you want to be grouped in this development session. In our
+example we decided to keep <filename>hello.cpp</filename>,
+<filename>hello.h</filename>, and <filename>main.cpp</filename> there as
+planned.</para>
+</step>
+<step>
+<para>Once your file list is complete, click the <guiicon>Save Session</guiicon>
+icon in the toolbar. Do not skip this step, &kdevelop; will forget the file list
+otherwise.</para>
+</step>
+</substeps>
+</step>
+</procedure>
+
+<para>That was it. Whenever you select the <guilabel>sources</guilabel> session
+from the <guilabel>Open Session</guilabel> drop down box, &kdevelop; will close
+all currently open editor windows and open the remembered ones
+(<filename>hello.cpp</filename>, <filename>hello.h</filename>, and
+<filename>main.cpp</filename> in our example) instead.</para>
+
+<para>You can define as many sessions as you wish in the context of your
+project. If you want to change the session&apos;s contents, just update the
+remembered file list with a <guiicon>Save Session</guiicon> click. And if you
+want get rid of a session, select it in the drop down box, then click the
+<guiicon>Delete Session</guiicon> icon in the toolbar right.</para>
+
+<para>There is even more. You can force &kdevelop; to open a given session by
+default when it loads the project. Just select the session in the drop down box
+on the <menuchoice><guimenu>Projects</guimenu> <guimenuitem>Project
+Options</guimenuitem> <guimenuitem>File List</guimenuitem></menuchoice> project
+options configuration page.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="file-list-session-default.png" format="PNG"/>
+</imageobject>
+<caption><para>Let &kdevelop; open a specific session when the project is
+loaded.</para></caption>
+</mediaobject>
+</screenshot>
+</sect3>
+</sect2>
+
+<sect2 id="gettingstarted-edit-problems">
+<title>Keeping an Eye on Common Problems</title>
+
+<para>When you open an editor window containing a source file, &kdevelop; will
+parse its contents. This allows the built in <emphasis>problem
+reporter</emphasis> to scan the source text for some common errors it knows of.
+And it can alert the user of different places which have been marked for special
+treatment.</para>
+
+<para>Let us illustrate this facility with our Hello example project.</para>
+
+<itemizedlist>
+<listitem>
+<para>Open an editor window with the <filename>main.cpp</filename> source
+file.</para>
+</listitem>
+
+<listitem>
+<para>Make sure it still contains the following line somewhere towards the
+end:</para>
+<programlisting>
+        /// @todo do something with the command line args here
+</programlisting>
+<para>This was inserted by the &appwizard; when you created the Hello project in
+the <link linkend="gettingstarted-new">Starting a New Project</link> chapter
+above.</para>
+</listitem>
+
+<listitem>
+<para>Now open the <guilabel>Problems</guilabel> tool view in the bottom tabs
+row. If all went right, it will currently report this todo:</para>
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="problem-report-todo.png"/>
+</imageobject>
+<caption><para>&kdevelop; is alerting a source code line containing a todo
+mark.</para></caption>
+</mediaobject>
+</screenshot>
+</listitem>
+</itemizedlist>
+
+<para>The format of the <computeroutput>/// @todo</computeroutput> command is
+for special treatment by the <application>Doxygen</application> code documenter,
+which we will look at briefly in the <link
+linkend="gettingstarted-doc">Documentation</link> section below. It is not
+mandatory that you use this format, the more common
+<computeroutput>TODO</computeroutput> and <computeroutput>FIXME</computeroutput>
+comment marks will be recognized as well.</para>
+
+<para>If you &eg; insert the following <computeroutput>TODO</computeroutput> and
+<computeroutput>FIXME</computeroutput> comment lines in our
+<filename>hello.cpp</filename> example file</para>
+<programlisting>
+Hello::Hello()
+    : KMainWindow( 0, "Hello" )
+{
+    // set the shell's ui resource file
+    // TODO check the user interface
+    setXMLFile("helloui.rc");
+
+    // FIXME change to a better suited greeting
+    new QLabel( "Hello World", this, "hello label" );
+}
+</programlisting>
+<para>you will find them listed in the <guilabel>Problems</guilabel> tool view
+as well:</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="problem-report-marks.png" format="PNG"/>
+</imageobject>
+<caption><para>The problem reporter listing lines which require attention in the
+currently edited file.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Note the other tabs in the <guilabel>Problem</guilabel> reporter tool view
+window, especially <guilabel>Fixme</guilabel>, and <guilabel>Todo</guilabel>. If
+you open them, you will find all <computeroutput>FIXME</computeroutput> and
+<computeroutput>TODO</computeroutput> marked lines, &kdevelop; has found so far
+in this session. For example the <computeroutput>TODO</computeroutput> alerts
+will currently look thus:</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="problem-report-all-todos.png" format="PNG"/>
+</imageobject>
+<caption><para>The problem reporter has collected the
+<computeroutput>TODO</computeroutput> alerts.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>The <guilabel>Errors</guilabel> tab will however not list every coding
+error you make. This is the job of other tools in &eg; the build process. But
+you will find here alerts of some common programming mistakes which would likely
+go unnoticed otherwise and probably be catched with difficulties during complex
+debugging session.</para>
+
+<para>You will find the &kdevelop; problem reporter facility a very valuable
+tool, so check the <guilabel>Problems</guilabel> tool view regularly in the
+development process.</para>
+</sect2>
+</sect1>
+
+<sect1 id="gettingstarted-compile">
+<title>How to Compile a Project</title>
+
+<para>Compiling a project in &kdevelop; requires several setup steps and then
+building the application. All these are available through the
+<guimenu>Build</guimenu> menu.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="build-menu.png" format="PNG"/>
+</imageobject>
+<caption><para>Building a project requires several steps.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>We are interested for now in the upper section only of this menu. The
+entries there are sorted in order of their importance. Thus the most often
+needed command is on top, the <guimenuitem>Build Project</guimenuitem> entry,
+which will cause all of the project be initialized, compiled and linked as
+needed. Other entries are there to compile selected project portions or a single
+file only, to perform several initialization sequences, or to install the
+completed application binaries.</para>
+
+<para>For now we will concentrate on several facilities which &kdevelop;
+provides for project setup, initializing, building, and running an application.
+In general, this includes:</para>
+
+<simplelist>
+<member><link linkend="gettingstarted-compile-basic">Looking briefly at the
+basic build cycle.</link></member>
+<member><link linkend="gettingstarted-compile-setup">Looking at some basic
+means to configure a project.</link></member>
+</simplelist>
+
+<sect2 id="gettingstarted-compile-basic">
+<title>The Basic Build Cycle</title>
+
+<para>Once you created a new project you usually want to check if everything
+went right so far. This implies a first build and test run of the application,
+which we will do now. In order to initially compile a project there are several
+steps to perform, which we will briefly look at.</para>
+<simplelist>
+<member><link linkend="gettingstarted-compile-basic-init">How to initialize the
+project for a first build.</link></member>
+<member><link linkend="gettingstarted-compile-basic-config">How to do the
+initial configuration.</link></member>
+<member><link linkend="gettingstarted-compile-basic-build">How to build the
+project.</link></member>
+<member><link linkend="gettingstarted-compile-basic-run">How to run the
+application from within &kdevelop;.</link></member>
+</simplelist>
+
+<note>
+<para>This discussion implies that your project is based on the &GNU; autotools,
+which enabled the &automanag; tool in &kdevelop; as our example Hello project
+does. If you created another type project, &eg; for the &Qt; based
+<application>QMake</application> project manager, there will be other facilities
+available in the menus or perhaps even none of them. You will have to consult
+the respective vendor documentation on project management and application
+building in these cases.</para>
+</note>
+
+<sect3 id="gettingstarted-compile-basic-init">
+<title>Initialize the Project for the Build</title>
+
+<para>When the &appwizard; created our Hello example project, it left it in a
+sort of raw, <quote>virgin</quote> state. The &GNU; autotools chain dictates
+several initialization steps to be performed before the application could be
+actually compiled and linked. If you try to build a project in such a raw state,
+&eg; by selecting the <menuchoice><guimenu>Build</guimenu> <guimenuitem>Build
+Project</guimenuitem></menuchoice> menu or pressing the <keycap>F8</keycap>
+function key, you will get the following warning.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="raw-project-warning.png" format="PNG"/>
+</imageobject>
+<caption><para>Trying to build a raw automake based project.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>You may press the <guibutton>Run Them</guibutton> button in which case
+&kdevelop; will try to automatically run all required setup steps prior to
+compiling and linking the application. But we will look at those initial steps
+in sequence, so cancel the dialog by pressing <guibutton>Do Not run</guibutton>.
+</para>
+
+<para>As mentioned already, compiling and linking the application is done
+through the <guimenu>Build</guimenu> menu. Call it up and select
+<guimenuitem>Run automake and friends</guimenuitem>.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="build-menu-automake.png" format="PNG"/>
+</imageobject>
+<caption><para>Initiating a basic initialization run.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>
+&kdevelop; will now open the <guilabel>Messages</guilabel> tool view window at
+the bottom and list a series of messages produced by several make tools. If
+everything went right, the final line will read 
+<quote><computeroutput>*** Success ***</computeroutput></quote>.</para>
+
+<para>If you scroll back to the top, you will find the command line, &kdevelop;
+issued to call up the tools beneath the surface:</para>
+
+<programlisting>
+cd '/home/devel/projects/hello' &amp;&amp; \
+WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -f Makefile.cvs
+</programlisting>
+
+<para>This basically tells that &kdevelop; first switched to the root directory
+of our example project. Then it set up a dedicated environment, advising the
+make system of the <application>autoconf</application> and
+<application>automake</application> tool revisions used for this initialization.
+And finally it instructed the make tool (&GNU; <application>gmake</application>
+in this case) to process the <filename>Makefile.cvs</filename> make file.</para>
+
+<para>This make file was automatically set up when you created the Hello
+project. It contains all the commands necessary to properly initialize the
+project so the resulting application will run under &kde;. Especially this will
+create the <filename>configure</filename> skript file necessary to perform the
+next setup step.</para>
+</sect3>
+
+<sect3 id="gettingstarted-compile-basic-config">
+<title>Initial Hello Configuration</title>
+
+<para>Configuring means to tailor the build process to the hardware and software
+peculiarities of your system. This is a basic requirement in build processes
+based on the &GNU; autotools scheme as you probably will know.</para>
+
+<para>You can command a configure sequence once the basic automake
+initialization has been successfully finished because only after this
+initial run the necessary <filename>configure</filename> files will be
+available. This done, select the <menuchoice><guimenu>Build</guimenu>
+<guimenuitem>Run Configure</guimenuitem></menuchoice> menu entry to initiate a
+configuration sequence.</para>
+
+<para>&kdevelop; opened the <guilabel>Messages</guilabel> tool view
+window again if necessary and listed the messages of the configure run therein.
+If all went right, the final messages will be <quote><computeroutput>Good - your
+configure finished. Start make now</computeroutput></quote> (which was issued by
+configure) followed by the &kdevelop; <quote><computeroutput>*** Success
+***</computeroutput></quote> message.</para>
+
+<para id="gettingstarted-compile-basic-config-cmd">On top of the
+<guilabel>Messages</guilabel> window you will again find
+the command line, &kdevelop; used to initiate this configuration run:</para>
+
+<programlisting>
+mkdir '/home/devel/projects/hello/debug' &amp;&amp; \
+cd '/home/devel/projects/hello/debug' &amp;&amp; \
+CXXFLAGS="-O0 -g3" "/home/devel/projects/hello/configure" --enable-debug=full
+</programlisting>
+
+<para>You can tell several interesting details from these commands.</para>
+
+<informaltable frame="none">
+<tgroup cols="2"><tbody><row>
+<entry>
+<mediaobject>
+<imageobject>
+<imagedata fileref="tutorial-debug-tree.png"/>
+</imageobject>
+</mediaobject>
+</entry>
+<entry>
+<itemizedlist>
+<listitem>
+<para>First, &kdevelop; uses a dedicated subdirectory in the project directory
+tree for the build process. This <filename class="directory">debug</filename>
+build directory (shown to the left) mirrors the basic project structure and
+contains some set of build related files, such as several
+<filename>configure</filename> based files and additionally a
+<filename>Makefile</filename> in each subdirectory.</para>
+</listitem>
+<listitem>
+<para>In the <link linkend="gettingstarted-compile-setup">Configuring the
+Project</link>
+section shortly below we will have a brief look at the motivations why
+&kdevelop; uses separate build directories in cases like this one. For the
+moment it is enough to know that &kdevelop; created this <filename
+class="directory">debug</filename> directory &mdash; if necessary &mdash; prior
+to the configure call and that the <filename>configure</filename> script did
+build the sub structure and all the <filename>Makefiles</filename> in
+there.</para>
+</listitem>
+<listitem>
+<para>Next, from within the <filename class="directory">debug</filename> build
+directory, &kdevelop; called the <filename>configure</filename> script in the
+root directory of our project using a dedicated environment, where the
+<computeroutput>CXXFLAGS="-O0 -g3"</computeroutput> flags will later signal the
+&gcc; compiler that it should not optimize the resulting binaries and include
+full debugging information with them.</para>
+</listitem>
+<listitem>
+<para>Finally the <filename>configure</filename> script was called with the
+<computeroutput>--enable-debug=full</computeroutput> option which instructs it
+to create each <filename>Makefile</filename> so that later compilation and
+linking will have all necessary debugging information be built in and
+usable.</para>
+</listitem>
+</itemizedlist>
+</entry>
+</row></tbody></tgroup>
+</informaltable>
+
+<para>All these settings are configurable on a per project basis. You will learn
+more about this in the <link linkend="project-management">Project
+Management</link> chapter.</para>
+</sect3>
+
+<sect3 id="gettingstarted-compile-basic-build">
+<title>Build the Project</title>
+
+<para>Once you got this far you will be ready to actually build, &ie;
+compile and link the application. Looking at the <guimenu>Build</guimenu> menu,
+there are three such compile options from which to select.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="build-commands.png" format="PNG"/>
+</imageobject>
+<caption><para>&kdevelop; commands to build binaries.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Going from bottom to top, there are:</para>
+<itemizedlist>
+<listitem>
+<para><guimenuitem>Compile File</guimenuitem> &mdash; This will compile the
+source file in the currently open editor window. Mostly used for quick error
+checks.</para>
+</listitem>
+<listitem>
+<para><guimenuitem>Build Active Target</guimenuitem> &mdash; This is mainly used
+in conjunction with the <link linkend="gettingstarted-extend-automake">Automake
+Manager</link> which we will briefly look at below.</para>
+</listitem>
+<listitem>
+<para><guimenuitem>Build Project</guimenuitem> &mdash; Now this is what we
+currently are interested in. It will iterate over the whole project, compiling
+and linking all files as necessary.</para>
+</listitem>
+</itemizedlist>
+
+<para>It might be interesting to watch what happens to the 
+<filename class="directory">Debug</filename> directory created in the former
+<filename>configure</filename> run. So best keep it open with all
+subdirectories unfolded just as shown above. Then select
+<menuchoice><guimenu>Build</guimenu> <guimenuitem>Build
+Project</guimenuitem></menuchoice> (or press the <keycap>F8</keycap> key) to
+initiate the build sequence. As before, the <guilabel>Messages</guilabel> tool
+view window will open at the bottom and list the outcome of this build run. And
+additionally some files will appear on the <filename
+class="directory">Debug</filename> subtree.</para>
+
+<para id="gettingstarted-compile-basic-build-cmd">There are not many source
+files in our Hello example project, so the <guilabel>Messages</guilabel> window
+will contain only a few lines. On top of them again find the command line
+&kdevelop; issued to the underlying shell.</para>
+
+<programlisting>
+cd '/home/devel/projects/hello/debug' &amp;&amp; \
+WANT_AUTOCONF_2_5="1" WANT_AUTOMAKE_1_6="1" gmake -k 
+</programlisting>
+
+<para>Not very surprisingly, &kdevelop; switched to the <filename
+class="directory">Debug</filename> subtree root in order to run the
+<filename>Makefile</filename> located there. A dedicated sub-environment was
+set up again as before in the <link
+linkend="gettingstarted-compile-basic-init">Initialization step</link> in which
+then the <application>gmake</application> tool was called.</para>
+
+<para>Note the <computeroutput>-k</computeroutput> option in the
+<application>gmake</application> call. It forces the build process to continue
+up to its very end, even if errors will occur. This makes sense as &kdevelop;
+will list all error messages in the <guilabel>Messages</guilabel> window. If
+there are any, use the virtues of an &IDE;: Just click on the error message in
+the <guilabel>Messages</guilabel> window and &kdevelop; will take you to
+exactly the position where the error occurred in the source file.</para>
+
+<para>And what did happen inside the <filename
+class="directory">Debug</filename> subtree? Not very much. A few files showed up
+on the <filename class="directory">doc/en</filename> and <filename
+class="directory">src</filename> branches, most notably the
+<filename>hello</filename> file in <filename
+class="directory">/home/devel/projects/hello/debug/src/</filename>. This,
+finally, is the application binary we were looking for. All what is left
+to do in our initial project check is to run this
+<filename>hello</filename>.</para>
+</sect3>
+
+<sect3 id="gettingstarted-compile-basic-run">
+<title>Run the Application</title>
+
+<para>There are no extra steps involved to run this new Hello
+application. Either select <menuchoice><guimenu>Build</guimenu>
+<guimenuitem>Execute Program</guimenuitem></menuchoice> or press
+<keycombo><keycap>Shift</keycap> <keycap>F9</keycap></keycombo> or use the
+<guibutton>Execute program</guibutton> button on the <guilabel>Build
+Toolbar</guilabel> shown below.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="run-button.png"/>
+</imageobject>
+<caption><para>Running an application form the <guilabel>Build
+Toolbar</guilabel>.</para>
+</caption>
+</mediaobject>
+</screenshot>
+
+<para>That was all. &kdevelop; will now start the new application in
+the dedicated console window which opens as <guilabel>Application</guilabel>
+tool view on the bottom. There the command &kdevelop; issued to execute the
+program will be shown in the top line:</para>
+
+<programlisting>
+./hello
+</programlisting>
+
+<para>showing that the &IDE; has a notion about where the executable it
+shall run resides. This notion can be widely configured. See more about
+this in the <link linkend="project-management">Project
+Management</link> chapter.</para>
+
+<para>The <computeroutput>./hello</computeroutput> line will most likely
+be followed by a warning message. Ignore this for now. It does not keep
+our <application>Hello</application> form running.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="hello-world-app.png" format="PNG"/>
+</imageobject>
+<caption>
+<para>Our initial <application>Hello</application> application.</para>
+</caption>
+</mediaobject>
+</screenshot>
+
+<para>Close the <application>Hello</application> application window as
+usual. If no errors occurred, &kdevelop; will report this as
+<quote><computeroutput>*** Exited normally ***</computeroutput></quote>
+in the <guilabel>Application</guilabel> tool view window.</para>
+</sect3>
+</sect2>
+
+<sect2 id="gettingstarted-compile-setup">
+<title>Configuring the Project</title>
+
+<para>In &kdevelop; there are numerous ways how you can manage your project.
+This behavior is configurable on a per-project basis and mostly of interest to
+the advanced developer. Yet there are a few project specific settings you
+should know of right from the beginning.
+</para>
+
+<simplelist>
+<member><link linkend="gettingstarted-compile-setup-build">Of what use are build
+configurations?</link></member>
+
+<member><link linkend="gettingstarted-compile-setup-config">Where to the define
+the behavior of the <filename>configure</filename> script.</link></member>
+
+<member><link linkend="gettingstarted-compile-setup-make">Some considerations
+how <application>make</application> should run.</link></member>
+
+<member><link linkend="gettingstarted-compile-setup-run">Where should the
+executable be and how should it be called?</link></member>
+</simplelist>
+
+<sect3 id="gettingstarted-compile-setup-build">
+<title>Build Configurations</title>
+
+<para>When we did a first run of the <filename>configure</filename> script in
+the <link linkend="gettingstarted-compile-basic-config">Initial Hello
+Configuration</link> section above, we noted that &kdevelop; had set up a
+dedicated <filename class="directory">debug</filename> subdirectory for this
+purpose. In this section we will briefly consider some consequences of
+this feature.</para>
+
+<para>First of all, &kdevelop; does not necessarily use dedicated build
+directories apart from the source. The preparations to automatically use
+dedicated build configurations is done through templates the &appwizard; uses
+when creating a new project.</para>
+
+<para>To find out which build configurations currently are available, have a
+look at the <menuchoice><guimenu>Project</guimenu> <guisubmenu>Build
+Configuration</guisubmenu></menuchoice> menu.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="build-configurations.png" format="PNG"/>
+</imageobject>
+<caption><para>There are various build configurations available
+for this project.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>In this case, like our Hello example project, there are three different
+build configurations available. In other cases, there may &mdash; initially
+&mdash; be only one such build configuration, namely
+<guimenuitem>default</guimenuitem>.</para>
+
+<para>The currently used build configuration has a check mark left to it. In
+order to switch to another build configuration simply select its menu
+entry.</para>
+
+<para>Now let us have a brief look at what these build configurations
+provide.</para>
+
+<variablelist id="gettingstarted-compile-setup-build-configs">
+<varlistentry>
+<term><guimenuitem>debug</guimenuitem></term>
+<listitem>
+<para>You should use this as the standard build configuration during the
+development process. The build occurs separately from the source directories in
+the dedicated <filename class="directory">debug</filename> subdirectory, &ie;
+all object, auxiliary, and executable files will be put in the subdirectories
+there instead of their counterparts in the project root. The
+<filename>configure</filename> script will be given the
+<computeroutput>--enable-debug=full</computeroutput> option and the
+<computeroutput>CXXFLAGS="-O0 -g3"</computeroutput> will signal the &gcc;
+compiler to not optimize the code and to insert extensive debug information
+into the resulting binaries.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenuitem>optimized</guimenuitem></term>
+<listitem>
+<para>This is used to build a final C++ application. The build occurs
+separately from the source directories in the dedicated <filename
+class="directory">optimized</filename> subdirectory. No specific arguments to
+the <filename>configure</filename> script will be preset, yet the
+<computeroutput>CXXFLAGS="-O2 -g0"</computeroutput> will signal the &gcc;
+compiler to optimize the code and to not insert debug information into the
+resulting binaries.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><guimenuitem>default</guimenuitem></term>
+<listitem>
+<para>The term <quote>default</quote> denotes the standard setup when you build
+an application from the console using &eg; the &GNU;
+<application>configure</application> and
+<application>make</application>/<application>gmake</application> command line
+oriented build tools. Other than <guimenuitem>debug</guimenuitem> or
+<guimenuitem>optimize</guimenuitem> no dedicated build directory will be used.
+The application will by default be built in the sources directories instead.
+There are no special configuration switches predefined. Building and running the
+application will use the default settings of the underlying tools (e.g. &gcc;,
+etc.).</para>
+
+<warning>
+<para>Think twice before you decide to use the
+<guimenuitem>default</guimenuitem> build environment!</para>
+
+<para>It cannot be used in parallel to the dedicated
+<guimenuitem>debug</guimenuitem> or <guimenuitem>optimized</guimenuitem> ones.
+<emphasis>Any build operation using <guimenuitem>default</guimenuitem> will
+render both of the other build environments unusable.</emphasis> This is caused
+by some peculiarities of the <filename>Makefile</filename> construction process
+using the
+<application>automake</application>/<application>autoconf</application>
+machinery, which cannot be easily overcome.</para>
+</warning>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<para>Now, why does one one want to use different build configurations at all,
+when they even appear to be not compatible to each other? The answer is &mdash;
+it simplifies edit-compile-debug cycles. The extra debug instructions
+inserted into the binaries as well as all those subtle structure changes to
+the program code made during optimizations will effect the run time behavior of
+the resulting application. So in many cases, when the logical structure of some
+routine appears to be correct, you may want to test whether it still behaves
+correctly under more practical conditions.</para>
+
+<para>This is where the build configurations of &kdevelop; step in. Because
+the built object and executable files in each dedicated build directory and the
+build commands are kept separately from each other only source changes need
+to be handled when you switch between these build configurations.</para>
+
+<para>Thus instead of cleaning up and recompile everything from scratch with
+alternate options, you need only switch from the
+<guimenuitem>debug</guimenuitem> to the <guimenuitem>optimize</guimenuitem>
+build configuration, have the source changes compiled in and then retest the
+application under these circumstances. If anything inappropriate shows up,
+simply switch back to <guimenuitem>debug</guimenuitem> and immediately continue
+your work there.</para>
+
+<para>A final note &mdash; many build configuration settings are configurable.
+You can even define your own build configurations if your development process
+requires some. We will briefly look at these possibilities in the next
+section.</para>
+</sect3>
+
+<sect3 id="gettingstarted-compile-setup-config">
+<title>Project Configure Options</title>
+
+<para>Configuring the application properly is vital in the &GNU;
+autotools building chain. This is usually guided by option definitions to the
+<filename>configure</filename> script and/or specific flags settings in the
+environment prior to running <filename>configure</filename> as &eg; the
+<computeroutput>CXXFLAGS</computeroutput> in our previous discussions.</para>
+
+<para>You may set most of the configuring options for a given project from
+within &kdevelop; &GUI;. Select
+<menuchoice><guimenu>Project</guimenu>
+<guimenuitem>Project Options</guimenuitem></menuchoice> and then from the
+icon bar on the left of the dialog the <guiicon>Configure Options</guiicon>
+icon. The <guilabel>Configure Options</guilabel> dialog featuring several tabbed
+windows will display on the right handed side.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="configure-project-configure.png" format="PNG"/>
+</imageobject>
+<caption><para>Most configure options can be defined here.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>As you see, there are quite a lot of options you can set up in this
+dialog. For now we will briefly look at only a few of them with regard to our
+Hello example project. For detailed instructions see the <link
+linkend="projects-configure">Configuring Projects</link> chapter. If you
+want to know more about the meaning of the various flags which can be
+set, look up <command>info make</command> from the console (or
+<command>info:make</command> from within &konqueror;) and there the
+<menuchoice><guimenu>Implicit Rules</guimenu>
+<guimenuitem>Implicit Variables</guimenuitem></menuchoice> section.</para>
+
+<para>There are several tabbed dialog setup windows from which the first
+one, <guilabel>General</guilabel>, refers to commonly used settings,
+while the others are rather compiler specific. In all cases, however, will the
+actual contents of those dialogs be governed by the given build
+configuration.</para>
+
+<para>You select the build configuration whose configuration settings
+have to be defined from the <guilabel>Configuration</guilabel> combo box
+on top of the <guilabel>Configure Options</guilabel> dialog.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="configure-project-buildconfig.png" format="PNG"/>
+</imageobject>
+<caption><para>Select the build configuration whose settings to
+define.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Now select another build configuration from this combo box and note how
+the contents of &eg; the <guilabel>Configure arguments</guilabel> and
+<guilabel>Build directory</guilabel> text boxes change according to the
+settings we mentioned in the <link
+linkend="gettingstarted-compile-setup-build-configs"> build
+configurations list</link> above.</para>
+
+<sect4 id="gettingstarted-compile-setup-config-general">
+<title>General Configuration Settings</title>
+
+<para>On the <guilabel>General</guilabel> dialog page, these
+configuration options can be defined:</para>
+
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>Configure arguments</title>
+<para>These are the options &kdevelop; assigns to the
+<filename>configure</filename> script call in the build process. See the
+<link linkend="gettingstarted-compile-basic-config-cmd">example</link> in
+the <quote>Initial Hello Configuration</quote> section above.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Build directory</title>
+<para>This is the subdirectory in the current project root, where &kdevelop; 
+will put all files created in the build process. Ideally, this should
+correspond to the name of the build configuration in use, but you are
+free to use any name you like, provided it is different from any other
+build configuration directory.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Top source directory</title>
+<para>You won&apos;t need this one often. It defaults to the project root
+directory and needs only be redefined if your project sources are located
+in another place.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>C/C++ preprocessor flags (CPPFLAGS)</title>
+<para>Put specific instructions for the preprocessor here. &kdevelop; will
+use this to set up a temporary environment before it calls the actual
+build tool. Again, see the <link
+linkend="gettingstarted-compile-basic-config-cmd">example</link> in
+the <quote>Initial Hello Configuration</quote> section above how this is
+done.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Linker flags (LDFLAGS)</title>
+<para>This is extra information for the <application>ld</application> linker
+tool where it should look for additional libraries. It is used to build the
+temporary build environment as well.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Environment Variables</title>
+<para>Here you may define additional variables to be set up in the
+temporal build environment, &kdevelop; will set up before calling the
+respective build tool. Again, you must define these environment variables for
+every build configuration where they are to be used.</para>
+</formalpara>
+</listitem>
+</itemizedlist>
+</sect4>
+
+<sect4 id="gettingstarted-compile-setup-config-spec">
+<title>Compiler Specific Settings</title>
+
+<para>The other tabs on the <guilabel>Configure Options</guilabel> dialog
+page are for compiler specific settings. They are similarly structured,
+so it suffices to have a brief look at the <guilabel>C++</guilabel> page.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="configure-project-cpp.png" format="PNG"/>
+</imageobject>
+<caption><para>Select the compiler and its working environment &kdevelop; shall
+use here.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>This is what you can set up from here:</para>
+
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>C++ compiler</title>
+<para>Select the C++ compiler &kdevelop; should regularly use from this
+combo box. It however lists only those compilers &kdevelop; really knows
+of.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Compiler command (CXX)</title>
+<para>Only for experts. This is only needed if the C++ compiler is not standard.
+Put the name by which it is called here.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Compiler flags (CXXFLAGS)</title>
+<para>Here you can enter any extra option &kdevelop; shall pass (via the
+<filename>Makefile</filename>) to the compiler. Some option values will be
+preset according to the build configuration selected in the
+<guilabel>Configuration</guilabel> combo box.</para>
+</formalpara>
+
+<para>Note, that many common compiler options can be selected from a
+dialog which will pop up when you press the <guibutton>...</guibutton> button to
+the right of the text box.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="configure-project-cppoptions.png" format="PNG"/>
+</imageobject>
+<caption><para>Use this dialog to define the &GNU; C++ compiler
+behavior.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>We deliberately selected the <guilabel>Optimization</guilabel> tab
+here. Note how the <guilabel>No Optimization</guilabel> option has been
+preselected (according to the <computeroutput>-O0</computeroutput>
+option preset in the <computeroutput>debug</computeroutput> build
+configuration).</para>
+
+<para>Unfortunately you cannot currently select all options from this
+dialog. The <computeroutput>-g3</computeroutput> option &eg; used by the
+<computeroutput>debug</computeroutput> build
+configuration would have to be altered manually if ever needed.</para>
+</listitem>
+</itemizedlist>
+</sect4>
+</sect3>
+
+<sect3 id="gettingstarted-compile-setup-make">
+<title>How Make Should Build the Program</title>
+
+<para>You can as well configure the way &kdevelop; will call the
+<application>make</application> tool in the project build. Select
+<menuchoice><guimenu>Project</guimenu>
+<guimenuitem>Project Options</guimenuitem></menuchoice> and then the
+<guiicon>Make Options</guiicon> icon from the left dialog window side. The
+<guilabel>Make Options</guilabel> dialog page will then be displayed to
+the right.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="configure-project-make.png" format="PNG"/>
+</imageobject>
+<caption><para>Define how &kdevelop; will call the
+<application>make</application> tool.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>There is not much to do here for now. The only setting of interest in
+most cases will be the <guilabel>Abort on first error</guilabel> switch.
+You will find it deactivated in most projects. This corresponds to the
+<computeroutput>-k</computeroutput> option in the
+<application>gmake</application> call we found in the <link
+linkend="gettingstarted-compile-basic-build-cmd">initial build</link> of
+our example Hello project.</para>
+
+<para>This makes sense in an &IDE; like &kdevelop; which will protocol any
+error message during the build. After the build process you may easily
+navigate to any error message in the <guilabel>Messages</guilabel> tool
+window. Use <menuchoice><guimenu>View</guimenu>
+<guimenuitem>Next Error</guimenuitem></menuchoice> and
+<menuchoice><guimenu>View</guimenu> <guimenuitem>Previous
+Error</guimenuitem></menuchoice> or respectively the <keycap>F4</keycap> and
+<keycombo><keycap>Shift</keycap> <keycap>F4</keycap></keycombo> keys for this.
+&kdevelop; will automatically activate the editor window of the source file in
+question and put the cursor on the error line.</para>
+
+<para>If on the other hand you rather want the build be stopped on whenever an
+error occurs, check the <guilabel>Abort on first error</guilabel> option
+in this dialog. &kdevelop; will then call <application>gmake</application>
+without the <computeroutput>-k</computeroutput> option.</para>
+</sect3>
+
+<sect3 id="gettingstarted-compile-setup-run">
+<title>How to Run the Executable</title>
+
+<para>Once the build is complete, you can easily run the application from within
+&kdevelop;. Use either <menuchoice><guimenu>Build</guimenu>
+<guimenuitem>Execute Program</guimenuitem></menuchoice>, the
+<keycombo><keycap>Shift</keycap> <keycap>F9</keycap></keycombo> keys, or the
+<guibutton>Execute program</guibutton> button in the <guilabel>Build
+Toolbar</guilabel> of &kdevelop;.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="run-button.png" format="PNG"/>
+</imageobject>
+<caption><para>Run the program from here.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>But where is the executable located which should be run? How does
+one have &kdevelop; append options to the call? Or, how can I have the
+application executed in a terminal by its own to test its console interactive
+behavior?</para>
+
+<para>All this can be solved by configuring some project oriented run options in
+&kdevelop;. Select <menuchoice><guimenu>Project</guimenu>
+<guimenuitem>Project Options</guimenuitem></menuchoice> and then the
+<guiicon>Run Options</guiicon> icon from the icon bar on the left dialog window
+side. The <guilabel>Run Options</guilabel> dialog page will display to the
+right.</para>
+
+<screenshot>
+<mediaobject>
+<imageobject>
+<imagedata fileref="configure-project-run.png" format="PNG"/>
+</imageobject>
+<caption><para>Define where and how your program shall be run.</para></caption>
+</mediaobject>
+</screenshot>
+
+<para>Now, there is quite a lot which can be set up from this dialog.
+Basically there are four groups of configuration items.</para>
+
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>Directory</title>
+<para>This tells &kdevelop; where it basically shall assume the
+executable to be called. There are three possibilities you can select
+from.</para>
+</formalpara>
+
+<para>Note however that only root directories are defined here.
+&kdevelop; usually looks for the executable in some subdirectory
+given in the next configuration group.</para>
+
+<itemizedlist>
+<listitem>
+<para>Run from the directory, where the executable was build the last
+time. This is the default. You can keep this for now.</para>
+</listitem>
+
+<listitem>
+<para>Run from the build directory according to the currently selected
+<link linkend="gettingstarted-compile-setup-build">build configuration</link>.
+The name of this directory was set up on the <link
+linkend="gettingstarted-compile-setup-config-general">General
+Configuration</link> dialog page.</para>
+
+<para>This is the root where &kdevelop; will find the executable. It
+changes automatically with the selection you made in
+<menuchoice><guimenu>Project</guimenu>
+<guisubmenu>Build Configurations</guisubmenu></menuchoice> menu. Try it.</para>
+
+<para>Other than always running the most recently built executable according to
+the setting above, this allows you to switch the program to be executed by
+simply selecting another build configuration from the <guimenu>Project</guimenu>
+menu.</para>
+</listitem>
+
+<listitem>
+<para>Run the executable found in a fixed custom directory. Again
+this is the root only from where the actual executable is to be
+found.</para>
+
+<para>Use this if you &eg; want to run the actually installed program instead of
+the version located in the project directories.</para>
+</listitem>
+</itemizedlist>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Program</title>
+<para>This tells &kdevelop; the relative position and name of the
+program it shall actually call. This is relative to the root directory
+defined in the configuration group above. Furthermore you can define any
+argument &kdevelop; will pass to the program when it is actually called.</para>
+</formalpara>
+
+<note>
+<para>If leave the <guilabel>Main program</guilabel> text box empty, the
+<emphasis>active target</emphasis> settings of the &automanag; will be used.
+Although this is an expert setting, inadvertently leaving this input
+field blank is a common cause of problems. Check this setting if &kdevelop;
+appears not to call the executable you wanted.</para>
+</note>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Environment Variables</title>
+<para>&kdevelop; will set up a dedicated shell environment to run the
+program in. Define any extra environment variable in this configuration
+group.</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>Miscellaneous</title>
+<para>Two more check boxes are located at the bottom of this dialog page.</para>
+</formalpara>
+
+<itemizedlist>
+<listitem>
+<para><guilabel>Automatically compile before execution</guilabel> comes
+in handy most of time. &kdevelop; will check the project for changes and
+perform necessary configure and build steps for you any time you command
+it to run the program.</para>
+
+<para>Uncheck this in case you want to run the program version prior to the
+last change.</para>
+</listitem>
+
+<listitem>
+<para><guilabel>Start in external terminal</guilabel> is interesting if
+you want to test the input/output behavior of non-&GUI; programs in a console
+terminal. This is unchecked by default, so &kdevelop; does start the program in
+a window of its own without console terminal I/O capabilities.</para>
+</listitem>
+</itemizedlist>
+</listitem>
+</itemizedlist>
+</sect3>
+</sect2> 
+</sect1>
+
+<sect1 id="gettingstarted-extend">
+<title>How to Extend a Project &mdash; the &automanag;</title>
+
+<para>(- to be written -)</para>
+
+<sect2 id="gettingstarted-extend-automake">
+<title>A Short Look at the Automake Machinery</title>
+
+<para>(- to be written -)</para>
+</sect2> 
+
+<sect2 id="gettingstarted-extend-pics">
+<title>How to Place Icons in a Separate Directory</title>
+
+<para>(- to be written -)</para>
+</sect2> 
+
+<sect2 id="gettingstarted-extend-class">
+<title>How to Add New Classes</title>
+
+<para>(- to be written -)</para>
+
+<caution><para>
+Be careful when you select your class file names. It is extremely difficult to
+change them later.</para></caution>
+</sect2> 
+
+<sect2 id="gettingstarted-extend-subproject">
+<title>What is in a Subproject?</title>
+
+<para>(- to be written -)</para>
+
+<sect3 id="gettingstarted-extend-subproject-active">
+<title>Concentrate on Your Work &mdash; the Active Target</title>
+
+<para>(- to be written -)</para>
+</sect3> 
+</sect2> 
+
+<sect2 id="gettingstarted-extend-restructure">
+<title>Some Steps to Restructure a Project</title>
+
+<para>(- to be written -)</para>
+</sect2> 
+</sect1>
+
+
+<sect1 id="gettingstarted-debug">
+<title>How to Debug</title>
+
+<para>(- to be written -)</para>
+</sect1> 
+
+
+<sect1 id="gettingstarted-doc">
+<title>A Note on Your Project Documentation</title>
+
+<para>The &kde; project uses <ulink
+url="http://www.docbook.org/tdg5/en/html/docbook.html">docbook</ulink> for
+generating your project handbook (&ie; the user manual). The user manual is
+available through your application menubar by choosing
+<menuchoice><guimenu>Help</guimenu>
+<guimenuitem><replaceable>YourApplication</replaceable>
+Handbook</guimenuitem></menuchoice > when your &kde; GUI application is running.
+After building your project, the user manual is displayed in &kde;
+&khelpcenter;. It should explain to the user how your application works, what
+are the main features and how to configure it. It should also explain the
+advanced features if any.
+</para>
+<para>All &kde; based templates in &kdevelop; have a doc subdir which contains
+a <filename>index.docbook</filename> template in the en folder to get you
+started in writing the user manual. You should edit this
+<filename>index.docbook</filename> in &kdevelop; and start changing personal
+details such as name, email, &etc;. Look at the comments in this file and try
+following these indications to start your application documentation. Rebuild
+your project to see the changes in &khelpcenter;.</para>
+<note><para>You need to install your project using
+<menuchoice><guimenu>Build</guimenu>
+<guimenuitem>Install</guimenuitem></menuchoice > or <guimenuitem>Install (as
+root user)</guimenuitem> in &kdevelop; to see the user manual in
+&khelpcenter;.</para></note>
+<para>You can find more about the docbook syntax on <ulink
+url="http://l10n.kde.org/docs/markup/index.html">the &kde; documentation
+website</ulink>.</para>
+</sect1>
+
+<sect1 id="gettingstarted-keys">
+<title>Last But Not Least, Keyboard Shortcuts</title>
+
+<para>(- to be written -)</para>
+</sect1>
+
+<sect1 id="gettingstarted-whereto">
+<title>Where to go from here</title>
+
+<para>(- to be written -)</para>
+
+<sect2 id="gettingstarted-whereto-faq">
+<title>Frequently Encountered Problems</title>
+
+<simplelist>
+<member>The nutshell chapter</member>
+<member>FAQ pages</member>
+<member>Forum</member>
+<member>Mailing lists</member>
+</simplelist>
+</sect2>
+
+<sect2 id="gettingstarted-whereto-projects">
+<title>Working With Projects</title>
+
+<para>(- to be written -)</para>
+
+<sect3 id="gettingstarted-whereto-projects-open">
+<title>Using Existing &kdevelop; Projects</title>
+
+<para>(- to be written -)</para>
+</sect3>
+
+<sect3 id="gettingstarted-whereto-projects-import">
+<title>Importing External Projects</title>
+
+<para>(- to be written -)</para>
+</sect3>
+</sect2>
+</sect1>
+
+</chapter>
diff --git a/doc/kdevelop/hello-world-app.png b/doc/kdevelop/hello-world-app.png
new file mode 100644
index 00000000..6f2ab007
--- /dev/null
+++ b/doc/kdevelop/hello-world-app.png
diff --git a/doc/kdevelop/importdirectory.png b/doc/kdevelop/importdirectory.png
new file mode 100644
index 00000000..3d0372ad
--- /dev/null
+++ b/doc/kdevelop/importdirectory.png
diff --git a/doc/kdevelop/index.docbook b/doc/kdevelop/index.docbook
new file mode 100644
index 00000000..993400c0
--- /dev/null
+++ b/doc/kdevelop/index.docbook
@@ -0,0 +1,372 @@
+<?xml version="1.0" ?>
+<!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.1.2-Based Variant V1.1//EN" "dtd/kdex.dtd" [
+<!--   <!ENTITY kdevelop "<application>KDevelop</application>"> -->
+  <!ENTITY kdevelop "KDevelop">
+  <!ENTITY kdevrelease "3.3.91">
+
+  <!-- abbreviations used in the body text -->
+  <!ENTITY apache "<application>Apache</application>">
+  <!ENTITY API "<acronym>API</acronym>">
+  <!ENTITY appwizard "Application Wizard">
+  <!ENTITY autoconf "<command>autoconf</command>">
+  <!ENTITY automake "<command>automake</command>">
+  <!ENTITY automanag "Automake Manager">
+  <!ENTITY ctags "<command>ctags</command>">
+  <!ENTITY CVS "<application>CVS</application>">
+  <!ENTITY cvs "CVS">
+  <!ENTITY doxygen "<application>Doxygen</application>">
+  <!ENTITY doxywizard "<application>doxywizard</application>">
+  <!ENTITY egrep "<command>egrep</command>">
+  <!ENTITY grep "<command>grep</command>">
+  <!ENTITY HTML "<acronym>HTML</acronym>">
+  <!ENTITY IDE "<acronym>IDE</acronym>">
+  <!ENTITY libtool "<command>libtool</command>">
+  <!ENTITY nfwizard "New File Wizard">
+  <!ENTITY python "<application>Python</application>">
+  <!ENTITY perl "<application>Perl</application>">
+  <!ENTITY php "<application>PHP</application>">
+  <!ENTITY promanag "Project Manager">
+  <!ENTITY qte "<application>Qt/embedded</application>">
+  <!ENTITY ssh "<application>ssh</application>">
+
+  <!-- chapters in separate docbook files -->
+  <!ENTITY survey-manual SYSTEM "survey-manual.docbook">
+  <!ENTITY getting-started SYSTEM "getting-started.docbook">
+  <!ENTITY kdevelop-survey SYSTEM "kdevelop-survey.docbook">
+  <!ENTITY setup SYSTEM "setup.docbook">
+  <!ENTITY applicationwizard SYSTEM "applicationwizard.docbook">
+  <!ENTITY editing SYSTEM "editing.docbook">
+  <!ENTITY file-browsers SYSTEM "file-browsers.docbook">
+  <!ENTITY class-browsers SYSTEM "class-browsers.docbook">
+  <!ENTITY documentation SYSTEM "documentation.docbook">
+  <!ENTITY project-management SYSTEM "project-management.docbook">
+  <!ENTITY adv-build-management SYSTEM "adv-build-management.docbook">
+  <!ENTITY debugger SYSTEM "debugger.docbook">
+  <!ENTITY cvs-chapter SYSTEM "cvs.docbook">
+  <!ENTITY external-progs SYSTEM "external-progs.docbook">
+  <!ENTITY scripts SYSTEM "scripts.docbook">
+  <!ENTITY credits SYSTEM "credits.docbook">
+  <!ENTITY kdevelop-scripting SYSTEM "kdevelop-scripting.docbook">
+
+  <!-- appendices in separate docbook files -->
+  <!ENTITY kdevelop-install SYSTEM "kdevelop-install.docbook">
+  <!ENTITY nutshell SYSTEM "nutshell.docbook">
+  <!ENTITY unixdev SYSTEM "unixdev.docbook">
+  <!ENTITY app-menu SYSTEM "app-menu.docbook">
+  <!ENTITY app-shortcuts SYSTEM "app-shortcuts.docbook">
+  <!ENTITY app-files SYSTEM "app-files.docbook">
+  <!ENTITY plugin-tools SYSTEM "plugin-tools.docbook">
+  <!ENTITY app-uimodes-examples SYSTEM "app-uimodes-examples.docbook">
+  <!ENTITY commands SYSTEM "commands.docbook">
+  <!ENTITY app-misc-info SYSTEM "app-misc-info.docbook">
+  <!ENTITY app-changelog SYSTEM "app-changelog.docbook">
+  <!ENTITY app-bibliography SYSTEM "app-bibliography.docbook">
+
+  <!-- book related entities -->
+  <!ENTITY kappname "&kdevelop;">
+  <!ENTITY % addindex "INCLUDE">
+  <!ENTITY % English "INCLUDE" > <!-- change language only here -->
+]>
+
+<!--
+NOTE:
+Entries which require special treatment are marked with comments starting with '###'. They should be visited on a regular basis.
+-->
+
+<book lang="&language;">
+
+<bookinfo>
+  <title>&kdevelop; User Manual</title>
+
+  <date>2006-06-19</date>
+  <releaseinfo>&kdevrelease;</releaseinfo>
+
+  <authorgroup>
+    <author>
+      <firstname>Bernd</firstname>
+      <surname>Gehrmann</surname>
+      <affiliation>
+        <address><email>bernd@kdevelop.org</email></address>
+      </affiliation>
+    </author>
+
+    <author>
+      <firstname>Caleb</firstname>
+      <surname>Tennis</surname>
+      <affiliation>
+        <address><email>caleb@aei-tech.com</email></address>
+      </affiliation>
+    </author>
+
+    <author>
+      <firstname>Bernd</firstname>
+      <surname>Pol</surname>
+      <affiliation>
+        <address><email>bernd.pol@online.de</email></address>
+      </affiliation>
+    </author>
+
+    <author>
+      <firstname>Volker</firstname>
+      <surname>Paul</surname>
+      <affiliation>
+        <address><email>volker.paul@tiscali.de</email></address>
+      </affiliation>
+    </author>
+  </authorgroup>
+
+  <copyright>
+    <year>2002</year>
+    <holder>Bernd Gehrmann</holder>
+  </copyright>
+  <copyright>
+    <year>2002</year>
+    <holder>Caleb Tennis</holder>
+  </copyright>
+  <copyright>
+    <year>2004</year>
+    <holder>Bernd Pol</holder>
+  </copyright>
+  <copyright>
+    <year>2005</year>
+    <holder>Volker Paul</holder>
+  </copyright>
+
+  <!-- TRANS:ROLES_OF_TRANSLATORS -->
+
+  <legalnotice>&FDLNotice;</legalnotice>
+
+  <abstract>
+    <para>&kdevelop; is an Integrated Development Environment to be used for a wide variety of programming tasks.</para>
+  </abstract>
+
+  <keywordset>
+    <keyword>KDE</keyword>
+    <keyword>KDevelop</keyword>
+    <keyword>IDE</keyword>
+    <keyword>development</keyword>
+    <keyword>programming</keyword>
+  </keywordset>
+
+</bookinfo>
+
+<!-- ====================================================================== -->
+
+&survey-manual;
+&getting-started;    <!-- "Getting Started"                                 -->
+&kdevelop-survey;    <!-- "Overview of &kdevelop; Features"                 -->
+&setup;              <!-- "Configuring &kdevelop;"                          -->
+&applicationwizard;  <!-- "Getting Started &mdash; the &appwizard;"         -->
+&editing; 
+&file-browsers; 
+&class-browsers; 
+&documentation; 
+&project-management; 
+&adv-build-management; 
+&debugger; 
+&cvs-chapter; 
+<!--&kdevelop-scripting;--> <!-- "Scripting &kdevelop;"                            -->
+&credits; 
+
+<!-- ====================================================================== -->
+<!-- External Appendices -->
+
+&kdevelop-install;   <!-- "Installing &kdevelop;"                           -->
+&nutshell; 
+&unixdev;            <!-- "Development on &UNIX;"                           -->
+<!--
+&app-menu; 
+&app-shortcuts; 
+-->
+&app-files; 
+&plugin-tools; 
+&app-uimodes-examples; 
+&commands;
+&app-misc-info; 
+&app-changelog; 
+
+<!-- ====================================================================== -->
+<!-- ### Questionable, probably not IDE-specific enough. Check later again.
+<chapter id="python">
+<title>Python</title>
+
+<para>...
+</para>
+
+</chapter> --> <!-- python -->
+
+<!-- ====================================================================== -->
+<!-- ### Questionable, probably not IDE-specific enough. Check later again.
+<chapter id="php">
+<title>PHP</title>
+
+<para>...
+</para>
+</chapter> --> <!-- php -->
+
+<!-- ====================================================================== -->
+
+<!--  Note (bp, 2003-09-04): <bibliography> should remain the last appendix -->
+<!--  section because of a (meinproc???) bug which sends the Next selection -->
+<!--  in circles back to it. -->
+<!-- (LWatts: 2005-04-30) This is probably due to a missing id= somewhere, -->
+<!-- so I've added a couple in hopes it goes away. -->
+
+<appendix id="app-bibliography">
+<title>Bibliography</title>
+
+<para>(... to be written ...)</para>
+
+<bibliography id="bibliography">
+
+<biblioentry>
+<title><ulink url="info://make/Top">GNU Make Manual</ulink></title>
+<authorgroup>
+<author><firstname>Richard M.</firstname><surname>Stallman</surname></author>
+<author><firstname>Roland</firstname><surname>McGrath</surname></author>
+</authorgroup>
+</biblioentry>
+
+<biblioentry>
+<title><ulink url="info://automake/Top">GNU Automake</ulink></title>
+<authorgroup>
+<author><firstname>David</firstname><surname>MacKenzie</surname></author>
+<author><firstname>Tom</firstname><surname>Tromey</surname></author>
+</authorgroup>
+</biblioentry>
+
+<biblioentry>
+<title><ulink url="info://autoconf/Top">GNU Autoconf</ulink></title>
+<authorgroup>
+<author><firstname>David</firstname><surname>MacKenzie</surname></author>
+<author><firstname>Ben</firstname><surname>Elliston</surname></author>
+</authorgroup>
+</biblioentry>
+
+<biblioentry>
+<title><ulink url="info://gcc/Top">Using the GNU Compiler Collection</ulink></title>
+<author><firstname>Richard M.</firstname><surname>Stallman</surname></author>
+</biblioentry>
+
+<biblioentry>
+<title><ulink url="info://libtool/Top">GNU Libtool</ulink></title>
+<authorgroup>
+<author><firstname>Gordon</firstname><surname>Matzigkeit</surname></author>
+<author><firstname>Alexandre</firstname><surname>Oliva</surname></author>
+<author><firstname>Thomas</firstname><surname>Tanner</surname></author>
+<author><firstname>Gary V.</firstname><surname>Vaughan</surname></author>
+</authorgroup>
+</biblioentry>
+
+<biblioentry>
+<title>GNU Autoconf, Automake, and Libtool</title>
+<edition>1st edition</edition>
+<pubdate>October 2000</pubdate>
+<authorgroup>
+<author><firstname>Gary V.</firstname><surname>Vaughan</surname></author>
+<author><firstname>Ben</firstname><surname>Elliston</surname></author>
+<author><firstname>Tom</firstname><surname>Tromey</surname></author>
+<author><firstname>Ian Lance</firstname><surname>Taylor</surname></author>
+</authorgroup>
+<publisher><publishername>New Riders Publishing</publishername></publisher>
+<isbn>ISBN 1578701902</isbn>
+</biblioentry>
+
+
+<biblioentry>
+<title>Advanced Programming in the &UNIX; Environment</title>
+<edition>1st edition</edition>
+<pubdate>June 1992</pubdate>
+<author><firstname>W. Richard</firstname><surname>Stevens</surname></author>
+<publisher><publishername>Addison-Wesley Pub Co</publishername></publisher>
+<isbn>ISBN 0201563177</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Thinking in C++, Volume 1: Introduction to Standard C++</title>
+<edition>2nd Edition</edition>
+<pubdate>April 15, 2000</pubdate>
+<author><firstname>Bruce</firstname><surname>Eckel</surname></author>
+<publisher><publishername>Prentice Hall</publishername></publisher>
+<isbn>ISBN 0139798099</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Open Source Development with CVS</title>
+<edition>2nd Edition</edition>
+<pubdate>October 12, 2001</pubdate>
+<authorgroup>
+<author><firstname>Karl</firstname><surname>Fogel</surname></author>
+<author><firstname>Moshe</firstname><surname>Bar</surname></author>
+</authorgroup>
+<publisher><publishername>The Coriolis Group</publishername></publisher>
+<isbn>ISBN 158880173X</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Programming PHP</title>
+<edition>1st edition</edition>
+<pubdate>March 2002</pubdate>
+<authorgroup>
+<author><firstname>Rasmus</firstname><surname>Lerdorf</surname></author>
+<author><firstname>Kevin</firstname><surname>Tatroe</surname></author>
+</authorgroup>
+<publisher><publishername>O'Reilly &amp; Associates</publishername></publisher>
+<isbn>ISBN 1565926102</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Programming Python</title>
+<edition>2nd Edition</edition>
+<pubdate>March 2001</pubdate>
+<author><firstname>Mark</firstname><surname>Lutz</surname></author>
+<publisher><publishername>O'Reilly &amp; Associates</publishername></publisher>
+<isbn>ISBN 0596000855</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Gui Programming With Python : Using the Qt Toolkit</title>
+<edition>Bk&amp;Cd-r edition</edition>
+<pubdate>January 2002</pubdate>
+<author><firstname>Boudewijn</firstname><surname>Rempt</surname></author>
+<publisher><publishername>Opendocs Llc</publishername></publisher>
+<isbn>ISBN 0970033044</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Programming Perl</title>
+<subtitle>The Camel book</subtitle>
+<edition>3rd Edition</edition>
+<pubdate>July 2000</pubdate>
+<authorgroup>
+<author><firstname>Larry</firstname><surname>Wall</surname></author>
+<author><firstname>Tom</firstname><surname>Christiansen</surname></author>
+<author><firstname>Jon</firstname><surname>Orwant</surname></author>
+</authorgroup>
+<publisher><publishername>O'Reilly &amp; Associates</publishername></publisher>
+<isbn>ISBN 0596000278</isbn>
+</biblioentry>
+
+<biblioentry>
+<title>Learning Perl</title>
+<subtitle>The Lama book</subtitle>
+<edition>3rd Edition</edition>
+<pubdate>July 15, 2001</pubdate>
+<authorgroup>
+<author><firstname>Randal L.</firstname><surname>Schwartz</surname></author>
+<author><firstname>Tom</firstname><surname>Phoenix</surname></author>
+</authorgroup>
+<publisher><publishername>O'Reilly &amp; Associates</publishername></publisher>
+<isbn>ISBN 0596001320</isbn>
+</biblioentry>
+
+</bibliography>
+<!-- -->
+
+</appendix> <!-- app-bibliography -->
+
+<!-- ====================================================================== -->
+
+&documentation.index;
+
+</book>
diff --git a/doc/kdevelop/kdcop_browsing.png b/doc/kdevelop/kdcop_browsing.png
new file mode 100644
index 00000000..26dbaaf1
--- /dev/null
+++ b/doc/kdevelop/kdcop_browsing.png
diff --git a/doc/kdevelop/kdevdesigner.png b/doc/kdevelop/kdevdesigner.png
new file mode 100644
index 00000000..4fa74c68
--- /dev/null
+++ b/doc/kdevelop/kdevdesigner.png
diff --git a/doc/kdevelop/kdevelop-ideal-mode-0.png b/doc/kdevelop/kdevelop-ideal-mode-0.png
new file mode 100644
index 00000000..ea2d7c50
--- /dev/null
+++ b/doc/kdevelop/kdevelop-ideal-mode-0.png
diff --git a/doc/kdevelop/kdevelop-ideal-mode.png b/doc/kdevelop/kdevelop-ideal-mode.png
new file mode 100644
index 00000000..00e73804
--- /dev/null
+++ b/doc/kdevelop/kdevelop-ideal-mode.png
diff --git a/doc/kdevelop/kdevelop-install.docbook b/doc/kdevelop/kdevelop-install.docbook
new file mode 100644
index 00000000..1ff5982c
--- /dev/null
+++ b/doc/kdevelop/kdevelop-install.docbook
@@ -0,0 +1,754 @@
+<appendix id="kdevelop-install">
+
+<appendixinfo>
+  <authorgroup>
+    <author><firstname>Bernd</firstname><surname>Pol</surname></author>
+    <author><firstname>Anne-Marie</firstname><surname>Mahfouf</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</appendixinfo>
+
+<title>Installing &kdevelop;</title>
+
+<indexterm zone="kdevelop-install">
+  <primary>installation</primary></indexterm>
+
+<para>
+In this chapter we will discuss the steps necessary to compile and install the &kdevelop; IDE:
+
+<itemizedlist>
+  <listitem><para>
+  <link linkend="kdevelop-install-howto">How to obtain &kdevelop;</link> mainly concentrates on downloading the most recent &kdevelop; sources from svn.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="requirements">&kdevelop; requirements</link> lists the programs and libraries which you need installed to successfully compile the IDE.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="compile-and-install">&kdevelop; compilation and installation</link> leads you through all the steps of compilation and installation of the application.
+  </para></listitem>
+  <listitem><para>
+<link linkend="make-api">How to obtain a &kdevelop; &API; documentation</link> tells what an API is and how you get such a useful tool for navigating the &kdevelop; sources.
+  </para></listitem>
+</itemizedlist>
+</para>
+
+<sect1 id="kdevelop-install-howto">
+<title>How to Obtain &kdevelop;</title>
+
+<indexterm zone="kdevelop-install-howto">
+  <primary>obtain &kdevelop;</primary></indexterm>
+<indexterm zone="kdevelop-install-howto">
+  <primary>&kdevelop;</primary>
+  <secondary>obtain</secondary></indexterm>
+
+<para>
+&kdevelop; is available in binary form from many different &Linux; distributions such as <!--&SuSE;, &RedHat;//--> SuSE, RedHat and others. These binaries are packed in some convenient format, mostly RPM, for easy installation. To install, follow the standard instructions given in your distribution.
+</para>
+<para>
+You may as well obtain the &kdevelop; sources, compile and install them by yourself. These sources can be found via the project home page at <ulink url="http://www.kdevelop.org"> http://www.kdevelop.org</ulink> or via the <ulink url="http://download.kde.org">&kde; ftp site</ulink>.
+</para>
+
+<sect2 id="howto-svn">
+<title>Get Daily &kdevelop; Snapshots from svn</title>
+
+<indexterm zone="howto-svn">
+  <primary>svn</primary></indexterm>
+
+<para>If you want to be in front of current development, anonymous svn repository snapshots are available.</para>
+<para>The module name is <emphasis>kdevelop</emphasis> at <filename class="directory">svn co svn://anonsvn.kde.org/home/kde/branches/KDE/3.5/kdevelop</filename>.
+</para>
+
+<sect3 id="howto-svn-co">
+<title>Initial svn Checkout</title>
+
+<indexterm zone="howto-svn-co">
+  <primary>checkout</primary></indexterm>
+<indexterm zone="howto-svn-co">
+  <primary>&kdevelop;</primary>
+  <secondary>svn</secondary>
+  <tertiary>checkout</tertiary></indexterm>
+
+<para>
+To obtain an initial version of &kdevelop; you must download it from anonymous svn.  For this so-called <emphasis>checkout</emphasis> operation follow these steps.
+</para>
+
+<note><para>
+We assume you want to put your &kdevelop; copy into the <filename class="directory">kde3src</filename> subdirectory of your home directory (<filename class="directory">~</filename>).
+</para></note>
+
+<informalexample><simplelist>
+  <member>
+  # Create the destination directory, if necessary:
+  </member>
+  <member>
+    <prompt>~&gt; </prompt>
+    <userinput>mkdir kde3src</userinput>
+  </member>
+  <member>
+    <prompt>~&gt; </prompt>
+    <userinput>cd kde3src</userinput>
+  </member>
+  <member>
+    <prompt>~/kde3src&gt; </prompt>
+    <userinput>svn co svn://anonsvn.kde.org/home/kde/branches/KDE/3.5/kdevelop</userinput>
+  </member>
+  <member>
+    <prompt>~/kde3src&gt; </prompt>
+    <userinput>cd kdevelop</userinput>
+  </member>
+</simplelist></informalexample>
+
+<note><para>
+  Once you have successfully checked out your &kdevelop; version, you may keep up with the changes using the update procedure shown in the next section.
+</para></note>
+
+<important><para>
+  Keep the server load low. <emphasis>Please do not checkout every time you want to keep your &kdevelop; up to date!</emphasis> Use svn update for this purpose.
+</para></important>
+
+<para>
+Now you may compile your &kdevelop; version as shown in the <link linkend="compile-and-install">&kdevelop; Compilation and Installation</link> section.
+</para>
+
+</sect3> <!-- howto-svn-co -->
+
+<sect3 id="howto-svn-up">
+<title>Keeping Your svn Copy up to Date</title>
+
+<indexterm zone="howto-svn-up">
+  <primary>update</primary></indexterm>
+<indexterm zone="howto-svn-up">
+  <primary>&kdevelop;</primary>
+  <secondary>svn</secondary>
+  <tertiary>update</tertiary></indexterm>
+
+<para>
+After you checked out (and successfully compiled) &kdevelop; from svn as shown above, you'll want to keep it up to date in order to get all the patches. Follow these steps. (We again assume you have put your &kdevelop; copy into the <filename class="directory">kde3src</filename> directory.)
+</para>
+<para>
+Note the <command>up</command> (= <emphasis>update</emphasis>) command instead of the <command>co</command> (which stands for <emphasis>checkout</emphasis>).
+</para>
+
+<informalexample><simplelist>
+  <member>
+    <prompt>~&gt; </prompt>
+    <userinput>cd kde3src</userinput>
+  </member>
+  <member>
+    <prompt>~/kde3src&gt; </prompt>
+    <userinput>cd kdevelop</userinput>
+  </member>
+  <member>
+    <prompt>~/kde3src&gt; </prompt>
+    <userinput>svn up</userinput>
+  </member>
+</simplelist></informalexample>
+
+<note><para>
+Keep an eye on the messages svn produces during the update sequence. The exact steps in the compilation sequence depend on this.
+</para></note>
+
+<para>
+Now you can compile a new &kdevelop; version as shown in the <link linkend="compile-and-install-make-svn">Special svn compilation considerations</link> chapter.
+</para>
+</sect3> <!-- howto-svn-up -->
+
+</sect2> <!-- howto-svn -->
+
+</sect1> <!-- howto -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="requirements">
+<title>&kdevelop; Requirements</title>
+
+<indexterm zone="requirements">
+  <primary>requirements</primary></indexterm>
+<indexterm zone="requirements">
+  <primary>&kdevelop;</primary>
+  <secondary>requirements</secondary></indexterm>
+<indexterm zone="requirements">
+  <primary>GNU</primary>
+  <secondary>requirements</secondary></indexterm>
+
+<para>
+In order to successfully compile and use &kdevelop;, you need the following programs and libraries. They are available on most platforms as distribution packages and thereby can be installed easily.
+</para>
+
+<itemizedlist>
+<title>Required:</title>
+  <listitem>
+  <para>
+    <application>gcc/g++</application> &ge; 2.95.3 (or compatible)
+    <indexterm>
+      <primary>gcc</primary>
+      <secondary>requirements</secondary></indexterm>
+    <indexterm>
+      <primary>g++</primary>
+      <secondary>requirements</secondary></indexterm>
+  </para>
+  <para>
+  Available from <ulink url="gcc.gnu.org">gcc.gnu.org</ulink>
+  </para>
+  </listitem>
+  <listitem>
+  <para>
+    <application>&GNU; make</application> (or compatible)
+    <indexterm>
+      <primary>make</primary>
+      <secondary>requirements</secondary></indexterm>
+  </para>
+  <para>
+  Available from <ulink url="www.gnu.org/software/make">www.gnu.org/software/make</ulink>
+  </para>
+  </listitem>
+  <listitem>
+  <para>
+    &perl; 5.004 (or higher)
+    <indexterm>
+      <primary>Perl</primary>
+      <secondary>requirements</secondary></indexterm>
+  </para>
+  <para>
+  Available from <ulink url="www.perl.com">www.perl.com</ulink>
+  </para>
+  </listitem>
+  <listitem>
+  <para>
+    <application>autoconf</application> &ge; 2.52 (or higher)
+    <indexterm>
+      <primary>autoconf</primary>
+      <secondary>requirements</secondary></indexterm>
+  </para>
+  <para>
+  Available from <ulink url="www.gnu.org/software/autoconf">www.gnu.org/software/autoconf</ulink>
+  </para>
+  </listitem>
+  <listitem>
+  <para>
+    <application>automake</application> &ge; 1.6 (or higher)
+    <indexterm>
+      <primary>automake</primary>
+      <secondary>requirements</secondary></indexterm>
+  </para>
+  <para>
+  Available from <ulink url="www.gnu.org/software/automake">www.gnu.org/software/automake</ulink>
+  </para>
+  </listitem>
+  <listitem>
+  <para>
+    <application>flex</application> 2.5.4 (or higher)
+    <indexterm>
+      <primary>flex</primary>
+      <secondary>requirements</secondary></indexterm>
+  </para>
+  <para>
+  Available from <ulink url="www.gnu.org/software/flex">www.gnu.org/software/flex</ulink>
+  </para>
+  </listitem>
+  <listitem>
+  <para>
+    &Qt; &ge; 3.3.0 (or higher)
+    <indexterm>
+      <primary>Qt</primary>
+      <secondary>requirements</secondary></indexterm>
+  </para>
+  <para>
+  Available from <ulink url="www.trolltech.com/products/qt">www.trolltech.com/products/qt</ulink>
+  </para>
+  </listitem>
+  <listitem>
+  <para>
+    <application>KDE</application> &ge; 3.4.0 (or higher)
+    <indexterm>
+      <primary>KDE</primary>
+      <secondary>requirements</secondary></indexterm>
+  </para>
+  <para>
+  Available from <ulink url="www.kde.org">www.kde.org</ulink>
+  </para>
+  </listitem>
+</itemizedlist>
+
+<itemizedlist>
+<title>Optional:</title>
+  <listitem><para>
+    The <emphasis><application>ctags</application></emphasis> source navigation tool, from <ulink url="http://ctags.sourceforge.net">http://ctags.sourceforge.net</ulink>, which enables you fast access to declarations and definitions by a few simple clicks on a name in the editor.
+    <indexterm><primary>ctags</primary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    <emphasis><application>dot</application></emphasis>, a graphics language compiler, from <ulink url="http://www.graphviz.org">http:/www.graphviz.org</ulink>. This
+  <!-- ### temporarily disabled until the graphical class browser works again
+  allows you to navigate in a graphical view of your classes' dependencies. Likewise the <application>dot</application> //-->
+  tool is needed in conjunction with &doxygen; below if you want to have class relationships graphically displayed (which is highly recommended).
+    <indexterm><primary>dot</primary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    The <emphasis>&doxygen;</emphasis> documentation tool, from <ulink url="http://www.doxygen.org">http://www.doxygen.org</ulink> if you want to generate concise and powerful API documentation from your projects.
+    <indexterm><primary>doxygen</primary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    <emphasis><application>valgrind</application></emphasis> from <ulink url="http://developer.kde.org/~sewardj/">http://developer.kde.org/~sewardj/</ulink> helps you to find memory management problems in your applications.
+    <indexterm><primary>valgrind</primary></indexterm>
+  </para></listitem>
+  <listitem><para>
+    <emphasis><application>svn</application></emphasis> from <ulink url="http://subversion.tigris.org/">http://subversion.tigris.org/</ulink> if you want to use the svn versioning system.
+    <indexterm>
+      <primary>svn</primary>
+      <secondary>requirements</secondary></indexterm>
+  </para></listitem>
+  <listitem><para>
+  Any other compiler and/or tool in case you want to develop for another language/platform than C++/&kde; or use some special facility.
+  </para></listitem>
+</itemizedlist>
+
+<note>
+<orderedlist>
+  <listitem>
+    <para>
+    You can, to a certain extent, circumvent the need for &autoconf; &ge; 2.52 and &automake; &ge; 1.6. Just remove the <filename class="directory">admin</filename> directory in your &kdevelop; installation directory and type
+    <indexterm>
+      <primary>autoconf</primary>
+      <secondary>circumvent version need</secondary></indexterm>
+    <indexterm>
+      <primary>automake</primary>
+      <secondary>circumvent version need</secondary></indexterm>
+    <indexterm>
+      <primary>version need</primary>
+      <secondary>circumvent for autoconf/automake</secondary></indexterm>
+    </para>
+    <informalexample><simplelist>
+      <member><prompt>(your-kdevelop-directory)&gt; </prompt>
+      <userinput>ln -s $KDEDIR/share/apps/kdelibs/admin admin</userinput></member>
+    </simplelist></informalexample>
+    <para>
+    at the console. This causes &kdevelop; to use the standard settings in the &kde; <filename class="directory">admin</filename> directory instead.
+    </para>
+  </listitem>
+  <listitem>
+    <para>
+    Be careful <emphasis>not to mix &Qt; versions</emphasis>. Always link &kdevelop; to the same &Qt; version your &kde; library was compiled. Otherwise you will most likely experience <emphasis>very strange</emphasis> behaviours.
+    </para>
+  </listitem>
+</orderedlist>
+</note>
+
+</sect1> <!-- requirements -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="compile-and-install">
+<title>&kdevelop; Compilation and Installation</title>
+
+<indexterm zone="compile-and-install">
+  <primary>&kdevelop;</primary>
+  <secondary>compilation</secondary></indexterm>
+<indexterm zone="compile-and-install">
+  <primary>&kdevelop;</primary>
+  <secondary>installation</secondary></indexterm>
+
+<para>
+Once all requirements are met, you are ready to compile and install &kdevelop;. This appendix will discuss the necessary steps to do so.
+</para>
+<itemizedlist>
+  <listitem><para>
+  <link linkend="compile-and-install-preliminaries">Preliminary Steps</link> tells you about setting up a proper environment.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="compile-and-install-make">Compile &kdevelop;</link> deals with obtaining the &kdevelop; sources from svn, how to prepare them for the installation process, and finally shows the steps necessary to compile and install &kdevelop;.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="compile-and-install-options">Some Notes on configure Options</link> tells you how to run &kdevelop; if it has been installed in a location other than the &kde; directory.
+  </para></listitem>
+</itemizedlist>
+
+<sect2 id="compile-and-install-preliminaries">
+<title>Preliminary Steps</title>
+
+<indexterm zone="compile-and-install-preliminaries">
+  <primary>preliminaries</primary>
+  <secondary>&kdevelop; installation</secondary></indexterm>
+<indexterm zone="compile-and-install-preliminaries">
+  <primary>KDEDIR</primary></indexterm>
+<indexterm zone="compile-and-install-preliminaries">
+  <primary>QTDIR</primary></indexterm>
+<indexterm zone="compile-and-install-preliminaries">
+  <primary>LD_LIBRARY_PATH</primary></indexterm>
+<indexterm zone="compile-and-install-preliminaries">
+  <primary>LIBRARY_PATH</primary></indexterm>
+<indexterm zone="compile-and-install-preliminaries">
+  <primary>PATH</primary></indexterm>
+
+<para>
+Before entering the compile sequence you must make sure all libraries and tools are available to the make system. To accomplish this some environment variables need to be properly set. The actual steps to be performed depend on the console shell you use.
+</para>
+
+<note><para>
+To avoid typing in all the statements that set the necessary environment variables every time you want to compile, you should put them into your <filename>.bashrc</filename> or <filename>.cshrc</filename> file. This way the environment variables will be properly set every time you start the shell.
+</para></note>
+
+<sect3 id="compile-and-install-preliminaries-bash">
+<title>Setting the Environment for the bash Shell</title>
+
+<para>
+If you use the bash shell add the following lines:
+</para>
+
+<informalexample><simplelist>
+  <member><userinput>export KDEDIR=</userinput>(path to your KDE installation)</member>
+  <member><userinput>export QTDIR=</userinput>(path to your Qt library)</member>
+  <member><userinput>export LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH</userinput></member>
+  <member><userinput>export LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH</userinput></member>
+  <member><userinput>export PATH=$QTDIR/bin:$KDEDIR/bin:$PATH</userinput></member>
+</simplelist></informalexample>
+<para></para>
+
+</sect3> <!-- compile-and-install-preliminaries-bash -->
+
+<sect3 id="compile-and-install-preliminaries-tcsh">
+<title>Setting the Environment for the tcsh Shell</title>
+
+<para>
+If you use the tcsh shell add the following lines:
+</para>
+<para>
+<informalexample><simplelist>
+  <member><userinput>setenv KDEDIR </userinput>(path to your KDE installation)</member>
+  <member><userinput>setenv QTDIR </userinput>(path to your Qt library)</member>
+  <member><userinput>setenv LD_LIBRARY_PATH=$QTDIR/lib:$KDEDIR/lib:$LD_LIBRARY_PATH</userinput></member>
+  <member><userinput>setenv LIBRARY_PATH $QTDIR/lib:$KDEDIR/lib:$LIBRARY_PATH</userinput></member>
+  <member><userinput>setenv PATH $QTDIR/bin:$KDEDIR/bin:$PATH</userinput></member>
+</simplelist></informalexample>
+</para>
+
+</sect3> <!-- compile-and-install-preliminaries-tcs -->
+
+</sect2> <!-- compile-and-install-preliminaries -->
+
+<sect2 id="compile-and-install-make">
+<title>Compile &kdevelop;</title>
+
+<indexterm zone="compile-and-install-make">
+  <primary>make</primary>
+  <secondary>&kdevelop; installation</secondary></indexterm>
+<indexterm zone="compile-and-install-make">
+  <primary>compiling</primary>
+  <secondary>&kdevelop;</secondary></indexterm>
+
+<note><para>
+In the following discussion we assume that you have put your &kdevelop; sources in the <filename class="directory">~/kde3src/kdevelop</filename> directory.
+</para></note>
+
+<sect3 id="compile-and-install-make-svn">
+<title>Special svn Compilation Considerations</title>
+
+<para>
+In case you use a &kdevelop; snapshot from svn the initial compilation steps depend on whether you just did a complete checkout or only updated the source.
+</para>
+
+<variablelist>
+<varlistentry>
+<term id="compile-and-install-make-svn-co">After a svn Checkout</term>
+<listitem>
+<para>
+You must <emphasis>initialize the make system</emphasis> after a fresh checkout. The same is true every time you need to start over from scratch. Type:
+</para>
+
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>make -f admin/Makefile.common svn-clean</userinput>
+</member></simplelist></informalexample>
+<para>
+and then <emphasis>all of the following steps</emphasis>.
+</para>
+<note><para>
+You might need access to the svn repository for the clean-up if any corrupted or missing files must be reconstructed.
+</para></note>
+<important><para>
+The <command>svn-clean</command> command will <emphasis>remove every file</emphasis> not in svn from the directory! Make sure to back up any valuable information before you issue this clean-up command.
+</para></important>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="compile-and-install-make-svn-up">After a svn Update</term>
+<listitem>
+<para>
+The next step depends on the output of the svn update sequence. If you got something like (there may be a U or a P marker in the leftmost column, both denoting the file has been changed):
+</para>
+
+<screen>
+U /some_directory_path/Makefile.am
+</screen>
+<para>
+or if you just did a full checkout, you must enter:
+</para>
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>make -f Makefile.svn</userinput>
+</member></simplelist></informalexample>
+<para>
+before you proceed with <emphasis>all of the following steps</emphasis>.
+</para>
+</listitem>
+</varlistentry>
+</variablelist>
+</sect3> <!-- compile-and-install-make-svn -->
+
+<sect3 id="compile-and-install-make-basic">
+<title>Basic <command>make</command> Command Sequence</title>
+
+<para>
+Once the basic make system is set up you must decide which type of the &kdevelop; system you want to use. This is done in the following configure step which builds the actual <filename>Makefile</filename>s the <command>make</command> command will use.
+</para>
+
+<note><para>
+You may drop the <option>--prefix</option> option in the following <command>configure</command> command lines if you want &kdevelop; be installed in the default &kde; directory. See the <link linkend="compile-and-install-options">Some notes on configure options</link> chapter for this.
+</para></note>
+
+<variablelist>
+<varlistentry>
+<term>A Debug-Compiled Version</term>
+<listitem>
+<para>
+If you want to keep track of what your &kdevelop; application does at run-time you may build a debug-compiled version. Just command <command>configure</command> to do so:
+</para>
+
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>./configure --enable-debug=full --prefix=</userinput>(where-your-kde3-is)
+</member></simplelist></informalexample>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>A Release-Compiled Version</term>
+<listitem>
+<para>If you only want to use &kdevelop; as-is a (smaller and faster
+running) release version suffices. <command>configure</command> defaults to
+this.</para>
+
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>./configure --prefix=</userinput>(where-your-kde3-is)
+</member></simplelist></informalexample>
+
+<note>
+<para>
+If you want to build your own <link linkend="make-api">API documentation</link> for &kdevelop; you must include yet another option in the <command>configure</command> command:
+</para>
+<informalexample><simplelist>
+  <member><prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>./configure --</userinput>(options-as-above) <userinput>\</userinput></member> <member><userinput>--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs</userinput></member>
+</simplelist></informalexample>
+</note>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Make and Install &kdevelop;</term>
+<listitem>
+<para>
+<command>configure</command> will check the system and build some <filename>Makefile</filename>s according to what it found. The <command>make</command> command will use the main <filename>Makefile</filename> by default. Thus
+</para>
+
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>make</userinput>
+</member></simplelist></informalexample>
+<para>
+suffices. If necessary, now gain root user rights using the command
+</para>
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>su</userinput>
+</member></simplelist></informalexample>
+<para>
+and entering the root password. Then install the application:
+</para>
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>make install</userinput>
+</member></simplelist></informalexample>
+<para>
+That's all. If you installed &kdevelop; in the default &kde; directory you may now run the IDE. Otherwise some additional steps will be necessary as shown in the <link linkend="compile-and-install-options-dir">Non-default installation directory</link> section below.
+</para>
+
+<note>
+  <para>
+  In fact there usually will have been three &kdevelop;-based applications installed:
+  </para>
+  <itemizedlist>
+    <listitem><para>The &kdevelop; IDE &mdash; this is the place where you will usually work.</para></listitem>
+    <listitem><para>The stand-alone &kdevelop; Assistant documentation browser &mdash; isolates all the powerful documentation facilities of the &kdevelop; IDE in a separate tool. This comes in handy when you want to look up some programming documentation but do not want to start the full IDE.</para></listitem>
+    <listitem><para>The &kdevelop; Designer &mdash; enhances the &Qt; User Interface Designer by &kde; specific elements and integrates nicely in the &kdevelop; IDE.</para></listitem>
+  </itemizedlist>
+</note>
+</listitem>
+</varlistentry>
+</variablelist>
+
+
+</sect3> <!-- compile-and-install-make-basic -->
+</sect2> <!-- compile-and-install-make -->
+
+
+<sect2 id="compile-and-install-options">
+<title>Some Notes on <command>configure</command> Options</title>
+
+<sect3 id="compile-and-install-options-dir">
+<title>Non-default Installation Directory</title>
+
+<indexterm zone="compile-and-install-options-dir">
+  <primary>&kdevelop;</primary>
+  <secondary>installation</secondary>
+  <tertiary>non-default directory</tertiary></indexterm>
+<indexterm zone="compile-and-install-options-dir">
+  <primary>non-default directory</primary></indexterm>
+<indexterm zone="compile-and-install-options-dir">
+  <primary>KDEDIRS</primary></indexterm>
+<indexterm zone="compile-and-install-options-dir">
+  <primary>kbuildsycoca</primary></indexterm>
+
+<para>
+By default <command>configure</command> prepares the IDE to be installed in the default &kde; directory. This is necessary because &kdevelop; assumes direct access to some tools and parts which reside there. If want to use your own installation directory, you must tell <command>configure</command> this by the <option>--prefix</option> option:
+</para>
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>./configure --prefix=</userinput>(where-your-kde3-is)
+</member></simplelist></informalexample>
+<para>
+There is a caveat if you do so. You must provide a means for &kdevelop; to access the needed tools and parts in the &kde; directory when running. (You can still use the IDE without doing so, but with very restrained capabilities.)
+</para>
+<para>
+Call up a shell and have the following commands executed before you start &kdevelop; at the shell prompt.
+</para>
+
+<note><para>
+  <emphasis>Take care to use the plural:</emphasis> It is <quote><envar>KDEDIRS</envar></quote>, not just <quote><envar>KDEDIR</envar></quote>)
+</para></note>
+
+<informalexample><simplelist>
+  <member>
+    <prompt>~&gt; </prompt>
+    <userinput>export KDEDIRS=/usr/local/kde:/opt/kde3</userinput>
+  </member>
+  <member>
+    <prompt>~&gt; </prompt>
+    <userinput>kbuildsycoca</userinput>
+  </member>
+  <member>
+  (Now start &kdevelop;:)
+  </member>
+  <member>
+    <prompt>~&gt; </prompt>
+    <userinput>kdevelop</userinput>
+  </member>
+</simplelist></informalexample>
+
+<note><simplelist>
+  <member>The <envar>KDEDIRS</envar> environment variable must be set to the <emphasis>list of active &kde; directories</emphasis> in your system. We use</member>
+  <member><filename class="directory">/usr/local/kde</filename>:<filename class="directory">/opt/kde3</filename></member>
+  <member>as an example only.</member>
+  <member>The <filename class="directory">/usr/local/kde</filename> directory may for instance contain an incomplete &kde; version you compiled for debug purposes, and the <filename class="directory">/opt/kde3</filename> directory may in addition contain the standard &kde; version from your distribution that is used for everyday work.</member>
+</simplelist></note>
+
+<para>
+In a tcsh shell you must set the environment variables using:
+</para>
+<informalexample><simplelist><member>
+    <prompt>~&gt; </prompt>
+    <userinput>setenv KDEDIRS /usr/local/kde:/opt/kde3</userinput>
+</member></simplelist></informalexample>
+<para>
+The <command>kbuildsycoca</command> command (<quote>build system control cache</quote>) looks around for libraries and caches their location and version, so that &kdevelop; can find them. The caveat is that it takes noticeable time&mdash;and it has to be run any time you call up the shell to start &kdevelop; from a non-default directory. You may want to put the above commands into a shell script to reduce the typing effort.
+</para>
+<para>
+(You could as well put the lines in your <filename>.bashrc</filename> or <filename>.cshrc</filename> file, but this is not advisable as <command>kbuildsycoca</command> will then be run any time you call up the shell.)
+</para>
+
+<note><para>
+The <command>kbuildsycoca</command> command does not run from within the root. You must call it from a non-root user. (But is <emphasis>not a very good idea</emphasis> after all to do software development from within the root!)
+</para></note>
+</sect3> <!-- compile-and-install-options-dir -->
+
+<!-- ### put a sect3 with other configuration options here -->
+
+</sect2> <!-- compile-and-install-options -->
+
+</sect1> <!-- compile-and-install -->
+
+<sect1 id="make-api">
+<title>How to Obtain a &kdevelop; API Documentation</title>
+
+<indexterm zone="make-api">
+  <primary>API</primary>
+  <secondary>&kdevelop;</secondary></indexterm>
+<indexterm zone="make-api">
+  <primary>&kdevelop;</primary>
+  <secondary>API</secondary></indexterm>
+<indexterm zone="make-api">
+  <primary>compiling</primary>
+  <secondary>&kdevelop;</secondary>
+  <tertiary>API</tertiary></indexterm>
+<indexterm zone="make-api">
+  <primary>configure</primary>
+  <secondary>&kdevelop; API</secondary></indexterm>
+
+<para>
+API is the short form of <quote>Application Program Interface</quote>. Actually such an API cotains a series of descriptions (&ie; calling conventions) by which an application program can access the operating system and other services. In our context, however, a broader definition was adopted. The API of a &kde; or &Qt; application is an abstract of the classes and methods interfaces, a synopsis to be used like a dictionary to navigate the sources.
+</para>
+<para>
+There is a version of the most current API available at the <ulink url="http://www.kdevelop.org/HEAD/doc/api/html/index.html">KDevelop-Home website</ulink>. It will be automatically updated every 24 hours so you can keep up.
+</para>
+<para>
+Alas, this version is best used read-only over the internet. If you do not always have internet access you may as well build your own API documentation from the &kdevelop; sources. To do so, you must tell the automake system where to find the KDELIBS API in your system. This is accomplished by the special option <option>--with-kdelibsdoxy-dir</option> in the <command>configure</command> command when you prepare to compile the &kdevelop; sources:
+</para>
+
+<informalexample><simplelist>
+  <member>
+    <prompt>~/kde3src/kdevelop&gt; </prompt>
+    <userinput>./configure --</userinput>(options-as-usual)<userinput> \</userinput>
+  </member>
+  <member>
+    <userinput>--with-kdelibsdoxy-dir=$KDEDIR/share/doc/HTML/en/kdelibs-apidocs</userinput>
+  </member>
+</simplelist></informalexample>
+
+<para>
+(<command>make</command> will replace the global <varname>$KDEDIR</varname> variable with the actual &kde; directory setting recorded therein.) Then issue a <command>make</command> command <link linkend="compile-and-install-make-basic">as usual</link>. After the &kdevelop; IDE has been built you have the option to build the API as well. For this you must issue
+</para>
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>make apidocs</userinput>
+</member></simplelist></informalexample>
+
+<para>
+This will build a <filename>Doxyfile</filename> in your &kdevelop; base directory which in turn will be processed by the <application>Doxygen</application> application to build quite a lot of <filename>.html</filename> API files. When this rather lengthy API building process (may last more than an hour on a slow system) finally comes to an end, you must install the API just like you have to install the &kdevelop; IDE itself. If necessary obtain superuser rights by
+</para>
+
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>su</userinput>
+</member></simplelist></informalexample>
+
+<para>
+and entering the root password. Then install the API files:
+</para>
+
+<informalexample><simplelist><member>
+  <prompt>~/kde3src/kdevelop&gt; </prompt>
+  <userinput>make install-apidox</userinput>
+</member></simplelist></informalexample>
+
+<para>
+Once this is done, <command>make</command> will inform you about the directory where you can finally look at the API documentation's contents. Note this address, you can use it from  &konqueror; as well as from inside &kdevelop;, in case you have set up the &kdevelop; sources themselves as a project to work on.
+</para>
+
+<note><para>
+You will most probably see a lot of warning and/or error messages during the API build run by <application>Doxygen</application>. It is best to ignore them, they are of interest to the &kdevelop; developers only. If the API generation ever comes to a successful end, the <filename>.html</filename> API files will be usable.
+</para></note>
+
+</sect1> <!-- make-api -->
+
+</appendix> <!-- kdevelop-install -->
diff --git a/doc/kdevelop/kdevelop-mdi-mode.png b/doc/kdevelop/kdevelop-mdi-mode.png
new file mode 100644
index 00000000..51ed019a
--- /dev/null
+++ b/doc/kdevelop/kdevelop-mdi-mode.png
diff --git a/doc/kdevelop/kdevelop-scripting.docbook b/doc/kdevelop/kdevelop-scripting.docbook
new file mode 100644
index 00000000..d9e59bb5
--- /dev/null
+++ b/doc/kdevelop/kdevelop-scripting.docbook
@@ -0,0 +1,56 @@
+<chapter id="kdevelop-scripting">
+
+<chapterinfo>
+  <authorgroup>
+    <author><firstname>Ian</firstname><surname>Geiser</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</chapterinfo>
+
+<title>Using Scripts in KDevelop</title>
+
+<sect1 id="running-scripts">
+<title>Running Scripts</title>
+<para>
+  To access a script that is available to &kdevelop; use the <menuchoice><guimenu>Tools</guimenu><guimenuitem>Scripts</guimenuitem></menuchoice> menu.  If there there is no such menu item then there are no installed scripts available to KDevelop.
+</para>
+</sect1>
+
+<sect1 id="adding-scripts">
+<title>Adding Scripts</title>
+<para>
+  Once you have added KScript support to your host application adding the scripts is just as easy. The scripts are comprised of two parts, a desktop file that contains meta-data about the script and the script itself. This approach was used because of security and simplicity. The desktop file provides meta-information for menus and script type. This keeps the host application from having to inspect for load each script. An example of this file is shown below:
+</para>
+<para>
+  The above example demonstrates the main parts that KScript will look for. The first item the "Name" is the name that will appear to the user in the host application and the "Comment" will be usually provided as a tool tip. The "Type" is the most important. This is used to select the proper script engine to run the script. Currently the ones available to KDE are "ShellScript/bash" and "JavaScript/kjs"
+The next step is to create the actual script. For the above example the Type of script that is used is "ShellScript/bash". The shellscript script engine provides a few things for the developer. The first element is the DCOP ID of the host application. This is passed to the script as the first argument. This means from anywhere in the script the value of "$1" will return the host's DCOP ID. An example shell script is shown below:
+</para>
+
+<para>This script is quite simple and just executes a command and sets the text of the first document to the output of "ls -l"</para>
+
+<para>One of the most useful tools in developing scripts for applications is the KDCOP application.</para>
+<figure id="screenshot-kdcop" float="1">
+  <title>KDCOP Browsing DCOP Interfaces in &kdevelop;</title>
+  <mediaobject>
+    <imageobject><imagedata fileref="kdcop_browsing.png"/></imageobject>
+  </mediaobject>
+</figure>
+
+<para>The KDCOP tool allows script developers to browse and debug the current interfaces of the host application. KDCOP also provides a neat feature of allowing users to select a method and drag the current code to their text editor. This simplifies use for people who are not savvy to the DCOP methods of the host language. Currently KDCOP supports KJSEmbed, Python, and UNIX Shell method for accessing DCOP.</para>
+
+<para>Once the script is complete it is ready to be installed. Application developers should document the location that will be scanned for scripts. In the case of the above example for Kate the scripts are located in "$KDEDIRS/share/apps/kate/scripts".</para>
+
+<figure id="screenshot-scripts" float="1">
+  <title>&kdevelop; Scripts on the Filesystem</title>
+  <mediaobject>
+    <imageobject><imagedata fileref="script_location.png"/></imageobject>
+  </mediaobject>
+</figure>
+
+<para>The script desktop file, and its associated script should be in the same directory. For script developers it is also recommended that all other script resources such as UI files, or data files should also reside in the script directory. In the above example the script will appear under the Tools->KDE Scripts menu. One important thing for script developers to note is that they should not perform operations that could block for a long time, or go into an eventloop. This is because the current version of the script interface is geared for automated tasks that run until completion. This is being addressed and extended for KDE 4.
+</para>
+
+</sect1>
+
+
+</chapter>
diff --git a/doc/kdevelop/kdevelop-survey.docbook b/doc/kdevelop/kdevelop-survey.docbook
new file mode 100644
index 00000000..9fe32d2d
--- /dev/null
+++ b/doc/kdevelop/kdevelop-survey.docbook
@@ -0,0 +1,489 @@
+<chapter id="kdevelop-survey">
+
+<chapterinfo>
+  <authorgroup>
+    <author><firstname>Bernd</firstname><surname>Pol</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</chapterinfo>
+
+<title>Overview of &kdevelop; Features</title>
+
+<indexterm zone="kdevelop-survey">
+  <primary>&kdevelop;</primary>
+  <secondary>survey</secondary></indexterm>
+<indexterm zone="kdevelop-survey">
+  <primary>overall view</primary></indexterm>
+<indexterm zone="kdevelop-survey">
+  <primary>survey</primary></indexterm>
+
+<para>
+&kdevelop; integrates a lot of tools, scripts, and templates in a common user interface. Basically it consists of
+
+<itemizedlist>
+  <listitem><para>
+  several <link  linkend="uimodes-survey">user interface modes</link> from which you can select the look and feel of the workspace,
+  </para></listitem>
+  <listitem><para>
+  an <link linkend="applicationwizard">&appwizard;</link> which aids you in setting up a new project,
+  </para></listitem>
+  <listitem><para>
+  several <link linkend="makesystems">project management systems</link> which aid in building and managing your project,
+  </para></listitem>
+  <listitem><para>
+  some <link linkend="editing">editing tools</link> to easily work on your program texts
+  </para></listitem>
+  <listitem><para>
+  various <link linkend="file-browsers">file browsers</link> providing you different views on your file system,
+  </para></listitem>
+  <listitem><para>
+  various <link linkend="class-browsers">class browsers</link> to aid you in maintaining the classes and their relationships of your object-oriented programming project,
+  </para></listitem>
+  <listitem><para>
+  a <link linkend="debugger">debugger interface</link> to find and remove program errors from within &kdevelop;, and
+  </para></listitem>
+  <listitem><para>
+  several <link linkend="plugin-tools">plugin tools</link>, extensible modules which can be loaded at runtime and on demand.  This allows you to only turn on those features you really need.
+  </para></listitem>
+  <listitem><para>
+  a set of other diagnosis, documentation, and optimization helper tools.
+  </para></listitem>
+</itemizedlist>
+</para>
+
+<note>
+  <para>
+  In fact there are three &kdevelop;-based applications:
+  </para>
+  <itemizedlist>
+    <listitem><para>The &kdevelop; IDE &mdash; this is the place where you will usually work.</para></listitem>
+    <listitem><para>The stand-alone &kdevelop; Assistant documentation browser &mdash; isolates all the powerful documentation facilities of the &kdevelop; IDE in a separate tool. This comes in handy when you want to look up some programming documentation but do not want to start the full IDE.</para></listitem>
+    <listitem><para>The &kdevelop; Designer &mdash; enhances the &Qt; User Interface Designer by &kde; specific elements and integrates nicely in the &kdevelop; IDE.</para></listitem>
+  </itemizedlist>
+</note>
+
+
+<sect1 id="uimodes-survey">
+<title>Available User Interface Modes</title>
+
+<indexterm zone="uimodes-survey">
+  <primary>&kdevelop;</primary>
+  <secondary>user interface modes</secondary></indexterm>
+<indexterm zone="uimodes-survey">
+  <primary>user interface</primary>
+  <secondary>&kdevelop; modes</secondary></indexterm>
+<indexterm zone="uimodes-survey">
+  <primary>UI modes</primary></indexterm>
+<indexterm zone="uimodes-survey">
+  <primary>Child Frame Windows</primary></indexterm>
+<indexterm zone="uimodes-survey">
+  <primary>Tabbed Pages</primary></indexterm>
+<indexterm zone="uimodes-survey">
+  <primary>Toplevel Windows</primary></indexterm>
+<indexterm zone="uimodes-survey">
+  <primary>IDEAl</primary></indexterm>
+
+<para>
+&kdevelop; offers developers four separate user interface modes (click on the mode name to view an example):
+<itemizedlist>
+  <listitem><para><link linkend="ideal-desc">IDEAl</link></para>
+  <para>
+  This is a novel user interface approach optimizing both work space and intuitive handling of the tools.
+  </para>
+  <itemizedlist>
+    <listitem><para>
+    All tool views are docked in a tabbar fashion around the mainframe area. They are grouped left, bottom, and right according to the services provided.
+    </para></listitem>
+    <listitem><para>
+    Editor and browser views will be stacked in a big sized tabbed window inmidst the mainframe area.
+    </para></listitem>
+  </itemizedlist>
+  </listitem>
+
+  <listitem>
+  <para><link linkend="mdi-desc">Child Frame Windows</link></para>
+  <itemizedlist>
+    <listitem><para>All tool views are initially docked to the mainframe.</para></listitem>
+    <listitem><para>Editor and browser views will live like toplevel windows within a view area of the mainframe.</para></listitem>
+  </itemizedlist>
+  </listitem>
+
+  <listitem>
+  <para><link linkend="tabbed-desc">Tabbed Pages</link></para>
+  <itemizedlist>
+    <listitem><para>
+    All tool views are initially docked to the mainframe.
+    </para></listitem>
+    <listitem><para>
+    Editor and browser views will be stacked in a tabbed window.
+    </para></listitem>
+  </itemizedlist>
+  </listitem>
+
+  <listitem>
+  <para><link linkend="toplevel-desc">Toplevel Windows</link></para>
+  <itemizedlist>
+    <listitem><para>
+    All editor, browser, and tool views will be toplevel windows directly on the desktop.
+    </para></listitem>
+    <listitem><para>
+    The main widget only contains the menu, toolbars, and statusbar.
+    </para></listitem>
+  </itemizedlist>
+  </listitem>
+
+</itemizedlist>
+</para>
+
+<sect2 id="uimodes-switch">
+<title>How to Switch User Interface Modes</title>
+
+<indexterm zone="uimodes-switch">
+  <primary>user interface</primary>
+  <secondary>switch modes</secondary></indexterm>
+<indexterm zone="uimodes-switch">
+  <primary>switch UI modes</primary></indexterm>
+
+<para>
+To switch the user interface mode select <menuchoice> <guimenu>Settings</guimenu> <guimenuitem>Configure KDevelop...</guimenuitem> </menuchoice> from the menus. The <guilabel>Customize KDevelop</guilabel> dialog will pop up, where you have to select <guilabel>User Interface</guilabel> in the left hand tree. This will display the settings page shown below.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="select-user-interface.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    Select a user interface mode
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+(Older &kdevelop; versions provide the top mode selection section only.)
+</para>
+
+<para>
+In the <guilabel>Major User-Interface Mode</guilabel> section select the radio button of the user interface mode you want to work in.
+</para>
+<para>
+Dependent on the user interface mode you selected, other configuration sections will become available where you can taylor more details of the look and feel to your preferences. See the <link linkend="setup-ui">Selecting the User Interface</link> chapter for more detail.
+</para>
+
+<note><para>
+Do not forget to restart &kdevelop; in order to let your selections take effect.
+</para></note>
+
+</sect2> <!-- uimodes-switch -->
+
+<sect2 id="maximize-workspace">
+<title>How to Maximize the Work Space Area</title>
+
+<indexterm zone="maximize-workspace">
+  <primary>&kdevelop;</primary>
+  <secondary>work space</secondary></indexterm>
+<indexterm zone="maximize-workspace">
+  <primary>&kdevelop;</primary>
+  <secondary>maximize work space</secondary></indexterm>
+<indexterm zone="maximize-workspace">
+  <primary>user interface</primary>
+  <secondary>work space</secondary></indexterm>
+<indexterm zone="maximize-workspace">
+  <primary>user interface</primary>
+  <secondary>menubar</secondary></indexterm>
+<indexterm zone="maximize-workspace">
+  <primary>user interface</primary>
+  <secondary>full screen mode</secondary></indexterm>
+<indexterm zone="maximize-workspace">
+  <primary>full screen mode</primary></indexterm>
+<indexterm zone="maximize-workspace">
+  <primary>menubar</primary>
+  <secondary>hide/unhide</secondary></indexterm>
+<indexterm zone="maximize-workspace">
+  <primary>hide menubar</primary></indexterm>
+<indexterm zone="maximize-workspace">
+  <primary>unhide menubar</primary></indexterm>
+
+<para>
+To maximize space, there is a full-screen window mode available which expands the mainframe area to the screen borders. Additional space can be reclaimed by hiding the menubar. And you can of course hide any toolbar as usual in <application>KDE</application> applications.
+</para>
+
+<variablelist>
+<varlistentry>
+<term>Full Screen Mode</term>
+<listitem>
+<para>
+To switch to or from full screen mode select <menuchoice>
+<guimenu>View</guimenu> <guimenuitem>Full-Screen Mode</guimenuitem>
+</menuchoice> from the menus or press
+<keycombo>&Ctrl;&Shift;<keycap>F</keycap> </keycombo>. There is also a
+<guiicon>Full-Screen Mode</guiicon> icon in the <guilabel>Browse
+Toolbar</guilabel> available.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Hide/Unhide the Menubar</term>
+<listitem>
+<para>
+To <emphasis>hide</emphasis> the menubar select <menuchoice> <guimenu>Settings</guimenu> <guimenuitem>Show Menubar</guimenuitem> </menuchoice> from the menus or press <keycombo>&Ctrl;<keycap>M</keycap> </keycombo>. You may also include a <guiicon>Show Menubar</guiicon> icon in a suiting toolbar, &eg; the <guilabel>Browse Toolbar</guilabel> for that purpose. To <emphasis>unhide</emphasis> the menubar you must press <keycombo> &Ctrl;<keycap>M</keycap> </keycombo> or use the <guiicon>Show Menubar</guiicon> icon if available.
+</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+</sect2> <!-- maximize-workspace -->
+
+</sect1> <!-- uimodes-survey -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="ui-elements">
+<title>Elements of the User Interface</title>
+
+<para>
+(... to be written ...)
+</para>
+
+<sect2 id="ui-elements-workarea">
+<title>The Workarea</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- ui-elements-workarea -->
+
+<sect2 id="ui-elements-titlebar">
+<title>The &kdevelop; Titlebar</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- ui-elements-titlebar -->
+
+<sect2 id="ui-elements-statusbar">
+<title>The &kdevelop; Statusbar</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- ui-elements-statusbar -->
+
+<sect2 id="ui-elements-menubar">
+<title>The menubar</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- ui-elements-menubar -->
+
+<sect2 id="ui-elements-toolbars">
+<title>The Toolbars</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- ui-elements-toolbars -->
+
+<sect2 id="ui-elements-treetoolviews">
+<title>The Tree Tool Views</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- ui-elements-treetoolviews -->
+
+<sect2 id="ui-elements-outputtoolviews">
+<title>The Output Tool Views</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- ui-elements-outputtoolviews -->
+
+</sect1> <!-- ui-elements -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="makesystems">
+<title>Project Management Systems</title>
+
+<indexterm zone="makesystems">
+  <primary>project management</primary></indexterm>
+
+<para>
+Globally, a project will rely on some form of project management system.  &kdevelop; offers four <emphasis>project management systems</emphasis> the programmer can select from when creating a new project.
+
+<itemizedlist>
+  <listitem><para>
+  <link linkend="automake-project">Automake projects</link> use the &GNU; standard development tools.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="qmake-project">QMake projects</link> use the trolltech QMake project manager.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="ant-project">ANT projects</link> use the Apache ANT project manager for &Java; development.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="custom-project">Custom projects</link> require you to maintain your own <filename>Makefiles</filename>.
+  </para></listitem>
+</itemizedlist>
+</para>
+
+<sect2 id="automake-project">
+<title>Automake Projects</title>
+
+<indexterm zone="automake-project">
+  <primary>projects</primary>
+  <secondary>automake</secondary></indexterm>
+<indexterm zone="automake-project">
+  <primary>automake</primary>
+  <secondary>projects</secondary></indexterm>
+
+<para>
+Projects created with &kdevelop;'s &automanag; make it very easy for developers to use the &GNU; standard development tools. They provide
+<itemizedlist>
+  <listitem><para>
+  a better way of <filename>Makefile</filename> generation and
+  </para></listitem>
+  <listitem><para>
+  a good and safe way for fast adaption towards different systems by autoconf-generated <filename>configure</filename> scripts.
+  </para></listitem>
+</itemizedlist>
+</para>
+</sect2> <!-- automake-project -->
+
+<sect2 id="qmake-project">
+<title>QMake Projects</title>
+
+<indexterm zone="qmake-project">
+  <primary>projects</primary>
+  <secondary>qmake</secondary></indexterm>
+<indexterm zone="qmake-project">
+  <primary>qmake</primary>
+  <secondary>projects</secondary></indexterm>
+
+<para>
+For developers who enjoy the flexibility and feel of &Qt;'s qmake system, &kdevelop; offers the ability to handle qmake based projects (.pro files) within the &GUI;.
+</para>
+<para>
+For more information on the QMake project manager see the <quote>qmake User Guide</quote> which should be included in your distribution or have a look at the <ulink url="http://doc.trolltech.com/">TROLLTECH Documentation</ulink> home page where you may find the QMake documentation of your <quote>Qt C++ GUI Application Development Toolkit</quote> version.
+</para>
+</sect2> <!-- qmake-project -->
+
+<sect2 id="cmake-project">
+<title>CMake Projects</title>
+
+<indexterm zone="cmake-project">
+  <primary>projects</primary>
+  <secondary>cmake</secondary></indexterm>
+<indexterm zone="cmake-project">
+  <primary>cmake</primary>
+  <secondary>projects</secondary></indexterm>
+
+<para>
+CMake will be the &kde; build system for &kde; 4 and &kdevelop; already
+provides you some CMake based templates in C and C++. You only need the cmake
+program in your $<envar>PATH</envar> to build them.
+</para>
+<para>
+To set up a new C or C++ project in &kdevelop; select
+<menuchoice><guimenu>Project</guimenu>
+<guimenuitem>New Project...</guimenuitem>
+<guimenuitem>C or C++</guimenuitem> 
+<guimenuitem>CMake based projects</guimenuitem>
+<guimenuitem>A shared library template or Hello world program</guimenuitem> 
+</menuchoice>.
+</para>
+</sect2> <!-- cmake-project -->
+
+<sect2 id="ant-project">
+<title>ANT Projects (&Java; Projects)</title>
+
+<indexterm zone="ant-project">
+  <primary>projects</primary>
+  <secondary>ant</secondary></indexterm>
+<indexterm zone="ant-project">
+  <primary>ant</primary>
+  <secondary>projects</secondary></indexterm>
+<indexterm zone="ant-project">
+  <primary>projects</primary>
+  <secondary>Java</secondary></indexterm>
+<indexterm zone="ant-project">
+  <primary>Java</primary>
+  <secondary>projects</secondary></indexterm>
+<indexterm zone="ant-project">
+  <primary>development</primary>
+  <secondary>Java</secondary></indexterm>
+
+<para>
+&Java; developers may want to use the Apache ANT project manager for their projects. To set up a new Ant project in &kdevelop; select <menuchoice><guimenu>Project</guimenu>
+<guimenuitem>New Project...</guimenuitem>
+<guimenuitem>Java</guimenuitem>
+<guimenuitem>Ant Project</guimenuitem>
+<guimenuitem>Application</guimenuitem></menuchoice>.
+</para>
+<para>
+For more information see <ulink url="http://ant.apache.org/">The Apache Ant Project</ulink> home page.
+</para>
+</sect2> <!-- ant-project -->
+
+<sect2 id="custom-project">
+<title>Custom Projects</title>
+
+<indexterm zone="custom-project">
+  <primary>projects</primary>
+  <secondary>custom</secondary></indexterm>
+<indexterm zone="custom-project">
+  <primary>custom projects</primary></indexterm>
+<indexterm zone="custom-project">
+  <primary>Makefile</primary>
+  <secondary>custom projects</secondary></indexterm>
+
+<para>
+If you prefer to maintain your own <filename>Makefiles</filename> for your project you may use the custom project option of &kdevelop;. This may be feasible in unusually structured projects or if you want to retain full control over the <command>make</command> process.
+</para>
+<para>
+Yet, if you do not <emphasis>really need</emphasis> the extra flexibility and control of the custom project manager you should consider &automanag; or one of the other project managers, because they considerably ease the program building and distribution processes.
+</para>
+</sect2> <!-- custom-project -->
+
+<sect2 id="makesystems-distribution">
+<title>How to Distribute Your Application</title>
+
+<indexterm zone="makesystems-distribution">
+  <primary>distribution</primary></indexterm>
+<indexterm zone="makesystems-distribution">
+  <primary>application</primary>
+  <secondary>distribution</secondary></indexterm>
+<indexterm zone="makesystems-distribution">
+  <primary>binary packages</primary></indexterm>
+
+<para>
+The distribution of your applications does not require the end-user to have anything different installed other than
+<itemizedlist>
+  <listitem><para>an appropriate compiler,</para></listitem>
+  <listitem><para>a linker, and</para></listitem>
+  <listitem><para>the appropriate development libraries,</para></listitem>
+</itemizedlist>
+</para>
+<para>
+which at least for C++ applications is most often the case. But you can as well distribute <emphasis>binary packages</emphasis> of your application.
+<!-- ### more detail on binary construction needed somewhere -->
+In either way, the end-user of your product does not need &kdevelop; installed.
+</para>
+<para>
+For giving away your sources, we advise to include the <emphasis>project file</emphasis> of &kdevelop; as well. This makes it very easy for other developers&mdash;if they use &kdevelop;&mdash;to work with your sources.
+</para>
+<para>
+For projects where <emphasis>several developers</emphasis>, maybe working on different places, are involved, this should be the case anyway. So you can ensure consistency of the <filename>Makefiles</filename> to not run into trouble.
+</para>
+<para>
+Especially on multi language applications, <emphasis>translators</emphasis> won't actually work with the source code, except in cases that require correction for enabling translation support.
+</para>
+
+</sect2> <!-- makesystems-distribution -->
+
+</sect1> <!-- makesystems -->
+
+</chapter> <!-- kdevelop-survey -->
diff --git a/doc/kdevelop/kdevelop-tabbed-mode.png b/doc/kdevelop/kdevelop-tabbed-mode.png
new file mode 100644
index 00000000..faa7a97f
--- /dev/null
+++ b/doc/kdevelop/kdevelop-tabbed-mode.png
diff --git a/doc/kdevelop/kdevelop-toplevel-mode.png b/doc/kdevelop/kdevelop-toplevel-mode.png
new file mode 100644
index 00000000..c2fb812b
--- /dev/null
+++ b/doc/kdevelop/kdevelop-toplevel-mode.png
diff --git a/doc/kdevelop/listplugins.sh b/doc/kdevelop/listplugins.sh
new file mode 100755
index 00000000..e21b3a15
--- /dev/null
+++ b/doc/kdevelop/listplugins.sh
@@ -0,0 +1,43 @@
+
+# kdevdir must be set to the KDevelop project directory.
+kdevdir=/home/volker/data/prj/kdevelop/kdevelop/
+# The plugins are in the parts/ subdirectory.
+
+pushd $kdevdir/parts >/dev/null
+oldscope=nix
+echo "<para>The following plugin list is generated by a small script"
+echo "written by Volker Paul. All plugins have a .desktop file"
+echo "where information such as name and comments are written."
+echo "If in the following these comments are not very useful,"
+echo "it is because the plugin authors made them this way.</para>"
+echo "<para>The plugins are grouped by scope (Core, Global, Project).</para>"
+
+for defscope in Core Global Project; do
+   if [ $defscope != $oldscope ]; then
+      oldscope=$defscope
+      echo
+#      echo "<sect1><title>Scope: $defscope</title>"
+      echo "<para>Scope: $defscope</para>"
+      echo "<itemizedlist>"
+   fi
+   for dir in `ls`; do
+	if [ ! -d $dir ]; then continue; fi
+	dfile=$dir/*.desktop
+	# echo $dfile | wc -w
+	if [ `echo $dfile | wc -w` -gt 1 ]; then continue; fi
+	if [ ! -f $dfile ]; then continue; fi
+	scope=`cat $dfile | grep "X-KDevelop-Scope=" | cut -d= -f2-`
+	if [ $scope != $defscope ]; then continue; fi
+	comment=`cat $dfile | grep "Comment=" | cut -d= -f2-`
+	name=`cat $dfile | egrep "^Name=" | cut -d= -f2- | tr " " _`
+	genericname=`cat $dfile | grep "GenericName=" | cut -d= -f2-`
+	echo "<listitem><formalpara id=\"$name\">"
+	echo "<title>$genericname</title>"
+	echo "<para>$comment</para></formalpara></listitem>"
+   done
+      echo "</itemizedlist>"
+#      echo "</sect1>"
+done
+popd >/dev/null
+echo "<para>So far the generated plugin list.</para>"
+echo
diff --git a/doc/kdevelop/loading-progress-bar.png b/doc/kdevelop/loading-progress-bar.png
new file mode 100644
index 00000000..f786721d
--- /dev/null
+++ b/doc/kdevelop/loading-progress-bar.png
diff --git a/doc/kdevelop/nutshell.docbook b/doc/kdevelop/nutshell.docbook
new file mode 100644
index 00000000..1c5395dd
--- /dev/null
+++ b/doc/kdevelop/nutshell.docbook
@@ -0,0 +1,242 @@
+<appendix id="nutshell">
+<title>In a Nutshell &mdash; Tips and Tricks</title>
+
+<!-- Traditionally, most of this stuff will have been put into a FAQ section. It is more useful, however, to put it at the very start of a manual, as this is the place the (inexperienced) user first looks for.
+
+I disagree. What is useful for a quick start, should go in "Getting started".
+Troubleshooting hints go in the appendix or a FAQ. Volker Paul.
+
+This chapter is meant to provide short hints and tips together with (mandatory) navigation links.
+There should be an additional FAQ section near the end nevertheless which contains more general stuff not directly related to navigating the manual. -->
+
+<para>
+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;.
+</para>
+<para>
+If you want more information on a topic, just follow the link in the title starting that advice.
+</para>
+<para>
+Information on these topics is availabe:
+</para>
+<simplelist>
+  <member><link linkend="nutshellitem-look-and-feel">Look and Feel</link></member>
+  <member><link linkend="nutshellitem-projects">Projects</link></member>
+  <member><link linkend="nutshellitem-compilation">Compilation</link></member>
+  <member><link linkend="nutshellitem-automake">&automanag;</link></member>
+  <member><link linkend="nutshellitem-compilemake">Compile/Make Problems</link></member>
+  <member><link linkend="nutshellitem-others">Other Topics</link></member>
+</simplelist>
+
+<variablelist id="nutshellitem-look-and-feel">
+<title>Look and Feel</title>
+
+<varlistentry>
+<term id="nutshell-ideal-tabs"><link linkend="setup-ui-toolview">Force
+smaller tool view tabs in IDEAl Mode</link></term>
+<listitem>
+<para>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 (<menuchoice><guimenu>Settings</guimenu>
+<guimenuitem>Configure KDevelop...</guimenuitem> <guimenuitem>User
+Interface</guimenuitem></menuchoice>).</para>
+<para>If you use an older &kdevelop; 3 version, this configuration dialog
+may not be available. To change the toolview tabs display manually, place a
+<option>MDIStyle</option> entry under the
+<option>[UI]</option> tag in your
+<filename>$KDEHOME/share/config/kdeveloprc</filename> configuration file as
+follows:</para>
+
+<simplelist>
+<member><option>MDIStyle=0</option>: icons only</member>
+<member><option>MDIStyle=1</option>: text only (default)</member>
+<!--<member><computeroutput>MDIStyle=2</computeroutput>: icons only on smaller tabs (not very useful)</member>-->
+<member><option>MDIStyle=3</option>: icons and text</member>
+</simplelist>
+</listitem>
+</varlistentry>
+
+<varlistentry>  <!-- ### remove this entry when the bug is repaired -->
+<term id="nutshell-weird-style">Weird colored characters and/or display
+style</term>
+<listitem>
+<para>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:</para>
+
+<itemizedlist>
+<listitem><para>In your
+<filename>$<envar>KDEHOME</envar>/share/config/kdeveloprc</filename>
+configuration file find the line containing
+<quote><computeroutput>Style=Checked</computeroutput></quote> and remove
+it. Then restart &kdevelop;.
+</para>
+</listitem>
+</itemizedlist>
+<para>(This behaviour does sometimes occur after you left clicked a .ui file
+in one of the file navigators and &kdevelop; did load
+<application>KUIViewer</application> to show the &GUI; which was produced
+from this file.)</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="nutshell-full-screen"><link linkend="maximize-workspace">Full
+screen mode</link></term>
+<listitem>
+<para>Select <menuchoice><guimenu>View</guimenu><guimenuitem>Full-Screen
+Mode</guimenuitem></menuchoice> from the menus or press
+<keycombo>&Ctrl;&Shift;<keycap>F</keycap></keycombo>.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="nutshell-hide-menu"><link linkend="maximize-workspace">Hide/Unhide
+the menubar</link></term>
+<listitem>
+<para>To hide the menubar select
+<menuchoice><guimenu>Settings</guimenu><guimenuitem>Show
+Menubar</guimenuitem></menuchoice> from the menus or press
+<keycombo>&Ctrl;<keycap>M</keycap></keycombo>. To redisplay the menubar only
+<keycombo>&Ctrl;<keycap>M</keycap> </keycombo> is available.</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<variablelist>
+<title id="nutshellitem-projects">Projects</title>
+<varlistentry>
+<term><link linkend="new-projects">Create New Project</link></term>
+<listitem>
+<para><menuchoice><guimenu>Project</guimenu><guimenuitem>New
+Project...</guimenuitem></menuchoice> will start the <link
+linkend="applicationwizard">&appwizard;</link>.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="nutshell-new-custom-project">Create a custom project</term>
+<listitem>
+<para>There is no direct way to create a custom project (&ie; a project
+which does use its own makefiles). Use
+<menuchoice><guimenu>Project</guimenu> <guimenuitem>Import Existing
+Project</guimenuitem></menuchoice> instead. Remember to set the appropriate
+<guilabel>Project Type</guilabel>, labeled by an additional <quote>(Custom
+Makefiles)</quote>, in the dialog.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="nutshell-project-options">Use project options early</term>
+<listitem>
+<para>Whenever you start a new project do not forget to set the
+<menuchoice><guimenu>Project</guimenu> <guimenuitem>Project
+Options...</guimenuitem></menuchoice> to your needs.</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<variablelist id="nutshellitem-compilation">
+<title>Compilation</title>
+<varlistentry>
+<term id="nutshell-compilemsg-detail"><link
+linkend="setup-main-compile">Missing detail in compilation
+messages</link></term>
+<listitem>
+<para>If during compilations you notice some valuable information is missing
+in the <guilabel>Messages Output View</guilabel> window, it may be that the
+level of message detail is set too low. &RMB; click in the window and select
+another detail level from the context menu.<!-- they are programmers, so -->
+<!-- they should know what a context menu is. (Re: But they keep on asking -->
+<!-- just about this one all the time!! bp) -->
+</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<variablelist id="nutshellitem-automake">
+<title><link linkend="automake-manager">&automanag;</link></title>
+
+<varlistentry>
+<term>Create new files in a project</term>
+<listitem>
+<para>Select the sub-project in the upper half of the &automanag;, then
+&RMB; click in the lower half on the groups title you want to have the files
+added and select <guimenuitem>Create New File...</guimenuitem>.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry id="nutshell-add-project-file">
+<term>Add existing files to a project</term>
+<listitem>
+<para>Select the sub-project in the upper half of the &automanag;, then
+&RMB; click in the lower half on the groups title you want to have the files
+added and select <guimenuitem>Add Existing Files...</guimenuitem>.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Remove a file from a project</term>
+<listitem>
+<para>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,
+&RMB; click on the file in this list and select
+<guimenuitem>Remove</guimenuitem>.</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<variablelist id="nutshellitem-compilemake">
+<title>Compile/Make Problems</title>
+<varlistentry>
+<term id="nutshell-builddirproblems"><link
+linkend="defaultbuild-warning">Project does not build again after switching
+to/from default target</link></term>
+<listitem>
+<para>There is a problem with the &automake;/&autoconf; machinery. If
+<menuchoice> <guimenu>Project</guimenu> <guimenuitem>Build
+Configuration</guimenuitem></menuchoice> provides to select from three build
+directories: <guimenuitem>default</guimenuitem>,
+<guimenuitem>optimized</guimenuitem>, and <guimenuitem>debug</guimenuitem>,
+by all means stick to <emphasis>either</emphasis> the default
+<emphasis>or</emphasis> the debug/optimized targets.</para>
+<itemizedlist>
+<listitem>
+<para>Once you configured your project with default it will no longer build
+with debug or optimzed.</para>
+</listitem>
+<listitem>
+<para>Once you configured your project with debug or optimzed it will no
+longer build with default.</para>
+</listitem>
+</itemizedlist>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="nutshell-autoconf-problem"><quote>Wrong
+<command>autoconf</command> version</quote> &etc; Error</term>
+<listitem>
+<para>There are several error messages concerning too old versions of
+<application>autoconf</application> &etc; prohibiting
+<command>configure</command> to work properly. Run
+<command>autoreconf</command> in the directory tree where the
+<filename>configure.in</filename> files in question are. This command will
+try to update the information in the &GNU; Build System files. See
+<command>man autoreconf</command> for more information.</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<variablelist id="nutshellitem-others">
+<title>Other Topics</title>
+<varlistentry>
+<term id="nutshell-others-files"><link linkend="app-files">Configuration
+Files used by &kdevelop;</link></term>
+<listitem>
+<para>Usually you should not need to care, but this is very useful to know
+in case something went wrong with your setup.</para>
+</listitem>	
+</varlistentry>
+</variablelist>
+
+</appendix> <!-- nutshell -->
diff --git a/doc/kdevelop/open-project.png b/doc/kdevelop/open-project.png
new file mode 100644
index 00000000..c7b1ee20
--- /dev/null
+++ b/doc/kdevelop/open-project.png
diff --git a/doc/kdevelop/open-recent-project.png b/doc/kdevelop/open-recent-project.png
new file mode 100644
index 00000000..20a1adc6
--- /dev/null
+++ b/doc/kdevelop/open-recent-project.png
diff --git a/doc/kdevelop/plugin-tools.docbook b/doc/kdevelop/plugin-tools.docbook
new file mode 100644
index 00000000..1c07cb7a
--- /dev/null
+++ b/doc/kdevelop/plugin-tools.docbook
@@ -0,0 +1,433 @@
+<appendix id="plugin-tools">
+<title>Plugin Tools</title>
+
+<indexterm zone="plugin-tools">
+  <primary>plugins</primary></indexterm>
+
+<para>
+&kdevelop; contains a large number of little tools that help you to perform
+certain task. Most of them are realized as plugins. That means, if you do not
+need a plugin, you can disable it.</para>
+<para>That also means, if you are looking for a functionality that should be there
+and isn't, then maybe it's implemented in a plugin and that plugin is disabled.
+For example, in the file menu there is a Quick Open feature, but only if
+it's enabled in the Project - Project Options dialog.
+</para>
+ 
+<para>Technically, plugins are based on the KDevPlugin class defined in 
+lib/interfaces/kdevplugin.h. The following is taken from a comment from there.</para>
+
+<para> 
+KDevPlugin is the base class for all KDevelop plugins.
+A plugin is a component which is loaded into KDevelop shell at startup or by request.
+A plugin has a scope that can be either:
+<itemizedlist>
+<listitem><simpara>Core</simpara></listitem>
+<listitem><simpara>Global</simpara></listitem>
+<listitem><simpara>Project</simpara></listitem>
+</itemizedlist>
+</para>
+
+<para>Core plugins are global plugins which offer some important "core" functionality and thus
+are not selectable by user in plugin configuration pages.</para>
+
+<para>Global plugins are plugins which require only shell to be loaded and do not operate on 
+KDevProject interface and/or do not use project wide information.
+For example, the uimode plugin allows a developer to select which user interface they wish to use. 
+</para>
+
+<para>Project plugins require a project to be loaded and are usually loaded/unloaded along with the project.
+If a plugin operates on project-related information then it is a project plugin.
+The Automake Manager, for example, only needs to be active when an Automake based project is currently loaded. 
+</para>
+
+<para>As stated above, core plugins cannot be disabled. Global plugins can be
+enabled/disabled in <menuchoice><guimenu>Settings</guimenu>
+<guimenuitem>Configure KDevelop...</guimenuitem></menuchoice>
+under <guibutton>Plugins</guibutton>.
+Project plugins can be
+enabled/disabled in <menuchoice><guimenu>Project</guimenu>
+<guimenuitem>Project Options...</guimenuitem></menuchoice>
+under <guibutton>Plugins</guibutton>.
+Active plugins can have many effects on KDevelop. 
+Depending on their function, they may add extra menus, extra menu items, extra tool buttons, etc. 
+</para>
+
+<para>Plugins which are disabled do not clutter your menus and are not loaded
+into memory.
+</para>
+
+
+<para>The following plugin list is generated by a small script
+(listplugins.sh) written by Volker Paul. All plugins have a .desktop file
+where information such as name and comments are written.
+If in the following these comments are not very useful,
+it is because the plugin authors made them this way.</para>
+<para>The plugins are grouped by scope (Core, Global, Project).</para>
+
+<para>Scope: Core</para>
+<itemizedlist>
+<listitem><formalpara id="KDevAppWizard">
+<title>Application Wizard</title>
+<para>Application Wizard</para></formalpara></listitem>
+<listitem><formalpara id="KDevDiff">
+<title>Difference Viewer</title>
+<para>Difference Viewer</para></formalpara></listitem>
+<listitem><formalpara id="KDevFileCreate">
+<title>FileCreate</title>
+<para>FileCreate</para></formalpara></listitem>
+<listitem><formalpara id="KDevFullScreen">
+<title>FullScreen</title>
+<para>FullScreen</para></formalpara></listitem>
+<listitem><formalpara id="KDevTipOfDay">
+<title>Tip of the Day</title>
+<para>Tip of the Day</para></formalpara></listitem>
+<listitem><formalpara id="KDevUIChooser">
+<title>User-Interface Selection</title>
+<para>Provides a dialog for UI-mode selection.</para></formalpara></listitem>
+<listitem><formalpara id="KDevVCSManager">
+<title>VCSManager</title>
+<para>Version Control System Manager </para></formalpara></listitem>
+</itemizedlist>
+
+<para>Scope: Global</para>
+<itemizedlist>
+<listitem><formalpara id="KDevAbbrev">
+<title>Abbreviation Expansion</title>
+<para>Provides support for customizable abbreviations - short words which expand into commonly needed code structures.</para></formalpara></listitem>
+<listitem><formalpara id="KDevDocumentation">
+<title>Documentation</title>
+<para>The Documentation plugin offers browsing and searching in local and online documentation with support for multiple documentation systems.</para></formalpara></listitem>
+<listitem><formalpara id="KDevfilelist">
+<title>FileList</title>
+<para>Provides a list of all currently open files. (Handy when the tab bar is not quite wide enough.)</para></formalpara></listitem>
+<listitem><formalpara id="KDevFileSelector">
+<title>File Selector</title>
+<para>Powerful network transparent file browser utility.</para></formalpara></listitem>
+<listitem><formalpara>
+<title>Shell Filtering and Insertion</title>
+<para>Provides a way of manipulating editor text using commandline tools. Appears in the Tools menu.</para></formalpara></listitem>
+<listitem><formalpara id="KDevGrepView">
+<title>Grep Frontend</title>
+<para>Integrates "find|grep" in KDevelop - allows fast searching of multiple files using patterns or regular expressions.</para></formalpara></listitem>
+<listitem><formalpara id="KDevKonsoleView">
+<title>Embedded Konsole</title>
+<para>This plugin gives KDevelop an embedded konsole for quick and easy command line access.</para></formalpara></listitem>
+<listitem><formalpara id="KDevOpenWith">
+<title>"Open with" Menu Addon</title>
+<para>This plugin provides additional "open" alternatives for various context menus in KDevelop.</para></formalpara></listitem>
+<listitem><formalpara id="KDevPartExplorer">
+<title>Part Explorer Tool</title>
+<para>A Graphical tool for performing KTrader-like queries about registered services</para></formalpara></listitem>
+<listitem><formalpara id="KDevRegexpTest">
+<title>Regular Expression Tester</title>
+<para>Tool to design and test regular expressions against common regexp syntaxes.</para></formalpara></listitem>
+<listitem><formalpara id="KDevReplace">
+<title>Replace Part</title>
+<para>This plugin is an interactive projectwide "Search and Replace" tool. Search using string or regexp matching, and select the replacements to be made from a preview before the action is finalized. When loaded it appears in the Edit menu.</para></formalpara></listitem>
+<listitem><formalpara id="KDevscripting">
+<title>Scripting</title>
+<para>The Scripting plugin offers KScript based scripting of the KDevelop application</para></formalpara></listitem>
+<listitem><formalpara id="Code_Snippets">
+<title>Code Snippets</title>
+<para>This plugin allows you to store code snippets and add them to your code</para></formalpara></listitem>
+<listitem><formalpara id="KDevTextTools">
+<title>Text Structure</title>
+<para>Provides a structure overview and navigation for HTML and TEX files</para></formalpara></listitem>
+<listitem><formalpara id="KDevTools">
+<title>Tools Menu Addition</title>
+<para>This plugin provides an easy way to add external applications to the Tools menu and toolbar.</para></formalpara></listitem>
+<listitem><formalpara id="KDevvalgrind">
+<title>Valgrind Frontend</title>
+<para>Valgrind is a tool that helps you find memory management problems in programs. http://developer.kde.org/~sewardj/</para></formalpara></listitem>
+</itemizedlist>
+
+<para>Scope: Project</para>
+<itemizedlist>
+<listitem><formalpara id="KDevannotation">
+<title>annotation Plugin</title>
+<para>annotation Description</para></formalpara></listitem>
+<listitem><formalpara id="KDevAStyle">
+<title>Source Code Formatter</title>
+<para>A plugin for formatting of sourcecode according to a specified set of rules. When loaded it is found in the Tools menu.</para></formalpara></listitem>
+<listitem><formalpara id="KDevBookmarks">
+<title>Bookmarks</title>
+<para>Plugin that provides navigation and overview of active source bookmarks and persists them between sessions.</para></formalpara></listitem>
+<listitem><formalpara id="KDevClassView">
+<title>Class View</title>
+<para>This plugin displays a graphical view of all the classes in the project, complete with methods and attributes, and provides a way of direct source navigation.</para></formalpara></listitem>
+<listitem><formalpara id="KDevcopyto">
+<title>CopyTo</title>
+<para>Simple file uploader plugin. It does a file copy over any KIO supported protocol.</para></formalpara></listitem>
+<listitem><formalpara id="KDevCTags2">
+<title>CTags Frontend</title>
+<para>CTags is a source navigation tool with support for many languages. When loaded it provides a context menu for finding type declarations/definitions and also a query dialog. http://ctags.sourceforge.net/</para></formalpara></listitem>
+<listitem><formalpara id="KDevdistpart">
+<title>Final Packaging Support</title>
+<para>Aids in building and publishing the final project. Only RPM package format is supported for now.</para></formalpara></listitem>
+<listitem><formalpara id="KDevDoxygen">
+<title>Doxygen Support</title>
+<para>The doxygen plugin provides a way to specify and control generation of documentation for a project, based on source code content. You need to have doxygen installed to be able to use this. For more info goto http://www.doxygen.org</para></formalpara></listitem>
+<listitem><formalpara id="KDevQuickOpen">
+<title>QuickOpen</title>
+<para>Provides an efficient way of finding/opening files, classes and methods in a large project. Appears in the File and Tools menus when loaded.</para></formalpara></listitem>
+<listitem><formalpara id="KDevSecurity">
+<title>Security Checker</title>
+<para>Code security checker</para></formalpara></listitem>
+</itemizedlist>
+<para>So far the generated plugin list.</para>
+
+
+<table id="table-project-parts">
+<title>Project Management Plugins in &kdevelop;</title>
+<tgroup cols="2"><tbody>
+<row>
+  <entry>antproject</entry>
+  <entry>ANT Project Manager (&Java; applications)</entry>
+</row>
+<row>
+  <entry>autoproject</entry>
+  <entry>Automake Project Manager</entry>
+</row>
+<row>
+  <entry>customproject</entry>
+  <entry>Custom Project Manager</entry>
+</row>
+<row>
+  <entry>trollproject</entry>
+  <entry>QMake based Project Manager</entry>
+</row>
+</tbody></tgroup>
+</table>
+<para>The above plugins are currently (May 2005) empty. Maybe 
+project management support will be implemented as plugins
+in the future.</para>
+
+
+<table>
+<title>Language Support Plugins in &kdevelop;</title>
+<tgroup cols="2">
+<tbody>
+<row><entry>cppsupport</entry><entry>Support for C/C++</entry></row>
+<row><entry>fortransupport</entry><entry>Support for Fortran</entry></row>
+<row><entry>javasupport</entry><entry>Support for &Java;</entry></row>
+<row><entry>perlsupport</entry><entry>Support for Perl</entry></row>
+<row><entry>phpsupport</entry><entry>Support for PHP</entry></row>
+<row><entry>pythonsupport</entry><entry>Support for Python</entry></row>
+</tbody></tgroup>
+</table>
+
+
+<para>In the following, some of the plugins will be discussed in detail.</para>
+
+<itemizedlist>
+<listitem>
+<formalpara>
+<title>The <command>abbrev</command> Plugin</title>
+<indexterm zone="plugin-tools"><primary><command>abbrev</command></primary></indexterm>
+
+<para>
+This plugin expands abbreviations into frequently used code snippets. It is
+activated by pressing <keycombo><keycap>Ctrl</keycap>
+<keycap>Space</keycap></keycombo>. For example, when you enter
+<literal>"ife"</literal> into a C++ in the editor and press
+<keycombo><keycap>Ctrl</keycap><keycap>Space</keycap></keycombo>, you obtain
+an <literal>if-else</literal> 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;.
+</para>
+</formalpara>
+
+<para>
+The set of code templates is configurable. If the plugin is enabled, you can see
+which ones are available in the <menuchoice><guimenu>Settings</guimenu>
+<guimenuitem>Configure KDevelop...</guimenuitem></menuchoice>
+dialog under <guibutton>Abbreviations</guibutton>.
+</para>
+</listitem>
+
+<listitem>
+<formalpara id="KDevFilter">
+<title>The <command>filter</command> Plugin</title>
+<indexterm zone="plugin-tools"><primary><command>filter</command></primary></indexterm>
+
+<para>
+This offers two features. If you select <menuchoice><guimenu>Tools</guimenu>
+<guimenuitem>Execute command</guimenuitem></menuchoice>, you can enter a shell
+command. The output of this command is inserted into the editor buffer when
+you hit the <guibutton>Start</guibutton> button.
+</para>
+</formalpara>
+
+<para>
+A related feature is available under
+<menuchoice><guimenu>Tools</guimenu><guimenuitem>Filter selection through
+command...</guimenuitem></menuchoice>.  In order to use this, you must
+select a text area in the editor. If you now enter a shell command and hit
+the <guibutton>Start</guibutton> 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, replacing the selection.
+</para>
+
+<para>
+For example, if you write documentation, you frequently have to refer
+to menu items. To do this correctly for e.g. the Copy command in the 
+Edit menu, you have to write:
+<programlisting>&lt;menuchoice&gt;&lt;guimenu&gt;Edit&lt;/guimenu&gt;&lt;guimenuitem&gt;Copy&lt;/guimenuitem&gt;&lt;/menuchoice&gt;</programlisting>
+This is cumbersome, so you'd rather just write "Edit - Copy"
+and let the computer do the tagging.
+Here is how you can do it.
+You write a little shell script called mef you put e.g. in your home's bin directory:
+<programlisting>sed s/"^\(.*\) - \(.*\)\$"/"&lt;menuchoice&gt;&lt;guimenu&gt;\1&lt;\/guimenu&gt;&lt;guimenuitem&gt;\2&lt;\/guimenuitem&gt;&lt;\/menuchoice&gt;"/</programlisting>
+Don't forget to make it executable.
+That's all. Now, in your documentation .docbook source, you write "Edit - Copy".
+You select this text you just wrote, choose
+<menuchoice><guimenu>Tools</guimenu><guimenuitem>Filter selection through
+command...</guimenuitem></menuchoice> and call ~/bin/mef.
+Instantly "Edit - Copy" is replaced by
+<programlisting>&lt;menuchoice&gt;&lt;guimenu&gt;Edit&lt;/guimenu&gt;&lt;guimenuitem&gt;Copy&lt;/guimenuitem&gt;&lt;/menuchoice&gt;</programlisting>
+</para>
+
+
+</listitem>
+
+<listitem>
+<formalpara>
+<title>The &doxygen; Plugin</title>
+<indexterm zone="plugin-tools"><primary>&doxygen;</primary></indexterm>
+<indexterm zone="plugin-tools"><primary>documentation tool</primary></indexterm>
+<indexterm zone="plugin-tools"><primary>API documentation</primary></indexterm>
+
+<para>
+This one helps you to use the &doxygen; API documentation tool
+(<ulink url="http://www.doxygen.org"/>). You can select
+<menuchoice><guimenu>Project</guimenu>
+<guimenuitem>Run Doxygen</guimenuitem></menuchoice> to generate API
+documentation for your current project, based on the configuration given by
+the file <filename>Doxyfile</filename> in your project directory.
+</para>
+</formalpara>
+
+<para>
+Furthermore, you can configure &doxygen; in the
+<menuchoice><guimenu>Project</guimenu>
+<guimenuitem>Project options...</guimenuitem></menuchoice> dialog. This dialog
+is very similar to the &doxywizard; tool.
+</para>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>The &ctags; Plugin</title>
+<indexterm zone="plugin-tools"><primary>&ctags;</primary></indexterm>
+
+<para>
+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.
+</para>
+</formalpara>
+
+<para>
+You activate this plugin under <menuchoice><guimenu>Tools</guimenu>
+<guimenuitem>CTags...</guimenuitem></menuchoice>. 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
+<filename>tags</filename> in your project directory. This is a text file containing
+all symbols of your source files.
+</para>
+
+<para>
+You can search in the symbol database in two ways: when the
+<guilabel>Regular expression match</guilabel> 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 <literal>.*Widget</literal>
+will search for all symbols ending with <literal>Widget</literal>. If the
+box is not checked, the search will be verbatim.
+</para>
+
+<para>
+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.
+</para>
+
+<para>
+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.
+</para>
+
+<para>
+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 <filename>tags</filename> file in regular intervals by pressing
+the button <guibutton>Regenerate</guibutton>.
+</para>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>The <command>astyle</command> Plugin</title>
+<indexterm zone="plugin-tools"><primary><command>astyle</command></primary></indexterm>
+<indexterm zone="plugin-tools"><primary><application>Artistic Style</application></primary></indexterm>
+<indexterm zone="plugin-tools"><primary>indentation</primary></indexterm>
+
+<para>
+Astyle is a plugin for formatting of sourcecode according to a specified set of rules.
+</para>
+</formalpara>
+</listitem>
+
+<listitem>
+<formalpara>
+<title>The <command>regexptest</command> Plugin</title>
+<indexterm zone="plugin-tools"><primary><command>regexptest</command></primary></indexterm>
+<indexterm zone="plugin-tools"><primary>debugging</primary><secondary>regular expressions</secondary></indexterm>
+<indexterm zone="plugin-tools"><primary>regular expressions</primary><secondary>debugging</secondary></indexterm>
+
+<para>
+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
+<menuchoice><guimenu>Tools</guimenu>
+<guimenuitem>Debug Regular Expression...</guimenuitem></menuchoice>.
+</para>
+</formalpara>
+
+<para>
+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;.
+</para>
+
+<para>
+When you enter an expression, you get immediate feedback about any syntax
+errors in it. By entering a text under <guilabel>Test string</guilabel>,
+you can see whether the expression matches this string. In particular, if
+your regular expression includes groups, such as <literal>([a-z])</literal>,
+the content of the matched subgroups will be shown in a list box.
+</para>
+</listitem>
+
+<!--
+<listitem>
+<formalpara>
+<title>The <command>konsole</command> Plugin</title>
+<indexterm zone="plugin-tools"><primary><command>konsole</command></primary></indexterm>
+<indexterm zone="plugin-tools"><primary>terminal</primary><secondary>embedded</secondary></indexterm>
+<para></para>
+</formalpara>
+</listitem>
+-->
+
+</itemizedlist>
+
+</appendix> <!-- plugin-tools -->
+
+<!-- ====================================================================== -->
diff --git a/doc/kdevelop/problem-report-all-todos.png b/doc/kdevelop/problem-report-all-todos.png
new file mode 100644
index 00000000..7b2d1b62
--- /dev/null
+++ b/doc/kdevelop/problem-report-all-todos.png
diff --git a/doc/kdevelop/problem-report-marks.png b/doc/kdevelop/problem-report-marks.png
new file mode 100644
index 00000000..1e01ebdf
--- /dev/null
+++ b/doc/kdevelop/problem-report-marks.png
diff --git a/doc/kdevelop/problem-report-todo.png b/doc/kdevelop/problem-report-todo.png
new file mode 100644
index 00000000..56ccbd54
--- /dev/null
+++ b/doc/kdevelop/problem-report-todo.png
diff --git a/doc/kdevelop/project-advanced.docbook b/doc/kdevelop/project-advanced.docbook
new file mode 100644
index 00000000..d597e65e
--- /dev/null
+++ b/doc/kdevelop/project-advanced.docbook
@@ -0,0 +1,83 @@
+<chapter id="projects-advanced">
+
+<chapterinfo>
+  <authorgroup>
+    <author><firstname>Bernd</firstname><surname>Pol</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</chapterinfo>
+
+<title>Advanced Project Management</title>
+
+<sect1 id="oldprojects">
+<title>Loading Projects</title>
+
+<sect2 id="loading-recent-project">
+<title>Loading a Recently Used Project</title>
+
+<para>
+(... to be written ...)
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="open-recent-project.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    How to open a recent project
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+
+</sect2> <!-- loading-recent-project -->
+
+<sect2 id="loading-project">
+<title>Loading an Existing Project</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- loading-project -->
+
+<sect2 id="converting-projects">
+<title>Converting Old KDevelop Project Files</title>
+
+<para>
+&kdevelop; allows you to open old KDevelop 2.x project files and convert them to &kdevelop; files. To do so go to <guimenuitem>Open Project...</guimenuitem> and select <guilabel>KDevelop 2 project files</guilabel> in the <guilabel>Filter:</guilabel>. Then select project file you want to open. The project gets converted to &kdevelop; and saved as a <guilabel>&kdevelop; project file</guilabel>.
+</para>
+
+</sect2> <!-- converting-projects -->
+
+<sect2 id="importing-projects">
+<title>Importing an Existing Project</title>
+
+<para>
+To import an existing directory in &kdevelop; select <guimenuitem>Import Existing Directory</guimenuitem>
+from the <guimenu>Project</guimenu> menu.  You should see the Import Directory Wizard, as seen below:
+</para>
+
+<figure id="screenshot-importdirectory" float="1">
+<title>The Import Directory Dialog</title>
+<mediaobject>
+<imageobject><imagedata fileref="importdirectory.png"/></imageobject>
+</mediaobject>
+</figure>
+
+</sect2> <!-- importing-projects -->
+
+</sect1> <!-- oldprojects -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="project-options">
+<title>Tailoring the Project &mdash; Project Options</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect1> <!-- project-options -->
+
+</chapter> <!-- projects-advanced -->
diff --git a/doc/kdevelop/project-management.docbook b/doc/kdevelop/project-management.docbook
new file mode 100644
index 00000000..38a3ff8d
--- /dev/null
+++ b/doc/kdevelop/project-management.docbook
@@ -0,0 +1,751 @@
+<chapter id="project-management">
+
+<chapterinfo>
+  <authorgroup>
+    <author><firstname>Bernd</firstname><surname>Pol</surname></author>
+    <author><firstname>Ian</firstname><surname>Wadham</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</chapterinfo>
+
+<title>Building and Project Management</title>
+
+<para>
+This chapter deals only with compiled projects, such as C++, &Java; or
+Fortran projects. Projects for scripting languages like Python and
+PHP work very differently.
+</para>
+
+<para>
+You will find here information on:</para>
+<itemizedlist>
+  <listitem><para>
+  <link linkend="automake-manager-summary">Summary of &automanag;</link> containing an initial overall view of &automanag;,
+  </para></listitem>
+  <listitem><para>
+  <link linkend="automake-manager-operation">Automake Manager Operation</link> describing the basics of how to work with &automanag;,
+  </para></listitem>
+</itemizedlist>
+
+<sect1 id="automake-manager-summary">
+<title>Summary of &automanag;</title>
+
+<para>
+In the <link linkend="unixdev-buildsystems">Build systems</link> chapter we have given a rough overview of the build systems commonly in use on &UNIX; systems. In the following sections we will look at this in more detail.
+</para>
+<para>
+There is some confusion about how to name such things. &GNU; calls them <quote>build systems</quote> when it describes Automake, Autoconf and Libtool. QMake calls itself <quote>a tool to write Makefiles for different compilers and platforms</quote>. In &kde; often the term <quote>project management systems</quote> is used. We will use this term in a broader sense to describe the built-in environments in &kdevelop; which are used to organize and build your projects. In the context of this section, however, we will mostly talk about <quote>automated build systems</quote>.
+</para>
+
+<sect2 id="automake-manager-summary-buildsys">
+<title>The Need for an Automated Build System</title>
+
+<para>
+If you have a simple <quote>Hello World</quote> program, written in C, you can compile and link it using &gcc; <parameter>-o hello hello.c</parameter> and execute it using the command <command>./hello</command>, so you do not even need a <filename>Makefile</filename>.
+</para>
+<para>
+If you have a C application with several modules and header files and you are only going to run it on your own machine (&ie; it is an in-house application), you will only need a simple <filename>Makefile</filename>, which is fairly easy to write by hand (use <userinput>info make</userinput> to find out more).
+</para>
+<para>
+The complications begin when:
+</para>
+<itemizedlist>
+  <listitem><para>
+  Your source-code, documentation, graphics, sounds, translations, data files, &etc; are located in more than one directory,
+  </para></listitem>
+  <listitem><para>
+  You have a hierarchy of directories and sub-directories,
+  </para></listitem>
+  <listitem><para>
+  You are using libraries that are not part of the traditional &UNIX; set, such as the &Qt; Object Library or the &kde; Desktop libraries,
+  </para></listitem>
+  <listitem><para>
+  You are using a pre-processor to generate some of your source-code, such as Qt's MOC pre-compiler,
+  </para></listitem>
+  <listitem><para>
+  You aim to distribute your application worldwide, to people who may not have the same &UNIX;/&Linux; system, software and hardware as you,
+  </para></listitem>
+  <listitem><para>
+  You require an automated Install and Uninstall facility,
+  </para></listitem>
+  <listitem><para>
+  You aim to make your application part of the &kde; Desktop set.
+  </para></listitem>
+</itemizedlist>
+
+<para>
+If you have some or all of the above situations, you probably need a <emphasis>build system</emphasis>. In the example above we used &gcc; to compile and build the <quote>Hello World</quote> program, but not all C compilers are called <quote>&gcc;</quote>. So if you distribute your application to someone who is using some other C compiler, your Makefile must somehow use the name of that person's compiler, otherwise your application will fail to compile&mdash;and that is just simple example of what can go wrong.
+</para>
+<para>
+A build system will iron out these differences for you.
+</para>
+<itemizedlist>
+  <listitem><para>
+  It will check that the libraries you need are present on each receiving machine,
+  </para></listitem>
+  <listitem><para>
+  will automatically scan all your application directories for files to pre-process, compile or install and
+  </para></listitem>
+  <listitem><para>
+  will install the components of your application in the correct receiving directories, making sure that
+  </para></listitem>
+  <listitem><para>
+  the directories are created in the receiving machine as required.
+  </para></listitem>
+</itemizedlist>
+
+<para>
+In brief, a build system offers safe and secure methods for your application to be compiled and installed correctly on any receiving machine. As we have shown before in the <link linkend="makesystems">Project Management Systems</link> survey, &kdevelop; offers three automated build systems and the option of creating your own Makefile, in short (click on the project names to get more information):
+</para>
+<itemizedlist>
+  <listitem><para>
+  <link linkend="automake-project">Automake projects</link> which use the &GNU; standard development tools.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="qmake-project">QMake projects</link> which use the trolltech QMake project manager.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="ant-project">ANT projects</link> which use the Apache ANT project manager for &Java; development.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="custom-project">Custom projects</link> which require you to maintain your own <filename>Makefiles</filename>.
+  </para></listitem>
+</itemizedlist>
+
+<important>
+<para>
+One of these four alternatives must be chosen when you create a project and <emphasis>the choice is difficult to change later</emphasis>, so you should give it some thought before you start.
+</para>
+</important>
+
+</sect2> <!--  automake-manager-summary-buildsys -->
+
+<sect2 id="automake-references">
+<title>Tutorials on Autoconf/Automake/Libtool</title>
+<para>
+There are several tutorials available on the &GNU; Build System (<command>Autoconf</command>, <command>Automake</command> and <command>Libtool</command>) of which the &automanag; makes use.
+</para>
+<itemizedlist>
+  <listitem><para>A short <ulink url="http://www.kdevelop.org/index.html?filename=tutorial_autoconf.html">autoconf tutorial</ulink> written by Christopher W. Curtis available on the &kdevelop; home page. It concentrates on some basic steps to modify a <filename>Makefile</filename>.
+  </para></listitem>
+  <listitem><para>
+  A more detailed tutorial can be found in a greater set of tutorials on  <ulink url="http://www.amath.washington.edu/~lf/tutorials/autoconf/toolsmanual_toc.html"><quote>Developing software with GNU</quote></ulink>.
+  </para></listitem>
+  <listitem><para>
+  And there is the famous <ulink url="http://sources.redhat.com/autobook"><quote>Goat Book</quote></ulink>, titled <quote>Autoconf, Automake, and Libtool</quote>. This is an easily readable, yet concise, introduction in all main aspects of the &GNU; Autotools.
+  </para></listitem>
+</itemizedlist>
+
+</sect2> <!--  automake-references -->
+
+<sect2 id="automake-manager-basics">
+<title>What does &automanag; Do?</title>
+
+<para>
+The <link linkend="applicationwizard">&appwizard;</link> will have set up some initial <filename>Makefile.am</filename> files when you created a <guilabel>New Project</guilabel> of a type that uses the &GNU; Build System, such as <menuchoice><guimenuitem>C++</guimenuitem> <guimenuitem>KDE</guimenuitem> <guimenuitem>Application framework</guimenuitem></menuchoice>. During development &automanag; creates any other <filename>Makefile.am</filename> files for projects that use the &GNU; Build System and maintains them all, &appwizard; and &automanag; created alike.
+</para>
+<para>
+There will be one <filename>Makefile.am</filename> file in each directory of your project that contains files to be compiled or installed. It will contain your specifications for compiling, building and installing files and a reference to any subdirectories that also have a <filename>Makefile.am</filename> file and possibly some files to compile, build and install.
+</para>
+
+<note><para>
+Your project's directories and source files may be structured to any depth, or you may prefer a flat project-structure with all subdirectories at the top level.
+</para></note>
+
+<para>
+The aim of the &GNU; Build System is to produce source-code file structures that can be compiled, built and installed on any &UNIX; or &Linux; system by using the simple commands:
+</para>
+
+<screen>
+./configure
+make
+make install    # Usually as "root".
+</screen>
+
+<para>and can be uninstalled by the command <command>make uninstall</command> (usually as root).
+</para>
+
+<para>
+How does this work? Well <command>configure</command> is a script that
+
+<itemizedlist>
+  <listitem><para>
+  works out the details of whatever system it is in, such as what compiler and libraries to use and where they are located, and then
+  </para></listitem>
+  <listitem><para>
+  creates recursive <filename>Makefile</filename> files by filling in the substitutions in the corresponding <filename>Makefile.in</filename> files.
+  </para></listitem>
+</itemizedlist>
+</para>
+<para>
+The <filename>Makefile.in</filename> are <quote>input</quote> files&mdash;templates which provide basic information for the <filename>Makefile</filename>s to be produced from them by filling in some system dependent information. They are generated by the <command>Automake</command> utility from the <filename>Makefile.am</filename> files.
+</para>
+<para>
+The process of going from <filename>Makefile.am</filename> (<filename>.am</filename> denotes <quote>Automake</quote> template files) to <filename>Makefile</filename> files is handled automatically by the &kdevelop; &promanag;, using the <command>Autoconf</command> utility, <command>M4</command> macros and other arcana we need not go into here.
+</para>
+<para>
+So when <command>make</command> runs, it automatically picks up the correct pieces from the current environment, such as compilers and libraries. Similarly, <command>make install</command> puts your application components, such as executables, documentation and data files in the correct places for that environment.
+</para>
+
+<para>
+If you distribute your application as a <quote>tarball</quote> (a single compressed file that &kdevelop; can create for you), it will include the <filename>Makefile.in</filename> files and the <filename>configure</filename> script file, so the recipient can compile, build and install your application without having <command>Automake</command>, <command>Autoconf</command> or &kdevelop; on their machine. The <filename>Makefile.am</filename> files are also included, just in case the receiver needs to do any source-code modifications.
+</para>
+<note><para>
+The rules are rather different if you distribute via a web-based source-code repository such as &kde; &cvs;.
+</para></note>
+
+</sect2> <!--  automake-manager-basics -->
+
+<sect2 id="automake-manager-basics-summary">
+<title>Summary of What Automake Manager Does</title>
+
+<itemizedlist>
+  <listitem><para>
+  Generates <filename>Makefile.am</filename> files in subdirectories it knows as <quote>subprojects</quote>.
+  </para></listitem>
+  <listitem><para>
+  Updates <filename>Makefile.am</filename> files as the project structure changes.
+  </para></listitem>
+  <listitem><para>
+  Updates <filename>Makefile.am</filename> files as files are added to or removed from the project.
+  </para></listitem>
+  <listitem><para>
+  Accepts definitions of how the various files are to be built or installed and modifies the <filename>Makefile.am</filename> accordingly.
+  </para></listitem>
+  <listitem><para>
+  Accepts parameters used in building or installing (&eg; library names) and ensures that they are used in the required compilation and build steps.
+  </para></listitem>
+</itemizedlist>
+
+</sect2> <!--  automake-manager-basics-summary -->
+
+<sect2 id="automake-file-contents">
+<title>Contents of Automake Files</title>
+
+<para>
+A <filename>Makefile.am</filename> file has lines containing variable-names followed by an equals sign and a list of files or parameter values. The <quote>variables</quote> have two-part names, such as <varname>bin_PROGRAMS</varname>, <varname>myapp_SOURCES</varname> or <varname>kdelnk_DATA</varname>. The second part is called the <emphasis>primary</emphasis> and represents something from which to build or install. The first part is called the <emphasis>prefix</emphasis> and represents:
+</para>
+<itemizedlist>
+  <listitem><para>
+  A <emphasis>directory</emphasis> in which to do installation (&eg; <filename>bin</filename>),
+  </para></listitem>
+  <listitem><para>
+  A <emphasis>qualifier</emphasis> for the primary (&eg; <varname>myapp</varname> for <varname>SOURCES</varname>, indicating that the source files listed after <varname>myapp_SOURCES</varname> go into building <filename>myapp</filename>),
+  </para></listitem>
+  <listitem><para>
+  A special <emphasis>prefix</emphasis> <varname>noinst</varname> (short for <quote>no installation</quote>), usually used to list program header files (<filename>.h</filename>),
+  </para></listitem>
+  <listitem><para>
+  Or the special prefix <varname>EXTRA</varname>, for <emphasis>configuration-dependent</emphasis> stuff.
+  </para></listitem>
+</itemizedlist>
+
+<para>
+For more information on <command>Automake</command> and <filename>Makefile.am</filename> files, look up <userinput>info Automake</userinput>.
+</para>
+<para>
+Basically, &automanag; creates and updates the variable-names and lists of files or parameters. See the following example of a <filename>Makefile.am</filename> for a typical application, called <filename>myapp</filename>.
+</para>
+
+<screen>
+## Makefile.am for myapp
+
+# this is the program that gets installed.  it's name is used for all
+# of the other Makefile.am variables
+bin_PROGRAMS = myapp
+
+# set the include path for X, qt and KDE
+INCLUDES = $(all_includes)
+
+# the library search path.
+myapp_LDFLAGS = $(KDE_RPATH) $(all_libraries)
+
+# the libraries to link against.
+myapp_LDADD   = $(LIB_KFILE) $(LIB_KDEPRINT)
+
+# which sources should be compiled for myapp
+myapp_SOURCES = main.cpp myapp.cpp myappview.cpp
+
+# these are the headers for your project
+noinst_HEADERS = myapp.h myappview.h
+
+# let automoc handle all of the meta source files (moc)
+METASOURCES = AUTO
+
+KDE_ICON = myapp
+
+# this is where the kdelnk file will go
+kdelnkdir = $(kde_appsdir)/Utilities
+kdelnk_DATA = myapp.desktop
+
+# this is where the XML-GUI resource file goes
+rcdir = $(kde_datadir)/myapp
+rc_DATA = myappui.rc
+
+AM_CXXFLAGS = -DMY_C++_PREPROCESSOR_OPTION
+</screen>
+
+<para>
+As you can see, many of the items on the right hand side are symbols of the form <varname>$(xxx)</varname>. These are <emphasis>environment variables</emphasis> which are defined in the actual &kde; environment and are substituted with real values when <command>./configure</command> generates the final <filename>Makefile</filename> files in the receiving machine.
+</para>
+
+<para>
+Also, sometime after you have started with &kdevelop;, it is a good idea to run the command <command>./configure --help</command>, which will show you the range of things you can change at build and installation time, such as for a test environment. In particular, the command:
+
+<screen>
+./configure --prefix=/where/you/wish
+</screen>
+will re-direct the entire installation to a directory structure of your choice, by changing the internal variable <varname>$(prefix)</varname> to value <filename class="directory">/where/you/wish</filename>.
+</para>
+
+</sect2> <!-- automake-file-contents -->
+
+</sect1> <!--  automake-manager-summary -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="automake-manager-operation">
+<title>Automake Manager Operation</title>
+
+<para>
+In this chapter you will find a basic description of the &automanag; elements and how to use them. This covers:
+<itemizedlist>
+  <listitem><para>
+  <link linkend="automake-manager-operation-window">The &automanag; Window</link> describes the basic structure of the &automanag; main window.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="automake-manager-operation-survey-window">The Overall View Window</link> describes the elements of the upper subwindow.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="automake-manager-operation-detail-window">The Detail View Window</link> describes the elements of the lower subwindow.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="automake-manager-operation-navigate">Navigating in the &automanag;</link> lists some basic operations you can perform in the &automanag;.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="automake-manager-operation-popups">Popup Menus in the &automanag;</link> describes the windows which will pop up when you select an action in the &automanag;.
+  </para></listitem>
+</itemizedlist>
+</para>
+
+<sect2 id="automake-manager-operation-window">
+<title>The &automanag; Window</title>
+
+<informaltable frame="none">
+<tgroup cols="2"><tbody><row>
+  <entry><inlinemediaobject>
+    <imageobject>
+      <imagedata fileref="automakemanager.png" format="PNG"/>
+    </imageobject>
+  </inlinemediaobject></entry>
+  <entry valign="top"><itemizedlist>
+    <listitem><para>
+    &automanag; runs in a split window. The top part is called the <emphasis>Overall View</emphasis> and the bottom part is called the <emphasis>Detail View</emphasis>. Between them is a narrow bar that can be dragged with the mouse to adjust the sizes of the views. In IDEAl mode you can also drag the side of the split window to change the width.
+    </para></listitem>
+    <listitem><para>
+    On top of each view there is a <emphasis>toolbar</emphasis>, the buttons in which will become activated when an element in this view is selected. This provides one way you can access the actions provided for that view element. The other are context menus which pop up on right mouse button click as will be discussed below.
+    </para></listitem>
+    <listitem><para>
+    In IDEAl mode there are two additional small buttons in the &automanag; window titlebar left hand side &ndash; a triangular shaped right arrow, and a dot button. The arrow button is used to <emphasis>close the window</emphasis>. The dot button on the other hand will <emphasis>keep the window open</emphasis> even if another &kdevelop; window has been selected. (Otherwise the &automanag; window will automatically close whenever another window gets the input focus.)
+    </para></listitem>
+  </itemizedlist></entry>
+</row></tbody></tgroup>
+</informaltable>
+
+</sect2> <!-- automake-manager-operation-window -->
+
+<sect2 id="automake-manager-operation-survey-window">
+<title>The Overall View Window</title>
+
+<para>
+The overall view window contains a tree-list of all the directories in your project that contain program files, documentation or data. Each such directory contains a <filename>Makefile.am</filename> file and is known in &automanag; as a <emphasis>subproject</emphasis>. There are three typical subprojects in a &kde;-based project as shown in the above illustration:
+</para>
+
+<itemizedlist>
+  <listitem><para>
+  <filename>src</filename> &ndash; source-code files for your application,
+  </para></listitem>
+  <listitem><para>
+  <filename>doc</filename> &ndash; your user manual or Handbook,
+  </para></listitem>
+  <listitem><para>
+  <filename>po</filename> &ndash; extracts of strings in your source-code files that require translation into other human languages (&eg; window titles, menu names, button labels, dialog box text and messages of various kinds).
+  </para></listitem>
+</itemizedlist>
+
+<para>
+Note that the <filename>doc</filename> subproject always has an <filename>en</filename> subproject, which you can see if you click on the <symbol>+</symbol> symbol next to the word <filename>doc</filename>. That is because the base language of all documentation in &kde; is  United States English (en). If your application becomes part of &kde;, the &kde; translation teams may translate your documentation from United States English into other languages and the translations will go into other subprojects, such as <filename>de</filename> (German) or <filename>fr</filename> (French). The strings in the <filename>po</filename> subproject may also be translated and stored in other files in <filename>po</filename>, thus allowing your application to be operated by people who do not know English.
+</para>
+
+<note><para>
+The <filename>doc</filename> and <filename>po</filename> subprojects serve different purposes. <filename>doc</filename> contains <emphasis>documentation</emphasis> like a user manual, <filename>po</filename> contains translatable text strings of the <emphasis>user interface</emphasis> which is integrated in the source code of this application.
+</para></note>
+
+<para>
+The overall view window serves&mdash;amongst other things&mdash;as a navigation tool. If you select a subproject in the overall view window, the corresponding details will be shown in the detail view window.
+</para>
+
+</sect2> <!-- automake-manager-operation-survey-window -->
+
+<sect2 id="automake-manager-operation-detail-window">
+<title>The Detail View Window</title>
+
+<para>
+The detail view contains a tree-list of all the files in the subproject currently selected in the overall view as well as the compilation, build and installation rules for this subproject. Thus the two views together can give you access to all the components of your application and all the information on how to compile, build and install it.
+</para>
+
+<sect3>
+<title>Targets</title>
+
+<para>The tree-list in the detail view has two levels. The top level consists of so-called &automanag; <emphasis>targets</emphasis> and the next level contains lists of files that go to make up each target.
+</para>
+
+<para>
+This concept of an &automanag; target differs somewhat from what a <filename>Makefile</filename> target usually is. In short:</para>
+<itemizedlist>
+  <listitem><para>
+  The definition of how a set of files is to be compiled, built or installed is known as a <emphasis>target</emphasis> in &automanag;, but as a <emphasis>variable</emphasis> in <command>Automake</command> itself.
+  </para></listitem>
+  <listitem><para>
+  A <emphasis>target</emphasis> in <command>make</command> is often something quite different, being the parameter of a <command>make</command> command (&eg; <userinput>make install</userinput>, <userinput>make clean</userinput>).
+  </para>
+  <para>
+  However some <filename>Makefile.am</filename> variables do represent an underlying <emphasis>sub-target</emphasis> in <command>make</command>.
+  </para></listitem>
+</itemizedlist>
+
+</sect3>
+</sect2> <!-- automake-manager-operation-detail-window -->
+
+<sect2 id="automake-manager-operation-navigate">
+<title>Navigating in the &automanag;</title>
+
+<para>
+In both the overall and the detail view you can left-click on the <symbol>+</symbol> or <symbol>-</symbol> next to a subproject or target name to expand or contract the tree view. If you do that with a <emphasis>subproject</emphasis> in the overall view, it shows or hides the subprojects at the next level down (if any). If you do it with a <emphasis>target</emphasis> in the detail view, it shows or hides the list of files that go into that target.
+</para>
+
+<variablelist>
+<varlistentry>
+<term>Opening a file for Edit</term>
+<listitem>
+<para>If you <emphasis>&LMB; click</emphasis> on a file name in the detail
+view, the corresponding file opens up in &kdevelop;'s editing window.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Activating the &automanag; Toolbar Buttons</term>
+<listitem>
+<para>
+If you <emphasis>&LMB; click</emphasis> on the name of a subproject in the
+overall view or target in the detail view, the name is highlighted and some
+toolbar buttons become active in the top part of that view.</para>
+
+<note>
+  <para>
+  It is recommended that you use the <emphasis>right mouse-button and popup menus</emphasis>, rather than the toolbar buttons, because it is then much easier to see and understand what you are doing.
+  </para>
+  <para>
+  Operations on subprojects and targets have far-reaching effects on the structure, compilation, building and installation of your application.
+  </para>
+</note>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Selecting Actions/Popup Menus</term>
+<listitem>
+<para>
+If you <emphasis>&RMB; click</emphasis> on the name of a subproject, target or file, a menu pops up and you can then select actions to perform on the subproject, target or file, such as add a target to the subproject, add a file to a target or logically remove the selected file from its target.
+</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+</sect2> <!-- automake-manager-operation-navigate -->
+
+<sect2 id="automake-manager-operation-popups">
+<title>Popup Menus in the &automanag;</title>
+
+<para>
+The following sections explain in short terms which operations the menus make available which will pop up on right mouse button clicks in the &automanag; window. They are meant for overall view only. You will find detailed descriptions of most operations in a later chapter.
+</para>
+<!-- ### add a link to this chapter when ready -->
+
+<sect3 id="automake-manager-operation-popups-file">
+<title>The Popup Menu for a File</title>
+
+<para>
+When you &RMB; click on a <emphasis>file name</emphasis> in the detail view the following menu will pop up allowing you to select one of several operations to be performed on that file. In the illustration below the <filename>hi-16app-myapp.png</filename> icon file was selected from the <guilabel>Icon data in myapp</guilabel> target of the <guilabel>myapp/src</guilabel> subproject.
+</para>
+
+<informaltable frame="none">
+<tgroup cols="2"><tbody><row>
+  <entry><inlinemediaobject>
+    <imageobject>
+      <imagedata fileref="automake-file-popup.png" format="PNG"/>
+    </imageobject>
+  </inlinemediaobject></entry>
+  <entry valign="bottom"><itemizedlist>
+    <listitem><para>
+    The main popup-menu item for a file is to <guimenuitem>Remove</guimenuitem> the file from its target (&ie; it will no longer be used to compile, build or install that target).
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>CVS</guimenuitem> item offers a variety of CVS operations on the file.
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Open With</guimenuitem> item allows you to open the file with a variety of editors or with any application at all (&eg; you can open the icon file in our example with <application>KIcon</application>).
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Perforce</guimenuitem> item is used for similar operations as in CVS using the commercial <quote><application>Perforce</application></quote> version control system.
+    </para></listitem>
+  </itemizedlist></entry>
+</row></tbody></tgroup>
+</informaltable>
+
+</sect3> <!-- automake-manager-operation-popups-file -->
+
+<sect3 id="automake-manager-operation-popups-target">
+<title>The Popup Menu for a Target</title>
+
+<para>
+When you right-click on a <emphasis>target</emphasis> in the detail view the following menu will pop up allowing you to select one of several operations to be performed on it. In the illustration below the <guilabel>myapp (Program in bin)</guilabel> target of the <guilabel>myapp/src</guilabel> subproject was selected.
+</para>
+
+<informaltable frame="none">
+<tgroup cols="2"><tbody><row>
+  <entry><inlinemediaobject>
+    <imageobject>
+      <imagedata fileref="automake-target-popup.png" format="PNG"/>
+    </imageobject>
+  </inlinemediaobject></entry>
+  <entry valign="bottom"><itemizedlist>
+    <listitem><para>
+    The <guimenuitem>Options</guimenuitem> item for a target only applies to source code files. In the corresponding dialog box you can specify linker flags and paths on which to locate libraries and you can give a list of actual libraries to be linked in to your application.
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Create New File</guimenuitem> item brings up a dialog in which you can set the file name and the type of file to be generated (from a drop-down list).
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Add Existing Files</guimenuitem> item brings up a dialog box in which you can add an already existing file to this target.
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Remove</guimenuitem> item for a target allows you to logically remove the target and all its files from the project structure.
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Make Target Active</guimenuitem> item only applies to targets containing source code files. New files will always be added to such an active target.
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Build Target</guimenuitem> item calls all necessary compile and make operations to build the code for this target only.
+    </para></listitem>
+  </itemizedlist></entry>
+</row></tbody></tgroup>
+</informaltable>
+
+</sect3> <!-- automake-manager-operation-popups-target -->
+
+<sect3 id="automake-manager-operation-popups-subproject">
+<title>The Popup Menu for a Subproject</title>
+
+<para>
+When you &RMB; click on a <emphasis>subproject</emphasis> in the overall view window the following menu will pop up which allows you to make major changes to the structure of your project and the way it is compiled, built and installed. You can use it to expand or modify the basic project structure that the &appwizard; has created.
+</para>
+
+
+<informaltable frame="none">
+<tgroup cols="2"><tbody><row>
+  <entry><inlinemediaobject>
+    <imageobject>
+      <imagedata fileref="automake-subproject-popup.png" format="PNG"/>
+    </imageobject>
+  </inlinemediaobject></entry>
+  <entry valign="bottom"><itemizedlist>
+    <listitem><para>
+    The <guimenuitem>Options</guimenuitem> item for a subproject controls the way that the subproject will be compiled, built and installed. The dialog box that pops up has tabs for Compiler, Includes, Prefixes and Build Order.
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Add Subproject</guimenuitem> item creates a new directory and skeleton Makefile.am file.
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Add Target</guimenuitem> item pops up a dialog in which you can set the rules for compiling, building or installing a group of files within your subproject.
+    </para></listitem>
+    <listitem><para>
+    <guimenuitem>Add Service</guimenuitem> (... to be written ...)
+    </para></listitem>
+    <listitem><para>
+    <guimenuitem>Add Application</guimenuitem> (... to be written ...)
+    </para></listitem>
+    <listitem><para>
+    <guimenuitem>Add Existing Subprojects</guimenuitem> (... to be written ...)
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Remove Subproject</guimenuitem> item in the popup menu for a subproject is the proper way to remove a subproject. It will adjust the <filename>Makefile.am</filename> files accordingly. You will also be offered the option to delete all the files (or links) in the corresponding subdirectory. Obviously, this feature should be used with caution.
+    </para></listitem>
+    <listitem><para>
+    The <guimenuitem>Build</guimenuitem> item calls all necessary compile and make operations to build the code for this subproject only.
+    </para></listitem>
+    <listitem><para>
+    <guimenuitem>Force Reedit</guimenuitem> (... to be written ...)
+    </para></listitem>
+    <listitem><para>
+    <guimenuitem>Clean</guimenuitem> (... to be written ...)
+    </para></listitem>
+    <listitem><para>
+    <guimenuitem>Install</guimenuitem> (... to be written ...)
+    </para></listitem>
+    <listitem><para>
+    <guimenuitem>Install (as root user)</guimenuitem> (... to be written ...)
+    </para></listitem>
+  </itemizedlist></entry>
+</row></tbody></tgroup>
+</informaltable>
+
+</sect3> <!-- automake-manager-operation-popups-subproject -->
+
+</sect2> <!-- automake-manager-operation-popups -->
+
+</sect1> <!-- automake-manager-operation -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="autoproject">
+<title>Automake Projects</title>
+<indexterm zone="autoproject"><primary><command>autoproject</command></primary></indexterm>
+<indexterm zone="autoproject"><primary>&automake;</primary></indexterm>
+<indexterm zone="autoproject"><primary>&autoconf;</primary></indexterm>
+<indexterm zone="autoproject"><primary>&libtool;</primary></indexterm>
+
+<para>
+(... to be written ...)
+</para>
+
+
+<sect2 id="autoconf">
+<title>Autoconf</title>
+<indexterm zone="autoconf"><primary><filename>configure</filename> script</primary></indexterm>
+<indexterm zone="autoconf"><primary><filename>config.status</filename> script</primary></indexterm>
+<indexterm zone="autoconf"><primary><filename>Makefile.in</filename></primary></indexterm>
+<indexterm zone="autoconf"><primary><filename>config.h.in</filename></primary></indexterm>
+
+<para>
+<filename>Makefile.in</filename> into <filename>Makefile</filename>
+</para>
+
+<programlisting>
+prefix = @prefix@
+INSTALL = @INSTALL@
+build_triplet = @build@
+CXX = @CXX@
+</programlisting>
+
+<programlisting>
+prefix = /home/bernd/kde3
+INSTALL = /usr/bin/ginstall -c -p
+build_triplet = i686-pc-linux-gnu
+CXX = g++
+</programlisting>
+
+<para>
+<filename>config.h.in</filename> into <filename>config.h</filename>
+</para>
+
+<programlisting>
+/* Define if you have libz */
+#undef HAVE_LIBZ
+/* The size of a `int', as computed by sizeof. */
+#undef SIZEOF_INT
+</programlisting>
+
+<programlisting>
+/* Define if you have libz */
+#define HAVE_LIBZ 1
+/* The size of a `int', as computed by sizeof. */
+#define SIZEOF_INT 4
+</programlisting>
+
+</sect2> <!-- autoconf -->
+
+
+<sect2 id="automake">
+<title>Automake</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect2> <!--automake  -->
+
+
+<sect2 id="automake-manager">
+<title>&kdevelop;'s &automanag;</title>
+
+<figure id="screenshot-automake-manager" float="1">
+<title>A screenshot of the automake manager</title>
+<mediaobject>
+<imageobject><imagedata fileref="automake-manager.png"/></imageobject>
+</mediaobject>
+</figure>
+
+</sect2> <!-- automake-manager -->
+
+
+<sect2 id="automakelibrary">
+<title>Building and Installing Libraries</title>
+
+<para>
+<itemizedlist>
+<listitem><para>
+  -rpath
+</para></listitem>
+<listitem><para>
+  PIC
+</para></listitem>
+<listitem><para>
+  static
+</para></listitem>
+<listitem><para>
+  plugins: no-undefined
+</para></listitem>
+</itemizedlist>
+</para>
+
+</sect2> <!-- automakelibrary -->
+
+</sect1> <!-- autoproject -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="customproject">
+<title>Custom Makefiles and Build Scripts</title>
+<indexterm zone="customproject"><primary><filename>Makefile</filename></primary></indexterm>
+<indexterm zone="customproject"><primary><filename>build.xml</filename></primary></indexterm>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect1> <!-- customproject -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="compileroptions">
+<title>Compiler Options</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect1> <!-- compileroptions -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="makeoptions">
+<title>Make Options</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect1> <!-- makeoptions -->
+
+</chapter> <!-- project-management -->
diff --git a/doc/kdevelop/raw-project-warning.png b/doc/kdevelop/raw-project-warning.png
new file mode 100644
index 00000000..c9065815
--- /dev/null
+++ b/doc/kdevelop/raw-project-warning.png
diff --git a/doc/kdevelop/run-button.png b/doc/kdevelop/run-button.png
new file mode 100644
index 00000000..51522e90
--- /dev/null
+++ b/doc/kdevelop/run-button.png
diff --git a/doc/kdevelop/script_location.png b/doc/kdevelop/script_location.png
new file mode 100644
index 00000000..e5488024
--- /dev/null
+++ b/doc/kdevelop/script_location.png
diff --git a/doc/kdevelop/select-user-interface-0.png b/doc/kdevelop/select-user-interface-0.png
new file mode 100644
index 00000000..c98faf71
--- /dev/null
+++ b/doc/kdevelop/select-user-interface-0.png
diff --git a/doc/kdevelop/select-user-interface.png b/doc/kdevelop/select-user-interface.png
new file mode 100644
index 00000000..927ad411
--- /dev/null
+++ b/doc/kdevelop/select-user-interface.png
diff --git a/doc/kdevelop/setup.docbook b/doc/kdevelop/setup.docbook
new file mode 100644
index 00000000..e5449a99
--- /dev/null
+++ b/doc/kdevelop/setup.docbook
@@ -0,0 +1,1990 @@
+<chapter id="setup">
+
+<chapterinfo>
+  <authorgroup>
+    <author><firstname>Bernd</firstname><surname>Pol</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</chapterinfo>
+
+<title>Configuring &kdevelop;</title>
+
+<para>
+&kdevelop; is a very powerful and flexible IDE which offers many ways to tailor it to your needs. To start configuration select <menuchoice><guimenu>Settings</guimenu><guimenuitem>Configure &kdevelop;...</guimenuitem></menuchoice>. This will cause the configuration dialog to pop up consisting of a selection window to the left and the configuration dialog on the right hand side whose contents will vary upon the configuration item you did select.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-select.png" format="PNG"/>
+    </imageobject>
+<textobject>
+<phrase>Select a configuration item</phrase>
+</textobject>
+    <caption><para>
+    Select a configuration item
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+We will discuss these configurations in a different order, split up into the main topics of <link linkend="setup-general">General Configuration</link>, <link linkend="setup-docu">Configuring the Documentation</link>, and <link linkend="setup-advanced">Advanced Configuration</link> which makes for a more intuitive reading.
+</para>
+<para>
+If you want directly look up a certain configuration item use one of the following links.
+</para>
+
+<simplelist>
+  <member><link linkend="setup-main">General</link></member>
+  <member><link linkend="setup-ui">User Interface</link></member>
+  <member><link linkend="setup-templates">File Templates</link></member>
+<member><link linkend="setup-editor">Editor</link></member>
+ <member><link linkend="setup-abbrev">Abbreviations</link></member>
+ <member><link linkend="setup-scripting">Scripting</link></member>
+  <member><link linkend="setup-menu-standard">Tools Menu</link></member>
+  <member><link linkend="setup-menu-external">External Tools</link></member>
+  <member><link linkend="setup-docu">Documentation</link></member>
+  <member><link linkend="setup-snippets">Code Snippets</link></member>
+  <member><link linkend="setup-file-list">File List</link></member>
+  <member><link linkend="setup-file-selector">File Selector</link></member>
+  <member><link linkend="setup-cpp-generator">C++ Class generator</link></member>
+  <member><link linkend="setup-format">Formatting</link></member>
+  <member><link linkend="setup-cpp-parsing">C++ Parsing</link></member>
+</simplelist>
+
+<sect1 id="setup-general">
+<title>General Configuration</title>
+
+<para>
+General configuration concerns the more common tasks of tailoring &kdevelop; as there are:
+</para>
+<itemizedlist>
+  <listitem><para>
+  <link linkend="setup-main">General Setup</link>
+  </para></listitem>
+  <listitem><para>
+  <link linkend="setup-ui">Selecting the User Interface</link>
+  </para></listitem>
+  <listitem>
+    <itemizedlist>
+<title>Source Edit Tasks</title>
+      <listitem><para>
+      <link linkend="setup-editor">Selecting an Editor</link>
+      </para></listitem>
+      <listitem><para>
+      <link linkend="setup-format">Selecting a Source Format Style</link>
+      </para></listitem>
+      <listitem><para>
+      <link linkend="setup-snippets">Setting Up the Code Snippets Tool</link>
+      </para></listitem>
+    </itemizedlist>
+  </listitem>
+  <listitem><para>
+  <link linkend="setup-file-selector">Configuring the File Selector</link>
+  </para></listitem>
+</itemizedlist>
+
+<sect2 id="setup-main">
+<title>General Setup</title>
+
+<para>
+The <guilabel>General</guilabel> configuration dialog allows you to define some basic &kdevelop; behaviour which seldom will change in everyday work. This concerns:
+</para>
+
+<variablelist>
+<varlistentry>
+<term>General project options such as</term>
+<listitem>
+    <itemizedlist>
+      <listitem><para>
+      defining a <link linkend="setup-main-projects">default parent directory</link> &kdevelop; shall use for new projects.
+      </para></listitem>
+       <listitem><para>
+      deciding whether you want &kdevelop; to <link linkend="setup-main-preload">automatically load</link> the project you last worked on.
+      </para></listitem>
+   </itemizedlist>
+  </listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Selecting a font for the most commonly used output view windows,
+namely:</term>
+<listitem>
+
+<itemizedlist>
+<listitem>
+<para>the <link linkend="setup-main-messages-font">Messages Output
+View</link> &kdevelop; uses to communicate &eg; compilation progresses,
+and</para>
+</listitem>
+<listitem>
+<para>the <!--<link linkend="setup-main-applications-font">-->Application Output
+View<!--</link>--> which will show error and state information concerning a running
+application.</para>
+</listitem>
+</itemizedlist>
+
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Some common behaviour concerning the displayed lines in the
+<guilabel>Messages Output View</guilabel> window, namely:</term>
+<listitem>
+    <itemizedlist>
+<listitem>
+<para>whether long lines will <link linkend="setup-main-wrap">wrap
+      around</link>, and </para>
+</listitem>
+<listitem>
+<para>if <link linkend="setup-main-navigation">directory entry and exit
+messages</link> issued by <command>make</command> will be shown.</para>
+</listitem>
+</itemizedlist>
+
+<para>The <link linkend="setup-main-compile">level of detail</link> of
+  messages concerning the compilation process shown in the
+  <guilabel>Messages Output View</guilabel> window.</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-general.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    The general configuration dialog
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<variablelist>
+<varlistentry>
+<term id="setup-main-preload"><guilabel>Load last project on
+startup</guilabel></term>
+<listitem>
+<para>
+Mark this checkbox if you want to continue to work with the last project you worked on. This will cause &kdevelop; to automatically load this project on start-up. It will usually be shown in the state you left work so you can readily proceed.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="setup-main-projects">
+<guilabel>Default projects directory:</guilabel></term>
+<listitem>
+<para>
+By default, &kdevelop; uses a common parent directory for all new
+projects. Enter the absolute path of this common directory in the box or
+select it from your directory structure. &kdevelop; will place the any new
+project here as a subdirectory.</para>
+<note><para>
+You may of course change the directory path of a new project at the time you set it up in the <link linkend="applicationwizard">&appwizard;</link>.
+</para></note>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="setup-main-messages-font"><guilabel>Window font:</guilabel></term>
+<listitem>
+<para>
+The <guilabel>Application Output View</guilabel> window is used to display error and state information from applications which are run from inside &kdevelop;. These are informations the applications usually sends to the console when run stand-alone. So you do not need to leave the IDE when testing the application you currently work on.
+</para>
+<para>
+To select a font suitable for the <guilabel>Messages Output View</guilabel> window click the <guilabel>Window Font</guilabel> button showing the currently selected font (it says <quote>Luxi Sans</quote> in the above illustration). The &kde; standard <guilabel>Select Font</guilabel> dialog will pop up from which you may select the font to be used.
+</para>
+<note><para>
+On first start-up, &kdevelop; initializes this font setting to the standard font for which your &kde; user has been configured. <emphasis>This setting is fixed</emphasis>, so if you alter <menuchoice><guimenuitem>Preferences</guimenuitem><guimenuitem>Appearances &amp; Themes</guimenuitem><guimenuitem>Fonts</guimenuitem></menuchoice> in the <guilabel>Control Center</guilabel>, this will not effect this &kdevelop; font selection. You will have to explicitely reselect the <guilabel>Messages Output View</guilabel> window font.
+</para></note>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="setup-main-compile"><guilabel>Compiler Output</guilabel></term>
+<listitem>
+<para>
+&kdevelop; preprocesses the messages the <guilabel>Messages Output View</guilabel> window receives during the build processes in order to filter superfluous information. You can control the level of detail &kdevelop; will display using the dropdown box in this field.
+</para>
+<variablelist>
+<varlistentry>
+<term><guilabel>Very Short</guilabel></term>
+<listitem><para>
+Displays only warnings, errors, and the filenames which are compiled.
+</para></listitem>
+</varlistentry>
+<varlistentry>
+<term><guilabel>Short</guilabel></term>
+<listitem><para>
+Suppresses all compiler flags and formats the output to be more readable.
+</para></listitem>
+</varlistentry>
+<varlistentry>
+<term><guilabel>Full</guilabel></term>
+<listitem><para>
+Displays all output messages unmodified.
+</para></listitem>
+</varlistentry>
+</variablelist>
+
+<tip><para>
+There is an alternative way to switch the compiler output detail. Just right click in the <guilabel>Messages Output View</guilabel> window and select the according detail level from the popup menu.
+</para></tip>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="setup-main-wrap"><guilabel>Line wrapping</guilabel></term>
+<listitem>
+<para>
+By default, &kdevelop; will wrap long lines around in the <guilabel>Messages Output View</guilabel> window so that valuable information will not be easily overlooked. In some cases this will clutter long message lists. Remove the checkbox mark if you do not want the lines wrap around.
+</para>
+<tip><para>
+There is an alternative way to switch the line wrapping. Just &RMB; click in the <guilabel>Messages Output View</guilabel> window and mark/unmark the <guimenuitem>Line Wrapping</guimenuitem> entry in the menu which will pop up.
+</para></tip>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="setup-main-navigation"><guilabel>Directory navigation
+messages</guilabel></term>
+<listitem>
+<para>
+The <command>make</command> tool usually will display messages like <quote>Entering directory</quote>, or <quote>Leaving directory</quote> when it switches the directories it currently works in. As this clutters the messages list in the <guilabel>Messages Output View</guilabel> window, &kdevelop; suppresses those messages by default. Mark the checkbox if you want to protocol which directories <command>make</command> worked in.
+</para>
+<note><para>
+Changes in this setting effect the processing of new messages only. Old directory navigation messages will be kept visible when you switch this feature off.
+</para></note>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="ui-designer-integration"><guilabel>UI Designer  Integration</guilabel></term>
+<listitem>
+<para>
+This let you choose the way you want <filename>.ui</filename> files to be displayed in &kdevelop;. &kdevelop; comes with its own UI designer called KDeveDesigner that can either be embedded or be run as a separate program. Qt Designer can also be used to edit <filename>.ui</filename> files.
+</para>
+<itemizedlist>
+  <listitem><para>
+  Use &kdevelop;'s embedded designer
+  </para><para>This uses &kdevelop; own designer embedded within &kdevelop;</para></listitem>
+  <listitem><para>
+  Run &kdevelop;'s designer as a separate application
+  </para><para>The KDevDesigner application will be run separately in its own window.</para>
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="kdevdesigner.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+   KDevDesigner in its own window
+    </para></caption>
+  </mediaobject>
+</screenshot>
+</listitem>
+  <listitem><para>
+Run Qt Designer
+  </para><para>Qt Designer from your Qt installation will be started externally whenever you click on a <filename>.ui</filename> file in &kdevelop;.</para></listitem>
+</itemizedlist>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="terminal-emulation"><guilabel>Terminal Emulation</guilabel></term>
+<listitem>
+<para>
+You choose here which terminal you want to be integrated within KDevelop.
+</para>
+<itemizedlist>
+  <listitem><para>
+  Use &kde; setting
+  </para><para>This uses &kde; setting as set in &kcontrol; in <guilabel>&kde; component</guilabel> <guilabel>Component Chooser</guilabel> tab which sets the default terminal emulator used by all &kde; applications that need a terminal.</para></listitem>
+  <listitem><para>
+  Other
+  </para><para>Choose some other terminal different from the default one.</para>
+</listitem>
+</itemizedlist>
+</listitem>
+</varlistentry>
+
+</variablelist>
+
+</sect2> <!-- setup-main -->
+
+<sect2 id="setup-ui">
+<title>Selecting the User Interface</title>
+
+<indexterm zone="setup-ui">
+  <primary>user interface</primary>
+  <secondary>switch modes</secondary></indexterm>
+<indexterm zone="setup-ui">
+  <primary>switch UI modes</primary></indexterm>
+
+<para>
+As already said in the <link linkend="uimodes-survey">Available User Interface Modes</link> chapter there are five different ways the &kdevelop; work area may be set up, namely:
+</para>
+<itemizedlist>
+  <listitem><para>
+  <link linkend="ideal-desc">Simplified IDEAl window mode</link>
+  </para><para>This is a simplified version of the IDEA user interface. It is designed to be simple and clean. It also does not uses docked toolviews.</para></listitem>
+  <listitem><para>
+  <link linkend="ideal-desc">IDEAl window mode</link>
+  </para><para>This is a clone of the IDEA user interface, similar to the Tabbed pages mode and is default.</para></listitem>
+  <listitem><para>
+  <link linkend="mdi-desc">Childframe window mode</link>
+  </para><para>All tool views are initially docked to the mainframe.
+Editor and browser views will live like toplevel windows within a view area of the mainframe.
+A typical example of this user interface mode is MS Visual Studio 6.0.</para></listitem>
+  <listitem><para>
+  <link linkend="tabbed-desc">Tabbed pages mode</link>
+  </para><para>All tool views are initially docked to the mainframe.
+Editor and browser views will be stacked in a tab window.
+A typical example of this user interface mode is KDEStudio, our friend C++-IDE in the world of KDE.</para></listitem>
+  <listitem><para>
+  <link linkend="toplevel-desc">Toplevel window mode</link>
+  </para><para>All editor, browser and tool views will be toplevel windows (directly on desktop).
+The main widget contains the menu, toolbars and statusbar only.
+A typical example of this user interface mode is Borland Delphi 6.0.</para></listitem>
+</itemizedlist>
+
+<para>
+To switch the user interface mode select <menuchoice> <guimenu>Settings</guimenu> <guimenuitem>Configure &kdevelop;...</guimenuitem> </menuchoice> from the menus. The <guilabel>Customize KDevelop</guilabel> dialog will pop up, where you have to select <guilabel>User Interface</guilabel> in the left hand tree. This will display the following settings dialog to the right.</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="select-user-interface-0.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Select a user interface mode</phrase></textobject>
+    <caption><para>
+    Select a user interface mode
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+Select the radio button of the user interface mode you want to switch to, then click <guibutton>OK</guibutton>.
+</para>
+
+<note><para>
+Do not forget to restart &kdevelop; in order to let any of these selections take effect.
+</para></note>
+
+<para>
+When you selected either the <guilabel>Simplified IDEAl window mode</guilabel> or the <guilabel>IDEAl window mode</guilabel> or the <guilabel>Tabbed pages mode</guilabel> two more configuration sections will become available: <link linkend="setup-ui-tabs">Use Tabs</link> and <link linkend="setup-ui-hover">Use Close On Hover</link>. These allow to configure under which circumstances tabs will be shown on top of the document windows and whether you may close the document by a click on the tab icon.
+</para>
+
+<para>
+In <guilabel>Simplified IDEAl window mode</guilabel> and in <guilabel>IDEAl window mode</guilabel> only yet another configuration section will be available, <link linkend="setup-ui-toolview">Toolview Tab Layout</link> which effectively allows to select between different sizes of the toolview tabs which surround the main working area in this mode.
+</para>
+
+<variablelist>
+<varlistentry>
+<term id="setup-ui-tabs">Configuring the Documents Tab Bar Display</term>
+<listitem>
+<para>
+In the IDEAl and tabbed pages modes there will be named tabs on top of the document windows by default, so you can easily select different documents with a &LMB; click. If you prefer to provide more space for the document windows in the &kdevelop; main work area, you may change to another behaviour in the <guilabel>Use Tabs</guilabel> configuration section.
+</para>
+
+<variablelist>
+<varlistentry>
+  <term><guilabel>Always</guilabel></term>
+  <listitem><para>
+  This is the default &mdash; show a tab comprising an icon and the document name on top of any document window in the &kdevelop; main area display.
+  </para></listitem>
+</varlistentry>
+<varlistentry>
+  <term><guilabel>When more than one</guilabel></term>
+  <listitem><para>
+  Do not show a tab when only one document is displayed. If there is more than one document, however, &kdevelop; will display an according tab bar as in the <guilabel>Always</guilabel> selection above. You may want to select this mode if you work on a single document most of the time as this provides more vertical space.
+  </para></listitem>
+</varlistentry>
+<varlistentry>
+  <term><guilabel>Never</guilabel></term>
+  <listitem><para>
+  Never show any document selection tab. You may prefer this mode if you seldom use the mouse to switch between documents. It provides more vertical space for all document windows. To select another the document window or to close any, use the &kdevelop; <guimenu>Window</guimenu> menu.
+  </para></listitem>
+</varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="setup-ui-hover">Setting Up to Close a Document by a Click On Its
+Tab</term>
+<listitem>
+<para>
+When you configured &kdevelop; to display the documents tab bar, either always or when more than one document is displayed in the main work area, you may add more functionality to the tabs beyond their document selection capability. Use the <guilabel>Use Close On Hover</guilabel> coniguration section for this.
+</para>
+
+<variablelist>
+<varlistentry>
+  <term><guilabel>No</guilabel></term>
+  <listitem><para>
+  This is standard behaviour. No extra functionality is added to the tabs. They may be used only to select document windows on &LMB; clicks.
+  </para></listitem>
+</varlistentry>
+<varlistentry>
+  <term><guilabel>Yes</guilabel></term>
+  <listitem><para>
+  When you selected this radio button, &kdevelop; will allow to close a document window by a &LMB; click. Use the mouse to point at the small icon on the on the left tab border. It will change to a close symbol. Now click with the &LMB; on this changed symbol and &kdevelop; will close the according document window.
+  </para></listitem>
+</varlistentry>
+<varlistentry>
+  <term><guilabel>Yes, Delayed</guilabel></term>
+  <listitem><para>
+  After selecting this radio button, &kdevelop; will allow to close a document window as shown in the <guilabel>Yes</guilabel> case above. The icon will not change instantly, however, but there will be a short delay before the close icon shows up.
+  </para></listitem>
+</varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="setup-ui-toolview">Configuring the Toolview Tab Layout</term>
+<listitem>
+<para>
+The <guilabel>Toolview Tab Layout</guilabel> configuration section will be available in IDEAl mode only. Use these radio buttons to set up the look of the toolview tabs which surround the main working area in this mode.
+</para>
+
+<variablelist>
+<varlistentry>
+  <term><guilabel>Icons</guilabel></term>
+  <listitem>
+  <para>
+  Each tab will show an icon only. If the associated toolview is displayed, the tab will open and a descriptive text for this toolview be shown. You may want to use this mode if you work on a monitor with limited resolution.
+  </para>
+  <para>
+  The icons are not very descriptive, however. If you want to find out which toolview is assigned to a given tab, point at it with the mouse and wait a second. A short tooltip will then pop up with the toolview name.
+  </para>
+  </listitem>
+</varlistentry>
+<varlistentry>
+  <term><guilabel>Text</guilabel></term>
+  <listitem><para>
+  This is the default toolview tab display mode. Each tab displays the name of its associated toolwiew.
+  </para></listitem>
+</varlistentry>
+<varlistentry>
+  <term><guilabel>Text and Icons</guilabel></term>
+  <listitem><para>
+  If the standard text toolview display looks too flat to you and you are working on a high-resolution monitor you may want to select this radio button. It will cause the name of the associated toolview be displayed on each tab plus an icon to the left of it, making the tabs easier to distinguish. See the <link linkend="folded-toolview-tabs">Folded Toolview Tabs</link> illustration below for an example.
+  </para></listitem>
+</varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Folded Toolview Tabs</term>
+<listitem>
+<para>
+If you selected the IDEAl mode toolview tabs to display texts (with or without accompanying icons) you need not worry about them being hidden behind some toolview window. If one of the bottom toolview windows occupies more space than is available to display all (vertical) tabs, they will fold around as this illustration shows:
+</para>
+
+<screenshot>
+  <mediaobject id="folded-toolview-tabs">
+    <imageobject>
+      <imagedata fileref="folded-tabs.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Toolview tabs fold to not be hidden behind another view window</phrase></textobject>
+    <caption><para>
+    Toolview tabs fold to not be hidden behind another view window
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<note><para>
+The active toolview window must be shown fixed (non-overlap mode), sharing the work area with the other windows, to force such tab folding. Press the small square in the window border to accomplish this as shown in the example.
+</para></note>
+</listitem>
+</varlistentry>
+</variablelist>
+
+</sect2> <!-- setup-ui -->
+
+<sect2 id="setup-templates">
+<title>File Templates</title>
+<!--TODO fill--><para></para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-file-templates.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Configure File Templates</phrase></textobject>
+    <caption><para>
+    Configure File Templates
+    </para></caption>
+  </mediaobject>
+</screenshot>
+</sect2> <!-- setup-templates -->
+
+<sect2 id="setup-editor">
+<title>Selecting an Editor</title>
+
+<para>&kdevelop; allows you to select your favorite text editor tool. Mark the <guilabel>Editor</guilabel> entry in the left hand side selections tree of the <guilabel>Configure KDevelop</guilabel> window. The following dialog will be displayed to the right.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-editor.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Select an editor</phrase></textobject>
+    <caption><para>
+    Select an editor
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+To select a new editor, click on the arrow on the drop down list field. Depending on the editor parts interfaces your &kde; version has compiled in you will be provided with a list of editors you may select from (see the <link linkend="setup-editor-kparts">Important</link> note below for this). Click on the editor of your liking and click <guilabel>OK</guilabel>. Currently there are two possibilities:
+</para>
+
+<variablelist>
+  <varlistentry>
+  <term><guilabel>Embedded Advanced Text Editor</guilabel></term>
+  <listitem><para>
+  This is the &kde; standard <application>Kate</application> editor part.
+  </para></listitem>
+  </varlistentry>
+
+  <varlistentry>
+  <term><guilabel>Qt Designer Based Text Editor</guilabel></term>
+  <listitem><para>
+  This is the editor &Qt; provides in its <application>Designer</application> component.
+  </para></listitem>
+  </varlistentry>
+</variablelist>
+
+<para>
+These editor interfaces are fully integrated in the &kdevelop; IDE concept. Particularly the possibility to jump to the offending source code line by just clicking on an error message in the <guilabel>Messages Output View</guilabel> window has been provided.
+</para>
+
+<note><para>
+Changing the editor will not effect already open files. There are two possibilities to proceed. Either close all open text windows and reopen them one by one. Or simply close the whole project and reopen it again. The windows will then automatically open under the new text editor interface.
+</para></note>
+
+<important id="setup-editor-kparts"><para>
+KDevelop lets you use editor interfaces which have registered with &kde; and that provide a KatePart interface. If you miss one one of the selections shown above check your &kde; installation if the corresponding KPart was correctly installed.
+</para></important>
+
+<para>What to do if the file has been changed externally:</para>
+<variablelist>
+  <varlistentry>
+  <term><guilabel>Do nothing</guilabel></term>
+  <listitem><para>
+ The file will be marked as externally changed and the user will be asked to verify any attempt to overwrite it.
+  </para></listitem>
+  </varlistentry>
+  <varlistentry>
+  <term><guilabel>Alert the user</guilabel></term>
+  <listitem><para>
+  A dialog will alert the user that a file has changed and offer the user to reload the file.
+  </para></listitem>
+  </varlistentry>
+  <varlistentry>
+  <term><guilabel>Automatically reload the file if safe, alert the user if not</guilabel></term>
+  <listitem><para>
+  Any files that are not modified in memory are reloaded and an alert is shown for any conflicts.
+  </para></listitem>
+  </varlistentry>
+</variablelist>
+</sect2> <!-- setup-editor -->
+
+<sect2 id="setup-abbrev">
+<title>Abbreviations for the Word Completion</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- setup-abbrev -->
+
+<sect2 id="setup-scripting">
+<title>Scripting</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- setup-scripting -->
+
+<sect2 id="setup-menu-standard">
+<title>Adding &kde; Standard Applications to the Tools Menu</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- setup-menu-standard  Tools Menu-->
+
+<sect2 id="setup-menu-external">
+<title>Adding External Applications to Menus</title>
+
+<para>
+(... to be written ...)
+</para>
+
+<sect3 id="setup-menu-external-tools">
+<title>Adding to the Tools Menu</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect3> <!-- setup-menu-external-tools -->
+
+<sect3 id="setup-menu-external-filecontext">
+<title>Adding to the File Context Menu</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect3> <!-- setup-menu-external-filecontext -->
+
+<sect3 id="setup-menu-external-dircontext">
+<title>Adding to the Directory Context Menu</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect3> <!-- setup-menu-external-dircontext -->
+
+</sect2> <!-- setup-menu-external -->
+
+<sect2 id="setup-format">
+<title>Selecting a Source Format Style</title>
+
+<para>
+&kdevelop; automatically formats a source text in a predefined style. This style is highly configurable.
+</para>
+
+<note><para>
+The reformat source feature is currently available for C, C++, and &Java; only. Especially you cannot use it for scripting languages like &eg; PHP. This is because &kdevelop; uses the <ulink url="http://astyle.sourceforge.net/">astyle</ulink> application to implement this feature.
+</para></note>
+
+<para>
+To set up a specific format style, select <menuchoice> <guimenu>Settings</guimenu> <guimenuitem>Configure &kdevelop;..</guimenuitem> </menuchoice> from the menubar. The <guilabel>Customize KDevelop</guilabel> dialog will pop up, where you have to select <guilabel>Source Formatter</guilabel> in the left hand tree. This will display a series of three settings dialog tabs to the right, namely a <link linkend="setup-format-general">General Formatting Setup</link>, a <link linkend="setup-format-indent">Indentation Style Setup</link>, and a <link linkend="setup-format-other">Other Formatting Setup</link>.
+</para>
+
+<tip><para>
+Any style changes apply to newly entered text only. If you want to change the formatting style of an already existing source text you will have to explicitely use the <menuchoice><guimenu>Edit</guimenu><guimenuitem>Reformat Source</guimenuitem></menuchoice> command.
+</para></tip>
+
+<note><para>
+The exact outcome of these style formatting definitions depends on the <link linkend="setup-editor">editor</link> you use. Currently, most settings are tailored to the Kate editor part (the <quote>Embedded Advanced Text Editor</quote>). Some other editors (&eg; the Qt editor) may rely on their own configuration settings. You will have to experiment in this case to find out the exact effects of the style settings provided here.
+</para></note>
+
+<warning><para>
+There may be incompatibilities between the configuration style settings provided here and the editor you use up to the extent that in extreme cases it even might destroy your files. Make sure you have a backup of your source files before you try out these settings with an none KDE standard editor.
+</para></warning>
+
+<sect3 id="setup-format-general">
+<title>General Formatting Setup</title>
+
+<para>
+The <guilabel>General</guilabel> tab of the <guilabel>Source Formatter</guilabel> dialog allows you to select one out of five predefined source format styles.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="SF-general.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Source format style general setup</phrase></textobject>
+    <caption><para>
+    Source format style general setup
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+A formatted source example will be displayed in the field to the right. If none of the predefined styles is to your liking, you may click the top <guilabel>User defined</guilabel> radio button and define your own source formatting style preferences on the other two tabs which will become available then.
+</para>
+
+<note><para>
+Currently only the predefined source formatting styles will be demonstrated by an example text. If you decide to define your own style, no example display will be available. You have to experiment on an actual source text to tailor the settings to your liking.
+</para></note>
+
+</sect3> <!-- setup-format-general -->
+
+<sect3 id="setup-format-indent">
+<title>Indentation Style Setup</title>
+
+<para>
+Proper indentation is the main means to enhance readability of a source text. I you selected the <guilabel>Indentation</guilabel> tab of the <guilabel>Source Formatter</guilabel> dialog you will be presented with a series of indentation formatting choices grouped into three boxes as following.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="SF-indent.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Source format indentation style setup</phrase></textobject>
+    <caption><para>
+    Source format indentation style setup
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<variablelist>
+<varlistentry>
+<term>Default Settings</term>
+<listitem>
+<para>The preset format choices will cause the source text to resemble the
+ANSI formatting style:</para>
+
+<screen>
+namespace foospace
+{
+  int Foo()
+  {
+    if (isBar)
+    {
+      bar();
+      return 1;
+    }
+    else
+      return 0;
+  }
+}
+</screen>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="setup-format-indent-filling">Defining Indentation Width and Characters</term>
+<listitem>
+<para>The radio buttons grouped in the <guilabel>Filling</guilabel> group
+define how indents in the source text will be drawn.</para>
+
+<variablelist>
+  <varlistentry>
+    <term><guilabel>Use tabs</guilabel></term>
+    <listitem>
+    <para>
+    This will cause the editor to insert a tab character for each
+indentation level. The tab width is predefined in the editor settings (8 or
+4 character columns usually). Use <menuchoice><guimenu>Settings</guimenu><guimenuitem>Configure Editor...</guimenuitem></menuchoice> to redefine it.
+    </para>
+    <note><para>
+    The actual tab width definition procedure depends on the editor you selected in the <link linkend="setup-editor">Selecting an Editor</link> configuration step. You will have to look up the corresponding editor help to find out.
+    </para></note>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Use spaces</guilabel></term>
+    <listitem><para>
+    If you select this radio button, the editor will enter a number of spaces for each indentation level. Change the number from the default 2 to the indentation width you prefer.
+    </para></listitem>
+  </varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Indented Entities</term>
+<listitem>
+<para>This defines which of the (C/C++) entities will be formatted with an
+extra indent beyond the current indentation level.</para>
+
+<para>By default only <guilabel>namespaces</guilabel> and
+<guilabel>labels</guilabel> will be extra indented. You may want to
+experiment with various settings to tailor those extra indents to your
+liking.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Continuation</term>
+<listitem>
+<para>
+The settings grouped here apply to those cases where the source formatter automatically wraps around long source lines. It takes two special cases in account, namely that in deeply nested indents there should remain enough room for the source and that conditionals should get extra indent levels on continuation to make them stand out properly.
+</para>
+
+<note><para>
+This applies to <emphasis>static word wrap cases</emphasis> only where a fixed maximum line width is used in the source text. If you set up your editor to dynamically wrap around long lines in display only (which is possible in the &kate; editor part) the effects of these settings usually will not show.
+</para></note>
+
+<variablelist>
+  <varlistentry>
+    <term><guilabel>Maximum in statement</guilabel></term>
+    <listitem>
+    <para>
+    This setting limits the maximum possible indentation for the continuation lines so that enough space will remain to keep the text readable. No continuation line will ever be indented beyond the number of columns you selected in this field.
+    </para>
+    <para>
+    The default is set to 40 character columns (half a standard 80 column page). You may want to increase this value to account for wider paper (e.g if you use landscape printing for your sources). Or decrease the value accordingly to take larger margin settings of your printouts into account.
+    </para>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Minimum in conditional</guilabel></term>
+    <listitem>
+    <para>
+    Conditionals or source following &eg; an assignment operator should usually get an extra indent on continuation lines in order to keep the text readable. The amount of this extra indent is defined here.
+    </para>
+    <para>
+    The default is set to <quote>Twice current</quote> which means that continued conditionals will get an extra indent level of the standard indentation size you selected in the <link linkend="setup-format-indent-filling">Filling</link> group. You may change this extra indent to another fixed width (including zero) using the arrows or by entering the value directly.
+    </para>
+    </listitem>
+  </varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+</variablelist>
+
+</sect3> <!-- setup-format-indent -->
+
+<sect3 id="setup-format-other">
+<title>Other Formatting Setup</title>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="SF-other.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Other source format style settings</phrase></textobject>
+    <caption><para>
+    Other source format style settings
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<variablelist>
+<varlistentry>
+<term>Controlling the position of braces</term>
+<listitem>
+<para>The radio buttons the (somewhat misnamed)
+<guilabel>Brackets</guilabel> group control the position of block delimiting
+braces in a (C/C++) source text. There are three possibilities from which
+you can select.</para>
+
+<variablelist>
+  <varlistentry>
+    <term><guilabel>Break</guilabel></term>
+    <listitem>
+    <para>This inserts a line break before each opening brace. Both delimiting braces of any block will be put at the same indentation level as the block head statement.</para>
+
+<screen>
+namespace foospace
+{
+  int Foo()
+  {
+    if (isBar)
+    {
+      bar();
+      return 1;
+    }
+    else
+      return 0;
+  }
+}
+</screen>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Attach</guilabel></term>
+    <listitem>
+    <para>
+    This will keep the opening brace of a block in line with the block head statement. Closing braces will be on the same indentation level as the block head statement. The <token>else</token> of an <token>if</token> statement will be kept in line with the closing brace of the preceding block.
+    </para>
+<screen>
+namespace foospace {
+  int Foo() {
+    if (isBar) {
+      bar();
+      return 1;
+    } else
+      return 0;
+  }
+}
+</screen>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Linux Style</guilabel></term>
+    <listitem>
+    <para>
+    This is a compromise of the above listed styles. Functional block delimiting braces will be put on extra lines. Braces opening a block in a conditional or loop statement will be kept in line.
+    </para>
+<screen>
+namespace foospace
+{
+  int Foo()
+  {
+    if (isBar) {
+      bar();
+      return 1;
+    } else
+      return 0;
+  }
+}
+</screen>
+    </listitem>
+  </varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Controlling Extra Spaces</term>
+<listitem>
+<para>
+By default &kdevelop; does minimize the use of spaces in source texts.
+</para>
+
+
+<screen>
+if (isBar(fooArg)==barValue)
+</screen>
+
+<para>You may enhance readability if you force the source formatter to
+insert extra spaces in special positions.</para>
+
+<variablelist>
+  <varlistentry>
+    <term><guilabel>Add spaces around parentheses</guilabel></term>
+    <listitem>
+    <para>In fact what is meant is to add spaces around the text put in parentheses. This enhances the readabilitiy of function arguments and conditionals.</para>
+<screen>
+if ( isBar( fooArg )==barValue )
+</screen>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Add spaces around operators</guilabel></term>
+    <listitem>
+    <para>This will put spaces around assignment and comparison operators to enhance the readability.</para>
+<screen>
+if (isBar(fooArg) == barValue)
+</screen>
+    </listitem>
+  </varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Controlling the formatting of one-line constructs</term>
+<listitem>
+<para>There are a few cases where you don't want the source formatter to
+split a long line apart. For C/C++ code this can be controlled here.</para>
+
+<variablelist>
+  <varlistentry>
+    <term><guilabel>Keep one-line statements</guilabel></term>
+    <listitem><para>
+    This keeps single line statements together in some situations even if they exceed a fixed maximum line length.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Keep one-line blocks</guilabel></term>
+    <listitem><para>
+    This keeps single line blocks together in some situations even if they exceed a fixed maximum line length.
+    </para></listitem>
+  </varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+</variablelist>
+
+
+</sect3> <!-- setup-format-other -->
+
+</sect2> <!-- setup-format -->
+
+<sect2 id="setup-snippets">
+<title>Setting Up the Code Snippets Tool</title>
+
+<para>
+When editing in &kdevelop; you can store often used parts of code as <link linkend="editing-snippets">Code Snippets</link>. To configure the capabilities of the code snippets part select <menuchoice> <guimenu>Settings</guimenu> <guimenuitem>Configure &kdevelop;..</guimenuitem> </menuchoice> from the menubar. The <guilabel>Customize KDevelop</guilabel> dialog will pop up, where you have to select <guilabel>Code Snippets</guilabel> in the left hand tree. This will show the following dialog in the right hand side.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-snippets.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Configuring the code snippets tool</phrase></textobject>
+    <caption><para>
+    Configuring the Code Snippets tool
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<variablelist>
+<varlistentry>
+<term>Activate Snippet Preview</term>
+<listitem>
+<para>Mark the <guilabel>Show snippet's text in tooltip</guilabel> checkbox
+if you want to view the stored text in a tooltip window whenever you keep
+the mouse cursor over the title of that snippet.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Working with Snippet Variables</term>
+<listitem>
+<para>The <guilabel>Code Snippets</guilabel> tool allows for a variable text
+in predefined places any time you insert a snippet into a file. To
+accomplish this  <guilabel>Code Snippets</guilabel> provides its own
+variables' mechanism. You can set up it's behaviour in the
+<guilabel>Variables</guilabel> group.</para>
+
+<variablelist>
+  <varlistentry>
+    <term><guilabel>Delimiter</guilabel></term>
+    <listitem><para>
+    The <guilabel>Code Snippets</guilabel> tool distinguishes variables in the text by surrounding the variable name with special delimiter symbols. To use your own delimiter symbol, change the predefined <guilabel>$</guilabel> character in the <guilabel>Delimiter</guilabel> field.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Input method for variables</guilabel></term>
+    <listitem><itemizedlist>
+      <listitem><para>
+      <guilabel>Single dialog for each variable within a snippet</guilabel> &ndash; will in turn pop up a separate dialog for each variable which the tool finds when inserting the selected code snippet.
+      </para></listitem>
+      <listitem><para>
+      <guilabel>One dialog for all variables within a snippet</guilabel> &ndash; will pop up a common dialog where the user has to fill in the values of all variables before the snippet will be inserted
+      </para></listitem>
+    </itemizedlist></listitem>
+  </varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+</variablelist>
+
+</sect2> <!-- setup-snippets -->
+
+<sect2 id="setup-file-list">
+<title>File List</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect2> <!-- setup-file-list-->
+
+<sect2 id="setup-file-selector">
+<title>Configuring the File Selector</title>
+
+<para>
+&kdevelop; provides a <guilabel>File Selector</guilabel> plugin which, when
+loaded at start-up, allows to navigate to any file or directory in the
+system.
+</para>
+
+<screenshot id="setup-fileselector-image">
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="file-selector.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>The file selector in IDEAl mode</phrase></textobject>
+    <caption><para>
+    The file selector (IDEAl mode)
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>The behaviour of the <guilabel>File Selector</guilabel> can be highly
+configured. Select <menuchoice> <guimenu>Settings</guimenu>
+<guimenuitem>Configure &kdevelop;..</guimenuitem> </menuchoice> from the
+menubar. The <guilabel>Customize KDevelop</guilabel> dialog will pop up,
+where you have to select <guilabel>File Selector</guilabel> in the left hand
+tree. This will show the following dialog in the right hand side.</para>
+
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-file-selector.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Configuring the file selector</phrase></textobject>
+    <caption><para>
+    Configuring the file selector
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<variablelist>
+<varlistentry>
+<term>Configuring the Toolbar</term>
+<listitem>
+<para>There is a toolbar on top of the <guilabel>File Selector</guilabel>
+which can be configured as usual in the <guilabel>Toolbar</guilabel>
+group.</para>
+
+<procedure id="setup-fileselector-add-action">
+  <title>Add an Action to the Toolbar</title>
+  <step>
+    <para>
+    Select an item in the right hand <guilabel>Selected actions</guilabel> list after which the new action should be inserted.
+    </para>
+  </step>
+  <step>
+    <para>
+    Select the action to be inserted in the left hand <guilabel>Available actions</guilabel> list.
+    </para>
+  </step>
+  <step>
+    <para>
+    Click the right (upper) arrow between both lists.
+    </para>
+    <para>The action will be removed from the <guilabel>Available actions</guilabel> list and inserted into the <guilabel>Selected actions</guilabel> list below the selected item.
+    </para>
+  </step>
+</procedure>
+
+<procedure>
+  <title>Remove an Action from the Toolbar</title>
+  <step>
+    <para>
+    Select the item to be removed in the right hand <guilabel>Selected actions</guilabel> list.
+    </para>
+  </step>
+  <step>
+    <para>
+    Click the left (lower) arrow between both lists.
+    </para>
+    <para>The selected item will be removed from the <guilabel>Selected actions</guilabel> list and put back into the <guilabel>Available actions</guilabel> list.
+    </para>
+  </step>
+</procedure>
+
+<procedure>
+  <title>Reorder the Actions on the Toolbar</title>
+  <step>
+    <para>
+    Select the action to be moved in the right hand <guilabel>Selected actions</guilabel> list.
+    </para>
+  </step>
+  <step>
+    <para>
+    Click the up or down arrow to the right of this list.
+    </para>
+    <para>The selected item will be moved up or down the <guilabel>Selected actions</guilabel> list.
+    </para>
+  </step>
+</procedure>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term id="setup-fileselector-autosync">Defining When the Contents Should
+Change</term>
+<listitem>
+<para>
+Updating the contents in the <guilabel>File Selector</guilabel> window takes time and resources, esp. when changing to another directory. Therefore  <guilabel>File Selector</guilabel> is set up by default in such a way that its contents change only on demand, &ie; when you select another directory or when you explicitely want to refresh its contents.
+</para>
+
+<note><para>
+Click the <guilabel>Reload</guilabel> button in the toolbar to update the contents of the <guilabel>File Selector</guilabel>. This toolbar button is not available by default, however. You must <link linkend="setup-fileselector-add-action">insert it there</link> first.
+</para></note>
+
+<para>
+You can configure the <guilabel>File Selector</guilabel> to immediately reflect certain changes in your work. The settings in the <guilabel>Auto Synchronization</guilabel> group of the configuration dialog are responsible for this.
+</para>
+
+<variablelist>
+  <varlistentry>
+    <term><guilabel>When a document becomes active</guilabel></term>
+    <listitem><para>
+    If you select this checkbox, the contents in the <guilabel>File Selector</guilabel> window will be updated whenever you go to another already open document, &eg; when you click on the tab of the according edit window in IDEAl mode. If necessary the <guilabel>File Selector</guilabel> will switch to the directory this file belongs to and update the display to show the actual contents in there.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>When a document is opened</guilabel></term>
+    <listitem><para>
+    If you select this checkbox, the contents in the <guilabel>File Selector</guilabel> window will be updated whenever a document will be opened, &eg; by the <menuchoice><guimenu>File</guimenu><guimenuitem>Open</guimenuitem></menuchoice> menu. If necessary the <guilabel>File Selector</guilabel> will switch to the directory this file belongs to and update the display to show the actual contents in there.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>When the file selector becomes visible</guilabel></term>
+    <listitem><para>
+    If you select this checkbox, the contents in the <guilabel>File Selector</guilabel> window will be updated whenever it gets visible again. If necessary it will switch to the directory the actual document belongs to and update the display to show the actual contents in there.
+    </para></listitem>
+  </varlistentry>
+</variablelist>
+
+<para>
+You may freely combine these settings to tailor the actualization behaviour of the <guilabel>File Selector</guilabel> to your liking.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term>Controlling the History in the Comboboxes</term>
+<listitem>
+<para>There are two comboboxes on top and bottom of the <guilabel>File
+Selector</guilabel> contents window which control the directory to be
+displayed (top combobox) and the filters to be applied to the file display
+(bottom combobox). A history of the most recent settings is kept in the
+selection field of each combobox. You can configure the number of history
+entries as follows.</para>
+
+<variablelist>
+  <varlistentry>
+    <term><guilabel>Remember locations</guilabel></term>
+    <listitem><para>
+    Enter here the maximum number of directory selections the upper combobox shall remember.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Remember filters</guilabel></term>
+    <listitem><para>
+    Enter here the maximum number of filter definitions the lower combobox shall remember.
+    </para></listitem>
+  </varlistentry>
+
+<varlistentry>
+<term>Controlling What Should be Remembered Between Sessions</term>
+<listitem>
+<para>
+By default the <guilabel>File Selector</guilabel> is set up so that it shows the display of the most recent session again at the next &kdevelop; start-up. You may change this behaviour in the <guilabel>Session</guilabel> configuration group.
+</para>
+
+<note><para>
+If &kdevelop; was automatically restarted by the &kde; session manager the changes in these settings will have no effect. In this case location and filter settings of the most recent &kde; session will always be restored.
+</para></note>
+</listitem>
+</varlistentry>
+
+  <varlistentry>
+    <term><guilabel>Restore location</guilabel></term>
+    <listitem>
+    <para>
+    Remove the checkbox mark here if you don't want the displayed location be remembered between sessions.
+    </para>
+    <note><para>
+    If you selected one of the <link linkend="setup-fileselector-autosync">automatic update</link> settings the displayed location might automatically change regardless what has been remembered from the recent session.
+    </para></note>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Restore filters</guilabel></term>
+    <listitem>
+    <para>
+    Remove the checkbox mark here if you don't want the filters applied to the display be remembered between sessions.
+    </para>
+    </listitem>
+  </varlistentry>
+</variablelist>
+</listitem>
+</varlistentry>
+</variablelist>
+
+</sect2> <!-- setup-file-selector -->
+
+<sect2 id="setup-cpp-generator">
+<title>C++ Class Generator</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect2> <!-- setup-c++-generator-->
+
+<sect2 id="setup-formatting">
+<title>Formatting</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect2> <!-- setup-formatting-->
+
+<sect2 id="setup-cpp-parsing">
+<title>C++ Parsing</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect2> <!-- setup-c++-parsing-->
+
+</sect1> <!-- setup-general -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="setup-docu">
+<title>Configuring the Documentation</title>
+
+<para>
+&kdevelop; contains a very powerful documentation facility which provides access to several kinds of extensive documentation. In &eg; IDEAl mode you find a <guilabel>Documentation</guilabel> tab at the right border of the work area.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="documents-contents.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>The &kdevelop; documentation window in IDEAl mode</phrase></textobject>
+    <caption><para>
+    The &kdevelop; documentation window (IDEAl mode)
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<note><para>
+&kdevelop; must have loaded the <guilabel>Documentation</guilabel> plugin in order to view the documentation tree. See the <link linkend="setup-plugins">Plugin Tools</link> section for more info.
+</para></note>
+
+<para>
+You may set up contents and behaviour of the various parts of this documentation window if you select <menuchoice> <guimenu>Settings</guimenu> <guimenuitem>Configure &kdevelop;..</guimenuitem> </menuchoice> from the menubar. The <guilabel>Customize KDevelop</guilabel> dialog will pop up, where you have to select <guilabel>Documentation</guilabel> in the left hand window.
+</para>
+
+<para>
+The thus displayed <link linkend="configure-docu-general">configuration page</link> shows three tabbed configuration dialog pages, namely:
+</para>
+
+<simplelist>
+  <member><link linkend="setup-docu-general">Documentation Collections</link></member>
+  <member><link linkend="setup-docu-textsearch">Full Text Search</link></member>
+  <member><link linkend="setup-docu-other">Other</link></member>
+</simplelist>
+
+<sect2 id="setup-docu-general">
+<title>Setting Up Documentation Collections</title>
+
+<para>
+The documentation configuration settings have been divided into a series of documentation collections, each providing access to documentation files of some unique format and content type. These setups control which documentation items will be listed on the <guilabel>Contents</guilabel> page of the &kdevelop; <guilabel>Documentation</guilabel> facility, and how the user may access documentation details by indexed and full text searches.
+</para>
+<para>
+The <guilabel>Documentation</guilabel> tab provides a series of configuration pages which are ordered vertically like a stack of index cards. One page at a time will open after a click on its index card title:
+</para>
+<simplelist>
+  <member><link linkend="setup-docu-general-qt">&Qt; Documentation Collection</link></member>
+  <member><link linkend="setup-docu-general-chm">CHM Documentation Collection</link></member>
+  <member><link linkend="setup-docu-general-dox">Doxygen Documentation Collection</link></member>
+  <member><link linkend="setup-docu-general-toc">&kdevelop; TOC Documentation Collection</link></member>
+  <member><link linkend="setup-docu-general-devhelp">Devhelp Documentation Collection</link></member>
+  <member><link linkend="setup-docu-general-custom">Custom Documentation Collection</link></member>
+</simplelist>
+
+<para id="configure-docu-general">
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-docu-general.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Setting up documentation collections</phrase></textobject>
+    <caption><para>
+    Setting up documentation collections
+    </para></caption>
+  </mediaobject>
+</screenshot>
+</para>
+
+<sect3 id="setup-docu-general-common">
+<title>Common Documentation Setup Structure</title>
+
+<para>
+All configurations pages on the <guilabel>Documentation</guilabel> tab use a common layout. You will find the currently available documentation items of this type listed on the open page to the left and a set of buttons to the right.
+</para>
+
+<variablelist>
+<varlistentry>
+<term id="setup-docu-buttons">Buttons to Maintain Documentation List Contents</term>
+<listitem>
+<para>
+There are three buttons available to maintain the contents of the documentation setup pages:
+</para>
+
+<variablelist>
+  <varlistentry>
+    <term><guibutton>Add</guibutton></term>
+    <listitem>
+      <para>Opens a <guilabel>Documentation Catalog Properties</guilabel> dialog as shown below where you can select the source location of the documentation item to be added and name it.</para>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guibutton>Edit</guibutton></term>
+    <listitem>
+      <para>Opens a <guilabel>Documentation Catalog Properties</guilabel> dialog as shown below where you can change the source location of the documentation item previously selected in the list and rename it.</para>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guibutton>Remove</guibutton></term>
+    <listitem>
+      <para>Removes the selected documentation entry from the list.</para>
+      <note><para>
+      The entry will be removed from the list only. Actual documentation sources remain untouched. You will have to remove them explicitely by other means.
+      </para></note>
+    </listitem>
+  </varlistentry>
+</variablelist>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-docu-edit.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    Add or change a documentation item
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+The button to the right of the <guilabel>Location</guilabel> field opens a directory dialog whose entries usually will be filtered according to the file type of the selected configuration page.
+</para>
+<para>
+The <guilabel>Title</guilabel> field may not be accessible, depending on the documentation type to be maintained.
+</para>
+</listitem>
+</varlistentry>
+<varlistentry>
+<term id="setup-docu-columns">Documentation List Structure</term>
+<listitem>
+<para>
+Every documentation setup page shows the listed documentation items in a table with four columns:
+</para>
+
+<variablelist>
+  <varlistentry>
+    <term><guilabel>TOC</guilabel></term>
+    <listitem>
+      <para>
+      If this check box is marked, this documentation item will show up on the <guilabel>Contents</guilabel> page of the &kdevelop; <guilabel>Documentation</guilabel> facility.
+      </para>
+      <note><para>
+      Unchecking the <guilabel>TOC</guilabel> check box will in turn disable the <guilabel>Index</guilabel> and <guilabel>Search</guilabel> check boxes (see below). Thus you cannot have documentation collection items indexed but not shown in the contents.
+      </para></note>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Index</guilabel></term>
+    <listitem>
+      <para>
+      If this check box is marked, an internal index will be built of this documentation item. This provides fast access to the documentation by the use of the <guilabel>Index</guilabel> and (optionally) <guilabel>Finder</guilabel> pages of the &kdevelop; <guilabel>Documentation</guilabel> facility.
+      </para>
+      <note>
+        <para>
+        The internal index will be built the first time the user selects the <guilabel>Index</guilabel> page. This will delay the first access noticeably, because the index will be read from disk and then cached.
+        </para>
+        <para>
+        All subsequent indexed searches will however use this chache and thus work significally faster.
+        </para>
+      </note>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Search</guilabel></term>
+    <listitem>
+      <para>
+      If this check box is marked, the contents of this documentation item will be included in the full text search path of the <guilabel>Search</guilabel> page of the &kdevelop; <guilabel>Documentation</guilabel> facility.
+      </para>
+      <note>
+        <para>
+        &kdevelop; utilizes the htdig application collection to perform full text searches. This search is done over an internal index, the htdig machinery has to build before it can be used.
+        </para>
+        <para>
+        Any change of the <guilabel>Search</guilabel> check box marks will thus effect the search runs only after you rebuilt the index on the  <guilabel>Search</guilabel> page of the &kdevelop; <guilabel>Documentation</guilabel> facility.
+        </para>
+      </note>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term><guilabel>Title</guilabel></term>
+    <listitem><para>
+    This is the name of the Documentation item as it will be shown on the <guilabel>Contents</guilabel> page of the &kdevelop; <guilabel>Documentation</guilabel> facility.
+    </para></listitem>
+  </varlistentry>
+</variablelist>
+
+<note><para>
+Former &kdevelop; versions allowed to select the documentation items to be displayed on a per-project basis. This is not available any more.
+</para></note>
+</listitem>
+</varlistentry>
+</variablelist>
+
+</sect3> <!-- setup-docu-general-common -->
+
+<sect3 id="setup-docu-general-qt">
+<title>&Qt; Documentation Collections</title>
+
+<para>
+On this configuration page all &Qt; documentation is set up.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-docu-general.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Setting up the &Qt; documentation collection</phrase></textobject>
+    <caption><para>
+    Setting up the &Qt; documentation collection
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+Normally &kdevelop; will fill this in on its first start-up. It looks for standard <filename>*.xml</filename>, or <filename>*.dcf</filename> documentation files in the &Qt; installation directory. The table to the left lists the files &kdevelop; found by their standard titles.
+</para>
+
+<para>
+If you have a non-standard installation, either there will be no information listed at all or the entries will possibly refer to improper locations (&eg; to another &Qt; installation available in your system). You may adjust the entries using the <link linkend="setup-docu-buttons">buttons</link> to the right of the list field.
+</para>
+
+<note><para>
+&kdevelop; will use the titles already provided by the installed &Qt; documentation. Hence the <guilabel>Title</guilabel> field in the <guilabel>Documentation Catalog Properties</guilabel> dialog is inaccessible.
+</para></note>
+
+<para>
+By default, not all &Qt; documentation will be shown on the <guilabel>Contents</guilabel> page of the &kdevelop; <guilabel>Documentation</guilabel> facility. Use the <guilabel>TOC</guilabel> check box in the <link linkend="setup-docu-columns">setup table</link> to select the documentation to be shown.
+</para>
+
+<para>
+If you want to have some specific &Qt; documentation included in the search indexes or full text search use the <guilabel>Index</guilabel> and <guilabel>Search</guilabel>check boxes in the <link linkend="setup-docu-columns">setup table</link>.
+</para>
+
+</sect3> <!-- setup-docu-general-qt -->
+
+<sect3 id="setup-docu-general-chm">
+<title>Setting Up the CHM Documentation Collection</title>
+
+<para>
+On this configuration page you may collect documentation according to the &Microsoft; CHM help file standard.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-docu-chm.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Setting up &Microsoft; CHM standard documentation files</phrase></textobject>
+    <caption><para>
+    Setting up &Microsoft; CHM standard documentation files
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+By default, this configuration page will be empty (as shown above). You may add new entries using the <link linkend="setup-docu-buttons">buttons</link> to the right of the list field. &kdevelop; will filter <filename>*.chm</filename> files in the directory dialog associated to the <guibutton>Add</guibutton> and <guibutton>Edit</guibutton> buttons.
+</para>
+
+<para>
+For more information on the format of &Microsoft; <filename>*.chm</filename> files see &eg; PHP: Documentation - Extended CHM Format at <ulink url="http://de2.php.net/docs-echm.php">http://de2.php.net/docs-echm.php</ulink>.
+</para>
+
+</sect3> <!-- setup-docu-general-chm -->
+
+<sect3 id="setup-docu-general-dox">
+<title>Documentation Generated by Doxygen</title>
+
+<para>
+On this configuration page all &API; documentation generated by &doxygen; is set up.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-docu-dox.png" format="PNG"/>
+    </imageobject>
+<textobject><phrase>Setting up Doxygen generated &API; documentation</phrase></textobject>
+    <caption><para>
+    Setting up Doxygen generated &API; documentation
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+In short, such an &API; documents the interface to certain library functions. The &API; documentation on this page should be produced by the externally provided <ulink url="http://www.stack.nl/~dimitri/doxygen/">&doxygen;</ulink> tool.
+</para>
+<para>
+&doxygen; generated &API; documentationconsists of a series of <filename>html</filename> files, starting with <filename>index.html</filename>. Additionally there may exist <filename>tag</filename> files which contain information to link to already existing &API; documentations. Thus &kdevelop; will look for <filename>index.html</filename> and <filename>*.tag</filename> files when seaching for &doxygen; generated &API; documentation.
+</para>
+<para>
+There are some structural constraints assumed when searching for &doxygen; generated &API; documentation. The directory in which the <filename>index.html</filename> file resides should contain subdirectories with separate documentation collections. Each of these subdirectories is assumed to contain a <filename>.tag</filename> file and a <filename class="directory">html/</filename> subdirectory.
+</para>
+<para>
+You may have a look at <filename class="directory">$<envar>KDEDIR</envar>/share/doc/HTML/en/kdelibs-apidocs</filename> for an example of such a &doxygen; &API; documentation layout.
+</para>
+
+<note><para>
+The older &kde; <ulink url="http://sirtaj.net/projects/kdoc/">KDoc</ulink> generated &API; format is not directly supported any more. If you still want to use such documentation, you may add it on the <link linkend="setup-docu-general-custom">Custom Documentation Collection</link> page.
+</para></note>
+
+<para>
+&kdevelop; will have filled in a link to the current &kde; Libraries &API;, provided it found one. There are several ways for &kdevelop; to find out:
+</para>
+
+<itemizedlist>
+  <listitem><para>
+  Either you provided the <command>configure</command> command with the
+  <option>--with-kdelibsdoxy-dir</option> option when you compiled
+  &kdevelop; (see the <link linkend="make-api">How to Obtain a &kdevelop; &API; Documentation</link> chapter).
+  </para></listitem>
+  <listitem><para>
+  Or the <command>configure</command> command did automatically find a &doxygen; generated &kde; Libraries &API; in one of several standard locations it knows of.
+  </para></listitem>
+  <listitem><para>
+  Or as a last resort the <filename class="directory">$<envar>KDEDIR</envar>/share/doc/HTML/en/kdelibs-apidocs/</filename> was found at the first &kdevelop; startup.
+  </para></listitem>
+</itemizedlist>
+
+<para>
+If &kdevelop; did not find a valid &doxygen; generated &kde; Libraries &API; at its first start-up the <guilabel>Doxygen Documentation Collection</guilabel> list will be empty.
+</para>
+
+<para>
+You may add your own &API; documentation entries (&eg; from your current projects) by using the <link linkend="setup-docu-buttons">buttons</link> to the right. If you want to have them included in the indexed and/or full text search mark the <guilabel>Index</guilabel> or <guilabel>Search</guilabel> check boxes in the <link linkend="setup-docu-columns">setup table</link>.
+</para>
+
+<note><para>
+&kdevelop; uses the title information from the <filename>index.html</filename>. Hence the <guilabel>Title</guilabel> field in the <guilabel>Documentation Catalog Properties</guilabel> dialog is inaccessible.
+</para></note>
+
+<tip>
+  <para>
+  The &kde; system provides more &API; documentation than the &kde; Libraries &API; only. You will need additional interfaces information if you want to &eg; include the &kate; part into you programs. For this &kate; part &API; for example you should compile and install the &kde; Base Libraries &API; from the <ulink url="http://developer.kde.org/source/index.html">sources</ulink> (using the <command>make apidox</command> and <command>make install</command> commands on the <filename class="directory">kdebase</filename> sources) and then add an entry to the <guilabel>Doxygen Documentation Collection</guilabel> list like this:
+  </para>
+  <screenshot><mediaobject>
+      <imageobject>
+        <imagedata fileref="configure-adddialog-baselibs.png" format="PNG"/>
+      </imageobject>
+<textobject><phrase>Adding a &kde; base &API; to the list</phrase></textobject>
+      <caption><para>
+      Adding a &kde; Base &API; to the list
+      </para></caption>
+    </mediaobject></screenshot>
+  <para>
+  (Of course you should replace the <filename class="directory">/home/dev/mykde-system/</filename> directory in the <guilabel>Location</guilabel> field example with the path to your &kde; installation.)
+  </para>
+</tip>
+
+<note><para>
+You must put the &API; of your current project into this <guilabel>Doxygen Documentation Collection</guilabel> as well. Former &kdevelop; versions did put it into the documentation tree on a per-project basis. This is not provided any more.
+</para></note>
+
+</sect3> <!-- setup-docu-general-dox -->
+
+<sect3 id="setup-docu-general-toc">
+<title>Handling Structured Documentation (KDevelopTOC Files)</title>
+
+<para>
+The main bulk of the &kdevelop; documentation facility provides immediate access to structured documentation, local as well as remote ones. You can configure this on the <guilabel>KDevelopTOC Documentation Collection</guilabel> page.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-docu-toc.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    Providing KDevelopTOC structured documentation access
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+&kdevelop; comes with a bunch of predefined KDevelopTOC files which are automatically entered in the table at installation time. To keep the display manageable only the most often used will initially be marked for display. If you want to see another documentation, mark the <guilabel>TOC</guilabel> check box in the <link linkend="setup-docu-columns">setup table</link>.
+</para>
+
+<para>
+KDevelopTOC files cannot be indexed to perform a full text search because they usually point to a remote location. On the other hand, such a <filename>.toc</filename> file can have an index manually defined, using the <computeroutput>&lt;index&gt;</computeroutput> tag. Thus the <guilabel>Index</guilabel> check box will be enabled ony when &kdevelop; finds an <computeroutput>&lt;index&gt;</computeroutput> tag in the <filename>.toc</filename> file. (For more detail see the description below in the <link linkend="setup-docu-general-toc-files">&kdevelop; TOC Files</link> section.)
+</para>
+<para>
+The <guilabel>Search</guilabel> check box in the <link linkend="setup-docu-columns">setup table</link> will alway be disabled.
+</para>
+
+<para>
+You may add new entries using the <link linkend="setup-docu-buttons">buttons</link> to the right of the list field. &kdevelop; will filter <filename>*.toc</filename> files in the directory dialog associated to the <guibutton>Add</guibutton> and <guibutton>Edit</guibutton> buttons.
+</para>
+
+<note><para>
+Other than former &kdevelop; versions will the <guibutton>Remove</guibutton> button not change the <filename>*.toc</filename> files on disk, so the remove operation is safe now.
+</para></note>
+
+</sect3> <!-- setup-docu-general-toc -->
+
+<sect3 id="setup-docu-general-toc-files">
+<title>&kdevelop; TOC Files</title>
+
+<para>
+There is a special feature associated with this. To illustrate, follow these steps: In the documentation tree find an entry shortly below the &Qt;/&kde; documentation (&eg; <quote>KDE2 Development Book (kde.org)</quote>). Click on the plus sign next to it. A tree will open where you can quickly navigate to subsequent chapters nested several levels deep, all offline. But if you finally select one of the chapters, &kdevelop; will in many cases try to access a <emphasis>remote</emphasis> documentation file.
+</para>
+
+<para>
+The rationale behind this is not only to locally navigate remote documentation without wasting net access ressources, but to provide the developer with easy, structured access to the documentation he/she needs. Using these tools one can access almost any local or remote documentation in a structured fashion even if the original is laid out flat or structured in another way. All that is needed is access to files and/or parts of files which are displayable by the Konqueror.
+</para>
+
+<para>
+Such structured access is made possible through the use of special <quote>table of content</quote> files, which are denoted by <filename>.toc</filename> filename extensions. Any such &kdevelop; TOC file contains an &XML; structured description of the document to be accessed.
+</para>
+
+<variablelist>
+<varlistentry>
+<term>Standard Directory of &kdevelop; TOC Files</term>
+<listitem>
+<para>
+When &kdevelop; was installed usually a series of predefined <filename>.toc</filename> files has been put into the <filename class="directory">$KDEDIR/share/apps/kdevdocumentation/tocs</filename> directory. These are fairly simple, structured text files. You may look at them using a text editor or other text display facility.
+</para>
+</listitem>
+</varlistentry></variablelist>
+
+<!-- FIXME: Lauri Watts (2005-05-03) This could be marked up a whole lot -->
+<!-- more clearly with the sgmltags stuff.  Making a note to do that once -->
+<!-- this first revision is done. -->
+
+<variablelist id="toc-file-structure">
+  <title>Basic Structure of &kdevelop; TOC Files</title>
+  <varlistentry>
+    <term>header</term>
+    <listitem>
+      <simplelist>
+        <member>
+          <computeroutput>&lt;!DOCTYPE kdeveloptoc&gt;</computeroutput>
+        </member>
+        <member>
+          <computeroutput>&lt;kdeveloptoc&gt;</computeroutput>
+        </member>
+        <member>
+          <emphasis>(title)</emphasis>
+        </member>
+        <member>
+          <emphasis>(base address)</emphasis>
+        </member>
+        <member>
+          <emphasis>(content structure)</emphasis>
+        </member>
+        <member>
+          <emphasis>(index structure)</emphasis>
+        </member>
+        <member>
+          <computeroutput>&lt;/kdeveloptoc&gt;</computeroutput>
+        </member>
+      </simplelist>
+      <para>
+      This &XML; structure will be parsed by the &kdevelop; <guilabel>Documentation</guilabel> plugin to set up the documentation tree contents and to guide the user in navigating the documentation. It contains all information necessary to display titles and access the documentation file contents.
+      </para>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>title</term>
+    <listitem>
+      <simplelist>
+        <member>
+          <computeroutput>&lt;title&gt;</computeroutput>
+          <emphasis>(some title string)</emphasis>
+          <computeroutput>&lt;/title&gt;</computeroutput>
+        </member>
+      </simplelist>
+      <para>
+      This is the title &kdevelop; will display at the basic levels in the documentation tree.
+      </para>
+      <note><para>
+      This displayed title cannot be changed by the user. If you want another text be displayed, you must manually change the <computeroutput>&lt;title&gt;</computeroutput> entry in the <filename>.toc</filename> file.
+      </para></note>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>base address</term>
+    <listitem>
+      <simplelist>
+        <member>
+          <computeroutput>&lt;base href="</computeroutput>
+          <emphasis>(base document &URL;)</emphasis>
+          <computeroutput>"/&gt;</computeroutput>
+        </member>
+      </simplelist>
+      <para>
+      This &URL; points to the location where all files of this documentation are located. It will be prepended before each section &URL; in the following content structure list. So, if you &eg; downloaded a documentation from a remote server, all you need to display the files from this new location is to change its <computeroutput>&lt;base&gt;</computeroutput> &URL;.
+      </para>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>content structure</term>
+    <listitem>
+      <simplelist>
+        <member>
+          <computeroutput>&lt;tocsect1 name="</computeroutput>
+          <emphasis>(section title)</emphasis>
+          <computeroutput>" url="</computeroutput>
+          <emphasis>(section &URL;)</emphasis>
+          <computeroutput>"&gt;</computeroutput>
+        </member>
+        <member>...</member>
+        <member>
+          <computeroutput>&lt;tocsectn name="</computeroutput>
+          <emphasis>(section title)</emphasis>
+          <computeroutput>" url="</computeroutput>
+          <emphasis>(section &URL;)</emphasis>
+          <computeroutput>"/&gt;</computeroutput>
+        </member>
+        <member>...</member>
+        <member>
+          <computeroutput>&lt;/tocsect1&gt;</computeroutput>
+        </member>
+      </simplelist>
+      <para>
+      All remaining navigation and access information is stored in a series of nested <computeroutput>&lt;tocsecti&gt;</computeroutput> ... <computeroutput>&lt;/tocsecti&gt;</computeroutput> pairs. Each <emphasis>i</emphasis> denotes a consecutive nesting level down to number <emphasis>n</emphasis> which will correspond to the finally displayed documentation section.
+      </para>
+      <para>
+      Any <computeroutput>&lt;tocsecti&gt;</computeroutput> entry must have a <computeroutput>name="xxx"</computeroutput> attribute associated with it (the "xxx" denotes the actual title string). This name will be displayed as level title in the documentation tree. It should correspond to an actual documentation section.
+      </para>
+      <para>
+      There may be an <computeroutput>url=""</computeroutput> attribute associated with any <emphasis>i</emphasis> nesting level. When the user clicks on a section title in the documentation tree &kdevelop; will try to access the file at the location pointed to by the combined base and section &URL;.
+      </para>
+      <para>
+      The <computeroutput>&lt;tocsectn/&gt;</computeroutput> entry must have an <computeroutput>url=""</computeroutput> attribute whatsoever.
+      This final nested <computeroutput>&lt;tocsectn/&gt;</computeroutput> does not come in pairs but will immediately be closed by a <computeroutput>/</computeroutput> before the <computeroutput>&gt;</computeroutput> bracket.
+      </para>
+      <note><para>
+      Any address combined of base and section &URL; must point to some displayable text file. Usually this will be an HTML-structured file. It is possible to link to anchor marks within such an HTML file using the standard # notation of the format: <filename>/base-url/section-url#anchor-mark</filename>.
+      </para></note>
+    </listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>index structure</term>
+    <listitem>
+      <simplelist>
+        <member>
+          <computeroutput>&lt;index&gt;</computeroutput>
+        </member>
+        <member>
+          <computeroutput>&lt;entry name="</computeroutput>
+          <emphasis>(index entry title)</emphasis>
+          <computeroutput>" url="</computeroutput>
+          <emphasis>(index section &URL;)</emphasis>
+          <computeroutput>"/&gt;</computeroutput>
+        </member>
+        <member>
+          <computeroutput>&lt;/index&gt;</computeroutput>
+        </member>
+      </simplelist>
+      <para>
+      Index is a plain list of index entries - pairs of title and &URL;. Index is not mandatory.
+      </para>
+    </listitem>
+  </varlistentry>
+</variablelist>
+<!-- FIXME: End -->
+
+</sect3> <!-- setup-docu-general-toc-files  -->
+
+<sect3 id="setup-docu-general-devhelp">
+<title>DevHelp Documentation</title>
+
+<para>
+DevHelp documentation is another means of structured documentation access. It uses structured table of content files denoted by a <filename>.devhelp</filename> extension similar to <link linkend="setup-docu-general-toc-files">&kdevelop; TOC files</link> to access documentation for the GNOME 2 desktop.
+</para>
+<para>
+You can control which DevHelp files should be accessible on the <guilabel>DevHelp Documentation Collection</guilabel> configuration page.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-docu-devhelp.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    Providing DevHelp documentation
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+DevHelp files originally were accessible on the <ulink url="http://lidn.sourceforge.net/">LiDN</ulink> website, but this seems to be not maintained for some time now. More recent DevHelp documentation is available at the <ulink url="http://htmlhelp.berlios.de/books/devhelp.php">DevHelp Books Download</ulink> web page.
+</para>
+
+<para>
+When &kdevelop; is installed it will attempt to find all <filename>.devhelp</filename> files in some standard places in the system, &eg; in the subdirectories of <filename class="directory">/opt/gnome/share/</filename>. Initially these files will not be marked for display.  If you want to see another documentation, mark the <guilabel>TOC</guilabel> check box in the <link linkend="setup-docu-columns">setup table</link>.
+</para>
+
+<para>
+You may add new entries using the <link linkend="setup-docu-buttons">buttons</link> to the right of the list field. &kdevelop; will filter <filename>*.toc</filename> files in the directory dialog associated to the <guibutton>Add</guibutton> and <guibutton>Edit</guibutton> buttons.
+</para>
+
+</sect3> <!-- setup-docu-general-devhelp -->
+
+<sect3 id="setup-docu-general-custom">
+<title>Setting Up Custom Documentation Collections</title>
+
+<para>
+This is for your own purpose. You may add almost any documentation files here, provided they can be displayed by the &konqueror; plugins.
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-docu-custom.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    Providing custom documentation
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+<para>
+Usually this collection will be empty at first &kdevelop; startup. We have filled in a deliberate item to show the entry structure.
+</para>
+<para>
+Handling is straightforward here. Use the <link linkend="setup-docu-buttons">buttons</link> to the right of the list field to add, edit or remove the document items. &kdevelop; will not filter anything in the directory dialog associated to the <guibutton>Add</guibutton> and <guibutton>Edit</guibutton> buttons.
+</para>
+
+<para>
+You will have to explicitely select the items for display in the &kdevelop; documentation facility. Mark the <guilabel>TOC</guilabel> check box of the entry in the <link linkend="setup-docu-columns">setup table</link>.
+</para>
+
+<note><para>
+Custom documention cannot be indexed or searched. Thus the <guilabel>Index</guilabel> and <guilabel>Search</guilabel> check boxes have no effect here as shown above.
+</para></note>
+
+</sect3> <!--- setup-docu-general-custom -->
+
+</sect2> <!-- setup-docu-general -->
+
+<sect2 id="setup-docu-textsearch">
+<title>Setting Up Text Search Indexes</title>
+
+<para>
+(... to be written ...)
+</para>
+
+<screenshot>
+  <mediaobject>
+    <imageobject>
+      <imagedata fileref="configure-doctree-textsearch.png" format="PNG"/>
+    </imageobject>
+    <caption><para>
+    Setting up text search indexes
+    </para></caption>
+  </mediaobject>
+</screenshot>
+
+</sect2> <!-- setup-docu-textsearch -->
+
+<sect2 id="setup-docu-other">
+<title>Other Documentation Configuration Settings</title>
+
+<para>
+(... to be written ...)
+</para>
+
+</sect2> <!-- setup-docu-other -->
+
+</sect1> <!-- setup-docu -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="setup-advanced">
+<title>Advanced Configuration</title>
+
+<para>
+(... to be written ...)
+</para>
+
+<sect2 id="setup-plugins">
+<title>Plugin Tools</title>
+
+<para>
+(... to be written ...)
+</para>
+</sect2> <!-- setup-plugins -->
+
+</sect1> <!-- setup-advanced -->
+
+</chapter> <!-- setup -->
diff --git a/doc/kdevelop/split-source-header-navigate.png b/doc/kdevelop/split-source-header-navigate.png
new file mode 100644
index 00000000..f4d72868
--- /dev/null
+++ b/doc/kdevelop/split-source-header-navigate.png
diff --git a/doc/kdevelop/split-source-header.png b/doc/kdevelop/split-source-header.png
new file mode 100644
index 00000000..d57b306b
--- /dev/null
+++ b/doc/kdevelop/split-source-header.png
diff --git a/doc/kdevelop/split-windows.png b/doc/kdevelop/split-windows.png
new file mode 100644
index 00000000..3ebb79f5
--- /dev/null
+++ b/doc/kdevelop/split-windows.png
diff --git a/doc/kdevelop/split-workspace.png b/doc/kdevelop/split-workspace.png
new file mode 100644
index 00000000..d497ab49
--- /dev/null
+++ b/doc/kdevelop/split-workspace.png
diff --git a/doc/kdevelop/survey-manual.docbook b/doc/kdevelop/survey-manual.docbook
new file mode 100644
index 00000000..d9611a03
--- /dev/null
+++ b/doc/kdevelop/survey-manual.docbook
@@ -0,0 +1,228 @@
+<chapter id="survey-manual">
+<title>What This Manual Contains</title>
+
+<para>
+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.
+</para>
+<para>
+Here you will find information on the following topics:
+</para>
+<variablelist>
+<varlistentry>
+<term><link linkend="getting-started">Getting Started with &kdevelop; &mdash; a Guided Tour</link> </term>
+<listitem>
+<para>Gives you a quick start on the use of this &IDE;, introducing the basic steps of how to work on a project.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="kdevelop-survey">Overview of the Features of
+ &kdevelop;</link></term>
+<listitem>
+<para>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;.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="setup">Configuring &kdevelop;</link></term>
+<listitem>
+<para>Shows how you can tailor the &IDE; to suit your needs.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="applicationwizard">Getting started: the
+&appwizard;</link></term>
+<listitem>
+<para>Describes the basics of how to set up a new project in &kdevelop;
+using the built-in &appwizard;.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="editing">Editing tools</link></term>
+<listitem>
+<para>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.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="file-browsers">The File Browsers</link></term>
+<listitem>
+<para>Demonstrates various tools to look at the structure of your project
+and how to access the files you want to work with.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="class-browsers">The Class Browsers</link></term>
+<listitem>
+<para>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.
+</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="documentation">Documentation</link></term>
+<listitem>
+<para>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.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="project-management">Building and Project
+ Management</link></term>
+<listitem>
+<para>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.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="adv-build-management">Advanced Build
+ Management</link></term>
+<listitem>
+<para>Looks at ways to keep multiple build configurations, to cross-compile
+for diverse platforms, or to make an embedded system using the
+<application>Qt/embedded</application> library.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="debugger">The Debugger Interface</link></term>
+<listitem>
+<para>Describes how to use the integrated <application>gdb</application>
+debugger interface so you can hunt down bugs without leaving
+&kdevelop;.</para>
+</listitem>
+</varlistentry>
+
+<!-- ### Currently disabled. Probably too specialized programming stuff. Check later again.
+  <listitem><para>
+  <link linkend="python">Python</link> &mdash; an overview of how to create Python-based applications in &kdevelop;.
+  </para></listitem>
+  <listitem><para>
+  <link linkend="php">PHP</link> &mdash;  an overview of how to create PHP-based HTML applications in &kdevelop;.
+  </para></listitem>//-->
+
+<varlistentry>
+<term><link linkend="cvs">Using CVS</link></term>
+<listitem>
+<para>Tells you how you can maintain your project using the CVS versioning
+system; a must, especially if many developers work on the same
+project.</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<!--
+  <listitem><para>
+  <link linkend="kdevelop-scripting">Scripting &kdevelop;</link> &mdash; describes how to add scripts to automate &kdevelop;.
+  </para></listitem>
+
+
+  <listitem><para>
+  Some commonly used information has been put into the <emphasis>appendix</emphasis>. Amongst others this consists of:
+-->
+<para>
+Some commonly used information has been put into the <emphasis>appendix</emphasis>. Amongst others this consists of:
+</para>
+
+<variablelist>
+<varlistentry>
+<term><link linkend="kdevelop-install">Installing &kdevelop;</link></term>
+<listitem>
+<para>Tells you where to obtain &kdevelop; and how to get it up and
+running.</para>
+</listitem>
+</varlistentry>
+</variablelist>
+
+<variablelist>
+<varlistentry>
+<term><link linkend="nutshell">In a Nutshell &mdash; Tips and
+Tricks</link></term>
+<listitem>
+<para>A quick reference to commonly used commands and actions. And a short
+guide to solve common problems when working with
+&kdevelop;.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="unixdev">Development on &UNIX;</link></term>
+<listitem>
+<para>A historical overview of &UNIX; program development, the main tools
+necessary and why you need an &IDE;.</para>
+</listitem>
+</varlistentry>
+
+<!--    
+    <listitem><para>
+    <link linkend="app-menus">Menus and Toolbars Overview</link> &mdash; provides you with a short overall view of the menu and toolbar selections available.
+    </para></listitem>
+
+    <listitem><para>
+      <link linkend="app-shortcuts">Shortcut Keys</link> &mdash; the keys you can use to work with &kdevelop; without resorting to the mouse.
+    </para></listitem>
+-->
+
+<varlistentry>
+<term><link linkend="app-files">Configuration Files Used by
+ &kdevelop;</link></term>
+<listitem><para>Lists the files &kdevelop; uses to save its internal
+ information. This is particularly useful in case something went wrong with
+ your setup.</para>
+</listitem>
+</varlistentry>
+
+<varlistentry><term>
+<link linkend="plugin-tools">Plugin Tools</link>
+</term><listitem><para>Lists the pluggable tools you can use to taylor the capabilities of
+&kdevelop; to your needs.
+</para></listitem></varlistentry>
+
+<!--  
+  <listitem><para>
+  <link linkend="plugin-tools">Plugin tools</link> &mdash; 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.
+  </para></listitem>
+-->
+<varlistentry><term>    
+<link linkend="app-uimodes-examples">KDevelop User Interface Mode Examples </link>
+</term><listitem><para>Shows user interface modes.
+</para></listitem></varlistentry>
+  
+<varlistentry><term>
+<link linkend="app-misc-info">Further Information </link> </term><listitem><para>
+Getting Information, reporting Bugs etc.
+</para></listitem></varlistentry>
+  
+<varlistentry><term>
+<link linkend="app-changelog">Changelog </link>
+</term><listitem><para>Shows the history of this documentation.
+</para></listitem></varlistentry>
+  
+<varlistentry><term>
+<link linkend="app-bibliography">Bibliography </link> 
+</term><listitem><para>Bibliography 
+</para></listitem></varlistentry>
+
+</variablelist>  
+    <!--
+    <listitem><para>
+    <link linkend="documentation-index">Index </link> &mdash; 
+    </para></listitem>
+-->  
+
+  
+</chapter>
diff --git a/doc/kdevelop/tutorial-debug-tree.png b/doc/kdevelop/tutorial-debug-tree.png
new file mode 100644
index 00000000..23c7f2c6
--- /dev/null
+++ b/doc/kdevelop/tutorial-debug-tree.png
diff --git a/doc/kdevelop/tutorial-hello-new.png b/doc/kdevelop/tutorial-hello-new.png
new file mode 100644
index 00000000..abbb912d
--- /dev/null
+++ b/doc/kdevelop/tutorial-hello-new.png
diff --git a/doc/kdevelop/tutorial-hello-options.png b/doc/kdevelop/tutorial-hello-options.png
new file mode 100644
index 00000000..7b9d98cd
--- /dev/null
+++ b/doc/kdevelop/tutorial-hello-options.png
diff --git a/doc/kdevelop/tutorial-new-project.png b/doc/kdevelop/tutorial-new-project.png
new file mode 100644
index 00000000..8f3aa78d
--- /dev/null
+++ b/doc/kdevelop/tutorial-new-project.png
diff --git a/doc/kdevelop/unixdev.docbook b/doc/kdevelop/unixdev.docbook
new file mode 100644
index 00000000..d7881afb
--- /dev/null
+++ b/doc/kdevelop/unixdev.docbook
@@ -0,0 +1,386 @@
+<appendix id="unixdev">
+
+<appendixinfo>
+  <authorgroup>
+    <author><firstname>Bernd</firstname><surname>Pol</surname></author>
+    <!-- ROLES_OF_TRANSLATORS -->
+  </authorgroup>
+</appendixinfo>
+
+<title>Development on &UNIX;</title>
+
+<indexterm zone="unixdev"><primary>development</primary></indexterm>
+<indexterm zone="unixdev">
+  <primary>&UNIX;</primary>
+  <secondary>development</secondary></indexterm>
+
+<sect1 id="history">
+<title>Some Historical Remarks</title>
+
+<indexterm zone="history"><primary>history</primary></indexterm>
+<indexterm zone="history"><primary>scripting languages</primary></indexterm>
+<indexterm zone="history">
+  <primary>&UNIX;</primary>
+  <secondary>history</secondary></indexterm>
+<indexterm zone="history">
+  <primary>&UNIX;</primary>
+  <secondary>pipe</secondary></indexterm>
+<indexterm zone="history">
+  <primary>&UNIX;</primary>
+  <secondary>shell</secondary></indexterm>
+<indexterm zone="history">
+  <primary>shell</primary>
+  <secondary>&UNIX;</secondary></indexterm>
+
+<para>
+From the beginning, &UNIX; has maintained two very different development paradigms. One is the world of <emphasis>system and application programming languages</emphasis>, where some source code is translated to machine code by a translation program, usually a <emphasis>compiler</emphasis> or an <emphasis>interpreter</emphasis>. The programming language C is an example. &UNIX; was the first operating system kernel to be written in such a high level language instead of tightly machine-oriented assembler which was common before that time. (In fact, the C language once even was invented to write the &UNIX; kernel and associated programs on a DEC PDP-11 computer.)
+</para>
+<para>
+The other paradigm is the world of <emphasis>scripting languages</emphasis>. This world evolved with the invention of the &UNIX; shell which was the user's interface to the operating system&mdash;and at the same time a very high level programming language. A shell script is built from a set of small utility programs like &eg; <command>grep</command>, <command>sed</command>, or <command>find</command>. Each such utility is designed for some tightly defined job. The trick is that any such utility can be connected to another one via a simple transport mechanism, called a <emphasis>pipe</emphasis>, which directs the output of the foregoing utility into the input of the next processed one. This makes for a very powerful and highly flexible programming tool.
+</para>
+<para>
+As time has gone by, both worlds have evolved. While C is still used mainly as a system programming language, C++ as a variant of C enriched by object-oriented and generic extensions has found its place for the development of complex applications in the 1990's. There are numerous other programming languages, even older ones keep their place&mdash;FORTRAN77 and Ada &eg; still have their stronghold in numerical applications.
+</para>
+</sect1> <!-- history -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="unixdev-scripting-languages">
+<title>Contemporary Scripting Languages</title>
+<para>
+In the scripting area, there has been a shift away from the shell, which suffers from portability concerns, to languages which unify all commonly needed functionality in their standard libraries, while still being able to interface to the outside through pipes when necessary.
+</para>
+<para>
+All these scripting languages have in common that they are widely portable between &UNIX; variants, Microsoft &Windows;, &MacOS; or even VMS. Also, they all have implementations that are freely distributable.
+</para>
+
+<sect2 id="unixdev-SL-Perl">
+<title>&perl;</title>
+
+<indexterm zone="unixdev-SL-Perl"><primary>Perl</primary></indexterm>
+<indexterm zone="unixdev-SL-Perl">
+  <primary>scripting languages</primary>
+  <secondary>Perl</secondary></indexterm>
+
+<para>
+<ulink url="http://www.perl.com">&perl;</ulink> has become popular as a text processing and system administration language. In the beginning of the World Wide Web, CGI scripts written in &perl; were a widely used method to create dynamic web pages from databases. Today, this method has been replaced mostly by the <command>mod_perl</command> plugin for the &apache; web server. Among &perl;'s strengths are its built-in support for advanced regular expression matching and its rich archive of freely distributed modules.
+</para>
+<para>
+For more information see the <ulink url="http://cpan.org">Comprehensive Perl Archive Network (<acronym>CPAN</acronym>)</ulink> website.
+</para>
+</sect2> <!-- unixdev-SL-Perl -->
+
+<sect2 id="unixdev-SL-Python">
+<title>Python</title>
+
+<indexterm zone="unixdev-SL-Python"><primary>Python</primary></indexterm>
+<indexterm zone="unixdev-SL-Python">
+  <primary>scripting languages</primary>
+  <secondary>Python</secondary></indexterm>
+
+<para>
+<ulink url="http://www.python.org">&python;</ulink> shines by the elegance of its class system and the ease and flexibility with which external libraries can be wrapped in a way that they appear like standard &python; classes and functions. In contrast to &perl;, &python; has a clear and concise embedding &API;, which makes it the language of choice for making C and C++ programs scriptable.
+</para>
+</sect2> <!-- unixdev-SL-Python -->
+
+<sect2 id="unixdev-SL-PHP">
+<title>PHP</title>
+
+<indexterm zone="unixdev-SL-PHP"><primary>PHP</primary></indexterm>
+<indexterm zone="unixdev-SL-PHP">
+  <primary>scripting languages</primary>
+  <secondary>PHP</secondary></indexterm>
+
+<para>
+<ulink url="http://www.php.net">&php;</ulink> was invented as a language directly embeddable into &HTML; pages and consequently has its main uses in delivering dynamic content on the web.
+</para>
+</sect2> <!-- unixdev-SL-PHP -->
+</sect1> <!-- unixdev-scripting-languages -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+<sect1 id="unixdev-hl-script">
+<title>Higher-level Scripting</title>
+
+<para>
+Higher-level &UNIX; applications usually miss the speed and flexibility of the traditional character-oriented shell scripting mechanisms. This is especially true in the world of graphical user interfaces (&GUI;) such as &eg; &kde;.
+</para>
+<para>
+There have been attempts to provide similar mechanisms which will work on a higher application level, most notably <link linkend="unixdev-corba">CORBA</link> and, in the &kde; environment, <link linkend="unixdev-dcop">&DCOP;</link>.
+</para>
+
+<sect2 id="unixdev-corba">
+<title>The CORBA Protocol</title>
+
+<indexterm zone="unixdev-corba"><primary>CORBA</primary></indexterm>
+<indexterm zone="unixdev-corba">
+  <primary>scripting languages</primary>
+  <secondary>CORBA</secondary></indexterm>
+<indexterm zone="unixdev-corba">
+  <primary>communication</primary>
+  <secondary>CORBA</secondary></indexterm>
+
+<para>
+<ulink url="http://www.omg.org/gettingstarted/corbafaq.htm">CORBA</ulink> (<emphasis>Common Object Request Broker Architecture</emphasis>) is an attempt to let computer applications work together over networks. It was devised by the private, vendor independent <ulink url="http://www.omg.org">OMG</ulink> (Object Management Group) standards comittee.
+</para>
+<para>
+CORBA-based programs use the IIOP standard protocol to communicate. Implementations based on IIOP are available on a wide variety of operating systems, programming languages, and networks and are thus highly portable.
+</para>
+<para>
+The main drawback of CORBA is its rather low speed. While this may be tolerable in networks, it is a real hindrance for inter-application communications in a non-networked environment such as &kde; running on a single computer.
+</para>
+
+</sect2> <!-- unixdev-corba -->
+
+<sect2 id="unixdev-dcop">
+<title>The &DCOP; Interface</title>
+
+<indexterm zone="unixdev-dcop"><primary>DCOP</primary></indexterm>
+<indexterm zone="unixdev-dcop">
+  <primary>scripting languages</primary>
+  <secondary>DCOP</secondary></indexterm>
+<indexterm zone="unixdev-dcop">
+  <primary>communication</primary>
+  <secondary>DCOP</secondary></indexterm>
+
+<para>
+Another evolution on &UNIX;-like scripting is the <ulink url="http://developer.kde.org/documentation/library/kdeqt/dcop.html"><emphasis>DCOP</emphasis></ulink> protocol which was devised for communication between &kde; applications to overcome the limitations of CORBA.
+</para>
+<para>
+&DCOP; stands for <emphasis>Desktop Communication Protocol</emphasis> and is implemented as a simple IPC/RPC mechanism built to operate over sockets. In effect this provides facilities similar to the traditional &UNIX; pipe mechanism.
+</para>
+<para>
+Traditional shell scripting is based on fairly small tool programs which were designed to work on a strictly textual basis. &DCOP; allows elaborate graphical programs to communicate with each other in a quite similar way. This enables &eg; a &kde; program to send messages to another &kde; program, or receive data from it for its own purposes.
+</para>
+<para>
+There are drawbacks, however. To use &DCOP; a program must be designed to contain a special &DCOP; interface. And the &DCOP; communication process runs somewhat slowly (although a lot faster than CORBA). But it returns much of the power and flexibility of &UNIX; scripting to high-level programs which are based on a graphical user interface.
+</para>
+<para>
+For more information, see the <ulink url="http://developer.kde.org/documentation/library/kdeqt/dcop.html">DCOP: Desktop COmmunications Protocol</ulink> paper or <ulink url="developer.kde.org/documentation/library/cvs-api/dcop/html/index.html">The &DCOP; Desktop Communication Protocol library</ulink> &API; reference of the &kde; dcop library.
+</para>
+</sect2> <!--  unixdev-dcop -->
+
+</sect1> <!--  unixdev-hl-script -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="unixdev-buildsystems">
+<title>Build Systems</title>
+
+<para>
+Except in very simple cases a programming project will consist of a lot of building blocks of source code each put into a separate file for easier maintenance. To make this running one has to effectively translate all this stuff into a few machine language units in a suiting format which allows the operating system to load and execute the program.
+</para>
+<para>
+To accomplish this, the basic tools needed are
+<itemizedlist>
+  <listitem><para>
+  a <emphasis>text editor</emphasis> to write the source code files,
+  </para></listitem>
+  <listitem><para>
+  a translating program, usually a <emphasis>compiler</emphasis> to turn the source code into object files,
+  </para></listitem>
+  <listitem><para>
+  a <emphasis>librarian</emphasis> which collects object files into libraries to reuse them easily without the need to recompile,
+  </para></listitem>
+  <listitem><para>
+  a <emphasis>linker</emphasis> which binds several object files and libraries together into one executable,
+  </para></listitem>
+  <listitem><para>
+  a <emphasis>make system</emphasis> which provides some means to manage all this stuff and&mdash;not to forget
+  </para></listitem>
+  <listitem><para>
+  a <emphasis>debugger</emphasis> to (hopefully) find all errors in the program and possibly some other diagnostic tools to get everything running smoothly.
+  </para></listitem>
+</itemizedlist>
+</para>
+
+<para>
+When you have a large project consisting of possibly hundreds of source code files, the process of compiling may become quite laborsome. You do not want to recompile all files each time you have changed only some of them. Instead, you only want to compile those files which are affected by the changes. In general, it is not always easily obvious which of the files have to be recompiled.
+</para>
+<para>
+When you &eg; change a function prototype in a header file, you need to compile every file which includes this header file. If your project contains many such files you may easily miss one or two of them if you have to do the job manually. Thus some means of automization is necessary.
+</para>
+
+<sect2 id="unixdev-buildsystems-make">
+<title>The Make Process</title>
+
+<indexterm zone="unixdev-buildsystems-make">
+  <primary>make</primary></indexterm>
+<indexterm zone="unixdev-buildsystems-make">
+  <primary>Makefile</primary></indexterm>
+<indexterm zone="unixdev-buildsystems-make">
+  <primary>rule</primary></indexterm>
+<indexterm zone="unixdev-buildsystems-make">
+  <primary>recompilations</primary></indexterm>
+<indexterm zone="unixdev-buildsystems-make">
+  <primary>target</primary></indexterm>
+<indexterm zone="unixdev-buildsystems-make">
+  <primary>dependencies</primary></indexterm>
+<indexterm zone="unixdev-buildsystems-make">
+  <primary>commands</primary></indexterm>
+
+<para>
+A tool which takes care of recompilations is <command>make</command>. It keeps track of all work using a set of <emphasis>rules</emphasis> which describe what to do in case some piece of information (usually a source or object code file) was changed. All rules belonging to a certain project are stored in a so-called <filename>Makefile</filename> which is processed by <command>make</command> any time you want to update your work.
+</para>
+<para>
+Each rule consists of several building blocks, namely
+<itemizedlist>
+  <listitem><para>
+  a <emphasis>target</emphasis>, &ie; the file to be built
+  </para></listitem>
+  <listitem><para>
+  a set of <emphasis>dependencies</emphasis>, basically the names of those files the target depends on (&eg; the name of a source file, where then the target will be the name of the object file to be built) and
+  </para></listitem>
+  <listitem><para>
+  the <emphasis>commands</emphasis> which are to be executed to <quote>make</quote> the target (&ie; to compile it or to link other object files together to build an executable progam file).
+  </para></listitem>
+</itemizedlist>
+</para>
+<para>
+Basically the <command>make</command> command will read the rules one after another, check each file in the dependency list of a given target and make this target anew if any one of these files has changed, using the commands listed in that rule.
+</para>
+<para>
+There are several additional possibilities to control such a make process, and a <filename>Makefile</filename> can thus grow very complex. We cannot go into the details here. However, we recommend that you make yourself accustomed to the syntax of <command>make</command>. Even if you do not normally use it directly, an understanding of the fundamentals of the build system can be useful. See the <ulink url="info://make/Top"> <quote>GNU Make Manual</quote></ulink> for more information. </para>
+<para>
+For more &kdevelop; specific detail see the <link  linkend="project-management">Building and Project Management</link> chapter of this manual.
+</para>
+<para>
+There are several tutorials available, see the <link linkend="automake-references">references</link> in the Building and project management chapter.
+</para>
+</sect2> <!-- unixdev-buildsystems-make -->
+
+</sect1> <!-- unixdev-buildsystems -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="unixdev-guidevelopment">
+<title>&GUI; Development</title>
+
+<indexterm zone="unixdev-guidevelopment">
+  <primary>GUI</primary></indexterm>
+<indexterm zone="unixdev-guidevelopment">
+  <primary>graphical user interface</primary></indexterm>
+<indexterm zone="unixdev-guidevelopment">
+  <primary>user interface</primary>
+  <secondary>GUI</secondary></indexterm>
+
+<para>
+Application developers become even more encumbered by having not only to create program libraries and logic, but also to provide an easy to use custom built user interface that is both intuitive and functional.  Most programmers receive little to no training in &GUI; development, and as a result user interfaces often are poorly designed.
+</para>
+<para>
+During the years some common design principles have evolved. It is strongly advised to adhere to them. This way your user interfaces will retain a common look and feel that the users of your application will gratefully appreciate.
+</para>
+<para>
+For &kde; &GUI; development there is a style guide available. It is found in the <ulink url="http://developer.kde.org/documentation/standards/kde/style/basics/index.html">&kde; User Interface Guidelines</ulink> on the &kde; Developer's Corner page.
+</para>
+<para>
+A short introduction to common &GUI; design principles can be found <ulink url="http://axp16.iie.org.mx/Monitor/v01n03/ar_ihc2.htm">here</ulink>.
+</para>
+
+</sect1> <!-- unixdev-guidevelopment -->
+
+<!-- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -->
+
+<sect1 id="unixdev-ide">
+<title>Integrating Concepts and Tools &ndash; the IDE</title>
+
+<indexterm zone="unixdev-ide">
+  <primary>IDE</primary></indexterm>
+<indexterm zone="unixdev-ide">
+  <primary>integrated development environment</primary></indexterm>
+<indexterm zone="unixdev-ide">
+  <primary>development</primary>
+  <secondary>IDE</secondary></indexterm>
+<indexterm zone="unixdev-ide">
+  <primary>environment</primary>
+  <secondary>IDE</secondary></indexterm>
+
+<para>
+There are separate tools available for almost any step in the programming process&mdash;planning, editing, managing files and compilation processes, debugging, documentation and the like. But once the projects grow the programming processes will most likely become quite cumbersome.
+</para>
+<para>
+Much repetitive work has to be done when designing, compiling, and debugging a program. A lot of such work can be saved through the use of templates and scripts. And another lot by keeping these tools easily available and able to communicate with each other under a common &GUI;.
+</para>
+<para>
+For example&mdash;would it not be convenient if a debugger were able to open the source file in question in an editor and place the cursor directly at the position of that bug just found?
+</para>
+<para>
+To more easily accomplish such a scheme, <emphasis>Integrated Development Environments</emphasis> (&IDE;s) were devised. Such an &IDE; integrates all templates, tools, and scripts which are commonly needed in the development process into one single environment.
+</para>
+<para>
+For the &kde; platform &kdevelop; is such an &IDE;. It provides a wide range of tools which ease program development and maintenance, even for different programming languages and across platforms.
+</para>
+
+<sect2 id="unixdev-ide-kdevelop">
+<title>Basic Features of &kdevelop; &kdevrelease;</title>
+
+<indexterm zone="unixdev-ide-kdevelop">
+  <primary>&kdevelop;</primary>
+  <secondary>features</secondary></indexterm>
+<indexterm zone="unixdev-ide-kdevelop">
+  <primary>features</primary></indexterm>
+
+<!-- ### copied from web page, needs to be updated -->
+
+<itemizedlist>
+  <listitem>
+  <para>Manages all <emphasis>development tools</emphasis> needed for C++ programming, such as compiler, linker, debugger and build system.</para>
+  </listitem>
+  <listitem>
+  <para>Provides an <emphasis>&appwizard;</emphasis> which generates complete, ready-to-go sample applications.</para>
+  </listitem>
+  <listitem>
+  <para>Allows the user to select an <emphasis>integrated editor</emphasis> based on the &kde; programmer's editor &kwrite;, Trolltec's <application>QEditor</application>, or others.</para>
+  </listitem>
+  <listitem>
+  <para>A <emphasis>class generator</emphasis>, for creating new classes and integrating them into the current project.</para>
+  </listitem>
+  <listitem>
+  <para><emphasis>File management</emphasis> for sources, headers, documentation &etc; to be included in the project.</para>
+  </listitem>
+  <listitem>
+  <para>Assistance in <emphasis>creating application user manuals</emphasis> written with &kde; tools.</para>
+  </listitem>
+  <listitem>
+  <para>Automatic &HTML; based <emphasis>&API; documentation</emphasis> for a project's classes with cross-references to the used libraries.</para>
+  </listitem>
+  <listitem>
+  <para><emphasis>Internationalization support</emphasis>, allowing translators to add their target language to a project easily, including support for &kbabel;.</para>
+  </listitem>
+  <listitem>
+  <para>Support for managing a project via one of several <emphasis>versioning systems</emphasis> (&eg; &CVS;) by providing an easy-to-use frontend for the most needed functions.</para>
+  </listitem>
+  <listitem>
+  <para>An integrated <emphasis>debugger</emphasis> frontend.</para>
+  </listitem>
+  <listitem>
+  <para>An integrated <emphasis>shell console</emphasis> emulator.</para>
+  </listitem>
+  <listitem>
+  <para><emphasis>Syntax highlighting</emphasis> in source texts.</para>
+  </listitem>
+  <listitem>
+  <para>An <emphasis>auto-code completion</emphasis> facility for class variables, class methods, function arguments and more.</para>
+  </listitem>
+  <listitem>
+  <para><emphasis>Templates for creating various projects</emphasis> (&kcontrol; modules, &kicker; (panel) applets, KIOSlaves, &konqueror; plugins and desktop styles).</para>
+  </listitem>
+  <listitem>
+  <para>Four <emphasis>navigation tree views</emphasis> for easily switching between source files, header files, classes and documentation, obviating the need for an external file manager.</para>
+  </listitem>
+  <listitem>
+  <para><emphasis>Cross-compiling support</emphasis>, with the ability to specify different compilers, compiler flags, target architecture, &etc;</para>
+  </listitem>
+  <listitem>
+  <para>Support for <emphasis>Qt/Embedded projects</emphasis> (such as the Zaurus and iPAQ).</para>
+  </listitem>
+  <listitem>
+  <para><emphasis>Inclusion of any other program</emphasis> you need for development by adding it to the <guimenuitem>Tools</guimenuitem> menu according to your individual needs.</para>
+  </listitem>
+</itemizedlist>
+
+</sect2> <!-- unixdev-ide-kdevelop -->
+
+</sect1> <!-- unixdev-ide -->
+
+</appendix> <!-- unixdev -->
+
diff --git a/doc/kdevelop/wrong-project-location.png b/doc/kdevelop/wrong-project-location.png
new file mode 100644
index 00000000..cb9c45a2
--- /dev/null
+++ b/doc/kdevelop/wrong-project-location.png
diff --git a/doc/platform/Mainpage.dox b/doc/platform/Mainpage.dox
new file mode 100644
index 00000000..dd69ba92
--- /dev/null
+++ b/doc/platform/Mainpage.dox
@@ -0,0 +1,148 @@
+/** \file Mainpage.dox
+    \brief The main page of the doxygen generated %API Documentation
+*/
+
+/**
+\mainpage The KDevelop Platform %API %Documentation
+
+
+KDevelop Platform is set of libraries and tools that are used to build IDEs (Integrated Development Environments),
+applications similar to IDEs (web development enviroment, text editors for programmers and designers, etc.)
+and/or IDE plugins for all possible purposes.
+
+Platform provides:
+- the plugin architecture (interfaces);
+- the common support libraries;
+- the generic shell with plugin profiles support.
+.
+
+\section intro Introduction
+
+This document is targeted at all those that want to build their own IDE or improve KDevelop's source code.
+If you are instead looking for a user manual, just go to the help menu of your KDevelop and select KDevelop handbook.
+This documentation contains the KDevelop Platform online class reference for the current
+development version of KDevelop.  Additionally, you
+can subscribe or read the <a href="http://www.kdevelop.org/index.html?filename=mailinglist.html">mailing list</a> for any additions and/or
+modifications to the Platform %API.
+
+An on-line, updated every 24H, html version of this documentation can be found at: http://www.kdevelop.org/HEAD/doc/platform/html/index.html
+
+You can also download a local browseable copy form http://www.kdevelop.org/HEAD/doc/platform/kdevplatformdoc.tar.bz2 . It gets updated every single day too.
+
+More information about the KDevelop Platform architecture in form of tutorials, Wikis, HOWTOs,
+and FAQs can be found at
+the <a href="http://www.kdevelop.org">KDevelop website</a>.
+
+Quick overviews of the architecture can also be found in the issues of <a href="http://www.kdevelop.org/doc/tehcnotes">
+KDevelop Technotes</a>.
+
+\section platformapi Platform Libraries API
+
+- <a href="kdevinterfaces/html/index.html"><b>Interfaces Library</b></a>
+   (<a href="kdevinterfaces/html/classes.html">classes</a>)\n
+   <i>Interfaces and classes that form KDevelop plugin architecture.</i>
+- <a href="kdevextensions/html/index.html"><b>Extension Interfaces Library</b></a>
+   (<a href="kdevextensions/html/classes.html">classes</a>)\n
+   <i>Extension interfaces used by KDevelop plugin architecture.</i>
+- <a href="kdevutil/html/index.html"><b>Utility Library</b></a>
+   (<a href="kdevutil/html/classes.html">classes</a>)\n
+   <i>Utility classes for the KDevelop architecture.</i>
+- <a href="kdevextras/html/index.html"><b>Extra Interfaces Library</b></a>
+   (<a href="kdevextras/html/classes.html">classes</a>)\n
+   <i>Extra interfaces that are not the part of KDevelop plugin architecture
+   but that can be implemented by extra plugins or "plugins for plugins".</i>
+- <a href="kdevwidgets/html/index.html"><b>Widgets Library</b></a>
+   (<a href="kdevwidgets/html/classes.html">classes</a>)\n
+   <i>A collection of widgets.</i>
+- <a href="propeditor/html/index.html"><b>Property Editing Library</b></a>
+   (<a href="propeditor/html/classes.html">classes</a>)\n
+   <i>A collection of facilities to store and edit the properties of various objects.</i>
+- <a href="kdevcatalog/html/index.html"><b>Catalog Library</b></a>
+   (<a href="kdevcatalog/html/classes.html">classes</a>)\n
+   <i>The persistant symbol store library working with BerkeleyDb backend.</i>
+.
+
+\section designerapi GUI Designer Integration API
+
+- <a href="external/html/index.html"><b>KInterfaceDesigner Library</b></a>
+   (<a href="external/html/classes.html">classes</a>)\n
+   <i>KInterfaceDesigner classes and interfaces which form the core of GUI Designer integration framework.</i>
+- <a href="designer_integration/html/index.html"><b>Designer Integration Support Library</b></a>
+   (<a href="designer_integration/html/classes.html">classes</a>)\n
+   <i>The base classes to implement GUI designer integration in language support plugins.</i>
+.
+
+\section pluginsapi Platform Plugins API
+
+- <a href="kdevdocinterfaces/html/index.html"><b>Documentation Part Interfaces Library</b></a>
+   (<a href="kdevdocinterfaces/html/classes.html">classes</a>)\n
+   <i>Interfaces to implement KDevelop documentation plugins.</i>
+.
+
+\section langapi Programming Language Support API
+
+- <a href="kdevlanginterfaces/html/index.html"><b>Language Support Interfaces Library</b></a>
+   (<a href="kdevlanginterfaces/html/classes.html">classes</a>)\n
+   <i>Interfaces for KDevelop language support facilities.</i>
+- <a href="kdevlangdebugger/html/index.html"><b>Debugger Support Library</b></a>
+   (<a href="kdevlangdebugger/html/classes.html">classes</a>)\n
+   <i>Classes to implement debugger support for a programming language.</i>
+.
+
+\section buildtoolapi Buildtool Support API
+
+- <a href="kdevbtbase/html/index.html"><b>Buildtool Base Library</b></a>
+   (<a href="kdevbtbase/html/classes.html">classes</a>)\n
+   <i>Base classes for KDevelop builtool support plugins.</i>
+- <a href="kdevpminterfaces/html/index.html"><b>Project Manager Interfaces Library</b></a>
+   (<a href="kdevpminterfaces/html/classes.html">classes</a>)\n
+   <i>Interfaces to implement plugins for the KDevelop generic project manager.</i>
+- <a href="kdevbtwidgets/html/index.html"><b>Buildtool Widgets Library</b></a>
+   (<a href="kdevbtwidgets/html/classes.html">classes</a>)\n
+   <i>Widgets commonly used in buildtool support plugins.</i>
+- <a href="kdevparserautotools/html/index.html"><b>Autotools parser Library</b></a>
+   (<a href="kdevparserautotools/html/classes.html">classes</a>)\n
+   <i>Parser for Autotools based support plugins.</i>
+- <a href="kdevparserqmake/html/index.html"><b>QMake parser Library</b></a>
+   (<a href="kdevparserqmake/html/classes.html">classes</a>)\n
+   <i>Parser for QMake based support plugins.</i>
+.
+
+\section shellapi Shell API
+
+- <a href="kdevshellsrc/html/index.html"><b>Generic Shell</b></a>
+   (<a href="kdevshellsrc/html/classes.html">classes</a>)\n
+   <i>The Shell - a profile-based implementation of KDevelop plugin architecture.</i>
+- <a href="kdevprofileslib/html/index.html"><b>Shell Profiles Library</b></a>
+   (<a href="kdevprofileslib/html/classes.html">classes</a>)\n
+   <i>Plugin profiles implementation for KDevelop shell.</i>
+.
+
+\section PlannedTasks Planned tasks
+
+Here is a priority ordered list:
+  -# fix the dispersed fixme
+  -# <a href="http://bugs.kde.org/buglist.cgi?product=kdevelop&bug_status=UNCONFIRMED&bug_status=NEW&bug_status=ASSIGNED&bug_status=REOPENED&order=bugs.bug_id">reported bugs in bugzilla database</a>
+  -# fix the dispersed todo all over the code.
+  .
+
+\section howTobuildAPIlocalcopy How to build a local copy of this documentation
+
+This documentation is large and changes with every cvs commit, therefore is not available for download.
+To build your local copy of this documentation you need to fetch KDevelop sources and 
+if you have doxygen >= 1.3.4 and (optionally) PHP >= 4.10 plus a local running webserver then
+- make apidox
+- make install-apidox (as root)
+.
+
+The advantage of the webserver is that you'll get a search engine in your documentation if you read your
+documentation using your local webserver.
+
+\section License
+
+Permission is granted to copy, distribute and/or modify this document under
+the terms of the GNU Free %Documentation License, Version 1.2 or any later
+version published by the Free Software Foundation; For details see
+http://www.gnu.org/copyleft/fdl.html .
+
+*/
diff --git a/doc/std/Makefile.am b/doc/std/Makefile.am
new file mode 100644
index 00000000..07f12cde
--- /dev/null
+++ b/doc/std/Makefile.am
@@ -0,0 +1,7 @@
+tocdir = ${kde_datadir}/kdevdocumentation/tocs
+toc_DATA = kdev3api.toc
+
+#indexdir = ${kde_datadir}/devdoctreeview/indices
+#index_DATA = 
+
+
diff --git a/doc/std/kdev3api.toc b/doc/std/kdev3api.toc
new file mode 100644
index 00000000..28d9cf3a
--- /dev/null
+++ b/doc/std/kdev3api.toc
@@ -0,0 +1,45 @@
+<!DOCTYPE kdeveloptoc>
+<kdeveloptoc>
+<title>KDevelop API Documentation</title>
+<base href="http://www.kdevelop.org/HEAD/doc/api/html"/>
+<tocsect1 name="Overview" url="index.html">
+	<tocsect2 name="KDevelop 3 Architecture" url="KDev3Arch.html"/>
+	<tocsect2 name="Programming Languages Status" url="LangSupportStatus.html"/>
+	<tocsect2 name="Editors Status" url="EditorsSupportStatus.html"/>
+</tocsect1>
+<tocsect1 name="How to" url="index.html#expand">
+	<tocsect2 name="Extend KDevelop via plugins" url="howToAddPlugins.html"/>
+	<tocsect2 name="Add a programming language" url="howToAddProgrammingLanguages.html"/>
+	<tocsect2 name="Add application templates" url="howToAddApplicationTemplates.html"/>
+	<tocsect2 name="Add file templates" url="howToAddFileTemplates.html"/>
+	<tocsect2 name="Add generic build tools" url="howToAddGenericBuildTools.html"/>
+	<tocsect2 name="Document KDevelop parts" url="howToDocument.html"/>
+</tocsect1>
+<tocsect1 name="Planned tasks" url="index.html#PlannedTasks">
+	<tocsect2 name="High priority tasks!" url="HighPriTasks.html"/>
+	<tocsect2 name="Future Tasks!" url="FutureTasks.html"/>
+</tocsect1>
+<tocsect1 name="Class Hierarchy" url="hierarchy.html">
+</tocsect1>
+<tocsect1 name="Classes" url="classes.html">
+</tocsect1>
+<tocsect1 name="Classes (annotated)" url="annotated.html">
+</tocsect1>
+<tocsect1 name="Members" url="functions.html">
+</tocsect1>
+<tocsect1 name="Namespaces" url="namespaces.html">
+</tocsect1>
+<tocsect1 name="Source Files" url="files.html">
+</tocsect1>
+<tocsect1 name="README.dox" url="index.html#misc">
+	<tocsect2 name="Requirements" url="requirements.html"/>
+	<tocsect2 name="Features" url="features.html"/>
+	<tocsect2 name="Authors" url="authors.html"/>
+	<tocsect2 name="Maintainers" url="maintainers.html"/>
+	<tocsect2 name="Unmaintained parts" url="unmaintained.html"/>
+	<tocsect2 name="Deprecated List" url="deprecated.html"/>
+	<tocsect2 name="Todo List" url="todo.html"/>
+	<tocsect2 name="Known Bugs" url="bug.html"/>
+	<tocsect2 name="F.A.Q." url="FAQ.html"/>
+</tocsect1>
+</kdeveloptoc>
diff --git a/doc/tools/Makefile.am b/doc/tools/Makefile.am
new file mode 100644
index 00000000..4eb7f5af
--- /dev/null
+++ b/doc/tools/Makefile.am
@@ -0,0 +1,4 @@
+EXTRA_DIST = index-texi index-python index.xsl \
+	     toc-gsdoc toc-docbook toc-python
+
+
diff --git a/doc/tools/index-python b/doc/tools/index-python
new file mode 100644
index 00000000..96cfcd8f
--- /dev/null
+++ b/doc/tools/index-python
@@ -0,0 +1,52 @@
+#!/usr/bin/perl
+
+use Getopt::Long;
+
+my $prefix = '';
+GetOptions( 'prefix=s' => \$prefix ) || die "Wrong options\n";
+
+$file = $ARGV[0];
+open(FILE, "$file") || die "File not found: $file\n";
+
+print "<conceptindex>\n";
+
+$ingroup = 0;
+while (<FILE>) {
+
+      if (/\<dt\>\<a href=\'(.+)'\>(.+)\<\/a\>/) {
+#              print "Index: $1, $2, $ingroup\n";
+               if ($ingroup) {
+                       $name = "$ingroup, $2";
+               } else {
+                       $name = $2;
+               }
+               $url = "$prefix/$1";
+               print "<entry name=\"$name\" url=\"$url\"/>\n";
+      } elsif (/\<dt\>(.+)/) {
+#              print "Ingroup: $1\n";
+              $ingroup = $1;
+      } elsif (/\s+\<\/dl>/) {
+              $ingroup = 0;
+      }
+}
+
+print "</conceptindex>\n";
+close(FILE);
+
+
+sub dehtml
+{
+        my ( $str ) = @_;
+
+        $str =~ s/\<CODE\>//g;
+        $str =~ s/\<\/CODE\>//g;
+        $str =~ s/\<TT\>//g;
+        $str =~ s/\<\/TT\>//g;
+
+        return $str;
+}
+
+# Local Variables:
+# mode: perl
+# fill-column: 120
+# End:
diff --git a/doc/tools/index-texi b/doc/tools/index-texi
new file mode 100755
index 00000000..8aa85184
--- /dev/null
+++ b/doc/tools/index-texi
@@ -0,0 +1,60 @@
+#!/usr/bin/perl
+
+use Getopt::Long;
+
+GetOptions( 'map=s'   => \%mapping ) || die "Wrong options\n";
+
+for $file (@ARGV) {
+
+        open(FILE, "$file") || die "File not found: $file\n";
+
+        $indir = 0;
+
+        while (<FILE>) {
+
+                if (/\<H1\>\<A NAME=\".*\" HREF=\".*\"\>(.*)\<\/A\>\<\/H1\>/) {
+                        $index = $mapping{$1};
+#                        print "Index: $1 => $index\n";
+                } elsif (/\<DIR\>/) {
+                        $indir = 1;
+                } elsif (/\<\/DIR>/) {
+                        $indir = 0;
+                } elsif ($indir) {
+                        if (/\<LI\>\<A HREF=\"([^\"]*)\"\>([^<]*)\<\/A\>/) {
+                                unless ($lastindex eq $index) {
+                                        if ($lastindex) {
+                                                print "</$lastindex>\n";
+                                        }
+                                        print "<$index>\n";
+                                        $lastindex = $index;
+                                }
+                                $name = dehtml($2);
+                                $url = $1;
+                                print STDOUT "<entry name=\"$name\" url=\"$url\"/>\n";
+                        }
+                }
+        }
+
+        close(FILE);
+}
+
+if ($lastindex) {
+        print "</$lastindex>\n";
+}
+
+sub dehtml
+{
+        my ( $str ) = @_;
+
+        $str =~ s/\<CODE\>//g;
+        $str =~ s/\<\/CODE\>//g;
+        $str =~ s/\<TT\>//g;
+        $str =~ s/\<\/TT\>//g;
+
+        return $str;
+}
+
+# Local Variables:
+# mode: perl
+# fill-column: 120
+# End:
diff --git a/doc/tools/index.xsl b/doc/tools/index.xsl
new file mode 100644
index 00000000..8d3d0a52
--- /dev/null
+++ b/doc/tools/index.xsl
@@ -0,0 +1,34 @@
+<?xml version="1.0"?>
+<xsl:stylesheet version="1.0"
+                xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:output omit-xml-declaration="yes"/>
+
+<xsl:template match="/"><xsl:apply-templates/></xsl:template>
+
+<xsl:template match="text()|@*"></xsl:template>
+
+<xsl:template match="chapter">
+  <xsl:variable name="url" select="@id"/>
+  <xsl:apply-templates/>   
+</xsl:template>  
+
+<xsl:template match="chapter/section[position()!=1]">
+  <xsl:variable name="url" select="@id"/>
+  <xsl:apply-templates/>   
+</xsl:template>  
+
+<xsl:template match="indexterm">
+  <xsl:choose>
+    <xsl:when test="./secondary and ./tertiary">
+    <entry name="{primary}, {secondary}, {tertiary}" url="{$url}.html"/>
+    </xsl:when>
+    <xsl:when test="./secondary">
+    <entry name="{primary}, {secondary}" url="{$url}.html"/>
+    </xsl:when>
+    <xsl:otherwise>
+    <entry name="{primary}" url="{$url}.html"/>
+    </xsl:otherwise>
+  </xsl:choose>
+</xsl:template>
+
+</xsl:stylesheet>
diff --git a/doc/tools/toc-docbook b/doc/tools/toc-docbook
new file mode 100644
index 00000000..6d16f9b3
--- /dev/null
+++ b/doc/tools/toc-docbook
@@ -0,0 +1,71 @@
+#!/usr/bin/perl
+
+# Copyright (C) 2001 by Claudiu Costin
+# <claudiuc@work.ro>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+use Getopt::Long;
+
+my $prefix = '';
+my $depth = 1;
+GetOptions( 'prefix=s' => \$prefix,
+            'depth=i' => \$depth ) || die "Wrong options\n";
+
+$initialdepth = $depth;
+$b3=$b2=$b1="";
+$in_processing=0;
+while (<>) {
+    chop;
+
+    if (/Table of Contents<\/B/) {
+        $in_processing=1;
+        next;
+    }
+    last if (/List of Tables/);
+    next if (!$in_processing);
+
+    if (/HREF=\"(.+)\"/) {
+        $url = $1;
+    }
+    if (/>(.+)<\/A/) {
+        $name=$1;
+        $name =~ s/\"/&quote;/g;
+        $name =~ s/&#8212;/-/g;
+        $name =~ s/^\s*-?\s*//g;
+        $name =~ s/\.$//g;
+#        print "NAME $name\n";
+    }
+
+    if ($b3 =~ /><DL/i) {
+	$depth++;
+        $b3=$b2;
+        $b2=$b1;
+	$b1=$_;
+	next;
+    }
+    if ($b3 =~ /><\/DL/i) {
+	$depth--;
+	print "  "x($depth-1) . "</tocsect${depth}>\n" if ($depth != $initialdepth-1);
+        $b3=$b2;
+        $b2=$b1;
+	$b1=$_;
+	next;
+    }
+
+    if ($b3 =~ />.*<\/DT/i && $name ne "" && $url ne "") {
+	if ($b1 =~ /><DL/i) {
+	    print "  "x($depth-1) . "<tocsect${depth} name=\"$name\" url=\"$url\">\n";
+        } else {
+	    print "  "x($depth-1) . "<tocsect${depth} name=\"$name\" url=\"$url\"/>\n";
+        }
+    }
+
+    # a simulated delay line with 6 cells
+    $b3=$b2;
+    $b2=$b1;
+    $b1=$_;
+}
diff --git a/doc/tools/toc-gsdoc b/doc/tools/toc-gsdoc
new file mode 100644
index 00000000..69785d91
--- /dev/null
+++ b/doc/tools/toc-gsdoc
@@ -0,0 +1,24 @@
+#!/usr/bin/perl
+
+use Getopt::Long;
+
+my $prefix = '';
+GetOptions( 'title=s'  => \$title,
+            'main=s'   => \$main ) || die "Wrong options\n";
+
+$file = $ARGV[0];
+open(FILE, "$file") || die "File not found: $file\n";
+
+print "<tocsect1 name=\"$title\" url=\"$main.html\">\n";
+
+while (<FILE>) {
+
+      if (/\<item\>\<uref url=\"(.+)\.html\"\>(.+)\<\/uref\>\<\/item\>/) {
+            $name = $1;
+            $url = "$1.html";
+            print "  <tocsect2 name=\"$name\" url=\"$url\"/>\n";
+      }
+
+}
+
+print "</tocsect1>\n";
diff --git a/doc/tools/toc-python b/doc/tools/toc-python
new file mode 100644
index 00000000..c91cdcf2
--- /dev/null
+++ b/doc/tools/toc-python
@@ -0,0 +1,57 @@
+#!/usr/bin/perl
+
+use Getopt::Long;
+
+my $prefix = '';
+GetOptions( 'prefix=s' => \$prefix,
+            'title=s'  => \$title,
+            'main=s'   => \$main ) || die "Wrong options\n";
+
+$file = $ARGV[0];
+open(FILE, "$file") || die "File not found: $file\n";
+
+$prevdepth = 1;
+$depth = 1;
+print "<tocsect${depth} name=\"$title\" url=\"$main.html\"";
+
+while (<FILE>) {
+
+      if (/^\s*href/ && !/.*\<\/A\>$/i) {
+              chop;
+              $_ = $_ . <FILE>;
+      }
+      if (/\<UL\>/i) {
+              $depth++;
+      } elsif (/\<\/UL\>/i) {
+              print "/" if ($prevdepth == $depth);
+              $depth--;
+              print ">\n</tocsect${depth}";
+      } elsif (/^\s*href=\"([^\"]+)\"\>(.+)\<\/A\>$/i) {
+              $url = "$prefix/$1";
+              $name = dehtml($2);
+              $name =~ s/\s+/ /g;
+              print "/" if ($prevdepth == $depth);
+              print ">\n<tocsect${depth} name=\"$name\" url=\"$url\"";
+              $prevdepth = $depth;
+      }
+}
+
+print ">\n";
+close(FILE);
+
+sub dehtml
+{
+        my ( $str ) = @_;
+
+        $str =~ s/\<(tt|b) class=\"([^\"]*)\"\>//g;
+        $str =~ s/\<\/(tt|b)\>//g;
+        $str =~ s/\<i\>//g;
+        $str =~ s/\<\/i\>//g;
+
+        return $str;
+}
+
+# Local Variables:
+# mode: perl
+# fill-column: 120
+# End:
diff --git a/doc/tools/toc-texi b/doc/tools/toc-texi
new file mode 100755
index 00000000..2be48fa6
--- /dev/null
+++ b/doc/tools/toc-texi
@@ -0,0 +1,47 @@
+#!/usr/bin/perl
+
+# Copyright (C) 2001 by Claudiu Costin
+# <claudiuc@work.ro>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+
+$depth=0;
+$buffer="";
+
+while (<>) {
+    chop;
+
+    if ($buffer =~ /<ul>/i) {
+	$depth++;
+	$buffer = $_;
+	next;
+    }
+    if ($buffer =~ /<\/ul>/i) {
+	$depth--;
+	print "  "x($depth-1) . "</tocsect${depth}>\n" if ($depth != 0);
+	$buffer = $_;
+	next;
+    }
+
+    if ($buffer =~ /<li>/i) {
+	$buffer =~ /HREF=\"([^\"]+)\"/;
+	$url=$1;
+	$buffer =~ /\">(.+)<\/A>/;
+	$text=$1;
+	$text =~ s/<tt>//gi;
+	$text =~ s/<\/tt>//gi;
+	$text =~ s/<CODE>//gi;
+	$text =~ s/<\/CODE>//gi;
+	$text =~ s/<BR>//gi;
+	if (/<ul>/i) {
+	    print "  "x($depth-1) . "<tocsect${depth} name=\"$text\" url=\"$url\">\n";
+        } else {
+	    print "  "x($depth-1) . "<tocsect${depth} name=\"$text\" url=\"$url\"/>\n";
+        }
+    }
+    # a simulated delay line with one cell
+    $buffer = $_;
+}