Beautify docbook files

8 files changed, 380 insertions, 1171 deletions

diff --git a/tde-i18n-de/docs/tdesdk/umbrello/authors.docbook b/tde-i18n-de/docs/tdesdk/umbrello/authors.docbook
index 5c39151e95a..344bc28b150 100644
--- a/tde-i18n-de/docs/tdesdk/umbrello/authors.docbook
+++ b/tde-i18n-de/docs/tdesdk/umbrello/authors.docbook
@@ -1,44 +1,15 @@
 <chapter id="authors">
-<title
->Autoren und Geschichte</title>
-<para
->Dieses Projekt wurde von Paul Hensgen als eines seiner Universitätsprojekte initiiert. Der Originalname des Projektes lautete <application
->UML Modeller </application
->. Paul hatte die Entwicklung bis Ende 2001, als die Version 1.0 erschien, vorangetrieben. </para>
-<para
->Version 1.0 bot schon eine Vielzahl von Funktionen. Nachdem Paul bei seiner Universität die Arbeit eingereicht hatte, konnten andere Entwickler dem Projekt beitreten, um es weiter zu verbessern. So wurde das ursprünglich binäre Dateiformat zugunsten von &XML; Dateien fallengelassen, es wurde Unterstützung für weitere &UML; Diagramme hinzugefügt, genauso wie die Quelltexterzeugung und das Einlesen von Quelltext, um nur ein  paar wenige Verbesserungen zu nennen. </para>
-<para
->Paul musste sich im Sommer 2002 aus dem Entwicklungsteam leider zurückziehen, aber das Programm lebt weiter und entwickelt sich, wie andere Open Source Software. Es wird heute von einer Gruppe von Entwicklern von überall aus der Welt gepflegt. Im September 2002 wurde der Projektname von <application
->&UML; Modeller</application
-> in &umbrello; geändert. Dafür gab es gute Gründe, z.B. war <quote
->uml</quote
-> &mdash; wie es allgemein genannt wurde &mdash; zu allgemein und es gab deswegen Probleme mit einigen Distributionen. Und außerdem sind die Entwickler der Meinung, dass <application
->Umbrello </application
-> ein viel coolerer Name ist. </para>
-<para
->&umbrello;s Entwicklung, genauso wie die Diskussion wo in zukünftigen Versionen die Schwerpunkte liegen sollen, ist offen und wird über das Internet geführt. Falls sie zu dem Projekt beitragen wollen, zögern sie nicht die Entwickler zu kontaktieren! Es gibt viele Möglichkeiten, wie man zu &umbrello; beitragen kann: </para>
+<title>Autoren und Geschichte</title>
+<para>Dieses Projekt wurde von Paul Hensgen als eines seiner Universitätsprojekte initiiert. Der Originalname des Projektes lautete <application>UML Modeller </application>. Paul hatte die Entwicklung bis Ende 2001, als die Version 1.0 erschien, vorangetrieben. </para>
+<para>Version 1.0 bot schon eine Vielzahl von Funktionen. Nachdem Paul bei seiner Universität die Arbeit eingereicht hatte, konnten andere Entwickler dem Projekt beitreten, um es weiter zu verbessern. So wurde das ursprünglich binäre Dateiformat zugunsten von &XML; Dateien fallengelassen, es wurde Unterstützung für weitere &UML; Diagramme hinzugefügt, genauso wie die Quelltexterzeugung und das Einlesen von Quelltext, um nur ein  paar wenige Verbesserungen zu nennen. </para>
+<para>Paul musste sich im Sommer 2002 aus dem Entwicklungsteam leider zurückziehen, aber das Programm lebt weiter und entwickelt sich, wie andere Open Source Software. Es wird heute von einer Gruppe von Entwicklern von überall aus der Welt gepflegt. Im September 2002 wurde der Projektname von <application>&UML; Modeller</application> in &umbrello; geändert. Dafür gab es gute Gründe, z.B. war <quote>uml</quote> &mdash; wie es allgemein genannt wurde &mdash; zu allgemein und es gab deswegen Probleme mit einigen Distributionen. Und außerdem sind die Entwickler der Meinung, dass <application>Umbrello </application> ein viel coolerer Name ist. </para>
+<para>&umbrello;s Entwicklung, genauso wie die Diskussion wo in zukünftigen Versionen die Schwerpunkte liegen sollen, ist offen und wird über das Internet geführt. Falls sie zu dem Projekt beitragen wollen, zögern sie nicht die Entwickler zu kontaktieren! Es gibt viele Möglichkeiten, wie man zu &umbrello; beitragen kann: </para>
 <itemizedlist>
-<listitem
-><para
->Fehler berichten oder Vorschläge für Verbesserungen machen</para
-></listitem>
-<listitem
-><para
->Fehler beheben oder neue Funktionen hinzufügen</para
-></listitem>
-<listitem
-><para
->Eine gute Dokumentation schreiben oder Umbrello in eine andere Sprache übersetzen</para
-></listitem>
-<listitem
-><para
->Und natürlich mit uns programmieren!</para
-></listitem>
+<listitem><para>Fehler berichten oder Vorschläge für Verbesserungen machen</para></listitem>
+<listitem><para>Fehler beheben oder neue Funktionen hinzufügen</para></listitem>
+<listitem><para>Eine gute Dokumentation schreiben oder Umbrello in eine andere Sprache übersetzen</para></listitem>
+<listitem><para>Und natürlich mit uns programmieren!</para></listitem>
 </itemizedlist>
-<para
->Es ist ersichtlich, dass es viele Möglichkeiten gibt, zum Projekt beizutragen. Alle Aufgaben dabei sind gleichwichtig und jeder ist herzlich willkommen uns zu helfen. </para>
-<para
->Die Entwickler von &umbrello; sind per Email erreichbar unter: <email
->uml_devel@lists.sourceforge.net</email
->. </para>
+<para>Es ist ersichtlich, dass es viele Möglichkeiten gibt, zum Projekt beizutragen. Alle Aufgaben dabei sind gleichwichtig und jeder ist herzlich willkommen uns zu helfen. </para>
+<para>Die Entwickler von &umbrello; sind per Email erreichbar unter: <email>uml_devel@lists.sourceforge.net</email>. </para>
 </chapter>
diff --git a/tde-i18n-de/docs/tdesdk/umbrello/code_import_and_generation.docbook b/tde-i18n-de/docs/tdesdk/umbrello/code_import_and_generation.docbook
index 1ed89f5d58e..0aa61dc182f 100644
--- a/tde-i18n-de/docs/tdesdk/umbrello/code_import_and_generation.docbook
+++ b/tde-i18n-de/docs/tdesdk/umbrello/code_import_and_generation.docbook
@@ -1,163 +1,82 @@
 <chapter id="code-import-generation">
-<title
->Quelltextimport und Quelltexterzeugung</title>
-<para
->&umbrello; ist ein &UML; Modellierungswerkzeug und sein Schwerpunkt liegt deshalb auf der <emphasis
->Analyse und des Designs</emphasis
-> ihres Systems. Um den Übergang zwischen Design und <emphasis
->Implementierung</emphasis
-> zu erleichtern, kann &umbrello; Quelltext in verschiedenen Programmiersprachen erzeugen. Möchte man hingegen die &UML; in einem bereits existierendem C++ Projekt einsetzen, unterstützt &umbrello; einem bei der Erstellung eines Modells des vorhandenen Systems, indem es den Quelltext einliest und die gefundenen Klassen erstellt. </para>
+<title>Quelltextimport und Quelltexterzeugung</title>
+<para>&umbrello; ist ein &UML; Modellierungswerkzeug und sein Schwerpunkt liegt deshalb auf der <emphasis>Analyse und des Designs</emphasis> ihres Systems. Um den Übergang zwischen Design und <emphasis>Implementierung</emphasis> zu erleichtern, kann &umbrello; Quelltext in verschiedenen Programmiersprachen erzeugen. Möchte man hingegen die &UML; in einem bereits existierendem C++ Projekt einsetzen, unterstützt &umbrello; einem bei der Erstellung eines Modells des vorhandenen Systems, indem es den Quelltext einliest und die gefundenen Klassen erstellt. </para>
 <sect1 id="code-generation">
-<title
->Quelltexterzeugung</title>
-<para
->&umbrello; kann Quelltext in verschiedenen Programmiersprachen auf Basis ihres &UML; Modells erzeugen und hilft dabei einen Anfang für die Implementierung zu schaffen. Der erzeugte Quelltext besteht aus den Klassendeklarationen, den Methoden und den Attributen. Man muss diese Hüllen <quote
->lediglich ausfüllen</quote
->, um die Klassenoperationen mit Funktionalität zu füllen. </para>
-<para
->&umbrello; 1.2 bietet Quelltexterzeugung in ActionScript, Ada, C++, CORBA IDL, &Java;, JavaScript, <acronym
->PHP</acronym
->, Perl, Python, SQL und XMLSchema. </para>
+<title>Quelltexterzeugung</title>
+<para>&umbrello; kann Quelltext in verschiedenen Programmiersprachen auf Basis ihres &UML; Modells erzeugen und hilft dabei einen Anfang für die Implementierung zu schaffen. Der erzeugte Quelltext besteht aus den Klassendeklarationen, den Methoden und den Attributen. Man muss diese Hüllen <quote>lediglich ausfüllen</quote>, um die Klassenoperationen mit Funktionalität zu füllen. </para>
+<para>&umbrello; 1.2 bietet Quelltexterzeugung in ActionScript, Ada, C++, CORBA IDL, &Java;, JavaScript, <acronym>PHP</acronym>, Perl, Python, SQL und XMLSchema. </para>
 <sect2 id="generate-code">
-<title
->Quelltext erzeugen</title>
-<para
->Um Quelltext mit &umbrello; zu erzeugen, muss man zuerst ein Modell laden, das mindestens eine Klasse enthält. Wenn man Quelltext erzeugen will, muss man den <guimenuitem
->Assistent für die Erzeugung des Quelltextes ...</guimenuitem
-> aus dem <guimenuitem
->Quelltextmenu</guimenuitem
-> auswählen. Dadurch wird der Assistent gestartet, der dann durch den Prozess zur Quelltexterzeugung führt. </para>
-<para
->Im ersten Schritt muss man die Klassen auswählen, für die Quelltext erzeugt werden soll. Am Anfang sind alle Klassen des Modells ausgewählt und man kann nun einzelne entfernen. Dazu muss man sie aus der rechten Liste in die linke Liste verschieben. </para>
-<para
->Im folgenden Schritt des Assistenten kann man die Parameter des Quelltextgenerators verändern. Folgende Parameter sind verfügbar: </para>
+<title>Quelltext erzeugen</title>
+<para>Um Quelltext mit &umbrello; zu erzeugen, muss man zuerst ein Modell laden, das mindestens eine Klasse enthält. Wenn man Quelltext erzeugen will, muss man den <guimenuitem>Assistent für die Erzeugung des Quelltextes ...</guimenuitem> aus dem <guimenuitem>Quelltextmenu</guimenuitem> auswählen. Dadurch wird der Assistent gestartet, der dann durch den Prozess zur Quelltexterzeugung führt. </para>
+<para>Im ersten Schritt muss man die Klassen auswählen, für die Quelltext erzeugt werden soll. Am Anfang sind alle Klassen des Modells ausgewählt und man kann nun einzelne entfernen. Dazu muss man sie aus der rechten Liste in die linke Liste verschieben. </para>
+<para>Im folgenden Schritt des Assistenten kann man die Parameter des Quelltextgenerators verändern. Folgende Parameter sind verfügbar: </para>
 <para>
 <screenshot>
-<screeninfo
->Parameter Quelltexterzeugung</screeninfo>
+<screeninfo>Parameter Quelltexterzeugung</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="generation-options.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->Parameter für die Quelltexterzeugung in &umbrello;</phrase>
+	    <phrase>Parameter für die Quelltexterzeugung in &umbrello;</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->Parameter für die Quelltexterzeugung in &umbrello; </para>
+	    <para>Parameter für die Quelltexterzeugung in &umbrello; </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 </para>
 <sect3 id="generation-options">
-<title
->Generierungsoptionen</title>
+<title>Generierungsoptionen</title>
 <!-- LW; to rearrange -->
 
 <sect4>
-<title
->Dokumentation Quelltext</title>
-<para
->Der Parameter <guilabel
->Erzeugt Dokumentations-Kommentare, selbst wenn diese leer sind.</guilabel
-> weist den Quelltextgenerator an, Kommentare der Form /** bla */ einzufügen, selbst wenn diese leer sind. Hat man die Klassen, Methoden und Attribute im Modell dokumentiert, fügt die Quelltexterzeugung diese Kommentare im <application
->Doxygen</application
-> Format mit ein, egal was an dieser Stelle ausgewählt wurde. Ist dieser Parameter aktiviert, werden im Unterschied allerdings für alle Klassen, Methoden und Attribute Platzhalter eingefügt, selbst wenn diese nicht im Modell dokumentiert wurden. Man sollte diese dann direkt im Quelltext in den bereits vorhandenen Platzhaltern dokumentieren. </para>
-<para
-><guilabel
->Erzeugt Kommentare für Abschnitte, selbst wenn diese leer sind.</guilabel
->: &umbrello; schreibt Kommentare in den Quelltext um die verschiedenen Bereiche einer Klasse zu trennen. So würde zum Beispiel <quote
->public methods</quote
-> oder <quote
->Attributes</quote
-> vor den entsprechenden Abschnitten eingefügt werden. Wurde dieser Parameter aktiviert, wird für jeden Abschnitt ein entsprechendes Kommentar eingefügt, selbst dann, wenn der Abschnitt leer ist. So würde zum Beispiel das Kommentar <quote
->protected methods </quote
-> eingefügt werden, selbst wenn keine geschützten Methoden in der Klasse existieren. </para>
+<title>Dokumentation Quelltext</title>
+<para>Der Parameter <guilabel>Erzeugt Dokumentations-Kommentare, selbst wenn diese leer sind.</guilabel> weist den Quelltextgenerator an, Kommentare der Form /** bla */ einzufügen, selbst wenn diese leer sind. Hat man die Klassen, Methoden und Attribute im Modell dokumentiert, fügt die Quelltexterzeugung diese Kommentare im <application>Doxygen</application> Format mit ein, egal was an dieser Stelle ausgewählt wurde. Ist dieser Parameter aktiviert, werden im Unterschied allerdings für alle Klassen, Methoden und Attribute Platzhalter eingefügt, selbst wenn diese nicht im Modell dokumentiert wurden. Man sollte diese dann direkt im Quelltext in den bereits vorhandenen Platzhaltern dokumentieren. </para>
+<para><guilabel>Erzeugt Kommentare für Abschnitte, selbst wenn diese leer sind.</guilabel>: &umbrello; schreibt Kommentare in den Quelltext um die verschiedenen Bereiche einer Klasse zu trennen. So würde zum Beispiel <quote>public methods</quote> oder <quote>Attributes</quote> vor den entsprechenden Abschnitten eingefügt werden. Wurde dieser Parameter aktiviert, wird für jeden Abschnitt ein entsprechendes Kommentar eingefügt, selbst dann, wenn der Abschnitt leer ist. So würde zum Beispiel das Kommentar <quote>protected methods </quote> eingefügt werden, selbst wenn keine geschützten Methoden in der Klasse existieren. </para>
 </sect4>
 <sect4>
-<title
->Ordner</title>
-<para
-><guilabel
->Verzeichnis für alle zu erzeugenden Dateien</guilabel
->: Hier wählt man das Verzeichnis aus, in dem der erzeugte Quelltext abgelegt werden soll. </para>
-<para
->Der Parameter <guilabel
->Einbeziehung der Header-Dateien aus Verzeichnis</guilabel
-> erlaubt es einen Kopf an den Anfang jeder erzeugten Datei einzufügen. Diese Dateiköpfe können zum Beispiel Urheberhinweise oder Lizenzinformationen enthalten, sowie Variablen, die während der Quelltexterzeugung entsprechend ersetzt werden. Man sollte einen Blick auf die Vorlagedateien für Dateiköpfe werfen, die mit &umbrello; ausgeliefert werden. Dort kann man sehen, wie man zum Beispiel mit den Variablen das aktuelle Datum oder einen Namen einfügen kann. </para>
+<title>Ordner</title>
+<para><guilabel>Verzeichnis für alle zu erzeugenden Dateien</guilabel>: Hier wählt man das Verzeichnis aus, in dem der erzeugte Quelltext abgelegt werden soll. </para>
+<para>Der Parameter <guilabel>Einbeziehung der Header-Dateien aus Verzeichnis</guilabel> erlaubt es einen Kopf an den Anfang jeder erzeugten Datei einzufügen. Diese Dateiköpfe können zum Beispiel Urheberhinweise oder Lizenzinformationen enthalten, sowie Variablen, die während der Quelltexterzeugung entsprechend ersetzt werden. Man sollte einen Blick auf die Vorlagedateien für Dateiköpfe werfen, die mit &umbrello; ausgeliefert werden. Dort kann man sehen, wie man zum Beispiel mit den Variablen das aktuelle Datum oder einen Namen einfügen kann. </para>
 </sect4>
 <sect4>
-<title
->Vorgaben für Überschreibung</title>
+<title>Vorgaben für Überschreibung</title>
 <!-- FIXME update for Umbrello 1.2's new C++ and Java code generators -->
-<para
->Dieser Parameter legt das Verhalten von &umbrello; fest, wenn es eine Datei während der Quelltexterzeugung anlegen will, die im Zielverzeichnis bereits existiert. &umbrello; kann vorhandene Dateien <emphasis
->nicht modifizieren</emphasis
->. Man kann wählen zwischen dem Überschreiben der existierenden Datei, dem Nachfragen, was passieren soll, und der Auswahl eines anderen Dateinamens durch &umbrello;. Soll &umbrello; einen anderen Dateinamen finden, dann hängt &umbrello; ein Suffix an die entsprechende Datei an. </para>
+<para>Dieser Parameter legt das Verhalten von &umbrello; fest, wenn es eine Datei während der Quelltexterzeugung anlegen will, die im Zielverzeichnis bereits existiert. &umbrello; kann vorhandene Dateien <emphasis>nicht modifizieren</emphasis>. Man kann wählen zwischen dem Überschreiben der existierenden Datei, dem Nachfragen, was passieren soll, und der Auswahl eines anderen Dateinamens durch &umbrello;. Soll &umbrello; einen anderen Dateinamen finden, dann hängt &umbrello; ein Suffix an die entsprechende Datei an. </para>
 </sect4>
 <sect4>
-<title
->Sprache</title>
-<para
->Umbrello wählt als Sprache für die Quelltexterzeugung die momentan als aktive Sprache gewählte aus. Man kann allerdings im Quelltextassistenten eine andere Sprache auswählen. </para>
+<title>Sprache</title>
+<para>Umbrello wählt als Sprache für die Quelltexterzeugung die momentan als aktive Sprache gewählte aus. Man kann allerdings im Quelltextassistenten eine andere Sprache auswählen. </para>
 </sect4>
-</sect3
-><!--generation-options-->
+</sect3><!--generation-options-->
 <sect3 id="generation-wizard-generation">
