<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE book PUBLIC "-//OASIS//DTD DocBook XML V4.1.2//EN" "http://www.oasis-open.org/docbook/xml/4.1.2/docbookx.dtd" [
<!ENTITY mdash "&#38;#x2014;">
<!ENTITY hellip "&#x2026;">
<!ENTITY introduction SYSTEM "introduction.xml">
<!ENTITY interface SYSTEM "interface.xml">
<!ENTITY fileoperations SYSTEM "fileoperations.xml">
<!ENTITY projects SYSTEM "projects.xml">
<!ENTITY build SYSTEM "build.xml">
<!ENTITY debugger SYSTEM "debugger.xml">
<!ENTITY glade SYSTEM "glade.xml">
<!ENTITY preferences SYSTEM "preferences.xml">
<!ENTITY tools SYSTEM "tools.xml">
<!ENTITY authors SYSTEM "authors.xml">
<!ENTITY license SYSTEM "license.xml">
<!ENTITY appversion "2.0.2">
<!ENTITY manrevision "2.7">
<!ENTITY date "April 2006">
<!ENTITY app "anjuta">
]>
<!-- =============Document Header ============================= -->
<book id="index" lang="de">
 <bookinfo>
  <title>Anjuta IDE-Handbuch</title>
  <edition>v1.0.0</edition>
  <abstract role="description">
  	<para>Handbuch für die Anjuta-IDE</para>
  </abstract>
  
	<author role="maintainer">
		<firstname>Naba</firstname>
		<surname>Kumar</surname>
	</author>
	<author>
		<firstname>Andy</firstname>
		<surname>Piper</surname>
	</author>
	<author>
		<firstname>Biswapesh</firstname>
		<surname>Chattopadhyayr</surname>
	</author>
	<author>
		<firstname>Johannes</firstname>
		<surname>Schmid</surname>
	</author>

  <copyright>
   <year>2001-2002</year>
   <year>2006-2008</year>
   <holder>Naba Kumar, Andy Piper, Biswapesh Chattopadhyay</holder>
   <holder>Johannes Schmid</holder>
  </copyright><copyright><year>2009, 2010</year><holder>Mario Blättermann (mariobl@gnome.org)</holder></copyright><copyright><year>2010</year><holder>Jonas Rebmann (jonas.rebmann@googlemail.com)</holder></copyright><copyright><year>2010</year><holder>Christian Kirbach (Christian.Kirbach@googlemail.com)</holder></copyright>
  
  <legalnotice>
   <para>Das vorliegende Dokument kann gemäß den Bedingungen der GNU Free Documentation License (GFDL), Version 1.1 oder jeder späteren, von der Free Software Foundation veröffentlichten Version ohne unveränderbare Abschnitte sowie ohne Texte auf dem vorderen und hinteren Buchdeckel kopiert, verteilt und/oder modifiziert werden. Eine Kopie der GFDL finden Sie unter diesem <ulink type="help" url="ghelp:fdl">Link</ulink>.</para>
   <para>Bei vielen der von Firmen zur Unterscheidung ihrer Produkte und Dienstleistungen verwendeten Namen handelt es sich um Marken. An den Stellen, an denen derartige Namen in einer GNOME-Dokumentation vorkommen und wenn die Mitglieder des GNOME-Dokumentationsprojekts über diese Marken informiert wurden, sind die Namen in Großbuchstaben oder mit großen Anfangsbuchstaben geschrieben.</para>
  </legalnotice>

	<revhistory>
		<revision>
		  <revnumber>Anjuta-Handbuch 2.1.0</revnumber>
		  <date>2007</date>
		  <revdescription>
			 <para role="author">Johannes Schmid<email>jhs@gnome.org</email></para>
			 <para role="publisher">Anjuta-Team</para>
		  </revdescription>
		</revision>
	</revhistory>
		
 </bookinfo>
 <!-- Document Body -->
 <!-- Introduction -->
  <!-- ============= Introduction ============================== -->
 <chapter id="introduction">
  <title>Einführung</title>
  <para><application>Anjuta</application> ist eine vielseitige integrierte Entwicklungsumgebung (IDE) für den GNOME-Desktop. Sie stellt eine Vielzahl an erweiterten Entwicklungsmethoden wie Projektverwaltung, Programmassistenten, einen interaktiven Debugger, den Oberflächengestalter Glade, die API-Hilfe Devhelp, den Speicher-Profiler Valgrind, den Leistungs-Profiler gprof, einen Klassengenerator, einen mächtigen Quelltexteditor, Quellcode-Browser und mehr zur Verfügung.</para>

  <para>Anjuta DevStudio wurde entwickelt, um einfach aber doch mächtig genug zu sein, um allen Bedürfnissen eines Programmierers nachzukommen. Wir haben Anjuta im Verlauf der Entwicklung viele neue Funktionen hinzugefügt. Unser Fokus liegt auf der gleichzeitigen Bereitstellung von Funktionalität und Nutzbarkeit und darauf, Software-Entwicklung genießbar zu machen, ohne Ihre Sinne zu überlasten. Wir planen Anjuta weiterhin zu verbessern und stabiler zu machen, um Ihnen das bestmögliche Entwicklungserlebnis zu vermitteln. Wir hoffen, Sie haben haben eine gute Zeit mit Anjuta. Falls nicht, so helfen Sie uns bitte es besser zu machen, und melden Sie Fehler und Verbesserungsvorschläge.</para>
  <para>Im folgenden Bildschirmfoto sehen Sie einiges von dem, was Ihnen in Anjuta begegnen werden.</para>

  <para>
  <figure id="anjuta-scrshot">
   <title>Anjuta in Aktion</title>
   <screenshot>
   <screeninfo>Anjuta in Aktion</screeninfo>
   <graphic format="PNG" fileref="figures/anjuta-in-action.png" srccredit="jhs"/>
   </screenshot>
   </figure>
  </para>

  <para>Anjuta hat ein flexibles und fortgeschrittenes Docking-System, das es Ihnen erlaubt alle Ansichten so anzuordnen, wie Sie es wollen. Sie können die Ansichten ziehen und ablegen, um das Layout neu anzuordnen. Die Layouts sind den Projekten zugeordnet, damit verschiedene Layouts für verschiedene Projekte gepflegt werden können. Alle Ansichten können minimiert werden, um die Übersicht zu verbessern. Minimierte Ansichten erscheinen als Symbole am linken Rand des Hauptfensters. Sie können alle Menüaktionen konfigurieren, indem Sie entweder tippen, während der Mauszeiger über einem Menüpunkt ist (der übliche Weg unter GNOME), oder direkt durch einen Dialog zur Zuordnung der Tastenkombinationen.</para>

  <para>Bitte melden sie alle Probleme, auf die sie bei der Nutzung von <application>Anjuta</application> stoßen - das hilft dabei, die Software zu verbessern als auch der Open-Source-Gemeinschaft.</para>
 </chapter>

 <!-- Getting Familiar with Anjuta -->
 <chapter id="familiar">
  <title>Erste Schritte mit Anjuta</title>
 <!-- ============= Getting Familiar: Menus  ============-->
  <sect1 id="menu-and-shortcuts">
   <title>Menüs und Tastenkombinationen</title>
   <para>Am oberen Rand des <application>Anjuta</application>-Hauptfensters ist die Menüleiste. Durch sie ist nahezu die gesamte Funktionalität von Anjuta durch Menüpunkte erreichbar. Aktionen wurden je nach Typ eingeteilt. Dateioperationen beispielsweise finden Sie im <guisubmenu>Datei</guisubmenu>-Menü.</para>
	
    <figure id="menubar">
      <title>Menüleiste</title>
	  <screenshot>
      <screeninfo>Anjuta-Menüleiste</screeninfo>
       <graphic fileref="figures/menubar.png" format="PNG" srccredit="jhs"/>
      </screenshot>
    </figure>
    
    <figure id="file-menu">
      <title>Menü »Datei«</title>
      <screenshot>
      <screeninfo>Menü »Datei«</screeninfo>
       <graphic fileref="figures/file_menu.png" format="PNG" srccredit="jhs"/>
      </screenshot>
    </figure>
	
   <para>Tastenkombinationen sind für viele Menüpunkte verfügbar. Alle Tastenkombinationen werden neben dem zugeordneten Menüpunkt angezeigt. Einige weitere hilfreiche Tastenkombinationen sind hier aufgeführt.</para>
	
   <para>
    <itemizedlist>
     <listitem>
      <para><emphasis>Editorseite wechseln:</emphasis><keycombo><keycap>Strg</keycap><keycap>Alt</keycap><keycap>Bild ↑</keycap></keycombo> (vorwärts) und <keycombo><keycap>Strg</keycap><keycap>Alt</keycap><keycap>Bild ↓</keycap></keycombo> (rückwärts). Sie können auch Seiten wechseln, indem Sie mit der rechten Maustaste auf die Karteireiter klicken und einen Dateinamen aus dem Einblendmenü wählen (dies ist nützlich, wenn alle Karteireiter nicht sofort sichtbar sind). Einige Arbeitsumgebungen haben eventuell diese Tastenkombinationen zugewiesen. In diesem Fall müssen Sie diese (nicht in Anjuta) anders belegen, wenn Sie sie in Anjuta verwenden möchten.</para>
     </listitem>
     <listitem>
      <para><emphasis>Kontexthilfe:</emphasis><keycombo><keycap>Umschalt</keycap><keycap>F1</keycap></keycombo>. Bewegen Sie die Eingabemarke über das Wort (z.B. ein Funktionsname), für das Sie die API-Hilfe aufrufen möchten, und verwenden Sie diese Tastenkombination. Die Kontexthilfe funktioniert nur, wenn <application>Devhelp</application> installiert ist; Andernfalls sind das Menü Kontexthilfe und der Knopf in der Werkzeugleiste deaktiviert. Sie können Devhelp von der <application>Devhelp</application>-Webseite beziehen. Sie müssen dann auch die zugehörigen <application>Devhelp</application>-Bücher installieren.</para>
     </listitem>
     <listitem>
      <para><emphasis>Automatische Vervollständigung:</emphasis><keycombo><keycap>Strg</keycap><keycap>Eingabetaste</keycap></keycombo>. Positionieren Sie die Eingabemarke genau hinter ein unvollständiges Wort und verwenden Sie diese Tastenkombination. Eine Liste mit möglichen Vervollständigungen wird darauf hin eingeblendet. Sie können in der Liste blättern, um die gewünschte Ergänzung zu suchen und auszuwählen.</para>
     </listitem>
     <listitem>
      <para><emphasis>Weitere Tastenkombinationen:</emphasis> Schauen Sie nach Tastenkombinationen, die rechts neben Menüeinträgen dargestellt sind. Tastenkombinationen können auch wie im Hinweis unten erklärt geändert werden.</para>
     </listitem>
    </itemizedlist>
   <tip>
   <title>Tastenkürzel anpassen</title>
   <para>Tastenkombinationen können unter <menuchoice><guisubmenu>Bearbeiten</guisubmenu><guimenuitem>Einstellungen</guimenuitem></menuchoice> im Karteireiter <interface>Tastenkombinationen</interface> geändert werden.</para>
   </tip>
   </para>
  </sect1>