-<title
->Quelltexterzeugung</title>
-<para
->Der dritte und letzte Schritt des Assistenten zeigt den Status der eigentlichen Quelltexterzeugung. Man muss lediglich auf die Schaltfläche Erzeugen klicken, damit die entsprechenden Dateien mit den Klassen angelegt werden. </para>
-<para
->Es ist zu beachten, dass die gesetzten Parameter nur für die aktuelle Quelltexterzeugung gültig sind. Beim nächsten Aufruf des Assistenten muss man alle Parameter, wie Header-Datei Verzeichnis und Vorgaben für Überschreibung, neu einstellen. Man kann allerdings die Voreinstellungen dauerhaft über den <guilabel
->Quelltexterzeugung</guilabel
-> Abschnitt in den &umbrello; Einstellungen verändern. Diese Einstellungen erreicht man über <menuchoice
-><guimenu
->Einstellungen</guimenu
-> <guimenuitem
->&umbrello; einrichten ...</guimenuitem
-></menuchoice
->. </para>
-<para
->Hat man die Standardeinstellungen für die Quelltexterzeugung bereits richtig eingestellt, kann man die Quelltexterzeugung ohne den entsprechenden Assistenten direkt starten. Dazu wählt man <guimenuitem
->Erzeuge alle Quelltexte</guimenuitem
-> aus dem Quelltext Menu. Dies erzeugt den Quelltext aller Klassen des Modells mit den aktuellen Einstellungen wie Ausgabeverzeichnis und Vorgaben für Überschreiben. Man sollte deshalb vorsichtig damit umgehen. </para>
+<title>Quelltexterzeugung</title>
+<para>Der dritte und letzte Schritt des Assistenten zeigt den Status der eigentlichen Quelltexterzeugung. Man muss lediglich auf die Schaltfläche Erzeugen klicken, damit die entsprechenden Dateien mit den Klassen angelegt werden. </para>
+<para>Es ist zu beachten, dass die gesetzten Parameter nur für die aktuelle Quelltexterzeugung gültig sind. Beim nächsten Aufruf des Assistenten muss man alle Parameter, wie Header-Datei Verzeichnis und Vorgaben für Überschreibung, neu einstellen. Man kann allerdings die Voreinstellungen dauerhaft über den <guilabel>Quelltexterzeugung</guilabel> Abschnitt in den &umbrello; Einstellungen verändern. Diese Einstellungen erreicht man über <menuchoice><guimenu>Einstellungen</guimenu> <guimenuitem>&umbrello; einrichten ...</guimenuitem></menuchoice>. </para>
+<para>Hat man die Standardeinstellungen für die Quelltexterzeugung bereits richtig eingestellt, kann man die Quelltexterzeugung ohne den entsprechenden Assistenten direkt starten. Dazu wählt man <guimenuitem>Erzeuge alle Quelltexte</guimenuitem> aus dem Quelltext Menu. Dies erzeugt den Quelltext aller Klassen des Modells mit den aktuellen Einstellungen wie Ausgabeverzeichnis und Vorgaben für Überschreiben. Man sollte deshalb vorsichtig damit umgehen. </para>
 </sect3>
-</sect2
-><!--generate-code-->
-</sect1
-> <!--code-generation-->
+</sect2><!--generate-code-->
+</sect1> <!--code-generation-->
 <sect1 id="code-import">
-<title
->Quelltext einlesen</title>
-<para
->&umbrello; kann bereits vorhandenen Quelltext eines bestehenden Projektes einlesen, um beim Aufbau des Systemmodells zu unterstützen. &umbrello; 1.2 verfügt über die Möglichkeit C++ Quelltext einzulesen, weitere Sprachen werden in späteren Versionen folgen. </para>
-<para
->Um Klassen in das aktuelle Modell zu importieren, muss man <guimenuitem
->Klassen importieren ...</guimenuitem
-> aus dem <guimenu
->Quelltextmenu</guimenu
-> auswählen. Im erscheinenden Dateidialog sind die Dateien auszuwählen, die die C++ Klassen Deklarationen enthalten und mit OK zu bestätigen. Die Klassen werden importiert und man findet sie danach in der Baumansicht des Modells. Es ist zu beachten, dass Umbrello beim Einlesen von Quelltext keine Diagramme anlegt, sondern lediglich die Klassen. Man kann diese nun in beliebigen Diagrammen verwenden. </para>
+<title>Quelltext einlesen</title>
+<para>&umbrello; kann bereits vorhandenen Quelltext eines bestehenden Projektes einlesen, um beim Aufbau des Systemmodells zu unterstützen. &umbrello; 1.2 verfügt über die Möglichkeit C++ Quelltext einzulesen, weitere Sprachen werden in späteren Versionen folgen. </para>
+<para>Um Klassen in das aktuelle Modell zu importieren, muss man <guimenuitem>Klassen importieren ...</guimenuitem> aus dem <guimenu>Quelltextmenu</guimenu> auswählen. Im erscheinenden Dateidialog sind die Dateien auszuwählen, die die C++ Klassen Deklarationen enthalten und mit OK zu bestätigen. Die Klassen werden importiert und man findet sie danach in der Baumansicht des Modells. Es ist zu beachten, dass Umbrello beim Einlesen von Quelltext keine Diagramme anlegt, sondern lediglich die Klassen. Man kann diese nun in beliebigen Diagrammen verwenden. </para>
 <para>
 <screenshot>
-<screeninfo
->Quelltext einlesen</screeninfo>
+<screeninfo>Quelltext einlesen</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="code-import.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->Dialog für das Einlesen von Quelltext in &umbrello;</phrase>
+	    <phrase>Dialog für das Einlesen von Quelltext in &umbrello;</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->Dialog für das Einlesen von Quelltext in &umbrello; </para>
+	    <para>Dialog für das Einlesen von Quelltext in &umbrello; </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 </para>
 </sect1>
-</chapter
-> <!--code-import-generation-->
+</chapter> <!--code-import-generation-->
diff --git a/tde-i18n-de/docs/tdesdk/umbrello/credits.docbook b/tde-i18n-de/docs/tdesdk/umbrello/credits.docbook
index 6f6407392c6..443095e5dee 100644
--- a/tde-i18n-de/docs/tdesdk/umbrello/credits.docbook
+++ b/tde-i18n-de/docs/tdesdk/umbrello/credits.docbook
@@ -1,11 +1,6 @@
 <chapter id="copyright">
-<title
->Copyright</title>
+<title>Copyright</title>
 
-<para
->Copyright 2001, Paul Hensgen</para>
-<para
->Copyright 2002-2003 Die &umbrello; Autoren. Siehe dazu <ulink url="http://uml.sf.net/developers.php"
->http://uml.sf.net/developers.php</ulink
-> für weitere Informationen.</para>
+<para>Copyright 2001, Paul Hensgen</para>
+<para>Copyright 2002-2003 Die &umbrello; Autoren. Siehe dazu <ulink url="http://uml.sf.net/developers.php">http://uml.sf.net/developers.php</ulink> für weitere Informationen.</para>
 &underFDL; &underGPL; </chapter>
diff --git a/tde-i18n-de/docs/tdesdk/umbrello/index.docbook b/tde-i18n-de/docs/tdesdk/umbrello/index.docbook
index 774318ea7af..fbea1b77742 100644
--- a/tde-i18n-de/docs/tdesdk/umbrello/index.docbook
+++ b/tde-i18n-de/docs/tdesdk/umbrello/index.docbook
@@ -1,14 +1,10 @@
 <?xml version="1.0" ?>
 <!DOCTYPE book PUBLIC "-//KDE//DTD DocBook XML V4.2-Based Variant V1.1//EN"
  "dtd/kdex.dtd" [
- <!ENTITY umbrello "<application
->Umbrello &UML; Modeller</application
->">
+ <!ENTITY umbrello "<application>Umbrello &UML; Modeller</application>">
  <!ENTITY kappname "&umbrello;">
  <!ENTITY packagename "tdesdk">
- <!ENTITY UML "<acronym
->UML</acronym
->">
+ <!ENTITY UML "<acronym>UML</acronym>">
  <!ENTITY introduction-chapter SYSTEM "introduction.docbook">
  <!ENTITY uml-basics-chapter SYSTEM "uml_basics.docbook">
  <!ENTITY working-with-umbrello-chapter SYSTEM "working_with_umbrello.docbook">
@@ -17,59 +13,43 @@
  <!ENTITY authors-chapter SYSTEM "authors.docbook">
  <!ENTITY credits-chapter SYSTEM "credits.docbook">
  <!ENTITY % addindex "IGNORE">
- <!ENTITY % German "INCLUDE"
-><!-- change language only here -->
+ <!ENTITY % German "INCLUDE"><!-- change language only here -->
   <!-- Do not define any other entities; instead, use the entities
        from kde-genent.entities and $LANG/user.entities. -->
 ]>
 
 <book id="Umbrello" lang="&language;">
 <bookinfo>
-<title
->Das Handbuch zu &umbrello;</title>
+<title>Das Handbuch zu &umbrello;</title>
 
 <authorgroup>
-<corpauthor
->&umbrello; Autoren</corpauthor>
+<corpauthor>&umbrello; Autoren</corpauthor>
 </authorgroup>
 
 <copyright>
-<year
->2001</year>
-<holder
->Paul Hensgen</holder>
+<year>2001</year>
+<holder>Paul Hensgen</holder>
 </copyright>
 <copyright>
-<year
->2002, 2003</year>
-<holder
->&umbrello; Autoren</holder>
+<year>2002, 2003</year>
+<holder>&umbrello; Autoren</holder>
 </copyright>
 
 
-<date
->2003-10-15</date>
-<releaseinfo
->1.2</releaseinfo>
+<date>2003-10-15</date>
+<releaseinfo>1.2</releaseinfo>
 
 <abstract>
-<para
->&umbrello; unterstützt den Software Entwicklungsprozess durch die Anwendung des Industriestandards Unified Modelling Language (&UML;). Dadurch kann man mithilfe von Diagrammen das System entwickeln und dokumentieren. </para>
+<para>&umbrello; unterstützt den Software Entwicklungsprozess durch die Anwendung des Industriestandards Unified Modelling Language (&UML;). Dadurch kann man mithilfe von Diagrammen das System entwickeln und dokumentieren. </para>
 </abstract>
 
 <keywordset>
-<keyword
->KDE</keyword>
-<keyword
->UML</keyword>
-<keyword
->modellieren</keyword>
-<keyword
->Diagramme</keyword>
-<keyword
->Software Entwicklung</keyword>
-<keyword
->Entwicklung</keyword>
+<keyword>KDE</keyword>
+<keyword>UML</keyword>
+<keyword>modellieren</keyword>
+<keyword>Diagramme</keyword>
+<keyword>Software Entwicklung</keyword>
+<keyword>Entwicklung</keyword>
 </keywordset>
 
 </bookinfo>
diff --git a/tde-i18n-de/docs/tdesdk/umbrello/introduction.docbook b/tde-i18n-de/docs/tdesdk/umbrello/introduction.docbook
index b349d8db9a0..8b2a85a7551 100644
--- a/tde-i18n-de/docs/tdesdk/umbrello/introduction.docbook
+++ b/tde-i18n-de/docs/tdesdk/umbrello/introduction.docbook
@@ -1,57 +1,19 @@
 <chapter id="introduction">
-<title
->Einführung</title>
+<title>Einführung</title>
 
-<para
->&umbrello; ist ein &UML; Diagramm Werkzeug, welches den Software Entwicklungs Prozess unterstützen kann. Hauptsächlich während der Analyse und des Design hilft &umbrello; dabei, ein qualitativ hochwertiges Produkt zu erzeugen. Die &UML; kann weiterhin zur Dokumentation des Softwaredesigns genutzt werden, um sie und ihre Kollegen zu unterstützen. </para>
-<para
->Ein gutes Modell des zukünftigen Softwaresystems ist die beste Grundlage, um mit anderen daran arbeitenden Entwicklern oder mit dem Kunden zu kommunizieren. Ein gutes Modell ist extrem wichtig für mittlere und große Projekte, aber selbst in kleinen Projekten ist es hilfreich. So kann man es selbst in einem Ein-Mann-Projekt einsetzen. Kleine Projekte profitieren von einem guten Model ebenso, da man einen Überblick erhält, was dabei hilft die Sache gleich beim ersten Versuch richtig umzusetzen. </para>
-<para
->Die &UML; ist eine Diagrammnotationssprache um solche Modelle zu beschreiben. Man kann seine Ideen mithilfe verschiedener Diagramme in der &UML; ausdrücken. &umbrello; 1.2 unterstützt folgende Typen: </para>
+<para>&umbrello; ist ein &UML; Diagramm Werkzeug, welches den Software Entwicklungs Prozess unterstützen kann. Hauptsächlich während der Analyse und des Design hilft &umbrello; dabei, ein qualitativ hochwertiges Produkt zu erzeugen. Die &UML; kann weiterhin zur Dokumentation des Softwaredesigns genutzt werden, um sie und ihre Kollegen zu unterstützen. </para>
+<para>Ein gutes Modell des zukünftigen Softwaresystems ist die beste Grundlage, um mit anderen daran arbeitenden Entwicklern oder mit dem Kunden zu kommunizieren. Ein gutes Modell ist extrem wichtig für mittlere und große Projekte, aber selbst in kleinen Projekten ist es hilfreich. So kann man es selbst in einem Ein-Mann-Projekt einsetzen. Kleine Projekte profitieren von einem guten Model ebenso, da man einen Überblick erhält, was dabei hilft die Sache gleich beim ersten Versuch richtig umzusetzen. </para>
+<para>Die &UML; ist eine Diagrammnotationssprache um solche Modelle zu beschreiben. Man kann seine Ideen mithilfe verschiedener Diagramme in der &UML; ausdrücken. &umbrello; 1.2 unterstützt folgende Typen: </para>
 <itemizedlist>
-<listitem
-><para
->Klassendiagramm</para
-></listitem>
-<listitem
-><para
->Sequenzdiagramm</para
-></listitem>
-<listitem
-><para
->Kollaborationsdiagramm</para
-></listitem>
-<listitem
-><para
->Anwendungsfalldiagramm</para
-></listitem>
-<listitem
-><para
->Zustandsdiagramm</para
-></listitem>
-<listitem
-><para
->Aktivitätsdiagramm</para
-></listitem>
-<listitem
-><para
->Komponenten Diagramm</para
-></listitem>
-<listitem
-><para
->Verteilungsdiagramm</para
-></listitem>
+<listitem><para>Klassendiagramm</para></listitem>
+<listitem><para>Sequenzdiagramm</para></listitem>
+<listitem><para>Kollaborationsdiagramm</para></listitem>
+<listitem><para>Anwendungsfalldiagramm</para></listitem>
+<listitem><para>Zustandsdiagramm</para></listitem>
+<listitem><para>Aktivitätsdiagramm</para></listitem>
+<listitem><para>Komponenten Diagramm</para></listitem>
+<listitem><para>Verteilungsdiagramm</para></listitem>
 </itemizedlist>
-<para
->Mehr Informationen über &UML; kann man auf der <ulink url="http://www.omg.org/"
-><acronym
->OMG</acronym
-> Homepage http://www.omg.org/</ulink
-> finden. Der &UML; Standard wurde von dieser Organisation geschaffen. </para>
-<para
->Wir hoffen sie haben Spaß mit &umbrello; und das es ihnen bei der Erstellung qualitativ hochwertiger Software hilft. &umbrello; ist ein freies Werkzeug. Die einzige Sache, um die wir sie bitten, ist es, Fehler, Probleme oder Vorschläge an die Umbrello Entwickler zu berichten über <email
->uml-devel@lists.sourceforge.net</email
-> oder <ulink url="http://bugs.kde.org"
->http://bugs.kde.org</ulink
->! </para>
+<para>Mehr Informationen über &UML; kann man auf der <ulink url="http://www.omg.org/"><acronym>OMG</acronym> Homepage http://www.omg.org/</ulink> finden. Der &UML; Standard wurde von dieser Organisation geschaffen. </para>
+<para>Wir hoffen sie haben Spaß mit &umbrello; und das es ihnen bei der Erstellung qualitativ hochwertiger Software hilft. &umbrello; ist ein freies Werkzeug. Die einzige Sache, um die wir sie bitten, ist es, Fehler, Probleme oder Vorschläge an die Umbrello Entwickler zu berichten über <email>uml-devel@lists.sourceforge.net</email> oder <ulink url="http://bugs.kde.org">http://bugs.kde.org</ulink>! </para>
 </chapter>
diff --git a/tde-i18n-de/docs/tdesdk/umbrello/other_features.docbook b/tde-i18n-de/docs/tdesdk/umbrello/other_features.docbook
index 289a7cb051d..eab3b1b312b 100644
--- a/tde-i18n-de/docs/tdesdk/umbrello/other_features.docbook
+++ b/tde-i18n-de/docs/tdesdk/umbrello/other_features.docbook
@@ -1,72 +1,35 @@
 <chapter id="other-features">
-<title
->Weitere Funktionen</title>
-<sect1
-> 
-<title
->Weitere Funktionen in &umbrello;</title>
-<para
->In diesem Kapitel werden weitere Funktionen von &umbrello; genau erläutert.</para>
+<title>Weitere Funktionen</title>
+<sect1> 
+<title>Weitere Funktionen in &umbrello;</title>
+<para>In diesem Kapitel werden weitere Funktionen von &umbrello; genau erläutert.</para>
 <sect2 id="copying-as-png">
-<title
->Objekte als PNG Bilder kopieren</title>
-<para
->Neben dem normalen Kopieren, Ausschneiden und Einfügen Funktionen für das Kopieren von Objekten zwischen einzelnen Diagrammen, beherrscht &umbrello; auch das Kopieren von Objekten als PNG Bildern, so dass man diese in andere Dokumente einfügen kann. Damit dies funktioniert, muss man keine speziellen Handlungen vornehmen. Einfach das Objekt (Klasse, Akteur, &etc;) auswählen und kopieren (<keycombo
->&Ctrl;<keycap
->C</keycap
-></keycombo
-> oder über das Menu), dann &kword; öffnen (oder jedes andere Programm, indem man Bilder einfügen kann) und <guimenuitem
->Einfügen</guimenuitem
-> auswählen. Mit dieser tollen Funktion kann man sehr leicht einzelne Teile von Diagrammen als einfache Bilder exportieren. </para>
+<title>Objekte als PNG Bilder kopieren</title>
+<para>Neben dem normalen Kopieren, Ausschneiden und Einfügen Funktionen für das Kopieren von Objekten zwischen einzelnen Diagrammen, beherrscht &umbrello; auch das Kopieren von Objekten als PNG Bildern, so dass man diese in andere Dokumente einfügen kann. Damit dies funktioniert, muss man keine speziellen Handlungen vornehmen. Einfach das Objekt (Klasse, Akteur, &etc;) auswählen und kopieren (<keycombo>&Ctrl;<keycap>C</keycap></keycombo> oder über das Menu), dann &kword; öffnen (oder jedes andere Programm, indem man Bilder einfügen kann) und <guimenuitem>Einfügen</guimenuitem> auswählen. Mit dieser tollen Funktion kann man sehr leicht einzelne Teile von Diagrammen als einfache Bilder exportieren. </para>
 </sect2>
 <sect2 id="export-as-png">
-<title
->Export als ein Bild</title>
-<para
->Man kann natürlich ebenfalls ein komplettes Diagramm als PNG Bild exportieren. Dazu wählt man das gewünschte Diagramm und ruft dann aus dem Menu <guimenu
->Diagramm</guimenu
-> den Eintrag <guimenuitem
->Exportieren als Bild ...</guimenuitem
-> auf. </para>
+<title>Export als ein Bild</title>
+<para>Man kann natürlich ebenfalls ein komplettes Diagramm als PNG Bild exportieren. Dazu wählt man das gewünschte Diagramm und ruft dann aus dem Menu <guimenu>Diagramm</guimenu> den Eintrag <guimenuitem>Exportieren als Bild ...</guimenuitem> auf. </para>
 </sect2>
 <sect2 id="printing">
-<title
->Drucken</title>
-<para
->&umbrello; ermöglicht es einzelne Diagramme zu drucken. Man kann dies entweder über den <guiicon
->Druckknopf</guiicon
-> aus der Programmwerkzeugleiste oder über den Menueintrag <guimenuitem
->Druck</guimenuitem
-> aus dem <guimenu
->Datei </guimenu
-> Menu aufrufen. Es erscheint der Standard &kde; Druckdialog, womit man den Ausdruck des Diagrammes steuern kann. </para>
+<title>Drucken</title>
+<para>&umbrello; ermöglicht es einzelne Diagramme zu drucken. Man kann dies entweder über den <guiicon>Druckknopf</guiicon> aus der Programmwerkzeugleiste oder über den Menueintrag <guimenuitem>Druck</guimenuitem> aus dem <guimenu>Datei </guimenu> Menu aufrufen. Es erscheint der Standard &kde; Druckdialog, womit man den Ausdruck des Diagrammes steuern kann. </para>
 </sect2>
 <sect2 id="logical-folders">
-<title
->Logische Ordner</title>
-<para
->Für eine bessere Organisation des Modells, besonders bei größeren Projekten, kann man logische Ordner in der Baumansicht anlegen. Dazu einfach <menuchoice
-><guimenu
->Neu</guimenu
-><guimenuitem
->Ordner</guimenuitem
-></menuchoice
-> aus dem Kontextmenu der Standardordner in der Baumansicht wählen und einen neuen Ordner anlegen. Ordner können verschachtelt werden und man kann Objekte in diese hinein ziehen oder kopieren. </para>
+<title>Logische Ordner</title>
+<para>Für eine bessere Organisation des Modells, besonders bei größeren Projekten, kann man logische Ordner in der Baumansicht anlegen. Dazu einfach <menuchoice><guimenu>Neu</guimenu><guimenuitem>Ordner</guimenuitem></menuchoice> aus dem Kontextmenu der Standardordner in der Baumansicht wählen und einen neuen Ordner anlegen. Ordner können verschachtelt werden und man kann Objekte in diese hinein ziehen oder kopieren. </para>
 
 <screenshot>
-<screeninfo
->das Modell mit Ordnern organisieren</screeninfo>
+<screeninfo>das Modell mit Ordnern organisieren</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="folders.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->Ein Modell mit logischen Ordnern in &umbrello; organisieren</phrase>
+	    <phrase>Ein Modell mit logischen Ordnern in &umbrello; organisieren</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->ein Modell mit logischen Ordnern in &umbrello; organisieren </para>
+	    <para>ein Modell mit logischen Ordnern in &umbrello; organisieren </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
diff --git a/tde-i18n-de/docs/tdesdk/umbrello/uml_basics.docbook b/tde-i18n-de/docs/tdesdk/umbrello/uml_basics.docbook
index 840c8853871..8c4e4138691 100644
--- a/tde-i18n-de/docs/tdesdk/umbrello/uml_basics.docbook
+++ b/tde-i18n-de/docs/tdesdk/umbrello/uml_basics.docbook
@@ -1,378 +1,169 @@
 <chapter id="uml-basics">
-<title
->&UML; Grundlagen</title>
+<title>&UML; Grundlagen</title>
 <sect1 id="about-uml">
-<title
->Über &UML;</title>
-<para
->Dieses Kapitel gibt einen kurzen Überblick über die &UML; Grundlagen. Man sollte sich aber bewusst sein, dass es keine vollständige &UML; Anleitung ist. Wenn man mehr über die Unified Modelling Language, oder allgemein über Software Analyse und Design, lernen will, dann sollte man eines der vielen zu diesem Thema publizierten Bücher lesen. Man kann natürlich die vielen Einführungen im Internet zum Thema als Ausgangspunkt wählen. </para>
-
-<para
->Die Unified Modelling Language (&UML;) ist eine Diagrammnotation zum spezifizieren, visualisieren und dokumentieren von Modellen objektorientierter Softwaresysteme. &UML; ist kein Vorgehensmodell, d.h. es sagt nichts über die einzelnen Schritte aus, die nötig sind, um ein System zu gestalten. Aber &UML; hilft ihnen ihr Design zu visualisieren und mit anderen zu kommunizieren. Der &UML; Standard wird von der Object Management Group (<acronym
->OMG</acronym
->) gepflegt und ist der Industriestandard zur Beschreibung von Softwaremodellen. </para>
-<para
->&UML; wurde für das objektorientierte Softwaredesign entwickelt und ist daher nur von begrenztem Nutzen bei anderen Programmierparadigmen. </para>
-<para
->&UML; setzt sich zusammen aus vielen Modellelementen, die für sich einen bestimmten Sachverhalt des Softwaresystems repräsentieren. Diese Elemente werden zu Diagrammen kombiniert, die einen Ausschnitt oder einen bestimmten Blickpunkt auf das System darstellen. Folgende Diagrammtypen werden von &umbrello; unterstützt: </para>
+<title>Über &UML;</title>
+<para>Dieses Kapitel gibt einen kurzen Überblick über die &UML; Grundlagen. Man sollte sich aber bewusst sein, dass es keine vollständige &UML; Anleitung ist. Wenn man mehr über die Unified Modelling Language, oder allgemein über Software Analyse und Design, lernen will, dann sollte man eines der vielen zu diesem Thema publizierten Bücher lesen. Man kann natürlich die vielen Einführungen im Internet zum Thema als Ausgangspunkt wählen. </para>
+
+<para>Die Unified Modelling Language (&UML;) ist eine Diagrammnotation zum spezifizieren, visualisieren und dokumentieren von Modellen objektorientierter Softwaresysteme. &UML; ist kein Vorgehensmodell, d.h. es sagt nichts über die einzelnen Schritte aus, die nötig sind, um ein System zu gestalten. Aber &UML; hilft ihnen ihr Design zu visualisieren und mit anderen zu kommunizieren. Der &UML; Standard wird von der Object Management Group (<acronym>OMG</acronym>) gepflegt und ist der Industriestandard zur Beschreibung von Softwaremodellen. </para>
+<para>&UML; wurde für das objektorientierte Softwaredesign entwickelt und ist daher nur von begrenztem Nutzen bei anderen Programmierparadigmen. </para>
+<para>&UML; setzt sich zusammen aus vielen Modellelementen, die für sich einen bestimmten Sachverhalt des Softwaresystems repräsentieren. Diese Elemente werden zu Diagrammen kombiniert, die einen Ausschnitt oder einen bestimmten Blickpunkt auf das System darstellen. Folgende Diagrammtypen werden von &umbrello; unterstützt: </para>
 
 <itemizedlist>
 
-<listitem
-><para
-><emphasis
-><link linkend="use-case-diagram"
->Anwendungsfalldiagramm</link
-> </emphasis
->, stellt Akteure (Menschen oder andere Nutzer des Systems), Anwendungsfälle (Szenario, wie die Akteure das System nutzen) und die Beziehungen dazwischen dar</para
-> </listitem>
-
-<listitem
-><para
-><emphasis
-><link linkend="class-diagram"
->Klassendiagramm</link
-></emphasis
->, stellt Klassen und ihre Beziehungen untereinander dar</para
-> </listitem>
-
-<listitem
-><para
-><emphasis
-><link linkend="sequence-diagram"
-> Sequenzdiagramm</link
-></emphasis
->, stellt Objekte und ihre Beziehungen dar, wobei der Schwerpunkt auf dem chronologischen Nachrichtenaustausch zwischen den Objekten liegt</para
-> </listitem>
-
-<listitem
-><para
-><emphasis
-><link linkend="collaboration-diagram"
->Kollaborationsdiagramm </link
-></emphasis
->, stellt Objekte und ihre Beziehungen dar, wobei der Schwerpunkt auf Objekten liegt, die am Nachrichtenaustausch beteiligt sind</para>
+<listitem><para><emphasis><link linkend="use-case-diagram">Anwendungsfalldiagramm</link> </emphasis>, stellt Akteure (Menschen oder andere Nutzer des Systems), Anwendungsfälle (Szenario, wie die Akteure das System nutzen) und die Beziehungen dazwischen dar</para> </listitem>
+
+<listitem><para><emphasis><link linkend="class-diagram">Klassendiagramm</link></emphasis>, stellt Klassen und ihre Beziehungen untereinander dar</para> </listitem>
+
+<listitem><para><emphasis><link linkend="sequence-diagram"> Sequenzdiagramm</link></emphasis>, stellt Objekte und ihre Beziehungen dar, wobei der Schwerpunkt auf dem chronologischen Nachrichtenaustausch zwischen den Objekten liegt</para> </listitem>
+
+<listitem><para><emphasis><link linkend="collaboration-diagram">Kollaborationsdiagramm </link></emphasis>, stellt Objekte und ihre Beziehungen dar, wobei der Schwerpunkt auf Objekten liegt, die am Nachrichtenaustausch beteiligt sind</para>
 </listitem>
 
-<listitem
-><para
-><emphasis
-><link linkend="state-diagram"
->Zustandsdiagramm</link
-> </emphasis
->, stellt Zustände, Zustandsänderungen und Ereignisse in einem Objekt oder Teilsystem dar</para
-> </listitem>
-
-<listitem
-><para
-><emphasis
-><link linkend="activity-diagram"
->Aktivitätsdiagram</link
-> </emphasis
->, stellt die Aktivitäten, Zustände und Zustandsänderungen von Objekten und die Ereignisse in Teilsystemen dar</para
-></listitem>
-
-<listitem
-><para
-><emphasis
-><link linkend="component-diagram"
->Komponentendiagramm</link
-> </emphasis
->, stellt die höheren Programmierkomponenten (wie KParts und Java Beans) dar.</para
-></listitem>
-
-<listitem
-><para
-><emphasis
-><link linkend="deployment-diagram"
->Verteilungsdiagramm</link
-></emphasis
-> , stellt die Instanzen der Komponenten und ihre Beziehungen dar.</para
-></listitem
-> 
+<listitem><para><emphasis><link linkend="state-diagram">Zustandsdiagramm</link> </emphasis>, stellt Zustände, Zustandsänderungen und Ereignisse in einem Objekt oder Teilsystem dar</para> </listitem>
+
+<listitem><para><emphasis><link linkend="activity-diagram">Aktivitätsdiagram</link> </emphasis>, stellt die Aktivitäten, Zustände und Zustandsänderungen von Objekten und die Ereignisse in Teilsystemen dar</para></listitem>
+
+<listitem><para><emphasis><link linkend="component-diagram">Komponentendiagramm</link> </emphasis>, stellt die höheren Programmierkomponenten (wie KParts und Java Beans) dar.</para></listitem>
+
+<listitem><para><emphasis><link linkend="deployment-diagram">Verteilungsdiagramm</link></emphasis> , stellt die Instanzen der Komponenten und ihre Beziehungen dar.</para></listitem> 
 
 </itemizedlist>
 
-</sect1
->   <!-- about-uml -->
+</sect1>   <!-- about-uml -->
 
-<sect1 id="uml-elements"
->  
-<title
->&UML; Elemente</title>
+<sect1 id="uml-elements">  
+<title>&UML; Elemente</title>
 <sect2 id="use-case-diagram">
-<title
->Anwendungsfalldiagramm</title>
-<para
->Anwendungsfalldiagramme beschreiben die Beziehungen und Abhängigkeiten zwischen einer Gruppe von <emphasis
->Anwendungsfällen</emphasis
-> und den teilnehmenden Akteuren in einem Prozess.</para>
-<para
->Dabei ist zu beachten, dass ein Anwendungsfalldiagramm nicht das Systemdesign wiederspiegelt und damit keine Aussage über die Systeminterna trifft. Anwendungsfalldiagramme werden zur Vereinfachung der Kommunikation zwischen Entwickler und zukünftigen Nutzer bzw. Kunde erstellt. Sie sind vorallem bei der Festlegung der benötigten Kriterien des zukünftigen Systems hilfreich. Somit treffen Anwendungsfalldiagramme eine Aussage, <emphasis
->was</emphasis
-> zu tun ist, aber nicht <emphasis
->wie</emphasis
-> wie das erreicht wird.</para>
+<title>Anwendungsfalldiagramm</title>
+<para>Anwendungsfalldiagramme beschreiben die Beziehungen und Abhängigkeiten zwischen einer Gruppe von <emphasis>Anwendungsfällen</emphasis> und den teilnehmenden Akteuren in einem Prozess.</para>
+<para>Dabei ist zu beachten, dass ein Anwendungsfalldiagramm nicht das Systemdesign wiederspiegelt und damit keine Aussage über die Systeminterna trifft. Anwendungsfalldiagramme werden zur Vereinfachung der Kommunikation zwischen Entwickler und zukünftigen Nutzer bzw. Kunde erstellt. Sie sind vorallem bei der Festlegung der benötigten Kriterien des zukünftigen Systems hilfreich. Somit treffen Anwendungsfalldiagramme eine Aussage, <emphasis>was</emphasis> zu tun ist, aber nicht <emphasis>wie</emphasis> wie das erreicht wird.</para>
 <para>
 <screenshot>
-<screeninfo
->ein beispielhaftes Anwendungsfalldiagramm.</screeninfo>
+<screeninfo>ein beispielhaftes Anwendungsfalldiagramm.</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="use-case-diagram.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->&umbrello; bei der Darstellung eines Anwendungfalldiagrammes </phrase>
+	    <phrase>&umbrello; bei der Darstellung eines Anwendungfalldiagrammes </phrase>
 	  </textobject>
 	  <caption>
-	    <para
->&umbrello; bei der Darstellung eines Anwendungfalldiagrammes </para>
+	    <para>&umbrello; bei der Darstellung eines Anwendungfalldiagrammes </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 </para>
 <sect3 id="use-case">
-<title
->Anwendungsfall</title>
-<para
->Ein <emphasis
->Anwendungsfall</emphasis
-> beschreibt, aus der Sicht des Akteur, eine Reihe von Aktivitäten im System, die ein konkret fassbares Ergebnis liefern.</para>
-<para
->Anwendungsfälle dienen als Beschreibung von typischen Interaktionen zwischen Nutzer und dem System. Sie stellen die externe Schnittstelle dar und spezifizieren damit die Anforderungen, was das System zu tun hat (nur das was, aber nicht das wie!). </para>
-<para
->Bei der Arbeit mit Anwendungsfällen, sollte man folgende einfache Regeln beachten: <itemizedlist>
- <listitem
-><para
->jeder Anwendungsfall ist mindestens mit einem Akteur verbunden</para
-></listitem>
- <listitem
-><para
->jeder Anwendungsfall hat einen Auslöser (also einen Akteur)</para
-></listitem>
- <listitem
-><para
->jeder Anwendungsfall führt zu einem relevanten Ergebnis (<quote
->messbar und wirtschaftlich relevant</quote
->)</para>
+<title>Anwendungsfall</title>
+<para>Ein <emphasis>Anwendungsfall</emphasis> beschreibt, aus der Sicht des Akteur, eine Reihe von Aktivitäten im System, die ein konkret fassbares Ergebnis liefern.</para>
+<para>Anwendungsfälle dienen als Beschreibung von typischen Interaktionen zwischen Nutzer und dem System. Sie stellen die externe Schnittstelle dar und spezifizieren damit die Anforderungen, was das System zu tun hat (nur das was, aber nicht das wie!). </para>
+<para>Bei der Arbeit mit Anwendungsfällen, sollte man folgende einfache Regeln beachten: <itemizedlist>
+ <listitem><para>jeder Anwendungsfall ist mindestens mit einem Akteur verbunden</para></listitem>
+ <listitem><para>jeder Anwendungsfall hat einen Auslöser (also einen Akteur)</para></listitem>
+ <listitem><para>jeder Anwendungsfall führt zu einem relevanten Ergebnis (<quote>messbar und wirtschaftlich relevant</quote>)</para>
  </listitem>
  </itemizedlist>
 </para>
-<para
->Anwendungsfälle können untereinander in Verbindung stehen. Die 3 gebräuchlichsten Beziehungen zwischen Anwendungsfällen sind:</para>
+<para>Anwendungsfälle können untereinander in Verbindung stehen. Die 3 gebräuchlichsten Beziehungen zwischen Anwendungsfällen sind:</para>
 <itemizedlist>
-<listitem
-><para
-><emphasis
->&lt;&lt;include&gt;&gt;</emphasis
->, wodurch ausgesagt wird, dass ein Anwendungsfall <emphasis
->in</emphasis
-> einem anderen Anwendungsfall stattfindet.</para
-></listitem>
-<listitem
-><para
-><emphasis
->&lt;&lt;extends&gt;&gt;</emphasis
->, wodurch ausgesagt wird, dass in einer bestimmten Situation (oder einem bestimmten Erweiterungspunkt) der Anwendungsfall durch einen anderen erweitert wird.</para
-></listitem>
-<listitem
-><para
-><emphasis
->Verallgemeinerung</emphasis
->, wodurch ausgesagt wird, dass ein Anwendungsfall die Eigenschaften eines <quote
->Super</quote
->anwendungsfall (übergeordneten) erbt und diese überschreiben oder erweitern kann, ganz ähnlich wie bei der Vererbung zwischen Klassen. </para>
+<listitem><para><emphasis>&lt;&lt;include&gt;&gt;</emphasis>, wodurch ausgesagt wird, dass ein Anwendungsfall <emphasis>in</emphasis> einem anderen Anwendungsfall stattfindet.</para></listitem>
+<listitem><para><emphasis>&lt;&lt;extends&gt;&gt;</emphasis>, wodurch ausgesagt wird, dass in einer bestimmten Situation (oder einem bestimmten Erweiterungspunkt) der Anwendungsfall durch einen anderen erweitert wird.</para></listitem>
+<listitem><para><emphasis>Verallgemeinerung</emphasis>, wodurch ausgesagt wird, dass ein Anwendungsfall die Eigenschaften eines <quote>Super</quote>anwendungsfall (übergeordneten) erbt und diese überschreiben oder erweitern kann, ganz ähnlich wie bei der Vererbung zwischen Klassen. </para>
 </listitem>
 </itemizedlist>
 </sect3>
 <sect3 id="actor">
-<title
->Akteur</title>
-<para
->Ein Akteur ist ein externes Objekt (außerhalb des Systems), welches mit dem System durch die Teilnahme und Auslösung von Anwendungsfällen in Kontakt tritt. Akteure können echte Menschen (z.B. der Nutzer des Systems), Computersysteme oder externe Ereignisse sein. </para>
-<para
->Akteure stellen somit nicht die <emphasis
->physische</emphasis
-> Person oder System dar, sondern vielmehr die <emphasis
->Rollen</emphasis
-> dieser Objekte. Steht eine physische Person auf verschiedenen Wegen (z.B. durch verschiedene Rollen) mit dem System in Kontakt, dann wird sie durch verschiedene Akteure dargestellt. So würde eine Person, die im Kundensupport genauso wie in der Auftragsannahme tätig ist, einmal als Akteur <quote
->Supportmitarbeiter</quote
-> und einmal als Akteur <quote
->Vertriebsmitarbeiter</quote
-> dargestellt werden. </para>
+<title>Akteur</title>
+<para>Ein Akteur ist ein externes Objekt (außerhalb des Systems), welches mit dem System durch die Teilnahme und Auslösung von Anwendungsfällen in Kontakt tritt. Akteure können echte Menschen (z.B. der Nutzer des Systems), Computersysteme oder externe Ereignisse sein. </para>
+<para>Akteure stellen somit nicht die <emphasis>physische</emphasis> Person oder System dar, sondern vielmehr die <emphasis>Rollen</emphasis> dieser Objekte. Steht eine physische Person auf verschiedenen Wegen (z.B. durch verschiedene Rollen) mit dem System in Kontakt, dann wird sie durch verschiedene Akteure dargestellt. So würde eine Person, die im Kundensupport genauso wie in der Auftragsannahme tätig ist, einmal als Akteur <quote>Supportmitarbeiter</quote> und einmal als Akteur <quote>Vertriebsmitarbeiter</quote> dargestellt werden. </para>
 </sect3>
 <sect3 id="use-case-description">