<!-- ============= Getting Familiar: Main window  ============-->
  <sect1 id="main-win">
   <title>Hauptfenster</title>
   <para>Das Hauptfenster enthält mehrere Ansichtsfenster, die sich durch Ziehen ihrer jeweiligen Titelleiste neu anordnen lassen. Sie können auch durch den Knopf links auf ihrer Titelleiste minimiert werden.</para>

   <para>
    <orderedlist>
     <listitem>
      <para>Das <interface>Dokumentenfenster</interface> hat jeweils nur ein Dokument aktiv (wenn Dateien geöffnet sind). Alle Dateibefehle wirken sich auf das aktive Dokument aus. Sie können zu jedem geöffneten Dokument durch einen Mausklick auf den jeweiligen Karteireiter wechseln. Sie können auch das gleiche tun, in dem Sie mit der rechten Maustaste auf einen beliebigen Karteireiter klicken und das gewünschte Dokument aus dem erscheinenden Einblendfenster wählen. Dies ist besonders dann nützlich, wenn viele Dateien geöffnet sind, aber nicht alle zugehörigen Dateireiter sichtbar sind.</para>
	 </listitem>
     <listitem>
      <para>Das <interface>Projektfenster</interface> enthält den Baum der Projektdateien, wenn ein Projekt geöffnet ist. Andernfalls ist das <interface>Projektfenster</interface> normalerweise verborgen. Ein Doppelklick auf ein beliebiges Objekt im  <interface>Projektfenster</interface> öffnet diese Datei.</para>
     </listitem>
      <listitem>
      <para>Das <interface>Dateifenster</interface> enthält einen Dateibaum. Falls kein Projekt geöffnet ist, so zeigt der Dateibaum normalerweise den obersten Ordner des Dateisystems. Dies kann aber in den Einstellungen angepasst werden. Wenn ein Projekt geöffnet ist, so werden im Fenster alle Dateien des Projekts angezeigt. Ein Doppelklick auf eine Datei öffnet diese mit der zugehörigen Anwendung, so wie es in den GNOME MIME-Einstellungen festgelegt ist. Ein Rechtsklick öffnet ein Kontextmenü, das Ihnen weitere Möglichkeiten zum Öffnen der Datei anbietet.</para>
     </listitem>
      <listitem>
      <para>Das <interface>Symbolfenster</interface> zeigt einen Baum der verfügbaren Symbole im Projekt, der durch Verarbeiten der  <application>ctags</application> gebildet wird. Ein Doppelklick öffnet ein Editorfenster mit der jeweiligen Datei in der entsprechenden Zeile.</para>
      <para>Es gibt auch einen <interface>Suchreiter</interface> im Symbolfenster, wo Sie nach Symbolen suchen können.</para>
     </listitem>
     <listitem>
      <para>Das <interface>Nachrichtenfenster</interface> stellt alle Ausgaben dar (sowohl <filename>stdout</filename> als auch <filename>stderr</filename>) dar, wenn ein externer Befehl ausgeführt wird. Das <interface>Nachrichtenfenster</interface> ist normalerweise verborgen, wird aber bei Ausführung externer Befehle eingeblendet, wie z.B. beim Kompilieren einer Datei oder des Projekts, Fehleranalyse, Suche und vielen weiteren Vorgängen. <application>Anjuta</application> fügt auch bei Bedarf eigene Nachrichten hier ein.</para>
      <para>Die Farbverwendung bei der Darstellung ist von Bedeutung. Nachrichten in der voreingestellten Vordergrundfarbe (normalerweise schwarz) sind normale Nachrichten. Orange Nachrichten sind Warnungen, und rote repräsentieren Fehler. Warnungen und Fehlernachrichten sind <emphasis>verknüpft</emphasis>: Ein Doppelklick auf eine solche Nachricht öffnet die entsprechende Datei in der jeweiligen Zeilennummer.</para>
      <para>Wenn Sie zum Beispiel eine Datei kompilieren, die Fehler enthält, so werden rote Nachrichten die Probleme erläutern und auf die Fehlerstelle hinweisen. Ein Doppelklick auf eine solche Nachricht öffnet die Datei und hebt die Zeile mit dem Fehler hervor.</para>
     </listitem>
     <listitem>
      <para>Das <interface>Terminalfenster</interface> ist ein Terminal-Emulator, in dem Sie wie im GNOME-Terminal Befehle eingeben können.</para>
     </listitem>
    </orderedlist>
   </para>
   <note>
   <title>Sitzungsverwaltung</title>
   <para>Alle Einstellungen, einschließlich Fenstergrößen und -positionen, werden beim Beenden von <application>Anjuta</application> gespeichert. Eine Sitzungsverwaltung befindet sich noch in der Entwicklung, so dass Sie <application>Anjuta</application> nicht mit ungespeicherten Dokumenten beenden sollten. <application>Anjuta</application> wird Sie warnen, wenn Sie beenden wollen, während noch ungespeicherte Dokumente geöffnet sind.</para>
   </note>
  </sect1>
 </chapter>

 <!-- File operations -->
  <chapter id="file-operations">
  <title>Dateioperationen</title>
  
  <!-- ============= File operations: Creating a new file === -->
  <sect1 id="creating-files">
   <title>Anlegen einer neuen Datei und Einfügen von Text</title>
    <sect2 id="new-file">
    <title>Erstellen einer neuen Datei</title>
     <para>
     To create a new file, choose <menuchoice><guisubmenu>File</guisubmenu>
     <guimenuitem>New</guimenuitem></menuchoice> from the menu bar, or click on the 
     <guibutton>New File</guibutton> button on the main toolbar. A new page will 
     appear in the editor (or a new window if the parent document is windowed). 
     New documents will be named <filename>newfile#1</filename>, 
     <filename>newfile#2</filename>, <filename>newfile#3</filename> and 
     so on. 
     </para>
	   <important>
	   <title>Datei speichern</title>
	   <para>Sie sollten neue Dokumente so bald wie möglich speichern, um Datenverluste in Folge von Abstürzen zu vermeiden.</para>
	   </important>
    </sect2>
    <sect2 id="file-wizard">
    <title>Datei-Assistent</title>
     <para>Ein Assistent kann auch dazu verwendet werden eine neue Datei zu erstellen. Wählen Sie dazu <menuchoice><guisubmenu>Datei</guisubmenu><guisubmenu>Neu</guisubmenu><guimenuitem>Datei</guimenuitem></menuchoice> aus der Menüleiste. Der Dialog »Neue Datei« wird geöffnet. Wählen Sie den Dateityp und geben Sie den Dateinamen ein. Die Endung wird automatisch hinzugefügt. Sie können Lizenzinformationen und einen Dateikopf hinzufügen. In Falle einer C/C++-Kopfdatei können sie auch eine Kopfvorlage hinzufügen. Klicken Sie <guibutton>OK</guibutton>, um die Erstellung zu bestätigen. <figure id="new-file-wizard">
       <title>Erstellungsassistent für Dateien</title>
       <screenshot>
        <screeninfo>Der »Datei öffnen«-Dialog</screeninfo>
        <graphic fileref="figures/new_file_wizard.png" format="PNG" srccredit="jnoel"/>
       </screenshot>
      </figure></para>
     <para><application>Anjuta</application> erstellt gelegentlich während einiger Vorgänge neue Dateifenster. Zum Beispiel erzeugen einige Subversion-Vorgänge wie <command>Diff</command> und <command>Protokoll ansehen</command> neue Dateifenster und geben die Ausgaben dort aus. Sie können bei Bedarf den Inhalt dieser Fenster in Dateien abspeichern.</para>
     </sect2>
     <sect2 id="inserting-macros">
      <title>Einfügen von Makros</title>
       <para>Sie können <emphasis>Makros</emphasis> verwenden, um schnell wiederholende Textpassagen zu bearbeiten.</para>
       <important>
       <para>Das Makro-Plugin muss aktiviert sein.</para>
       </important>
      <sect3 id="inserting">
       <title>Einfügen</title>
       <para>Es gibt zwei Arten Makros: Anjuta-Makros und Benutzer-Makros (sie werden als »Meine Makros« angezeigt). Anjuta-Makros können nicht verändert werden, aber Sie können Benutzer-Makros erstellen und bearbeiten.</para>
       <para>Zum Einfügen eines Makros positionieren Sie die Eingabemarke an die gewünschte Stelle. Wählen Sie  <menuchoice><guisubmenu>Bearbeiten</guisubmenu><guisubmenu>Makros</guisubmenu><guimenuitem>Makros …</guimenuitem></menuchoice>. Es wird ein Dialog geöffnet. Wählen Sie das gewünschte Makro aus der Liste. Das Ergebnis der Makro-Umsetzung wird im Fenster dargestellt und eine Zusammenfassung wird im Dialogfenster angezeigt. Wählen Sie <guibutton>Einfügen</guibutton>. Der umgesetzte Makrotext wird an der aktuellen Position der Eingabemarke eingefügt.</para>
       <para>Eine andere Möglichkeit Makros einzufügen ist <menuchoice><guisubmenu>Bearbeiten</guisubmenu><guisubmenu>Makros</guisubmenu><guimenuitem>Makro einfügen …</guimenuitem></menuchoice> auszuwählen, und dann die gewünschte Makro-Tastenkombination zu drücken. <figure id="display-macro">
         <title>Makro</title>
          <screenshot>
           <screeninfo>Der Makro-Dialog</screeninfo>
           <graphic fileref="figures/display_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
        </figure></para>
       </sect3>
       <sect3 id="defining-macro">
        <title>Definieren von Makros</title>
        <para>Wählen Sie im Fenster »Makro einfügen« <guibutton>Hinzufügen</guibutton> oder wählen Sie <menuchoice><guisubmenu>Bearbeiten</guisubmenu><guisubmenu>Makros</guisubmenu><guimenuitem>Makro hinzufügen … </guimenuitem></menuchoice>. Daraufhin öffnet sich das Fenster »Hinzufügen/Bearbeiten«. Geben Sie den Namen des Makros ein, wählen oder definieren Sie eine Kategorie und legen Sie eine Tastenkombination fest. Bearbeiten Sie dann Text relativ zu Ihrem Makro. Das Zeichen » | « deutet die Position der Eingabemarke nach Ausführung des Makros an. Klicken Sie auf <guibutton>OK</guibutton>. Das Makro wird zur Liste hinzugefügt.</para>
        <para>Sie können auch ein Makro löschen, indem Sie es in der Liste auswählen und <guibutton>Entfernen</guibutton> klicken. Dies ist natürlich nur mit Benutzer-Makros (»Meine Makros«) möglich.</para>
        <para>Auf ähnliche Weise können Sie ein Makro bearbeiten und ändern, indem Sie es in der Liste auswählen und <guibutton>Bearbeiten</guibutton> wählen. <figure id="add-edit-macro">
          <title>Makro hinzufügen/bearbeiten</title>
          <screenshot>
           <screeninfo>Dialog zum Hinzufügen/Bearbeiten</screeninfo>
           <graphic fileref="figures/add_edit_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
         </figure></para>
       </sect3>
       <sect3 id="macro-keyword">
        <title>Makro-Schlüsselwörter</title>
        <para>Makro-Schlüsselwörter stehen zur Verfügung. Sie können in Makro-Definitionen eingebunden werden. Makro-Schlüsselwörter beginnen und enden jeweils mit dem Zeichen » @ «.</para>
        <para>Verfügbare Makro-Schlüsselwörter sind @DATE_TIME@, @DATE_YMD@, @DATE_Y@, @USER_NAME@, @FILE_NAME@, @FILE_NAME_UP@, @FILE_NAME_UP_PREFIX@, @EMAIL@, @TABSIZE@, @INDENTSIZE@, und @USETABS@. <figure id="keyword-macro">
         <title>Schlüsselwort-Makro</title>
          <screenshot>
           <screeninfo>Das Schlüsselwort-Makro</screeninfo>
           <graphic fileref="figures/keyword_macro.png" format="PNG" srccredit="jnoel"/>
          </screenshot>
         </figure></para>
      </sect3>
     </sect2>
  </sect1>

 <!-- ============= File operations: Opening and saving files === -->
  <sect1 id="open-save-files">
   <title>Öffnen und Speichern von Dateien</title>
   <para>
    <orderedlist>
     <listitem>
      <para><emphasis>Eine Datei öffnen:</emphasis> Um eine bestehende Datei zu öffnen, wählen Sie <menuchoice><guisubmenu>Datei</guisubmenu><guimenuitem>Öffnen</guimenuitem></menuchoice> aus der Menüleiste und klicken Sie auf den Knopf <guibutton>Öffnen</guibutton>, oder verwenden sie die  Tastenkombination <keycombo><keycap>Strg</keycap><keycap>O</keycap></keycombo>. Dies öffnet den Dialog <interface>Datei öffnen</interface>. <figure id="open-file">
        <title>Dialog zum Öffnen von Dateien</title>
        <screenshot>
		<screeninfo>Der »Datei öffnen«-Dialog</screeninfo>
         <graphic fileref="figures/open_file.png" format="PNG" srccredit="jnoel"/>
        </screenshot>
       </figure> Geben sie den Namen der Datei ein, die Sie öffnen wollen, oder wählen Sie sie aus. Klicken sie dann auf <guibutton>Öffnen</guibutton>. Um mehrere Dateien auf einmal zu öffnen können Sie mehrere nacheinander auswählen, indem Sie <keycap>Strg</keycap> gedrückt halten; Dann klicken sie auf <guibutton>Öffnen</guibutton>. Wenn Sie Ihre Meinung geändert haben, können sie <guibutton>Abbrechen</guibutton> drücken, um den Dialog zu schließen, ohne eine Datei zu öffnen.</para>
	  <para>
	   <figure id="open-file-multiple">
        <title>Dialog zum Öffnen mehrerer Dateien</title>
        <screenshot>
		<screeninfo>Der Dialog »Datei öffnen« im Modus für mehrere Dateien</screeninfo>
         <graphic fileref="figures/open_file_multiple.png" format="PNG" srccredit="jnoel"/>
        </screenshot>
       </figure>
	  </para>
	  <para>Sie können die Einstellung <emphasis>Verborgene Dateien zeigen</emphasis> im Einblendfenster aktivieren, das nach einem Rechtsklick im Dialog zum Öffnen von Dateien erscheint. Mit dieser Einstellung werden verborgene Dateien (ihr Name beginnt mit ».«) in der Dateiliste sichtbar. Nehmen Sie diese Einstellung zurück, um verborgene Dateien nicht anzuzeigen. Der Dialog zum Öffnen von Dateien besitzt auch einen eingebauten Typenfilter. Wählen Sie den entsprechenden Dateitypenfilter im Dialog, und die Dateiliste wird auf Dateien des gewählten Typs beschränkt.</para>
     </listitem>
     
     <listitem>
      <para><emphasis>Speichern einer Datei:</emphasis> Wählen Sie zum Speichern einer Datei <menuchoice><guisubmenu>Datei</guisubmenu><guimenuitem>Speichern</guimenuitem></menuchoice> aus der Menüzeile und klicken auf den Knopf  <guibutton>Speichern</guibutton> in der Werkzeugleiste, oder drücken <keycombo><keycap>Strg</keycap><keycap>S</keycap></keycombo>. Falls die Datei neu ist, wird der Dialog <interface>Speichern unter</interface> geöffnet. Geben Sie einen Dateinamen ein und klicken Sie auf <guibutton>Speichern</guibutton>, um die neue Datei unter dem angegebenen Namen abzuspeichern. <screenshot>
	    <screeninfo>Als Datei speichern</screeninfo>
            <graphic fileref="figures/save_as_file.png" format="PNG" srccredit="jnoel"/>
           </screenshot></para>
	   <note>
	   <title>Automatisches Speichern einer Datei</title>
		<para>Wenn automatisches Speichern aktiviert ist, so speichert Anjuta nicht automatisch neue Dateien. Sie müssen diese zunächst selbst speichern. Das gleiche gilt für die Einstellung <guimenuitem>Alle speichern</guimenuitem>: Anjuta speichert nicht neue Dateien, solange Sie diese noch nicht selbst gespeichert haben. <emphasis>Sie müssen zuerst eine Datei selbst speichern, bevor automatisches Speichern oder <guimenuitem>Alle speichern</guimenuitem> mit diesen funktioniert.</emphasis></para>
	   </note>
     </listitem>

     <listitem>
      <para><emphasis>Eine Datei unter anderem Namen speichern:</emphasis> Sie können explizit eine Datei unter einem neuen Namen speichern. Wählen Sie dazu <menuchoice><guisubmenu>Datei</guisubmenu><guimenuitem>Speichern unter</guimenuitem></menuchoice> aus der Menüzeile. Der Dialog <interface>Datei speichern unter</interface> wird geöffnet und fragt Sie nach dem neuen Dateinamen. Geben Sie den Namen ein und klicken Sie auf <guibutton>Speichern</guibutton>.</para>
      <note>
       <title>Datei beim Speichern überschreiben</title>
       <para>Wenn Sie <guimenuitem>Speichern unter</guimenuitem> mit einer bestehenden Datei verwenden, so wird das Original nicht gelöscht. Es verbleibt seit dem letzten Speichern unverändert. Falls eine Datei mit dem neuen Dateinamen bereits besteht, dann wird ein Bestätigungsdialog angezeigt, um sicherzustellen, dass Sie sie überschreiben wollen. Mit einem Klick auf <guibutton>Ja</guibutton> wird die Datei mit derjenigen überschrieben, die Sie speichern.</para>
      </note>
     </listitem>
     
     <listitem>
      <para><emphasis>Eine Datei schließen:</emphasis> Wählen Sie zum Schließen einer Datei <menuchoice><guisubmenu>Datei</guisubmenu><guimenuitem>Schließen</guimenuitem></menuchoice> aus der Menüzeile, oder klicken Sie auf den Knopf  <guibutton>Schließen</guibutton> in der Werkzeugleiste (Sie können eine Datei auch durch Klick auf das Kreuz (»X«) im Reiter zum Dateinamen schließen.). So wird die aktuelle Datei geschlossen. Falls die Datei neu oder nicht gespeichert ist, so wird <application>Anjuta</application> nachfragen, ob die Datei vor dem Schließen gespeichert werden soll.</para>
     </listitem> 
    </orderedlist>
   </para>
  </sect1>
 
 <!-- ============= File operations: Editing files === -->
  <sect1 id="editing-files">
   <title>Bearbeiten von Dateien</title>
   <para><application>Anjuta</application> verfügt über eine Reihe von Funktionsmerkmalen, die Ihnen beim Bearbeiten von Quelldateien helfen. Die folgenden abschnitte beschreiben, wie einige der interessanten Funktionsmerkmale verwendet werden.</para>
   <sect2 id="editor-margins-sec">
   <title>Editorränder</title>
      <para><emphasis>Editorränder:</emphasis> Editorränder befinden sich links des Editors und werden für einige bestimmte Zwecke verwendet. Es stehen drei Editorränder zur Verfügung: Der <emphasis>Zeilennummernrand</emphasis>, der <emphasis>Markierungsrand</emphasis> und der <emphasis>Rand für Textfaltungen</emphasis>. Per Voreinstellung (das heißt beim ersten Start von <application>Anjuta</application>) ist nur der Rand für Textfaltungen sichtbar. Die anderen beiden können über das Menü <menuchoice><guimenu>Ansicht</guimenu><guisubmenu>Editor</guisubmenu></menuchoice> sichtbar geschaltet werden. <figure id="editor-margins">
        <title>Editorränder</title>
        <screenshot>
         <screeninfo>Die Werkzeugleiste für Beschriftungen</screeninfo>
         <graphic fileref="figures/editor_margins.png" format="PNG" srccredit="naba"/>
        </screenshot>
       </figure></para>
       <para>Der<emphasis>Rand für Zeilennummern</emphasis> ist der größte aller drei Ränder (und etwas dunkler als die anderen) und gibt die Zeilennummern eines Dokumentes an. Der <emphasis>Rand für Zeilennummern</emphasis> kann über den Menüpunkt <menuchoice><guimenu>Ansicht</guimenu><guisubmenu>Editor</guisubmenu><guimenuitem>Rand für Zeilennummern</guimenuitem></menuchoice> angezeigt oder verborgen werden. Ein Linksklick auf den Rand markiert eine ganze Zeile (einschließlich des Zeilenumbruchs, sofern vorhanden). Sie können eine Schriftart für den Zeilennummernrand in den Einstellungen festlegen.</para>
	  <para>Der <emphasis>Markierungsrand</emphasis> kann über den Menüpunkt <menuchoice><guimenu>Ansicht</guimenu><guisubmenu>Editor</guisubmenu><guimenuitem>Markierungsrand</guimenuitem></menuchoice> verborgen und angezeigt werden. Dieser Rand zeigt grafische Symbole zur Markierung einer Zeile. Der Rand kann Markierungen für Lesezeichen (blau und rechteckig), für Haltepunkte (rot und rund) sowie Zeilenangaben enthalten (gelber spitzer Pfeil). Eine Markierung für Lesezeichen deutet eine Zeile mit Lesezeichen an und kann über das Menü <menuchoice><guimenu>Gehe zu</guimenu><guisubmenu>Lesezeichen</guisubmenu><guimenuitem> Lesezeichen an/aus</guimenuitem></menuchoice> ein- und ausgeschaltet werden, sofern sich die Eingabemarke in dieser Zeile befindet. Eine Markierung für Haltepunkte wird bei der Fehlerdiagnose verwendet, um einen Haltepunkt festzulegen (lesen Sie den Abschnitt Fehlerdiagnose für weitere Informationen). Eine Markierung für Zeilennummern gibt die aktuelle Programmposition während der Fehlerdiagnose an.</para>
       <para>Der <emphasis>Textfaltungsrand</emphasis> enthält gegebenenfalls den Faltungsbaum. Ein Klick auf Knoten im Faltungsbaum klappt Code-Blöcke ein oder aus. Es wird ein Unterstrich unter einer eingeklappten Zeile angezeigt, um zu verdeutlichen, dass ein Code-Block unter der Zeile eingeklappt wurde. Lesen Sie für weitere Informationen zum Falten den Abschnitt <emphasis>Textfaltung</emphasis> weiter unten.</para>
       <note>
       <title>Verborgener Markierungsrand</title>
        <para>Falls der Markierungsrand nicht sichtbar ist, zeigt Anjuta Markierungen als Hintergrundfarbe einer Zeile an. Wenn zum Beispiel eine Markierung eines Haltepunkts für eine Zeile gesetzt ist und der Markierungsrand nicht sichtbar ist, so wird diese Zeile mit einem roten Hintergrund dargestellt. Ähnlich wird für ein Lesezeichen und eine Zeilennummernmarkierung die Hintergrundfarbe tiefblau bzw. gelb sein. Wenn Ihnen dies nicht gefällt (eventuell. im Zusammenspiel mit dem aktuell verwendeten Thema), so können Sie den Markierungsrand im Menü <menuchoice><guimenu>Ansicht</guimenu><guisubmenu>Editor</guisubmenu><guimenuitem>Markierungsrand</guimenuitem></menuchoice> einschalten. <figure id="editor-markers">
          <title>Editorränder im Falle unsichtbarer Markierungsränder</title>
          <screenshot>
           <screeninfo>Die Werkzeugleiste für Beschriftungen</screeninfo>
           <graphic fileref="figures/editor_markers.png" format="PNG" srccredit="naba"/>
          </screenshot>
         </figure></para>
       </note>
      </sect2>
      <sect2 id="editor-guides-sec">
      <title>Bearbeitungshilfen</title>
      <para>The editor can be set to display certain document information which is
      normally invisible, including <emphasis>indentation guides</emphasis>, <emphasis>white space</emphasis>
      and <emphasis>line end characters</emphasis>. They can be make
      visible or invisible by toggling the menu items in <menuchoice><guimenu>View</guimenu>
      <guisubmenu>Editor</guisubmenu></menuchoice>. Indentation guides are small dotted lines 
      drawn to connect matching braces in source code. When the cursor is over a
      matching brace, its dotted indentation guide is highlighted to emphasize the indentation level visually.
      </para>
       <figure id="editor-guides">
        <title>Editor mit Bearbeitungshilfen</title>
        <screenshot>
         <screeninfo>Editor mit Bearbeitungshilfen</screeninfo>
         <graphic fileref="figures/editor_guides.png" format="PNG" srccredit="naba"/>
        </screenshot>
      </figure>
    </sect2>
   <sect2 id="highlighting">
   <title>Syntaxhervorhebung</title>
   <para><application>Anjuta</application> kann die Syntax von vielen verschiedenen Sprachen hervorheben. Dies geschieht normalerweise automatisch durch Erkennung der Dateiart anhand der Erweiterung. Falls <application>Anjuta</application> einen Dateityp nicht erkennen kann, dann wird keine Syntaxhervorhebung eingesetzt. Sie können explizit einen Hervorhebungsmodus erzwingen, indem Sie den Stil im Menü <menuchoice><guimenu>Ansicht</guimenu><guisubmenu>Editor</guisubmenu><guisubmenu> Hervorhebungsmodus</guisubmenu></menuchoice> wählen.</para>
    <note>
     <para>Anjuta verwendet eine Eigenschaftendatei mit dem Namen <filename>$prefix/share/anjuta/properties/anjuta.properties</filename>, die das gleiche Format wie eine SciTE-Eigenschaftendatei besitzt, aber nicht alle Eigenschaften verwendet. Der Stil jedes Elements für alle Sprachen ist in der Datei <filename>$prefix/share/anjuta/properties/styles.properties</filename> hinterlegt. Sie verwendet einige gewöhnliche Eigenschaften, die von Anjuta in der Datei <filename>$home/.config/anjuta/scintilla/editor-style.properties</filename> festgelegt sind.</para>
   </note>
   </sect2>
   <sect2 id="codefolding">
    <title>Textfaltung</title>
    <para>Anjuta kann <emphasis>Code-Faltungen</emphasis> für Quelldateien mit in Blöcken strukturierten Sprachen (wie C, C++, Pascal, und Java) anzeigen. Alle Code-Blöcke in Quelldateien können ein- und ausgeklappt werden, indem auf die Faltungspunkte im Rand für Code-Faltung des <interface>Editor</interface>-fensters geklickt wird (normalerweise ein »+/-«- Symbol oder ein Pfeil nach oben/unten). Die Faltungspunkte erscheinen automatisch in Quelldateien, die Code-Blöcke enthalten.</para>
    <para>Code-Faltung ist besonders nützlich beim Bearbeiten von sehr großen Quelldateien mit tausenden Zeilen. Sobald Teile eingeklappt sind, scheint ein Dokument kleiner zu sein, und einfaches Durchsuchen und Bearbeiten werden möglich.</para>
    <note>
     <para>Bitte beachten Sie, dass Code-Faltung und Bearbeitungshilfen nur im Scintilla-Editor verfügbar sind.</para>
	</note>
   </sect2>
   <sect2 id="autoformat">
    <title>Automatische Formatierung von Quelltext</title>
    <para>Anjuta kann C- oder C++-Quelldateien oder Header-Dateien automatisch formatieren (automatisch einrücken). Dies ermöglicht eine gute Übersicht über den Quellcode, verbessert die Lesbarkeit, reduziert die Wahrscheinlichkeit von Syntaxfehlern und spart vor allem Zeit. Zum automatischen Einrücken wählen Sie <menuchoice><guimenu>Bearbeiten</guimenu><guimenuitem>Automatisches Einrücken </guimenuitem></menuchoice> in der Menüzeile. Sie können den Stil der Formatierung in den Einstellungen selbst anpassen.</para>
   </sect2>
  </sect1>

 <!-- ============= File operations: Browsing with the tags browser ===   -->
  <sect1 id="browsing-files">
   <title>Der Symbol-Browser</title>
   <para>
    You can browse C and C++ source and header files using <emphasis>tags</emphasis> in the files. 
	A tag (or <emphasis>symbol</emphasis>) refers to a named entity such as a function definition, structure, or macro.
    Anjuta scans open C and C++ source and header files for available tags.
   </para>
   <para>
    <application>Anjuta</application> will automatically scan for tags 
    in all of the source and header files of any open project. You can
	jump to any function definition, structure definition, class definition or other tag 
	without manually opening the containing file. You don't even have to know which file the
	tag is found in. The symbol browser
    lists all available symbols in the project.
    <figure id="symbol-browser">
     <title>Symbol-Browser</title>
     <screenshot>
      <screeninfo>Symbol-Browser</screeninfo>
      <graphic fileref="figures/symbol_browser.png" format="PNG" srccredit="jhs"/>
     </screenshot>
    </figure>
    </para>
   <tip>
    <title>Tag synchronization</title>
    <para>
     You don't have to worry about the synchronization and update of the tag 
     database. <application>Anjuta</application> will take care of everything. 
	 You just have to decide which tag you want to go to!
    </para>
   </tip>
   
  </sect1>

  <!-- ============= File operations: Searching and replacing in files === -->
  <sect1 id="search-replace-files">
   <title>Suchen und Ersetzen von Text in Dateien</title>
    <sect2 id="searching">
    <title>Suchen</title>
      <para>Um nach einer <emphasis>Zeichenkette</emphasis> oder einem <emphasis>regulären Ausdruck</emphasis> in der aktuellen Datei zu suchen, wählen Sie <menuchoice><guimenu>Bearbeiten</guimenu><guisubmenu>Suchen</guisubmenu><guimenuitem>Finden</guimenuitem></menuchoice> oder drücken Sie <keycombo><keycap>Strg</keycap><keycap>Alt</keycap><keycap>F</keycap></keycombo>. Daraufhin wird der Dialog <interface>Finden</interface> geöffnet.</para>
      <para>Geben Sie die zu suchende Zeichenkette in das Feld ein und wählen Sie, ob es eine normale Zeichenkette oder ein regulärer Ausdruck ist. Sie können auch die Suchrichtung, die Beachtung von Groß-/Kleinschreibung und den Suchbereich festlegen. Klicken Sie zum Starten der Suche auf <guibutton>Suchen</guibutton>.</para>
      <para>Bei erfolgreicher Suche springt Anjuta den Suchtreffer an oder führt eine weitere Aktion aus (entsprechend der <guilabel>Suchaktion</guilabel>, die Sie im Reiter <guilabel>Suchziel</guilabel> gewählt haben). Wenn die Suche ohne Erfolg blieb, wird Anjuta eine Nachricht anzeigen, die darüber informiert.</para>
      <para>Wenn Sie die Suche fortsetzen möchten, klicken Sie auf den Knopf <guibutton>Suchen</guibutton> ein weiteres Mal oder drücken Sie <keycombo><keycap>Strg</keycap><keycap>G</keycap></keycombo>. So wird der nächste Suchtreffer aufgesucht (Verwenden Sie <keycombo><keycap>Umschalt</keycap><keycap>Strg</keycap><keycap>G</keycap></keycombo> für den vorhergehenden Suchtreffer). Sie können den Suchtext ändern, indem Sie die neue Zeichenkette in das Textfeld <guilabel>Suchausdruck</guilabel> im Suchdialog eingeben.</para>
      <figure id="search-expr">
      <title>Dialog »Suchtext«</title>
        <screenshot>
        <graphic fileref="figures/search_expr.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
	  <para>Drücken Sie zum Anhalten einer langen Suche den Knopf <guibutton>Stopp</guibutton>.</para>
    </sect2>
    <sect2 id="search-range">
    <title>Festlegen des Suchbereichs</title>
      <para>Legen Sie im Reiter <interface>Suchziel</interface> den Suchbereich und die Aktion fest, die im Falle eines Sucherfolgs ausgeführt werden soll.</para>
      <para>Sie können die maximale Anzahl der auszuführenden Aktionen festlegen.</para>
      <figure id="search-target">
      <title>Dialog »Suchziel«</title>
        <screenshot>
        <graphic fileref="figures/search_target.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
      <para>Sie können wählen, nach welchem Text gesucht werden soll.</para>
      <figure id="search-target-in">
      <title>Auswahlmöglichkeiten für »Suchen in«</title>
       <screenshot>
       <graphic fileref="figures/search_target_in.png" format="PNG" srccredit="jhs"/>
       </screenshot>
      </figure>
      <sect3 id="search-file">
      <title>Suchen in Dateien</title>
       <para>Setzen Sie zur Textsuche in Ihrem Projekt <guilabel>Suchen in</guilabel> auf »Alle Projektdateien«.</para>
       <para>Geben Sie im Reiter <guilabel>Suchausdruck</guilabel> den zu suchenden Text ein und legen Sie die Sucheinstellungen fest, wie z.B. <guilabel>Groß-/Kleinschreibung berücksichtigen</guilabel> oder <guilabel>Nur vollständige Wörter berücksichtigen</guilabel>. Starten Sie die Suche mit  <guibutton>Suchen</guibutton>.</para>
       <para>Verwenden Sie zum Suchen von Text in mehreren Dateien das Feld <guilabel>Suchen in</guilabel> zur Eingabe von Dateimustern. Legen Sie die Suchvariablen fest. Klicken Sie anschließen zum Start der Suche auf <guibutton>Suchen</guibutton>.</para>	 
         <figure id="search-file-pattern">
         <title>Dateisuchmuster</title>
          <screenshot>
          <graphic fileref="figures/search_file_pattern.png" format="PNG" srccredit="jhs"/>
          </screenshot>
       </figure>

      </sect3>		 

	</sect2>
    <sect2 id="search-action">
    <title>Einen Suchvorgang angeben</title>
      <para>Sie können auswählen welche Aktion bei erfolgreicher Suche ausgeführt werden soll.</para>
      <para>Abhängig von der vorherigen Auswahl (<guilabel>Suche in</guilabel>, <guilabel>Suchrichtung</guilabel> usw.) stehen einige Vorgänge nicht zur Verfügung.</para>
      <figure id="search-target-action">
      <title>Auswahlmöglichkeiten für die Aktion »Suchziel«</title>
       <screenshot>
       <graphic fileref="figures/search_target_action.png" format="PNG" srccredit="jhs"/>
       </screenshot>
      </figure>
  
    </sect2>
    <sect2 id="replacing">
    <title>Ersetzen</title>
      <para>Suchen und Ersetzen ist vergleichbar mit der Textsuche, mit dem Unterschied, dass Sie auch den Ersatztext im Textfeld <guilabel>Ersetzen durch</guilabel> eingeben können. Und Sie können auch festlegen, ob Sie vor jeder Ersetzung gefragt werden möchten (»Ersten Treffer ersetzen« und »Alle Treffer ersetzen«).</para>
      <figure id="replace">
      <title>Ersetzen</title>
        <screenshot>
        <graphic fileref="figures/search_replace.png" format="PNG" srccredit="jhs"/>
        </screenshot>
      </figure>
	  <para>Wählen Sie <guibutton>Ersetzen</guibutton> zum Ersetzen der Übereinstimmung oder <guibutton>Weiter</guibutton>, um zur nächsten Übereinstimmung zu gelangen.</para>

	</sect2>
    <sect2 id="search-setting">
    <title>Sucheinstellungen</title>
      <para>Sie können Suchoptionen auch speichern.</para>
      <para>Das in rot hervorgehobene Objekt ist das aktive. Das vorausgewählte Objekt gibt Sucheinstellungen vor, die beim Start von Anjuta geladen werden.</para>
      <figure id="search-setting-fig">
      <title>Dialog zu den Sucheinstellungen</title>
        <screenshot>
        <graphic fileref="figures/search_setting.png" format="PNG" srccredit="jhs"/>
        </screenshot>
       </figure>
    </sect2>

  </sect1>

 <!-- ============= File operations: Printing Files === -->
   <sect1 id="printing">
    <title>Drucken einer Datei</title>
    <para>Sie können die Druckvorschau mit <menuchoice><guisubmenu>Datei</guisubmenu><guimenuitem>Druckvorschau</guimenuitem></menuchoice> aufrufen. Die aktuelle Datei wird abgebildet und eine Druckvorschau angezeigt. Im Editor hervorgehobener Quelltext wird auch ähnlich in der Vorschau hervorgehoben (und im Ausdruck). Der Reiter <guilabel>Drucken</guilabel> in den Einstellungen der Editor-Plugins weitere Einstellungen, die den Ausdruck mit Zeilennummern, umgebrochenen Zeilen und/oder Headern ermöglichen. <figure>
       <title>Druckvorschau für eine C-Datei</title>
       <screenshot>
       <screeninfo>Druckvorschau</screeninfo>
        <graphic fileref="figures/print_preview.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure></para> 
    <para>
	 <figure>
       <title>Druckeinstellungen</title>
       <screenshot>
	   <screeninfo>Druckeinstellungen</screeninfo>
        <graphic fileref="figures/prefs_print.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
	</para>
	<para>Wenn Sie nun drucken möchten und mit der Vorschau zufrieden sind, wählen Sie <menuchoice><guisubmenu>Datei</guisubmenu><guimenuitem>Drucken</guimenuitem></menuchoice> oder <guibutton>Drucken</guibutton> im Vorschaufenster. Der unten gezeigte Druckdialog wird daraufhin geöffnet. Wählen Sie die passenden Druckeinstellungen und klicken Sie zum Drucken der Datei auf <guibutton>Drucken</guibutton>.</para>
	<para>Sie können auch Hoch- oder Querformat, Papiergröße, Seitenorientierung und Papiertyp festlegen. Vergessen Sie nicht die richtigen Einstellungen für Ihren Drucker zu treffen, da andernfalls der Ausdruck nicht wie erwartet sein kann.</para>
	<para>
	 <figure>
       <title>Druckdialog</title>
       <screenshot>
	   <screeninfo>Druckdialog</screeninfo>
        <graphic fileref="figures/print_dlg.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
	</para>
   </sect1>
 </chapter>


 <!-- Project Management -->
 <!-- ============= Project management ====================== -->
 <chapter id="project-management">
  <title>Projektverwaltung</title>
  
  <para>Anjuta verfügt über ein mächtiges Plugin zur Projektverwaltung, das die meisten auf <ulink type="info" url="info:automake">automake/autoconf</ulink> basierenden Projekte öffnen kann. In einigen ungewöhnlich konfigurierten Projekten kann es fehlschlagen, aber solange das Projekt  automake/autoconf auf typische Weise verwendet, sollte es funktionieren.</para>

  <para>Das vorteilhafte ist, dass Anjuta nichts zusätzlich zu den in der Projektstruktur hinterlegten Projektinformationen speichert. Das heißt, es gibt keine separaten Projektdaten von Anjuta, und alle Projektarbeiten geschehen direkt in der Projektstruktur. So ist es möglich, das Projekt ohne Anjuta zu verwalten und zu entwickeln, ohne den Zwang, zu einem Anjuta-eigenen Format umwandeln zu müssen. Technisch betrachtet sind Anjuta-Projekte automake-Projekte, und so ist gemischte Entwicklung (mit und ohne Anjuta-Anwender) als auch der Wechsel zwischen Entwicklungsplattformen ohne Hindernisse möglich.</para>

  <sect1 id="new-project">
   <title>Erstellen eines neuen Projekts</title>
   <sect2 id="new-project-from-template">
   <title>Erstellen eines Projekts aus einer Vorlage</title>
   <para>
   The project wizard plugin uses a powerful template processing engine
   called <application>autogen</application>. All new projects are created from
   templates that
   are written in <application>autogen</application> syntax. The project wizard
   lets you create new
   projects from a selection of project templates. The selection includes
   simple generic, flat (no subdirectory), GTK+, GNOME, Java, Python
   projects and more. New templates can be easily downloaded and
   installed since each template is just a collection of text files.
   </para>

   <para>Zum Erstellen eines neuen Projekts wählen Sie den Menüpunkt <menuchoice><guisubmenu>Datei</guisubmenu><guisubmenu>Neu</guisubmenu><guimenuitem>Projekt …</guimenuitem></menuchoice>, um so den Projekt-Assistenten zu starten. Lesen Sie die erste Seite sorgsam. Klicken Sie auf <guibutton>Vor</guibutton>, um fortzusetzen.</para>
   <para>WÄhlen Sie die Art der zu erstellenden Anwendung auf der zweiten Seite. Klicken Sie auf <guibutton>Vor</guibutton>, um fortzusetzen.</para>

   <para>
    On the following pages, enter all necessary
    details for your project. You can change these settings later, but
    it is advisable to set them right initially in order to maintain the project's
    integrity.
    White spaces or any non-alphanumeric characters, except 
    underscore (_) and dash (-), are not allowed in many of the entry boxes 
	that follow (except perhaps the
    <guilabel>Author</guilabel> text box).
	</para>

   <para>
    You can also specify whether your  
    project will have <emphasis>internationalization support</emphasis> 
    using <application>gettext</application> (read the
    <ulink type="info" url="info:gettext">gettext info page</ulink> for 
	more details). This gives your project multilingual support for 
	different languages such as English, French and Dutch.
    The rest of the options are for setting whether the GNU copyright 
	statement should appear in the comments at the top of each file, and for
	enabling GNOME desktop menu information if necessary. Shared library
    support allows you to add shared library modules later on. If
    you plan to have libraries in your project, it would be good to enable this.
    Depending on the project type that is being created, Anjuta may request
    additional information.
   </para>

   <para>Im letzten Schritt sollen Sie die eingegebenen Informationen prüfen. Klicken Sie zur Erstellung des Projekts auf <guibutton>Beenden</guibutton>.</para>

   <para>Sobald das Projekt erstellt wurde, können Sie es testen und es erstellen oder ausführen.</para>
  </sect2>
   <sect2 id="importing-project">
    <title>Importieren von Projekten</title>
    <para>
     The import project feature is used to import an already existing project and convert it into an
     <application>Anjuta</application> project. Activate the import project wizard via
     <menuchoice><guimenu>File</guimenu><guimenu>New</guimenu>
	<guimenuitem>Project from existing sources</guimenuitem></menuchoice>
     and follow the instructions dictated by the wizard. Once a project has been imported, it can be
     opened in <application>Anjuta</application> subsequently just like any other <application>
     Anjuta</application> project.
    </para>
	<note>
	<para>Der Importiervorgang funktioniert nur, wenn das bestehende Projekt <ulink type="info" url="info:automake">autoconf/automake</ulink> oder in gewissem Rahmen ein Makefile verwendet.</para>
	</note>
   </sect2>
  </sect1>
  
  <sect1 id="load-save-projects">
   <title>Laden und Speichern von Projekten</title>
   <sect2 id="loading-project">
    <title>Laden von Projekten</title>
    <para>Um ein Projekt zu öffnen, wählen Sie <menuchoice><guisubmenu>Datei</guisubmenu><guimenuitem>Öffnen …</guimenuitem></menuchoice>. Wählen Sie die Projektdatei (<filename>*.anjuta</filename>) im Dialog aus und klicken Sie auf <guibutton>OK</guibutton>.</para> 

    <para>Wenn ein Projekt jüngst geöffnet wurde, dann finden Sie es im Menü <menuchoice><guisubmenu>Datei</guisubmenu><guisubmenu>Zuletzt geöffnet</guisubmenu></menuchoice>. Wählen Sie den Dateinamen des Projekts aus der Liste, und das Projekt wird geöffnet.</para>
    <para>
     As soon as a project is opened, <application>Anjuta</application> will enter 
	 <emphasis>Project mode</emphasis>. There are three panes in the project window. The
     first is the project pane and lists project files organized by file type. The second
     is the symbol browser, which has already been discussed in the section <emphasis>The Symbol Browser</emphasis>. The third pane is the file view of the project and
     is more or less similar to a mini file-manager. In the file view, all the files present
     in the project tree are visible. Right-clicking on these files will pop up a
     context menu with file operations.
    </para>
    <para>
     If the project is also a CVS tree, then corresponding file revision numbers are also
     listed to the right of file names in the file view pane.
    </para>
   </sect2>
   <sect2 id="saving-project">
    <title>Speichern von Projekten</title>
    <para>Das Projekt wird beim Schließen automatisch gespeichert, weil alle Änderungen direkt in der Projektstruktur vorgenommen werden.</para>
   </sect2>
  </sect1>

  <sect1 id="projects-structure">
  <title>Projektstruktur</title>
  <para>
   Here is the <interface>Project window</interface> with its  
   context menu
   (accessible by clicking on the right mouse button). 
   <figure id="project-window">
    <title>Projektfenster</title>
    <screenshot>
     <screeninfo>Das Projektfenster</screeninfo>
     <graphic fileref="figures/project-window.png" format="PNG" srccredit="jhs"/>
    </screenshot>
   </figure>
  </para>
  <para>
  The <interface>Project window</interface> displays the project's
  <ulink type="info" url="info:automake"><application>automake</application></ulink>
  hierarchy organized
  into <emphasis>groups</emphasis> of <emphasis>targets</emphasis>. Groups correspond to
  directories in your project and targets
  correspond to normal <application>automake</application> targets (not to be confused
  with make targets). The <interface>Project window</interface> actually
  has two parts: the lower part
  shows the complete project hierarchy and the upper part
  lists important targets directly. Important targets include executable
  and library targets; the view makes these easily accessible.
  This is particularly useful in large projects where the hierarchy
  can be deep and hard to navigate from the tree alone. Targets are, in
  turn, composed of source files.
  </para>

  <para>
  <itemizedlist>
   <listitem>
    <para>
      <emphasis>Groups</emphasis> are used to logically organize targets.
      A project can contain any number of groups. Each group can have subgroups
      as well as targets. In automake projects, groups are just subdirectories
      in the project. The top-level group is always labeled "/".
    </para>
   </listitem>
   <listitem>
    <para>
      <emphasis>Targets</emphasis> are the build targets in the project, such as
      programs (executable binaries), scripts, libraries and miscellaneous data.
      Not all target types are built from sources; some exist just to
      organize sources and therefore may not exist physically (e.g. a
      Miscellaneous Data target).
      Targets exist under groups. See <link linkend="adding-target">"Adding targets"</link> for
      a full list of available target types.
    </para>
   </listitem>
   <listitem>
    <para>
      <emphasis>Source files</emphasis> may be used to build targets, though some source files
      simply belong to targets. They exist only under targets. Many target types
      expect certain type of source files (e.g. the Programs and Libraries target
      types), but some can accept any file (e.g. a Miscellaneous Data target).
    </para>
   </listitem>
  </itemizedlist>
  </para>

  <para>
  Each project group and target is configurable in the standard
  <application>automake</application> way. You can set compiler and linker
  flags directly for each target, or set <application>configure</application> variables. Groups allow
  you to set an installation destination for their targets.
  </para>

  <para>
  Just like the file manager, the project manager view also has convenience actions
  (accessible from the context menu) for source
  files and targets.
  </para>

  <para>
   Many command-line tools are available to maintain and manage a project, 
   and each tool has its own specific rules and capabilities.
   <application>Anjuta</application> tries to automate most common
   operations using plugins. However, you might occasionally still need
   to perform certain operations manually.
  </para>
  
  <para>
   You may modify a project's structure using external tools or by hand-editing the project
   files.   It doesn't matter whether the project is loaded in
   <application>Anjuta</application> or not. <application>Anjuta</application>
   will update itself with any external changes made to a project.
  </para>
  </sect1>
 
  <sect1 id="groups-and-targets">
   <title>Gruppen und Ziele</title>

   <sect2 id="adding-groups">
    <title>Hinzufügen von Gruppen</title>
    <para>So fügen Sie eine neue Gruppe hinzu (die einem Ordner in automake-Projekten entspricht): <itemizedlist>
         <listitem>
           <para>Wählen Sie <menuchoice><guisubmenu>Projekt</guisubmenu><guimenuitem>Gruppe hinzufügen …</guimenuitem></menuchoice> und ein Dialog zum Hinzufügen neuer Gruppen erscheint.</para>
         </listitem>
         <listitem>
           <para>Wählen Sie die Gruppe, innerhalb der die neue Gruppe hinzugefügt werden soll.</para>
         </listitem>
         <listitem>
            <para>Geben Sie den namen der neuen Gruppe ein und klicken Sie auf <guibutton>Hinzufügen</guibutton>.</para>
         </listitem>
        </itemizedlist></para>
     <para>In Automake-Projekten wird ein neuer Ordner mit dem angegebenen Namen im Ordner der übergeordneten Gruppe erstellt.</para>
    <para>
     You can also add a new group from the <interface>Project</interface> window directly.  Right-click the group
     under which to add the new group, then choose
     <guimenuitem>Add Group</guimenuitem> from the context menu.
    </para>
   </sect2>

   <sect2 id="removing-group">
    <title>Entfernen von Gruppen</title>
    <para>So entfernen Sie eine Gruppe: <itemizedlist>
     <listitem>
       <para>Klicken Sie mit der rechten Maustaste auf die Gruppe in der Ansicht <interface>Projektverwaltung</interface>.</para>
     </listitem>
     <listitem>
       <para>Wählen Sie <guimenuitem>Entfernen</guimenuitem> im Kontextmenü.</para>
     </listitem>
    </itemizedlist></para>
    <para>
      The target and sources associated
      with the group will also be removed from the project. (They are not
      deleted from the file system, though. You can add them to the project again later if you like.)
    </para>
   </sect2>

   <sect2 id="adding-target">
    <title>Hinzufügen von Zielen</title>
    <para>So fügen Sie ein neues Ziel hinzu: <itemizedlist>
      <listitem>
       <para>Select <menuchoice><guisubmenu>Project</guisubmenu>
       <guimenuitem>Add Target</guimenuitem></menuchoice> and a dialog to
       add a new target will popup.</para>
     </listitem>
     <listitem>
      <para>Select the group under which to add the target.</para>
     </listitem>
     <listitem>
      <para>Wählen Sie den Zieltyp.</para>
     </listitem>
     <listitem>
      <para>Enter a name for the new target and click <guibutton>Add</guibutton>.</para>
     </listitem>
    </itemizedlist></para>
    <para>
     You can also add a new target from the <interface>Project</interface> window directly.
     Right-click the group
     under which to add the target, then select
     <guimenuitem>Add target</guimenuitem> from the context menu.
    </para>
    <para>
     Target names usually require some standard prefix and suffix, depending
     on the type of target. Anjuta will warn you if a name is not valid and
     may provide an example of a valid name.
    </para>
    <para>
     There are several target types for automake projects. They are:
    <itemizedlist>
     <listitem>
      <para>
       The <emphasis>Program</emphasis> target type is for executable binaries. Select
       this type if you want to add an executable to the project. By default, all program
       targets will be installed in the standard executable directory, e.g.
       /usr/bin or /usr/local/bin. You can override this by specifying a different
       installation directory in the properties of the group containing the target.
      </para>
     </listitem>
     <listitem>
      <para>
       The <emphasis>Shared Library</emphasis> target type is for shared or dynamic libraries.
       Select this type if you are adding a shared library to the project. By default, all
       shared libraries are installed in the standard libraries directory, e.g.
       /usr/lib or /usr/local/lib. You can override this by specifying a different
       installation directory in the properties of the group containing the target.
      </para>
     </listitem>
     <listitem>
      <para>
       The <emphasis>Static Library</emphasis> target type is for static libraries.
       Select this type if you are adding a static library to the project. By default,
       all static libraries are installed in the standard libraries directory, e.g.
       /usr/lib or /usr/local/lib. You can override this by specifying a different
       installation directory in the properties of the group containing the target.
      </para>
     </listitem>
     <listitem>
      <para>
       The <emphasis>Java Module</emphasis> target type is for Java modules. Select
       this type if you are grouping Java sources into a module. You need to provide
       an installation directory for this target where the .class files will
       be installed. It can be set in the properties of the group containing the target.
      </para>
      <note>
       <para>
         There can really be only one Java module in a group. This is a
         restriction made by automake. Please read the automake info page for more
         details.
       </para>
      </note>
     </listitem>
     <listitem>
      <para>
       The <emphasis>Python Module</emphasis> target type is for Python modules. Select
       this type if you are grouping Python sources into a module. You need to provide
       an installation directory for this target where the sources will
       be installed. It can be set in the properties of the group containing the target.
      </para>
     </listitem>
     <listitem>
      <para>
        The <emphasis>Scripts</emphasis> target type is for grouping scripts. They will be
        installed in the standard executable directory.
      </para>
     </listitem>
     <listitem>
      <para>
        The <emphasis>Miscellaneous Data</emphasis> target type is for grouping
        simple files in a project. You must specify an installation directory
        in the group properties.
      </para>
     </listitem>
     <listitem>
      <para>
        The <emphasis>Header Files</emphasis> target type is for grouping C/C++
        header files that need to be installed on a system (for example as part
        of a library API). (For header files that do not need to be installed,
        make them part of the Program target along with the sources.) Header files will
        be installed in the standard include directory unless an installation path
        is specified in the group properties.
      </para>
     </listitem>
     <listitem>
      <para>
        The <emphasis>Man Documentation</emphasis> and <emphasis>Info Documentation</emphasis>
        target types are for grouping man and info documentation respectively.
        By default, documentation files will be installed in the standard installation directories.
      </para>
     </listitem>
    </itemizedlist>
    </para>
   </sect2>
   <sect2 id="removing-target">
    <title>Entfernen von  Zielen</title>
    <para>So entfernen Sie ein Ziel: <itemizedlist>
       <listitem>
        <para>Right-click the target in the <interface>Project Manager</interface> view.</para>
       </listitem>
       <listitem>
        <para>Wählen Sie <guimenuitem>Entfernen</guimenuitem> im Kontextmenü.</para>
       </listitem>
      </itemizedlist></para>
    <para>
      The sources associated with the targets
      will also be removed from the project (they are not deleted from the
      file system, though).
    </para>
   </sect2>
  </sect1>

  <sect1 id="adding-removing-sources">
   <title>Hinzufügen und Entfernen von Dateien</title>
   <sect2 id="adding-sources">
    <title>Hinzufügen von Quelldateien</title>
    <para>
     Select the menu item <menuchoice><guisubmenu>Project</guisubmenu>
	 <guimenuitem>Add Source File</guimenuitem></menuchoice>.
	From the dialog, select the target to which the file should be added and
    the file itself. You can add multiple files at once. To do that, select
    multiple files from the file selection dialog using either the <keycap>Shift</keycap> or <keycap>Ctrl</keycap>
    key. Then click <guibutton>Add</guibutton> to add the
    files to the project.
    </para>
    <para>
    By default, the current editor file will be preselected for addition in the
    dialog. Another convenient way to add a file is to right-click it in the
    <interface>File Manager</interface> and choose
    <guimenuitem>Add to project</guimenuitem> from the
    context menu.	
    </para>
    <para>
     If the file you choose has already been added to the project, then
     <application>Anjuta</application> will not add it again. 
     It will also give you a warning that the file has already been added.
    </para>
    <para>
     If the file you choose is not in the project directory, you will be asked
     to confirm that you wish to copy the file into the target's directory.
     <application>Anjuta</application> cannot add files which are 
	 outside of a target's directory without copying them in.
    </para>
   </sect2>
   <sect2 id="removing-sources">
    <title>Entfernen von Quelldateien</title>
    <para>
     To remove a file from the project, right-click the file you want to remove
     in the <interface>Project window</interface> and
	 choose <guimenuitem>Remove</guimenuitem> from the context menu.
    </para>
    <para>Ein Bestätigungsdialog wird geöffnet, und die Datei wird aus dem Projekt entfernt.</para>
    <important>
     <title>Die Datei wurde nicht entfernt!</title>
     <para>Die Datei wird nicht aus dem Dateisystem entfernt. Sie ist noch vorhanden, und Sie können Sie später wieder hinzufügen, falls gewünscht. Die Datei wird nur aus der Projektliste entfernt und wird für Projektoperationen wie Kompilieren, Erstellen oder Veröffentlichen von Distributionspaketen nicht mehr berücksichtigt.</para>
     </important>
   </sect2>
  </sect1>
  
  <sect1 id="project-config">
   <title>Projekteinstellungen</title>
   <para>
    Project configuration involves setting the correct build flags for
    targets, groups and the project itself. You can set these flags in their
    respective properties dialogs.
   </para>

   <para>
    You can freely use autoconf and automake variables that are automatically
    set for the project during configuration. Apart from these automatically
    set variables, you can also define your own variables in
    <link linkend="project-properties">Project Properties</link> and use them in
    properties. This will make it easy to update flags later, especially when
    a variable is used in several targets.
   </para>

   <para>Einige der am häufigsten vorkommenden Variablen werden hier aufgelistet. Eine vollständige Liste finden Sie in der <ulink url="info:automake">Infoseite zu automake</ulink>. <itemizedlist>
      <listitem>
       <para><emphasis>$(prefix)</emphasis>: Das Installationspräfix. Das Projekt wird in verschiedenen Unterordnern unter diesem Präfix installiert. Vorgabe ist /usr/local.</para>
      </listitem>
      <listitem>
       <para><emphasis>$(bindir)</emphasis>: Der Installationsordner für ausführbare Dateien. Alle Ihre ausführbaren Dateien und Skripte werden in diesen Ordner installiert. Vorgabe ist $(prefix)/bin.</para>
      </listitem>
      <listitem>
       <para><emphasis>$(libdir)</emphasis>: Der Installationsordner für Bibliotheken. Alle Ihre Bibliotheken (sowohl gemeinsame als auch statische) werden in diesen Ordner oder in einen Unterordner davon installiert. Vorgabe ist $(prefix)/lib.</para>
      </listitem>
      <listitem>
       <para>
         <emphasis>$(module_CFLAGS)</emphasis> and $(module_LIBS): These
         flags are set by <application>configure</application> for the packages that your project
         depends on. The packages used by the project are set in
         <link linkend="project-properties">Project Properties</link>. 'module'
         is a package group that you specify in the project properties as described below.
       </para>
      </listitem>
     </itemizedlist></para>


   <sect2 id="project-properties">
    <title>Projekteigenschaften</title>
    <para>
    The project properties dialog can be opened only by
    choosing <menuchoice><guisubmenu>Project</guisubmenu>
    <guimenuitem>Properties</guimenuitem></menuchoice> from the toplevel menu bar. You can:
    <itemizedlist>
     <listitem>
      <para>
      Set the project name, version and URL in the <guibutton>General</guibutton> page.
      <application>configure</application> variables can also be use in these fields. The URL is the
      bug report URL for the project.
      </para>
     </listitem>
     <listitem>
      <para>
      Add and remove dependencies for your project in the
      <guibutton>Packages</guibutton> page. See below for details.
      </para>
     </listitem>
     <listitem>
      <para>
      Create more configure variables in the <guibutton>Variables</guibutton> page
      to use in group and target properties.
      </para>
     </listitem>
    </itemizedlist>
    </para>
    <para>
    Dependencies
    are external packages that the project uses and are hence required
    to build it. Only packages installed using
    <ulink url="info:pkg-config">pkg-config</ulink>
    can be added from this interface. For others, the configure.ac file can
    be edited manually.
    <figure>
       <title>Eigenschaften-Dialog für Projekte</title>
       <screenshot>
	   <screeninfo>Eigenschaften-Dialog für Projekte</screeninfo>
        <graphic fileref="figures/project_info.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
   </para>
   <para>
    External package dependencies are grouped into <emphasis>modules</emphasis>,
    so that their combined build flags can be conveniently added to different
    targets. <emphasis>Modules</emphasis> are just arbitrary
    groups of packages and can be named anything (only alphanumeric characters and _ are
    allowed in module names). Usually, they follow the name of
    targets they would be used in. Consequently, for small projects with single 
    targets, just one module to hold all dependencies is enough.
   </para>
   <para>
    Each package exports a set of <emphasis>compiler flags</emphasis>
    and <emphasis>libraries</emphasis>. They are aggregated together for
    all packages under a module, and <application>configure</application> variables
    <emphasis>$(module_CFLAGS)</emphasis> and
    <emphasis>$(module_LIBS)</emphasis> are defined. These variables can then
    be used in <link linkend="group-properties">Group properties</link>
    and <link linkend="target-properties">Target properties</link>.
   </para>
   <para>
    To add a package dependency:
    <itemizedlist>
     <listitem>
      <para>
      Select <menuchoice><guisubmenu>Project</guisubmenu>
      <guimenuitem>Properties</guimenuitem></menuchoice> to bring up the project
      properties dialog.
      </para>
     </listitem>
     <listitem>
      <para>Select the tab <guibutton>Packages</guibutton> to bring up the Packages
      page.</para>
     </listitem>
     <listitem>
      <para>
      Select the <emphasis>module</emphasis> to add the package to. If there
      is no module created yet or there is no appropriate module, create one
      by clicking <guibutton>Add module</guibutton>. Give a sensible name to the
      module, preferably in UPPERCASE to match other <application>configure</application> variables
      (only use alphanumeric and '_' characters) and press <keycap>Enter</keycap>
      to create it.
      </para>
     </listitem>
     <listitem>
      <para>Click <guibutton>Add Package</guibutton> to bring up the package selection dialog.</para>
     </listitem>
     <listitem>
      <para>Select the package to add and click <guibutton>Add</guibutton>.</para>
     </listitem>
     <listitem>
      <para>Click <guibutton>Close</guibutton> to close the properties dialog.</para>
     </listitem>
    </itemizedlist>
   </para>
   </sect2>

   <sect2 id="group-properties">
    <title>Gruppeneigenschaften</title>
    <para>
    To edit a group's properties, double-click the group in the
    <interface>Project</interface> window to open the <interface>Group Properties</interface> dialog.
    (You can alternatively right-click the group
    and select <guimenuitem>Properties</guimenuitem> from the context menu.)
     <figure>
       <title>Eigenschaften-Dialog für Gruppen</title>
       <screenshot>
	   <screeninfo>Eigenschaften-Dialog für Gruppen</screeninfo>
        <graphic fileref="figures/project_group.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
    </para>

    <para>
         Properties set for a group apply to all
         the targets under it. So any compiler or linker flags set for a group will
         be automatically be part of all the targets in it (in addition to
         each target's individual properties). The following fields are available in the Group
         Properties dialog.

		   <itemizedlist>
		    <listitem>
		     <para>
                <emphasis>Includes</emphasis>: Set your include directories for your C and C++ targets here.
                You need to provide the full include options of the compiler
                here, e.g. -I/usr/include/blah. The include paths will be used
                to find header files included by your source files. (You can also
                add other compiler flags here, but it's preferable
                to set them in their respective <emphasis>compiler flags</emphasis> fields as described below.)
             </para>
           </listitem>
		    <listitem>
		     <para>
                <emphasis>Compiler flags</emphasis>: Set your compiler-specific
                flags here. There are different fields for different compiler
                categories. Flags that can be set here depend on the actual
                compiler used. The default compiler used for C/C++ is gcc/g++
                (the GNU C compiler). Check out the <ulink url="info:gcc">gcc info
                documentation</ulink> for more details.
             </para>
           </listitem>
		    <listitem>
		     <para>
                <emphasis>Install directories</emphasis>: The dialog will display
                a field for each target in the group
                that requires an installation directory. Set each installation
                directory as relative to one of the many <application>automake</application>
                directory variables, such as $(prefix), $(bindir), $(libdir),
                or $(datadir).
             </para>
           </listitem>
          </itemizedlist>

    </para>
   </sect2>

   <sect2 id="target-properties">
    <title>Ziel-Eigenschaften</title>
    <para>
     Any properties set for a target apply to that target only.  A target also inherits
		 properties from its containing group.
		</para>
	  <para>
    To set a target's properties, double-click the target
    in the <interface>Project window</interface> to open the Target Properties dialog. (You can
    alternatively right-click the target and select <guimenuitem>Properties</guimenuitem> from
    the context menu.)
     <figure>
       <title>Eigenschaften-Dialog für Ziele</title>
       <screenshot>
	   <screeninfo>Eigenschaften-Dialog für Ziele</screeninfo>
        <graphic fileref="figures/project_target.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
    </para>
    <para>
        You can add the modules you have added in <link linkend="project-properties">Project properties</link>
        to a specific target here. To activate the module simply toggle the checkbox
        next to the module name. This will automatically add include and linker
        flags to that target and enable you to use the module within this target.
    </para>
    <sect3 id="target-advanced">
    <title>Advanced target options</title>
    <para>
    The following fields are available in the advanced target configuration that
    you reach when you clicked the <guibutton>Advanded...</guibutton> button in the
    target properties dialog.
    </para>
    <para>
    <figure>
       <title>Eigenschaften-Dialog für Ziele</title>
       <screenshot>
	   <screeninfo>Eigenschaften-Dialog für Ziele</screeninfo>
        <graphic fileref="figures/project_target_details.png" format="PNG" srccredit="jhs"/>
       </screenshot>
     </figure>
		   <itemizedlist>
		    <listitem>
		     <para>
                <emphasis>Compiler settings</emphasis>: Set your compiler-specific
                flags here. There are different fields for different compiler
                categories. Flags that can be set here depend on the actual
                compiler used. The default compiler used for C/C++ is gcc/g++
                (the GNU C compiler). Check out the <ulink url="info:gcc">gcc info
                documentation</ulink> for more details.
             </para>
            </listitem>
		    <listitem>
		     <para>
                <emphasis>Linker flags</emphasis>: Set linker flags that should
                be used when linking the target. These flags apply only to Program
                and Library targets. See the <ulink url="info:ld">ld info documentation</ulink>
                for available linker options.
             </para>
            </listitem>
		    <listitem>
		     <para>
                <emphasis>Libraries</emphasis>: Set the libraries that the
                target depends on.
             </para>
           </listitem>
          </itemizedlist>

    </para>
    </sect3>
   </sect2>
  </sect1>
  
 </chapter>

 <!-- Build -->
 <!-- ============= Build ====================== -->
 <chapter id="building">
  <title>Erstellen</title>
  <para>
   Anjuta handles <application>autotools</application> projects. It is able to cope with other kinds of
   projects, such as projects using a user-written Makefile, but the current build
   interface is targeted at autotools projects. Some knowledge of them is
   useful to better understand the way a project is built.
  </para>
  <para>
   An autotools project is built in three steps:
  </para>
  <para>
     <orderedlist>
      <listitem><para>Generate</para></listitem>
      <listitem><para>Configure</para></listitem>
      <listitem><para>Build</para></listitem>
     </orderedlist>
  </para>
  <para>
   <emphasis>Build</emphasis> is the main step in which all target files are
   generated from the source files. It can be divided into
   two subphases: <emphasis>Compile</emphasis> and <emphasis>Link</emphasis>.
   In the <emphasis>Compile</emphasis> phase each object file is generated from 
   its corresponding source file. For instance, a source file <filename>hello.c</filename>
   will generate <filename>hello.o</filename> after compilation. Usually you do not need 
   to worry about these object files — just think of them as intermediate files. 
   In the <emphasis>Link</emphasis> phase, all object files and libraries
   are linked together to create the final executable.
   Some programming languages do not need a <emphasis>Compile</emphasis>
   and a <emphasis>Link</emphasis> phase. Moreover the <emphasis>Build</emphasis> step
   may be used to generate other files, like documentation which doesn't need such phases.
  </para>
  <para>
   <emphasis>Configure</emphasis> is the step in which the source tree is adjusted
   to your system. <application>autotools</application> projects can be built on a wide range of systems using
   different compilers and having different library functions. This step runs a
   script named <filename>configure</filename> that will check for various characteristics
   of your system
   and create some of the files required to perform a build (such as 
   <filename>Makefile</filename> and <filename>config.h</filename>).
   This step is used to select build options, too; for
   instance, a build option may disable optimization to make debugging easier or disable some
   experimental part of a program.
  </para>
  <para>
   <emphasis>Generate</emphasis> is the step in which the <filename>configure</filename>
   script and other related files are created. The <filename>configure</filename>
   script used above needs to run on
   various systems and checks a lot of things. It would be quite difficult to write it
   by hand. Moreover <application>autotools</application> enforces some project organization rules
   such as the presence of some mandatory files: <filename>NEWS</filename> and <filename>COPYING</filename>, for example.
   It includes several tools
   to create necessary files from simpler files written by the developer
   such as <filename>configure.in</filename> (or <filename>configure.ac</filename>) and
   <filename>Makefile.am</filename>. All these tools are commonly run
   from a script named <filename>autogen.sh</filename> in the project directory. This step is useful only
   for a developer (someone modifying the source files), as the
   <filename>configure</filename> script depends only on the source files, and is distributed within the
   project package.
   Note that the makefiles created by <application>configure</application> include some rules
   to automatically regenerate the project when needed, so it often not needed to
   rerun it directly.
 </para>
 <para>
  Read the info pages of <ulink type="info" url="info:automake"><application>automake</application></ulink> 
  and <ulink type="info" url="info:autoconf"><application>autoconf</application></ulink> for more 
  details on how these tools work.
 </para>


 <!-- Build: Generate and Configure -->

 <sect1 id="build-configure">
  <title>Generate and Configure</title>
  <sect2 id="configure">
   <title>Configure a project</title>
   <para>
    You need to run this step before being able to build your project. This is
    usually run only once at the beginning of the first build process —
    for example, just after you have extracted a source tarball of a
    project distribution. After that, configuration is automatically handled by the 
    subsequent build processes.
    If you have used the <emphasis>Application Wizard</emphasis> 
    to create the application, then you will not need to run this 
    separately: the wizard will run it as a part of the project generation process.
   </para>
   <para>
    There is no requirement to run this only once. It can be 
    run at any time, usually when the configuration options need to be changed. One thing to 
    note is that if the <filename>config.h</filename> file in the top level directory is 
    changed, running <filename>configure</filename> again will not overwrite it.
   </para>
   <para>
    Both generate and configure steps are launched with a single menu item:
    <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Configure Project…</guimenuitem></menuchoice>.
    This menu item brings a dialog where you can choose:
    <itemizedlist>
     <listitem><para>Whether you want to run the generate step or not</para>
      <para>
       The generate step needs to be run once at the beginning of the project; then it is automatically
       handled by the build process. You can force it to run by checking the checkbox
       <interface>Regenerate project</interface>; you might do this if you encounter
       difficulties while building a project (e.g. if you receive build errors
       after you've modified lots of build files).
      </para>
     </listitem>
     <listitem><para>The configuration name</para>
      <para>
       This name is used to refer to each configuration. Some configurations (Default,
       Debug, Optimized) are already defined by default. One configuration includes
       a build directory and some configuration options.
      </para>
     </listitem>
     <listitem><para>The build directory</para>
      <para>
       This is the build directory name. In the Default configuration, it is the same
       directory as the source directory but autotools supports building in a
       different directory.
      </para> 
      <note><para>
       Each configuration must have a different build directory and if one configuration
       uses the source directory, you cannot have other configurations at the same time.
       You need to run <menuchoice><guisubmenu>Build</guisubmenu>
       <guimenuitem>Remove Configuration</guimenuitem></menuchoice> on the configuration
       using the source directory before adding a new configuration.
      </para></note>
     </listitem>
     <listitem><para>Configure options</para>
      <para>
       These options are passed to the <filename>configure</filename> script. Some are standard, such as --prefix and CFLAGS; others depend on the project. You can get a list of allowed configuration options by
       running the <filename>configure</filename> script with the <option>--help</option> argument.
      </para>
     </listitem>
    </itemizedlist>
   </para>
  </sect2>
  <sect2 id="select-configure">
   <title>Select a configuration</title>
   <para>
    If you have created different configurations, you can select which one is active by
    selecting it in <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Select Configuration</guimenuitem></menuchoice>.
   </para>
  </sect2>
  <sect2 id="clean-configure">
   <title>Clean a configuration</title>
   <para>
    To clean the project and leave it in a state that requires rerunning the
    configure step, choose <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Remove Configuration</guimenuitem></menuchoice>.
    It run <command>make distclean</command> and deletes more files than <guimenuitem>Clean Project</guimenuitem>.
    In other words, it leaves the project
    as though it has just been extracted from a distribution tarball. Note
    that it does not remove the configuration directory itself; you can
    do that yourself if you like.
   </para>
  </sect2>
 </sect1>


 <!-- Build: Compile and Build -->

 <sect1 id="build-compile-and-build">
  <title>Kompilieren und Erstellen</title>
  <sect2 id="build-compile">
   <title>Kompilieren einer Datei</title>
   <para>
    In a project, individual source files can be compiled separately into objects 
    (<filename>*.o</filename> files). Although you do not have to worry about these object 
    files, sometimes it is handy to compile a file first (for example, to make sure there are 
    no syntax errors). Building a whole project can take a lot of time, especially in the case of 
    larger and more complex applications. Therefore, you will probably go through a series of 
    edit-compile iterations while developing a project.
   </para>
   <para>
    To compile a file, choose the menu item <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Compile</guimenuitem></menuchoice> or  press <keycap>F11</keycap>.
    This will compile the active file.
   </para>
  </sect2>

  <sect2 id="build-build">
   <title>Erstellen eines ausführbaren Programms</title>
   <para>
    <application>Anjuta</application> has no separate link command, simply because 
    it is not necessary. The build process will compile all source files and link them together 
    along with the necessary libraries. The build command will not recompile those files which are 
    already up-to-date (this is called the <emphasis>dependency check</emphasis>). 
    If you have already compiled all files individually, then the only thing the build 
    step performs is the link. If you have already built the project and no dependent file has been 
    modified, even the link stage will be skipped.
   </para>
   <para>
    So how exactly does the dependency check influence project development? 
    If you have modified a file, then all of the source files that depend on the modified 
    file are recompiled. All files (not just the object files and executable) in the 
    project are checked for these dependencies during the build process. If it is found that 
    a particular file is dependent on some other file which has been modified, then that file 
    will be regenerated.
   </para>
   <para>
    Can you imagine how your life (as a programmer) would be if the dependency check were not there? If you 
    cannot answer just yet, then you will find out when you start developing big projects!
   </para>
   <para>
    <menuchoice><guisubmenu>Build</guisubmenu><guimenuitem>Build</guimenuitem></menuchoice> 
    will build all files in the directory of the currently active file. 
   </para>
   <para>
    <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Build Project</guimenuitem></menuchoice> will build 
    the whole project — all subdirectories are built recursively.
   </para>
  </sect2>
 </sect1>


 <!-- Build: Other operations -->

 <sect1 id="build-other">
  <title>Weitere Operationen</title>
  <sect2 id="build-dist">
   <title>Erstellen eines Distributionspakets</title>
   <para>
    To build a tarball distribution of the project choose <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Build Tarball</guimenuitem></menuchoice>. This will create a 
    tarball (<filename>*.tar.gz</filename>) and put it in the top-level project directory. 
    Copy the file to a safe place for distribution.
   </para>
  </sect2>
  <sect2 id="build-install">
   <title>Installieren eines Projekts</title>
   <para>
    Choosing the menu item <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Install</guimenuitem></menuchoice> will install the generated 
    application on your system. 
   </para>
   <note>
    <title>Systemweite Installation</title>
    <para>
     You must be logged in as root to perform a system-wide install. Also note that for a GNOME 
     application to use the pixmaps in the project, it must be installed as a system-wide 
     application. Otherwise, when the application is executed in your project, there will be 
     lots of "pixmap not found" errors. You can configure Anjuta to use <command>sudo</command>
     or <command>su</command> before installing the project in the build preferences.
    </para>
   </note>
  </sect2>
  <sect2 id="build-clean">
   <title>Cleaning</title>
   <para>
    This deletes all of the files generated by the build process, including
    all object files (<filename>*.o</filename> files) and the executable(s).
    It can be applied on one directory or the whole project.
   </para>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Clean Project</guimenuitem></menuchoice> to clean all project
    files.
   </para>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Build</guisubmenu>
    <guimenuitem>Clean</guimenuitem></menuchoice> to clean only the directory
    of the current active file.
   </para>
  </sect2>

 </sect1>

</chapter>

 <!-- Debugging -->
 <!-- ============= Debugging ====================== -->
 <chapter id="debugging">
  <title>Fehlerdiagnose</title>
  <para>
   <emphasis>To debug is human. To fix it is divine...</emphasis>
  </para>
  <para>
   Well, the <emphasis>human</emphasis> part is what this section is about. The 
   <emphasis>divine</emphasis> part is up to you!
  </para>
  <para>
   When a program does not behave in the way it is supposed to, we say the program
   contains a <emphasis>bug</emphasis>. A bug is not a compilation error — 
   compilation errors are relatively easy to clear, because the compiler tells you 
   where the problems are. By contrast, bugs are errors 
   that happen during program execution and they can be hard (sometimes very hard!) 
   to detect.
  </para>
  <para>
   Any program that you think is bug-free is never completely bug-free. All we can try 
   to do is to reduce the number of bugs contained in the program. The process of removing 
   bugs is known as <emphasis>debugging</emphasis>, and the tool that is used for debugging 
   is called the <emphasis>debugger</emphasis>. <application>Anjuta</application> provides a 
   very user-friendly and powerful debugging environment (actually, a GUI wrapper over 
   <application>gdb</application>, a powerful command line debugging tool and standard on Linux).
  </para>
  <para>
   A debugger tracks and traces the execution of the program and provides various 
   views of information needed to study the execution of the program.
  </para>

 <!-- Debugger: Start and stop -->

 <sect1 id="debugger-session">
  <title>Start and stop</title>

  <para>
   The debugger is always started with a program loaded. There are two ways to do this:
   <itemizedlist>
    <listitem><para><emphasis>Running an executable</emphasis></para></listitem>
    <listitem><para><emphasis>Attaching to a process</emphasis></para></listitem>
   </itemizedlist>
   <note>
    <para>
     Almost every feature of Anjuta is provided by a plugin. If you do not see
     the menus described here. It is probably because the debugger plugin is not
     loaded. Go in 
     <menuchoice><guisubmenu>Edit</guisubmenu><guimenuitem>Preferences</guimenuitem><guimenuitem>General</guimenuitem><guimenuitem>Installed plugins</guimenuitem></menuchoice>
     and check that the debugger plugin is loaded.
     It is an user activatable plugin, so loaded or unloaded on request.
    </para>
   </note>
  </para>

  <sect2 id="debug-run">
   <title>Running an executable</title>
   <para>
     Running a program with or without the debugger uses the same menu: select
     <menuchoice><guisubmenu>Run</guisubmenu><guimenuitem>Run Program</guimenuitem></menuchoice> 
     to run a program without the debugger and
     <menuchoice><guisubmenu>Run</guisubmenu><guimenuitem>Debug Program</guimenuitem></menuchoice>
     to run it with the debugger.
   </para>
   <note>
    <para>
     In order to better use the debugger, it is strongly recommended that you build your program
     with debugging information (-g for gcc) and no optimization (-O0 for gcc). This can be
     done by selecting the Debug configuration before building the program for the first time.
    </para>
   </note>
   <para>
    You can select which program to run and its environment using
    <menuchoice><guisubmenu>Run</guisubmenu><guimenuitem>Program Parameters…</guimenuitem></menuchoice>. 
    You can choose:
    <itemizedlist>
     <listitem><para>The program that you want to debug</para>
      <para>
       The drop-down menu of the target drop-down combination box 
       is pre-filled with all executables of the current project. But you can alternatively
       select another executable which is not part of the project. The debugger also accepts libtool
       executables; these are scripts generated by libtool which wrap real executables.
      </para>
     </listitem>
     <listitem><para>Die Befehlszeilenparameter</para></listitem>
     <listitem><para>Der Arbeitsordner</para></listitem>
     <listitem><para>Umgebungsvariablen</para>
      <para>Aktuelle Umgebungsvariablen werden hier in Hellgrau dargestellt. Sie können hier Umgebungsvariablen hinzufügen, ändern oder löschen.</para>
      <tip><para>
       To debug Anjuta using Anjuta, you can use a different theme to change the look of the instance
       being debugged; for example, you could add "GTK2_RC_FILES=/usr/share/themes/Crux/gtk-2.0/gtkrc".
      </para></tip>
     </listitem>
     <listitem><para>Whether the program should run in a terminal or not.  If so, the Anjuta terminal plugin is used.</para></listitem>
    </itemizedlist>
   </para>
  </sect2>
	
  <sect2 id="debug-attach">
  <title>Attaching to a Process</title>
   <para>
    It is also possible to attach to a running process and debug it by choosing the menu item
    <menuchoice><guisubmenu>Run</guisubmenu>
	<guimenuitem>Debug Process …</guimenuitem></menuchoice>. A list of all
    processes running on the system will appear. 
   </para>
   <figure id="attach">
    <title>Attach to Process dialog</title>
    <screenshot>
	<screeninfo>Attach to Process dialog</screeninfo>
     <graphic fileref="figures/attach.png" format="PNG" srccredit="andyp"/>
    </screenshot>
   </figure>
   <para>	
    Select the process to attach to and click <guibutton>OK</guibutton> to start the debugger,
    attach to the selected process and stop it.
   </para>
   <note>
    <para>
     It is currently not possible to load symbol information for an attached
 	process. Symbols should be included in the process. 
    </para>
   </note>
  </sect2>
  
  <sect2 id="debug-stop">
   <title>Stopping the Debugger</title>
    <para>
     Choose the menu item <menuchoice><guisubmenu>Run</guisubmenu>
     <guimenuitem>Stop Debugger</guimenuitem></menuchoice> to stop the debugger.
     This will kill the program which is being debugged. If the debugger has
     been attached to a running process, the debugger will just detach from it without killing
     it. You will get a confirmation box if a program is currently attached or running.
   </para>
  </sect2>

  <sect2 id="debug-add-sources">
   <title>Hinzufügen von Quellordnern</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Add source paths…</guimenuitem></menuchoice> to display a dialog
    box allowing you to add and remove source directories.
   </para>
   <para>
    Most executables include full file paths, so defining the directories where are the source files
    is normally not useful. But some executables include only file names without paths; in this case,
    the debugger will search for source files in all these directories.
    The order of directories can be important if several files have the same name, so
    you can change it using the <guibutton>Up</guibutton> and <guibutton>Down</guibutton>  buttons.
    The directory list is sent to the debugger when it is started. After changing it,
    you need to restart the debugger to cause it to use the new list.
   </para>
  </sect2>

 </sect1>
 
 <!-- Debugger: Execution -->
 
 <sect1 id="debugger-exec">
  <title>Ausführung</title>
  <para>
   Execution of a program in the debugger can be finely controlled. The program can be 
   executed in single steps, or allowed to continue until it encounters a breakpoint. 
   Executing like this is essential for tracking program behavior. Like a video editing 
   session, the program can be executed in <emphasis>slow motion</emphasis>
   with the ability to go forward, pause, stop, and so on. You cannot go backward yet though.
  </para>
  <para>
   The methods those can be used to execute a program in the debugger are described in 
   the following sections. These commands are available only when the program has already
   been started.
  </para>
  
  <sect2 id="dbg-step-in">
   <title>Single stepping (step in)</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Step In</guimenuitem></menuchoice>
    or click on the <guibutton>Step In</guibutton> icon in the 
	<interface>Debug toolbar</interface> to step into a program.
   </para>
   <para>
    Single stepping executes only one statement of the program (from the place where it 
	has stopped) and then returns control. If the statement that is executed contains one 
	or more functions, the debugger tries to step inside the functions (in the sequence in 
	which the functions are executed). Once the statement is executed and
    control is passed back, you can study your program's state.
   </para>
   <para>
    If the <interface>Disassembly window</interface> has the focus when this command is selected,
    it executes only one assembler instruction.
   </para>
  </sect2>

  <sect2 id="dbg-step-over">
   <title>Single stepping (step over)</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Step Over</guimenuitem></menuchoice>
    or click on the <guibutton>Step Over</guibutton> icon in the 
	<interface>Debug toolbar</interface> to step over statements in a program.
   </para>
   <para>
    <emphasis>Step over</emphasis> is similar to <emphasis>step in</emphasis>,
    except that it does not step inside any function in the statement being executed.
    The statement will be executed in one go.
   </para>
   <para>
    If the <interface>Disassembly window</interface> has the focus when this command is selected,
    it executes one assembler instruction but does not stop inside if this instruction is a call
    to a subroutine. 
   </para>
   <note>
    <para>
     If a dynamic library is loaded during the step, the program will not
     stop at the end of the step. But it will run until it finds a breakpoint or you
     stop it.
    </para>
   </note>
  </sect2>
  
  <sect2 id="dbg-step-out">
   <title>Single stepping (step out)</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Step Out</guimenuitem></menuchoice>
    or click on the <guibutton>Step Out</guibutton> icon in the 
	<interface>Debug toolbar</interface> to step out in a program.
   </para>
   <para>
    <emphasis>Step out</emphasis> will execute the current function until it 
	returns. The program will be stopped once it exits from the function. 
	Step out is not really single stepping, because it does not only execute 
	a single statement — it executes the whole function until that 
	function returns to the calling function.
   </para>
  </sect2>
  
  <sect2 id="dbg-run">
   <title>Ausführen/Fortsetzen</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Run/Continue</guimenuitem></menuchoice>
    or click on the <guibutton>Run/Continue</guibutton> icon in the 
	<interface>Debug toolbar</interface> to continue the execution of a program.
    </para>
   <para>
    This option continues the execution of the program until a breakpoint is 
	encountered, or the program exits.
   </para>
  </sect2>

  <sect2 id="dbg-runto">
   <title>Run To</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Run to Cursor</guimenuitem></menuchoice>
    or click on the <guibutton>Run to Cursor</guibutton> icon in the 
	<interface>Debug toolbar</interface> to run until the line at the cursor is reached.
   </para>
   <para>
    This option continues the execution of the program until the line or the
    address (if the <interface>Disassembly window</interface> has the focus) at
    the cursor is reached. 
   </para>
  </sect2>
  
  <sect2 id="dbg-stop">
   <title>Stop Program</title>
   <para>
    While the program is running and has control, no debugging tasks can be 
	performed. To obtain control while the program is running, choose the menu item
	<menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Pause Program</guimenuitem></menuchoice> or click on the
    <guibutton>Pause Program</guibutton> icon in the <interface>Debug toolbar</interface>.
    This will interrupt the program and return control to the debugger.
   </para>
  </sect2>
  
 </sect1>
 
<!-- ============= Debugging: Breakpoints ====================== -->
 
 <sect1 id="debugging-breaks">
  <title>Breakpoints</title>
  <para>
   When debugging a program, it is useful to be able to stop the execution of the program at
   a particular point, so that the state of the program can be examined at that location. 
   Breakpoints enable this to happen. Breakpoints can be set at different locations in a 
   source file and then the program is allowed to run. When a breakpoint is encountered, 
   the execution of the program is suspended, enabling expressions to be evaluated, 
   variables to be inspected, the stack trace to be studied, and so on.
  </para>

  <sect2 id="breaks-list">
   <title>Listing Breakpoints</title>
   <para>
    The <interface>Breakpoint list window</interface> can be opened by 
	choosing <menuchoice><guisubmenu>View</guisubmenu>
    <guimenuitem>Breakpoints</guimenuitem></menuchoice>
   </para>
   <para>
    <figure>
      <title>Protokoll a_nsehe</title>
      <screenshot>
       <screeninfo>Protokoll a_nsehe</screeninfo>
       <graphic fileref="figures/brk_dlg.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>
    The view has the following columns:
    <variablelist>
     <varlistentry>
      <term>Ort</term>
      <listitem>
       <para>
        This is the position of the breakpoint in the source file. When the breakpoint
        is set by the debugger, you can get additional information such as the function
        containing the breakpoint.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Adresse</term>
      <listitem>
       <para>
        This field is filled with the 
        address of the breakpoint when it is set by the debugger.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Typ</term>
      <listitem>
       <para>
        This always displays "breakpoint". It will be used
        in a future release supporting different kinds of breakpoints.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Bedingung</term>
      <listitem>
       <para>
        This is the breakpoint condition. It is empty if no condition is defined.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Pass count</term>
      <listitem>
       <para>
        When the debugger is not running, this column displays the pass count of the breakpoint,
        or zero if it is not defined.
       </para>
       <para>
        When the debugger is running, if the pass count is zero, this column displays
        the number of times this breakpoint has been triggered. If the pass count is not
        zero, both numbers are displayed. The pass count is the second number.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Status</term>
      <listitem>
       <para>
        This is the state of the breakpoint. It may be
        <itemizedlist>
         <listitem><para>Pending: the breakpoint is not set in your program.</para></listitem>
         <listitem><para>Permanent: the breakpoint is set (its id number in given inside parentheses).</para></listitem>
         <listitem><para>Temporary: the breakpoint is set but will be deleted if reached.</para></listitem>
        </itemizedlist>
       </para>
      </listitem>
     </varlistentry>
    </variablelist>
   </para>
   <note>
    <para>
     All breakpoints are kept across Anjuta sessions even if they correspond to
     a non-existing location. In this case their states are set as pending. The interface
     tries to set them each time the program is started or a new dynamic library is loaded. 
    </para>
   </note>
  </sect2>  

  <sect2 id="breaks-set">
   <title>Adding or Setting Breakpoints</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Add Breakpoint…</guimenuitem></menuchoice>
    or <menuchoice><guimenuitem>Add Breakpoint…</guimenuitem></menuchoice>
	in the breakpoint list popup menu to open the <interface>add breakpoint</interface> dialog.
   </para>
   <para>
    <figure>
      <title>Breakpoint add dialog</title>
      <screenshot>
	   <screeninfo>Breakpoint add dialog</screeninfo>
       <graphic fileref="figures/brk_add.png" format="PNG" srccredit="mkv"/>
      </screenshot>
    </figure>
   </para>
   <para>
    Enter the location and, optionally, the
    break condition and the pass count; then click <guibutton>OK</guibutton> to set the 
    breakpoint.
    <variablelist>
     <varlistentry>
      <term>Ort</term>
      <listitem>
       <para>
        Enter the location at which to set the breakpoint. It can be specified in any of
        the following formats:
       </para>
       <para>
        <orderedlist>
         <listitem><para>Dateiname:Zeilennummer</para></listitem>
         <listitem><para>Funktionsname</para></listitem>
         <listitem><para>Datei:Funktionsname</para></listitem>
        </orderedlist>
       </para>
       <para>
        The first format is obvious — the location refers to the line number 
        <emphasis>Line_number</emphasis> in the source file <emphasis>File</emphasis>. 
        The second format refers to the first line of the function 
        <emphasis>Function_name</emphasis>. The third is similar to the second, except that 
        this notation is used where there is more than one function with the name 
        <emphasis>Function_name</emphasis> in the program. It is possible to 
        differentiate between them by providing the <emphasis>File</emphasis>, so the 
        notation refers to the function <emphasis>Function_name</emphasis> in the 
        file <emphasis>File</emphasis>.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Bedingung</term>
      <listitem>
       <para>
        The <emphasis>Condition</emphasis> parameter displays a associated expression
        which should evaluate to a Boolean value — that is, the 
        evaluation of the expression should result in either TRUE(1) or FALSE(0). 
        If the final evaluation value is not a Boolean value, then it will be 
        appropriately type cast to a Boolean.
       </para>
       <para>
        Every time the breakpoint is encountered during your program's execution, the break 
        condition will be evaluated. The debugger will break the execution only if 
        the evaluation results in a TRUE value, otherwise it will continue the 
        execution as though there had been no breakpoint.
       </para>
       <para>
        The default value, if you leave this field blank, of <emphasis>Condition</emphasis>
        is TRUE. The debugger will always break the execution at the breakpoint location.
       </para>
      </listitem>
     </varlistentry>
     <varlistentry>
      <term>Pass Count</term>
      <listitem>
       <para>
        The <emphasis>Pass count</emphasis> is an integer (unsigned) value which 
        tells the debugger to skip the breakpoint that number of times before it 
        is considered. <emphasis>Pass count</emphasis> has a higher priority than 
        the <emphasis>Break condition</emphasis>. Only when the 
        <emphasis>Pass count</emphasis> reaches zero will the debugger evaluate the 
        <emphasis>Break condition</emphasis> (if any condition is present). If there 
        is no condition, the debugger will break the execution once the 
        <emphasis>Pass count</emphasis> counts down to zero.
       </para>
       <para>
        The default value, if you leave this field blank, of the <emphasis>Pass count</emphasis>
        is zero. The breakpoint will be considered when it is first encountered.
       </para>
      </listitem>
     </varlistentry>
    </variablelist>
   </para>
   <para>
    A breakpoint may also be set by selecting a line in the editor
    and choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Toggle Breakpoint</guimenuitem></menuchoice> in the editor context
	menu
        or the <guibutton>Toggle Breakpoint</guibutton> icon in the 
	<interface>Debug toolbar</interface>.
   </para>
   <tip>
    <para>
     Breakpoints can be added even if the debugger is not started, or in a dynamic
     library which is not loaded yet. But they cannot be added while a program is running
     under control of the debugger.
    </para>
   </tip>
  </sect2>
  
  <sect2 id="breaks-edit">
   <title>Editing Breakpoints</title>
   <para>
    You can change the condition and the pass count by
    selecting the breakpoint in the breakpoint list and clicking <menuchoice><guimenuitem>Edit Breakpoint</guimenuitem></menuchoice>
    in the popup menu.
   </para>
   <para>
    Edit the entries as required and click on <guibutton>OK</guibutton> to
    commit the changes.
   </para>
  </sect2>

  <sect2 id="breaks-del">
   <title>Deleting Breakpoints</title>
   <para>
    Select the breakpoint in the breakpoint list view and click on
    <menuchoice><guimenuitem>Remove Breakpoint</guimenuitem></menuchoice> to delete it.
   </para>
   <para>
    A existing breakpoint may also be deleted by selecting its line in the editor
    and choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Toggle Breakpoint</guimenuitem></menuchoice>,
    the editor context menu item
	<menuchoice><guimenuitem>Toggle Breakpoint</guimenuitem></menuchoice>
    or the <guibutton>Toggle Breakpoint</guibutton> icon in the 
	<interface>Debug toolbar</interface>.
   </para>
   <para>
    You can remove all breakpoints by clicking on <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Remove All Breakpoints</guimenuitem></menuchoice> or on
    <menuchoice><guimenuitem>Remove All Breakpoints</guimenuitem></menuchoice> in
    the breakpoint list context menu.
   </para>
  </sect2>

  <sect2 id="breaks-enbdis">
   <title>Enabling or Disabling Breakpoints</title>
   <para>
    Click on the Enable column of the <interface>Breakpoint list window</interface> or
    in the context menu item <menuchoice><guimenuitem>Enable Breakpoint</guimenuitem></menuchoice>
    to enable or disable the selected breakpoint. 
	The breakpoint will be enabled or disabled, depending on its current state.
   </para>
   <para>
    To disable all breakpoints, click on <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Disable All Breakpoints</guimenuitem></menuchoice> or on
    <menuchoice><guimenuitem>Disable All Breakpoints</guimenuitem></menuchoice> in
    the breakpoint list context menu.
   </para>
  </sect2>
 </sect1>

<!-- ============= Debugging: Expressions ====================== -->
 <sect1 id="debugging-expr">
  <title>Ausdrücke</title>

  <sect2 id="var-local">
   <title>Auflisten lokaler Variablen</title>
   <para>
    When a program is running under the control of the debugger, the 
    <interface>Locals list window</interface> can be opened by 
    choosing <menuchoice><guisubmenu>View</guisubmenu>
    <guimenuitem>Locals</guimenuitem></menuchoice>.
   </para>
   <para>
    Local variables of the current frame (the current function in which the program control
    is present) are displayed in the <interface>Locals window</interface>.
    During execution of the program (e.g. during single stepping), local
    variables will be updated. If any variable value was changed in the last debugging step, its
    value will be highlighted in red. Variables are presented in a tree form for easy
    view.
    <figure>
      <title>Lokale Variablen</title>
      <screenshot>
	  <screeninfo>Lokale Variablen</screeninfo>
       <graphic fileref="figures/local_variables.png" format="PNG" srccredit="naba"/>
      </screenshot>
    </figure>
   </para>
   <para>
    The value of a local variable can be modified by selecting it and clicking in
    the <guilabel>Value</guilabel> column.
   </para>
   <note>
    <para>
     <application>gdb</application> is more and more often used as a back end for a graphical front end. It
     has been improved recently in this area. It is recommended that you use the latest
     version (6.6) of gdb. With older versions, gdb can crash when the front end
     asks for an pointer with an invalid (but unused) value.
    </para>
   </note>
  </sect2>

  <sect2 id="var-watch">
   <title>Listing watched expressions</title>
   <para>
    Inspecting or evaluating an expression provides the result only once. To continuously 
	monitor some variables or expressions, use <emphasis>expression watches</emphasis>.
   </para>
   <para>
	   Choose the menu item <menuchoice><guisubmenu>View</guisubmenu><guimenuitem>Watches</guimenuitem>
	   </menuchoice> to display the <interface>Watches window</interface>.
   </para>
  </sect2>

  <sect2 id="watch-add">
   <title>Adding an expression to watch</title>
   <para>
    Right-click on the <interface>Watches window</interface>
    to open the context menu. Choose the 
	menu item <guimenuitem>Add Watch…</guimenuitem>. Alternatively, you can
    use <menuchoice><guisubmenu>Debug</guisubmenu>
	<guimenuitem>Add Watch…</guimenuitem></menuchoice>
    A dialog prompting for the expression will appear. Enter the expression and 
    click <guibutton>OK</guibutton>.
   </para>
   <para>
    By default watch expressions are updated automatically 
    each time the program is stopped. This can be changed in the add watch dialog
    or later using the <guimenuitem>Automatic update</guimenuitem> menu item in the
    <interface>Watches window</interface> context menu. A watched expression
    can be updated manually by choosing
    <guimenuitem>Update Watch</guimenuitem> or <guimenuitem>Update All</guimenuitem> in
    the context menu.
   </para>
   <para>
    It is not necessary to have the debugger running to add a new watch expression.
    If the debugger is not running or the corresponding expression cannot be found, 
    the front end will try to create the watch expression each time the program
    is stopped.
   </para>
  </sect2>

  <sect2 id="watch-remove">
   <title>Removing a watched expression</title>
   <para>
    Right-click the watch expression that you want to remove in the <interface>Watches 
	window</interface>, then choose the context
	menu item <guimenuitem>Remove</guimenuitem> to remove it.
   </para>
   <para>
    All watches can be removed by choosing <guimenuitem>Remove All</guimenuitem> in the
    context menu of the <interface>Watches window</interface>.
   </para>
  </sect2>

  <sect2 id="expr-eval">
   <title>Evaluating expressions</title>
   <para>
    When control is returned from a program — possibly at a breakpoint — 
	it is possible to evaluate expressions or inspect the values of variables in the 
	program. Choose the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
    <guimenuitem>Inspect/Evaluate …</guimenuitem></menuchoice>, 
    <menuchoice><guimenuitem>Inspect/Evaluate …</guimenuitem></menuchoice>
    in the context menu of the editor or click 
	the <guibutton>Inspect</guibutton> button on the <interface>Debug Toolbar</interface>. 
   </para>
   <para>
	   A window will appear showing the evaluation of the expression
	   highlighted in the editor.
	   You can evaluate a new expression by clicking on the <guilabel>name</guilabel> column
	   and entering the new one.
   </para>
   <para>
    You can add the expression to the list of watched expressions directly by 
    clicking on the <guibutton>Add</guibutton> button. 
   </para>
  </sect2>

  <sect2 id="expr-hiver">
   <title>Inspecting expressions in editor window</title>
   <para>
    When the debugger is active with the program stopped, you can get the value of an
    expression just by putting the mouse pointer over it and staying there for a short time.
    If the expression is already present in the <interface>Locals</interface> or <interface>Watches</interface> window, its value is
    displayed in a tooltip.
   </para>
   <para>
    This capability is currently working only for simple variables, not for structures or arrays.
   </para>
  </sect2>

 </sect1>

<!-- ============= Debugging: Program Stack ====================== -->
 <sect1 id="debugging-stack">
  <title>Stacktrace</title>

  <sect2 id="stack-win">
   <title>Stack-Fenster</title>
   <para>
    The <interface>stack trace window</interface> shows the contents of the 
	program stack. It lists all functions and their arguments in the 
	sequence they were called. There is also a number representing each call. 
	This number is called the <emphasis>frame</emphasis>. Each call in the trace 
	exists in a different frame. This starts from frame 0 (the last function
    called) and grows higher as function nesting becomes deeper.
   </para>
   <para>
	   Choose the menu item <menuchoice><guisubmenu>View
	   </guisubmenu><guimenuitem>Stack</guimenuitem></menuchoice> to open the stack trace for the program 
	being debugged.
   </para>
   <para>
    <figure>
      <title>Stack trace window</title>
      <screenshot>
	   <screeninfo>Stack trace window</screeninfo>
       <graphic fileref="figures/stack.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>
    A small arrow points to the currently selected frame in the stack trace. By 
	default, this will be frame 0, the last function called. All evaluation 
	and inspection of expressions or variables will be with reference to this selected 
	frame. The scope of variables or expressions being evaluated will be limited 
	to the selected frame only. The same applies for new expressions only in the watch.
   </para>
  </sect2>
  
  <sect2 id="stack-frame">
   <title>Setting the current frame</title>
   <para>
    Double-clicking on any frame in the stack trace sets that frame as the 
	currently selected frame.  The arrow will point to the frame, indicating that it 
	has been selected as the current frame. Alternatively, open the 
	context menu by right-clicking on the 
	<interface>Stack trace window</interface>, and choose the menu item 
	<guimenuitem>Set current frame</guimenuitem> to set the frame.
   </para>
   <para>
    Changing the stack frame changes the <interface>Locals window</interface>
    content, but not the <interface>Watches window</interface> as each
    expression is evaluated in the frame used when it was defined.
   </para>
  </sect2>
 </sect1>

<!-- ============= Debugging: Program Thread ====================== -->
 <sect1 id="debugging-thread">
  <title>Thread</title>

  <sect2 id="thread-win">
   <title>Thread-Fenster</title>
   <para>
    The <interface>Thread window</interface> shows all threads used by the program
    and indicates the current thread. Choose the menu item <menuchoice><guisubmenu>View</guisubmenu>
    <guimenuitem>Thread</guimenuitem></menuchoice> to open this window.
   </para>
   <para>
    A small arrow points to the current thread. When the
    program is stopped, the current thread is the thread which has been interrupted.
    Each thread has its own stack frame, so changing the current thread changes
    the current stack frame. 
   </para>
  </sect2>

  <sect2 id="set-thread">
   <title>Setting the current thread</title>
   <para>
    Double-clicking on any thread in the thread list will set that thread as the 
	currently selected thread. The arrow will point to the thread, indicating that it 
	has been selected as the current thread. Alternatively, open the 
	context menu by right-clicking on the 
	<interface>Thread list window</interface>, and choose the menu item 
	<guimenuitem>Set current thread</guimenuitem> to set the thread.
   </para>
   <para>
    Changing the thread changes the value of CPU registers and the current
    stack frame, so the <interface>Locals window</interface> changes too.
   </para>
  </sect2>
 </sect1>

<!-- ============= Debugging: CPU ====================== -->
 <sect1 id="debugging-cpu">
  <title>CPU</title>

  <sect2 id="cpu-regs">
   <title>Register window</title>
   <para>
    It is possible to examine the contents of the internal registers of the 
	CPU (microprocessor). Choose the menu item <menuchoice><guisubmenu>View</guisubmenu>
	<guimenuitem>Registers</guimenuitem></menuchoice>. A window listing all 
	available registers in the microprocessor and their corresponding contents 
	will appear.
   </para>
   <para>
    If any register value was changed in the last debugging step, its
    value will be highlighted in red. It is possible to change one register value
    by selecting it and clicking in the <guilabel>value</guilabel> column.    
   </para>
  </sect2>

  <sect2 id="cpu-memory">
   <title>Memory window</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>View</guisubmenu><guimenuitem>Memory 
	</guimenuitem></menuchoice> to open the <interface>memory window</interface>
    for the program being debugged. This window shows the contents of all memory. 
   </para>
   <para>
    The first column displays memory addresses in hexadecimal, the second displays memory contents
    in hexadecimal and the last column shows memory contents in ASCII.
   </para>
   <para>
    The addressing space of even a 32-bit microprocessor is quite large (4 gigabytes),
    so it is very difficult to go to a particular address with the scrollbar. But
    you can click on the right mouse button to display a context menu and select
    <menuchoice><guimenuitem>Goto address</guimenuitem></menuchoice> to get
    a small edit box where you can enter an address in hexadecimal.
   </para>
  </sect2>

  <sect2 id="cpu-disassembly">
   <title>Disassembly window</title>
   <para>
    Choose the menu item <menuchoice><guisubmenu>View</guisubmenu><guimenuitem>Disassembly
	</guimenuitem></menuchoice> to open the <interface>disassembly window</interface>
    for the program being debugged.
   </para>
   <para>
    The first column displays addresses in hexadecimal. In the second column, you can
    have a label starting at the beginning of the line and ending with a colon or
    a assembly-language instruction indented by 4 space characters.
   </para>
   <para>
    Again, as the addressing space is very large, the scrollbar is quite useless.
    You can click on the right mouse button to display the context menu and select
    <menuchoice><guimenuitem>Goto address</guimenuitem></menuchoice> to get
    a small edit box where you can enter an address in hexadecimal. The position
    in the disassembly window will be changed to the program counter value when
    the program is stopped.
   </para>
  </sect2>
 </sect1>

<!-- Debugger: Others-->
 <sect1 id="debugger-others">
  <title>Sonstige</title>

  <para>
   There are a number of other debugger features used less frequently and not
   very well integrated in the new front end but which are still working.
  </para>

  <sect2 id="dbg-dyna-libs">
   <title>Dynamisch geladene Bibliotheken</title>
   <para>
    To obtain a list of the dynamic libraries used by a program, choose the 
	menu item <menuchoice><guisubmenu>Debug</guisubmenu><guisubmenu>Info</guisubmenu>
	<guimenuitem>Shared Libraries</guimenuitem></menuchoice>. This will bring 
	open a window which will list all shared libraries the program has loaded 
	and their locations in memory. It also shows whether each library's symbol table is 
	loaded or not (Yes/No).
   </para>
   <para>
    <figure>
      <title>Shared Libraries window</title>
      <screenshot>
	   <screeninfo>Shared Libraries window</screeninfo>
       <graphic fileref="figures/sharedlibs.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
  </sect2>

  <sect2 id="dbg-signal">
   <title>Kernelsignale</title>
   <para>
    Kernel signals are a way of signaling between processes in Linux. The list 
	of signals available for a program can be displayed by choosing the menu item
    <menuchoice><guisubmenu>Debug</guisubmenu><guisubmenu>Info</guisubmenu><guimenuitem>Kernel Signals</guimenuitem></menuchoice>.
    A window will open which lists all signals available in the system along with
    a brief description of each signal.
   </para>
   <para>
    <figure>
      <title>Kernelsignale-Fenster</title>
      <screenshot>
	   <screeninfo>Kernelsignale-Fenster</screeninfo>
       <graphic fileref="figures/signals.png" format="PNG" srccredit="andyp"/>
      </screenshot>
    </figure>
   </para>
   <para>
    There are three columns which specify what to do when a signal is received:
   </para>
   
   <orderedlist>
    <listitem>
     <para><emphasis>Stop</emphasis> — this tells the debugger whether to 
	 stop the program execution (and return control) when the program receives 
	 this signal.
     </para>
    </listitem>
    <listitem>
     <para><emphasis>Print</emphasis> — this tells the debugger whether to 
	 display the received signal.
     </para>
    </listitem>
    <listitem>
     <para><emphasis>Pass</emphasis> — this tells the debugger whether to pass 
	 the signal to the program.
     </para>
    </listitem>
   </orderedlist>
   <note>
    <para>
     The context menu that is displayed when you click on the right mouse button has
     all its items disabled because the corresponding functions are not implemented
     yet.
    </para>
   </note>
  </sect2>

  <sect2 id="dbg-files">
   <title>Informationen über benutzte Dateien</title>
   <para>
    You can get some information about the files used by the debugged program
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Target files</guimenuitem></menuchoice>. 
	A window will open displaying this information.
   </para>
  </sect2>

  <sect2 id="dbg-program">
   <title>Information about debugged program</title>
   <para>
    You can get some information about the debugged program
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Program</guimenuitem></menuchoice>. 
	A window will open displaying this information.
   </para>
  </sect2>
 
  <sect2 id="dbg-kernel">
   <title>Informationen über die Kernelstruktur</title>
   <para>
    You can get some information about kernel data for the current process
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Kernel user struct</guimenuitem></menuchoice>. 
	A window will open displaying this information.
   </para>
  </sect2>

  <sect2 id="var-global">
   <title>Informationen über globale Variablen</title>
   <para>
    You can list all global variables
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Info Global Variable</guimenuitem></menuchoice>. 
	A window will open listing all global variables.
   </para>
  </sect2>

  <sect2 id="stack-frame-info">
   <title>Information about the current frame</title>
   <para>
    You can obtain information about the currently selected frame 
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Info Current Frame</guimenuitem></menuchoice>. 
	A window will open describing the current frame.
   </para>
  </sect2>

  <sect2 id="stack-arg-info">
   <title>Informationen über die aktuellen Funktionsargumente</title>
   <para>
    You can obtain information about the arguments of the current function 
	by choosing the menu item <menuchoice><guisubmenu>Debug</guisubmenu>
	<guisubmenu>Information</guisubmenu><guimenuitem>Arguments</guimenuitem></menuchoice>. 
	A window will open describing the arguments.
   </para>
  </sect2>
  
  <sect2 id="dbg-command">
   <title>Benutzerbefehl</title>
   <para>
    To send directly a command to the back end choose the
	menu item <menuchoice><guimenu>Debug</guimenu>
	<guimenuitem>Debugger command</guimenuitem></menuchoice>. This will bring
    a small dialog where you can enter commands that will be send to the debugger
    when you press <keycap>Return</keycap>.
   </para>
   <note>
    <para>
     The front end sends this command directly to the back end without performing any checks.
     By example if you set a breakpoint like this, it will not appear in the
     <interface>breakpoint list window</interface>. It is better to avoid using this
     command unless you know exactly what you are doing.
    </para>
   </note>
  </sect2>
 </sect1> 

 </chapter>

 <!-- Glade Interface Designer -->
 <chapter id="glade">
	<title>Glade Oberflächenentwicklung</title>

	<sect1>
		<title>Schnellstart</title>
		<para>
			If you don't want to read all this boring manual, here is few steps to
			get all things ready for use:
			<orderedlist>
				<listitem><para>
					You should have a project containing Glade file opened;
				</para></listitem>
				<listitem><para>
					Unlike original Glade designer, Anjuta plugin uses double click
					for creating handlers for default signal. You can perform a click
					on widgets (e.g. switch current tab in a GtkNotebook)
					by keeping "Windows" or "Super" key pressed;
				</para></listitem>
				<listitem><para>
					Open
					<menuchoice><guimenuitem>Preferences</guimenuitem>
					<guimenuitem>Glade GUI Designer</guimenuitem></menuchoice>
					and check the three topmost flags
					<guilabel>Insert handler on edit</guilabel>,
					<guilabel>Separated designer layout</guilabel>
					and <guilabel>Automatically add resources</guilabel>;
				</para></listitem>
				<listitem><para>
					Check
					<menuchoice>
						<guimenuitem>View</guimenuitem>
						<guimenuitem>Designer</guimenuitem>
					</menuchoice>
					flag and move this window to a better place;
				</para></listitem>
				<listitem><para>
					Switch to a Glade file in the design area and to the source code file that
					should contain callbacks for the Glade file, then press
					<menuchoice><guimenuitem>Glade</guimenuitem>
					<guimenuitem>Associate last designer and editor</guimenuitem></menuchoice>;
				</para></listitem>
				<listitem><para>
					Optionally select a target for image and other resources in the
					project manager and press <guilabel>Set as default resource target</guilabel>
					in the context menu.
				</para></listitem>
			</orderedlist>
		</para>
	</sect1>
	
	<sect1>
		<title>Allgemeine Fragen zur Benutzung von Glade</title>
		<para>
			Glade plugin mostly copies functionality of standalone Glade
			designer, but there are some special features. The four windows of
			the Glade desinger are design area, palette, widgets inspector and
			property editor. They have the same purpose as in the standalone
			designer, so please consult
			<ulink type="help" url="ghelp:glade">Glade Interface Designer Manual</ulink>
			for their description. An extra functionality allows you to
			use infrastructure of Anjuta more effectively and is described here.
		</para>
	</sect1>

	<sect1>
		<title>Editor and designer association</title>
		<para>
			You can associate text editor and Glade designer so you will easily
			switch between them and automatically insert handler stubs for
			newly entered handlers. You can associate more then one editor to
			a designer. The most recent editor or associated with the current
			toplevel widget will be used.
			There are two ways of associating editor and designer.
			The first way is using associations dialog. The second way is to
			choose designer and editor document in any order and then press
			<menuchoice><guimenuitem>Glade</guimenuitem>
			<guimenuitem>Associate last designer and editor</guimenuitem></menuchoice>
			menu item.
		</para>
	</sect1>

	<sect1>
		<title>Associations dialog</title>
		<para>
			Allows you to create and manager associations. To create an
			association select designer and editor in the comboboxes and press
			<guibutton>Associate</guibutton>. You can also select the document by
			switching to it in document manager or windows list in the main menu.
			The list in the middle of the dialog shows existing associations.
			A couple of controls below are intended for editing association properties.
			Here is their description:
			<variablelist>
				<varlistentry>
					<term><guilabel>Spec regexp</guilabel></term>
					<listitem><para>
						Shortened from "special regular expression". Used for defining
						a custom position for inserting stubs.
					</para></listitem>
				</varlistentry>
				<varlistentry>
					<term><guilabel>Widget-Name</guilabel></term>
					<listitem><para>
							The name of the toplevel widget this assoctiation belongs to.
					</para></listitem>
				</varlistentry>
				<varlistentry id="glade-position-type">
					<term><guilabel>Position type</guilabel></term>
					<listitem><para>
						Describes a position at which a handler stub will be inserted.
						<guilabel>After begin</guilabel> means after special mark
						(which may be entered in the <guilabel>Spec regexp</guilabel> entry)
						and <guilabel>before end</guilabel> means before special end mark.
						Default begin mark is /* window_name callbacks */ and default end
						mark is /* end of window_name callbacks */. window_name may be ommited.
					</para></listitem>
				</varlistentry>
			</variablelist>
		</para>
	</sect1>
	
	<sect1 id="glade-default-signal">
		<title>Vorgegebenes Signal</title>
		<para>
			Double click on a widget in the design area will create a new handler
			for default signal using a predefined template for its naming.
			For example, the default signal is "clicked" for button, "toggled" for
			check box, etc.
			If <guilabel>Insert handler on edit</guilabel> option is enabled then a new handler stub will be inserted to the position
			which depends on <guilabel>Position type</guilabel> setting.
		</para>
	</sect1>
	
	<sect1>
		<title>Inserting a stub</title>
		<para>
			One of the most valuable goal of <application>Anjuta</application> and
			<application>Glade</application> integration is automatical creating of
			handler stubs, so you will not need to do a lot of routine work for that,
			it will be done automatically.
		</para>
		<para>
			There are several ways to create a stub:
			<itemizedlist>
				<listitem><para>
						Automatically if <guilabel>Insert handler on edit</guilabel> option
						if enabled
					</para></listitem>
				<listitem><para>
						Using
						<menuchoice><guimenuitem>Glade</guimenuitem>
						<guimenuitem>Insert handler stub, autoposition</guimenuitem></menuchoice>
						in hte main menu
					</para></listitem>
				<listitem><para>
						Using <guilabel>Insert handler stub</guilabel> item in the context
						menu of text document
					</para></listitem>
			</itemizedlist>
		</para>
	</sect1>

	<sect1>
		<title>Einstellungen</title>
		<variablelist>
			<varlistentry>
				<term><guilabel>Insert handler on edit</guilabel></term>
				<listitem><para>
					Enables inserting a handler stub into the associated editor after
					entering a new handler into signal editor or creating a
					<link linkend="glade-default-signal">default signal handler</link>
				</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Separated designer layout</guilabel></term>
				<listitem><para>
						Detaches the design area from document manager so you can dock it
						separately from text editors.
					</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Automatisch Ressourcen hinzufügen</guilabel></term>
				<listitem><para>
					When checked then all resources (e.g. images) will be added to
					the target in the current project. You can choose the target
					using project manager context menu or by entering target id in
					the entry below the check button.
				</para></listitem>
			</varlistentry>
			<varlistentry>
				<term><guilabel>Vorlage für Handler</guilabel></term>
				<listitem><para>
						You can choose between the two formats of automatic naming of
						signal handler.
				</para></listitem>
			</varlistentry>
		</variablelist>
	</sect1>

</chapter>

 <!-- Preferences -->
 <!-- Preferences -->
 <chapter id="preferences">
  <title>Einstellungen</title>
  <para>
   Preferences are ways to customize <application>Anjuta</application> to suit
   your tastes. Activate <menuchoice><guimenu>Edit</guimenu><guimenuitem>Preferences</guimenuitem>
   </menuchoice> to bring up the preferences dialog. Some preferences are explained below.
  </para>
  <sect1 id="prefs-general"><title>Allgemein</title>
    <orderedlist>
     <listitem><para>
      <emphasis>Project Directory</emphasis> is the path where you plan to put all your projects.
      The application wizard creates new projects in this directory only. The default project directory
      is ~/Projects and generally this is fine for most people.
      </para>
     </listitem>
      <listitem><para>
       <emphasis>User Info:</emphasis> Provide your name and email address here. These are not
       used to do software registration; rather, they are used to create ChangeLog entries and other
       text insertions.</para>
      </listitem>
     </orderedlist>
    </sect1>
    <sect1 id="prefs-files"><title>Dateimanager</title>
    <orderedlist>
     <listitem><para>
      <emphasis>Root directory if no project is open</emphasis> is the path where
      the root of the file manager points if no project is currently open.
      </para>
     </listitem>
      <listitem><para>
       <emphasis>File Filter:</emphasis> You can filter out some files from the file tree, for example,
       hidden files, or files that are ignored by the version control system which usually means they are
       generated at build time and should not be changed.
       </para>
      </listitem>
     </orderedlist>
    </sect1>
 </chapter>

 <!-- Tools -->
 <!-- new chapter -->
 <chapter id="tools">
  <title>Benutzerdefinierte Werkzeuge</title>

  <sect1 id="tools-intro">
  <title>Einführung</title>
  <para>
  You'll sometimes find the built-in functionality provided by Anjuta to be
  insufficient. In these cases, you might be tempted to either add the
  feature yourself to the Anjuta codebase or submit a feature request to
  implement the feature. However, both approaches are likely to be slow
  and problematic, especially if your tool is a specialized one. In these
  circumstances, it is advisable to use the Anjuta tools framework instead.
  </para>

  <para>
  Anjuta provides a powerful framework for defining user-defined tools for
  extending its functionality. Tools have access to almost all features of
  the IDE through the use of variables. You can add tools under any menu item,
  specify input, output and error redirection within the GUI framework and
  supply command-line parameters to the tool.
  </para>
	<note>
	<para>Das Werkzeug-Plugin muss aktiviert sein, um diese Funktion nutzen zu können.</para>
	</note>
  </sect1>

  <sect1 id="tools-example">
  <title>Werkzeug-Beispiele</title>
  <para>Das ist ein einfaches Beispiel, wie man das Werkzeug-Plugin verwenden kann, um das Generierungsskript für GNOME-Änderungsprotokolle einzubauen.</para>

  <figure id="tool-list">
    <title>Der Werkzeugeditor</title>
    <screenshot>
	<screeninfo>Der Werkzeugeditor</screeninfo>
     <graphic fileref="figures/tool-editor.png" format="PNG" srccredit="jhs"/>
    </screenshot>
   </figure>

  </sect1>

</chapter>

 <!-- Authors -->
  <chapter id="authors">
  <title>Autoren</title>
   <para>Das <application>Anjuta</application>-Projekt wurde von Naba Kumar begründet. Auf <ulink type="http" url="http://anjuta.org/credits">dieser Seite</ulink> finden Sie alle Anjuta-Mitwirkenden.</para>

   <para>Besuchen sie die Projekt Internet-Seite <ulink type="http" url="http://anjuta.org/">http://anjuta.org</ulink> für weitere Informationen zu <application>Anjuta</application>. Fehler sollten im Fehlererfassungssystem auf der Entwicklungsseite zum Projekt <ulink type="http" url="http://www.sourceforge.net/projects/anjuta"> http://www.sourceforge.net/projects/anjuta</ulink> gemeldet werden.</para>
   
   <para>Dieses Handbuch wurde von Naba Kumar, Andy Piper, Biswapesh Chattopadhyay und Johannes Schmid geschrieben. Bitte senden Sie alle Vorschläge und Kommentare, die dieses Handbuch betreffen, an die Anjuta Devel-Mailing-Liste <email>anjuta-devel-list@gnome.org</email>. Es können auch Kommentare auf der Projektseite auf SourceForge abgegeben werden.</para> 
</chapter>


 <!-- License -->
 <chapter id="license">
  <title>Lizenz</title>
   <para>Dieses Programm ist freie Software; Sie können es weiterverbreiten und/oder ändern unter den Bedingungen der <citetitle><ulink type="help" url="gnome-help:gpl">GNU General Public License</ulink></citetitle> wie sie von der <ulink type="http" url="http://www.fsf.org">Free Software Foundation</ulink> veröffentlicht wurde; entweder in Version 2 der Lizenz oder (nach Ihrer Wahl) jeder neueren Version.</para>
   <para>Die Veröffentlichung dieses Programms erfolgt in der Hoffnung, dass es Ihnen von Nutzen sein wird, aber OHNE IRGENDEINE GARANTIE, sogar ohne die implizite Garantie der MARKTREIFE oder der VERWENDBARKEIT FÜR EINEN BESTIMMTEN ZWECK. Details finden Sie in der <citetitle>GNU General Public License</citetitle>.</para>
   <para>Eine Kopie der <citetitle><ulink type="help" url="gnome-help:gpl">GNU General Public License</ulink></citetitle> ist im Anhang des <citetitle>GNOME Benutzerhandbuchs</citetitle> enthalten. Sie können außerdem eine Kopie der <citetitle><ulink type="help" url="gnome-help:gpl">GNU General Public License</ulink></citetitle> von der Free Software Foundation erhalten, indem Sie auf <ulink type="http" url="http://www.fsf.org">ihre Internetseite</ulink> gehen oder an die <address>Free Software Foundation, Inc.<street>51 Franklin Street, Fifth Floor</street><city>Boston</city>, <state>MA</state><postcode>02111-1301</postcode><country>USA</country></address> schreiben.</para>
</chapter>

</book>