-<title
->Anwendungsfallbeschreibung</title>
-<para
->Eine Anwendungsfallbeschreibung legt in Textform den Anwendungsfall dar. Normalerweise werden dazu Notizen oder sonstwie mit dem Anwendungsfall verlinkte Dokumente dargestellt und beschreiben die Prozesse oder Aktivitäten, die im Anwendungfall stattfinden. </para>
+<title>Anwendungsfallbeschreibung</title>
+<para>Eine Anwendungsfallbeschreibung legt in Textform den Anwendungsfall dar. Normalerweise werden dazu Notizen oder sonstwie mit dem Anwendungsfall verlinkte Dokumente dargestellt und beschreiben die Prozesse oder Aktivitäten, die im Anwendungfall stattfinden. </para>
 </sect3>
-</sect2
-> <!-- use-case-diagram -->
+</sect2> <!-- use-case-diagram -->
 
 <sect2 id="class-diagram">
-<title
->Klassendiagramm</title>
-<para
->Klassendiagramme zeigen die verschiedenen Klassen, aus denen das System besteht, und wie diese untereinander in Abhängigkeit stehen. Die Klassendiagramme werden als <quote
->statisch</quote
-> bezeichnet, da sie lediglich die Klassen mit ihren Methoden und Attributen sowie die statischen Verbindungen zwischen ihnen darstellen. Dabei wird gezeigt, welche Klassen von anderen Klassen <quote
->etwas wissen</quote
-> und welche Klassen <quote
->ein Teil</quote
-> von anderen Klassen sind. Es wird aber nicht der Nachrichtenaustausch (Methodenaufrufe) zwischen den Klassen dargestellt. </para>
+<title>Klassendiagramm</title>
+<para>Klassendiagramme zeigen die verschiedenen Klassen, aus denen das System besteht, und wie diese untereinander in Abhängigkeit stehen. Die Klassendiagramme werden als <quote>statisch</quote> bezeichnet, da sie lediglich die Klassen mit ihren Methoden und Attributen sowie die statischen Verbindungen zwischen ihnen darstellen. Dabei wird gezeigt, welche Klassen von anderen Klassen <quote>etwas wissen</quote> und welche Klassen <quote>ein Teil</quote> von anderen Klassen sind. Es wird aber nicht der Nachrichtenaustausch (Methodenaufrufe) zwischen den Klassen dargestellt. </para>
 <para>
 <screenshot>
-<screeninfo
->ein beispielhaftes Klassendiagramm</screeninfo>
+<screeninfo>ein beispielhaftes Klassendiagramm</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="class-diagram.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->&umbrello; bei der Darstellung eines Klassendiagrammes</phrase>
+	    <phrase>&umbrello; bei der Darstellung eines Klassendiagrammes</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->&umbrello; bei der Darstellung eines Klassendiagrammes </para>
+	    <para>&umbrello; bei der Darstellung eines Klassendiagrammes </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 </para>
 <sect3 id="class">
-<title
->Klasse</title>
-<para
->Eine Klasse definiert die Attribute und Methoden einer Menge von Objekten. Alle Objekte dieser Klasse (die Instanzen) haben das gleiche Verhalten und die selben Attribute (aber mit unterschiedlichen Werten). Der Begriff <quote
->Typ</quote
-> wird manchmal synonym für Klasse verwendet, aber es muss beachtet werden, dass Typ allgemeiner ist und daher die beiden Begriffe nicht identisch in ihrer Bedeutung sind. </para>
-<para
->In der &UML; werden Klassen als Rechtecke mit dem Klassennamen dargestellt. Sie können die Attribute und Operationen der Klasse in 2 extra <quote
->abgetrennten Bereichen</quote
-> innerhalb des Rechteck enthalten. </para>
+<title>Klasse</title>
+<para>Eine Klasse definiert die Attribute und Methoden einer Menge von Objekten. Alle Objekte dieser Klasse (die Instanzen) haben das gleiche Verhalten und die selben Attribute (aber mit unterschiedlichen Werten). Der Begriff <quote>Typ</quote> wird manchmal synonym für Klasse verwendet, aber es muss beachtet werden, dass Typ allgemeiner ist und daher die beiden Begriffe nicht identisch in ihrer Bedeutung sind. </para>
+<para>In der &UML; werden Klassen als Rechtecke mit dem Klassennamen dargestellt. Sie können die Attribute und Operationen der Klasse in 2 extra <quote>abgetrennten Bereichen</quote> innerhalb des Rechteck enthalten. </para>
 <para>
 <screenshot>
-<screeninfo
->eine Klasse in der &UML;</screeninfo>
+<screeninfo>eine Klasse in der &UML;</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="class.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->visuelle Darstellung einer Klasse in der &UML;</phrase>
+	    <phrase>visuelle Darstellung einer Klasse in der &UML;</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->visuelle Darstellung einer Klasse in der &UML; </para>
+	    <para>visuelle Darstellung einer Klasse in der &UML; </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 </para>
 <sect4 id="attribute">
-<title
->Attribut</title>
-<para
->In der &UML; werden Attribute mindestens mit ihrem Namen dargestellt, es können aber noch der Typ, der Anfangswert und weitere Eigenschaften mit angezeigt werden. So kann man z.B. die Sichtbarkeit von Attributen mit darstellen: </para>
+<title>Attribut</title>
+<para>In der &UML; werden Attribute mindestens mit ihrem Namen dargestellt, es können aber noch der Typ, der Anfangswert und weitere Eigenschaften mit angezeigt werden. So kann man z.B. die Sichtbarkeit von Attributen mit darstellen: </para>
 <itemizedlist>
-<listitem
-><para
-><literal
->+</literal
->, steht für <emphasis
->public</emphasis
-> (öffentliche) Attribute</para
-></listitem>
-<listitem
-><para
-><literal
->#</literal
->, steht für <emphasis
->protected</emphasis
-> (geschützte) Attribute</para
-></listitem>
-<listitem
-><para
-><literal
->-</literal
->, steht für <emphasis
->private</emphasis
-> Attribute</para
-></listitem>
+<listitem><para><literal>+</literal>, steht für <emphasis>public</emphasis> (öffentliche) Attribute</para></listitem>
+<listitem><para><literal>#</literal>, steht für <emphasis>protected</emphasis> (geschützte) Attribute</para></listitem>
+<listitem><para><literal>-</literal>, steht für <emphasis>private</emphasis> Attribute</para></listitem>
 </itemizedlist>
 </sect4>
 <sect4 id="operation">
-<title
->Operation</title>
-<para
->Operationen (Methoden) müssen ebenfalls mindestens mit ihrem Namen dargestellt werden und können weiterhin die Parameter und die Rückgabewerte in der Darstellung enthalten. Wie bei Attributen, ist die Sichtbarkeit ebenfalls darstellbar: <itemizedlist>
-<listitem
-><para
-><literal
->+</literal
->, steht für <emphasis
->public</emphasis
-> (öffentliche) Operationen</para
-></listitem>
-<listitem
-><para
-><literal
->#</literal
->, steht für <emphasis
->protected</emphasis
-> (geschützte) Operationen</para
-></listitem>
-<listitem
-><para
-><literal
->-</literal
->, steht für <emphasis
->private</emphasis
-> Operationen</para
-></listitem>
+<title>Operation</title>
+<para>Operationen (Methoden) müssen ebenfalls mindestens mit ihrem Namen dargestellt werden und können weiterhin die Parameter und die Rückgabewerte in der Darstellung enthalten. Wie bei Attributen, ist die Sichtbarkeit ebenfalls darstellbar: <itemizedlist>
+<listitem><para><literal>+</literal>, steht für <emphasis>public</emphasis> (öffentliche) Operationen</para></listitem>
+<listitem><para><literal>#</literal>, steht für <emphasis>protected</emphasis> (geschützte) Operationen</para></listitem>
+<listitem><para><literal>-</literal>, steht für <emphasis>private</emphasis> Operationen</para></listitem>
 </itemizedlist>
 </para>
 </sect4>
 
 <sect4 id="templates">
-<title
->Klassen-Templates</title>
-<para
->Klassen können als Klassen-Templates genutzt werden um zu zeigen, dass es sich um eine unspezifizierte Klasse oder Typ handelt. Der Klassentyp wird während der Instanzbildung (also Objekt wird angelegt) bestimmt. Template-Klassen gibt es in modernen Sprachen wie C++ und ab Java 1.5, wo sie Generics genannt werden. </para>
+<title>Klassen-Templates</title>
+<para>Klassen können als Klassen-Templates genutzt werden um zu zeigen, dass es sich um eine unspezifizierte Klasse oder Typ handelt. Der Klassentyp wird während der Instanzbildung (also Objekt wird angelegt) bestimmt. Template-Klassen gibt es in modernen Sprachen wie C++ und ab Java 1.5, wo sie Generics genannt werden. </para>
 </sect4>
 </sect3>
 
 <sect3 id="class-associations">
-<title
->Klassenassoziation</title>
-<para
->Klassen können sich auf unterschiedlichen Wegen aufeinander beziehen (assoziieren):</para>
+<title>Klassenassoziation</title>
+<para>Klassen können sich auf unterschiedlichen Wegen aufeinander beziehen (assoziieren):</para>
 <sect4 id="generalization">
-<title
->Verallgemeinerung</title>
-<para
->Die Vererbung ist ein Basiskonzept der objektorientierten Programmierung. Ein Klasse <quote
->erhält</quote
-> dabei alle Attribute und Operationen der Klasse, von der sie abgeleitet wird. Die Klasse kann diese Operationen/Attribute überschreiben und ändern, sowie neue hinzufügen.</para>
-<para
->In der &UML; wird durch die Assoziation <emphasis
->Verallgemeinerung</emphasis
-> zwischen 2 Klassen eine Hierarchie aufgebaut, die das Konzept von abgeleiteter Klasse und Basisklasse verkörpert. Die Verallgemeinerung zwischen 2 Klassen wird in der &UML; durch eine Linie zwischen den 2 Klassen dargestellt, wobei sich ein Pfeil auf der Seite der Basisklasse befindet. <screenshot>
-<screeninfo
->Verallgemeinerung</screeninfo>
+<title>Verallgemeinerung</title>
+<para>Die Vererbung ist ein Basiskonzept der objektorientierten Programmierung. Ein Klasse <quote>erhält</quote> dabei alle Attribute und Operationen der Klasse, von der sie abgeleitet wird. Die Klasse kann diese Operationen/Attribute überschreiben und ändern, sowie neue hinzufügen.</para>
+<para>In der &UML; wird durch die Assoziation <emphasis>Verallgemeinerung</emphasis> zwischen 2 Klassen eine Hierarchie aufgebaut, die das Konzept von abgeleiteter Klasse und Basisklasse verkörpert. Die Verallgemeinerung zwischen 2 Klassen wird in der &UML; durch eine Linie zwischen den 2 Klassen dargestellt, wobei sich ein Pfeil auf der Seite der Basisklasse befindet. <screenshot>
+<screeninfo>Verallgemeinerung</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="generalization.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->visuelle Darstellung der Verallgemeinerung in &UML;</phrase>
+	    <phrase>visuelle Darstellung der Verallgemeinerung in &UML;</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->visuelle Darstellung der Verallgemeinerung in &UML; </para>
+	    <para>visuelle Darstellung der Verallgemeinerung in &UML; </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
@@ -380,35 +171,21 @@
 </sect4>
 
 <sect4 id="uml-associations">
-<title
->Assoziation</title>
-<para
->Eine Assoziation stellt den Zusammenhang zwischen Klassen dar und beschreibt damit die allgemeine Bedeutung und Struktur verschiedenster Typen von <quote
->Verbindungen</quote
-> zwischen Objekten.</para>
-<para
->Assoziationen sind der Mechanismus, der es den Objekten erlaubt untereinander zu kommunizieren. Sie beschreiben die Verbindungen zwischen verschiedenen Klassen (die Verbindung zwischen den eigentlichen Objekten werden als Objektverbindungen oder als <emphasis
->Link</emphasis
-> bezeichnet). </para>
-<para
->Assoziationen können Rollen haben, die den Zweck der Verbindung beschreiben und entweder uni- oder bidirektional sind (ob die Verbindung zwischen den Objekten ein- oder zweiseitig ist). Beide Enden einer Assoziation verfügen über einen Multiplizitätswert, der angibt, wieviele Objekte auf der einen Seite mit wieviel Objekten auf der anderen Seite verbunden sein können. </para>
-<para
->In der &UML; wird die Assoziation durch eine Linie zwischen den in der Beziehung teilnehmenden Klassen dargestellt. Dabei kann die Rolle und die Multiplizität ebenfalls angezeigt werden. Multiplizität wird als Bereich [min..max] von nicht negativen Werten dargestellt, wobei der Stern (<literal
->*</literal
->) auf der Maximumseite einen unendlichen Wert repräsentiert. <screenshot>
-<screeninfo
->&UML; Assoziation</screeninfo>
+<title>Assoziation</title>
+<para>Eine Assoziation stellt den Zusammenhang zwischen Klassen dar und beschreibt damit die allgemeine Bedeutung und Struktur verschiedenster Typen von <quote>Verbindungen</quote> zwischen Objekten.</para>
+<para>Assoziationen sind der Mechanismus, der es den Objekten erlaubt untereinander zu kommunizieren. Sie beschreiben die Verbindungen zwischen verschiedenen Klassen (die Verbindung zwischen den eigentlichen Objekten werden als Objektverbindungen oder als <emphasis>Link</emphasis> bezeichnet). </para>
+<para>Assoziationen können Rollen haben, die den Zweck der Verbindung beschreiben und entweder uni- oder bidirektional sind (ob die Verbindung zwischen den Objekten ein- oder zweiseitig ist). Beide Enden einer Assoziation verfügen über einen Multiplizitätswert, der angibt, wieviele Objekte auf der einen Seite mit wieviel Objekten auf der anderen Seite verbunden sein können. </para>
+<para>In der &UML; wird die Assoziation durch eine Linie zwischen den in der Beziehung teilnehmenden Klassen dargestellt. Dabei kann die Rolle und die Multiplizität ebenfalls angezeigt werden. Multiplizität wird als Bereich [min..max] von nicht negativen Werten dargestellt, wobei der Stern (<literal>*</literal>) auf der Maximumseite einen unendlichen Wert repräsentiert. <screenshot>
+<screeninfo>&UML; Assoziation</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="association.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->visuelle Darstellung einer &UML; Assoziation</phrase>
+	    <phrase>visuelle Darstellung einer &UML; Assoziation</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->visuelle Darstellung einer &UML; Assoziation </para>
+	    <para>visuelle Darstellung einer &UML; Assoziation </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
@@ -416,365 +193,226 @@
 </sect4>
 
 <sect4 id="aggregation">
-<title
->Aggregation</title>
-<para
->Aggregationen sind eine Spezialart von Assoziationen. Dabei haben die verbundenen Klassen nicht den gleichen Status, sondern es wird eine <quote
->Teil eines Ganzes</quote
-> Beziehung dargestellt. Ein Aggregation beschreibt, wie die Klasse, die die Rolle des Ganzen vertritt, sich aus anderen Klassen, die die Rollen des Teil innehaben, zusammensetzt. Bei Aggregationen hat die Klasse mit der Rolle des Ganzen immer eine Multiplizität von 1. </para>
-<para
->In der &UML; werden Aggregationen durch Assoziationen dargestellt, wobei auf der Seite des Ganzen ein Rhombus ist. <screenshot>
-<screeninfo
->Aggregation</screeninfo>
+<title>Aggregation</title>
+<para>Aggregationen sind eine Spezialart von Assoziationen. Dabei haben die verbundenen Klassen nicht den gleichen Status, sondern es wird eine <quote>Teil eines Ganzes</quote> Beziehung dargestellt. Ein Aggregation beschreibt, wie die Klasse, die die Rolle des Ganzen vertritt, sich aus anderen Klassen, die die Rollen des Teil innehaben, zusammensetzt. Bei Aggregationen hat die Klasse mit der Rolle des Ganzen immer eine Multiplizität von 1. </para>
+<para>In der &UML; werden Aggregationen durch Assoziationen dargestellt, wobei auf der Seite des Ganzen ein Rhombus ist. <screenshot>
+<screeninfo>Aggregation</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="aggregation.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->visuelle Darstellung einer Aggregationsbeziehung in der &UML;</phrase>
+	    <phrase>visuelle Darstellung einer Aggregationsbeziehung in der &UML;</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->visuelle Darstellung einer Aggregationsbeziehung in der &UML; </para>
+	    <para>visuelle Darstellung einer Aggregationsbeziehung in der &UML; </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 </para>
 </sect4>
 <sect4 id="composition">
-<title
->Komposition</title>
-<para
->Kompositionen sind Assoziationen, die eine <emphasis
->sehr starke</emphasis
-> Aggregation darstellen. Das bedeutet, dass Kompositionen ebenfalls eine Teil eines Ganzen Beziehung darstellen, wobei die Beziehung aber so stark ist, dass die Teile nicht allein existieren können. Sie bestehen nur innerhalb des Ganzen und werden zerstört, wenn das Ganze zerstört wird.</para>
-<para
->In der &UML; werden Kompositionen durch ein ausgefülltes Rhombus auf der Seite des Ganzen dargestellt. </para>
-<para
-><screenshot>
-<screeninfo
->Komposition</screeninfo>
+<title>Komposition</title>
+<para>Kompositionen sind Assoziationen, die eine <emphasis>sehr starke</emphasis> Aggregation darstellen. Das bedeutet, dass Kompositionen ebenfalls eine Teil eines Ganzen Beziehung darstellen, wobei die Beziehung aber so stark ist, dass die Teile nicht allein existieren können. Sie bestehen nur innerhalb des Ganzen und werden zerstört, wenn das Ganze zerstört wird.</para>
+<para>In der &UML; werden Kompositionen durch ein ausgefülltes Rhombus auf der Seite des Ganzen dargestellt. </para>
+<para><screenshot>
+<screeninfo>Komposition</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="composition.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->visuelle Darstellung einer Kompositionsbeziehung in der &UML;</phrase>
+	    <phrase>visuelle Darstellung einer Kompositionsbeziehung in der &UML;</phrase>
 	  </textobject>
 	</mediaobject>
-</screenshot
-></para>
+</screenshot></para>
 </sect4>
-</sect3
-> <!--class-associations-->
+</sect3> <!--class-associations-->
 
 <sect3 id="other-class-diagram-items">
-<title
->Andere Klassendiagramm Elemente</title>
-<para
->Neben Klassen können weitere Elemente in einem Klassendiagramm dargestellt werden.</para>
+<title>Andere Klassendiagramm Elemente</title>
+<para>Neben Klassen können weitere Elemente in einem Klassendiagramm dargestellt werden.</para>
 <sect4 id="interfaces">
-<title
->Schnittstelle</title>
-<para
->Schnittstellen (Interfaces) sind abstrakte Klassen. Das bedeutet, von der Klasse können keine Instanzen direkt gebildet werden. Schnittstellen können Operationen aber keine Attribute beinhalten. Klassen können durch eine Realisierungsassoziation von Schnittstellen abgeleitet werden und von der Klasse können dann Instanzen gebildet werden.</para>
+<title>Schnittstelle</title>
+<para>Schnittstellen (Interfaces) sind abstrakte Klassen. Das bedeutet, von der Klasse können keine Instanzen direkt gebildet werden. Schnittstellen können Operationen aber keine Attribute beinhalten. Klassen können durch eine Realisierungsassoziation von Schnittstellen abgeleitet werden und von der Klasse können dann Instanzen gebildet werden.</para>
 <!-- FIXME screenshot -->
 </sect4>
 <sect4 id="datatype">
-<title
->Datentypen</title>
-<para
->Datentypen sind Primitive, die normalerweise in den Programmiersprachen verfügbar sind wie Integer und Boolean. Sie können keine Beziehung zu Klassen haben, aber Klassen zu ihnen.</para>
+<title>Datentypen</title>
+<para>Datentypen sind Primitive, die normalerweise in den Programmiersprachen verfügbar sind wie Integer und Boolean. Sie können keine Beziehung zu Klassen haben, aber Klassen zu ihnen.</para>
 <!-- FIXME screenshot -->
 </sect4>
 <sect4 id="enum">
-<title
->Aufzählungen</title>
-<para
->Aufzählungen sind eine einfache Liste von Werten. Ein typisches Beispiel für eine Aufzählung sind die Wochentage. Die einzelnen Einträge in der Aufzählung werden als Aufzählungswert bezeichnet. Wie Datentypen können sie keine Beziehung zu Klassen haben, aber Klassen können Beziehungen zu ihnen haben.</para>
+<title>Aufzählungen</title>
+<para>Aufzählungen sind eine einfache Liste von Werten. Ein typisches Beispiel für eine Aufzählung sind die Wochentage. Die einzelnen Einträge in der Aufzählung werden als Aufzählungswert bezeichnet. Wie Datentypen können sie keine Beziehung zu Klassen haben, aber Klassen können Beziehungen zu ihnen haben.</para>
 <!-- FIXME screenshot -->
 </sect4>
 <sect4 id="package">
-<title
->Pakete</title>
-<para
->Pakete stehen für Namensräume (Namespace) in Programmiersprachen. In einem Diagramm stehen sie stellvertretend für Teilsysteme, die aus mehr als einer Klasse, manchmal hunderte, bestehen können.</para>
+<title>Pakete</title>
+<para>Pakete stehen für Namensräume (Namespace) in Programmiersprachen. In einem Diagramm stehen sie stellvertretend für Teilsysteme, die aus mehr als einer Klasse, manchmal hunderte, bestehen können.</para>
 <!-- FIXME screenshot -->
 </sect4>
 </sect3>
 
-</sect2
-> <!-- class diagram -->
+</sect2> <!-- class diagram -->
 
 <sect2 id="sequence-diagram">
-<title
->Sequenzdiagramm</title>
+<title>Sequenzdiagramm</title>
 
-<para
->Sequenzdiagramme zeigen den Nachrichtenaustausch (also Methodenaufruf) zwischen Objekten in einem spezifischen Zeitrahmen. Dabei wird besondere Betonung auf die Reihenfolge und die Zeiten gelegt, in denen die Nachrichten an die Objekte gesendet werden.</para>
+<para>Sequenzdiagramme zeigen den Nachrichtenaustausch (also Methodenaufruf) zwischen Objekten in einem spezifischen Zeitrahmen. Dabei wird besondere Betonung auf die Reihenfolge und die Zeiten gelegt, in denen die Nachrichten an die Objekte gesendet werden.</para>
 
-<para
->Im Sequenzdiagramm wird das Objekt durch eine vertikal verlaufende gestrichelte Linie gekennzeichnet. Der Objektname befindet sich am oberen Ende. Die Zeitachse verläuft ebenfalls vertikal, wobei sie sich nach unten hin erhöht. Nachrichten zwischen den Objekten werden als Pfeile mit den Operationen- und Parameternamen gekennzeichnet. </para>
+<para>Im Sequenzdiagramm wird das Objekt durch eine vertikal verlaufende gestrichelte Linie gekennzeichnet. Der Objektname befindet sich am oberen Ende. Die Zeitachse verläuft ebenfalls vertikal, wobei sie sich nach unten hin erhöht. Nachrichten zwischen den Objekten werden als Pfeile mit den Operationen- und Parameternamen gekennzeichnet. </para>
 
 <!-- FIXME update screenshot to show synchronous messages -->
 <screenshot>
-<screeninfo
->Sequenzdiagramm</screeninfo>
+<screeninfo>Sequenzdiagramm</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="sequence-diagram.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->&umbrello; bei der Darstellung eines Sequenzdiagrammes</phrase>
+	    <phrase>&umbrello; bei der Darstellung eines Sequenzdiagrammes</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->&umbrello; bei der Darstellung eines Sequenzdiagrammes </para>
+	    <para>&umbrello; bei der Darstellung eines Sequenzdiagrammes </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 
-<para
->Nachrichten können synchron oder asynchron sein. Bei synchronen Nachrichten erfolgt ein normaler Nachrichtenaufruf und die Kontrolle wird an das gerufene Objekt übergeben. Asynchrone Aufrufe geben sofort die Kontrolle an das rufende Objekt zurück. Synchrone Nachrichten haben eine vertikale Box auf der Seite des gerufenen Objektes um den Programmverlauf darzustellen.</para>
-</sect2
-> <!-- sequence diagrams -->
+<para>Nachrichten können synchron oder asynchron sein. Bei synchronen Nachrichten erfolgt ein normaler Nachrichtenaufruf und die Kontrolle wird an das gerufene Objekt übergeben. Asynchrone Aufrufe geben sofort die Kontrolle an das rufende Objekt zurück. Synchrone Nachrichten haben eine vertikale Box auf der Seite des gerufenen Objektes um den Programmverlauf darzustellen.</para>
+</sect2> <!-- sequence diagrams -->
 
 <sect2 id="collaboration-diagram">
-<title
->Kollaborationsdiagramm</title>
+<title>Kollaborationsdiagramm</title>
 
-<para
->Kollaborationsdiagramme zeigen die Interaktionen zwischen Objekten, die an einer spezifischen Situation teilnehmen. Dies entspricht im Wesentlichen den Informationen aus dem Sequenzdiagramm, wobei bei diesen der Schwerpunkt auf dem zeitlichen Auftreten liegt. Bei Kollaborationsdiagramm wird hingegen vordergründig die Verbindung zwischen Objekten und ihrer Topologie gelegt.</para>
+<para>Kollaborationsdiagramme zeigen die Interaktionen zwischen Objekten, die an einer spezifischen Situation teilnehmen. Dies entspricht im Wesentlichen den Informationen aus dem Sequenzdiagramm, wobei bei diesen der Schwerpunkt auf dem zeitlichen Auftreten liegt. Bei Kollaborationsdiagramm wird hingegen vordergründig die Verbindung zwischen Objekten und ihrer Topologie gelegt.</para>
 
-<para
->Die Nachrichten zwischen den Objekten werden in Kollaborationsdiagrammen durch Pfeile dargestellt, an denen Name, Parameter und die Nachrichtensequenz steht. Die Kollaborationsdiagramme sind hervorragend dafür geeignet eine spezielle Programmabfolge oder Situation zu zeigen. Man kann damit sehr leicht und schnell einen Teil der Programmlogik demonstrieren und erklären. </para>
+<para>Die Nachrichten zwischen den Objekten werden in Kollaborationsdiagrammen durch Pfeile dargestellt, an denen Name, Parameter und die Nachrichtensequenz steht. Die Kollaborationsdiagramme sind hervorragend dafür geeignet eine spezielle Programmabfolge oder Situation zu zeigen. Man kann damit sehr leicht und schnell einen Teil der Programmlogik demonstrieren und erklären. </para>
 
 <screenshot>
-<screeninfo
->Kollaboration</screeninfo>
+<screeninfo>Kollaboration</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="collaboration-diagram.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->&umbrello; bei der Darstellung einnes Kollaborationdiagrammes</phrase>
+	    <phrase>&umbrello; bei der Darstellung einnes Kollaborationdiagrammes</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->&umbrello; bei der Darstellung einnes Kollaborationdiagrammes </para>
+	    <para>&umbrello; bei der Darstellung einnes Kollaborationdiagrammes </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 
-</sect2
-> <!-- collaboration diagrams -->
+</sect2> <!-- collaboration diagrams -->
 
 <sect2 id="state-diagram">
-<title
->Zustandsdiagramm</title>
-<para
->Zustandsdiagramme zeigen Objekte in ihren verschiedenen Zuständen während ihres Lebens und sie zeigen die Einflüsse, die die Objekte in einen anderen Zustand bringen. </para
->                              
-<para
->Zustandsdiagramme betrachten Objekte als <emphasis
->Zustandsmaschinen </emphasis
-> oder endliche Automaten, die in einer endlichen Anzahl von Zuständen sein können und die ihren Zustand durch eine endliche Anzahl von Einflüssen verändern. So kann sich zum Beispiel das Objekt <emphasis
->NetServer</emphasis
-> während seines Lebens in folgenden Zuständen befinden: </para>
+<title>Zustandsdiagramm</title>
+<para>Zustandsdiagramme zeigen Objekte in ihren verschiedenen Zuständen während ihres Lebens und sie zeigen die Einflüsse, die die Objekte in einen anderen Zustand bringen. </para>                              
+<para>Zustandsdiagramme betrachten Objekte als <emphasis>Zustandsmaschinen </emphasis> oder endliche Automaten, die in einer endlichen Anzahl von Zuständen sein können und die ihren Zustand durch eine endliche Anzahl von Einflüssen verändern. So kann sich zum Beispiel das Objekt <emphasis>NetServer</emphasis> während seines Lebens in folgenden Zuständen befinden: </para>
 <itemizedlist>
-<listitem
-><para
->bereit</para
-></listitem>
-<listitem
-><para
->wartend</para
-></listitem>
-<listitem
-><para
->arbeitend</para
-></listitem>
-<listitem
-><para
->angehalten</para
-></listitem>
+<listitem><para>bereit</para></listitem>
+<listitem><para>wartend</para></listitem>
+<listitem><para>arbeitend</para></listitem>
+<listitem><para>angehalten</para></listitem>
 </itemizedlist>
-<para
->und die Ereignisse, die eine Zustandsänderung des Objektes auslösen, könnten sein:</para>
+<para>und die Ereignisse, die eine Zustandsänderung des Objektes auslösen, könnten sein:</para>
 <itemizedlist>
-<listitem
-><para
->Objekt ist angelegt</para
-></listitem>
-<listitem
-><para
->Objekt erhält Nachricht zu warten</para
-></listitem>
-<listitem
-><para
->ein Client fordert eine Verbindung über ein Netzwerk an</para
-></listitem>
-<listitem
-><para
->ein Client beendet eine Anforderung</para
-></listitem>
-<listitem
-><para
->eine Anforderung wird bearbeitet und beendet</para
-></listitem>
-<listitem
-><para
->Objekt empfängt Nachricht anhalten</para
-></listitem>
-<listitem
-><para
->&etc;</para
-></listitem>
+<listitem><para>Objekt ist angelegt</para></listitem>
+<listitem><para>Objekt erhält Nachricht zu warten</para></listitem>
+<listitem><para>ein Client fordert eine Verbindung über ein Netzwerk an</para></listitem>
+<listitem><para>ein Client beendet eine Anforderung</para></listitem>
+<listitem><para>eine Anforderung wird bearbeitet und beendet</para></listitem>
+<listitem><para>Objekt empfängt Nachricht anhalten</para></listitem>
+<listitem><para>&etc;</para></listitem>
 </itemizedlist>
 <para>
 <screenshot>
-<screeninfo
->Zustandsdiagramm</screeninfo>
+<screeninfo>Zustandsdiagramm</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="state-diagram.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->Umbrello bei der Darstellung eines Zustanddiagrammes</phrase>
+	    <phrase>Umbrello bei der Darstellung eines Zustanddiagrammes</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->Umbrello bei der Darstellung eines Zustanddiagrammes </para>
+	    <para>Umbrello bei der Darstellung eines Zustanddiagrammes </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 </para>
 <sect3 id="state">
-<title
->Zustand</title>
-<para
->Zustände sind die Bausteine des Zustandsdiagrammes. Ein Zustand gehört zu genau einer Klasse und steht für eine bestimmte Konstellation der Attributwerte dieser Klasse. Somit beschreibt ein Zustand in der &UML; den internen Zustand eines Objektes einer bestimmten Klasse. </para
->                       
-<para
->Wichtig ist dabei, dass nicht jede Attributveränderung im Objekt zu einem neuen Zustand führen soll, sondern lediglich Attributwerte mit spürbaren Auswirkungen als Zustand des Objektes zu vermerken sind.</para>
-<para
->2 besondere Zustände sind Start und Ende. So kann es kein Ereignis geben, dass ein Objekt in seinen Startzustand zurückversetzt und kein Ereignis kann ein Objekt in einen anderen Zustand versetzen, wenn dieses bereits seinen Endzustand erreicht hat. </para>
+<title>Zustand</title>
+<para>Zustände sind die Bausteine des Zustandsdiagrammes. Ein Zustand gehört zu genau einer Klasse und steht für eine bestimmte Konstellation der Attributwerte dieser Klasse. Somit beschreibt ein Zustand in der &UML; den internen Zustand eines Objektes einer bestimmten Klasse. </para>                       
+<para>Wichtig ist dabei, dass nicht jede Attributveränderung im Objekt zu einem neuen Zustand führen soll, sondern lediglich Attributwerte mit spürbaren Auswirkungen als Zustand des Objektes zu vermerken sind.</para>
+<para>2 besondere Zustände sind Start und Ende. So kann es kein Ereignis geben, dass ein Objekt in seinen Startzustand zurückversetzt und kein Ereignis kann ein Objekt in einen anderen Zustand versetzen, wenn dieses bereits seinen Endzustand erreicht hat. </para>
 </sect3>
 
-</sect2
-> <!-- state diagrams -->
+</sect2> <!-- state diagrams -->
 
 <sect2 id="activity-diagram">
-<title
->Aktivitätsdiagramm</title>
-<para
->Aktivitätsdiagramme beschreiben die Abfolge von Aktivitäten in einem System. Sie sind dabei eine spezielle Form der Zustandsdiagramme, indem sie fast ausschließlich Aktivitäten beinhalten. </para>
+<title>Aktivitätsdiagramm</title>
+<para>Aktivitätsdiagramme beschreiben die Abfolge von Aktivitäten in einem System. Sie sind dabei eine spezielle Form der Zustandsdiagramme, indem sie fast ausschließlich Aktivitäten beinhalten. </para>
 <para>
 <screenshot>
-<screeninfo
->ein beispielhaftes Aktivitätsdiagramm</screeninfo>
+<screeninfo>ein beispielhaftes Aktivitätsdiagramm</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="activity-diagram.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->&umbrello; bei der Darstellung eines Aktivitätdiagrammes</phrase>
+	    <phrase>&umbrello; bei der Darstellung eines Aktivitätdiagrammes</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->&umbrello; bei der Darstellung eines Aktivitätdiagrammes </para>
+	    <para>&umbrello; bei der Darstellung eines Aktivitätdiagrammes </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 </para>
-<para
->Aktivitätsdiagramme sind den prozeduralen Flussdiagrammen sehr ähnlich. Der Unterschied ist, dass Aktivitäten klar an Objekte gekoppelt sind.</para>
-
-<para
->Aktivitätsdiagramme gehören immer eindeutig zu <emphasis
->Klassen</emphasis
->, <emphasis
->Operationen</emphasis
-> oder <emphasis
->Anwendungsfällen</emphasis
->.</para>
-
-<para
->In Aktivitätsdiagrammen können sowohl sequenzielle wie auch parallele Aktivitäten dargestellt werden. Parallele Bearbeitung wird mittels der Fork/Wait Symbole umgesetzt. Für parallel laufende Aktivitäten ist es dabei unerheblich, in welcher Reihenfolge sie ablaufen. Sie können zum gleichen Zeitpunkt aber auch nacheinander ausgeführt werden.</para>
+<para>Aktivitätsdiagramme sind den prozeduralen Flussdiagrammen sehr ähnlich. Der Unterschied ist, dass Aktivitäten klar an Objekte gekoppelt sind.</para>
+
+<para>Aktivitätsdiagramme gehören immer eindeutig zu <emphasis>Klassen</emphasis>, <emphasis>Operationen</emphasis> oder <emphasis>Anwendungsfällen</emphasis>.</para>
+
+<para>In Aktivitätsdiagrammen können sowohl sequenzielle wie auch parallele Aktivitäten dargestellt werden. Parallele Bearbeitung wird mittels der Fork/Wait Symbole umgesetzt. Für parallel laufende Aktivitäten ist es dabei unerheblich, in welcher Reihenfolge sie ablaufen. Sie können zum gleichen Zeitpunkt aber auch nacheinander ausgeführt werden.</para>
 <sect3 id="activity">
-<title
->Aktivität</title>
-<para
->Eine Aktivität ist ein einzelner Schritt in einem Prozess. Somit ist eine Aktivität ein Zustand des Systems mit einer internen Aktivität und mindestens einem Übergang. Es sind allerdings mehrere Übergänge möglich, wenn die Aktivität unterschiedliche Bedingungen enthält. </para
-> 
-<para
->Aktivitäten können eine Hierarchie bilden, indem man eine Aktivität aus anderen zusammensetzen kann. Dabei müssen die eingehenden und ausgehenden Übergänge mit den entsprechenden Übergängen in der Verfeinerung übereinstimmen. </para>
+<title>Aktivität</title>
+<para>Eine Aktivität ist ein einzelner Schritt in einem Prozess. Somit ist eine Aktivität ein Zustand des Systems mit einer internen Aktivität und mindestens einem Übergang. Es sind allerdings mehrere Übergänge möglich, wenn die Aktivität unterschiedliche Bedingungen enthält. </para> 
+<para>Aktivitäten können eine Hierarchie bilden, indem man eine Aktivität aus anderen zusammensetzen kann. Dabei müssen die eingehenden und ausgehenden Übergänge mit den entsprechenden Übergängen in der Verfeinerung übereinstimmen. </para>
 
 </sect3>
-</sect2
-> <!-- activity diagram -->
+</sect2> <!-- activity diagram -->
 
 <sect2 id="helper-elements">
-<title
->Hilfselemente</title>
-<para
->In der &UML; sind einige Elemente, die keine semantische Bedeutung für das Modell haben, aber Diagramme verständlicher machen können. Die Elemente sind: </para>
+<title>Hilfselemente</title>
+<para>In der &UML; sind einige Elemente, die keine semantische Bedeutung für das Modell haben, aber Diagramme verständlicher machen können. Die Elemente sind: </para>
 <itemizedlist>
-<listitem
-><para
->Textzeile</para
-></listitem>
-<listitem
-><para
->Textnotiz und entsprechende Verbindung</para
-></listitem>
-<listitem
-><para
->Rahmen</para
-></listitem>
-</itemizedlist
->   
-<para
->Mit der Textzeile kann eine Kurzinformation in das Diagramm eingefügt werden. Der Text ist freistehend und hat keine Bedeutung für das Modell. </para
->           
-
-<para
->Mittels der Textnotiz können detailierte Informationen über ein Objekt oder eine Situation eingefügt werden. Der große Vorteil der Textnotiz ist, dass sie mit einem &UML; Element verbunden werden kann und somit die Notiz zu diesem speziellen Objekt oder der speziellen Situation <quote
->gehört</quote
->. </para>
-
-<para
->Rahmen sind frei schwebende Rechtecke, die zur visuellen Gruppierung von Objekten in Diagrammen genutzt werden können. Sie machen ein Diagramm besser lesbar, haben aber keine logische Bedeutung für das Modell.</para>
+<listitem><para>Textzeile</para></listitem>
+<listitem><para>Textnotiz und entsprechende Verbindung</para></listitem>
+<listitem><para>Rahmen</para></listitem>
+</itemizedlist>   
+<para>Mit der Textzeile kann eine Kurzinformation in das Diagramm eingefügt werden. Der Text ist freistehend und hat keine Bedeutung für das Modell. </para>           
+
+<para>Mittels der Textnotiz können detailierte Informationen über ein Objekt oder eine Situation eingefügt werden. Der große Vorteil der Textnotiz ist, dass sie mit einem &UML; Element verbunden werden kann und somit die Notiz zu diesem speziellen Objekt oder der speziellen Situation <quote>gehört</quote>. </para>
+
+<para>Rahmen sind frei schwebende Rechtecke, die zur visuellen Gruppierung von Objekten in Diagrammen genutzt werden können. Sie machen ein Diagramm besser lesbar, haben aber keine logische Bedeutung für das Modell.</para>
 
 <!-- FIXME, screenshot -->
-</sect2
-> <!-- helper elements -->
+</sect2> <!-- helper elements -->
 
 <sect2 id="component-diagram">
-<title
->Komponentendiagramm</title>
-<para
->Komponentendiagramme stellen die Software Komponenten (entweder Komponententechnologien wie KParts, CORBA Komponenten oder Java Beans oder klar abgrenzbare Systemeinheiten) dar und die Resultate wie Quelltextdateien, Programmbibliotheken oder relationale Datenbanktabellen.</para>
+<title>Komponentendiagramm</title>
+<para>Komponentendiagramme stellen die Software Komponenten (entweder Komponententechnologien wie KParts, CORBA Komponenten oder Java Beans oder klar abgrenzbare Systemeinheiten) dar und die Resultate wie Quelltextdateien, Programmbibliotheken oder relationale Datenbanktabellen.</para>
 
-<para
->Komponenten können Schnittstellen (also abstrakte Klasse mit Operationen) enthalten, mit denen Verbindungen zwischen Komponenten möglich werden.</para>
+<para>Komponenten können Schnittstellen (also abstrakte Klasse mit Operationen) enthalten, mit denen Verbindungen zwischen Komponenten möglich werden.</para>
 </sect2>
 
 <sect2 id="deployment-diagram">
-<title
->Verteilungsdiagramm</title>
+<title>Verteilungsdiagramm</title>
 
-<para
->Verteilungsdiagramme zeigen die Laufzeitobjekte der Komponenten und ihre Beziehungen. Sie beinhalten Knoten als physische Ressourcen, typischerweise ein Computer. Weiterhin zeigen sie Schnittstellen und Objekte (Klasseninstanzen).</para>
+<para>Verteilungsdiagramme zeigen die Laufzeitobjekte der Komponenten und ihre Beziehungen. Sie beinhalten Knoten als physische Ressourcen, typischerweise ein Computer. Weiterhin zeigen sie Schnittstellen und Objekte (Klasseninstanzen).</para>
 
 </sect2>
 
-</sect1
-> 
+</sect1> 
 </chapter>
diff --git a/tde-i18n-de/docs/tdesdk/umbrello/working_with_umbrello.docbook b/tde-i18n-de/docs/tdesdk/umbrello/working_with_umbrello.docbook
index 0c13894d907..0b127fde832 100644
--- a/tde-i18n-de/docs/tdesdk/umbrello/working_with_umbrello.docbook
+++ b/tde-i18n-de/docs/tdesdk/umbrello/working_with_umbrello.docbook
@@ -1,407 +1,188 @@
 <chapter id="working-with-umbrello">
-<title
->Mit &umbrello; arbeiten</title>
+<title>Mit &umbrello; arbeiten</title>
 <!-- Umbrello basics: creating diagrams, creating classes, adding objects to diagrams,
    associations, editing properties, anchor points in associations, removing objects, removing
    diagrams
 -->
 
-<para
->Dieses Kapitel gibt eine Einführung in die Oberfläche von &umbrello; und vermittelt alle Kenntnisse, um sofort mit der Modellierung anzufangen. Wie normalerweise üblich, sind (fast) alle Aktionen über &umbrello;s Menus und Werkzeugleisten erreichbar. Allerdings nutzt &umbrello; ebenfalls sehr stark die über rechte Maustaste erreichbaren Kontextmenus. Man kann fast auf jedes Element in &umbrello;s Arbeitsbereich oder Baumansicht mit der rechten Maustaste klicken, um für das gewählte Element sinnvoll erscheinende Funktionen zu erreichen. Für einige Nutzer ist dies am Anfang sehr verwirrend, da sie meist die Arbeit über Menus und Werkzeugleisten gewöhnt sind. Aber hat man sich erst einmal an den <mousebutton
->Rechtsklick</mousebutton
-> gewöhnt, kann man sein Arbeitstempo wesentlich erhöhen. </para>
+<para>Dieses Kapitel gibt eine Einführung in die Oberfläche von &umbrello; und vermittelt alle Kenntnisse, um sofort mit der Modellierung anzufangen. Wie normalerweise üblich, sind (fast) alle Aktionen über &umbrello;s Menus und Werkzeugleisten erreichbar. Allerdings nutzt &umbrello; ebenfalls sehr stark die über rechte Maustaste erreichbaren Kontextmenus. Man kann fast auf jedes Element in &umbrello;s Arbeitsbereich oder Baumansicht mit der rechten Maustaste klicken, um für das gewählte Element sinnvoll erscheinende Funktionen zu erreichen. Für einige Nutzer ist dies am Anfang sehr verwirrend, da sie meist die Arbeit über Menus und Werkzeugleisten gewöhnt sind. Aber hat man sich erst einmal an den <mousebutton>Rechtsklick</mousebutton> gewöhnt, kann man sein Arbeitstempo wesentlich erhöhen. </para>
 
 <sect1 id="user-interface">
-<title
->Nutzeroberfläche</title>
-<para
->&umbrello;s Hauptfenster unterteilt sich in 3 Bereiche, die dabei helfen den Überblick über das gesamte System zu wahren, verschiedene Diagramme schnell aufzurufen und letztendlich am Modell zu arbeiten. </para>
-<para
->Diese Bereiche werden folgendermaßen bezeichnet:</para>
+<title>Nutzeroberfläche</title>
+<para>&umbrello;s Hauptfenster unterteilt sich in 3 Bereiche, die dabei helfen den Überblick über das gesamte System zu wahren, verschiedene Diagramme schnell aufzurufen und letztendlich am Modell zu arbeiten. </para>
+<para>Diese Bereiche werden folgendermaßen bezeichnet:</para>
 <itemizedlist>
-<listitem
-><para
->Baumansicht</para
-></listitem>
-<listitem
-><para
->Arbeitsbereich</para
-></listitem>
-<listitem
-><para
->Dokumentationsfenster</para
-></listitem>
+<listitem><para>Baumansicht</para></listitem>
+<listitem><para>Arbeitsbereich</para></listitem>
+<listitem><para>Dokumentationsfenster</para></listitem>
 </itemizedlist>
 
 <screenshot>
-<screeninfo
->&umbrello;s Nutzeroberfläche</screeninfo>
+<screeninfo>&umbrello;s Nutzeroberfläche</screeninfo>
 	<mediaobject>
 	  <imageobject>
 	    <imagedata fileref="umbrello-ui.png" format="PNG"/>
 	  </imageobject>
 	  <textobject>
-	    <phrase
->&umbrello;s Nutzeroberfläche</phrase>
+	    <phrase>&umbrello;s Nutzeroberfläche</phrase>
 	  </textobject>
 	  <caption>
-	    <para
->&umbrello;s Nutzeroberfläche </para>
+	    <para>&umbrello;s Nutzeroberfläche </para>
 	  </caption>
 	</mediaobject>
 </screenshot>
 
 <sect2 id="tree-view">
-<title
->Baumansicht</title>
-<para
->Die Baumansicht befindet sich am oberen linken Rand des Fensters und zeigt alle Diagramme, Klassen, Akteure und Anwendungsfälle, aus denen das Modell besteht. Mit der Baumansicht bekommt man einen schnellen Überblick über die Elemente, die das System formen. Weiterhin kann man mit der Baumansicht sehr elegant zwischen den einzelnen Diagrammen wechseln und Elemente aus dem Modell in das aktuelle Diagramm einfügen. </para>
-<para
->Besteht das Modell aus vielen Klassen und Diagrammen, hilft die Baumansicht bei der Wahrung der Übersicht, indem man das Modell mittels Ordnern besser organisiert. Man kann Ordner anlegen, indem man vom Kontextmenu (Klick mit rechter Maustaste auf ein Ordnerelement in der Baumansicht) den entsprechenden Befehl wählt. Die Elemente kann man einfach in die gewünschten Ordner mittels Drag'n Drop (Ziehen und Ablegen) verschieben. </para>
+<title>Baumansicht</title>
+<para>Die Baumansicht befindet sich am oberen linken Rand des Fensters und zeigt alle Diagramme, Klassen, Akteure und Anwendungsfälle, aus denen das Modell besteht. Mit der Baumansicht bekommt man einen schnellen Überblick über die Elemente, die das System formen. Weiterhin kann man mit der Baumansicht sehr elegant zwischen den einzelnen Diagrammen wechseln und Elemente aus dem Modell in das aktuelle Diagramm einfügen. </para>
+<para>Besteht das Modell aus vielen Klassen und Diagrammen, hilft die Baumansicht bei der Wahrung der Übersicht, indem man das Modell mittels Ordnern besser organisiert. Man kann Ordner anlegen, indem man vom Kontextmenu (Klick mit rechter Maustaste auf ein Ordnerelement in der Baumansicht) den entsprechenden Befehl wählt. Die Elemente kann man einfach in die gewünschten Ordner mittels Drag'n Drop (Ziehen und Ablegen) verschieben. </para>
 </sect2>
 
 <sect2 id="documentation-window">
-<title
->Dokumentationsfenster</title>
-<para
->Das Dokumentationsfenster ist das kleine Fenster am unteren linken Rand des &umbrello; Fensters. Es zeigt die für das aktuell gewählte Objekt hinterlegte Dokumentation. Das Dokumentationsfenster ist sehr klein, da es nur einen kurzen Einblick in die hinterlegte Dokumentation geben soll. Die komplette Dokumentation ist natürlich über die Eigenschaften des Elementes verfügbar. </para>
+<title>Dokumentationsfenster</title>
+<para>Das Dokumentationsfenster ist das kleine Fenster am unteren linken Rand des &umbrello; Fensters. Es zeigt die für das aktuell gewählte Objekt hinterlegte Dokumentation. Das Dokumentationsfenster ist sehr klein, da es nur einen kurzen Einblick in die hinterlegte Dokumentation geben soll. Die komplette Dokumentation ist natürlich über die Eigenschaften des Elementes verfügbar. </para>
 </sect2>
 <sect2 id="work-area">
-<title
->Arbeitsbereich</title>
-<para
->Der Arbeitsbereich ist der Hauptteil des Fensters. Hier findet die eigentliche Arbeit statt. Er wird zum bearbeiten und anschauen der im Modell hinterlegten Diagramme genutzt. Der Arbeitsbereich zeigt das aktuell aktive Diagramm. Momentan kann immer nur 1 Diagramm im Arbeitsbereich zu einem Zeitpunkt dargestellt werden. </para>
+<title>Arbeitsbereich</title>
+<para>Der Arbeitsbereich ist der Hauptteil des Fensters. Hier findet die eigentliche Arbeit statt. Er wird zum bearbeiten und anschauen der im Modell hinterlegten Diagramme genutzt. Der Arbeitsbereich zeigt das aktuell aktive Diagramm. Momentan kann immer nur 1 Diagramm im Arbeitsbereich zu einem Zeitpunkt dargestellt werden. </para>
 </sect2>
-</sect1
-> <!--user-interface-->
+</sect1> <!--user-interface-->
 <sect1 id="load-save">
-<title
->Erstellen, Laden und Speichern von Modellen</title>
-<para
->Um etwas Sinnvolles mit &umbrello; machen zu können, muss man zuerst ein Modell anlegen, an dem man arbeiten kann. Während &umbrello;s Start wird entweder das zuletzt bearbeitete Modell geladen oder ein neues leeres Modell angelegt. Die hängt von den Einstellungen im Einstellungsfenster ab. Dadurch kann man sofort mit der gewünschten Arbeit beginnen. </para>
+<title>Erstellen, Laden und Speichern von Modellen</title>
+<para>Um etwas Sinnvolles mit &umbrello; machen zu können, muss man zuerst ein Modell anlegen, an dem man arbeiten kann. Während &umbrello;s Start wird entweder das zuletzt bearbeitete Modell geladen oder ein neues leeres Modell angelegt. Die hängt von den Einstellungen im Einstellungsfenster ab. Dadurch kann man sofort mit der gewünschten Arbeit beginnen. </para>
 <sect2 id="new-model">
-<title
->Neues Modell</title>
-<para
->Um zu irgendeinem Zeitpunkt ein neues Modell anzulegen, wählt man <guimenuitem
->Neu</guimenuitem
-> aus dem <guimenu
->Dateimenu</guimenu
-> oder klickt auf das <guiicon
->Neu</guiicon
-> Symbol in der horizontalen Werkzeugleiste. Arbeitet man gerade an einem Modell, fragt &umbrello; zuerst nach, ob man das aktuelle Modell nicht speichern will, bevor man ein neues Element anlegt. </para>
+<title>Neues Modell</title>
+<para>Um zu irgendeinem Zeitpunkt ein neues Modell anzulegen, wählt man <guimenuitem>Neu</guimenuitem> aus dem <guimenu>Dateimenu</guimenu> oder klickt auf das <guiicon>Neu</guiicon> Symbol in der horizontalen Werkzeugleiste. Arbeitet man gerade an einem Modell, fragt &umbrello; zuerst nach, ob man das aktuelle Modell nicht speichern will, bevor man ein neues Element anlegt. </para>
 </sect2>
 <sect2 id="save-model">
-<title
->Modell speichern</title>
-<para
->Man kann zu jedem Zeitpunkt das Modell speichern indem man den <guimenuitem
->Speichern</guimenuitem
->Eintrag aus dem <guimenu
->Datei</guimenu
-> Menu wählt, oder auf das entsprechende Symbol in der horizontalen Werkzeugleiste klickt. Soll das Modell unter einem anderen Dateinamen gespeichert werden, wählt man den Eintrag <guimenuitem
->Speichern unter ...</guimenuitem
-> aus dem <guimenu
->Datei</guimenu
-> Menu. </para>
-<para
->Zur Absicherung bietet &umbrello; die Möglichkeit, das Modell automatisch nach einem bestimmten Zeitabschnitt zu speichern. Man kann diese Möglichkeit und das Zeitintervall in &umbrello;s <guimenu
->Einstellungen</guimenu
-> definieren.</para>
+<title>Modell speichern</title>
+<para>Man kann zu jedem Zeitpunkt das Modell speichern indem man den <guimenuitem>Speichern</guimenuitem>Eintrag aus dem <guimenu>Datei</guimenu> Menu wählt, oder auf das entsprechende Symbol in der horizontalen Werkzeugleiste klickt. Soll das Modell unter einem anderen Dateinamen gespeichert werden, wählt man den Eintrag <guimenuitem>Speichern unter ...</guimenuitem> aus dem <guimenu>Datei</guimenu> Menu. </para>
+<para>Zur Absicherung bietet &umbrello; die Möglichkeit, das Modell automatisch nach einem bestimmten Zeitabschnitt zu speichern. Man kann diese Möglichkeit und das Zeitintervall in &umbrello;s <guimenu>Einstellungen</guimenu> definieren.</para>
 </sect2>
 <sect2 id="load-model">
-<title
->Modell laden</title>
-<para
->Um ein bereits existierendes Modell zu laden, muss man <guimenuitem
->Öffnen</guimenuitem
-> aus dem <guimenu
->Datei</guimenu
-> Menu oder das entsprechende Symbol aus der horizontalen Werkzeugleiste wählen. Die zuletzt bearbeiteten Modelle sind ebenfalls über das Untermenu <guimenuitem
->Zuletzt geöffnete Dateien</guimenuitem
-> im <guimenu
->Datei</guimenu
-> Menu verfügbar. Dadurch kann man häufig verwendete Modelle wesentlich schneller aufrufen. </para>
-<para
->Mit &umbrello; kann man immer nur an einem Modell gleichzeitig arbeiten. Fordert man das Programm zum Laden eines anderen Modells auf und wurde das momentan bearbeitete Modell seit dem letzten Speichern verändert, fragt &umbrello; nach, ob man die Änderungen nicht zuerst speichern will. Dadurch wird ein möglicher Datenverlust verhindert. Man kann aber mehrere Instanzen von &umbrello; starten und auch zwischen den Instanzen Objekte kopieren und einfügen. </para>
+<title>Modell laden</title>
+<para>Um ein bereits existierendes Modell zu laden, muss man <guimenuitem>Öffnen</guimenuitem> aus dem <guimenu>Datei</guimenu> Menu oder das entsprechende Symbol aus der horizontalen Werkzeugleiste wählen. Die zuletzt bearbeiteten Modelle sind ebenfalls über das Untermenu <guimenuitem>Zuletzt geöffnete Dateien</guimenuitem> im <guimenu>Datei</guimenu> Menu verfügbar. Dadurch kann man häufig verwendete Modelle wesentlich schneller aufrufen. </para>
+<para>Mit &umbrello; kann man immer nur an einem Modell gleichzeitig arbeiten. Fordert man das Programm zum Laden eines anderen Modells auf und wurde das momentan bearbeitete Modell seit dem letzten Speichern verändert, fragt &umbrello; nach, ob man die Änderungen nicht zuerst speichern will. Dadurch wird ein möglicher Datenverlust verhindert. Man kann aber mehrere Instanzen von &umbrello; starten und auch zwischen den Instanzen Objekte kopieren und einfügen. </para>
 </sect2>
-</sect1
->  <!--load-save-->
+</sect1>  <!--load-save-->
 <sect1 id="edit-model">
-<title
->Modelle bearbeiten</title>
-<para
->In &umbrello; gibt es prinzipiell 2 Möglichkeiten die Elemente des Modells zu verändern. <itemizedlist>
-<listitem
-><para
->Man kann die Elemente direkt in der Baumansicht bearbeiten.</para
-></listitem>
-<listitem
-><para
->Man kann die Elemente in den Diagrammen bearbeiten.</para
-></listitem>
+<title>Modelle bearbeiten</title>
+<para>In &umbrello; gibt es prinzipiell 2 Möglichkeiten die Elemente des Modells zu verändern. <itemizedlist>
+<listitem><para>Man kann die Elemente direkt in der Baumansicht bearbeiten.</para></listitem>
+<listitem><para>Man kann die Elemente in den Diagrammen bearbeiten.</para></listitem>
 </itemizedlist>
 </para>
-<para
->Über das mit der rechten Maustaste erreichbare Kontextmenu kann man in der Baumansicht fast alle Elemente des Modells hinzufügen, entfernen oder verändern. Klickt man zum Beispiel mit der <mousebutton
->rechten</mousebutton
-> Maustaste auf einen Ordner in der Baumansicht, kann man eines der verschiedenen Diagramme sowie Akteure, Klassen und Anwendungsfälle anlegen, je nachdem ob der Ordner der <emphasis
->logischen Sicht</emphasis
-> oder der <emphasis
->Anwendungsfallsicht</emphasis
-> untergeordnet ist. </para>
-<para
->Nachdem man ein Element dem Modell hinzugefügt hat, kann man seine Eigenschaften über den Eigenschaftendialog ändern. Diesen erreicht man über den Punkt <emphasis
->Eigenschaften</emphasis
-> aus dem Kontextmenu des jeweiligen Elements. </para>
-<para
->Weiterhin kann man das Modell durch das Anlegen und Ändern von Elementen in den Diagrammen bearbeiten. Weitere Details, wie das geht, sind in den folgenden Abschnitten zu finden. </para>
+<para>Über das mit der rechten Maustaste erreichbare Kontextmenu kann man in der Baumansicht fast alle Elemente des Modells hinzufügen, entfernen oder verändern. Klickt man zum Beispiel mit der <mousebutton>rechten</mousebutton> Maustaste auf einen Ordner in der Baumansicht, kann man eines der verschiedenen Diagramme sowie Akteure, Klassen und Anwendungsfälle anlegen, je nachdem ob der Ordner der <emphasis>logischen Sicht</emphasis> oder der <emphasis>Anwendungsfallsicht</emphasis> untergeordnet ist. </para>
+<para>Nachdem man ein Element dem Modell hinzugefügt hat, kann man seine Eigenschaften über den Eigenschaftendialog ändern. Diesen erreicht man über den Punkt <emphasis>Eigenschaften</emphasis> aus dem Kontextmenu des jeweiligen Elements. </para>
+<para>Weiterhin kann man das Modell durch das Anlegen und Ändern von Elementen in den Diagrammen bearbeiten. Weitere Details, wie das geht, sind in den folgenden Abschnitten zu finden. </para>
 </sect1>
 <sect1 id="add-remove-diagrams">
-<title
->Diagramme hinzufügen und entfernen</title>
-<para
->Das &UML; Modell besteht aus &UML; Elementen und den Assoziationen zwischen diesen. Man kann aber das Modell nicht direkt sehen, sondern man nutzt <emphasis
->Diagramme</emphasis
->, um es zu betrachten. </para>
+<title>Diagramme hinzufügen und entfernen</title>
+<para>Das &UML; Modell besteht aus &UML; Elementen und den Assoziationen zwischen diesen. Man kann aber das Modell nicht direkt sehen, sondern man nutzt <emphasis>Diagramme</emphasis>, um es zu betrachten. </para>
 <sect2 id="create-diagram">
-<title
->Diagramme anlegen</title>
-<para
->Um ein neues Diagramm dem Modell hinzufügen, muss man lediglich den Diagrammtyp aus dem Untermenu <guimenuitem
->Neu</guimenuitem
-> aus dem <guimenu
->Diagramm</guimenu
-> Menu wählen und dem Kind einen Namen geben. Das Diagramm wird angelegt und als aktives Diagramm für den Arbeitsplatz ausgewählt. Es taucht sofort in der Baumansicht auf. </para>
-<para
->Man sollte sich daran erinnern, dass &umbrello; sehr starken Gebrauch von den Kontextmenus, erreichbar über die rechte Maustaste, macht. So kann man auf einen Ordner in der Baumansicht mit der rechten Maustaste klicken und aus dem Untermenu <guisubmenu
->Neu</guisubmenu
-> den gewünschten Typ auswählen. Es ist zu beachten, dass man in der Anwendungsfallsicht lediglich Anwendungsfalldiagramme hinzufügen kann und in der logischen Sicht alle anderen Diagrammtypen. </para>
+<title>Diagramme anlegen</title>
+<para>Um ein neues Diagramm dem Modell hinzufügen, muss man lediglich den Diagrammtyp aus dem Untermenu <guimenuitem>Neu</guimenuitem> aus dem <guimenu>Diagramm</guimenu> Menu wählen und dem Kind einen Namen geben. Das Diagramm wird angelegt und als aktives Diagramm für den Arbeitsplatz ausgewählt. Es taucht sofort in der Baumansicht auf. </para>
+<para>Man sollte sich daran erinnern, dass &umbrello; sehr starken Gebrauch von den Kontextmenus, erreichbar über die rechte Maustaste, macht. So kann man auf einen Ordner in der Baumansicht mit der rechten Maustaste klicken und aus dem Untermenu <guisubmenu>Neu</guisubmenu> den gewünschten Typ auswählen. Es ist zu beachten, dass man in der Anwendungsfallsicht lediglich Anwendungsfalldiagramme hinzufügen kann und in der logischen Sicht alle anderen Diagrammtypen. </para>
 </sect2>
 <sect2 id="remove-diagram">
-<title
->Diagramme entfernen</title>
-<para
->Will man ein Diagramm aus dem Modell entfernen, muss man es aktivieren und dann <guimenuitem
->Löschen</guimenuitem
-> aus dem <guimenu
->Diagramm</guimenu
-> Menu aufrufen. Man kann dies ebenfalls über den <guisubmenu
->Löschen</guisubmenu
-> Eintrag im Kontextmenu des entsprechenden Diagramms in der Baumansicht machen. </para>
-<para
->Da das Löschen eines Diagramms ein ernster Eingriff ist, der Datenverlust verursachen kann, falls es unbeabsichtigt passiert, fragt &umbrello; um Bestätigung, bevor die Löschoperation ausgeführt wird. Wurde das Diagramm einmal gelöscht und die Datei gespeichert, gibt es keine Möglichkeit, die Aktion rückgängig zu machen! </para>
+<title>Diagramme entfernen</title>
+<para>Will man ein Diagramm aus dem Modell entfernen, muss man es aktivieren und dann <guimenuitem>Löschen</guimenuitem> aus dem <guimenu>Diagramm</guimenu> Menu aufrufen. Man kann dies ebenfalls über den <guisubmenu>Löschen</guisubmenu> Eintrag im Kontextmenu des entsprechenden Diagramms in der Baumansicht machen. </para>
+<para>Da das Löschen eines Diagramms ein ernster Eingriff ist, der Datenverlust verursachen kann, falls es unbeabsichtigt passiert, fragt &umbrello; um Bestätigung, bevor die Löschoperation ausgeführt wird. Wurde das Diagramm einmal gelöscht und die Datei gespeichert, gibt es keine Möglichkeit, die Aktion rückgängig zu machen! </para>
 </sect2>
 <sect2 id="rename-diagram">
-<title
->Diagramme umbenennen</title>
-<para
->Will man ein Diagramm umbenennen, kann man dies durch den <guisubmenu
->Umbenennen</guisubmenu
-> Eintrag im Kontextmenu des Diagramms in der Baumansicht erreichen. </para>
-<para
->Ein anderer Weg ist der Eigenschaftendialog des Diagramms, der durch den Eintrag Eigenschaften aus dem über die rechte Maustaste erreichbaren Kontextmenus des Diagramms aufgerufen werden kann. Weiterhin kann man in der Baumansicht mit einem Doppelklick auf das Diagramm den Eigenschaftendialog ebenfalls aufrufen. </para>
+<title>Diagramme umbenennen</title>
+<para>Will man ein Diagramm umbenennen, kann man dies durch den <guisubmenu>Umbenennen</guisubmenu> Eintrag im Kontextmenu des Diagramms in der Baumansicht erreichen. </para>
+<para>Ein anderer Weg ist der Eigenschaftendialog des Diagramms, der durch den Eintrag Eigenschaften aus dem über die rechte Maustaste erreichbaren Kontextmenus des Diagramms aufgerufen werden kann. Weiterhin kann man in der Baumansicht mit einem Doppelklick auf das Diagramm den Eigenschaftendialog ebenfalls aufrufen. </para>
 </sect2>
 </sect1>
 <sect1 id="edit-diagram">
-<title
->Diagramme bearbeiten</title>
-<para
->Während der Arbeit mit Diagrammen versucht &umbrello; einen durch die Anwendung einfacher Regeln zu unterstützen, indem nur die möglichen Elemente in einem Diagramm zur Verfügung stehen und nur die sinnvollen Beziehungen zwischen diesen angelegt werden können. Als &UML; Experte wird man dies vielleicht gar nicht bemerken, für Anfänger ist es eine große Unterstützung bei der Erstellung von standardkonformen Diagrammen. </para>
-<para
->Nachdem man ein Diagramm angelegt hat, kann man es bearbeiten. Es ist dabei der Unterschied zwischen Diagramm- und Modellbearbeitung, für Anfänger schwieriger verständlich, zu beachten. Wie bereits dargelegt wurde, sind Diagramme eine <emphasis
->Sicht</emphasis
-> auf das <emphasis
->Modell</emphasis
->. Legt man zum Beispiel in einem Klassendiagramm eine Klasse an, dann bearbeitet man eigentlich sowohl Modell wie auch Diagramm. Ändert man hingegen lediglich die Farbe oder andere Darstellungsoptionen einer Klasse in einem Klassendiagramm, dann wird dadurch lediglich das Diagramm, aber nicht das Modell verändert. </para>
+<title>Diagramme bearbeiten</title>
+<para>Während der Arbeit mit Diagrammen versucht &umbrello; einen durch die Anwendung einfacher Regeln zu unterstützen, indem nur die möglichen Elemente in einem Diagramm zur Verfügung stehen und nur die sinnvollen Beziehungen zwischen diesen angelegt werden können. Als &UML; Experte wird man dies vielleicht gar nicht bemerken, für Anfänger ist es eine große Unterstützung bei der Erstellung von standardkonformen Diagrammen. </para>
+<para>Nachdem man ein Diagramm angelegt hat, kann man es bearbeiten. Es ist dabei der Unterschied zwischen Diagramm- und Modellbearbeitung, für Anfänger schwieriger verständlich, zu beachten. Wie bereits dargelegt wurde, sind Diagramme eine <emphasis>Sicht</emphasis> auf das <emphasis>Modell</emphasis>. Legt man zum Beispiel in einem Klassendiagramm eine Klasse an, dann bearbeitet man eigentlich sowohl Modell wie auch Diagramm. Ändert man hingegen lediglich die Farbe oder andere Darstellungsoptionen einer Klasse in einem Klassendiagramm, dann wird dadurch lediglich das Diagramm, aber nicht das Modell verändert. </para>
 <sect2 id="insert-elements">
-<title
->Elemente einfügen</title>
-<para
->Eines der ersten Dinge mit einem neuen Diagramm ist es, Elemente wie Klassen, Akteure oder Anwendungsfälle einzufügen. Es gibt prinzipiell 2 Möglichkeiten, wie dies geschehen kann.</para>
+<title>Elemente einfügen</title>
+<para>Eines der ersten Dinge mit einem neuen Diagramm ist es, Elemente wie Klassen, Akteure oder Anwendungsfälle einzufügen. Es gibt prinzipiell 2 Möglichkeiten, wie dies geschehen kann.</para>
 <itemizedlist>
-<listitem
-><para
->Existierende Elemente aus der Baumansicht in das Diagramm schieben.</para
-></listitem>
-<listitem
-><para
->Ein neues Element mithilfe der Werkzeuge in der vertikalen Werkzeugleiste anlegen und gleichzeitig dem aktiven Diagramm hinzuzufügen.</para
-></listitem>
+<listitem><para>Existierende Elemente aus der Baumansicht in das Diagramm schieben.</para></listitem>
+<listitem><para>Ein neues Element mithilfe der Werkzeuge in der vertikalen Werkzeugleiste anlegen und gleichzeitig dem aktiven Diagramm hinzuzufügen.</para></listitem>
 </itemizedlist>
-<para
->Um ein im Modell bereits existierendes Element in das aktuelle Diagramm einzufügen, muss man es lediglich von der Baumansicht in das Diagramm an die gewünschte Stelle ziehen. Man kann das Element jederzeit mit dem Auswahlwerkzeug im Diagramm verschieben. </para>
-<para
->Die zweite Möglichkeit Elemente hinzuzufügen ist es, eines der Werkzeuge aus der vertikalen Werkzeugleiste am rechten Bildschirmrand zu benutzen. Dabei wird das Element ebenfalls dem Modell hinzugefügt. </para>
-<para
->Die vertikale Werkzeugleiste befindet sich standardmäßig am rechten Fensterrand des Anwendungsfensters, man kann sie allerdings an andere Stellen verschieben oder sie über allen anderen Bereichen schwebend positionieren. Die in dieser Werkzeugleiste verfügbaren Werkzeuge, dargestellt durch die verschiedenen Knöpfe, ändern sich je nach momentan bearbeiteten Diagrammtyp. Das momentan gewählte Werkzeug wird hervorgehoben in der Werkzeuglaste dargestellt. Über die <keycap
->&Esc;</keycap
-> Taste kann man das Auswahl-Werkzeug auswählen. </para>
-<para
->Hat man ein Bearbeitungswerkzeug aus der Werkzeugleiste ausgewählt, zum Beispiel um eine Klasse einzufügen, ändert sich der Mauszeiger in ein Kreuz. Man kann nun das Element in das Diagramm über einen einzelnen Klick mit der linken Maustaste im Diagramm einfügen. &UML; Elemente müssen immer <emphasis
->eindeutige Namen</emphasis
-> haben. Gibt es zum Beispiel in einem Diagramm die Klasse <quote
->KlasseA</quote
->, dann kann man in einem anderen Diagramm keine neue Klasse mit dem gleichen Namen einfügen. Soll es sich bei den beiden Klassen um unterschiedliche Elemente handeln, dann müssen diese auch unterschiedliche Namen haben. Um das <emphasis
->gleiche</emphasis
-> Element nochmals einzufügen, ist das Werkzeug Klasse einfügen nicht das richtige Hilfsmitteln. Man muss in solch einem Fall lediglich die gewünschte Klasse aus der Baumansicht in das Diagramm ziehen. </para>
+<para>Um ein im Modell bereits existierendes Element in das aktuelle Diagramm einzufügen, muss man es lediglich von der Baumansicht in das Diagramm an die gewünschte Stelle ziehen. Man kann das Element jederzeit mit dem Auswahlwerkzeug im Diagramm verschieben. </para>
+<para>Die zweite Möglichkeit Elemente hinzuzufügen ist es, eines der Werkzeuge aus der vertikalen Werkzeugleiste am rechten Bildschirmrand zu benutzen. Dabei wird das Element ebenfalls dem Modell hinzugefügt. </para>
+<para>Die vertikale Werkzeugleiste befindet sich standardmäßig am rechten Fensterrand des Anwendungsfensters, man kann sie allerdings an andere Stellen verschieben oder sie über allen anderen Bereichen schwebend positionieren. Die in dieser Werkzeugleiste verfügbaren Werkzeuge, dargestellt durch die verschiedenen Knöpfe, ändern sich je nach momentan bearbeiteten Diagrammtyp. Das momentan gewählte Werkzeug wird hervorgehoben in der Werkzeuglaste dargestellt. Über die <keycap>&Esc;</keycap> Taste kann man das Auswahl-Werkzeug auswählen. </para>
+<para>Hat man ein Bearbeitungswerkzeug aus der Werkzeugleiste ausgewählt, zum Beispiel um eine Klasse einzufügen, ändert sich der Mauszeiger in ein Kreuz. Man kann nun das Element in das Diagramm über einen einzelnen Klick mit der linken Maustaste im Diagramm einfügen. &UML; Elemente müssen immer <emphasis>eindeutige Namen</emphasis> haben. Gibt es zum Beispiel in einem Diagramm die Klasse <quote>KlasseA</quote>, dann kann man in einem anderen Diagramm keine neue Klasse mit dem gleichen Namen einfügen. Soll es sich bei den beiden Klassen um unterschiedliche Elemente handeln, dann müssen diese auch unterschiedliche Namen haben. Um das <emphasis>gleiche</emphasis> Element nochmals einzufügen, ist das Werkzeug Klasse einfügen nicht das richtige Hilfsmitteln. Man muss in solch einem Fall lediglich die gewünschte Klasse aus der Baumansicht in das Diagramm ziehen. </para>
 </sect2>
 <sect2 id="delete-elements">
-<title
->Elemente löschen</title>
-<para
->Man kann jedes Element über den Eintrag <guimenuitem
->Löschen</guimenuitem
-> aus dem Kontextmenu entfernen. </para>
-<para
->Hier zeigt sich wiederum der <emphasis
->große</emphasis
-> Unterschied zwischen einem Element aus einem Diagramm und einem Element aus dem Modell zu entfernen. Löscht man ein Element in einem Diagramm, dann wird es nur aus diesem speziellen Diagramm entfernt. Das Element ist aber weiterhin Teil des Modells und falls es in anderen Diagrammen genutzt wird, werden diese nicht verändert. Löscht man hingegen das Element in der Baumansicht, dann löscht man das Element im ganzen <emphasis
->Modell</emphasis
->. Da das Element dann nicht länger im Modell existiert, wird es ebenfalls in allen Diagrammen gelöscht, in denen es verwendet wird. </para>
+<title>Elemente löschen</title>
+<para>Man kann jedes Element über den Eintrag <guimenuitem>Löschen</guimenuitem> aus dem Kontextmenu entfernen. </para>
+<para>Hier zeigt sich wiederum der <emphasis>große</emphasis> Unterschied zwischen einem Element aus einem Diagramm und einem Element aus dem Modell zu entfernen. Löscht man ein Element in einem Diagramm, dann wird es nur aus diesem speziellen Diagramm entfernt. Das Element ist aber weiterhin Teil des Modells und falls es in anderen Diagrammen genutzt wird, werden diese nicht verändert. Löscht man hingegen das Element in der Baumansicht, dann löscht man das Element im ganzen <emphasis>Modell</emphasis>. Da das Element dann nicht länger im Modell existiert, wird es ebenfalls in allen Diagrammen gelöscht, in denen es verwendet wird. </para>
 </sect2>
 <sect2 id="edit-elements">
-<title
->Elemente bearbeiten</title>
-<para
->Man kann die meisten &UML; Elemente des Modells ändern, indem man den Eigenschaftdialog öffnet und die gewünschten Änderungen vornimmt. Um zum Beispiel ein Objekt zu verändern, ist es auszuwählen und dann <guimenuitem
->Eigenschaften</guimenuitem
-> aus seinem Kontextmenu (rechte Maustaste) zu wählen. Jedes Element verfügt über solch einen Dialog, der aus mehreren Seiten besteht, abhängig vom Typ des zu bearbeitenden Elementes. Für einige Elemente, wie Akteure, kann man lediglich einige wenige Parameter wie den Namen oder die Dokumentation ändern. Für andere Elemente hingegen, wie Klassen, kann man viele Einstellungen vornehmen wie Attribute und Operationen, Sichtbarkeit und die Darstellung im Diagramm (nur Operationen oder komplette Signatur der Operationen). Man kann sogar die Linienfarben und die Füllfarbe für die Visualisierung der Klasse im Diagramm einstellen. </para>
+<title>Elemente bearbeiten</title>
+<para>Man kann die meisten &UML; Elemente des Modells ändern, indem man den Eigenschaftdialog öffnet und die gewünschten Änderungen vornimmt. Um zum Beispiel ein Objekt zu verändern, ist es auszuwählen und dann <guimenuitem>Eigenschaften</guimenuitem> aus seinem Kontextmenu (rechte Maustaste) zu wählen. Jedes Element verfügt über solch einen Dialog, der aus mehreren Seiten besteht, abhängig vom Typ des zu bearbeitenden Elementes. Für einige Elemente, wie Akteure, kann man lediglich einige wenige Parameter wie den Namen oder die Dokumentation ändern. Für andere Elemente hingegen, wie Klassen, kann man viele Einstellungen vornehmen wie Attribute und Operationen, Sichtbarkeit und die Darstellung im Diagramm (nur Operationen oder komplette Signatur der Operationen). Man kann sogar die Linienfarben und die Füllfarbe für die Visualisierung der Klasse im Diagramm einstellen. </para>
 
-<para
->Für die meisten &UML; Elemente kann man diesen Eigenschaftendialog durch einen Doppelklick auf das entsprechende Element mit dem Auswahlwerkzeug (Pfeil) aufrufen. Die Ausnahme bilden Assoziationen. Ein Doppelklick fügt ihnen einen neuen Ankerpunkt hinzu. Den Eigenschaftendialog erreicht man für Assoziationen über das Kontextmenu per rechter Maustaste. </para>
+<para>Für die meisten &UML; Elemente kann man diesen Eigenschaftendialog durch einen Doppelklick auf das entsprechende Element mit dem Auswahlwerkzeug (Pfeil) aufrufen. Die Ausnahme bilden Assoziationen. Ein Doppelklick fügt ihnen einen neuen Ankerpunkt hinzu. Den Eigenschaftendialog erreicht man für Assoziationen über das Kontextmenu per rechter Maustaste. </para>
 
-<para
->Man kann den Eigenschaftendialog auch über das Kontextmenu in der Baumansicht erreichen. Dadurch kann man die Eigenschaften für Diagramme bearbeiten, zum Beispiel ob der Raster anzuzeigen ist oder nicht. </para>
+<para>Man kann den Eigenschaftendialog auch über das Kontextmenu in der Baumansicht erreichen. Dadurch kann man die Eigenschaften für Diagramme bearbeiten, zum Beispiel ob der Raster anzuzeigen ist oder nicht. </para>
 </sect2>
 <sect2 id="edit-classes">
-<title
->Klassen bearbeiten</title>
-<para
->Obwohl das Bearbeiten der Eigenschaften von Objekten bereits im letzten Abschnitt erörtert wurde, folgt ein weiterer Abschnitt zu Klassen, da sie komplizierter als alle anderen &UML; Elemente sind. </para>
-<para
->Im Eigenschaftendialog der Klassen kann man alles von der Farbe bis zu den Operationen und Attributen bearbeiten. </para>
+<title>Klassen bearbeiten</title>
+<para>Obwohl das Bearbeiten der Eigenschaften von Objekten bereits im letzten Abschnitt erörtert wurde, folgt ein weiterer Abschnitt zu Klassen, da sie komplizierter als alle anderen &UML; Elemente sind. </para>
+<para>Im Eigenschaftendialog der Klassen kann man alles von der Farbe bis zu den Operationen und Attributen bearbeiten. </para>
 <sect3 id="class-general-settings">
-<title
->Allgemeine Klasseneinstellungen</title>
-<para
->Die Seite im Eigenschaftendialog für die allgemeinen Einstellungen ist selbsterklärend. Dort kann man den Klassennamen, die Sichtbarkeit, die Dokumentation &etc; ändern. Diese Seite ist immer verfügbar. </para>
+<title>Allgemeine Klasseneinstellungen</title>
+<para>Die Seite im Eigenschaftendialog für die allgemeinen Einstellungen ist selbsterklärend. Dort kann man den Klassennamen, die Sichtbarkeit, die Dokumentation &etc; ändern. Diese Seite ist immer verfügbar. </para>
 </sect3>
 <sect3 id="class-attributes-settings">
-<title
->Attributeinstellungen von Klassen</title>
-<para
->Auf der Seite für die Attributeinstellungen kann man Attribute der Klasse hinzufügen, bearbeiten und löschen. Man kann weiterhin die Attribute in der Liste nach oben und nach unten über die Pfeile verschieben. Diese Seite ist ebenfalls immer verfügbar. </para>
+<title>Attributeinstellungen von Klassen</title>
+<para>Auf der Seite für die Attributeinstellungen kann man Attribute der Klasse hinzufügen, bearbeiten und löschen. Man kann weiterhin die Attribute in der Liste nach oben und nach unten über die Pfeile verschieben. Diese Seite ist ebenfalls immer verfügbar. </para>
 </sect3>
 <sect3 id="class-operations-settings">
-<title
->Operationseinstellungen von Klassen</title>
-<para
->Wie in der Seite für die Attributeinstellungen, kann man auf der Seite für die Operationseinstellungen Operationen hinzufügen, bearbeiten und aus der Klasse entfernen. Fügt man eine Operation hinzu oder verändert eine bestehende, dann geschieht dies über den <emphasis
->Operationseigenschaften Dialog</emphasis
->. Um einen neuen Parameter zu einer Operation hinzuzufügen, muss man den Knopf <guibutton
->Neuer Parameter</guibutton
-> benutzen, der den <emphasis
->Paramtereigenschaften Dialog</emphasis
-> aufruft. Diese Seite ist immer verfügbar. </para>
+<title>Operationseinstellungen von Klassen</title>
+<para>Wie in der Seite für die Attributeinstellungen, kann man auf der Seite für die Operationseinstellungen Operationen hinzufügen, bearbeiten und aus der Klasse entfernen. Fügt man eine Operation hinzu oder verändert eine bestehende, dann geschieht dies über den <emphasis>Operationseigenschaften Dialog</emphasis>. Um einen neuen Parameter zu einer Operation hinzuzufügen, muss man den Knopf <guibutton>Neuer Parameter</guibutton> benutzen, der den <emphasis>Paramtereigenschaften Dialog</emphasis> aufruft. Diese Seite ist immer verfügbar. </para>
 </sect3>
 <sect3 id="class-template-settings">
-<title
->Einstellung für parametrisierbare Klasse</title>
-<para
->Auf dieser Seite kann man Klassen-Templates, das sind unspezifizierte Klassen und Datentypen, einfügen. In Java 1.5 werden sie unter der Bezeichnung Generics eingeführt. </para>
+<title>Einstellung für parametrisierbare Klasse</title>
+<para>Auf dieser Seite kann man Klassen-Templates, das sind unspezifizierte Klassen und Datentypen, einfügen. In Java 1.5 werden sie unter der Bezeichnung Generics eingeführt. </para>
 </sect3>
 <sect3 id="class-associations-page">
-<title
->Seite der Klassenassoziationen</title>
-<para
->Die Seite <guilabel
->Assoziationen</guilabel
-> zeigt alle mit der Klasse verbundenen Assoziationen im aktuellen Diagramm. Ein Doppelklick auf eine Assoziation zeigt den entsprechenden Eigenschaftsdialog. Je nach Assoziationstyp kann man einige Parameter wie Multiplizität und Rollennamen ändern. Verfügt die gewählte Assoziation nicht über solche Parameter, dann ist der Eigenschaftdialog nicht änderbar und man kann lediglich die Dokumentation der Assoziation ändern. </para>
-<para
->Diese Seite ist nur verfügbar, wenn man die Klasseneigenschaften aus einem Diagramm heraus aufruft. Erfolgt hingegen der Aufruf aus der Baumansicht, ist diese Seite nicht verfügbar. </para>
+<title>Seite der Klassenassoziationen</title>
+<para>Die Seite <guilabel>Assoziationen</guilabel> zeigt alle mit der Klasse verbundenen Assoziationen im aktuellen Diagramm. Ein Doppelklick auf eine Assoziation zeigt den entsprechenden Eigenschaftsdialog. Je nach Assoziationstyp kann man einige Parameter wie Multiplizität und Rollennamen ändern. Verfügt die gewählte Assoziation nicht über solche Parameter, dann ist der Eigenschaftdialog nicht änderbar und man kann lediglich die Dokumentation der Assoziation ändern. </para>
+<para>Diese Seite ist nur verfügbar, wenn man die Klasseneigenschaften aus einem Diagramm heraus aufruft. Erfolgt hingegen der Aufruf aus der Baumansicht, ist diese Seite nicht verfügbar. </para>
 </sect3>
 <sect3 id="class-display-page">
-<title
->Seite Anzeige</title>
-<para
->In der Seite <guilabel
->Anzeige</guilabel
-> kann man einstellen, wie die Klasse im Diagramm dargestellt wird. Eine Klasse kann zum Beispiel als einfaches Rechteck mit dem Namen dargestellt werden. Dies ist besonders nützlich, wenn man sehr viele Klassen im Diagramm hat, oder sich noch nicht für Details interessiert. Man kann aber auch die komplette Klasse mit Paketen, Stereotypen, Attributen und Operationen mit Signatur und Sichtbarkeit anzeigen lassen. </para>
-<para
->Je nach gewünschtem Informationsumfang, kann man die entsprechenden Optionen auf dieser Seite wählen. Die hier gemachten Einstellungen sind lediglich <emphasis
->Anzeigeeinstellungen</emphasis
-> für das aktuelle Diagramm. Das bedeutet, <quote
->ausgeblendete</quote
-> Operationen im Diagramm sind trotzdem weiterhin Teil des gesamten Modells. Diese Seite ist nur verfügbar, wenn der Eigenschaftendialog der Klasse aus einem Diagramm heraus aufgerufen wurde. Wird der Eigenschaftendialog lediglich aus der Baumansicht aufgerufen, fehlen die Darstellungseinstellungen logischerweise.</para>
+<title>Seite Anzeige</title>
+<para>In der Seite <guilabel>Anzeige</guilabel> kann man einstellen, wie die Klasse im Diagramm dargestellt wird. Eine Klasse kann zum Beispiel als einfaches Rechteck mit dem Namen dargestellt werden. Dies ist besonders nützlich, wenn man sehr viele Klassen im Diagramm hat, oder sich noch nicht für Details interessiert. Man kann aber auch die komplette Klasse mit Paketen, Stereotypen, Attributen und Operationen mit Signatur und Sichtbarkeit anzeigen lassen. </para>
+<para>Je nach gewünschtem Informationsumfang, kann man die entsprechenden Optionen auf dieser Seite wählen. Die hier gemachten Einstellungen sind lediglich <emphasis>Anzeigeeinstellungen</emphasis> für das aktuelle Diagramm. Das bedeutet, <quote>ausgeblendete</quote> Operationen im Diagramm sind trotzdem weiterhin Teil des gesamten Modells. Diese Seite ist nur verfügbar, wenn der Eigenschaftendialog der Klasse aus einem Diagramm heraus aufgerufen wurde. Wird der Eigenschaftendialog lediglich aus der Baumansicht aufgerufen, fehlen die Darstellungseinstellungen logischerweise.</para>
 </sect3>
 <sect3 id="class-color-page">
-<title
->Seite Klassen Farbe</title>
-<para
->Auf der Seite <guilabel
->Objektfarbe</guilabel
-> kann man die Linienfarben und die Füllfarbe einstellen. Diese Seite ist nur verfügbar, wenn die Eigenschaften der Klasse aus einem Diagramm aufgerufen wurden und nicht aus der Baumansicht. </para>
+<title>Seite Klassen Farbe</title>
+<para>Auf der Seite <guilabel>Objektfarbe</guilabel> kann man die Linienfarben und die Füllfarbe einstellen. Diese Seite ist nur verfügbar, wenn die Eigenschaften der Klasse aus einem Diagramm aufgerufen wurden und nicht aus der Baumansicht. </para>
 </sect3>
 </sect2>
 
 <sect2 id="associations">
-<title
->Assoziationen</title>
-<para
->Assoziationen bringen 2 &UML; Elemente miteinander in Verbindung. Normalerweise werden Assoziationen zwischen Klassen definiert, aber einige können auch zwischen Anwendungsfällen und Akteuren angelegt werden. </para>
-<para
->Um eine Assoziation anzulegen, ist das entsprechende Werkzeug aus der vertikalen Werkzeugleiste auszuwählen (zum Beispiel allgemeine Assoziation, Verallgemeinerung, Aggregation &etc;) und auf das Ausgangselement zu klicken. Danach muss man auf den 2. Partner der Assoziation klicken. Es handelt sich dabei um 2 Klicks und <emphasis
->nicht</emphasis
-> um einen Klick mit anschließendem Ziehen von einem Element zum anderen! </para>
-<para
->Versucht man eine Assoziation anzulegen, die nicht mit den &UML; Spezifikationen vereinbar ist, dann verhindert dies &umbrello; und gibt einen entsprechenden Hinweis aus. Dies ist zum Beispiel der Fall, wenn zwischen Klasse A und B eine Verallgemeinerung existiert und nun versucht wird, eine Verallgemeinerung von B nach A anzulegen. </para>
-<para
->Durch einen <mousebutton
->Rechtsklick</mousebutton
-> auf eine Assoziation erscheint ein Menu mit den Einträgen, die man auf die Assoziation anwenden kann. Um zum Beispiel eine Assoziation zu löschen, muss man den Eintrag <guimenuitem
->Löschen</guimenuitem
-> aus dem Kontextmenu auswählen. Man kann über den Eintrag <guimenuitem
->Eigenschaften</guimenuitem
-> je nach Typ der Assoziation in einem Dialog die Attribute der Assoziation wie Rollenname und Multiplizität ändern. </para>
+<title>Assoziationen</title>
+<para>Assoziationen bringen 2 &UML; Elemente miteinander in Verbindung. Normalerweise werden Assoziationen zwischen Klassen definiert, aber einige können auch zwischen Anwendungsfällen und Akteuren angelegt werden. </para>
+<para>Um eine Assoziation anzulegen, ist das entsprechende Werkzeug aus der vertikalen Werkzeugleiste auszuwählen (zum Beispiel allgemeine Assoziation, Verallgemeinerung, Aggregation &etc;) und auf das Ausgangselement zu klicken. Danach muss man auf den 2. Partner der Assoziation klicken. Es handelt sich dabei um 2 Klicks und <emphasis>nicht</emphasis> um einen Klick mit anschließendem Ziehen von einem Element zum anderen! </para>
+<para>Versucht man eine Assoziation anzulegen, die nicht mit den &UML; Spezifikationen vereinbar ist, dann verhindert dies &umbrello; und gibt einen entsprechenden Hinweis aus. Dies ist zum Beispiel der Fall, wenn zwischen Klasse A und B eine Verallgemeinerung existiert und nun versucht wird, eine Verallgemeinerung von B nach A anzulegen. </para>
+<para>Durch einen <mousebutton>Rechtsklick</mousebutton> auf eine Assoziation erscheint ein Menu mit den Einträgen, die man auf die Assoziation anwenden kann. Um zum Beispiel eine Assoziation zu löschen, muss man den Eintrag <guimenuitem>Löschen</guimenuitem> aus dem Kontextmenu auswählen. Man kann über den Eintrag <guimenuitem>Eigenschaften</guimenuitem> je nach Typ der Assoziation in einem Dialog die Attribute der Assoziation wie Rollenname und Multiplizität ändern. </para>
 <sect3 id="anchor-points">
-<title
->Ankerpunkte</title>
-<para
->Assoziationen werden standardmäßig als durchgezogene Linie zwischen den beiden zu verbindenden Objekten im Diagramm gezeichnet. </para>
-<para
->Man kann solch einen zusätzlichen Ankerpunkt durch einen <mousebutton
->Doppelklick</mousebutton
-> auf die Assoziation an einer beliebigen Stelle einfügen. Diesen eingefügten Ankerpunkt (dargestellt durch einen blauen Punkt, wenn die Assoziation ausgewählt ist) kann man nun verschieben, um der Assoziation die gewünschte Form zu geben. </para>
-<para
->Um einen Ankerpunkt zu entfernen, muss man diesen lediglich <mousebutton
->doppelt</mousebutton
-> mit der linken Maustaste anklicken. </para>
-<para
->Es ist zu beachten, dass man den Eigenschaftsdialog einer Assoziation lediglich über ihr Kontextmenu aufrufen kann. Ein <mousebutton
->Doppelklick</mousebutton
->, wie bei anderen &UML; Elementen, fügt einen Ankerpunkt ein. </para>
+<title>Ankerpunkte</title>
+<para>Assoziationen werden standardmäßig als durchgezogene Linie zwischen den beiden zu verbindenden Objekten im Diagramm gezeichnet. </para>
+<para>Man kann solch einen zusätzlichen Ankerpunkt durch einen <mousebutton>Doppelklick</mousebutton> auf die Assoziation an einer beliebigen Stelle einfügen. Diesen eingefügten Ankerpunkt (dargestellt durch einen blauen Punkt, wenn die Assoziation ausgewählt ist) kann man nun verschieben, um der Assoziation die gewünschte Form zu geben. </para>
+<para>Um einen Ankerpunkt zu entfernen, muss man diesen lediglich <mousebutton>doppelt</mousebutton> mit der linken Maustaste anklicken. </para>
+<para>Es ist zu beachten, dass man den Eigenschaftsdialog einer Assoziation lediglich über ihr Kontextmenu aufrufen kann. Ein <mousebutton>Doppelklick</mousebutton>, wie bei anderen &UML; Elementen, fügt einen Ankerpunkt ein. </para>
 </sect3>
 </sect2>
 
 <sect2 id="notes">
-<title
->Textnotizen, Anmerkungen und Rahmen</title>
-<para
->Textnotizen, Textzeilen und Rahmen sind Elemente, die in allen Diagrammtypen verfügbar sind. Sie haben keine inhaltliche Bedeutung für das Modell, sie können aber hilfreiche Kommentare und Erklärungen enthalten, die ein Diagramm leichter lesbar machen. </para>
-<para
->Um eine Textnotiz oder eine Textzeile einzufügen, wählt man das entsprechende Werkzeug aus der vertikalen Werkzeugleiste und klickt im Diagramm an die Stelle, wo das Kommentar erscheinen soll. Man kann den Text über das Kontextmenu ändern oder im Fall von Textnotizen durch einen <mousebutton
->Doppelklick</mousebutton
-> auf den Text. </para>
+<title>Textnotizen, Anmerkungen und Rahmen</title>
+<para>Textnotizen, Textzeilen und Rahmen sind Elemente, die in allen Diagrammtypen verfügbar sind. Sie haben keine inhaltliche Bedeutung für das Modell, sie können aber hilfreiche Kommentare und Erklärungen enthalten, die ein Diagramm leichter lesbar machen. </para>
+<para>Um eine Textnotiz oder eine Textzeile einzufügen, wählt man das entsprechende Werkzeug aus der vertikalen Werkzeugleiste und klickt im Diagramm an die Stelle, wo das Kommentar erscheinen soll. Man kann den Text über das Kontextmenu ändern oder im Fall von Textnotizen durch einen <mousebutton>Doppelklick</mousebutton> auf den Text. </para>
 <sect3 id="anchors">
-<title
->Anker</title>
-<para
->Mit Ankern kann man ein &UML; Element mit einer Textnotiz verbinden. Möchte man zum Beispiel mit einer Textnotiz einige Hinweise über eine Klasse angeben, dann verbindet man diese Textnotiz mit der Klasse. Dadurch ist ersichtlich, dass die Textnotiz sich auf das entsprechende Element <quote
->bezieht</quote
->. </para>
-<para
->Um einen Anker zwischen einer Textnotiz und einem &UML; Element einzufügen, muss man das entsprechende Werkzeug von der vertikalen Werkzeugleiste wählen. Zuerst klickt man auf die gewünschte Textnotiz und mit dem zweiten Klick auf das zu verlinkende &UML; Element. </para>
+<title>Anker</title>
+<para>Mit Ankern kann man ein &UML; Element mit einer Textnotiz verbinden. Möchte man zum Beispiel mit einer Textnotiz einige Hinweise über eine Klasse angeben, dann verbindet man diese Textnotiz mit der Klasse. Dadurch ist ersichtlich, dass die Textnotiz sich auf das entsprechende Element <quote>bezieht</quote>. </para>
+<para>Um einen Anker zwischen einer Textnotiz und einem &UML; Element einzufügen, muss man das entsprechende Werkzeug von der vertikalen Werkzeugleiste wählen. Zuerst klickt man auf die gewünschte Textnotiz und mit dem zweiten Klick auf das zu verlinkende &UML; Element. </para>
 </sect3>
 </sect2>
 </sect1>