po4a 0.66 - en to de translation catalogue (1063 entries)

note: type: Attribute 'xml:lang' of: <refentry>
en: en
de: de

note: type: Content of: <refentry><refmeta><refmiscinfo>
en: Po4a Tools
de: Po4a-Werkzeuge

note: type: Content of: <refentry><refnamediv><refpurpose>
en: display a translated man page according to a PO
de: Anzeigen einer übersetzten Handbuchseite entsprechend einer PO-Datei

note: type: Content of: <refentry><refsynopsisdiv><cmdsynopsis>
en: <command>po4a-display-man</command> <arg choice='plain'><option>-p</option> </arg> <arg choice='plain'><replaceable>PO_FILE</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-m</option> </arg><arg choice='plain'><replaceable>MASTER_FILE</replaceable></arg></arg> <arg choice='opt'><arg choice='plain'><option>-o</option> </arg><arg choice='plain'><replaceable>PO4A_OPT</replaceable></arg></arg>
de: <command>po4a-display-man</command> <arg choice='plain'><option>-p</option> </arg> <arg choice='plain'><replaceable>PO_DATEI</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-m</option> </arg><arg choice='plain'><replaceable>MASTER_DATEI</replaceable></arg></arg> <arg choice='opt'><arg choice='plain'><option>-o</option> </arg><arg choice='plain'><replaceable>PO4A_OPT</replaceable></arg></arg>

note: type: =head1
en: DESCRIPTION
de: BESCHREIBUNG

note: type: Content of: <refentry><refsect1><para>
en: Translators can use <command>po4a-display-man</command> to see how their translation of a man page will be rendered to the end users, without recompiling and reinstalling the whole project.
de: Übersetzer können den Befehl <command>po4a-display-man</command> verwenden, um zu sehen, wie ihre Übersetzung der Handbuchseite den Endanwendern dargestellt wird, ohne das gesamte Projekt neu zu übersetzen und zu installieren.

note: type: Content of: <refentry><refsect1><para>
en: This script only works with man pages written directly in <emphasis remap='I'>nroff</emphasis> and handled by the po4a's <emphasis remap='I'>man</emphasis> module.  Manual pages generated from other formats, like DocBook or POD, are not supported.  See <citerefentry><refentrytitle>po4a-display-pod</refentrytitle><manvolnum>1</manvolnum></citerefentry> for an equivalent supporting <emphasis remap='I'>POD</emphasis> documents.
de: Dieses Skript funktioniert nur mit Handbuchseiten, die direkt in <emphasis remap='I'>nroff</emphasis> geschrieben sind und durch das Modul <emphasis remap='I'>man</emphasis> von Po4a verarbeitet werden. Handbuchseiten, die von anderen Formaten wie DocBook oder POD erstellt werden, werden nicht unterstützt. Verwenden Sie <citerefentry><refentrytitle>po4a-display-pod</refentrytitle><manvolnum>1</manvolnum></citerefentry> als Äquivalent, das <emphasis remap='I'>POD</emphasis>-Dokumente unterstützt.

note: type: =head1
en: OPTIONS
de: OPTIONEN

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-p </option><replaceable>PO_FILE</replaceable>
de: <option>-p </option><replaceable>PO_DATEI</replaceable>

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The PO file containing the translations.
de: Die PO-Datei, die Übersetzungen enthält.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-m </option><replaceable>MASTER_FILE</replaceable>
de: <option>-m </option><replaceable>MASTER_DATEI</replaceable>

note: .br type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The original man page.  It can be the absolute or relative path to the original man page (gzipped or not), the name of the man page or the name and section of the man page (using the man.section format).  When the master document is not provided with the <option>-m</option> option, <command>po4a-display-man</command> tries to find the original man page based on the line reference of the first string in the PO.
de: Die ursprüngliche Handbuchseite. Es kann ein absoluter oder relativer Pfad zu der ursprünglichen Handbuchseite (ggf. gzippt), der Name der Handbuchseite und der Abschnitt der Handbuchseite (im Format Handbuchseite.Abschnitt) sein. Wird das Master-Dokument nicht mit der Option <option>-m</option> angegeben, versucht <command>po4a-display-man</command> die ursprüngliche Handbuchseite basierend auf der Zeilenreferenz der ersten Zeichenkette in der PO-Datei zu finden.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: Some options to pass to <citerefentry><refentrytitle>po4a-translate</refentrytitle><manvolnum>1</manvolnum></citerefentry>.
de: Optionen, die an <citerefentry><refentrytitle>po4a-translate</refentrytitle><manvolnum>1</manvolnum></citerefentry> übergeben werden sollen.

note: type: =head1
en: SEE ALSO
de: SIEHE AUCH

note: type: Content of: <refentry><refsect1><title>
en: AUTHOR
de: AUTOR

note: type: Content of: <refentry><refnamediv><refpurpose>
en: display of a translated POD file according to a PO
de: Anzeige einer übersetzten POD-Datei entsprechend der PO-Datei

note: type: Content of: <refentry><refsynopsisdiv><cmdsynopsis>
en: <command>po4a-display-pod</command> <arg choice='plain'><option>-p </option></arg> <arg choice='plain'><replaceable>PO_FILE</replaceable></arg> <arg choice='plain'><option>-m </option></arg> <arg choice='plain'><replaceable>POD_FILE</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-o </option></arg><arg choice='plain'><replaceable>PO4A_OPT</replaceable></arg></arg>
de: <command>po4a-display-pod</command> <arg choice='plain'><option>-p </option></arg> <arg choice='plain'><replaceable>PO_DATEI</replaceable></arg> <arg choice='plain'><option>-m </option></arg> <arg choice='plain'><replaceable>POD_DATEI</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-o </option></arg><arg choice='plain'><replaceable>PO4A_OPT</replaceable></arg></arg>

note: type: Content of: <refentry><refsect1><para>
en: Translators can use <command>po4a-display-pod</command> to see how their translation of a man page will be rendered to the end users, without recompiling and reinstalling the whole project.  Most of the time, the POD file is only available in source package or embedded in Perl script.
de: Übersetzer können <command>po4a-display-pod</command> verwenden, um anzuschauen, wie eine Handbuchseite Endbenutzern angezeigt wird, ohne das gesamte Projekte neu zu kompilieren und zu installieren. Meistens ist die POD-Datei nur im Quellpaket oder in einem Perl-Skript eingebettet verfügbar.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-m </option><replaceable>POD_FILE</replaceable>
de: <option>-m </option><replaceable>POD_DATEI</replaceable>

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The original POD file used by po4a to generate PO file.
de: die ursprüngliche POD-Datei, die von Po4a zum Erstellen der PO-Datei verwandt wurde

note: type: textblock
en: po4a - update both the PO files and translated documents in one shot
de: po4a - PO-Dateien und übersetzte Dokumente auf einen Rutsch aktualisieren

note: type: =head1
en: SYNOPSIS
de: ÜBERSICHT

note: type: textblock
en: B<po4a> [I<options>] I<config_file>
de: B<po4a> [I<Optionen>] I<Konfig_Datei>

note: type: textblock
en: po4a (PO for anything) eases the maintenance of documentation translation using the classical gettext tools. The main feature of po4a is that it decouples the translation of content from its document structure.  Please refer to the page L<po4a(7)> for a gentle introduction to this project.
de: Po4a (PO für alles) erleichtert die Pflege von Dokumentationsübersetzungen mittels der klassischen Gettext-Werkzeuge. Die Hauptfunktionalität von Po4a besteht darin, dass sie die Übersetzung des Dokumenteninhaltes von der Dokumentenstruktur entkoppelt. Bitte schauen Sie in die Seite L<po4a(7)> für eine schonende Einführung in dieses Projekt.

note: type: textblock
en: Upon execution, B<po4a> parses all documentation files specified in its configuration file. It updates the PO files (containing the translation) to reflect any change to the documentation, and produce a translated documentation by injecting the content's translation (found in the PO files) into the structure of the original master document.
de: Bei der Ausführung wertet B<po4a> alle in seiner Konfigurationsdatei festgelegten Dokumentationsdateien aus. Es aktualisiert die PO-Dateien (die die Übersetzung enthalten), um alle Änderungen an der Dokumentation abzubilden, und erstellt die übersetzte Dokumentation, indem der Inhalt der Übersetzung (wie er sich in den PO-Dateien befindet) in die Struktur des ursprünglichen Master-Dokumentes eingespeist wird.

note: type: textblock
en: At first, the PO files only contain the strings to translate from the original documentation. This file format allows the translators to manually provide a translation for each paragraph extracted by B<po4a>. If the documentation is modified after translation, B<po4a> marks the corresponding translations as "fuzzy" in the PO file to request a manual review by the translators. The translators can also provide so-called "addendum", that are extra content stating for example who did the translation and how to report bugs.
de: Zuerst enthalten die PO-Dateien nur die zu übersetzenden Zeichenketten aus der ursprünglichen Dokumentation. Dieses Dateiformat erlaubt es den Übersetzern, manuell eine Übersetzung für jeden Absatz, der von B<po4a> herausgelöst wurde, bereitzustellen. Falls die Dokumentation nach der Übersetzung verändert wird, markiert B<po4a> die entsprechende Übersetzung als »fuzzy« (unscharf) in der PO-Datei. Damit wird um eine manuelle Begutachtung durch die Übersetzer gebeten. Die Übersetzer können auch ein sogenanntes »addendum« bereitstellen, das zusätzliche Inhalte bereitstellt, in denen beispielsweise angegeben wird, wer die Übersetzung angefertigt hat und wie Fehler berichtet werden sollen.

note: type: verbatim
en:  master documents ---+---->-------->---------+
      (doc authoring)    |                       |
                         V   (po4a executions)   >-----+--> translated
                         |                       |     |     documents
     existing PO files -->--> updated PO files >-+     |
          ^                            |               |
          |                            V               |
          +----------<---------<-------+               ^
           (manual translation process)                |
                                                       |
     addendum -->--------------------------------------+
de:     Masterdokumente  ---+---->-------->------>------>----+
     (Dokumentenerstellung) |                                |
                            V        (Po4a-Ausführung)       >-----+--> übersetzte
                            |                                |     |    Dokumente
     bestehende PO-Dateien ->---> aktualisierte PO-Dateien >-+     |
             ^                               |               |
             |                               V               |
             +----------<----------<---------+               ^
              (manueller Übersetzungsprozess)                |
                                                             |
     Addendum -->--------------------------------------------+

note: type: textblock
en: The workflow of B<po4a> is asynchronous, as suited to open-source projects. The documentation writers author the master documents at their own pace. The translators review and update the translations in the PO files. The maintainers rerun B<po4a> on need, to reflect any change to the original documentation to the PO files, and to produce updated documentation translations, by injecting the latest translation into the latest document structure.
de: Der Arbeitsablauf in B<po4a> ist asynchron, passend für Open-Source-Projekte. Der Dokumentenersteller schreibt das Master-Dokument in seiner eigenen Geschwindigkeit. Die Übersetzer prüfen und aktualisieren die Übersetzungen in den PO-Dateien. Die Betreuer führen bei Bedarf B<po4a> erneut aus, um alle Änderungen an der Ursprungsdokumentation in den PO-Dateien wiederzugeben und aktualisierte Dokumentenübersetzungen bereitzustellen, indem sie die neusten Übersetzungen in die neuste Dokumentenstruktur einspeisen.

note: type: textblock
en: By default, a given translated document is produced when at least 80% of its content is translated. The untranslated text is kept in the original language.  The produced documentation thus mixes languages if the translation is not complete. You can change the 80% threshold with the I<--keep> option described below. Note however that discarding translations as soon as they are not 100% may be discouraging for the translators whose work will almost never be shown to the users, while showing "translations" that are too incomplete may be troubling for the end users.
de: Standardmäßig wird ein angegebenes Dokument erstellt, wenn mindestens 80% seines Inhalts übersetzt ist. Der nicht übersetzte Text wird in der Ursprungssprache behalten. Die erstellte Dokumentation mischt daher die Sprachen, falls die Übersetzung nicht vollständig ist. Sie können den Schwellwert von 80% mit der oben beschriebenen Option I<--keep> ändern. Beachten Sie aber, dass das Verwerfen von Übersetzungen, sobald sie nicht mehr zu 100% erfüllt sind, für die Übersetzer entmutigend sein kann, deren Arbeit fast nie dem Benutzer angezeigt wird, während das Zeigen von »Übersetzungen«, die zu unvollständig sind, bei Endbenutzer zu Verdruß führen kann.

note: type: textblock
en: Storing the translated documentation files in the version control system is probably a bad idea, since they are automatically generated. The precious files are the PO files, that contain the hard work of your fellow translators. Also, some people find it easier to interact with the translators through an online platform such as S<weblate>, but this is naturally fully optional.
de: Das Speichern der übersetzten Dokumentationsdateien in dem Versionssteuerungssystem ist wahrscheinlich eine schlechte Idee, da diese Dateien automatisch erstellt werden. Die wertvollen Dateien sind die PO-Dateien, die die harte Arbeit ihrer Mitübersetzer enthalten. Auch finden es manche Leute einfacher, mit den Übersetzern durch eine Online-Plattform wie S<weblate> zu interagieren, aber dieses ist natürlich vollständig optional.

note: type: =head2
en: Quick start tutorial
de: Schnellstartanleitung

note: type: textblock
en: Let's assume you maintain a program named B<foo> which has a man page F<man/foo.1> written in English (the bridge language in most open-source projects, but B<po4a> can be used from or to any language). Some times ago, someone provided a German translation named F<man/foo.de.1> and disappeared.  This is a problem because you just got a bug report saying that your documentation contains a gravely misleading information that must be fixed in all languages, but you don't speak German so you can only modify the original, not the translation. Now, another contributor wants to contribute a translation to Japanese, a language that you don't master either.
de: Nehmen wir an, dass Sie ein Programm namens B<foo> betreuen, das eine auf englisch geschriebene Handbuchseite F<man/foo.1> enthält. (Englisch wird in den meisten Open-Source-Projekten als Brückensprache verwandt, aber B<po4a> kann in jeder Sprachkombination eingesetzt werden). Vor einiger Zeit stellte jemand eine deutsche Übersetzung mit dem Namen F<man/foo.de.1> bereit und verschwand. Dies ist ein Problem, da Sie gerade einen Fehlerbericht bekommen haben, der Sie informiert, dass Ihre Dokumentation eine grob irreführende Information enthält, die in allen Sprachen korrigiert werden muss. Sie sprechen aber kein Deutsch, so dass Sie nur das Ursprungsdokument korrigieren können, nicht die Übersetzung. Und jetzt möchte ein anderer Beitragender eine japanische Übersetzung erstellen und Sie sprechen auch kein japanisch.

note: type: textblock
en: It is time to convert your documentation to B<po4a> to solve your documentation maintenance nightmares. You want to update the doc when needed, you want to ease the work of your fellow translators, and you want to ensure that your users never see any outdated and thus misleading documentation.
de: Jetzt ist es Zeit, Ihre Dokumentation nach B<po4a> umzuwandeln, um Ihre Dokumentations-Wartungs-Albträume zu lösen. Sie möchten Ihre Dokumentation je nach Bedarf ändern können, Sie möchten die Arbeit ihrer Mitübersetzer erleichtern und Sie möchten sicherstellen, dass Ihre Benutzer niemals veraltete und daher irreführende Dokumentation sehen.

note: type: textblock
en: The conversion includes two steps: setup the po4a infrastructure, and convert the previous German translation to salvage the previous work. This latter part is done using S<po4a-gettextize>, as follows. As detailed in the documentation of L<po4a-gettextize(1)>, this process rarely fully automatic, but once it's done, the B<de.po> file containing the German translation can be integrated in your po4a workflow.
de: Die Umwandlung besteht aus zwei Schritten: Einrichtung der Po4a-Infrastruktur und der Umwandlung der bisherigen deutschen Übersetzung, um die bisherige Arbeit zu retten. Letzterer Teil erfolgt mittels S<po4a-gettextize> wie folgt beschrieben. Wie im Detail in L<po4a-gettextize(1)> dargestellt, ist der Prozess selten vollautomatisch, aber wenn er einmal erledigt ist, dann enthält die Datei B<de.po> die deutsche Übersetzung, die in Ihren Po4a-Arbeitsablauf integriert werden kann.

note: type: textblock
en: Let's now configure po4a. With the appropriate file layout, your configuration file could be as simple as this:
de: Lassen Sie uns nun Po4a konfigurieren. Bei geeigneter Anordung der Dateien, könnte die Konfigurationsdatei so einfach wie folgende sein:

note: type: textblock
en: It specifies that all PO files (containing the work of the translators) are the F<man/po4a/> directory, and that you have only one master file, F<man/foo.1>. If you had several master files, you would have several lines similar to the second one. Each such line also specify where to write the corresponding translation files. Here, the German translation of F<man/foo.1> is in F<man/translated/foo.de.1>.
de: Sie legt fest, dass alle PO-Dateien (die die Arbeit der Übersetzer enthalten) im Verzeichnis F<man/po4a/> liegen und dass Sie eine Master-Datei F<man/foo.1> haben. Falls Sie mehrere Master-Dateien haben, hätten Sie mehrere Zeilen ähnlich der zweiten Zeile. Jeder dieser Zeilen gibt auch an, wohin die entsprechenden Übersetzungsdateien geschrieben werden sollen. Hier ist die deutsche Übersetzung von F<man/foo.1> in F<man/translated/foo.de.1>.

note: type: textblock
en: The last thing we need to complete the configuration of B<po4a> is a POT file containing the template material that should be used to start a new translation.  Simply create an empty file with the S<.pot> extension in the specified S<po_directory> (e.g. F<man/po4a/foo.pot>), and B<po4a> will fill it with the expected content.
de: Das letzte, was wir zum Abschluss der Konfiguration von B<po4a> benötigen, ist eine POT-Datei, die das Vorlagenmaterial enthält, das zum Starten einer neuen Übersetzung verwandt werden soll. Erstellen Sie einfach eine leere Datei mit der Endung S<.pot> im festgelegten S<po_directory> (z.B. F<man/po4a/foo.pot>) und B<po4a> wird sie mit dem erwarteten Inhalt ausfüllen.

note: type: textblock
en: Here is a recap of the files in this setup:
de: Hier ist eine kurze Wiederholung dieser Installation:

note: type: verbatim
en:   ├── man/
      │   ├── foo.1        <- The original man page, in English.
      │   ├── po4a/
      │   │   ├── de.po    <- The German PO translation, from gettextization.
      │   │   └── foo.pot  <- The POT template of future translations (empty at first)
      │   └── translated/  <- Directory where the translations will be created
      └── po4a.cfg         <- The configuration file.
de:   ├── man/
      │   ├── foo.1        <- Die ursprüngliche Handbuchseite in englischer Sprache.
      │   ├── po4a/
      │   │   ├── de.po    <- Die deutsche PO-Übersetzung aus der Gettextisierung.
      │   │   └── foo.pot  <- Die POT-Vorlage für zukünftige Übersetzung (am Anfang leer)
      │   └── translated/  <- Verzeichnis, in das die Übersetzungen hin erzeugt werden
      └── po4a.cfg         <- Die Konfigurationsdatei.

note: type: textblock
en: Once setup, executing B<po4a> will parse your documentation, update the POT template file, use it to update the PO translation files, and use them to update the documentation translation files. All in one command:
de: Sobald die Installation erfolgt ist, wird B<po4a> Ihre Dokumentation auswerten, die POT-Vorlagendatei aktualisieren und diese zur Aktualisierung der PO-Übersetzungsdateien und zur Aktualisierung der Dokument-Übersetzungsdateien verwenden. Alles in einem Befehl:

note: type: textblock
en: This it. B<po4a> is now fully configured. Once you've fixed your error in F<man/foo.1>, the offending paragraph in the German translation will be replaced by the fixed text in English. Mixing languages is not optimal, but it's the only way to remove errors in translations that you don't even understand, and ensure that the content presented to the users is never misleading. Updating the German translation is also much easier in the corresponding PO file, so the language mix-up may not last long. Finally, when the Japanese translator gives you a S<jp.po> translated file, just drop it in F<man/po4a/po/>. A translated page will appear as F<man/translated/foo.jp.1> (provided that enough content is translated) when you run B<po4a> again.
de: Das wars. B<po4a> ist jetzt vollständig konfiguriert. Sobald Sie die Fehler in F<man/foo.1> behoben haben, wird der betroffene Absatz in der deutschen Übersetzung durch den korrigierten Absatz auf Englisch ersetzt. Das Mischen der Sprachen ist nicht optimal, aber es ist die einzige Möglichkeit, Fehler in Übersetzungen zu beheben, die Sie nicht mal verstehen und sicherzustellen, dass der den Benutzern dargestellte Inhalt niemals irreführend ist. Das Aktualisieren der deutschen Übersetzung ist in der entsprechenden PO-Datei auch viel leichter, so dass der Sprachen-Mix nicht sehr lange vorliegen könnte. Wenn dann schließlich der japanische Übersetzer Ihnen eine übersetzte Datei S<jp.po> gibt, legen Sie diese einfach in F<man/po4a/po/> ab. Wenn Sie dann B<po4a> wieder ausführen, erscheint einfach eine übersetzte Datei als F<man/translated/foo.jp.1> (vorausgesetzt, dass genug Inhalt übersetzt ist).

note: type: textblock
en: Minimal threshold for translation percentage to keep (i.e. write) the resulting file (default: 80). I.e. by default, files have to be translated at least at 80% to be written on disk.
de: Minimaler Schwellwert in Prozent, ab der die übersetzte Datei erhalten (d.h. geschrieben) wird, standardmäßig 80. D.h., standardmäßig müssen Dateien zu 80% übersetzt sein, um auf Platte geschrieben zu werden.

note: type: textblock
en: Show a short help message.
de: zeigt eine kurze Hilfemeldung an

note: type: textblock
en: Charset of the files containing the documents to translate. Note that all master documents must use the same charset.
de: Zeichensatz der Dateien, die die zu übersetzenden Dokumente enthalten. Beachten Sie, dass alle Master-Dokumente im gleichen Zeichensatz vorliegen müssen.

note: type: textblock
en: Charset of the files containing the localized documents. Note that all translated documents will use the same charset.
de: Zeichensatz der Dateien, die die lokalisierten Dokumente enthalten. Beachten Sie, dass alle übersetzte Dateien den gleichen Zeichensatz verwenden werden.

note: type: textblock
en: Charset of the addenda. Note that all the addenda should be in the same charset.
de: Zeichensatz der Addenda. Beachten Sie, dass alle Addenda im gleichen Zeichensatz vorliegen sollten.

note: type: textblock
en: Display the version of the script and exit.
de: zeigt die Version des Skripts und beendet sich

note: type: textblock
en: Increase the verbosity of the program.
de: Erhöhen der Ausführlichkeit des Programms

note: type: textblock
en: Decrease the verbosity of the program.
de: Verringern der Ausführlichkeit des Programms

note: type: textblock
en: Output some debugging information.
de: Fehlersuch- (Debug-)Informationen ausgeben

note: type: textblock
en: Extra option(s) to pass to the format plugin. See the documentation of each plugin for more information about the valid options and their meanings. For example, you could pass '-o tablecells' to the AsciiDoc parser, while the text parser would accept '-o tabs=split'.
de: Extraoption(en), die an die Formaterweiterung übergeben werden soll. Lesen Sie die Dokumentation jeder Erweiterung für weitere Informationen über die gültigen Optionen und ihre Bedeutungen. Beispielsweise könnten Sie dem AsciiDoc-Auswerter »-o tablecells« übergeben, während der Text-Auswerter »-o tabs=split« akzeptierte.

note: type: textblock
en: Always generate the POT and PO files, even if B<po4a> considers it is not necessary.
de: immer die POT- und PO-Dateien erstellen, selbst wenn B<po4a> dies nicht für notwendig betrachtet

note: type: textblock
en: The default behavior (when B<--force> is not specified) is the following:
de: Das Standardverhalten (wenn B<--force> nicht angegeben ist) ist wie folgt:

note: type: textblock
en: If the POT file already exists, it is regenerated if a master document or the configuration file is more recent (unless B<--no-update> is provided).  The POT file is also written in a temporary document and B<po4a> verifies that the changes are really needed.
de: Falls die POT-Datei bereits existiert, wird sie neu erstellt, falls ein Master-Dokument oder die Konfigurationsdatei neuer ist (außer B<--no-update> ist angegeben). Die POT-Datei wird auch in ein temporäres Dokument geschrieben und B<po4a> überprüft, dass die Änderungen wirklich benötigt werden.

note: type: textblock
en: Also, a translation is regenerated only if its master document, the PO file, one of its addenda or the configuration file is more recent.  To avoid trying to regenerate translations which do not pass the threshold test (see B<--keep>), a file with the F<.po4a-stamp> extension can be created (see B<--stamp>).
de: Eine Übersetzung wird auch nur neu erstellt, falls das Master-Dokument, die PO-Datei, einer ihrer Addenda oder die Konfigurationsdatei neuer ist. Um zu vermeiden, dass die Erstellung von Übersetzungen, die die Schwellwertbarriere nicht erreichen, versucht wird (siehe B<--keep>), kann eine Datei mit der Erweiterung F<.po4a-stamp> erstellt werden (siehe B<--stamp>).

note: type: textblock
en: If a master document includes files, you should use the B<--force> flag because the modification time of these included files are not taken into account.
de: Falls ein Master-Dokument Dateien einbindet, soillten Sie den Schalter B<--force> verwenden, da der Änderungszeitpunkt dieser eingebundenen Dateien nicht mit betrachtet wird.

note: type: textblock
en: The PO files are always re-generated based on the POT with B<msgmerge -U>.
de: Die PO-Dateien werden basierend auf der POT-Datei mittels B<msgmerge -U> neu erstellt.

note: type: textblock
en: Tells B<po4a> to create stamp files when a translation is not generated because it does not reach the threshold. These stamp files are named according to the expected translated document, with the F<.po4a-stamp> extension.
de: Sorgt dafür, dass B<po4a> Stempeldateien erstellt, wenn eine Übersetzung nicht erstellt wurde, da sie den Schwellwert nicht erreichte. Diese Stempeldateien werden entsprechend des erwarteten übersetzten Dokuments, mit der Erweiterung F<.po4a-stamp>, benannt.

note: type: textblock
en: Note: This only activates the creation of the F<.po4a-stamp> files. The stamp files are always used if they exist, and they are removed with B<--rm-translations> or when the file is finally translated.
de: Hinweis: Dies aktiviert nur die Erstellung der F<.po4a-stamp>-Dateien. Die Stempeldateien werden immer benutzt, falls sie existieren, und sie werden mit B<--rm-translations> oder wenn die Datei schließlich übersetzt ist entfernt.

note: type: textblock
en: Do not generate the translated documents, only update the POT and PO files.
de: die übersetzten Dokumente nicht erstellen, nur die POT- und PO-Dateien aktualisieren

note: type: textblock
en: Do not change the POT and PO files, only the translation may be updated.
de: die POT- und PO-Dateien nicht ändern, nur die Übersetzung darf aktualisiert werden.

note: type: textblock
en: Keeps the existing translation files even if the translation doesn't meet the threshold specified by B<--keep>.  This option does not create new translation files with few content, but it will save existing translations which decay because of changes to the master files.
de: behält die existierenden Übersetzungsdateien, selbst falls die Übersetzung nicht die durch B<--keep> festgelegte Schwelle erreicht. Dies wird keine Übersetzungsdateien mit wenigen Inhalten erstellen, sondern bestehende Dateien sichern, deren Übersetzungen aufgrund von Änderungen an den Master-Dateien verfallen.

note: type: textblock
en: WARNING: This flag changes the po4a behavior in a rather drastic way: your translated files will not get updated at all until the translation improves. Only use this flag if you prefer shipping an outdated translated documentation rather than only shipping an accurate untranslated documentation.
de: WARNUNG: Dieser Schalter ändert das Verhalten von Po4a ziemlich drastisch: Ihre übersetzten Dateien werden überhaupt nicht aktualisiert, bis die Übersetzung verbessert wird. Verwenden Sie diesen Schalter nur, falls Sie die Auslieferung von veralteter Dokumentation gegenüber einer akuraten nicht übersetzten Dokumentation bevorzugen.

note: type: textblock
en: Remove the translated files (implies B<--no-translations>).
de: entfernt die übersetzten Dateien (impliziert B<--no-translations>)

note: type: textblock
en: This flag does nothing since 0.41, and may be removed in later releases.
de: Seit Version 0.41 macht dieser Schalter nichts und könnte daher in zukünftigen Veröffentlichungen entfernt werden.

note: type: =item
en: B<--translate-only> I<translated-file>
de: B<--translate-only> I<übersetzte-Datei>

note: type: textblock
en: Translate only the specified file.  It may be useful to speed up processing if a configuration file contains a lot of files.  Note that this option does not update PO and POT files.  This option can be used multiple times.
de: Nur die angegebene Datei übersetzen. Das kann nützlich sein, um die Verarbeitung zu beschleunigen, falls die Konfigurationsdatei eine Reihe Dateien enthält. Beachten Sie, dass diese Optione die PO- und POT-Dateien nicht aktualisiert. Diese Option kann mehrfach angewandt werden.

note: type: =item
en: B<--variable> I<var>B<=>I<value>
de: B<--variable> I<Var>B<=>I<Wert>

note: type: textblock
en: Define a variable that will be expanded in the B<po4a> configuration file.  Every occurrence of I<$(var)> will be replaced by I<value>.  This option can be used multiple times.
de: Definiert eine Variable, die in der B<po4a>-Konfigurationsdatei expandiert wird. Jedes Vorkommen von I<$(Var)> wird durch I<Wert> ersetzt. Diese Option kann mehrfach verwandt werden.

note: type: =item
en: B<--srcdir> I<SRCDIR>
de: B<--srcdir> I<QUELLVERZ>

note: type: textblock
en: Set the base directory for all input documents specified in the B<po4a> configuration file.
de: setzt das Basisverzeichnis für alle Eingabedokumente, die in der Konfigurationsdatei B<po4a> angegeben sind

note: type: textblock
en: If both I<destdir> and I<srcdir> are specified, input files are searched in the following directories, in order: I<destdir>, the current directory and I<srcdir>. Output files are written to I<destdir> if specified, or to the current directory.
de: Falls sowohl I<ZIELVERZ> als auch I<QUELLVERZ> festgelegt sind, wird in den folgenden Verzeichnissen, in dieser Reihenfolge, nach Eingabedateien gesucht: I<ZIELVERZ>, das aktuelle Verzeichnis und I<QUELLVERZ>. Ausgabedateien werden in das I<ZIELVERZ>, falls angegeben, oder in das aktuelle Verzeichnis geschrieben.

note: type: =item
en: B<--destdir> I<DESTDIR>
de: B<--destdir> I<ZIELVERZ>

note: type: textblock
en: Set the base directory for all the output documents specified in the B<po4a> configuration file (see B<--srcdir> above).
de: setzt das Basisverzeichnis für alle in der B<po4a>-Konfigurationsdatei angegebenen Dokumente (siehe B<--srcdir> weiter oben).

note: type: =head2
en: Options modifying the POT header
de: Optionen, die die POT-Kopfzeilen verändern

note: type: =item
en: B<--porefs> I<type>
de: B<--porefs> I<Typ>

note: type: textblock
en: Specify the reference format. Argument I<type> can be one of B<never> to not produce any reference, B<file> to only specify the file without the line number, B<counter> to replace line number by an increasing counter, and B<full> to include complete references (default: full).
de: Gibt das Referenzformat an. Das Argument I<Typ> kann entweder B<never> (keine Referenz erzeugen), B<file> (nur die Datei ohne Zeilenzahlen festlegen), B<counter> (alle Zeilennummern durch einen ansteigenden Zähler ersetzen) oder B<full> (komplette Referenzen einbinden) sein. Die Vorgabe ist »full«.

note: type: =item
en: B<--wrap-po> B<no>|B<newlines>|I<number> (default: 76)
de: B<--wrap-po> B<no>|B<newlines>|I<Zahl> (Vorgabe: 76)

note: type: textblock
en: Specify how the po file should be wrapped. This gives the choice between either files that are nicely wrapped but could lead to git conflicts, or files that are easier to handle automatically, but harder to read for humans.
de: Legt fest, wie die PO-Datei umgebrochen werden soll. Dies ermöglicht die Auswahl zwischen Dateien, die schön umgebrochen sind aber zu GIT-Konflikten führen können oder Dateien, die leichter automatisch handzuhaben, aber schwerer für Menschen zu lesen sind.

note: type: textblock
en: Historically, the gettext suite has reformatted the po files at the 77th column for cosmetics. This option specifies the behavior of po4a. If set to a numerical value, po4a will wrap the po file after this column and after newlines in the content. If set to B<newlines>, po4a will only split the msgid and msgstr after newlines in the content. If set to B<no>, po4a will not wrap the po file at all.  The reference comments are always wrapped by the gettext tools that we use internally.
de: Aus kosmetischen Gründen hat die Gettext-Programmsammlung PO-Dateien in der 77.Spalte umgebrochen. Diese Option legt das Verhalten von Po4a fest. Falls auf einen numerischen Wert gesetzt, wird Po4a die PO-Datei nach dieser Spalte und nach Zeilenumbrüchen im Inhalt umbrechen. Falls auf B<newlines> gesetzt, wird Po4a die msgid und msgstr nur nach Zeilenumbrüchen im Inhalt auftrennen. Falls auf B<no> gesetzt, wird Po4a die PO-Datei überhaupt nicht umbrechen. Die Referenzkommentare werden durch die von Po4a intern verwandten Gettext-Werkzeuge immer umgebrochen.

note: type: textblock
en: Note that this option has no impact on how the msgid and msgstr are wrapped, i.e.  on how newlines are added to the content of these strings.
de: Beachten Sie, dass diese Option keine Auswirkung darauf hat, wie msgid und msgstr umgebrochen werden, d.h. wie Zeilenumbrüche zu dem Inhalt dieser Zeilen hinzugefügt werden.

note: type: textblock
en: Language of the source files containing the documents to translate. Note that all master documents must use the same language.
de: Sprache der Quelldateien, die die zu übersetzenden Dokumente enthalten. Beachten Sie, dass alle Master-Dokumente in der gleichen Sprache vorliegen müssen.

note: type: =item
en: B<--msgid-bugs-address> I<email@address>
de: B<--msgid-bugs-address> I<e-mail@adresse>

note: type: textblock
en: Set the report address for msgid bugs. By default, the created POT files have no Report-Msgid-Bugs-To fields.
de: Setzt die E-Mail-Adresse, an die Fehler in den Meldungen (msgid) berichtet werden sollen. Standardmäßig haben die erstellten POT-Dateien keine »Report-Msgid-Bugs-To«-Felder.

note: type: =item
en: B<--copyright-holder> I<string>
de: B<--copyright-holder> I<Zeichenkette>

note: type: textblock
en: Set the copyright holder in the POT header. The default value is "Free Software Foundation, Inc."
de: Setzt den Namen des Urhebers in den Kopfzeilen der POT-Datei. Standardmäßig ist dies »Free Software Foundation, Inc.«.

note: type: =item
en: B<--package-name> I<string>
de: B<--package-name> I<Zeichenkette>

note: type: textblock
en: Set the package name for the POT header. The default is "PACKAGE".
de: Setzt den Paketnamen für die POT-Kopfzeilen. Standardmäßig »PACKAGE«.

note: type: =item
en: B<--package-version> I<string>
de: B<--package-version> I<Zeichenkette>

note: type: textblock
en: Set the package version for the POT header. The default is "VERSION".
de: Setzt die Paketversion für die POT-Kopfzeilen. Standardmäßig »VERSION«.

note: type: =head2
en: Options to modify the PO files
de: Optionen, um PO-Dateien zu verändern

note: type: =item
en: B<--msgmerge-opt> I<options>
de: B<--msgmerge-opt> I<Optionen>

note: type: textblock
en: Extra options for B<msgmerge>(1).
de: Extraoptionen für B<msgmerge>(1).

note: type: textblock
en: Note: B<$lang> will be extended to the current language.
de: Hinweis: B<$lang> wird zur aktuellen Sprache erweitert.

note: type: textblock
en: This option removes B<--previous> from the options passed to B<msgmerge>.  This is necessary to support versions of B<gettext> earlier than 0.16.
de: Diese Option entfernt B<--previous> aus den an B<msgmerge> übergebenen Optionen. Dies ist notwendig, um Version von B<gettext>-Versionen vor 0.16 zu unterstützen.

note: type: textblock
en: This option adds B<--previous> to the options passed to B<msgmerge>.  It requires B<gettext> 0.16 or later, and is activated by default.
de: Diese Option fügt B<--previous> zu den an B<msgmerge> übergebenen Optionen hinzu. Dies benötigt B<gettext> 0.16 oder neuer und ist standardmäßig aktiviert.

note: type: =head1
en: CONFIGURATION FILE
de: KONFIGURATIONSDATEI

note: type: textblock
en: po4a expects a configuration file as argument. This file must contain the following elements:
de: Po4a erwartet eine Konfigurationsdatei als Argument. Diese Datei muss die folgenden Elemente enthalten:

note: type: textblock
en: The path to the PO files and the list of languages existing in the project;
de: Den Pfad zu den PO-Dateien und der Liste der in dem Projekt existierenden Sprachen.

note: type: textblock
en: Optionally, some global options and so-called configuration aliases that are used as templates to configure individual master files;
de: Optional, einige globale Optionen und sogenannte Konfigurationsaliase, die als Vorlagen zur Konfiguration individueller Master-Dateien verwandt werden.

note: type: textblock
en: The list of each master file to translate, along with specific parameters.
de: Die Liste der zu übersetzenden Master-Dateien, zusammen mit speziellen Parametern.

note: type: textblock
en: All lines contain a command between square braces, followed by its parameters.  Comments begin with the char '#' and run until the end of the line. You can escape the end of line to spread a command over several lines.
de: Alle Zeilen enthalten einen Befehl zwischen eckigen Klammern, gefolgt von seinen Parametern. Kommentare beginnen mit dem Zeichen »#« und gehen bis zum Zeilenende. Sie können das Zeilenende maskieren, um einen Kommentar über mehrere Zeilen auszubreiten.

note: type: textblock
en: Some full examples are presented on this page, while other examples can be found in the C<t/cfg> directory of the source distribution.
de: In dieser Seite werden einige vollständige Beispiele vorgestellt, andere Beispiele können im Verzeichnis C<t/cfg> der Quelldistribution gefunden werden.

note: type: =head2
en: Finding the PO and POT files
de: Finden der PO- und POT-Dateien

note: type: textblock
en: The simplest solution is to explicitly give the path to POT and PO files, as follows:
de: Die einfachste Lösung ist die explizite Angabe der Pfade zu den POT- und PO-Dateien, wie folgt:

note: type: textblock
en: This specifies the path to the POT file first, and then the paths to the German and French PO files.
de: Die speziellen Pfade zu der POT-Datei zuerst, und dann die Pfade zu den deutschen und französischen PO-Dateien.

note: type: textblock
en: The same information can be written as follows to reduce the risk of copy/paste errors:
de: Die gleiche Information kann wie folgt geschrieben werden, um das Risko von Kopier-/Einfügefehlern zu vermeiden:

note: type: textblock
en: The C<$lang> component is automatically expanded using the provided languages list, reducing the risk of copy/paste error when a new language is added.
de: Die Komponente C<$lang> wird automatisch mittels der bereitgestellten Sprachliste ausgegeben, wodurch das Risiko von Kopieren-/Einfüge-Fehlern reduziert wird, wenn eine neue Sprache hinzugefügt wird.

note: type: textblock
en: You can further compact the same information by only providing the path to the directory containing your translation project, as follows.
de: Die gleiche Information kann noch kompakter geschrieben werden, indem Sie nur die Pfade zu dem Verzeichnis angeben, das Ihr Übersetzungsprojekt enthält, wie folgt:

note: type: textblock
en: The provided directory must contain a set of PO files, each named F<XX.po> with C<XX> the ISO 639-1 of the language used in this file. The directory must also contain a single POT file, with the C<.pot> file extension. For the first run, this file can be empty but it must exist (po4a cannot guess the name to use before the extension).
de: Das bereitgestellte Verzeichnis muss eine Gruppe von PO-Dateien enthalten, jede mit Namen F<XX.po>, wobei C<XX> der ISO 631-Code der in dieser Datei verwandten Sprache ist. Das Verzeichnis muss auch eine einzelne POT-Datei enthalten, die die Endung C<.pot> trägt. Beim ersten Lauf kann diese Datei leer sein, sie muss aber existieren (Po4a kann den Namen, der vor der Erweiterung zu verwenden ist, nicht erraten).

note: type: textblock
en: Note that you must choose only one between C<po_directory> and C<po4a_paths>. The first one (C<po_directory>) is more compact, further reduces the risk of copy/paste error, but forces you to use the expected project structure and file names. The second one (C<po4a_paths>), is more explicit, probably more readable, and advised when you setup your first project with po4a.
de: Beachten Sie, dass Sie nur einen aus C<po_directory> und C<po4a_paths> auswählen dürfen. Ersterer (C<po_directory>) ist kompakter, reduziert das Risiko von Kopieren-/Einfügenfehlern weiter, erzwingt aber die Verwendung von einer erwarteten Projektstruktur und Dateinamen. Die zweite Möglichkeit (C<po4a_paths>) ist expliziter, wahrscheinlich lesbarer und wird empfohlen, wenn Sie Ihr erstes Projekt mit Po4a einrichten.

note: type: =head3
en: Centralized or split PO files?
de: Zentralisierte oder getrennte PO-Dateien?

note: type: textblock
en: By default, po4a produces one single PO file per target language, containing the whole content of your translation project. As your project grows, the size of these files may become problematic. When using weblate, it is possible to specify priorities for each translation segment (i.e., msgid) so that the important ones get translated first. Still, some translation teams prefer to split the content in several files.
de: Standardmäßig erstellt Po4a eine einzelne PO-Datei pro Zielsprache, die den gesamten Inhalt Ihres Übersetzungsprojektes enthält. Mit dem Wachstum Ihres Projektes könnte die Größe der Dateien problematisch werden. Bei der Verwendung von Weblate ist es möglich, für jedes Übersetzungssegment (d.h., msgid) Prioritäten festzulegen, so dass wichtige zuerst übersetzt werden. Einige Übersetzungsteams bevorzugen es aber weiterhin, den Inhalt in mehrere Teile zu trennen.

note: type: textblock
en: To have one PO file per master file, you simply have to use the string C<$master> in the name of your PO files on the C<[po4a_paths]> line, as follows.
de: Um eine PO-Datei pro Master-Datei zu erhalten, müssen Sie einfach die Zeichenkette C<$master> im Namen Ihrer PO-Dateien auf der C<[po4a_paths]>-Zeile wie folgt verwenden:

note: type: verbatim
en:  [po4a_paths] doc/$master/$master.pot $lang:doc/$master/$lang.po
de:  [po4a_paths] dok/$master/$master.pot $lang:dok/$master/$lang.po

note: type: textblock
en: With this line, po4a will produce separate POT and PO files for each document to translate.  For example, if you have 3 documents and 5 languages, this will result in 3 POT files and 15 PO files. These files are named as specified on the C<po4a_paths> template, with C<$master> substituted to the basename of each document to translate. In case of name conflict, you can specify the POT file to use as follows, with the C<pot=> parameter.
de: Mit dieser Zeile wird Po4a getrennte POT- und PO-Dateien für jedes zu übersetzende Dokument erstellen. Wenn Sie beispielsweise 3 Dokumente und 5 Sprachen haben, führt dies zu 3 POT-Dateien und 15 PO-Dateien. Diese Dateien werden so benannt, wie sie in der Vorlage C<po4a_paths> festgelegt wurden, wobei C<$master> durch den Basisnamen jedes der zu übersetzenden Dokumente ersetzt wird. Im Falle von Namenskonflikten können Sie mit dem Parameter C<pot=> die zu verwendende POT-Datei festlegen.

note: type: textblock
en: This feature can also be used to group several translated files into the same POT file. The following example only produces 2 POT files: F<l10n/po/foo.pot> (containing the material from F<foo/gui.xml>) and F<l10n/po/bar.pot> (containing the material from both F<bar/gui.xml> and F<bar/cli.xml>).
de: Diese Funktionalität kann auch dazu verwandt werden, um mehrere übersetzte Dateien in die gleiche POT-Datei zu gruppieren. Das folgende Beispiel erstellt nur zwei POT-Dateien: F<l10n/po/foo.pot> (dass das Material aus F<foo/gui.xml> enthält) und F<l10n/po/bar.pot> (dass das Material aus sowohl F<bar/gui.xml> als auch F<bar/cli.xml> enthält).

note: type: textblock
en: In split mode, B<po4a> builds a temporary compendium during the PO update, to share the translations between all the PO files. If two PO files have different translations for the same string, B<po4a> will mark this string as fuzzy and will submit both translations in all the PO files containing this string. When unfuzzied by the translator, the translation is automatically used in every PO files.
de: Im getrennten Modus baut B<po4a> während der PO-Aktualisierung ein temporäres Kompendium auf, um die Übersetzungen zwischen allen PO-Dateien gemeinsam zu benutzen. Falls zwei PO-Dateien eine verschiedene Übersetzung der gleichen Zeichenkette haben, wird B<po4a> diese Zeichenkette mit »fuzzy« markieren und beide Übersetzungen in alle PO-Dateien einstellen, die diese Zeichenkette enthalten. Wenn der Übersetzer die Zeichenkette bereinigt, dann wird die Übersetzung automatisch in jede PO-Datei übernommen.

note: type: =head2
en: Specifying the documents to translate
de: Angabe der zu übersetzenden Dokumente

note: type: textblock
en: You must also list the documents that should be translated. For each master file, you must specify the format parser to use, the location of the translated document to produce, and optionally some configuration. Here is an example:
de: Sie müssen auch die zu übersetzenden Dokumente aufführen. Für jede Master-Datei müssen Sie den zu verwendenden Format-Auswerter, den Ort der zu erstellenden Dokumente und optional weitere Konfiguration festlegen. Beispiel:

note: type: verbatim
en:  [type: sgml] doc/my_stuff.sgml fr:doc/fr/mon_truc.sgml \
                  de:doc/de/mein_kram.sgml
     [type: man] script fr:doc/fr/script.1 de:doc/de/script.1
     [type: docbook] doc/script.xml fr:doc/fr/script.xml \
                 de:doc/de/script.xml
de:  [type: sgml] dok/mein_zeug.sgml fr:dok/fr/mon_truc.sgml \
                  de:dok/de/mein_kram.sgml
     [type: man] script fr:dok/fr/script.1 de:dok/de/script.1
     [type: docbook] dok/script.xml fr:dok/fr/script.xml \
                 de:dok/de/script.xml

note: type: textblock
en: But again, these complex lines are difficult to read and modify, e.g. when adding a new language. It is much simpler to reorganize things using the C<$lang> template as follows:
de: Aber diese drei komplexen Zeilen sind wieder schwer zu lesen und zu verändern, z.B. wenn neue Sprachen hinzugefügt werden. Es ist viel einfacher, die Dinge neu mittels der Vorlage C<$lang> wie folgt zu organisieren:

note: type: verbatim
en:  [type: sgml]    doc/my_stuff.sgml $lang:doc/$lang/my_stuff.sgml
     [type: man]     script.1          $lang:po/$lang/script.1
     [type: docbook] doc/script.xml    $lang:doc/$lang/script.xml
de:  [type: sgml]    dok/mein_zeug.sgml $lang:dok/$lang/mein_zeug.sgml
     [type: man]     script.1           $lang:po/$lang/script.1
     [type: docbook] dok/script.xml     $lang:dok/$lang/script.xml

note: type: =head2
en: Specifying options
de: Angabe der Optionen

note: type: textblock
en: There is two types of options: I<po4a options> are default values to the po4a command line options while I<format options> are used to change the behavior of the format parsers. As a I<po4a options>, you could for example specify in your configuration file that the default value of the B<--keep> command line parameter is 50% instead of 80%. I<Format options> are documented on the specific page of each parsing module, e.g. L<Locale::Po4a::Xml(3pm)>. You could for example pass B<nostrip> to the XML parser to not strip the spaces around the extracted strings.
de: Es gibt zwei Arten von Optionen: I<Po4a-Optionen> sind Vorgabewerte für die Po4a-Befehlszeilenoptionen, während I<Formatoptionen> zur Änderung des Verhaltens der Formatauswertprogramme verwandt werden. Als I<Po4a-Option> könnten Sie beispielsweise in Ihrer Konfigurationsdatei festlegen, dass der Vorgabewert für den Befehlszeilenparameter von B<--keep> 50% statt 80% beträgt. I<Formatoptionen> sind in ihren speziellen Handbuchseiten für jedes Auswertmodul dokumentiert, z.B. L<Locale::Po4a::Xml(3pm)>. Sie könnten beispielsweise B<nostrip> an das XML-Auswertprogramm übergeben, um die Leerzeichen rund um herausgelöste Zeichenketten nicht zu entfernen.

note: type: textblock
en: You can pass these options for a specific master file, or even for a specific translation of that file, using C<opt:> and C<opt_XX:> for the C<XX> language.  In the following example, the B<nostrip> option is passed to the XML parser (for all languages), while the threshold will be reduced to 0% for the French translation (that is thus always kept).
de: Sie können diese Optionen für eine bestimmte Masterdatei oder sogar für eine bestimmte Übersetzung dieser Datei mittels C<opt:> und C<opt_XX:> für die Sprache C<XX> übergeben. Im nachfolgenden Beispiel wird die Option B<nostrip> für den XML-Auswerter (für alle Sprachen) übergeben, während der Schwellwert für die französische Übersetzung auf 0% reduziert wird (diese wird daher immer beibehalten).

note: type: textblock
en: In any case, these configuration chunks must be located at the end of the line.  The declaration of files must come first, then the addendum if any (see below), and then only the options. The grouping of configuration chunks is not very important, since elements are internally concatenated as strings. The following examples are all equivalent:
de: Auf jeden Fall müssen diese Konfigurationsteile sich am Ende der Zeile befinden. Die Erklärung der Dateien muss zuerst kommen, dann das Addendum, falls vorhanden, (siehe unten) und dann nur die Optionen. Die Gruppierung der Konfigurationsteile ist nicht sehr wichtig, da die Elemente intern als Zeichenketten aneinandergehängt werden. Die folgenden Beispiele sind alle äquivalent:

note: type: textblock
en: Note that language specific options are not used when building the POT file. It is for example impossible to pass B<nostrip> to the parser only when building the French translation, because the same POT file is used to update every languages. So the only options that can be language-specific are the ones that are used when producing the translation, as the C<--keep> option.
de: Beachten Sie, dass beim Bau von POT-Dateien die sprachspezifischen Optionen nicht verwandt werden. Es ist beispielsweise unmöglich, B<nostrip> nur an das Auswertprogramm zu übergeben, wenn die französische Übersetzung gebaut wird, da die gleiche POT-Datei zur Aktualisierung aller Sprachen verwandt wird. Daher sind die einzigen sprachspezifischen Optionen diejenigen, die bei der Erstellung der Übersetzung verwandt werden können, wie die Option C<--keep>.

note: type: =head3
en: Configuration aliases
de: Konfigurationsaliase

note: type: textblock
en: To pass the same options to several files, the best is to define a type alias as follows. In the next example, C<--keep 0> is passed to every Italian translation using this C<test> type, that is an extension of the C<man> type.
de: Um die gleiche Option an mehrere Dateien zu übergeben, ist es am besten, wie folgt einen Typ-Alias zu definieren. Im nächsten Beispiel wird C<--keep 0> an jede italienische Übersetzung mittels dieses Typs C<test> übergeben, der eine Erweiterung des Typs C<man> ist.

note: type: textblock
en: You can also extend an existing type reusing the same name for the alias as follows. This is not interpreted as as an erroneous recursive definition.
de: Sie können auch einen bestehenden Typ wie folgt erweitern, um den gleichen Aliasnamen erneut zu benutzen. Dies wird nicht als fehlerhafte rekursive Definition interpretiert.

note: type: =head3
en: Global default options
de: Globale Vorgabeoptionen

note: type: textblock
en: You can also use C<[options]> lines to define options that must be used for all files, regardless of their type.
de: Sie können auch C<[options]>-Zeilen verwenden, um Optionen zu definieren, die für alle Dateien, unabhängig von deren Typ, verwandt werden müssen.

note: type: textblock
en: As with the command line options, you can abbreviate the parameters passed in the configuration file:
de: Wie bei Befehlszeilenoptionen können Sie die in der Konfigurationsdatei übergebenen Parameter abkürzen:

note: type: =head3
en: Option priorities
de: Optionsprioritäten

note: type: textblock
en: The options of every sources are concatenated, ensuring that the default values can easily be overridden by more specific options. The order is as follows:
de: Die Optionen jeder Quelle werden aneinandergehängt, wodurch sichergestellt wird, dass die Vorgabewerte leicht durch speziellere Optionen außer Kraft gesetzt werden können. Die Reihenfolge ist wie folgt:

note: type: textblock
en: C<[options]> lines provide default values that can be overridden by any other source.
de: C<[options]>-Zeilen stellen Vorgabewerte bereit, die durch jede andere Quelle außer Kraft gesetzt werden können.

note: type: textblock
en: Type aliases are then used. Language specific settings override the ones applicable to all languages.
de: Dann werden Typ-Aliase verwandt. Sprachspezifische Einstellungen setzen die für alle Sprachen angewandten Einstellungen außer Kraft.

note: type: textblock
en: Settings that are specific to a given master file override both the default ones and the ones coming from the type alias. In this case also, language specific settings override the global ones.
de: Einstellungen, die für eine gegebene Master-Datei spezifisch sind, setzen sowohl die Vorgabe- als auch die von Typ-Alias kommenden Einstellungen außer Kraft. In diesem Fall setzen auch sprachspezifische Einstellungen die globalen außer Kraft.

note: type: textblock
en: Finally, parameters provided on the B<po4a> command line override any settings from the configuration file.
de: Schließlich setzen auf der B<po4a>-Befehlszeile bereitgestellte Parameter alle Einstellungen aus Konfigurationsdateien außer Kraft.

note: type: =head3
en: Example
de: Beispiel

note: type: textblock
en: Here is an example showing how to quote the spaces and quotes:
de: Hier ist ein Beispiel, das zeigt, wie Leer- und Anführungszeichen maskiert werden:

note: type: =head2
en: Addendum: Adding extra content in the translation
de: Addendum: Zusätzliche Inhalte in der Übersetzung hinzufügen

note: type: textblock
en: If you want to add an extra section to the translation, for example to give credit to the translator, then you need to define an addendum to the line defining your master file. Please refer to the page L<po4a(7)> for more details on the syntax of addendum files.
de: Falls Sie einen zusätzlichen Abschnitt zu der Übersetzung hinzufügen möchten, beispielsweise für Danksagungen an den Übersetzer, müssen Sie ein Addendum für die Zeile, die ihre Master-Datei definiert, hinzufügen. In der Handbuchseite L<po4a(7)> finden Sie weitere Details zu der Syntax von Addendum-Dateien.

note: type: verbatim
en:  [type: pod] script fr:doc/fr/script.1 \
                 add_fr:doc/l10n/script.fr.add
de:  [type: pod] script fr:dok/fr/script.1 \
                 add_fr:dok/l10n/script.fr.add

note: type: textblock
en: You can also use language templates as follow:
de: Sie können wie folgt auch Sprachvorlagen verwenden:

note: type: verbatim
en:  [type: pod] script $lang:doc/$lang/script.1 \
                 add_$lang:doc/l10n/script.$lang.add
de:  [type: pod] Skript $lang:dok/$lang/script.1 \
                 add_$lang:dok/l10n/script.$lang.add

note: type: textblock
en: If an addendum fails to apply, the translation is discarded.
de: Falls ein Addendum nicht angewandt werden kann, wird die Übersetzung verworfen.

note: type: =head3
en: Modifiers for the addendum declaration
de: Attribute für die Addendum-Angabe

note: type: textblock
en: Addendum modifiers can simplify the configuration file in the case where not all languages provide an addendum, or when the list of addenda changes from one language to the other. The modifier is a single char located before the file name.
de: Addendum-Attribute können die Konfigurationsdatei in Fällen, in denen nicht alle Sprachen ein Addendum bereitstellen oder wenn sich Addenda von Sprache zu Sprache verändern, vereinfachen. Das Attribut ist ein einzelnes Zeichen, das sich vor dem Dateinamen befindet.

note: type: textblock
en: Include I<addendum_path> if this file does exist, otherwise do nothing.
de: Berücksichtige I<Addendum_Pfad> falls die Datei existiert, andernfalls passiert nichts.

note: type: textblock
en: I<addendum_path> is not a regular addendum but a file containing a list of addenda, one by line.  Each addendum may be preceded by modifiers.
de: I<Addendum_Pfad> ist kein reguläres Addendum, sondern eine Datei, die eine Liste von Addenda enthält, eines pro Zeile. Jedem Addendum kann ein Modifikator vorangestellt sein.

note: type: textblock
en: I<addendum_path> is discarded, it is not loaded and will not be loaded by any further addendum specification.
de: I<Addendum_Pfad> wird verworfen, es wird nicht geladen und wird auch nicht von weiteren Addendumspezifikationen geladen.

note: type: textblock
en: The following includes an addendum in any language, but if only it exists. No error is reported if the addendum does not exist.
de: Folgendes Beispiel enthält ein Addendum für jede Sprache, aber nur, falls es existiert. Falls es nicht existiert, wird kein Fehler gemeldet.

note: type: verbatim
en:  [type: pod] script $lang:doc/$lang/script.1  add_$lang:?doc/l10n/script.$lang.add
de:  [type: pod] script $lang:dok/$lang/script.1  add_$lang:?dok/l10n/script.$lang.add

note: type: textblock
en: The following includes a list of addendum for every language:
de: Folgendes Beispiel enthält eine Liste von Addenda für jede Sprache:

note: type: verbatim
en:  [type: pod] script $lang:doc/$lang/script.1  add_$lang:@doc/l10n/script.$lang.add
de:  [type: pod] script $lang:dok/$lang/script.1  add_$lang:@dok/l10n/script.$lang.add

note: type: =head2
en: Filtering the translated strings
de: Übersetzte Zeichenketten filtern

note: type: textblock
en: Sometimes, you want to hide some strings from the translation process. To that extend, you can give a C<pot_in> parameter to your master file to specify the name of the file to use instead of the real master when building the POT file. Here is an example:
de: Manchmal möchten Sie einige Zeichenketten vor dem Übersetzungsprozess verstecken. Um dies zu erreichen, können Sie einen C<pot_in>-Parameter an Ihre Masterdatei übegeben, um den Namen der Datei festzulegen, die statt des echten Masters für den Bau der POT-Datei verwandt werden soll. Hier ist ein Beispiel:

note: type: textblock
en: With this setting, the strings to translate will be extracted from the F<book-filtered.xml> (that must be produced before calling B<po4a>) while the translated files will be built from F<book.xml>. As a result, any string that is part of F<book.xml> but not in F<book-filtered.xml> will not be included in the PO files, preventing the translators from providing a translation for them. So these strings will be left unmodified when producing the translated documents.  This naturally decreases the level of translation, so you may need the C<--keep> option to ensure that the document is produced anyway.
de: Mit dieser Einstellung werden die zu übersetzenden Zeichenketten aus F<book-filtered.xml> herausgelöst (diese Datei muss vor dem Aufruf von B<po4a> erstellt worden sein), während die übersetzten Dateien aus F<book.xml> heraus gebaut werden. Damit wird jede Zeichenkette, die Teil von F<book.xml> ist, aber nicht in F<book-filtered.xml> vorkommt, nicht Teil der PO-Dateien sein und damit verhindert, dass die Übersetzer eine Übersetzung davon bereitstellen. Daher verbleiben diese Zeichenketten bei der Erstellung übersetzter Dokumente unverändert. Damit wird logischerweise der Anteil der Übersetzung reduziert und Sie könnten die Option C<--keep> verwenden müssen, um sicherzustellen, dass das Dokument trotzdem erstellt wird.

note: type: =head1
en: AUTHORS
de: AUTOREN

note: type: =head1
en: COPYRIGHT AND LICENSE
de: URHEBERRECHT UND LIZENZ

note: type: textblock
en: Copyright 2002-2022 by SPI, inc.
de: Copyright 2002-2022 SPI, Inc.

note: type: textblock
en: This program is free software; you may redistribute it and/or modify it under the terms of GPL (see the COPYING file).
de: Dieses Programm ist freie Software; Sie können es unter den Bedingungen der GPL (siehe die Datei COPYING) vertreiben und/oder verändern.

note: type: textblock
en: po4a-gettextize - convert an original file (and its translation) to a PO file
de: po4a-gettextize - konvertiert eine Originaldatei (und ihre Übersetzungen) in eine PO-Datei

note: type: textblock
en: (I<XX.po> is the output, all others are inputs)
de: (I<XX.po> ist die Ausgabe, alles andere sind Eingaben)

note: type: textblock
en: The B<po4a-gettextize> script helps you converting your previously existing translations into a po4a-based workflow. This is only to be done once to salvage an existing translation while converting to po4a, not on a regular basis after the conversion of your project. This tedious process is explained in details in Section 'Converting a manual translation to po4a' below.
de: Das Skript B<po4a-gettextize> hilft Ihnen bei der Umwandlung Ihrer bereits bestehenden Übersetzung in einen Po4a-basierten Arbeitsablauf. Dies sollte nur einmalig passieren, um bestehende Übersetzungen zu retten, während sie in Po4a konvertiert werden, und nicht immer wiederkehrend, nach der Umwandlung Ihres Projekts. Dieser aufwändige Prozess wird im Detail im nachfolgenden Abschnitt »Umwandlung einer händischen Übersetzung nach Po4a« beschrieben.

note: type: textblock
en: You must provide both a master file (e.g., the source in English) and an existing translated file (e.g., a previous translation attempt without po4a). If you provide more than one master or translation files, they will be used in sequence, but it may be easier to gettextize each page or chapter separately and then use B<msgmerge> to merge all produced PO files. As you wish.
de: Sie müssen eine Master-Datei (d.h. die Quelldatei auf Englisch) und eine bestehende übersetzte Datei (z.B. ein vorheriger Übersetzungsversuch ohne Po4a) bereitstellen. Falls Sie mehr als eine Master- oder Übersetzungsdatei bereitstellen, werden sie nacheinander verwandt, aber es könnte einfacher sein, jede Seite oder jedes Kapitel separat zu gettextisieren, und dann B<msgmerge> zu verwenden, um alle PO-Dateien zusammenzuführen. Wie Sie möchten.

note: type: textblock
en: If the master document has non-ASCII characters, the new generated PO file will be in UTF-8. If the master document is completely in ASCII, the generated PO will use the encoding of the translated input document.
de: Falls das Master-Dokument Zeichen außerhalb von ASCII enthält, wird die neuerstellte PO-Datei UTF-8-kodiert sei. Falls das Master-Dokument komplett ASCII-kodiert ist, wird die erstellte PO-Datei die Kodierung des übersetzten Eingabedokuments verwenden.

note: type: textblock
en: Format of the documentation you want to handle. Use the B<--help-format> option to see the list of available formats.
de: Format der Dokumentation, mit der Sie arbeiten möchten. Verwenden Sie die Option B<--help-format>, um eine Liste der verfügbaren Formate zu erhalten.

note: type: textblock
en: File containing the master document to translate. You can use this option multiple times if you want to gettextize multiple documents.
de: Datei, die das zu übersetzende Master-Dokument enthält. Sie können diese Option mehrfach verwenden, falls Sie mehrere Dokumente mit Gettext behandeln möchten.

note: type: textblock
en: Charset of the file containing the document to translate.
de: Zeichensatz der Datei, die das zu übersetzende Dokument enthält.

note: type: textblock
en: File containing the localized (translated) document. If you provided multiple master files, you may wish to provide multiple localized file by using this option more than once.
de: Datei, die das lokalisierte (übersetzte) Dokument enthält. Falls Sie mehrere Master-Dateien angeben, könnte es sinnvoll sein, mehrere lokalisierte Dateien durch mehrfache Verwendung dieser Option anzugeben.

note: type: textblock
en: Charset of the file containing the localized document.
de: Zeichensatz der Datei, die das lokalisierte Dokument enthält.

note: type: textblock
en: File where the message catalog should be written. If not given, the message catalog will be written to the standard output.
de: Datei, in die der Nachrichtenkatalog geschrieben werden soll. Falls keine angegeben ist, wird der Nachrichtenkatalog auf die Standardausgabe geschrieben.

note: type: textblock
en: List the documentation formats understood by po4a.
de: die von Po4a verstandenen Dokumentationsformate auflisten

note: type: textblock
en: Keep the temporary master and localized POT files built before merging.  This can be useful to understand why these files get desynchronized, leading to gettextization problems
de: die temporären Master- und vor dem Zusammenführen gebauten lokalisierten POT-Dateien behalten. Dies kann hilfreich sein, um zu verstehen, warum Dateien nicht mehr synchron sind und damit zu Gettextisierungs-Problemen führen.

note: type: =head2
en: Converting a manual translation to po4a
de: Umwandlung einer händischen Übersetzung nach Po4a

note: type: textblock
en: B<po4a-gettextize> synchronizes the master and localized files to extract their content into a PO file. The content of the master file gives the B<msgid> while the content of the localized file gives the B<msgstr>. This process is somewhat fragile: the Nth string of the translated file is supposed to be the translation of the Nth string in the original.
de: B<po4a-gettextize> synchronisiert die Master- und die übersetzen Dateien um ihre Inhalte in eine PO-Datei auszulösen. Der Inhalt der Master-Datei ergibt die B<msgid>, während der Inhalt der übersetzten Dateien die B<msgstr> ergibt. Dieser Prozess ist etwas fragil: es wird angenommen, dass die N-te Zeichenkette der übersetzten Datei die Übersetzung der N-ten Zeichenkette des Originals ist.

note: type: textblock
en: Gettextization works best if you manage to retrieve the exact version of the original document that was used for translation. Even so, you may need to fiddle with both master and localized files to align their structure if it was changed by the original translator, so working on files' copies is advised.
de: Gettextisierung funktioniert am besten, wenn es Ihnen gelingt, exakt die gleiche Version des ursprünglichen Dokuments zu finden, das für die Übersetzung verwandt wurde. Selbst dann könnte es notwendig sein, dass sie mit der Master-Datei als auch den übersetzten Dateien herumbasteln, um ihre Strukturen anzupassen, falls diese vom ursprünglichen Übersetzer geändert wurden. Daher wird empfohlen, mit Kopien der Dateien zu arbeiten.

note: type: textblock
en: Internally, each po4a parser reports the syntactical type of each extracted strings. This is how desynchronization are detected during the gettextization.  In the example depicted below, it is very unlikely that the 4th string in translation (of type 'chapter') is the translation of the 4th string in original (of type 'paragraph'). It is more likely that a new paragraph was added to the original, or that two original paragraphs were merged together in the translation.
de: Intern berichtet jedes Po4a-Auswerteprogramm den syntaktischen Typ jeder ausgelesenen Zeichenkette. Damit werden während der Gettextisierung Desynchronisationen erkannt. Im nachfolgenden Beispiel ist es sehr unwahrscheinlich, dass die vierte Zeichenkette der Übersetzung (vom Typ »Kapitel«) die Übersetzung der vierten Zeichenkette des Originals (vom Typ »Absatz«) ist. Es ist wahrscheinlicher, dass ein neuer Absatz im Ursprungsdokument hinzugefügt oder dass zwei Absätze in der Übersetzung zusammengefasst wurden.

note: type: verbatim
en:     Original         Translation
de:     Original         Übersetzung

note: type: verbatim
en:   chapter            chapter
        paragraph          paragraph
        paragraph          paragraph
        paragraph        chapter
      chapter              paragraph
        paragraph          paragraph
de:   Kapitel            Kapitel
        Absatz             Absatz
        Absatz             Absatz
        Absatz           Kapitel
      Kapitel              Absatz
        Absatz             Absatz

note: type: textblock
en: B<po4a-gettextize> will verbosely diagnose any structure desynchronization. When this happens, you should manually edit the files to add fake paragraphs or remove some content here and there until the structure of both files actually match. Some tricks are given below to salvage the most of the existing translation while doing so.
de: B<po4a-gettextize> wird jede Strukturdesynchronisation ausführlich diagnostizieren. Wenn dies passiert, sollten Sie die Dateien manuell bearbeiten, um Pseudo-Absätze hinzuzufügen oder einigen Inhalt hier oder dort zu entfernen, bis die Struktur beider Dateien genau übereinstimmt. Nachfolgend werden einige Tricks beschrieben, um dabei das meiste der bestehenden Übersetzung zu retten.

note: type: textblock
en: If you are lucky enough to have a perfect match in the file structures out of the box, building a correct PO file is a matter of seconds. Otherwise, you will soon understand why this process has such an ugly name :) Even so, gettextization often remains faster than translating everything again. I gettextized the French translation of the whole Perl documentation in one day despite the I<many> synchronization issues. Given the amount of text (2Mb of original text), restarting the translation without first salvaging the old translations would have required several months of work. In addition, this grunt work is the price to pay to get the comfort of po4a. Once converted, the synchronization between master documents and translations will always be fully automatic.
de: Falls Sie Glück haben und die Dateistrukturen sofort genau passen, ist die Erstellung einer PO-Datei eine Frage von Sekunden. Andernfalls werden Sie schnell verstehen, warum dieser Prozess einen so scheußlichen Namen hat :). Selbst dann ist die Gettextisierung oft schneller als die Neuübersetzung von allem. Ich habe die französische Übersetzung der gesamten Perl-Dokumentation an einem Tage gettextisiert, obwohl es I<viele> Synchronisierungsprobleme gab. Im Angesicht der Textmenge (2 MB an ursprünglichem Text), hätte der Neustart der Übersetzung ohne Rettung der alten Übersetzung mehrere Monate an Arbeit bedeutet. Zusätzlich ist dies der Preis, den Sie zur Nutzung des Komforts von Po4a zahlen müssen. Sobald die Konvertierung erfolgte, ist die Synchronisation zwischen dem Master-Dokument und den Übersetzungen immer voll automatisch.

note: type: textblock
en: After a successful gettextization, the produced documents should be manually checked for undetected disparities and silent errors, as explained below.
de: Nach einer erfolgreichen Gettextisierung sollten die erstellten Dokumente manuell auf unerkannte Abweichungen und nicht gemeldete Fehler überprüft werden, wie dies nachfolgend beschrieben ist.

note: type: =head3
en: Hints and tricks for the gettextization process
de: Tipps und Tricks für den Gettextisierungsprozess

note: type: textblock
en: The gettextization stops as soon as a desynchronization is detected. When this happens, you need to edit the files as much as needed to re-align the files' structures. B<po4a-gettextize> is rather verbose when things go wrong. It reports the strings that don't match, their positions in the text, and the type of each of them. Moreover, the PO file generated so far is dumped as F<gettextization.failed.po> for further inspection.
de: Die Gettextisierung stoppt sofort, wenn eine Desynchronisierung erkannt wurde. Wenn das passiert, müssen Sie die Dateien soweit notwendig bearbeiten und die Strukturen der Dateien wieder anpassen. B<po4a-gettextize> erklärt relativ ausführlich, wenn etwas schief gelaufen ist. Es werden die Zeichenketten berichtet, die nicht zueinander passen, ihre Position im Text und ihr Typ. Desweiteren wird die soweit generierte PO-Datei in F<gettextization.failed.po> zur weiteren Untersuchung ausgegeben.

note: type: textblock
en: Here are some tricks to help you in this tedious process and ensure that you salvage the most of the previous translation:
de: Hier sind weitere Tricks, die Ihnen bei diesem mühsamen Prozess helfen und sicherstellen, dass sie das meiste der vorhergehenden Übersetzung retten:

note: type: textblock
en: Remove all extra content of the translations, such as the section giving credits to the translators. They should be added separately to B<po4a> as addendas (see L<po4a(7)>).
de: Entfernen Sie sämtlichen zusätzlichen Inhalt der Übersetzung, wie beispielsweise Absätze, die den Übersetzern danken. Sie sollten zu B<po4a> separat als Addenda hinzugefügt werden (siehe L<po4a(7)>).

note: type: textblock
en: When editing the files to align their structures, prefer editing the translation if possible. Indeed, if the changes to the original are too intrusive, the old and new versions will not be matched during the first po4a run after gettextization (see below). Any unmatched translation will be dumped anyway.  That being said, you still want to edit the original document if it's too hard to get the gettextization to proceed otherwise, even if it means that one paragraph of the translation is dumped. The important thing is to get a first PO file to start with.
de: Bei der Bearbeitung der Dateien zur Anpassung ihrer Struktur sollten Sie bevorzugt die Übersetzung bearbeiten. Falls die Änderungen am Original zu umfangreich sind, passen die alten und neuen Versionen während der ersten Po4a-Ausführung nach der Gettextisierung nicht mehr zusammen (siehe unten). Jede nicht passende Übersetzung wird sowieso verworfen. Mit diesem Wissen sollten Sie weiterhin das Originaldokument bearbeiten, falls es andernfalls zu schwer ist, den Gettextisierungsprozess fortzuführen, selbst falls das bedeutet, dass ein Absatz der Übersetzung verworfen wird. Das Wichtigste ist, eine erste PO-Datei zum Starten zu bekommen.

note: type: textblock
en: Do not hesitate to kill any original content that would not exist in the translated version. This content will be automatically reintroduced afterward, when synchronizing the PO file with the document.
de: Haben Sie keine Scheu, ursprüngliche Inhalte zu löschen, die in der übersetzten Version nicht erscheinen würden. Dieser Inhalt wird danach automatisch wieder eingefügt, wenn die PO-Datei mit dem Dokument synchronisiert wird.

note: type: textblock
en: You should probably inform the original author of any structural change in the translation that seems justified. Issues in the original document should reported to the author. Fixing them in your translation only fixes them for a part of the community. Plus, it is impossible to do so when using po4a ;) But you probably want to wait until the end of the conversion to B<po4a> before changing the original files.
de: Sie sollten wahrscheinlich den Ursprungsautor über sämtliche gerechtfertigten Strukturänderungen in der Übersetzung informieren. Probleme in dem Ursprungsdokument sollten an den Autor berichtet werden. Wenn Sie diese nur in Ihrer Übersetzung korrigieren, werden diese nur für einen Teil der Gemeinschaft korrigiert. Und desweiteren ist das unmöglich, wenn Sie Po4a verwenden ;) Aber am besten warten Sie damit, bis Sie die Umwandlung mit B<po4a> fertiggestellt haben, bevor Sie die Ursprungsdateien ändern.

note: type: textblock
en: Sometimes, the paragraph content does match, but not their types. Fixing it is rather format-dependent. In POD and man, it often comes from the fact that one of them contains a line beginning with a white space while the other does not.  In those formats, such paragraph cannot be wrapped and thus become a different type. Just remove the space and you are fine. It may also be a typo in the tag name in XML.
de: Manchmal passen die Inhalte des Absatzes, aber ihr Typ nicht. Dies zu korrigieren hängt stark vom Format ab. In POD und Man kommt dies oft daher, dass bei einem der beiden eine Zeile enthalten ist, die mit einem Leerzeichen beginnt. In diesen Formaten kann so ein Absatz nicht umgebrochen werden und erhält daher einen anderen Typ. Entfernen Sie einfach das Leerzeichen und es klappt wieder. Es kann sich auch um einen Tippfehler im Namen der Markierung (Tags) in XML handeln.

note: type: textblock
en: Likewise, two paragraphs may get merged together in POD when the separating line contains some spaces, or when there is no empty line between the B<=item> line and the content of the item.
de: Entsprechend könnten zwei Absätze in POD zusammengefasst worden sein, wenn die trennende Zeile Leerzeichen enthält oder wenn es keine Leerzeile zwischen der B<=item>-Zeile und dem Inhalt des »item«s gibt.

note: type: textblock
en: Sometimes, the desynchronization message seems odd because the translation is attached to the wrong original paragraph. It is the sign of an undetected issue earlier in the process. Search for the actual desynchronization point by inspecting the file F<gettextization.failed.po> that was produced, and fix the problem where it really is.
de: Manchmal erscheinen die Desynchronisationsmeldungen komisch, da die Übersetzung an einen falschen Ursprungsabsatz angehängt ist. Dies ist ein Zeichen eines vorhergehenden und unerkannten Problems früher im Prozess. Suchen Sie nach dem tatsächlichen Desynchronisationspunkt, indem Sie die erstellte Datei F<gettextization.failed.po> untersuchen, und beheben Sie das Problem, wo es wirklich ist.

note: type: textblock
en: Other issues may come from duplicated strings in either the original or translation. Duplicated strings are merged in PO files, with two references.  This constitutes a difficulty for the gettextization algorithm, that is a simple one to one pairing between the B<msgid>s of both the master and the localized files. It is however believed that recent versions of po4a deal properly with duplicated strings, so you should report any remaining issue that you may encounter.
de: Andere Probleme können von doppelten Zeichenketten entweder im Original oder der Übersetzung kommen. Doppelte Zeichenketten werden in PO-Dateien mit zwei Referenzen zusammengeführt. Dies stellt für den Gettextisierungs-Algorithmus eine Schwierigkeit dar, der ein einfacher Paarungs-Algorithmus zwischen den B<msgid>s der Master-Dateien als auch den übersetzten Dateien ist. Allerdings wird davon ausgegangen, dass neuere Versionen von Po4a korrekt mit doppelten Zeichenketten umgehen, so dass Sie alle verbliebenen Probleme (auf Englisch) berichten sollten, auf die Sie treffen.

note: type: =head2
en: Reviewing files produced by B<po4a-gettextize>
de: Überprüfen von Dateien, die durch B<po4a-gettextize> erstellt wurden

note: type: textblock
en: Any file produced by B<po4a-gettextize> should be manually reviewed, even when the script terminates successfully. You should skim over the PO file, ensuring that the B<msgid> and B<msgstr> actually match. It is not necessary to ensure that the translation is perfectly correct yet, as all entries are marked as fuzzy translations anyway. You only need to check for obvious matching issues because badly matched translations will be dumped in subsequent steps while you want to salvage them.
de: Jede von B<po4a-gettextize> erstellte Datei sollte manuell geprüft werden, selbst wenn sich das Skript erfolgreich beendet. Sie sollten die PO-Datei überfliegen, um sicherzustellen, dass die B<msgid> und B<msgstr> tatsächlich zueinander passen. Es ist noch nicht notwendig, sicherzustellen, dass die Übersetzung perfekt korrekt ist, da alle Einträge sowieso als unscharf (»fuzzy«) markiert sind. Sie müssen nur auf offensichtliche Übereinstimmungsprobleme hin prüfen, da schlecht passende Übersetzungen in nachfolgenden Schritten verworfen werden, während Sie sie eigentlich retten wollen.

note: type: textblock
en: Fortunately, this step does not require to master the target languages as you only want to recognize similar elements in each B<msgid> and its corresponding B<msgstr>. As a speaker of French, English, and some German myself, I can do this for all European languages at least, even if I cannot say one word of most of these languages. I sometimes manage to detect matching issues in non-Latin languages by looking at string length, phrase structures (does the amount of interrogation marks match?) and other clues, but I prefer when someone else can review those languages.
de: Glücklicherweise verlangt dieser Schritt nicht, dass Sie die Zielsprache verstehen, sie müssen nur ähnliche Elemente in jeder B<msgid> und seiner entsprechenden B<msgstr> erkennen. Da ich selbst Französisch, Englisch und etwas Deutsch spreche, kann ich das mindestens für alle europäischen Sprachen durchführen. Manchmal gelingt es mir sogar, Zuordnungsprobleme in nicht lateinischen Sprachen zu erkennen, indem ich auf die Länge der Zeichenketten, Struktur der Phrasen (passt die Anzahl der Satzzeichen?) und andere Hinweise achte, aber ich bevorzuge, wenn jemand anders diese Sprachen überprüfen kann.

note: type: textblock
en: If you detect a mismatch, edit the original and translation files as if B<po4a-gettextize> reported an error, and try again. Once you have a decent PO file for your previous translation, backup it until you get po4a working correctly.
de: Falls Sie eine falsche Zuordnung erkennen, bearbeiten Sie das Original und die Übersetzungsdateien, falls B<po4a-gettextize> einen Fehler meldet und versuchen Sie es erneut. Sobald Sie eine geeigente PO-Datei für Ihre bisherige Übersetzung haben, sichern Sie diese, bis Sie Po4a korrekt zum Funktionieren bekommen.

note: type: =head2
en: Running B<po4a> for the first time
de: B<po4a> das erste Mal ausführen

note: type: textblock
en: The easiest way to setup po4a is to write a B<po4a.conf> configuration file, and use the integrated po4a program (B<po4a-updatepo> and B<po4a-translate> are deprecated). Please check the "CONFIGURATION FILE" Section in L<po4a(1)> documentation for more details.
de: Am einfachsten wird Po4a eingerichtet, indem eine Konfigurationsdatei B<po4a.conf> geschrieben und das integrierte Po4a-Programm verwandt wird (B<po4a-updatepo> und B<po4a-translate> sind veraltet). Bitte lesen Sie den Abschnitt »KONFIGURATIONSDATEI« in der Dokumentation L<po4a(1)> für weitere Details.

note: type: textblock
en: When B<po4a> runs for the first time, the current version of the master documents will be used to update the PO files containing the old translations that you salvaged through gettextization. This can take quite a long time, because many of the B<msgid>s of from the gettextization do not exactly match the elements of the POT file built from the recent master files. This forces gettext to search for the closest one using a costly string proximity algorithm.  For example, the first run over the Perl documentation's French translation (5.5 MB PO file) took about 48 hours (yes, two days) while the subsequent ones only take seconds.
de: Wenn B<po4a> das erste Mal ausgeführt wird, wird die aktuelle Version der Master-Dokumente zur Aktualisierung der PO-Dateien, die die alten, zu rettenden Übersetzungen enthalten, verwandt. Das kann eine ganze Zeit dauern, da viele der B<msgid>s der Gettextisierung nicht genau auf die Elemente der POT-Datei von den neuesten Master-Dateien passen. Dies zwingt Gettext dazu, den ähnlichsten mittels eines teueren Ähnlichkeitsalgorithmus für Zeichenketten zu ermitteln. Beispielsweise dauert der erste Lauf über die französische Übersetzung der Perl-Dokumentation (5,5 MB PO-Datei) mehr als 48 Stunden (ja, zwei Tage), während nachfolgende Läufe nur Sekunden dauerten.

note: type: =head2
en: Moving your translations to production
de: Verschieben Ihrer Übersetzung in den Produktivbetrieb

note: type: textblock
en: After this first run, the PO files are ready to be reviewed by translators. All entries were marked as fuzzy in the PO file by B<po4a-gettextization>, forcing their careful review before use. Translators should take each entry to verify that the salvaged translation actually match the current original text, update the translation on need, and remove the fuzzy markers.
de: Nach diesem ersten Lauf sind die PO-Dateien bereit, von Übersetzern geprüft zu werden. Alle Einträge in der PO-Datei wurden durch B<po4a-gettextization> als unscharf markiert, wodurch ihre sorgfältige Prüfung vor der Verwendung erzwungen wird. Übersetzer sollten sich jeden Eintrag vornehmen und nachprüfen, dass die gerettete Übersetzung tatsächlich auf den aktuellen Ursprungstext passt und bei Bedarf die Übersetzung aktualisieren und die »fuzzy«-Markierungen entfernen.

note: type: textblock
en: Once enough fuzzy markers are removed, B<po4a> will start generating the translation files on disk, and you're ready to move your translation workflow to production. Some projects find it useful to rely on weblate to coordinate between translators and maintainers, but that's beyond B<po4a>' scope.
de: Sobald genug »fuzzy«-Markierungen entfernt wurden, wird B<po4a> damit beginnen, die auf der Platte befindlichen Übersetzungsdateien zu erstellen und Sie können den Übersetzungsarbeitsablauf produktiv stellen. Einige Projekte finden es nützlich, Weblate zur Koordination zwischen Übersetzern und Betreuern zu verwenden, allerdings ist das jenseits des Aufgabenbereichs von B<po4a>.

note: type: textblock
en: po4a-normalize - normalize a documentation file by parsing it in po4a, and writing it back
de: po4a-normalize - normalisiert eine Dokumentationsdatei, indem sie mit Po4a ausgewertet und dann zurückgeschrieben wird

note: type: textblock
en: B<po4a-normalize> B<-f> I<fmt> I<master.doc>
de: B<po4a-normalize> B<-f> I<fmt> I<Master.doc>

note: type: textblock
en: The po4a (PO for anything) project goal is to ease translations (and more interestingly, the maintenance of translations) using gettext tools on areas where they were not expected like documentation.
de: Das Projektziel von Po4a (PO für alles) ist es, die Übersetzung (und interessanter, die Wartung der Übersetzung) zu vereinfachen, indem die Gettext-Werkzeuge auch für Gebiete verwendet werden, wo diese nicht erwartet werden, wie Dokumentation.

note: type: textblock
en: The B<po4a-normalize> script is a debugging tool used to make sure that po4a don't change the document when it's not supposed to. Only use it if you're developing a new module, or if you doubt the sanity of the tools.
de: Das Skript B<po4a-normalize> ist ein Fehlersuchwerkzeug, das dazu verwandt wird, um sicherzustellen, dass Po4a das Dokument nicht verändert, wenn das nicht erfolgen soll. Verwenden Sie das Skript nur, wenn Sie ein neues Modul entwickeln oder Sie den Verstand der Werkzeuge anzweifeln.

note: type: textblock
en: The generated document will be written to F<po4a-normalize.output> while the generated POT file will be written to F<po4a-normalize.po> by default, but you can use the B<--localized> and B<--pot> options to change that.
de: Das erstellte Dokument wird nach F<po4a-normalize.output> geschrieben, während die erstellte POT-Datei nach F<po4a-normalize.po> geschrieben wird. Sie können dies mit den Optionen B<--localized> und B<--pot> ändern.

note: type: textblock
en: Create an blank translated document.  The generated translated document will be generated assuming all messages are translated by a space or new line.
de: Erstellt ein leeres übersetztes Dokument. Das erstellte übersetzte Dookument wird unter der Annahme erstellt, dass alle Nachrichten durch ein Leerzeichen oder einen Zeilenumbruch übersetzt werden.

note: type: textblock
en: This is useful to check what parts of the document cannot be translated.
de: Dies ist nützlich, um zu prüfen, welche Teile des Dokuments nicht übersetzt werden können.

note: type: textblock
en: Name of the normalized file to produce (I<po4a-normalize.output> by default).
de: Name der zu erstellenden normierten Datei (standardmäßig I<po4a-normalize.output>).

note: type: textblock
en: Pot file to produce (I<po4a-normalize.po> by default).
de: Zu erzeugende POT-Datei (standardmäßig I<po4a-normalize.po>).

note: type: textblock
en: Copyright 2002-2020 by SPI, inc.
de: Copyright 2002-2020 SPI, Inc.

note: type: textblock
en: po4a-translate - convert a PO file back to documentation format
de: po4a-translate - konvertiert eine PO-Datei zurück ins Dokumentationsformat

note: type: textblock
en: B<po4a-translate> B<-f> I<fmt> B<-m> I<master.doc> B<-p> I<XX.po> B<-l> I<XX.doc>
de: B<po4a-translate> B<-f> I<fmt> B<-m> I<Master.dok> B<-p> I<XX.po> B<-l> I<XX.dok>

note: type: textblock
en: (I<XX.doc> is the output, all others are inputs)
de: (I<XX.dok> ist die Ausgabe, alles andere sind Eingaben)

note: type: textblock
en: The B<po4a-translate> script is in charge of converting the translation (which was done in a PO file) back into the documentation format. The provided PO file should be the translation of the POT file which was produced by L<po4a-gettextize(1)>.
de: Das Skript B<po4a-translate> ist dafür zuständig, die Übersetzung (die in einer PO-Datei erfolgte) zurück in das Dokumentationsformat zu wandeln. Die bereitgestellte PO-Datei sollte die Übersetzung einer POT-Datei sein, die mittels L<po4a-gettextize(1)> erstellt wurde.

note: type: textblock
en: Add a file to the resulting file (to put translator's name or a section "About this translation", for example). The first line of the file to insert should be a PO4A header indicating where it should be added (see section B<HOWTO add extra text to translations> in L<po4a(7)>).
de: Fügt eine Datei zu der entstehenden Datei hinzu (um beispielsweise den Namen des Übersetzers oder einen Abschnitt »Über diese Übersetzung« hinzuzufügen). Die erste Zeile der einzufügenden Datei sollte eine PO4A-Kopfzeile sein, die angibt, wo der Inhalt eingefügt werden soll (lesen Sie den Abschnitt B<HOWTO: Wie wird zusätzlicher Text zu Übersetzungen hinzugefügt> in L<po4a(7)>).

note: type: textblock
en: File containing the master document to translate.
de: Datei, die das zu übersetzende Master-Dokument enthält.

note: type: textblock
en: File where the localized (translated) document should be written.
de: Datei, in die das lokalisierte (übersetzte) Dokument geschrieben werden soll.

note: type: textblock
en: File from which the message catalog should be read.
de: Datei, aus der der Nachrichtenkatalog gelesen werden soll.

note: type: textblock
en: Minimal threshold for translation percentage to keep (i.e. write) the resulting file (default: 80). I.e. by default, files have to be translated at least at 80% to get written.
de: Minimaler Schwellwert in Prozent, ab der die übersetzte Datei erhalten (d.h. geschrieben) wird, standardmäßig 80. D.h., standardmäßig müssen Dateien zu 80% übersetzt sein, um geschrieben zu werden.

note: type: textblock
en: Column at which we should wrap the resulting file.
de: Spalte, an der die entstehende Datei umgebrochen werden soll.

note: type: =item
en: B<--porefs> I<type>[,B<wrap>|B<nowrap>]
de: B<--porefs> I<Typ>[,B<wrap>|B<nowrap>]

note: type: textblock
en: Argument can be followed by a comma and either B<wrap> or B<nowrap> keyword.  References are written by default on a single line.  The B<wrap> option wraps references on several lines, to mimic B<gettext> tools (B<xgettext> and B<msgmerge>).  This option will become the default in a future release, because it is more sensible.  The B<nowrap> option is available so that users who want to keep the old behavior can do so.
de: Das Argument kann von einem Komma und entweder dem Schlüsselwort B<wrap> oder B<nowrap> gefolgt werden. Referenzen werden standardmäßig auf eine einzelne Zeile geschrieben. Die Option B<wrap> bricht Referenzen über mehre Zeilen um, um die B<gettext> (B<xgettext> und B<msgmerge>) nachzuahmen. Diese Option wird in zukünftigen Veröffentlichungen die Vorgabe werden, da sie vernünftiger ist. Die Option B<nowrap> ist für Benutzer, die das alte Verhalten beibehalten möchten, verfügbar.

note: type: textblock
en: Historically, the gettext suite has reformatted the po files at the 77th column for cosmetics. This option specifies the behavior of po4a. If set to a numerical value, po4a will wrap the po file after this column and after newlines in the content. If set to B<newlines>, po4a will only split the msgid and msgstr after newlines in the content. If set to B<no>, po4a will not wrap the po file at all.  The wrapping of the reference comments is controlled by the B<--porefs> option.
de: Aus kosmetischen Gründen hat die Gettext-Programmsammlung in der Vergangenheit PO-Dateien in der 77.Spalte umgebrochen. Diese Option legt das Verhalten von Po4a fest. Falls auf einen numerischen Wert gesetzt, wird Po4a die PO-Datei nach dieser Spalte und nach Zeilenumbrüchen im Inhalt umbrechen. Falls auf B<newlines> gesetzt, wird Po4a die msgid und msgstr nur nach Zeilenumbrüchen im Inhalt auftrennen. Falls auf B<no> gesetzt, wird Po4a die PO-Datei überhaupt nicht umbrechen. Der Umbruch der Referenzkommentare wird mit der Option B<--porefs> gesteuert.

note: type: textblock
en: Note that this option has no impact on how the msgid and msgstr are wrapped, ie on how newlines are added to the content of these strings.
de: Beachten Sie, dass diese Option keine Auswirkung darauf hat, wie msgid und msgstr umgebrochen werden, d.h. wie Zeilenumbrüche zu dem Inhalt dieser Zeilen hinzugefügt werden.

note: type: =head1
en: Adding content (beside translations) to generated files
de: Inhalte (neben den Übersetzungen) zu erstellten Dateien hinzufügen

note: type: textblock
en: To add some extra content to the generated document beside what you translated (like the name of the translator, or an "About this translation" section), you should use the B<--addendum> option.
de: Um neben der eigentlichen Übersetzung zusätzliche Inhalte zum erstellten Dokument hinzuzufügen (wie den Namen des Übersetzers oder einen Abschnitt »Über diese Übersetzung«) sollten Sie die Option B<--addendum> verwenden.

note: type: textblock
en: The first line of the addendum must be a header indicating where to put it in the document (it can be before or after a given part of the document).  The rest of the file will be added verbatim to the resulting file without further processing.
de: Die erste Zeile des Addendums muss eine Kopfzeile sein, die angibt, wo im Dokument das Addendum eingefügt werden soll (dies kann vor oder nach einem bestimmten Teil des Dokuments sein). Der Rest der Datei wird unverändert zu der entstehenden Datei ohne weitere Bearbeitung hinzugefügt.

note: type: textblock
en: Note that if po4a-translate fails to add one of the given files, it discards the whole translation (because the missing file could be the one indicating the author, what would prevent the users to contact him to report bugs in the translation).
de: Beachten Sie, dass Po4a die gesamte Übersetzung verwerfen wird, falls eine der angegebenen Dateien nicht hinzugefügt werden konnte (da die fehlende Datei Informationen über den Autor enthalten könnte und somit den Benutzer davon abhalten könnte, Fehler in der Übersetzung zu berichten).

note: type: textblock
en: The header has a pretty rigid syntax. For more information on how to use this feature and how it works, please refer to the L<po4a(7)> man page.
de: Diese Kopfzeile hat eine ziemlich starre Syntax. Für weitere Informationen zur Nutzung dieser Funktionalität und deren Funktionsweise lesen Sie die Handbuchseite L<po4a(7)>.

note: type: textblock
en: po4a-updatepo - update the translation (in PO format) of documentation
de: po4a-updatepo - aktualisiert die Übersetzung (im PO-Format) einer Dokumentation

note: type: textblock
en: B<po4a-updatepo> B<-f> I<fmt> (B<-m> I<master.doc>)+ (B<-p> I<XX.po>)+
de: B<po4a-updatepo> B<-f> I<fmt> (B<-m> I<Master.dok>)+ (B<-p> I<XX.po>)+

note: type: textblock
en: (I<XX.po> are the outputs, all others are inputs)
de: (I<XX.po> sind die Ausgaben, alles andere sind Eingaben)

note: type: textblock
en: The B<po4a-updatepo> script is in charge of updating PO files to make them reflect the changes made to the original documentation file. For that, it converts the documentation file to a POT file, and call L<msgmerge(1)> on this new POT and on the provided PO files.
de: Das Skript B<po4a-updatepo> ist dafür verantwortlich, die PO-Dateien zu aktualisieren, um die Änderungen an der Originaldatei wiederzugeben. Dafür konvertiert es die Dokumentationsdatei in eine POT-Datei und ruft L<msgmerge(1)> mit dieser neuen POT-Datei und den bereitgestellten PO-Dateien auf.

note: type: textblock
en: It is possible to give more than one PO file (if you want to update several languages at once), and several documentation files (if you want to store the translations of several documents in the same PO file).
de: Es ist möglich, mehr als eine PO-Datei (falls Sie mehrere Sprachen gleichzeitig aktualisieren möchten) und mehrere Dokumentationsdateien anzugeben (falls Sie die Übersetzung mehrere Dokumente in der gleichen PO-Datei speichern möchten).

note: type: textblock
en: If the master document has non-ASCII characters, this script will convert the PO files to UTF-8 (if they weren't already), for a transparent handling of non-standard characters.
de: Falls im Master-Dokument nicht ASCII-Zeichen vorkommen, wird dieses Skript die PO-Dateien nach UTF-8 konvertieren (falls sie dies nicht bereits waren), um Zeichen außerhalb des Standards transparent zu handhaben.

note: type: textblock
en: File(s) containing the master document to translate.
de: Datei(en), die das zu übersetzende Master-Dokumente enthalten.

note: type: textblock
en: Charset of the files containing the document to translate. Note that all files must have the same charset.
de: Zeichensatz der Dateien, die das zu übersetzende Dokument enthalten. Beachten Sie, dass alle Dateien im gleichen Zeichensatz vorliegen müssen.

note: type: textblock
en: PO file(s) to update. If these files do not exist, they are created by B<po4a-updatepo>.
de: Zu aktualisierende PO-Datei(en). Falls diese Dateien noch nicht existieren werden sie mit B<po4a-updatepo> erstellt.

note: type: textblock
en: msguntypot - update PO files when a typo is fixed in POT file
de: msguntypot - aktualisiert PO-Dateien, wenn ein Tippfehler in einer POT-Datei korrigiert wurde

note: type: textblock
en: B<msguntypot> B<-o> I<old_pot> B<-n> I<new_pot> I<pofiles> ...
de: B<msguntypot> B<-o> I<alte_POT> B<-n> I<neue_POT> I<PO-Dateien> …

note: type: textblock
en: When you fix a trivial error which surely doesn't affect translations (e.g.  a typo) in a POT file, you should unfuzzy the corresponding msgstr in the translated PO files to avoid so extra work to the translators.
de: Wenn Sie einen trivialen Fehler in einer POT-Datei korrigieren, der definitiv die Übersetzungen nicht betrifft (z.B. einen Tippfehler), sollten Sie bei den entsprechenden Msgstr den »fuzzy«-Eintrag in den übersetzen PO-Dateien entfernen, um zusätzliche Arbeit für die Übersetzer zu vermeiden.

note: type: textblock
en: This task is difficult and error prone when done manually, and this tool is there to help doing so correctly. You just need to provide the two versions of the POT file: before the edition and after as marked in the above synopsis, and it all becomes automatic.
de: Diese Aufgabe ist schwierig und fehlerträchtig, wenn Sie sie manuell durchführen. Daher gibt es dieses Werkzeug, um es korrekt zu erledigen. Sie müssen nur die zwei Versionen der POT-Datei bereitstellen: vor der Änderung und danach, wie in der oben angegeben Übersicht aufgeführt. Dann passiert alles automatisch.

note: type: =head1
en: HOW TO USE IT
de: ANLEITUNG

note: type: textblock
en: In short, when you discover a typo in one of your [english] message, do the following:
de: Kurz gesagt, wenn Sie einen Tippfehler in einer Ihrer Nachrichten (in der Quellsprache, i.d.R. englisch) entdecken, führen Sie Folgendes durch:

note: type: =item
en: - Regenerate your POT and PO files.
de: - Erstellen Sie die POT- und PO-Dateien neu.

note: type: verbatim
en:   make -C po/ update-po # for message program translations
      debconf-updatepo      # for debconf translations
      po4a po4a.conf        # for po4a based documentation translations
de:   make -C po/ update-po # für Übersetzungen der Meldungen in Programmen
      debconf-updatepo      # für Debconf-Übersetzungen
      po4a po4a.conf        # für Po4a-basierte Dokumentenübersetzungen

note: type: textblock
en: or something else, depending on your project's building settings. You know how to make sure your POT and PO files are uptodate, don't you??
de: oder etwas anderes, abhängig von den Baueinstellungen Ihres Projekts. Sie wissen, wie Sie sicherstellen können, dass die POT- und PO-Dateien aktuell sind, oder?

note: type: =item
en: - Make a copy of your POT file.
de: - Erstellen Sie eine Kopie der POT-Datei.

note: type: verbatim
en:   cp myfile.pot myfile.pot.orig
de:   cp meineDatei.pot meineDatei.pot.orig

note: type: =item
en: - Make a copy of all your PO files.
de: - Erstellen Sie eine Kopie aller PO-Dateien.

note: type: verbatim
en:   mkdir po_fridge; cp *.po po_fridge
de:   mkdir po_Eisfach; cp *.po po_Eisfach

note: type: =item
en: - Fix your typo.
de: - Korrigieren Sie Ihren Tippfehler.

note: type: textblock
en: $EDITOR the_file_in_which_there_is_a_typo
de: $EDITOR die_Datei_mit_dem_Tippfehler

note: type: textblock
en: See above.
de: Siehe oben

note: type: textblock
en: At this point, the typo fix fuzzied all the translations, and this unfortunate change is the only one between the PO files of your main directory and the one from the fridge. Here is how to solve this.
de: Jetzt sind durch die Korrektur des Tippfehlers alle Übersetzungen an dieser Stelle unscharf. Diese unglückliche Änderung ist die einzige zwischen den PO-Dateien in Ihrem Hauptverzeichnis und denen aus dem Eisfach. Sie können das wie folgt beheben:

note: type: =item
en: - Discard fuzzy translation, restore the ones from the fridge.
de: - Verwerfen Sie die unscharfen Übersetzungen, stellen Sie die aus dem Eisfach wieder her.

note: type: verbatim
en:   cp po_fridge/*.po .
de:   cp po_Eisfach/*.po .

note: type: =item
en: - Manually merge the PO files with the new POT file, but taking the useless fuzzy into account.
de: - Fügen Sie die PO-Dateien manuell mit der neuen POT-Datei zusammen, wobei Sie die nutzlosen unscharfen Einträge berücksichtigen:

note: type: verbatim
en:   msguntypot -o myfile.pot.orig -n myfile.pot *.po
de:   msguntypot -o meineDatei.pot.orig -n meineDatei.pot *.po

note: type: =item
en: - Cleanups.
de: - Nacharbeiten

note: type: verbatim
en:   rm -rf myfile.pot.orig po_fridge
de:   rm -rf meineDatei.pot.orig po_Eisfach

note: type: textblock
en: You're done. The typo was eradicated from msgstr of both your POT and PO files, and the PO files were not fuzzyied in the process. Your translators love you already.
de: Das war's. Der Tippfehler wurde aus den Msgstr sowohl der POT- als auch den PO-Dateien beseitigt und die PO-Dateien sind nach Abschluss des Prozesses nicht mehr unscharf. Ihre Übersetzer lieben Sie jetzt schon.

note: type: textblock
en: Despite its name, this tool is not part of the gettext tool suite. It is instead part of po4a. More precisely, it's a random Perl script using the fine po4a modules. For more information about po4a, please see:
de: Anders als sein Name es vermuten lässt, ist dieses Werkzeug nicht Teil der Gettext-Werkzeugsammlung. Es ist stattdessen Teil von Po4a. Oder genauer, ein zufälliges Skript, das die schönen Po4a-Module benutzt. Für weitere Informationen über Po4a lesen Sie bitte:

note: type: textblock
en: Copyright 2005 by SPI, inc.
de: Copyright 2005 SPI, Inc.

note: type: textblock
en: po4a - framework to translate documentation and other materials
de: Po4a - Rahmenwerk zur Übersetzung von Dokumentation und anderen Materialien

note: type: =head1
en: Introduction
de: Einleitung

note: type: textblock
en: po4a (PO for anything) eases the maintenance of documentation translation using the classical gettext tools. The main feature of po4a is that it decouples the translation of content from its document structure.
de: Po4a (PO für alles) erleichtert die Pflege von Dokumentationsübersetzungen mittels der klassischen Gettext-Werkzeuge. Die Hauptfunktionalität von Po4a ist, dass sie die Übersetzung des Inhaltes von der Dokumentenstruktur trennt.

note: type: textblock
en: This document serves as an introduction to the po4a project with a focus on potential users considering whether to use this tool and on the curious wanting to understand why things are the way they are.
de: Dieses Dokument dient als Einführung in das Po4a-Projekt mit einem Fokus auf mögliche Benutzer, die überlegen, ob sie dieses Werkzeug verwenden sollten und den Neugierigen, die verstehen möchten, warum die Dinge so sind, wie sie sind.

note: type: =head1
en: Why po4a?
de: Warum Po4a?

note: type: textblock
en: The philosophy of Free Software is to make the technology truly available to everyone. But licensing is not the only consideration: untranslated free software is useless for non-English speakers. Therefore, we still have some work to do to make software available to everybody.
de: Die Philosophie Freier Software ist es, die Technik wirklich für jeden verfügbar zu machen. Aber Lizenzierung ist nicht die einzige Betrachtung: nicht übersetzte Freie Software ist für nicht englisch sprechende Personen nutzlos. Daher haben wir noch einiges zu tun, Software für jede Person verfügbar zu machen.

note: type: textblock
en: This situation is well understood by most projects and everybody is now convinced of the necessity to translate everything. Yet, the actual translations represent a huge effort of many individuals, crippled by small technical difficulties.
de: Von den meisten Projekten wird diese Situation sehr gut verstanden und jeder ist jetzt von der Notwendigkeit, alles zu übersetzen, überzeugt. Allerdings stellt die eigentliche Übersetzung einen riesengroßen Aufwand durch viele Beteiligte dar, die zudem von kleinen technischen Schwierigkeiten behindert werden.

note: type: textblock
en: Thankfully, Open Source software is actually very well translated using the gettext tool suite. These tools are used to extract the strings to translate from a program and present the strings to translate in a standardized format (called PO files, or translation catalogs). A whole ecosystem of tools has emerged to help the translators actually translate these PO files. The result is then used by gettext at run time to display translated messages to the end users.
de: Dankenswerterweise ist Open-Source-Software mittels der Gettext-Werkzeugsammlung sehr gut übersetzt. Diese Werkzeuge werden zum Entnehmen der zu übersetzenden Zeichenketten aus einem Programm verwandt und dann werden diese Zeichenketten in einem standardisierten Format dargestellt (genannt PO-Dateien oder Übersetzungskataloge). Ein gesamtes Ökosystem an Werkzeugen ist entstanden, um Übersetzern beim eigentlichen Übersetzen dieser PO-Dateien zu helfen. Das Ergebnis wird dann von Gettext zur Laufzeit verwandt, um dem Endbenutzer die übersetzten Meldungen anzuzeigen.

note: type: textblock
en: Regarding documentation, however, the situation still somewhat disappointing.  At first translating documentation may seem to be easier than translating a program as it would seem that you just have to copy the documentation source file and start translating the content. However, when the original documentation is modified, keeping track of the modifications quickly turns into a nightmare for the translators. If done manually, this task is unpleasant and error prone.
de: Im Hinblick auf Dokumentation ist die Situation allerdings immer noch etwas entäuschend. Anfangs erscheint die Übersetzung der Dokumentation leichter als die Übersetzung eines Programms, da es so aussieht, als müssten Sie nur das Ursprungsdokument kopieren und anfangen, den Inhalt zu übersetzen. Wenn allerdings das Ursprungsdokument verändert wird, wird die Nachverfolgung der Änderungen schnell zu einem Albtraum für Übersetzer. Falls dies manuell erfolgt, ist die Aufgabe unschön und fehlerbehaftet.

note: type: textblock
en: Outdated translations are often worse than no translation at all. End-users can be tricked by documentation describing an old behavior of the program.  Furthermore, they cannot interact directly with the maintainers since they don't speak English. Additionally, the maintainer cannot fix the problem as they don't know every language in which their documentation is translated.  These difficulties, often caused by poor tooling, can undermine the motivation of volunteer translators, further aggravating the problem.
de: Veraltete Übersetzungen sind oft schlimmer als gar keine. Endbenutzer können durch Dokumentation, die veraltetes Verhalten des Programms beschreibt, verwirrt werden. Sie können zudem nicht direkt mit dem Betreuer in Kontakt treten, da sie kein Englisch sprechen. Zusätzlich kann der Betreuer keine Probleme beheben, da er nicht jede Sprache spricht, in die seine Dokumentation übersetzt ist. Diese Schwierigkeiten, die oft durch schlechte Werkzeuge hervorgerufen werden, können die Motivation für freiwillige Übersetzer unterminieren, wodurch das Problem weiter verschlimmert wird.

note: type: textblock
en: B<The goal of the po4a project is to ease the work of documentation translators>.  In particular, it makes documentation translations I<maintainable>.
de: B<Das Ziel des Po4a-Projektes ist es, die Arbeit der Dokumentenübersetzer zu erleichtern.> Insbesondere macht es die Dokumentenübersetzungen I<pflegbar>.

note: type: textblock
en: The idea is to reuse and adapt the gettext approach to this field. As with gettext, texts are extracted from their original locations and presented to translators as PO translation catalogs. The translators can leverage the classical gettext tools to monitor the work to do, collaborate and organize as teams. po4a then injects the translations directly into the documentation structure to produce translated source files that can be processed and distributed just like the English files. Any paragraph that is not translated is left in English in the resulting document, ensuring that the end users never see an outdated translation in the documentation.
de: Die Idee besteht darin, den Gettext-Ansatz für dieses Feld wiederzuverwenden und anzupassen. Wie bei Gettext werden Texte aus ihren ursprünglichen Orten herausgelöst und den Übersetzern als PO-Übersetzungskataloge dargestellt. Die Übersetzer können die klassischen Gettext-Werkzeuge wirksam einsetzen, um die zu erledigende Arbeit zu überwachen, zusammenzuarbeiten und sich als Teams zu organisieren. Po4a fügt dann die Übersetzung direkt in die Dokumentationsstruktur ein, um übersetzte Quelldateien zu erstellen, die dann genau wie die englischen Dateien verarbeitet und verteilt werden können. Jeder Absatz, der nicht übersetzt ist, verbleibt im entstehenden Dokument auf englisch, wodurch sichergestellt ist, dass die Endbenutzer niemals veraltete Übersetzungen in der Dokumentation sehen.

note: type: textblock
en: This automates most of the grunt work of the translation maintenance.  Discovering the paragraphs needing an update becomes very easy, and the process is completely automated when elements are reordered without further modification. Specific verification can also be used to reduce the chance of formatting errors that would result in a broken document.
de: Dies automatisiert den größten Teil der Routinearbeit bei der Wartung von Übersetzungen. Es wird sehr leicht, die zu aktualisierenden Absätze zu erkennen und der Prozess ist vollständig automatisiert, wenn Elemente ohne weitere Änderungen neu sortiert werden. Es können auch spezielle Überprüfungen verwandt werden, um die Möglichkeit von Formatierungsfehlern zu verringern, die zu einem defekten Dokument führen würden.

note: type: textblock
en: Please also see the B<FAQ> below in this document for a more complete list of the advantages and disadvantages of this approach.
de: Bitte lesen Sie auch die B<FAQ> weiter unten in diesem Dokument für eine komplette Liste der Vor- und Nachteile dieser Vorgehensweise.

note: type: =head2
en: Supported formats
de: Unterstützte Formate

note: type: textblock
en: Currently, this approach has been successfully implemented to several kinds of text formatting formats:
de: Derzeit wurde diese Vorgehensweise erfolgreich für mehrere Arten von Textformatierungsformaten umgesetzt:

note: type: =item
en: man (mature parser)
de: man (ausgereiftes Auswertprogramm)

note: type: textblock
en: The good old manual pages' format, used by so many programs out there. po4a support is very welcome here since this format is somewhat difficult to use and not really friendly to newbies.
de: Das gute alte Handbuchformat, verwandt von vielen Programmen da draußen. Die Unterstützung durch Po4a wird hier sehr begrüßt, da dieses Format etwas schwierig zu benutzen und für Neulinge nicht wirklich einladend ist.

note: type: textblock
en: The L<Locale::Po4a::Man(3pm)|Man> module also supports the mdoc format, used by the BSD man pages (they are also quite common on Linux).
de: Das Modul L<Locale::Po4a::Man(3pm)|Man> unterstützt das Format »mdoc«, das von den BSD-Handbuchseiten verwandt wird (diese sind auch unter Linux recht häufig anzutreffen).

note: type: =item
en: AsciiDoc (mature parser)
de: AsciiDoc (ausgereiftes Auswertprogramm)

note: type: textblock
en: This format is a lightweight markup format intended to ease the authoring of documentation. It is for example used to document the git system. Those manpages are translated using po4a.
de: Dieses Format ist ein leichtgewichtiges Textauszeichnungsformat, um das Schreiben von Dokumentation zu erleichtern. Es wird beispielsweise von dem Git-System verwandt. Dessen Handbuchseiten werden mittels Po4a übersetzt.

note: type: textblock
en: See L<Locale::Po4a::AsciiDoc> for details.
de: Siehe L<Locale::Po4a::AsciiDoc> für Details.

note: type: =item
en: pod (mature parser)
de: pod (ausgereiftes Auswertprogramm)

note: type: textblock
en: This is the Perl Online Documentation format. The language and extensions themselves are documented using this format in addition to most existing Perl scripts. It makes easy to keep the documentation close to the actual code by embedding them both in the same file. It makes programmer's life easier, but unfortunately, not the translator's, until you use po4a.
de: Das ist das »Perl Online Documentation«-Format. Die Sprache und Erweiterungen selbiger sind in diesem Format dokumentiert sowie die meisten existierenden Perl-Skripte. Sie erleichtert es, die Dokumentation nahe beim eigentlichen Code zu halten, indem beide in die gleiche Datei eingebettet werden. Es erleichtert Programmierern die Arbeit, aber unglücklicherweise nicht den Übersetzern, bis sie Po4a verwenden.

note: type: textblock
en: See L<Locale::Po4a::Pod> for details.
de: Siehe L<Locale::Po4a::Pod> für Details.

note: type: =item
en: sgml (mature parser)
de: sgml (ausgereiftes Auswertprogramm)

note: type: textblock
en: Even if superseded by XML nowadays, this format is still used for documents which are more than a few screens long. It can even be used for complete books.  Documents of this length can be very challenging to update. B<diff> often reveals useless when the original text was re-indented after update.  Fortunately, po4a can help you after that process.
de: Obwohl dieses Format heutzutage von XML verdrängt wurde, wird es noch für Dokumente verwandt, die mehr als ein paar Bildschirmseiten lang sind. Es kann sogar für komplette Bücher verwandt werden. Die Übersetzung so langer Dokumente zu aktualisieren kann eine echte Herausforderung werden. B<diff> stellt sich oft als nutzlos raus, wenn der ursprüngliche Text nach der Aktualisierung neu eingerückt wurde. Glücklicherweise kann Ihnen Po4a nach diesem Prozess helfen.

note: type: textblock
en: Currently, only DebianDoc and DocBook DTD are supported, but adding support for a new one is really easy. It is even possible to use po4a on an unknown SGML DTD without changing the code by providing the needed information on the command line. See L<Locale::Po4a::Sgml(3pm)> for details.
de: Derzeit werden nur die DebianDoc- und DocBook-DTD unterstützt, aber das Hinzufügen einer Unterstützung für eine neue DTD ist wirklich leicht. Es ist sogar möglich, Po4a für eine unbekannte SGML-DTD zu verwenden, ohne den Code zu verändern, indem die benötigten Informationen auf der Befehlszeile übergeben werden. Lesen Sie L<Locale::Po4a::Sgml(3pm)> für weitere Details.

note: type: =item
en: TeX / LaTeX (mature parser)
de: TeX / LaTeX (ausgereiftes Auswertprogramm)

note: type: textblock
en: The LaTeX format is a major documentation format used in the Free Software world and for publications.
de: Das LaTeX-Format ist ein wichtiges Dokumentationsformat, das in der Welt der Freien Software und für Veröffentlichungen genutzt wird.

note: type: textblock
en: The L<Locale::Po4a::LaTeX(3pm)|LaTeX> module was tested with the Python documentation, a book and some presentations.
de: Das Modul L<Locale::Po4a::LaTeX(3pm)|LaTeX> wurde mit der Python-Dokumentation, einem Buch und ein paar Präsentationen ausprobiert.

note: type: =item
en: text (mature parser)
de: text (ausgereiftes Auswertprogramm)

note: type: textblock
en: The Text format is the base format for many formats that include long blocks of text, including Markdown, fortunes, YAML front matter section, debian/changelog, and debian/control.
de: Das Text-Format ist das Grundlagenformat für viele Formate, die längere Textblöcke enthalten wie Markdown, Glückssprüche, YAML-Deckblattabschnitte, debian/changelog und debian/control.

note: type: textblock
en: This supports the common format used in Static Site Generators, READMEs, and other documentation systems. See L<Locale::Po4a::Text(3pm)|Text> for details.
de: Dies unterstützt das häufige in »Static Site Generators«, READMEs und anderen Dokumentationssystemen verwandte Format. Siehe L<Locale::Po4a::Text(3pm)|Text> für Details.

note: type: =item
en: xml and XHMTL (probably mature parser)
de: xml und XHMTL (wahrscheinlich ausgereiftes Auswertprogramm)

note: type: textblock
en: The XML format is a base format for many documentation formats.
de: Das XML-Format liegt vielen Dokumentationsformaten zu Grunde.

note: type: textblock
en: Currently, the DocBook DTD (see L<Locale::Po4a::Docbook(3pm)> for details) and XHTML are supported by po4a.
de: Derzeit werden die DocBook-DTD (siehe L<Locale::Po4a::Docbook(3pm)> für weitere Details) und XHTML von Po4a unterstützt.

note: type: =item
en: BibTex (probably mature parser)
de: BibTex (wahrscheinlich ausgereiftes Auswertprogramm)

note: type: textblock
en: The BibTex format is used alongside LaTex for formatting lists of references (bibliographies).
de: Das BibTex-Format wird zusammen mit LaTex zur Formatierung von Fundstellen (Bibliographien) verwandt.

note: type: textblock
en: See L<Locale::Po4a::BibTex> for details.
de: Siehe L<Locale::Po4a::BibTex> für Details.

note: type: =item
en: Docbook (probably mature parser)
de: Docbook (wahrscheinlich ausgereiftes Auswertprogramm)

note: type: textblock
en: A XML-based markup language that uses semantic tags to describe documents.
de: Ein XML-basierte Auszeichnungssprache, die semantische Markierungen zur Beschreibung von Dokumenten verwendet.

note: type: textblock
en: See L<Locale::Po4a:Docbook> for greater details.
de: Siehe L<Locale::Po4a:Docbook> für genauere Details.

note: type: =item
en: Guide XML (probably mature parser)
de: Anleitungs-XML (wahrscheinlich ausgereiftes Auswertprogramm)

note: type: textblock
en: A XML documentation format. This module was developed specifically to help with supporting and maintaining translations of Gentoo Linux documentation up until at least March 2016 (Based on the Wayback Machine). Gentoo have since moved to the DevBook XML format.
de: Ein XML-Dokumentationsformat. Dieses Modul wurde speziell entwickelt, um bei der Unterstützung und Betreuung der Gentoo-Linux-Dokumentation bis mindestens einschließlich März 2016 (laut der Wayback Machine) zu helfen. Gentoo ist seitdem auf das Format DevBook XML umgestiegen.

note: type: textblock
en: See L<Locale::Po4a:Guide> for greater details.
de: Siehe L<Locale::Po4a:Guide> für genauere Details.

note: type: =item
en: Wml (probably mature parser)
de: Wml (wahrscheinlich ausgereiftes Auswertprogramm)

note: type: textblock
en: The Web Markup Language, do not mixup WML with the WAP stuff used on cell phones.  This module relies on the Xhtml module, which itself relies on the XmL module.
de: Die Web-Auszeichnungssprache, verwechseln Sie WML nicht dem WAP-Zeug, das auf Handys verwendet wird. Dieses Modul baut auf dem Xhtml-Modul auf, das wiederum auf dem XmL-Modul aufbaut.

note: type: textblock
en: See L<Locale::Po4a::Wml> for greater details.
de: Siehe L<Locale::Po4a::Wml> für genauere Details.

note: type: =item
en: Yaml (probably mature parser)
de: Yaml (wahrscheinlich ausgereiftes Auswertprogramm)

note: type: textblock
en: A strict superset of JSON. YAML is often used as systems or configuration projects.  YAML is at the core of Red Hat's Ansible.
de: Eine strikte Obermenge von JSON. YAML wird oft als System- oder Konfigurationsprojekt verwandt. YAML ist der Kern von Red Hats Ansible.

note: type: textblock
en: See L<Locale::Po4a::Yaml> for greater details.
de: Siehe L<Locale::Po4a::Yaml> für genauere Details.

note: type: =item
en: RubyDoc (probably mature parser)
de: RubyDoc (wahrscheinlich ausgereiftes Auswertprogramm)

note: type: textblock
en: The Ruby Document (RD) format, originally the default documentation format for Ruby and Ruby projects before converted to RDoc in 2002. Though apparently the Japanese version of the Ruby Reference Manual still use RD.
de: Das Ruby-Dokument (RD-)Format, ursprünglich das Standarddokumentationsformat von Ruby und Ruby-Projekten, bevor die Umstellung auf RDoc in 2002 erfolgte. Obwohl anscheinend die japanische Version des Ruby-Referenzhandbuches immer noch RD verwendet.

note: type: textblock
en: See L<Locale::Po4a::RubyDoc> for greater details.
de: Siehe L<Locale::Po4a::RubyDoc> für genauere Details.

note: type: =item
en: Halibut (probably experimental parser)
de: Halibut (wahrscheinlich experimentelles Auswertprogramm)

note: type: textblock
en: A documentation production system, with elements similar to TeX, debiandoc-sgml, TeXinfo, and others, developed by Simon Tatham, the developer of PuTTY.
de: Ein Dokumentenerstellungssystem, mit Elementen, die TeX, debiandoc-sgml, TeXinfo und anderen ähneln. Entwickelt von Simon Tatham, dem Entwickler von PuTTY.

note: type: textblock
en: See L<Locale::Po4a:Halibut> for greater details.
de: Siehe L<Locale::Po4a:Halibut> für genauere Details.

note: type: =item
en: Ini (probably experimental parser)
de: Ini (wahrscheinlich experimentelles Auswertprogramm)

note: type: textblock
en: Configuration file format popularized by MS-DOS.
de: Konfigurationsdateiformat, durch MS-DOS beliebt geworden.

note: type: textblock
en: See L<Locale::Po4a::Ini> for greater details.
de: Siehe L<Locale::Po4a::Ini> für genauere Details.

note: type: =item
en: texinfo (very highly experimental parser)
de: texinfo (sehr hoch experimentelles Auswertprogramm)

note: type: textblock
en: All of the GNU documentation is written in this format (it's even one of the requirements to become an official GNU project). The support for L<Locale::Po4a::Texinfo(3pm)|Texinfo> in po4a is still at the beginning.  Please report bugs and feature requests.
de: Die gesamte GNU-Dokumentation ist in diesem Format geschrieben (dies ist sogar eine der Voraussetzungen, um ein offizielles GNU-Projekt zu werden). Die Unterstützung für L<Locale::Po4a::Texinfo(3pm)|Texinfo> in Po4a ist noch ganz am Anfang. Bitte berichten Sie Fehler und Funktionalitätswünsche.

note: type: =item
en: Others supported formats
de: Andere unterstützte Formate

note: type: textblock
en: Po4a can also handle some more rare or specialized formats, such as the documentation of compilation options for the 2.4+ Linux kernels (L<Locale::Po4a::KernelHelp>) or the diagrams produced by the dia tool (L<Locale::Po4a:Dia>). Adding a new format is often very easy and the main task is to come up with a parser for your target format. See L<Locale::Po4a::TransTractor(3pm)> for more information about this.
de: Po4a kann auch mit einigen selteneren oder spezialisierten Formaten umgehen, wie dem Dokumentationsformat der Kompilierungsoptionen des 2.4+-Linux-Kernels (L<Locale::Po4A::KernelHelp>) oder der vom Dia-Werkzeug erstellten Diagramme (L<Locale::Po4a:Dia>). Das Hinzufügen eines neuen Formats ist oft sehr leicht und die Hauptaufgabe besteht darin, einen Parser für Ihr Zielformat zu entwickeln. Lesen Sie L<Locale::Po4a::TransTractor(3pm)> für mehr Informationen dazu.

note: type: =item
en: Unsupported formats
de: Nicht unterstützte Formate

note: type: textblock
en: Unfortunately, po4a still lacks support for several documentation formats. Many of them would be easy to support in po4a. This includes formats not just used for documentation, such as, package descriptions (deb and rpm), package installation scripts questions, package changelogs, and all the specialized file formats used by programs such as game scenarios or wine resource files.
de: Unglücklicherweise fehlen Po4a immer noch Unterstützung für eine Reihe von Dokumentationsformaten. Viele davon könnten leicht in Po4a unterstützt werden. Dazu gehören auch Formate, die nicht nur für die Dokumentation verwandt werden, wie Paketbeschreibungen (Deb und RPM), Paketinstallationsskriptfragen, Paket-Änderungsprotokolle (»Changelogs«) und alle spezialisierten Dateiformate, die von Programmen verwandt werden, wie Spieleszenarien oder WINE-Ressource-Dateien.

note: type: =head1
en: Using po4a
de: Po4a verwenden

note: type: textblock
en: Historically, po4a was built around four scripts, each fulfilling a specific task. L<po4a-gettextize(1)> helps bootstrapping translations and optionally converting existing translation projects to po4a. L<po4a-updatepo(1)> reflects the changes to the original documentation into the corresponding po files.  L<po4a-translate(1)> builds translated source file from the original file and the corresponding PO file. In addition, L<po4a-normalize(1)> is mostly useful to debug the po4a parsers, as it produces an untranslated document from the original one. It makes it easier to spot the glitches introduced by the parsing process.
de: Historisch war Po4a um vier Skripte herum aufgebaut, wobei jedes eine bestimmte Aufgabe erfüllte. L<po4a-gettextize(1)> hilft beim erstmaligen Erzeugen von Übersetzungen und optional der Umwandlung bestehender Übersetzungsprojekte in Po4a. L<po4a-updatepo(1)> spiegelt die Änderungen an der Ursprungsdokumentation in die entsprechenden PO-Dateien. L<po4a-translate(1)> baut übersetzte Quelldateien aus der ursprünglichen Datei und der entsprechenden PO-Datei. Zusätzlich ist L<po4a-normalize(1)> hauptsächlich zur Fehlersuche der Po4a-Auswerteprogramme nützlich, da es ein nicht übersetztes Dokument aus dem ursprünglichen baut. Dies erleichtert es, Störungen zu finden, die aus dem Auswerteprozess stammen.

note: type: textblock
en: The rest of this section gives an overview of how use the scripts' interface of po4a. Most users will probably prefer to use the all-in-one tool, that is described in the documentation of L<po4a(1)>.
de: Der Rest dieses Abschnitts gibt einen Überblick über die Skriptschnittstelle von Po4a. Die meisten Benutzer werden wahrscheinlich das Komplettwerkzeug bevorzugen, das in der Dokumentation von L<po4a(1)> beschrieben ist.

note: type: =head2
en: Graphical overview of the po4a scripts
de: Graphischer Überblick über die Po4a-Skripte

note: type: textblock
en: The following schema gives an overview of how each po4a script can be used.  Here, F<master.doc> is an example name for the documentation to be translated; F<XX.doc> is the same document translated in the language XX while F<doc.XX.po> is the translation catalog for that document in the XX language. Documentation authors will mostly be concerned with F<master.doc> (which can be a manpage, an XML document, an asciidoc file or similar); the translators will be mostly concerned with the PO file, while the end users will only see the F<XX.doc> file.
de: Das nachfolgende Schema gibt einen Überblick darüber, wie jedes Po4a-Skript verwandt werden kann. Hier steht F<master.dok> als Beispielname für die zu übersetzende Dokumentation; F<XX.dok> das gleiche Dokument übersetzt in die Sprache XX während F<doc.XX.po> der Übersetzungskatalog für das Dokument in der Sprache XX ist. Dokumentationsautoren kümmern sich hauptsächlich um F<master.dok> (dies kann eine Handbuchseite, ein XML-Dokument, eine Asciidoc-Datei oder ähnliches sein); die Übersetzer kümmern sich hauptsächlich um die PO-Dateien, während die Endbenutzer nur die Datei F<XX.dok> sehen werden.

note: type: verbatim
en:                                    master.doc
                                           |
                                           V
         +<-----<----+<-----<-----<--------+------->-------->-------+
         :           |                     |                        :
    {translation}    |         { update of master.doc }             :
         :           |                     |                        :
       XX.doc        |                     V                        V
     (optional)      |                 master.doc ->-------->------>+
         :           |                   (new)                      |
         V           V                     |                        |
      [po4a-gettextize]   doc.XX.po -->+   |                        |
              |            (old)       |   |                        |
              |              ^         V   V                        |
              |              |     [po4a-updatepo]                  |
              V              |           |                          V
       translation.pot       ^           V                          |
              |              |        doc.XX.po                     |
              |              |         (fuzzy)                      |
       { translation }       |           |                          |
              |              ^           V                          V
              |              |     {manual editing}                 |
              |              |           |                          |
              V              |           V                          V
          doc.XX.po --->---->+<---<-- doc.XX.po    addendum     master.doc
          (initial)                 (up-to-date)  (optional)   (up-to-date)
              :                          |            |             |
              :                          V            |             |
              +----->----->----->------> +            |             |
                                         |            |             |
                                         V            V             V
                                         +------>-----+------<------+
                                                      |
                                                      V
                                               [po4a-translate]
                                                      |
                                                      V
                                                    XX.doc
                                                 (up-to-date)
de:                                    Master.dok
                                           |
                                           V
         +<-----<----+<-----<-----<--------+------->-------->-------+
         :           |                     |                        :
    {Übersetzung}    |     { Aktualisierung von Master.dok }        :
         :           |                     |                        :
       XX.dok        |                     V                        V
    (optional)       |                 Master.dok ->-------->------>+
         :           |                   (neu)                      |
         V           V                     |                        |
      [po4a-gettextize]   dok.XX.po--->+   |                        |
              |            (alt)       |   |                        |
              |              ^         V   V                        |
              |              |     [po4a-updatepo]                  |
              V              |           |                          V
       Übersetzung.pot       ^           V                          |
              |              |         dok.XX.po                    |
              |              |        (unscharf)                    |
       { Übersetzung }       |           |                          |
              |              ^           V                          V
              |              |  {manuelle Bearbeitung}              |
              |              |           |                          |
              V              |           V                          V
          dok.XX.po --->---->+<---<---- doc.XX.po   Addendum     Master.dok
        (anfänglich)                    (aktuell)  (optional)     (aktuell) 
              :                          |            |             |
              :                          V            |             |
              +----->----->----->------> +            |             |
                                         |            |             |
                                         V            V             V
                                         +------>-----+------<------+
                                                      |
                                                      V
                                               [po4a-translate]
                                                      |
                                                      V
                                                    XX.dok
                                                   (aktuell)

note: type: textblock
en: This schema is complicated, but in practice only the right part (involving L<po4a-updatepo(1)> and L<po4a-translate(1)>) is used once the project is setup and configured.
de: Dieses Schema ist kompliziert, aber in der Praxis wird nur der rechte Teil (der L<po4a-updatepo(1)> und L<po4a-translate(1)> betrifft) verwandt, sobald das Projekt eingerichtet und konfiguriert ist.

note: type: textblock
en: The left part depicts how L<po4a-gettextize(1)> can be used to convert an existing translation project to the po4a infrastructure. This script takes an original document and its translated counterpart, and tries to build the corresponding PO file. Such manual conversion is rather cumbersome (see the L<po4a-gettextize(1)> documentation for more details), but it is only needed once to convert your existing translations. If you don't have any translation to convert, you can forget about this and focus on the right part of the schema.
de: Der linke Teil stellt dar, wie L<po4a-gettextize(1)> verwandt werden kann, um ein bestehendes Übersetzungsprojekt in die Po4a-Infrastruktur zu überführen. Dieses Skript akzeptiert ein Ursprungsdokument und sein übersetztes Gegenstück und versucht, eine entsprechende PO-Datei daraus zu bauen. Eine solche manuelle Umwandlung ist recht beschwerlich (lesen Sie die Dokumentation von L<po4a-gettextize(1)> für weitere Details), sie wird aber nur einmalig notwendig, um Ihre bestehende Übersetzungen zu überführen. Falls Sie keine Übersetzungen überführen müssen, können Sie diesen Schritt ignorieren und sich auf den rechten Teil des Schemas konzentrieren.

note: type: textblock
en: On the top right part, the action of the original author is depicted, updating the documentation. The middle right part depicts the automatic actions of L<po4a-updatepo(1)>. The new material is extracted and compared against the exiting translation. The previous translation is used for the parts that didn't change, while partially modified parts are connected to the previous translation with a "fuzzy" marker indicating that the translation must be updated. New or heavily modified material is left untranslated.
de: Ganz oben rechts wird die Aktion der Ursprungsautors dargestellt, der die Dokumentation aktualisiert. Der mittel-rechte Teil stellt die automatischen Aktionen von L<po4a-updatepo(1)> dar. Das neue Material wird herausgelöst und mit der bestehenden Übersetzung verglichen. Die vorherige Übersetzung wird für unveränderte Teile verwandt, während teilweise geänderte Teile mit der vorherigen Übersetzung mit einer »fuzzy«-Markierung verbunden sind, die anzeigt, dass die Übersetzung aktualisiert werden muss. Neues oder stark verändertes Material verbleibt unübersetzt.

note: type: textblock
en: Then, the I<manual editing> reported depicts the action of the translators, that modify the PO files to provide translations to every original string and paragraph. This can be done using either a specific editor such as the B<GNOME Translation Editor>, KDE's B<Lokalize> or B<poedit>, or using an online localization platform such as B<weblate> or B<pootle>. The translation result is a set of PO files, one per language. Please refer to the gettext documentation for more details.
de: Dann stellt I<manuelle Bearbeitung> die Aktionen der Übersetzer dar, die die PO-Dateien verändern, um Übersetzungen für jede Ursprungszeichenkette und jeden Absatz bereitzustellen. Dies kann entweder mit einem speziellen Editor wie dem B<GNOME-Übersetzungseditor>, KDEs B<Lokalize> oder B<poedit> erfolgen, oder mittels einer Online-Lokalisierungsplattform wie B<Weblate> oder B<Pootle>. Das Übersetzungsergebnis ist eine Gruppe von PO-Dateien, eine pro Sprache. Bitte lesen Sie die Gettext-Dokumentation für weitere Details.

note: type: textblock
en: The bottom part of the figure shows how L<po4a-translate(1)> creates a translated source document from the F<master.doc> original document and the F<doc.XX.po> translation catalog that was updated by the translators. The structure of the document is reused, while the original content is replaced by its translated counterpart. Optionally, an addendum can be used to add some extra text to the translation. This is often used to add the name of the translator to the final document. See below for details.
de: Der untere Teil der Abbildung zeigt, wie L<po4a-translate(1)> ein übersetztes Quelldokument aus dem ursprünglichen Dokument F<master.doc> und dem Übersetzungskatakog F<doc.XX.po>, der durch die Übersetzer aktualisiert wurde, erstellt. Die Struktur des Dokuments wird wiederverwandt, während der ursprüngliche Inhalt durch sein übersetztes Gegenstück ersetzt wird. Optional kann ein Addendum verwandt werden, um einigen Extratext zu der Übersetzung hinzuzufügen. Dies wird oft dazu verwandt, den Namen des Übersetzers zum finalen Dokument hinzuzufügen. Sie finden Details hierzu weiter unten.

note: type: textblock
en: As noted before, the L<po4a(1)> program combines the effects of the separated scripts, updating the PO files and the translated document in one invocation.  The underlying logic remains the same.
de: Wie zuvor angemerkt, kombiniert das Programm L<po4a(1)> die Wirkung der getrennten Skripte, Aktualisierungen der PO-Dateien und des übersetzten Dokumentes in einem Aufruf. Die zugrundeliegende Logik bleibt identisch.

note: type: =head2
en: Starting a new translation
de: Eine neue Übersetzung beginnen

note: type: textblock
en: If you use L<po4a(1)>, there is no specific step to start a translation. You just have to list the languages in the configuration file, and the missing PO files are automatically created. Naturally, the translator then have to provide translations for every content used in your documents. L<po4a(1)> also creates a POT file, that is a PO template file. Potential translators can translate your project into a new language by renaming this file and providing the translations in their language.
de: Falls Sie L<po4a(1)> verwenden, gibt es keinen bestimmten Schritt zum Start einer Übersetzung. Sie müssen nur die Sprachen in der Konfigurationsdatei aufführen und die fehlenden PO-Dateien werden automatisch erstellt. Natürlich müssen die Übersetzer dann die Übersetzungen für sämtliche Inhalte in Ihren Dokumenten bereitstellen. L<po4a(1)> erstellt auch eine POT-Datei, das ist eine PO-Vorlagendatei. Mögliche Übersetzer können Ihr Projekt in eine neue Sprache übersetzen, indem sie diese Datei umbenennen und die Übersetzungen in ihrer Sprache bereitstellen.

note: type: textblock
en: If you prefer to use the individual scripts separately, you should use L<po4a-gettextize(1)> as follows to create the POT file. This file can then be copied into F<XX.po> to initiate a new translation.
de: Falls Sie es bevorzugen, die individuellen Skripte separat zu verwenden, sollten Sie L<po4a-gettextize(1)> wie folgt verwenden, um die POT-Datei zu erstellen. Diese Datei kann dann nach F<XX.po> kopiert werden, um eine neue Übersetzung zu starten.

note: type: verbatim
en:   $ po4a-gettextize --format <format> --master <master.doc> --po <translation.pot>
de:   $ po4a-gettextize --format <Format> --master <Master.dok> --po <Übersetzung.pot>

note: type: textblock
en: The master document is used in input, while the POT file is the output of this process.
de: Das Masterdokument wird als Eingabe, während die POT-Datei als die Ausgabe des Prozesses verwandt wird.

note: type: =head2
en: Integrating changes to the original document
de: Integration von Änderungen am ursprünglichen Dokument

note: type: textblock
en: The script to use for that is L<po4a-updatepo(1)> (please refer to its documentation for details):
de: Das hierzu zu verwendende Programm ist L<po4a-updatepo(1)> (bitte lesen Sie dessen Dokumentation für Details):

note: type: verbatim
en:   $ po4a-updatepo --format <format> --master <new_master.doc> --po <old_doc.XX.po>
de:   $ po4a-updatepo --format <Format> --master <neue_Master.dok> --po <alte_dok.XX.po>

note: type: textblock
en: The master document is used in input, while the PO file is updated: it is used both in input and output.
de: Das Master-Dokument wird in der Eingabe verwandt, während die PO-Datei aktualisiert wird: sie wird sowohl in der Ein- als auch der Ausgabe verwandt.

note: type: =head2
en: Generating a translated document
de: Erstellen eines übersetzten Dokumentes

note: type: textblock
en: Once you're done with the translation, you want to get the translated documentation and distribute it to users along with the original one.  For that, use the L<po4a-translate(1)> program as follows:
de: Sobald Sie mit der Übersetzung fertig sind, möchten Sie die übersetzte Dokumentation erhalten und diese dann zusammen mit der ursprünglichen an die Benutzer verteilen. Verwenden Sie hierfür das Programm L<po4a-translate(1)> wie folgt:

note: type: verbatim
en:   $ po4a-translate --format <format> --master <master.doc> --po <doc.XX.po> --localized <XX.doc>
de:   $ po4a-translate --format <Format> --master <Master.dok> --po <dok.XX.po> --localized <XX.dok>

note: type: textblock
en: Both the master and PO files are used in input, while the localized file is the output of this process.
de: Sowohl die Master- als auch die PO-Dateien werden als Eingabe verwandt, während die lokalisierte Datei die Ausgabe dieses Prozesses ist.

note: type: =head2
en: Using addenda to add extra text to translations
de: Verwendung von Addenda, um zusätzlichen Text zu Übersetzungen hinzuzufügen

note: type: textblock
en: Adding new text to the translation is probably the only thing that is easier in the long run when you translate files manually :). This happens when you want to add an extra section to the translated document, not corresponding to any content in the original document. The classical use case is to give credits to the translation team, and to indicate how to report translation-specific issues.
de: Hinzufügen von neuem Text zu der Übersetzung ist wahrscheinlich das einzige, was langfristig bei der manuellen Übersetzung einfacher ist :). Dies kommt vor, wenn Sie einen zusätzlichen Abschnitt zu dem übersetzten Dokument hinzufügen möchten, der nicht zu Inhalten im Ursprungsdokument passt. Der klassische Anwendungsfall ist die Danksagung an das Übersetzungs-Team und die Information, wie übersetzungsspezifische Fehler berichtet werden sollen.

note: type: textblock
en: With po4a, you have to specify B<addendum> files, that can be conceptually viewed as patches applied to the localized document after processing. Each addendum must be provided as a separate file, which format is however very different from the classical patches. The first line is a I<header line>, defining the insertion point of the addendum (with an unfortunately cryptic syntax -- see below) while the rest of the file is added verbatim at the determined position.
de: Mit Po4a müssen Sie B<addendum>-Dateien angeben, die konzeptionell als Patches angesehen werden können, die auf das lokalisierte Dokument nach der Verarbeitung angewandt werden. Jedes Addendum muss als separate Datei bereitgestellt werden, wobei das Format sich allerdings deutlich von klassischen Patches unterscheidet. Die erste Zeile ist eine I<Kopfzeile>, die den Einschubpunkt des Addendums definiert (mit einer unglücklicherweise kryptischen Syntax -- siehe unten), während der Rest der Datei unverändert an der festgelegten Position eingefügt wird.

note: type: textblock
en: The header line must begin with the string B<PO4A-HEADER:>, followed by a semi-colon separated list of I<key>B<=>I<value> fields.
de: Die Kopfzeile muss mit der Zeichenkette B<PO4A-HEADER:> beginnen, gefolgt von einer durch Semikola getrennten Liste von I<Schlüssel>B<=>I<Wert>-Paaren.

note: type: textblock
en: For example, the following header declares an addendum that must be placed at the very end of the translation.
de: Beispielsweise erklärt die folgende Kopfzeile, dass ein Addendum ganz am Ende der Übersetzung abgelegt werden muss.

note: type: textblock
en: Things are more complex when you want to add your extra content in the middle of the document. The following header declares an addendum that must be placed after the XML section containing the string C<About this document> in translation.
de: Die Dinge werden komplexer, wenn Sie den zusätzlichen Inhalt in der Mitte des Dokuments hinzufügen wollen. Die folgende Kopfzeile erklärt, dass nach dem XML-Abschnitt, der die Zeichenkette B<Über dieses Dokument> in der Übersetzung enthält, ein Addendum abgelegt werden muss.

note: type: verbatim
en:  PO4A-HEADER: position=About this document; mode=after; endboundary=</section>
de:  PO4A-HEADER: position=Über dieses Dokument; mode=after; endboundary=</section>

note: type: textblock
en: In practice, when trying to apply an addendum, po4a searches for the first line matching the C<position> argument (this can be a regexp). Do not forget that po4a considers the B<translated> document here. This documentation is in English, but your line should probably read as follows if you intend your addendum to apply to the French translation of the document.
de: In der Praxis wird Po4a beim Versuch, ein Addendum anzuwenden, nach der ersten Zeile, die auf das Argument C<Position> passt, suchen (C<Position> kann ein regulärer Ausdruck sein). Vergessen Sie nicht, dass Po4a hier das B<übersetzte> Dokument betrachtet. Das Ursprungsdokument ist auf Englisch, aber Ihre Zeile sollte wahrscheinlich wie folgt aussehen, falls Sie möchten, dass sie auf die französische Übersetzung des Dokuments angewandt wird.

note: type: textblock
en: Once the C<position> is found in the target document, po4a searches for the next line after the C<position> that matches the provided C<endboundary>. The addendum is added right B<after> that line (because we provided an I<endboundary>, i.e. a boundary ending the current section).
de: Sobald die C<Position> im Zieldokument gefunden wurde, sucht Po4a für die nächste Zeile nach der C<Position>, die auf das bereitgestellte C<endboundary> passt. Das Addendum wird direkt B<nach> dieser Zeile eingefügt (da wir eine I<endboundary> bereitstellten, d.h. eine Begrenzung, die den aktuellen Abschnitt beendet).

note: type: textblock
en: The exact same effect could be obtained with the following header, that is equivalent:
de: Der genau gleiche Effekt könnte mit den nachfolgenden Kopfzeilen erreicht werden, die äquivalent sind:

note: type: verbatim
en:  PO4A-HEADER: position=About this document; mode=after; beginboundary=<section>
de:  PO4A-HEADER: position=Über dieses Dokument; mode=after; beginboundary=<section>

note: type: textblock
en: Here, po4a searches for the first line matching C<<section>> after the line matching C<About this document> in the translation, and add the addendum B<before> that line since we provided a I<beginboundary>, i.e. a boundary marking the beginning of the next section. So this header line requires to place the addendum after the section containing C<About this document>, and instruct po4a that a section starts with a line containing the C<<section>> tag. This is equivalent to the previous example because what you really want is to add this addendum either after C</section>> or before C<<section>>.
de: Hier sucht Po4a in der Übersetzung nach der ersten Zeile, die auf C<<section>> passt und nach der auf C<Über dieses Dokument> passenden Zeile liegt, und fügt das Addendum B<vor> dieser Zeile ein, da wir ein I<beginboundary> bereitgestellt haben, d.h. eine Begrenzungsmarkierung, die den Anfang des nächsten Abschnitts markiert. Daher verlangt diese Kopfzeile, dass das Addendum nach dem Abschnitt, der C<Über dieses Dokument> enthält, gesetzt wird, und weist Po4a an, dass dieser Abschnitt mit einer Zeile, die die Markierung C<<section>> enthält, beginnt. Dies ist zum vorherigen Beispiel äquivalent, da Sie in Wirklichkeit möchten, dass dieses Addendum entweder nach C</section>> oder vor C<<section>> hinzugefügt wird.

note: type: textblock
en: You can also set the insertion I<mode> to the value C<before>, with a similar semantic: combining C<mode=before> with an C<endboundary> will put the addendum just B<after> the matched boundary, that the last potential boundary line before the C<position>. Combining C<mode=before> with an C<beginboundary> will put the addendum just B<before> the matched boundary, that the last potential boundary line before the C<position>.
de: Sie können den Einfüge-I<Modus> auch auf den Wert C<before> setzen, mit einer ähnlichen Semantik: Kombinierung von C<mode=before> mit einem C<endboundary> wird dass Addendum genau B<nach> der passenden Begrenzung setzen. Dies ist die letzte mögliche Begrenzungszeile vor der C<Position>. Kombinierung von C<mode=before> mit einer C<beginboundary> setzt das Addendum genau B<vor> die passende Begrenzung. Dies ist die letzte mögliche Begrenzung vor der C<Position>.

note: type: verbatim
en:   Mode   | Boundary kind |     Used boundary      | Insertion point compared to the boundary
     ========|===============|========================|=========================================
     'before'| 'endboundary' | last before 'position' | Right after the selected boundary
     'before'|'beginboundary'| last before 'position' | Right before the selected boundary
     'after' | 'endboundary' | first after 'position' | Right after the selected boundary
     'after' |'beginboundary'| first after 'position' | Right before the selected boundary
     'eof'   |   (none)      |  n/a                   | End of file
de:   Modus  | Begrenzungsart |  Verwandte Begrenzung | Einfügepunkt im Vergleich zur Begrenzung
     ========|================|=======================|=========================================
     'before'| 'endboundary'  | letzte vor 'Position' | direkt nach der ausgewählten Begrenzung
     'before'|'beginboundary' | letzte vor 'Position' | direkt vor der ausgewählten Begrenzung
     'after' | 'endboundary'  | erste nach 'Position' | direkt nach der ausgewählten Begrenzung
     'after' |'beginboundary' | erste nach 'Position' | direkt vor der ausgewählten Begrenzung
     'eof'   |   (keine)      |  n.Z.                 | Dateiende

note: type: =head3
en: Hint and tricks about addenda
de: Tipps und Tricks rund um Addenda

note: type: textblock
en: Remember that these are regexp. For example, if you want to match the end of a nroff section ending with the line C<.fi>, do not use C<.fi> as B<endboundary>, because it will match with C<the[ fi]le>, which is obviously not what you expect. The correct B<endboundary> in that case is: C<^\.fi$>.
de: Denken Sie daran, dass dies reguläre Ausdrücke sind. Falls Sie beispielsweise das Ende eines Nroff-Abschnittes, das auf die Zeile C<.fi> endet, vergleichen wollen, verwenden Sie nicht C<.fi> als B<endboundary>, da es auf C<the[ fi]le> passen wird, was sie offensichtlich nicht erwarten würden. Das korrekte B<endboundary> ist in diesem Fall: B<^\.fi$>.

note: type: textblock
en: White spaces ARE important in the content of the C<position> and boundaries. So the two following lines B<are different>. The second one will only be found if there is enough trailing spaces in the translated document.
de: Leerzeichen SIND im Inhalt von C<position> und Begrenzungen wichtig. Daher B<unterscheiden> sich die beiden nachfolgenden Zeilen. Die zweite wird nur gefunden, falls im übersetzen Dokument ausreichend angehängte Leerzeichen sind.

note: type: verbatim
en:  PO4A-HEADER: position=About this document; mode=after; beginboundary=<section>
     PO4A-HEADER: position=About this document ; mode=after; beginboundary=<section>
de:  PO4A-HEADER: position=Über dieses Dokument; mode=after; beginboundary=<section>
     PO4A-HEADER: position=Über dieses Dokument ; mode=after; beginboundary=<section>

note: type: textblock
en: Although this context search may be considered to operate roughly on each line of the B<translated> document, it actually operates on the internal data string of the translated document. This internal data string may be a text spanning a paragraph containing multiple lines or may be a XML tag itself alone. The exact I<insertion point> of the addendum must be before or after the internal data string and can not be within the internal data string.
de: Obwohl diese Kontextsuche so betrachtet werden könnte, als ob sie ungefähr auf jeder Zeile des B<übersetzten> Dokuments arbeiten würde, arbeitet sie tatsächlich auf der internen Datenzeichenkette des übersetzten Dokuments. Diese interne Datenzeichenkette kann ein Text sein, der mehrere Absätze mit mehreren Zeilen umfasst oder kann eine einzelne XML-Markierung selbst sein. Der genaue I<Einfügepunkt> des Addendums muss vor oder nach der internen Datenzeichenkette und kann nicht innerhalb der internen Datenzeichenkette liegen.

note: type: textblock
en: Pass the B<-vv> argument to po4a to understand how the addenda are added to the translation. It may also help to run po4a in debug mode to see the actual internal data string when your addendum does not apply.
de: Übergeben Sie das Argument B<-vv> an Po4a, um zu verstehen, wie Addenda zu der Übersetzung hinzugefügt werden. Es kann auch helfen, Po4a im Fehlersuchmodus zu betreiben, um die tatsächlichen internen Datenzeichenketten zu sehen, wenn Ihr Addendum nicht angewandt wird.

note: type: =head3
en: Addenda examples
de: Addenda-Beispiele

note: type: textblock
en: If you want to add something after the following nroff section:
de: Falls Sie etwas hinter den folgenden Nroff-Abschnitt hinzufügen möchten:

note: type: verbatim
en:   .SH "AUTHORS"
de:   .SH "AUTOREN"

note: type: textblock
en: You should select a two step approach by setting B<mode=after>. Then you should narrow down search to the line after B<AUTHORS> with the B<position> argument regex. Then, you should match the beginning of the next section (i.e., B<^\.SH>) with the B<beginboundary> argument regex. That is to say:
de: Sie sollten den zweischrittigen Zugang durch Setzen von B<mode=after> wählen. Dann sollten Sie mit dem regulären Argumentenausdruck B<Position> die Suche auf die Zeile nach B<AUTOREN> eingrenzen. Dann sollten Sie eine Übereinstimmung mit dem Anfang des nächsten Abschnittes (d.h. B<^\.SH>) mit dem regulären Argumentenausdruck B<beginboundary> erzielen. Mit anderen Worten:

note: type: verbatim
en:  PO4A-HEADER:mode=after;position=AUTHORS;beginboundary=\.SH
de:  PO4A-HEADER:mode=after;position=AUTOREN;beginboundary=\.SH

note: type: textblock
en: If you want to add something right after a given line (e.g. after the line "Copyright Big Dude"), use a B<position> matching this line, B<mode=after> and give a B<beginboundary> matching any line.
de: Falls Sie etwas direkt nach einer Zeile hinzufügen möchten (etwa hinter »Copyright Großer Kerl«), verwenden Sie eine B<Position>, die auf diese Zeile passt und geben Sie ein B<beginboundary> an, das zu irgendeiner Zeile passt.

note: type: verbatim
en:  PO4A-HEADER:mode=after;position=Copyright Big Dude, 2004;beginboundary=^
de:  PO4A-HEADER:mode=after;position=Copyright Großer Kerl, 2004;beginboundary=^

note: type: textblock
en: If you want to add something at the end of the document, give a B<position> matching any line of your document (but only one line. Po4a won't proceed if it's not unique), and give an B<endboundary> matching nothing. Don't use simple strings here like B<"EOF">, but prefer those which have less chance to be in your document.
de: Falls Sie am Ende des Dokuments etwas hinzufügen möchten, geben Sie eine B<Position> an, die zu einer Zeile Ihres Dokuments passt (aber nur eine Zeile – Po4a wird nicht fortfahren, wenn sie nicht eindeutig ist) und geben Sie ein B<endboundary> an, das zu nichts passt. Verwenden Sie hier keine einfachen Zeichenketten wie B<»EOF«>, aber nehmen Sie bevorzugt solche, bei denen es unwahrscheinlich ist, dass sie sich in Ihrem Dokument befinden.

note: type: verbatim
en:  PO4A-HEADER:mode=after;position=About this document;beginboundary=FakePo4aBoundary
de:  PO4A-HEADER:mode=after;position=Über dieses Dokument;beginboundary=FakePo4aBoundary

note: type: =head3
en: More detailed example
de: Ein ausführlicheres Beispiel

note: type: textblock
en: Original document (POD formatted):
de: Originaldokument (POD-formatiert):

note: type: verbatim
en:  |=head1 NAME
     |
     |dummy - a dummy program
     |
     |=head1 AUTHOR
     |
     |me
de:  |=head1 BESCHREIBUNG
     |
     |dummy - Ein Platzhalterprogramm
     |
     |=head1 AUTOR
     |
     |ich

note: type: textblock
en: Then, the following addendum will ensure that a section (in French) about the translator is added at the end of the file (in French, "TRADUCTEUR" means "TRANSLATOR", and "moi" means "me").
de: Dann wird das folgende Addendum sicherstellen, dass ein Abschnitt (auf Französisch) über den Übersetzer an das Ende der Datei hinzugefügt wird (auf Französisch heißt »ÜBERSETZER« »TRADUCTEUR« und »moi« heißt »ich«).

note: type: textblock
en: To put your addendum before the AUTHOR, use the following header:
de: Um Ihr Addendum vor dem AUTOR einzufügen, verwenden Sie die folgende Kopfzeile:

note: type: textblock
en: This works because the next line matching the B<beginboundary> /^=head1/ after the section "NAME" (translated to "NOM" in French), is the one declaring the authors. So, the addendum will be put between both sections. Note that if another section is added between NAME and AUTHOR sections later, po4a will wrongfully put the addenda before the new section.
de: Dies funktioniert, da die nächste auf das B<beginboundary> /^=head1/ passende Zeile nach dem Abschnitt »BESCHREIBUNG« (übersetzt zu »NOM« auf Französisch) diejenige ist, die die Autoren deklariert. Daher wird das Addendum zwischen beide Abschnitte gelegt. Beachten Sie: Falls später ein anderer Abschnitt zwischen den Abschnitten NAME und AUTHOR hinzugefügt wird, wird Po4a das Addendum fehlerhafterweise vor den neuen Abschnitt legen.

note: type: textblock
en: To avoid this you may accomplish the same using B<mode>=I<before>:
de: Um dies zu vermeiden, können Sie das gleiche mittels B<mode>=I<before> erreichen:

note: type: =head1
en: How does it work?
de: Wie funktioniert es?

note: type: textblock
en: This chapter gives you a brief overview of the po4a internals, so that you may feel more confident to help us maintaining and improving it. It may also help you understanding why it does not do what you expected, and how to solve your problems.
de: Dieses Kapitel gibt Ihnen einen kurzen Überblick über die Interna von Po4a, so dass Sie sich sicherer fühlen, es zu warten und zu verbessern. Es könnte Ihnen auch dabei helfen, zu verstehen, warum es nicht das tut, was Sie erwarten, und wie Sie Ihre Probleme beheben können.

note: type: textblock
en: The po4a architecture is object oriented. The L<Locale::Po4a::TransTractor(3pm)|TransTractor> class is the common ancestor to all po4a parsers. This strange name comes from the fact that it is at the same time in charge of translating document and extracting strings.
de: Die Po4a-Architektur ist objektorientiert. Die Klasse L<Locale::Po4a::TransTractor(3pm)|TransTractor> ist der gemeinsame Vorfahr von allen Auswertungsklassen. Dieser merkwürdige Name ist der Tatsache zu verdanken, dass er gleichzeitig für das Übersetzen des Dokuments und das Extrahieren von Zeichenketten zuständig ist.

note: type: textblock
en: More formally, it takes a document to translate plus a PO file containing the translations to use as input while producing two separate outputs: Another PO file (resulting of the extraction of translatable strings from the input document), and a translated document (with the same structure than the input one, but with all translatable strings replaced with content of the input PO). Here is a graphical representation of this:
de: Förmlicher ausgedrückt nimmt es ein Dokument zum Übersetzen plus eine PO-Datei, die die Übersetzungen enthält, als Eingabe, während es zwei getrennte Ausgaben erzeugt: Eine weitere PO-Datei (die das Ergebnis des Extrahierens übersetzbarer Zeichenketten vom Eingabedokument ist) und einem übersetzen Dokument (mit der gleichen Struktur, wie der aus der Eingabe, bei der aber alle übersetzbaren Zeichenketten durch den Inhalt der Eingabe-PO-Datei ersetzt wurden). Hier eine grafische Darstellung davon:

note: type: verbatim
en:    Input document --\                             /---> Output document
                         \      TransTractor::       /       (translated)
                          +-->--   parse()  --------+
                         /                           \
       Input PO --------/                             \---> Output PO
                                                             (extracted)
de:  Eingabedokument -- \                             /---> Ausgabedokument
                         \      TransTractor::       /       (übersetzt)
                          +-->--   parse()  --------+
                         /                           \
     Eingabe-PO-Datei---/                             \---> Ausgabe-PO-Datei
                                                              (extrahiert)

note: type: textblock
en: This little bone is the core of all the po4a architecture. If you omit the input PO and the output document, you get B<po4a-gettextize>. If you provide both input and disregard the output PO, you get B<po4a-translate>. The B<po4a> calls TransTractor twice and calls B<msgmerge -U> between these TransTractor invocations to provide one-stop solution with a single configuration file.  Please see L<Locale::Po4a::TransTractor(3pm)> for more details.
de: Dieser kleine Knochen ist der Kern der Po4a-Architektur. Falls Sie die Eingabe-PO-Datei und das Ausgabedokument weglassen, erhalten Sie B<po4a-gettextize>. Falls Sie beide Eingaben bereitstellen und die Ausgabe-PO-Datei nicht beachten, erhalten Sie B<po4a-translate>. B<po4a> ruft TransTractor zweimal auf und ruft B<msgmerge -U> zwischen diesen TransTractor-Aufrufen auf, um Lösungen aus einer Hand mit einer einzelnen Konfigurationsdatei bereitzustellen. Bitte lesen Sie L<Locale::Po4a::TransTractor(3pm)> für weitere Details.

note: type: =head1
en: Open-source projects using po4a
de: Open-Source-Projekte, die Po4a verwenden

note: type: textblock
en: Here is a very partial list of projects that use po4a in production for their documentation. If you want to add your project to the list, just drop us an email (or a Merge Request).
de: Es folgt eine unvollständige Liste von Projekten, die Po4a für ihre Dokumentation im Einsatz haben. Falls Sie Ihre Projekt in diese Liste aufgenommen haben möchten, schicken Sie uns auf Englisch eine E-Mail (oder einen »Merge Request«).

note: type: textblock
en: adduser (man): users and groups management tool.
de: adduser (man): Benutzer- und Gruppenverwaltungswerkzeug.

note: type: textblock
en: apt (man, docbook): Debian package manager.
de: apt (man, docbook): Debian-Paketverwalter.

note: type: textblock
en: aptitude (docbook, svg): terminal-based package manager for Debian
de: aptitude (docbook, svg): Terminal-baierter Paketverwalter für Debian

note: type: textblock
en: L<F-Droid website|https://gitlab.com/fdroid/fdroid-website> (markdown): installable catalogue of FOSS (Free and Open Source Software) applications for the Android platform.
de: L<F-Droid website|https://gitlab.com/fdroid/fdroid-website> (markdown): installierbarer Katalog an FOSS (Free and Open Source Software) Anwendungen für die Android-Plattform.

note: type: textblock
en: L<git|https://github.com/jnavila/git-manpages-l10n> (asciidoc): distributed version-control system for tracking changes in source code.
de: L<git|https://github.com/jnavila/git-manpages-l10n> (asciidoc): verteiltes Versionssteuersystem zur Nachverfolgung von Quellcodeänderungen.

note: type: textblock
en: This project provides an infrastructure for translating many manpages to different languages, ready for integration into several major distributions (Arch Linux, Debian and derivatives, Fedora).
de: Dieses Projekt stellt die Infrastruktur zur Übersetzung vieler Handbuchseiten in verschiedene Sprachen bereit, mit Integration in viele große Distributionen (Arch Linux, Debian und abgeleitete, Fedora).

note: type: textblock
en: L<Stellarium|https://github.com/Stellarium/stellarium> (HTML): a free open source planetarium for your computer. po4a is used to translate the sky culture descriptions.
de: L<Stellarium|https://github.com/Stellarium/stellarium> (HTML): ein freies, Open-Source-Planetarium für Ihren Rechner. Po4a wird zur Übersetzung der Himmelskulturbeschreibungen verwandt.

note: type: textblock
en: Other item to sort out: L<https://gitlab.com/fdroid/fdroid-website/> L<https://github.com/fsfe/reuse-docs/pull/61>
de: Anderer zu sortierender Eintrag: L<https://gitlab.com/fdroid/fdroid-website/> L<https://github.com/fsfe/reuse-docs/pull/61>

note: type: =head1
en: FAQ
de: Häufig gestellte Fragen

note: type: =head2
en: How do you pronounce po4a?
de: Wie wird Po4a ausgesprochen?

note: type: textblock
en: I personally vocalize it as L<pouah|https://en.wiktionary.org/wiki/pouah>, which is a French onomatopoetic that we use in place of yuck :) I may have a strange sense of humor :)
de: Ich persönlich spreche es als L<pouah|https://en.wiktionary.org/wiki/pouah> aus, was auf Französich lautmalerisch anstelle von »Bäh« verwandt wird :) Vielleicht habe ich einen merkwürdigen Humor :)

note: type: =head2
en: What about the other translation tools for documentation using gettext?
de: Was ist mit den anderen Übersetzungswerkzeugen für Dokumentation, die Gettext benutzen?

note: type: textblock
en: There are a few of them. Here is a possibly incomplete list, and more tools are coming at the horizon.
de: Es gibt eine Reihe davon. Hier ist eine unvollständige Liste und weitere Werkzeuge erscheinen am Horizont.

note: type: textblock
en: This is the tool developed by KDE people to handle DocBook XML. AFAIK, it was the first program to extract strings to translate from documentation to PO files, and inject them back after translation.
de: Dies ist das durch KDE-Leute entwickelte Werkzeug, um DocBook-XML zu handhaben. Soweit bekannt, war es das erste Programm zum Extrahieren von Zeichenketten aus der Dokumentation in PO-Dateien und um sie nach dem Übersetzen wieder einzuspeisen.

note: type: textblock
en: It can only handle XML, and only a particular DTD. I'm quite unhappy with the handling of lists, which end in one big msgid. When the list become big, the chunk becomes harder to swallow.
de: Es kann nur XML und eine spezielle DTD handhaben. Der Verfasser ist ziemlich unglücklich mit der Handhabung von Listen, die in einer großen Msgid enden. Wenn die Liste groß wird, wird es schwerer, mit dem großen Stück umzugehen.

note: type: textblock
en: This program done by Denis Barbier is a sort of precursor of the po4a SGML module, which more or less deprecates it. As the name says, it handles only the DebianDoc DTD, which is more or less a deprecated DTD.
de: Dieses von Denis Barbier erstellte Programm ist so eine Art Vorläufer des Po4a-SGML-Moduls, wodurch ersteres mehr oder weniger missbilligt ist. Wie der Name sagt, handhabt es nur die DebianDoc-DTD, die mehr oder weniger eine missbilligte DTD ist.

note: type: textblock
en: Used by the GIMP Documentation Team since 2004, works quite well even if, as the name suggests, only with XML files and needs specially configured makefiles.
de: Vom GIMP-Dokumentationsteam seit 2004 verwandt. Funktioniert recht gut, selbst wenn es, wie es der Name andeutet, nur mit XML-Dateien funktioniert und besonders konfigurierte Makefiles benötigt.

note: type: textblock
en: The Sphinx Documentation Project also uses gettext extensively to manage its translations. Unfortunately, it works only for a few text formats, rest and markdown, although it is perhaps the only tool that does this managing the whole translation process.
de: Das Sphinx-Dokumentationsprojekt verwendet Gettext auch intensiv, um seine Übersetzungen zu verwalten. Unglücklicherweise funktioniert es nur für einige wenige Textformate, Rest und Markdown, obwohl es wahrscheinlich das einzige Werkzeug ist, das den gesamten Übersetzungsprozess verwaltet.

note: type: textblock
en: The main advantages of po4a over them are the ease of extra content addition (which is even worse there) and the ability to achieve gettextization.
de: Die Hauptvorteile von Po4a demgegenüber sind die Erleichterung beim Hinzufügen zusätzlichen Inhalts (was dort sogar schlechter ist) und die Fähigkeit, Gettext zu verwenden.

note: type: =head2
en: SUMMARY of the advantages of the gettext based approach
de: ZUSAMMENFASSUNG der Vorteile der Gettext-basierten Herangehensweise

note: type: textblock
en: The translations are not stored along with the original, which makes it possible to detect if translations become out of date.
de: Die Übersetzungen werden nicht zusammen mit dem Original gespeichert, wodurch es möglich wird, festzustellen, ob Übersetzungen nicht mehr aktuell sind.

note: type: textblock
en: The translations are stored in separate files from each other, which prevents translators of different languages from interfering, both when submitting their patch and at the file encoding level.
de: Die Übersetzungen werden jeweils in separaten Dateien gespeichert, was verhindert, dass sich Übersetzer unterschiedlicher Sprachen, sowohl beim Senden des Patches als auch auf der Ebene des Dateikodierung, stören.

note: type: textblock
en: It is based internally on B<gettext> (but B<po4a> offers a very simple interface so that you don't need to understand the internals to use it).  That way, we don't have to re-implement the wheel, and because of their wide use, we can think that these tools are more or less bug free.
de: Es basiert intern auf B<Gettext> (B<Po4a> bietet aber eine sehr einfache Schnittstelle, so dass Sie die Interna nicht verstehen müssen, um es zu benutzen). Auf diese Art muss das Rad nicht neu erfunden werden und aufgrund ihrer weiten Verbreitung kann davon ausgegangen werden, dass diese Werkzeuge mehr oder weniger fehlerfrei sind.

note: type: textblock
en: Nothing changed for the end-user (beside the fact translations will hopefully be better maintained). The resulting documentation file distributed is exactly the same.
de: Für den Endanwender hat sich nichts geändert (außer der Tatsache, dass Übersetzungen hoffentlich besser gepflegt werden). Die resultierende Dokumentationsdatei, die verteilt wird, ist exakt dieselbe.

note: type: textblock
en: No need for translators to learn a new file syntax and their favorite PO file editor (like Emacs' PO mode, Lokalize or Gtranslator) will work just fine.
de: Es ist nicht nötig, dass Übersetzer eine neue Dateisyntax lernen und ihr bevorzugter PO-Editor (wie der PO-Modus von Emacs, Lokalize oder Gtranslator) wird gut funktionieren.

note: type: textblock
en: gettext offers a simple way to get statistics about what is done, what should be reviewed and updated, and what is still to do. Some example can be found at those addresses:
de: Gettext bietet eine einfache Möglichkeit, Statistiken darüber zu erhalten, was erledigt ist, was überprüft und aktualisiert werden sollte und was noch zu erledigen ist. Einige Beispiele können unter den folgenden Adressen gefunden werden:

note: type: textblock
en: But everything isn't green, and this approach also has some disadvantages we have to deal with.
de: Aber nicht alles ist rosig und diese Herangehensweise hat auch einige Nachteile, die bewältigt werden müssen.

note: type: textblock
en: Addenda are… strange at the first glance.
de: Addenda sind … auf den ersten Blick merkwürdig.

note: type: textblock
en: You can't adapt the translated text to your preferences, like splitting a paragraph here, and joining two other ones there. But in some sense, if there is an issue with the original, it should be reported as a bug anyway.
de: Sie können den übersetzten Text nicht nach Ihren Präferenzen anpassen, wie das Aufteilen eines Absatzes hier und das Zusammensetzen zwei anderer dort. Aber, falls es in einem gewissen Sinn ein Problem mit dem Original gibt, sollte es sowieso als Fehler gemeldet werden.

note: type: textblock
en: Even with an easy interface, it remains a new tool people have to learn.
de: Sogar mit der einfachen Oberfläche bleibt es ein neues Werkzeug, das Leute lernen müssen.

note: type: textblock
en: One of my dreams would be to integrate somehow po4a to Gtranslator or Lokalize. When a documentation file is opened, the strings are automatically extracted, and a translated file + po file can be written to disk. If we manage to do an MS Word (TM) module (or at least RTF) professional translators may even use it.
de: Es wäre traumhaft, wenn jemand Po4a in Gtranslator oder Lokalize einbinden würde. Wenn eine Dokumentationsdatei geöffnet wird, werden die Zeichenketten automatisch extrahiert. Wenn sie gespeichert wird, kann eine übersetzte Datei + PO-Datei auf die Platte geschrieben werden. Falls es fertiggebracht wird, ein MS-Word-Modul™ (oder zumindest RTF) zu erstellen, können es sogar professionelle Übersetzer nutzen.

note: type: textblock
en: The documentation of the all-in-one tool that you should use: L<po4a(1)>.
de: Die Dokumentation des Komplettwerkzeuges, das Sie verwenden sollen: L<po4a(1)>.

note: type: textblock
en: The documentation of the individual po4a scripts: L<po4a-gettextize(1)>, L<po4a-updatepo(1)>, L<po4a-translate(1)>, L<po4a-normalize(1)>.
de: Die Dokumentation der individuellen Po4a-Skripte: L<po4a-gettextize(1)>, L<po4a-updatepo(1)>, L<po4a-translate(1)>, L<po4a-normalize(1)>.

note: type: textblock
en: The additional helping scripts: L<msguntypot(1)>, L<po4a-display-man(1)>, L<po4a-display-pod(1)>.
de: Die zusätzlichen Helferskripte: L<msguntypot(1)>, L<po4a-display-man(1)>, L<po4a-display-pod(1)>.

note: type: textblock
en: The parsers of each formats, in particular to see the options accepted by each of them: L<Locale::Po4a::AsciiDoc(3pm)> L<Locale::Po4a::Dia(3pm)>, L<Locale::Po4a::Guide(3pm)>, L<Locale::Po4a::Ini(3pm)>, L<Locale::Po4a::KernelHelp(3pm)>, L<Locale::Po4a::Man(3pm)>, L<Locale::Po4a::RubyDoc(3pm)>, L<Locale::Po4a::Texinfo(3pm)>, L<Locale::Po4a::Text(3pm)>, L<Locale::Po4a::Xhtml(3pm)>, L<Locale::Po4a::Yaml(3pm)>, L<Locale::Po4a::BibTeX(3pm)>, L<Locale::Po4a::Docbook(3pm)>, L<Locale::Po4a::Halibut(3pm)>, L<Locale::Po4a::LaTeX(3pm)>, L<Locale::Po4a::Pod(3pm)>, L<Locale::Po4a::Sgml(3pm)>, L<Locale::Po4a::TeX(3pm)>, L<Locale::Po4a::Wml(3pm)>, L<Locale::Po4a::Xml(3pm)>.
de: Die Auswertprogramme für jedes Format, insbesondere, um die durch jedes akzeptierten Optionen zu sehen: L<Locale::Po4a::AsciiDoc(3pm)> L<Locale::Po4a::Dia(3pm)>, L<Locale::Po4a::Guide(3pm)>, L<Locale::Po4a::Ini(3pm)>, L<Locale::Po4a::KernelHelp(3pm)>, L<Locale::Po4a::Man(3pm)>, L<Locale::Po4a::RubyDoc(3pm)>, L<Locale::Po4a::Texinfo(3pm)>, L<Locale::Po4a::Text(3pm)>, L<Locale::Po4a::Xhtml(3pm)>, L<Locale::Po4a::Yaml(3pm)>, L<Locale::Po4a::BibTeX(3pm)>, L<Locale::Po4a::Docbook(3pm)>, L<Locale::Po4a::Halibut(3pm)>, L<Locale::Po4a::LaTeX(3pm)>, L<Locale::Po4a::Pod(3pm)>, L<Locale::Po4a::Sgml(3pm)>, L<Locale::Po4a::TeX(3pm)>, L<Locale::Po4a::Wml(3pm)>, L<Locale::Po4a::Xml(3pm)>.

note: type: textblock
en: The implementation of the core infrastructure: L<Locale::Po4a::TransTractor(3pm)> (particularly important to understand the code organization), L<Locale::Po4a::Chooser(3pm)>, L<Locale::Po4a::Po(3pm)>, L<Locale::Po4a::Common(3pm)>. Please also check the F<CONTRIBUTING.md> file in the source tree.
de: Die Implementierung der Kerninfrastruktur: L<Locale::Po4a::TransTractor(3pm)> (insbesondere zum Verständnis der Code-Organisation wichtig), L<Locale::Po4a::Chooser(3pm)>, L<Locale::Po4a::Po(3pm)>, L<Locale::Po4a::Common(3pm)>. Prüfen Sie bitte auch die Datei F<CONTRIBUTING.md> im dem Quellbaum.

note: type: textblock
en: Locale::Po4a::AsciiDoc - convert AsciiDoc documents from/to PO files
de: Locale::Po4a::AsciiDoc - konvertiert AsciiDoc-Dokumente von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::AsciiDoc is a module to help the translation of documentation in the AsciiDoc format.
de: Locale::Po4a::AsciiDoc ist ein Modul, um bei der Übersetzung von Dokumentation im AsciiDoc-Format zu helfen.

note: type: =head1
en: OPTIONS ACCEPTED BY THIS MODULE
de: VON DIESEM MODUL AKZEPTIERTE OPTIONEN

note: type: textblock
en: These are this module's particular options:
de: Dies sind die Modul-spezifischen Optionen:

note: type: textblock
en: The name of a file containing definitions for po4a, as defined in the B<INLINE CUSTOMIZATION> section.  You can use this option if it is not possible to put the definitions in the document being translated.
de: Der Name der Datei, die die Definitionen für Po4a enthält, wie diese im Abschnitt B<ANPASSUNGEN IM DOKUMENT> beschrieben sind. Sie können diese Option verwenden, falls es nicht möglich ist, die Definitionen in das zu übersetzende Dokument zu schreiben.

note: type: textblock
en: In a definitions file, lines must not start by two slashes, but directly by B<po4a:>.
de: In einer Definitionsdatei dürfen die Zeilen nicht mit zwei Schrägstrichen, sondern müssen direkt durch B<po4a:> beginnen.

note: type: textblock
en: Space-separated list of attribute entries you want to translate.  By default, no attribute entries are translatable.
de: leerzeichengetrennte Liste von Attributeinträgen, die Sie übersetzen möchten. Standardmäßig sind keine Attributeinträge übersetzbar.

note: type: textblock
en: Space-separated list of macro definitions.
de: leerzeichengetrennte Liste von Makrodefinitionen

note: type: textblock
en: Space-separated list of style definitions.
de: leerzeichengetrennte Liste von Stildefinitionen

note: type: textblock
en: Enable automatic line wrapping in non-verbatim blocks, even if the result could be misinterpreted by AsciiDoc formatters.
de: Aktiviert automatischen Zeilenumbruch in wörtlichen Blöcken, selbst wenn das Ergebnis durch AsciiDoc-Formatierprogramme falsch interpretiert werden könnte.

note: type: textblock
en: By default, po4a will not wrap the produced AsciiDoc files because a manual inspection is mandated to ensure that the wrapping does not change the formatting. Consider for instance the following list item:
de: Standardmäßig bricht Po4a die erstellten AsciiDoc-Dateien nicht um, da eine manuelle Überprüfung notwendig ist, um sicherzustellen, dass der Umbruch nicht die Formatierung ändert. Betrachten Sie beispielsweise die folgende Liste:

note: type: verbatim
en:  * a long sentence that is ending with a number 1. A second sentence.
de:  * ein langer Satz, der auf eine Zahl 1 endet. Ein zweiter Satz.

note: type: textblock
en: If the wrapping leads to the following presentation, the item is split into a numbered sub-list. To make things worse, only the speakers of the language used in the translation can inspect the situation.
de: Falls der Umbruch zu der folgenden Darstellung führt, dann wird der Eintrag in eine nummerierte Unterliste aufgeteilt. Um es noch schlimmer werden zu lassen, können nur die Leser der in der Übersetzung verwandten Sprache die Situation überprüfen.

note: type: verbatim
en:  * a long sentence that is ending with a number
       1. A second sentence.
de:  * eine langer Satz, der auf einer Zahl
       1 endet. Ein zweiter Satz.

note: type: textblock
en: Note that not wrapping the files produced by po4a should not be a problem since those files are meant to be processed automatically.  They should not be regarded as source files anyway.
de: Beachten Sie, dass es kein Problem ist, dass die von Po4a erstellten Dateien nicht umgebrochen werden, da diese Dateien für die automatische Verarbeitung gedacht sind. Sie sollten sowieso nicht als Eingabedatei verstanden werden.

note: type: textblock
en: With this option, po4a will produce better-looking source files, that may lead to possibly erroneous formatted outputs.
de: Mit dieser Option wird Po4a besser aussehende Quelldateien erstellen, die zu möglicherweise falsch formatierten Ausgaben führen können.

note: type: textblock
en: By default, the targets of block images are translatable to give opportunity to make the content point to translated images. This can be stopped by setting this option.
de: Standardmäßig können die Ziele von Blockbildern übersetzt werden, um die Möglichkeit zu schaffen, auf übersetzte Inhalte zu verweisen. Dies kann durch Setzen dieser Option gestoppt werden.

note: type: textblock
en: This option is a flag that enables sub-table segmentation into cell content.  The segmentation is limited to cell content, without any parsing inside of it.
de: Diese Option ist ein Schalter, der Innerzell-Abtrennung in Zellinhalten ermöglicht. Die Abtrennung ist auf Zellinhalte begrenzt, ohne das Innere auszuwerten.

note: type: textblock
en: Switch parsing rules to compatibility with different tools. Available options are "asciidoc" or "asciidoctor". Asciidoctor has stricter parsing rules, such as equality of length of opening and closing block fences.
de: Schaltet die Auswertregeln auf Kompatibilität zu verschiedenen Werkzeugen um. Verfügbare Optionen sind »asciidoc« und »asciidoctor«. Asciidoctor hat strengere Auswertregeln, wie die Gleichheit der Längen von öffnenden und schließenden Blockbegrenzungen.

note: type: textblock
en: Disable linting messages. When the source code cannot be fixed for clearer document structure, these messages are useless.
de: Deaktiviert Linting-Meldungen. Wenn der Quellcode nicht für eine klarere Dokumentenstruktur korrigiert werden kann, dann sind diese Meldungen zwecklos.

note: type: textblock
en: Do not translate array values in the YAML Front Matter section.
de: Keine Feldwerte in dem Abschnitt »YAML Front Matter« übersetzen.

note: type: =head1
en: INLINE CUSTOMIZATION
de: ANPASSUNGEN IM DOKUMENT

note: type: textblock
en: The AsciiDoc module can be customized with lines starting by B<//po4a:>.  These lines are interpreted as commands to the parser.  The following commands are recognized:
de: Das AsciiDoc-Modul kann durch Zeilen, die mit B<% po4a:> beginnen, angepasst werden. Diese Zeilen werden vom Parser als Befehle interpretiert. Die folgenden Befehle werden erkannt:

note: type: =item
en: B<//po4a: macro >I<name>B<[>I<attribute list>B<]>
de: B<//po4a: macro >I<Name>B<[>I<Attributliste>B<]>

note: type: textblock
en: This describes in detail the parameters of a B<macro>; I<name> must be a valid macro name, and it ends with an underscore if the target must be translated.
de: Dies beschreibt die Parameter eines I<Macro>s im Detail. I<Name> muss ein gültiger Makroname sein und er endet in einem Unterstrich, falls das Ziel übersetzt werden muss.

note: type: textblock
en: The I<attribute list> argument is a comma separated list which contains information about translatable arguments.  This list contains either numbers, to define positional parameters, or named attributes.
de: Das Argument I<Attributliste> ist eine kommatagetrennte Liste, die Informationen über übersetzbare Argumente enthält. Diese Liste enthält entweder Zahlen, um Positionsparameter zu definieren, oder benannte Attribute.

note: type: textblock
en: If a plus sign (B<+>) is prepended to I<name>, then the macro and its arguments are translated as a whole.  There is no need to define attribute list in this case, but brackets must be present.
de: Falls I<Name> ein Pluszeichen (B<+>) vorangestellt wird, dann wird das Makro und seine Argumente als ganzes übersetzt. In diesem Fall ist es nicht notwendig, die Attributliste zu definieren, aber die Klammern müssen vorhanden sein.

note: type: =item
en: B<//po4a: style >B<[>I<attribute list>B<]>
de: B<//po4a: style >B<[>I<Attributliste>B<]>

note: type: textblock
en: This describes in detail which attributes of a style must be translated.
de: Dies beschreibt im Detail, welche Atribute eines Stils übersetzt werden müssen.

note: type: textblock
en: The I<attribute list> argument is a comma separated list which contains information about translatable arguments.  This list contains either numbers, to define positional parameters, or named attributes.  The first attribute is the style name, it will not be translated.
de: Das Argument I<Attributliste> ist eine kommatagetrennte Liste, die Informationen über übersetzbare Argumente enthält. Diese Liste enthält entweder Zahlen, um Positionsparameter zu definieren, oder benannte Attribute. Das erste Attribut ist der Name des Stils, er wird nicht übersetzt.

note: type: textblock
en: If a plus sign (B<+>) is prepended to the style name, then the attribute list is translated as a whole.  There is no need to define translatable attributes.
de: Falls dem Stilnamen ein Pluszeichen (B<+>) vorangestellt wird, dann wird die Attributliste als ganzes übersetzt. Es ist nicht notwendig, übersetzbare Attribute festzulegen.

note: type: textblock
en: If a minus sign (B<->) is prepended to the style name, then this attribute is not translated.
de: Falls dem Stilnamen ein Minuszeichen (B<->) vorangestellt wird, dann wird dieses Attribut nicht übersetzt.

note: type: =item
en: B<//po4a: entry >I<name>
de: B<//po4a: entry >I<Name>

note: type: textblock
en: This declares an attribute entry as being translatable.  By default, they are not translated.
de: Dies erklärt einen Attributeintrag als übersetzbar. Standardmäßig sind sie nicht übersetzbar.

note: type: =head1
en: STATUS OF THIS MODULE
de: STATUS DIESES MODULS

note: type: textblock
en: Tested successfully on simple AsciiDoc files.
de: Erfolgreich bei einigen einfachen AsciiDoc-Dateien getestet.

note: type: textblock
en: Locale::Po4a::BibTeX - convert BibTeX documents from/to PO files
de: Locale::Po4a::BibTeX - konvertiert BibTeX-Dokumente von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::BibTeX is a module to help the translation of bibliographies in the BibTeX format into other [human] languages.
de: Locale::Po4a::BibTeX ist ein Modul, um bei der Übersetzung von Bibliographien im BibTeX-Format in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: Fields values are extracted and proposed for translation.
de: Feldwerte werden herausgelöst und für die Übersetzung vorgeschlagen.

note: type: textblock
en: NONE.
de: KEINE

note: type: textblock
en: It is a very simple module, but still young.
de: Es ist ein sehr einfaches Modul, aber noch sehr jung.

note: type: textblock
en: Locale::Po4a::Chooser - manage po4a modules
de: Locale::Po4a::Chooser - Po4a-Module verwalten

note: type: textblock
en: Locale::Po4a::Chooser is a module to manage po4a modules. Previously, all po4a binaries used to know all po4a modules (pod, man, sgml, etc). This made the addition of a new module boring, because you had to make sure that the documentation is synchronized in all modules, and that each of them can access the new module.
de: Locale::Po4a::Chooser ist ein Modul, um Po4a-Module zu verwalten. Früher kannten alle Po4a-Programme alle Po4a-Module (pod, man, sgml usw.). Dies führte dazu, dass das Hinzufügen von neuen Modulen nervig wurde, da Sie sicherstellen musste, dass die Dokumentation in allen Modulen synchronisiert ist und dass jedes davon auf das neue Modul zugreifen kann.

note: type: textblock
en: Now, you just have to call the Locale::Po4a::Chooser::new() function, passing the name of module as argument.
de: Jetzt müssen Sie nur die Funktion Locale::Po4a::Chooser::new() aufrufen und den Namen des Moduls als Argument übergeben.

note: type: textblock
en: The function Locale::Po4a::Chooser::list() lists the available formats, and exits with the value passed as argument. So, we call Locale::Po4a::Chooser::list(0) when requested for the list of formats, and Locale::Po4a::Chooser::list(1) when passed an invalid format name.
de: Die Funktion Locale::Po4a::Chooser::list() führt alle verfügbaren Formate auf und beendet sich mit dem als Argument übergebenen Wert. Daher wird Locale::Po4a::Chooser::list(0) aufgerufen, wenn eine Liste der Formate angefordert wird und Locale::Po4a::Chooser::list(1), wenn ein ungültiger Formatname übergeben wird.

note: type: =item
en: About po4a:
de: Über Po4a:

note: type: =item
en: About modules:
de: Über Module:

note: type: textblock
en: Locale::Po4a::Common - common parts of the po4a scripts and utils
de: Locale::Po4a::Common - allgemeine Teile von Po4a-Skripten und -Werkzeugen

note: type: textblock
en: Locale::Po4a::Common contains common parts of the po4a scripts and some useful functions used along the other modules.
de: Locale::Po4a::Common enthält allgemeine Teile der Po4a-Skripte und einige nützliche Funktionen, die von den anderen Modulen verwandt werden.

note: type: textblock
en: If needed, you can disable the use of Text::WrapI18N as such:
de: Falls notwendig können Sie Text::WrapI18N deaktiveren, indem Sie

note: type: textblock
en: instead of:
de: anstelle Folgendem schreiben:

note: type: textblock
en: The ordering is important here: as most Locale::Po4a modules load themselves Locale::Po4a::Common, the first time this module is loaded determines whether Text::WrapI18N is used.
de: Die Reihenfolge ist hier wichtig: da die meisten Locale::Po4a-Module selbst Locale::Po4a::Common laden, wird beim ersten Laden des Moduls entschieden, ob Text::WrapI18N verwandt wird.

note: type: =head1
en: FUNCTIONS
de: FUNKTIONEN

note: type: =head2
en: Showing output messages
de: Zeigt Ausgabenachrichten an

note: type: textblock
en: Shows the current version of the script, and a short copyright message. It takes the name of the script as an argument.
de: Zeigt die aktuelle Version des Skriptes und eine kurze Copyright-Nachricht an. Es erwartet den Namen des Skriptes als Argument.

note: type: textblock
en: This function displays a message the same way as sprintf() does, but wraps the result so that they look nice on the terminal.
de: Diese Funktion zeigt eine Nachricht genauso an, wie das sprintf() macht, fügt aber einen Zeilenumbruch hinzu, so dass sie auf einem Terminal gut aussieht.

note: type: textblock
en: This function works like wrap_msg(), but it takes a module name as the first argument, and leaves a space at the left of the message.
de: Diese Funktion funktioniert wie wrap_msg(), erwartet aber den Modulnamen als erstes Argument und lässt links der Nachricht noch ein Leerzeichen.

note: type: textblock
en: This function works like wrap_msg(), but it takes a file:line reference as the first argument, a module name as the second one, and leaves a space at the left of the message.
de: Diese Funktion funktioniert wie wrap_msg(), erwartet aber eine file:line-Referenz als erstes Argument, einen Modulnamen als zweites und lässt links der Nachricht noch ein Leerzeichen.

note: type: =head2
en: Wrappers for other modules
de: Wrapper (Adpater) für andere Module

note: type: textblock
en: When the Locale::Gettext module cannot be loaded, this module provide dummy (empty) implementation of the following functions. In that case, po4a messages won't get translated but the program will continue to work.
de: Wenn das Modul Locale::Gettext nicht geladen werden kann, stellt dieses Modul eine Pseudo- (leere) Implementierung der im Folgenden aufgeführten Funktionen dar. In diesem Fall werden die Nachrichten nicht durch Po4a übersetzt, aber das Programm wird weiterhin funktionieren.

note: type: textblock
en: If Locale::gettext is present, this wrapper also calls setlocale(LC_MESSAGES, "") so callers don't depend on the POSIX module either.
de: Falls Locale::gettext vorhanden ist, ruft dieser Adapter auch setlocale(LC_MESSAGES, "") auf, so dass Aufrufende nicht auch vom POSIX-Modul abhängen müssen.

note: type: textblock
en: Locale::Po4a::Dia - convert uncompressed Dia diagrams from/to PO files
de: Locale::Po4a::Dia - konvertiert unkomprimierte Dia-Diagramme von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Dia is a module to help the translation of diagrams in the uncompressed Dia format into other [human] languages.
de: Locale::Po4a::Dia ist ein Modul, um bei der Übersetzung von Diagrammen im unkomprimierten Dia-Format in andere [natürliche] Sprachen zu helfen.

note: type: verbatim
en: You can get Dia (the graphical editor for these diagrams) from:
      http://www.gnome.org/projects/dia/
de: Sie können Dia (den graphischen Editor für diese Diagramme) unter folgender
    Adresse erhalten:
      http://www.gnome.org/projects/dia/

note: type: =head1
en: TRANSLATING WITH PO4A::DIA
de: ÜBERSETZEN MIT PO4A::DIA

note: type: textblock
en: This module only translates uncompressed Dia diagrams.  You can save your uncompressed diagrams with Dia itself, unchecking the "Compress diagram files" at the "Save Diagram" dialog.
de: Dieses Modul übersetzt nur unkomprimierte Dia-Diagramme. Sie können Ihr unkomprimiertes Diagramm mit Dia selbst speichern, indem Sie die Option »Komprimiere Diagrammdateien« im Dialog »Diagramme speichern« abwählen.

note: type: verbatim
en: Another way is to uncompress the dia files from command line with:
      gunzip < original.dia > uncompressed.dia
de: Eine andere Möglichkeit besteht darin, das Diagramm auf der Befehlszeile zu
    entkomprimieren:
      gunzip < Original.dia > unkomprimiert.dia

note: type: textblock
en: This module is fully functional, as it relies in the L<Locale::Po4a::Xml> module. This only defines the translatable tags (E<lt>dia:stringE<gt>), and filters the internal strings (the content of the E<lt>dia:diagramdataE<gt> tag), not interesting for translation.
de: Dieses Modul ist vollständig funktionsfähig, da es auf dem Modul L<Locale::Po4a::Xml> beruht. Dies definiert nur die übersetzbaren Markierungen (E<lt>dia:stringE<gt>) und filtert die internen Zeichenketten (den Inhalt der Markierung E<lt>dia:diagramdataE<gt>), der für die Übersetzung uninteressant ist).

note: type: textblock
en: Locale::Po4a::Docbook - convert DocBook XML documents from/to PO files
de: Locale::Po4a::Docbook - konvertiert DocBook-XML-Dokumente von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Docbook is a module to help the translation of DocBook XML documents into other [human] languages.
de: Locale::Po4a::Docbook ist ein Modul, um Ihnen bei der Übersetzung von DocBook-XML-Dokumenten in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: This module is fully functional, as it relies in the L<Locale::Po4a::Xml> module. This only defines the translatable tags and attributes.
de: Dieses Modul ist voll funktional, da es vom Modul L<Locale::Po4a::Xml> abhängt. Es definiert nur die übersetzbaren Markierungen (»Tags«) und Attribute.

note: type: textblock
en: The only known issue is that it doesn't handle entities yet, and this includes the file inclusion entities, but you can translate most of those files alone (except the typical entities files), and it's usually better to maintain them separated.
de: Das einzige bekannte Problem ist, dass es noch nicht mit Entitäten umgehen kann. Hierzu gehören auch die Dateieinbindungsentitäten. Allerdings können Sie die meisten solcher Dateien einzeln übersetzten (außer den typischen Entitätendateien) und im Allgemeinen ist es auch besser, sie einzeln zu warten.

note: type: =head2
en: OVERRIDE THE DEFAULT BEHAVIOR WITH COMMAND LINE OPTIONS
de: AUSSERKRAFTSETZEN DES VORGABEVERHALTENS MIT BEFEHLSZEILENOPTIONEN

note: type: textblock
en: The default behavior of system provided modules is set to be on the safe side.
de: Das Vorgabeverhalten der vom System bereitgestellten Module ist auf einen sicheren Wert eingestellt.

note: type: textblock
en: For example, the default of B<< <author> >> tag is aiming it to appear under B<< <para> >>.  But you may be using it only under B<< <bookinfo> >>.  For this case, you may want to translate it independently for each author.
de: Beispielsweise ist die Vorgabe für die Markierung B<< <author> >>, dass sie unter B<< <para> >> erscheinen soll. Aber Sie könnten es nur unter B<< <bookinfo> >> verwenden. In diesem Fall möchten Sie es vielleicht unabhängig für jeden Autor übersetzen.

note: type: textblock
en: If you don't like the default behavior of the xml module and its derivative modules, you can provide command line options to change their behavior.  For example, you can add the following to the po4a configuration file:
de: Falls Sie das Vorgabeverhalten des XML-Moduls und seiner abgeleiteten Module nicht mögen, können Sie Befehlszeilenoptionen verwenden, um ihr Verhalten zu verändern. Beispielsweise können Sie Folgendes zu der Po4a-Konfigurationsdatei hinzuufügen:

note: type: textblock
en: This overrides the default behavior for B<< <bookinfo> >> and B<< <author> >>, set B<< <bookinfo> >> and B<< <author> >> to break input data stream on these tags, set B<< <bookinfo> >> not to translate its tagged content, and set B<< <author> >> to translate its tagged content.
de: Dies setzt das Vorgabeverhalten für B<< <bookinfo> >> und B<< <author> >> außer Kraft, setzt, dass B<< <bookinfo> >> und B<< <author> >> den Eingabedatenstrom bei diesen Merkierungen unterbrichen, setzt, dass B<< <bookinfo> >> nicht seinen markierten Inhalt übersetzt und setzt, dass B<< <author> >> seinen markierten Inhalt übersetzt.

note: type: textblock
en: Locale::Po4a::Guide - convert Guide XML documents from/to PO files
de: Locale::Po4a::Guide - konvertiert Guide-XML-Dokumente von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Guide is a module to help in the translation of the Gentoo Linux documentation in the Guide XML format into other [human] languages.
de: Locale::Po4a::Guide ist ein Modul, um bei der Übersetzung von Gentoo-Linux-Dokumentation im Guide-XML-Format in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: This format is documented here: http://www.gentoo.org/doc/en/xml-guide.xml
de: Diese Format ist hier dokumentiert: http://www.gentoo.org/doc/en/xml-guide.xml

note: type: textblock
en: The only known issue is that it doesn't include files with the <include href="..."> tag, but you can translate all those files alone, and it's usually better to have them separated.
de: Das einzige bekannte Problem ist, dass es keine Dateien mit der <include href="…">-Markierung einbindet. Allerdings können Sie alle diese Dateien einzeln übersetzen und im Allgemeinen ist es auch besser, sie separat zu haben.

note: type: textblock
en: Locale::Po4a::Halibut - convert Halibut documents and derivates from/to PO files
de: Locale::Po4a::Halibut - konvertiert Halibut-Dokumente und -Derivate von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Halibut is a module to help the translation of Halibut documents into other [human] languages.
de: Locale::Po4a::Halibut ist ein Modul, um bei der Übersetzung von Halibut-Dokumenten in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: This module contains the definitions of common Halibut commands and environments.
de: Dieses Modul enthält die Definitionen von allgemeinen Halibut-Befehlen und -Umgebungen.

note: type: textblock
en: This module is still beta.  Please send feedback and feature requests.
de: Dieses Modul ist noch im Beta-Stadium. Bitte schicken Sie uns Rückmeldungen und Funktionalitätswünsche.

note: type: =head1
en: CAVEAT
de: WARNUNG

note: type: textblock
en: Some constructs are badly supported. The known ones are documented below.
de: Einige Konstrukte werden schlecht unterstützt. Die bekannten sind im Folgenden aufgeführt.

note: type: =head2
en: Verbatim blocks
de: Wörtliche Blöcke

note: type: textblock
en: The verbatim block is not considered as a whole. Each line will be translated separately.
de: Der wörtliche Block wird nicht als gesamtes betrachtet. Jede Zeile wird einzeln übersetzt.

note: type: textblock
en: This program is free software; you may redistribute it and/or modify it under the terms of GPL (see COPYING file).
de: Dieses Programm ist freie Software, Sie können es unter den Bedingungen der GPL (siehe Datei COPYING) vertreiben und/oder verändern.

note: type: textblock
en: Locale::Po4a::Ini - convert INI files from/to PO files
de: Locale::Po4a::Ini - konvertiert INI-Dateien von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Ini is a module to help the translation of INI files into other [human] languages.
de: Locale::Po4a::Ini ist ein Modul, um bei der Übersetzung von INI-Dateien in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: The module searches for lines of the following format and extracts the quoted text:
de: Das Modul sucht nach Zeilen im folgenden Format und löst den zitierten Text heraus:

note: type: textblock
en: identificator="text than can be translated"
de: identificator="Text der übersetzt werden kann"

note: type: textblock
en: NOTE: If the text is not quoted, it will be ignored.
de: HINWEIS: Falls der Text nicht in Anführungszeichen eingeschlossen ist, wird er ignoriert.

note: type: textblock
en: Locale::Po4a::KernelHelp - convert kernel configuration help from/to PO files
de: Locale::Po4a::KernelHelp - konvertiert Kernelkonfigurationshilfe von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::KernelHelp is a module to help the translation of documentation for the Linux kernel configuration options into other [human] languages.
de: Locale::Po4a::KernelHelp ist ein Modul, um bei der Übersetzung von Dokumentation für die Konfigurationsoptionen des Linux-Kernels in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: This module is just written, and needs more tests. Most of the needed work will concern the tools used to parse this file (and configure the kernel), so that they accept to read the documentation from another (translated)  file.
de: Dieses Modul wurde gerade geschrieben und benötigt noch weitere Tests. Der Großteil der benötigten Arbeit betrifft die Werkzeuge, die diese Datei auswerten (und den Kernel konfigurieren), so dass sie das Lesen der Dokumentation aus einer anderen (übersetzten) Datei akzeptieren.

note: type: textblock
en: Locale::Po4a::LaTeX - convert LaTeX documents and derivates from/to PO files
de: Locale::Po4a::LaTeX - konvertiert LaTeX-Dokumente und Derivative von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::LaTeX is a module to help the translation of LaTeX documents into other [human] languages. It can also be used as a base to build modules for LaTeX-based documents.
de: Locale::Po4a::LaTeX ist ein Modul, um bei der Übersetzung von LaTeX-Dokumenten in andere [natürliche] Sprachen zu helfen. Es kann auch als Basis verwandt werden, um Module für LaTeX-basierte Dokumente zu erstellen.

note: type: textblock
en: This module contains the definitions of common LaTeX commands and environments.
de: Dieses Modul enthält die Definitionen von allgemeinen LaTeX-Befehlen und -Umgebungen.

note: type: textblock
en: See the L<Locale::Po4a::TeX(3pm)|Locale::Po4a::TeX> manpage for the list of recognized options.
de: Lesen Sie die Handbuchseite L<Locale::Po4a::TeX(3pm)|Locale::Po4a::TeX> für die Liste der unterstützten Optionen.

note: type: textblock
en: Locale::Po4a::Man - convert manual pages from/to PO files
de: Locale::Po4a::Man - konvertiert Handbuchseiten von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Man is a module to help the translation of documentation in the nroff format (the language of manual pages) into other [human] languages.
de: Locale::Po4a::Man ist ein Modul, um bei der Übersetzung von Dokumentation im Nroff-Format (die Sprache der Handbuchseiten) in andere [natürliche] Sprachen zu helfen.

note: type: =head1
en: TRANSLATING WITH PO4A::MAN
de: ÜBERSETZEN MIT PO4A::MAN

note: type: textblock
en: This module tries pretty hard to make translator's life easier. For that, the text presented to translators isn't a verbatim copy of the text found in the man page. Indeed, the cruder parts of the nroff format are hidden, so that translators can't mess up with them.
de: Das Modul gibt sich sehr viel Mühe, das Leben von Übersetzern zu erleichtern. Dafür ist der Text, der dem Übersetzer vorgelegt wird, keine wörtliche Kopie des Textes, wie er in der Handbuchseite vorliegt. Tatsächlich werden die unfeinen Teile des Nroff-Formats versteckt, so dass die Übersetzer nicht mit ihnen Unordnung erzeugen können.

note: type: =head2
en: Text wrapping
de: Zeilenumbruch

note: type: textblock
en: Unindented paragraphs are automatically rewrapped for the translator.  This can lead to some minor difference in the generated output, since the rewrapping rules used by groff aren't very clear. For example, two spaces after a parenthesis are sometimes preserved.
de: Nicht eingerückte Absätze werden für den Übersetzer automatisch umgebrochen. Dies kann zu ein paar kleineren Unterschieden in der erstellten Ausgabe führen, da die von Groff verwandten Zeilenumbruchregeln nicht sehr klar sind. Beispielsweise werden zwei Leerzeichen nach einer Klammer manchmal erhalten.

note: type: textblock
en: Anyway, the difference will only be about the position of the extra spaces in wrapped paragraph, and I think it's worth.
de: Wie dem auch sei, der Unterschied besteht nur in der Position von zusätzlichen Leerzeichen in umgebrochenen Absätzen und ich denke, das ist es Wert.

note: type: =head2
en: Font specification
de: Schriftangabe

note: type: textblock
en: The first change is about font change specifications.  In nroff, there are several ways to specify if a given word should be written in small, bold or italics. In the text to translate, there is only one way, borrowed from the POD (Perl online documentation) format:
de: Die erste Änderung besteht in der Schriftänderungsspezifikation. In Nroff gibt es mehrere Arten, anzugeben, ob ein Wort in kleinen Buchstaben, fett oder kursiv geschrieben werden soll. In dem zu übersetzenden Text gibt es nur eine Art, ausgeliehen vom POD- (Perl online documentation) Format:

note: type: =item
en: IE<lt>textE<gt> -- italic text
de: IE<lt>TextE<gt> -- kursiver Text

note: type: textblock
en: equivalent to \fItext\fP or ".I text"
de: äquivalent zu \fIText\fP or ".I Text"

note: type: =item
en: BE<lt>textE<gt> -- bold text
de: BE<lt>TextE<gt> -- fetter Text

note: type: textblock
en: equivalent to \fBtext\fP or ".B text"
de: äquivalent zu \fBText\fP or ".B Text"

note: type: =item
en: RE<lt>textE<gt> -- roman text
de: RE<lt>textE<gt> -- aufrechter Text

note: type: textblock
en: equivalent to \fRtext\fP
de: äquivalent zu \fRtext\fP

note: type: =item
en: CWE<lt>textE<gt> -- constant width text
de: CWE<lt>textE<gt> -- Text mit konstanter Breite

note: type: textblock
en: equivalent to \f(CWtext\fP or ".CW text"
de: äquivalent zu \f(CWtext\fP oder ".CW text"

note: type: textblock
en: Remark: The CW face is not available for all groff devices. It is not recommended to use it. It is provided for your convenience.
de: Bemerkung: Die CW-Schriftart ist nicht für alle Groff-Geräte verfügbar. Es wird empfohlen, sie nicht zu verwenden. Sie wird zur Bequemlichkeit bereitgestellt.

note: type: =head2
en: Automatic characters transliteration
de: Automatische Zeichenumschreibung

note: type: textblock
en: Po4a automatically transliterate some characters to ease the translation or the review of the translation.  Here is the list of the transliterations:
de: Po4a schreibt automatisch einige Zeichen um, um die Übersetzung oder die Begutachtung der Übersetzung zu vereinfachen. Folgende Zeichen werden umgeschrieben:

note: type: =item
en: hyphens
de: Gedankenstriche

note: type: textblock
en: Hyphens (-) and minus signs (\-) in man pages are all transliterated as simple dashes (-) in the PO file.  Then all dash are transliterated into roff minus signs (\-) when the translation is inserted into the output document.
de: Bindestriche (-) und Minuszeichen (\-) in Handbuchseiten werden alle zu Gedankenstrichen (-) in der PO-Datei umgeschrieben. Dann werden alle Gedankenstriche in Roff-Minuszeichen (\-) umgeschrieben, wenn die Übersetzung in das Ausgabedokument eingefügt wird.

note: type: textblock
en: Translators can force an hyphen by using the roff glyph '\[hy]' in their translations.
de: Übersetzer können einen Gedankenstrich erzwingen, indem Sie das Roff-Zeichen »\[hy]« in ihrer Übersetzung verwenden.

note: type: =item
en: non-breaking spaces
de: nicht trennbare Leerzeichen

note: type: textblock
en: Translators can use non-breaking spaces in their translations.  These non-breaking spaces (0xA0 in latin1) will be transliterated into a roff non-breaking space ('\ ').
de: Übersetzer können nicht trennbare Leerzeichen in ihren Übersetzungen verwenden. Diese nicht trennbaren Leerzeichen (0xA0 in latin1) werden in ein nicht trennbares Leerzeichen (»\ «) von Roff umgeschrieben.

note: type: =item
en: quotes transliterations
de: Umschreibung von Anführungszeichen

note: type: textblock
en: `` and '' are respectively tranliterated into \*(lq and \*(rq.
de: `` und '' werden in \*(lq und \*(rq respektive umgeschrieben.

note: type: textblock
en: To avoid these transliterations, translators can insert a zero width roff character (i.e., using `\&` or '\&' respectively).
de: Um diese Umschreibung zu vermeiden, können Übersetzer ein Roff-Zeichen mit einer Breite von Null einfügen (d.h. `\&` oder '\&' respektive verwenden).

note: type: =head2
en: Putting 'E<lt>' and 'E<gt>' in translations
de: »E<lt>« und »E<gt>« in Übersetzungen einbauen

note: type: textblock
en: Since these chars are used to delimit parts under font modification, you can't use them verbatim. Use EE<lt>ltE<gt> and EE<lt>gtE<gt> instead (as in POD, one more time).
de: Da diese Zeichen zur Begrenzung von Teilen mit Schriftänderung verwandt werden, können Sie sie nicht unverändert verwenden. Verwenden Sie stattdessen EE<lt>ltE<gt> und EE<lt>gtE<gt> (wie in POD, nochmals).

note: type: textblock
en: Activate debugging for some internal mechanisms of this module.  Use the source to see which parts can be debugged.
de: Aktiviert Fehlersuchroutinen für einige interne Mechanismen dieses Moduls. Verwenden Sie den Quelltext, um zu sehen, welche Teile damit auf Fehler untersucht werden können.

note: type: textblock
en: Increase verbosity.
de: Ausführlichkeit erhöhen

note: type: textblock
en: This option controls the behavior of the module when it encounter a .de, .ie or .if section. It can take the following values:
de: Diese Option steuert das Verhalten des Moduls, wenn es auf einen Abschnitt ».de«, ».ie« oder ».if« trifft. Sie kann die folgenden Werte annehmen:

note: type: textblock
en: This is the default value.  The module will fail when a .de, .ie or .if section is encountered.
de: Dies ist der Standardwert. Das Modul wird fehlschlagen, wenn es auf einen Abschnitt ».de«, ».ie« oder ».if« trifft.

note: type: textblock
en: Indicates that the .de, .ie or .if sections must be copied as is from the original to the translated document.
de: gibt an, dass die Abschnitte ».de«, ».ie« und ».if« unverändert vom Original in das übersetzte Dokument kopiert werden müssen

note: type: textblock
en: Indicates that the .de, .ie or .if sections will be proposed for the translation.  You should only use this option if a translatable string is contained in one of these section. Otherwise, I<verbatim> should be preferred.
de: Gibt an, dass die Abschnitte ».de«, ».ie« und ».if« zur Übersetzung vorgeschlagen werden. Sie sollten diese Option nur verwenden, wenn innerhalb dieser Abschnitte sich eine übersetzbare Zeichenkette befindet. Andernfalls sollte I<verbatim> vorgezogen werden.

note: type: textblock
en: This option specifies that the file was generated, and that po4a should not try to detect if the man pages was generated from another format.  This option is mandatory to use po4a on generated man pages.  Note that translating generated pages instead of sources ones is often more fragile, and thus a bad idea.
de: Diese Option gibt an, dass die Datei automatisch generiert wurde und dass Po4a nicht versuchen sollte, herauszufinden, ob die Handbuchseite aus einem anderen Format generiert wurde. Diese Option ist zwingend anzugeben, wenn Po4a mit generierten Handbuchseiten verwandt wird. Beachten Sie, dass die Übersetzung von generierten Handbuchseiten (statt der Quellseiten) oft fehleranfälliger und daher keine Gute Idee ist.

note: type: textblock
en: This option is only useful for mdoc pages.
de: Diese Option ist nur für Mdoc-Seiten nützlich.

note: type: textblock
en: It selects a stricter support of the mdoc format by telling po4a not to translate the 'NAME' section.  mdoc pages whose 'NAME' section is translated won't generate any header or footer.
de: Es wählt eine strengere Unterstützung für das Mdoc-Format aus, indem Po4a angewiesen wird, den Abschnitt »NAME« nicht zu übersetzen. Mdoc-Seiten, deren »NAME«-Abschnitt übersetzt wurde, erstellen keine Kopf- oder Fußzeilen.

note: type: verbatim
en: According to the groff_mdoc page, the NAME, SYNOPSIS and DESCRIPTION
    sections are mandatory.
    There are no known issues with translated SYNOPSIS or DESCRIPTION section,
    but you can also specify these sections this way:
     -o mdoc=NAME,SYNOPSIS,DESCRIPTION
de: Entsprechend der Groff-Mdoc-Seite, sind die Abschnitte »NAME«, »SYNOPSIS«
    (im deutschen »ÜBERSICHT«) und »DESCRIPTION« (»BESCHREIBUNG«) verpflichtend.
    Es gibt keine bekannten Probleme mit übersetzten SYNPOSIS- oder
    DESCRIPTION-Abschnitten, Sie können aber diese Abschnitte auch in dieser Art
    spezifizieren:
     -o mdoc=NAME,SYNOPSIS,DESCRIPTION

note: type: verbatim
en: This mdoc issue can also be solved with an addendum like this one:
     PO4A-HEADER:mode=before;position=^.Dd
     .TH DOCUMENT_TITLE 1 "Month day, year" OS "Section Name"
de: Dieses Mdoc-Problem kann auch mit einem Addendum der folgenden Art behoben
    werden:
     PO4A-HEADER:mode=before;position=^.Dd
     .TH DOCUMENT_TITLE 1 "Monat Tag, Jahr" OS "Abschnittname"

note: type: textblock
en: Note: if a macro is not supported by po4a and if you consider that it is a standard roff macro, you should submit it to the po4a development team.
de: Hinweis: Falls ein Makro von Po4a nicht unterstützt wird und falls Sie denken, dass dies ein Standard-Roff-Makro ist, dann sollten Sie es dem Po4a-Entwicklungsteam mitteilen.

note: type: textblock
en: B<untranslated> indicates that this macro (at its arguments) don't have to be translated.
de: B<untranslated> gibt an, dass dieses Makro (und seine Argumente) nicht übersetzt werden müssen.

note: type: textblock
en: B<noarg> is like B<untranslated>, except that po4a will verify that no argument is added to this macro.
de: B<noarg> verhält sich wie B<untranslated>, außer dass Po4a überprüfen wird, dass kein Argument zu diesem Makro hinzugefügt wird.

note: type: textblock
en: B<translate_joined> indicates that po4a must propose to translate the arguments of the macro.
de: B<translate_joined> zeigt an, dass Po4a die Argumente dieses Makros zur Übersetzung vorschlagen muss.

note: type: textblock
en: With B<translate_each>, the arguments will also be proposed for the translation, except that each one will be translated separately.
de: Mit B<translate_each> werden die Argumente auch zur Übersetzung vorgeschlagen, außer dass jedes separat übersetzt wird.

note: type: textblock
en: This option takes as argument a list of comma-separated couples I<begin>:I<end>, where I<begin> and I<end> are commands that delimit the begin and end of a section that should not be rewrapped.
de: Diese Option akzeptiert als Argument eine Komma-separierte Liste von I<Anfang>:I<Ende>-Paaren, wobei I<Anfang> und I<Ende> Befehle sind, die den Anfang und das Ende eines Abschnitts, der nicht neu umgebrochen werden soll, abgrenzen.

note: type: textblock
en: Note: no test is done to ensure that an I<end> command matches its I<begin> command; any ending command stop the no_wrap mode.  If you have a I<begin> (respectively I<end>) macro that has no I<end> (respectively I<begin>), you can specify an existing I<end> (like fi) or I<begin> (like nf) as a counterpart.  These macros (and their arguments) won't be translated.
de: Hinweis: Es erfolgt keine Überprüfung, um sicherzustellen, dass der I<Ende>-Befehl auf einen I<Anfang>-Befehl passt, jeder Beendigungsbefehl beendet den »no_wrap«-Modus. Falls ein I<Anfang>- (respektive ein I<Ende>-)Makro existiert, für das kein I<Ende> (respektive I<Anfang>) existiert, können Sie ein existierendes I<Ende> (wie fi) oder I<Anfang> (wie nf) als Gegenstück angeben. Diese Makros (und ihre Argumente) werden nicht übersetzt.

note: type: textblock
en: This option specifies a list of comma-separated macros that must not split the current paragraph. The string to translate will then contain I<foo E<lt>.bar baz quxE<gt> quux>, where I<bar> is the command that should be inlined, and I<baz qux> its arguments.
de: Diese Option gibt eine Komma-separierte Liste von Makros an, die den aktuellen Absatz nicht trennen dürfen. Die zu übersetzende Zeichenkette wird dann I<foo E<lt>.bar baz quxE<gt> quux> enthalten, wobei I<bar> der Befehl ist, der in der Zeile bleiben soll und I<baz qux> seine Argumente sind.

note: type: textblock
en: This option indicates how po4a should behave when an unknown macro is found.  By default, po4a fails with a warning.  It can take the following values: B<failed> (the default value), B<untranslated>, B<noarg>, B<translate_joined>, or B<translate_each> (see above for an explanation of these values).
de: Diese Option zeigt an, wie sich Po4a verhalten soll, wenn ein unbekanntes Makro gefunden wird. Standardmäßig schlägt Po4a mit einer Warnung fehl. Diese Option kann die folgenden Werte annehmen: B<failed> (der Standardwert), B<untranslated>, B<noarg>, B<translate_joined> oder B<translate_each> (die Erklärung dieser Werte ist weiter oben erfolgt).

note: type: =head1
en: AUTHORING MAN PAGES COMPLIANT WITH PO4A::MAN
de: ERSTELLEN VON PO4A::MAN-KONFORMEN HANDBUCHSEITEN

note: type: textblock
en: This module is still very limited, and will always be, because it's not a real nroff interpreter. It would be possible to do a real nroff interpreter, to allow authors to use all the existing macros, or even to define new ones in their pages, but we didn't want to. It would be too difficult, and we thought it wasn't necessary. We do think that if manpages' authors want to see their productions translated, they may have to adapt to ease the work of translators.
de: Dieses Modul ist noch sehr begrenzt und wird dies immer bleiben, da es kein echter Nroff-Interpreter ist. Es wäre möglich, einen echten Nroff-Interpreter zu erstellen, um Autoren die Verwendung aller existierender Makros (und sogar die Definition neuer Makros) in ihren Seiten zu erlauben, aber wir wollten das nicht. Es wäre zu schwierig und wir dachten, es wäre nicht notwendig. Wir glauben, dass Handbuchseitenautoren, die ihre Werke übersetzt bekommen möchten, sich anpassen müssen, um die Arbeit der Übersetzer zu erleichtern.

note: type: textblock
en: So, the man parser implemented in po4a have some known limitations we are not really inclined to correct, and which will constitute some pitfalls you'll have to avoid if you want to see translators taking care of your documentation.
de: Daher hat der Parser in Po4a einige bekannte Einschränkungen, die wir nicht planen, zu korrigieren und die einige Fallstricke enthalten, die Sie vermeiden sollten, falls Sie möchten, dass Übersetzer sich um Ihre Dokumentation kümmern.

note: type: =head2
en: Don't program in nroff
de: Programmieren Sie nicht in Nroff

note: type: textblock
en: nroff is a complete programming language, with macro definition, conditionals and so on. Since this parser isn't a fully featured nroff interpreter, it will fail on pages using these facilities (There are about 200 such pages on my box).
de: Nroff ist eine komplette Programmiersprache mit Makrodefinitionen, Bedingungen und so weiter. Da dieser Parser kein vollständiger Nroff-Interpreter ist, wird er bei Seiten fehlschlagen, die diese Funktionalitäten verwenden (es gibt rund 200 solche Seiten auf meiner Kiste).

note: type: =head2
en: Use the plain macro set
de: Verwenden Sie den Makrosatz »plain«

note: type: textblock
en: There are still some macros which are not supported by po4a::man. This is only because I failed to find any documentation about them. Here is the list of unsupported macros used on my box. Note that this list isn't exhaustive since the program fails on the first encountered unsupported macro. If you have any information about some of these macros, I'll happily add support for them. Because of these macros, about 250 pages on my box are inaccessible to po4a::man.
de: Es gibt noch einige Makros, die von po4a::man nicht unterstützt werden. Das passiert nur, da ich keine Information über sie gefunden habe. Es folgt eine Liste von nicht unterstützen Makros, die ich auf meiner Kiste gefunden habe. Beachten Sie, dass diese Liste nicht abschließend ist, da das Programm beim ersten nicht unterstützten Makro abbricht. Falls Sie über einige dieser Makros Informationen haben, werde ich gerne die Unterstützung hierfür hinzufügen. Aufgrund dieser Makros sind rund 250 Seiten auf meinem Rechner nicht für po4a::man verfügbar.

note: type: =head2
en: Hiding text from po4a
de: Text vor Po4a verstecken

note: type: textblock
en: Sometimes, the author knows that some parts are not translatable, and should not be extracted by po4a. For example, an option may accept an I<other> argument, and I<other> may also appear as the last item of a list. In the first case, I<other> should be not be translatable. And in the second case, I<other> should be translated.
de: Manchmal weiß der Autor, dass einige Teile nicht übersetzbar sind und daher von Po4a nicht ausgelesen werden sollten. Beispielsweise könnte eine Option I<other> als Argument akzeptieren und I<other> könnte zusätzlich als letztes Argument in einer Liste auftauchen. Im ersten Fall sollte I<other> nicht übersetzt werden, im zweiten Falls dagegen schon (z.B. ins Deutsche als »sonstiges«).

note: type: textblock
en: In such case, the author can avoid po4a to extract some strings, using some special groff constructs:
de: In diesem Fall kann der Autor durch spezielle Groff-Konstrukte Po4a anweisen, bestimmte Zeichenketten nicht auszulesen:

note: type: textblock
en: (this will require the B<-o groff_code=verbatim> option)
de: (dies benötigt die Option B<-o groff_code=verbatim>)

note: type: verbatim
en: A new macro can also be defined to automate this:
     .de IR_untranslated
     .    IR \\$@
     ..
de: Ein neues Makro kann auch zur Automatisierung hiervon verwandt werden:
     .de IR_untranslated
     .    IR \\$@
     ..

note: type: textblock
en: (this will require the options B<-o groff_code=verbatim> and B<-o untranslated=IR_untranslated>; with this construct, the B<.if !'po4a'hide'> conditional is not strictly needed since po4a will not parse the internal of the macro definition)
de: (dies benötigt die Option B<-o groff_code=verbatim> und B<-o untranslated=IR_untranslated>; mit diesem Konstrukt wird die Bedingung B<.if !'po4a'hide'> streng genommen nicht benötigt, da Po4a nicht die Interna der Makrodefinition auswerten wird)

note: type: verbatim
en: or using an alias:
     .als IR_untranslated IR
de: oder durch Verwendung eines Alias:
     .als IR_untranslated IR

note: type: textblock
en: This will require the B<-o untranslated=als,IR_untranslated> option.
de: (dies benötigt die Option B<-o untranslated=als,IR_untranslated>)

note: type: =head2
en: Conclusion
de: Schlussfolgerungen

note: type: textblock
en: To summarise this section, keep simple, and don't try to be clever while authoring your man pages. A lot of things are possible in nroff, and not supported by this parser. For example, don't try to mess with \c to interrupt the text processing (like 40 pages on my box do). Or, be sure to put the macro arguments on the same line that the macro itself. I know that it's valid in nroff, but would complicate too much the parser to be handled.
de: Um diesen Abschnitt zusammenzufassen: Halten Sie es einfach und versuchen Sie nicht, beim Verfassen Ihrer Handbuchseiten überschlau zu sein. In Nroff sind viele Dinge möglich und werden nicht von diesem Parser unterstützt. Versuchen Sie zum Beispiel nicht, mit \c herumzumurksen, um die Textverarbeitung zu unterbrechen (wie es 40 Seiten auf der Kiste des Verfassers tun). Oder stellen Sie sicher, dass Sie die Makro-Argumente auf die gleiche Zeile wie das Makro selbst legen. Es ist bekannt, dass dies in Nroff gültig ist, würde aber die Handhabung durch den Parser zu sehr komplizieren.

note: type: textblock
en: Of course, another possibility is to use another format, more translator friendly (like POD using po4a::pod, or one of the XML family like SGML), but thanks to po4a::man it isn't needed anymore. That being said, if the source format of your documentation is POD, or XML, it may be clever to translate the source format and not this generated one. In most cases, po4a::man will detect generated pages and issue a warning. It will even refuse to process POD generated pages, because those pages are perfectly handled by po4a::pod, and because their nroff counterpart defines a lot of new macros I didn't want to write support for. On my box, 1432 of the 4323 pages are generated from POD and will be ignored by po4a::man.
de: Natürlich wäre eine weitere Möglichkeit, ein anderes, übersetzerfreundlicheres Format zu benutzen (wie POD unter Benutzung von po4a::pod oder einem aus der XML-Familie, wie SGML), aber dank po4a::man ist das nicht mehr nötig. Davon abgesehen, falls das Quellformat Ihrer Dokumentation POD oder XML ist, könnte es klug sein, das Quellformat und nicht das erzeugte zu übersetzen. In den meisten Fällen wird po4a::man erzeugte Seiten ermitteln und ein Warnung ausgeben. Es wird sogar die Verarbeitung der erzeugten Seiten verweigern, da diese Seiten perfekt durch po4a::pod gehandhabt werden und da ihr Nroff-Gegenstück eine große Menge neuer Makros definiert, für die der Verfasser keine Unterstützung schreiben möchte. Auf dessen Kiste wurden 1432 der 4323 Seiten aus POD erzeugt und werden von po4a::man ignoriert.

note: type: textblock
en: In most cases, po4a::man will detect the problem and refuse to process the page, issuing an adapted message. In some rare cases, the program will complete without warning, but the output will be wrong. Such cases are called "bugs" ;) If you encounter such case, be sure to report this, along with a fix when possible…
de: In den meisten Fällen wird po4a::man das Problem feststellen und die Verarbeitung der Seite verweigern und eine angepasste Nachricht ausgeben. In einigen seltenen Fällen wird das Programm vollständig ohne Warnung ausgeführt, die Ausgabe ist aber falsch. Solche Fälle werden »Fehler« genannt. ;) Falls Sie auf einen solchen Fall stoßen, stellen Sie sicher, dass Sie dies melden, wenn möglich zusammen mit einer Fehlerbehebung …

note: type: textblock
en: This module can be used for most of the existing man pages.
de: Dieses Module kann für die meisten existierenden Handbuchseiten benutzt werden.

note: type: textblock
en: Some tests are regularly run on Linux boxes:
de: Einige Tests werden regelmäßig auf Linux-Kisten ausgeführt:

note: type: textblock
en: one third of the pages are refused because they were generated from another format supported by po4a (e.g. POD or SGML).
de: ein Drittel Seiten werden abgelehnt, da sie in einem anderen durch Po4a unterstützten Format erzeugt wurde (z.B. POD or SGML).

note: type: textblock
en: 10% of the remaining pages are rejected with an error (e.g. a groff macro is not supported).
de: Zehn Prozent der verbleibenden Seiten werden mit einem Fehler zurückgewiesen (z.B. wird ein Groff-Makro nicht unterstützt).

note: type: textblock
en: Then, less than 1% of the pages are accepted silently by po4a, but with significant issues (i.e. missing words, or new words inserted)
de: Dann wird weniger als ein Prozent der Seiten stillschweigend durch Po4a akzeptiert, aber mit wesentlichen Problemen (d.h. fehlenden Wörtern oder neu eingefügten Wörtern),

note: type: textblock
en: The other pages are usually handled without differences more important than spacing differences or line rewrapped (font issues in less than 10% of the processed pages).
de: Die anderen Seiten werden üblicherweise ohne Unterschiede gehandhabt, die wichtiger sind als Leerzeichenunterschiede oder neue Zeilenaufteilung (Schriftprobleme in weniger als zehn Prozent der verarbeiteten Seiten).

note: type: textblock
en: Locale::Po4a::Po - PO file manipulation module
de: Locale::Po4a::Po - PO-Dateien-Manipulationsmodul

note: type: verbatim
en:     # Read PO file
        $pofile->read('file.po');
de:     # PO-Datei einlesen
        $pofile->read('Datei.po');

note: type: verbatim
en:     # Add an entry
        $pofile->push('msgid' => 'Hello', 'msgstr' => 'bonjour',
                      'flags' => "wrap", 'reference'=>'file.c:46');
de:     # Einen Eintrag hinzufügen 
        $pofile->push('msgid' => 'Hallo', 'msgstr' => 'bonjour',
                      'flags' => "wrap", 'reference'=>'file.c:46');

note: type: verbatim
en:     # Extract a translation
        $pofile->gettext("Hello"); # returns 'bonjour'
de:     # Eine Übersetzung extrahieren
        $pofile->gettext("Hello"); # liefert »bonjour«

note: type: verbatim
en:     # Write back to a file
        $pofile->write('otherfile.po');
de:     # In eine Datei zurückschreiben
        $pofile->write('andereDatei.po');

note: type: textblock
en: Locale::Po4a::Po is a module that allows you to manipulate message catalogs. You can load and write from/to a file (which extension is often I<po>), you can build new entries on the fly or request for the translation of a string.
de: Locale::Po4a::Po ist ein Modul, das Ihnen die Bearbeitung von Nachrichtenkatalogen ermöglicht. Sie können eine Datei laden und in sie schreiben (deren Erweiterung oft I<po> lautet), Sie können dynamisch neue Einträge hinzufügen oder um die Übersetzung einer Zeichenkette bitten.

note: type: textblock
en: For a more complete description of message catalogs in the PO format and their use, please refer to the info documentation of the gettext program (node "`PO Files"').
de: Für eine umfangreichere Beschreibung der Nachrichtenkataloge im PO-Format und ihren Einsatz lesen Sie bitte die Info-Dokumentation des Gettext-Programms (Knoten »PO Files«).

note: type: textblock
en: This module is part of the po4a project, which objective is to use PO files (designed at origin to ease the translation of program messages) to translate everything, including documentation (man page, info manual), package description, debconf templates, and everything which may benefit from this.
de: Dieses Modul ist Teil des Po4a-Projekts, dessen Ziel es ist, PO-Dateien (ursprünglich dazu erstellt, um die Übersetzung von Programmmeldungen zu erleichtern) zur Übersetzung von allem einzusetzen, darunter Dokumentation (Handbuchseiten, Info-Handbücher), Paketbeschreibungen, Debconf-Vorlagen und allem, das daraus Nutzen ziehen kann.

note: type: =head1
en: Functions concerning entire message catalogs
de: Funktionen, die gesamte Nachrichtenkataloge betreffen

note: type: textblock
en: Creates a new message catalog. If an argument is provided, it's the name of a PO file we should load.
de: Erstellt einen neuen Nachrichtenkatalog. Falls ein Argument angegeben ist, ist es der Name der PO-Datei, die geladen werden soll.

note: type: textblock
en: Reads a PO file (which name is given as argument).  Previously existing entries in self are not removed, the new ones are added to the end of the catalog.
de: Liest eine PO-Datei ein (deren Namen als Argument übergeben wird). Vorherige Einträge in »self« werden nicht entfernt, die neuen werden am Ende des Katalogs hinzugefügt.

note: type: textblock
en: Writes the current catalog to the given file.
de: schreibt den aktuellen Katalog in die übergebene Datei

note: type: textblock
en: Like write, but if the PO or POT file already exists, the object will be written in a temporary file which will be compared with the existing file to check if the update is needed (this avoids to change a POT just to update a line reference or the POT-Creation-Date field).
de: Wie write, aber falls die PO- oder POT-Datei bereits existiert, wird das Objekt in eine temporäre Datei geschrieben, die mit der bestehenden Datei verglichen wird, um zu überprüfen, ob eine Aktualisierung benötigt wird (dies vermeidet eine Änderung an der POT-Datei, um lediglich eine Zeilenreferenz oder das Feld »POT-Creation-Date« zu aktualisieren).

note: type: textblock
en: This function extracts a catalog from an existing one. Only the entries having a reference in the given file will be placed in the resulting catalog.
de: Diese Funktion löst einen Katalog aus einem bestehenden heraus. Nur die Einträge, die eine Referenz in der angegebenen Datei haben, werden in dem resultierenden Katalog eingefügt.

note: type: textblock
en: This function parses its argument, converts it to a Perl function definition, evals this definition and filters the fields for which this function returns true.
de: Diese Funktion wertet ihr Argument aus, konvertiert es in eine Perl-Funktionsdefinition, wertet diese Definition aus und filtert die Felder heraus, für die diese Funktion wahr zurückliefert.

note: type: textblock
en: I love Perl sometimes ;)
de: Manchmal liebe ich Perl ;)

note: type: textblock
en: Recodes to UTF-8 the PO's msgstrs. Does nothing if the charset is not specified in the PO file ("CHARSET" value), or if it's already UTF-8 or ASCII.
de: Wandelt die Kodierung der Msgstrs in der PO-Datei in UTF-8. Führt nichts aus, falls der Zeichensatz (Wert von »CHARSET«) in der PO-Datei nicht angegeben ist oder falls es bereits UTF-8 oder ASCII ist.

note: type: =head1
en: Functions to use a message catalog for translations
de: Funktionen, die einen Nachrichtenkatalog für Übersetzungen verwenden

note: type: textblock
en: Request the translation of the string given as argument in the current catalog.  The function returns the original (untranslated) string if the string was not found.
de: Erbittet die Übersetzung der als Argument übergebenen Zeichenkette im aktuellen Katalog. Die Funktion liefert die ursprüngliche (unübersetzte) Zeichenkette zurück, falls die Zeichenkette nicht gefunden wurde.

note: type: textblock
en: After the string to translate, you can pass a hash of extra arguments. Here are the valid entries:
de: Nach der zu übersetzenden Zeichenkette können Sie einen Hash mit zusätzlichen Argumenten übergeben. Dabei gibt es die folgenden gültigen Einträge:

note: type: textblock
en: boolean indicating whether we can consider that whitespaces in string are not important. If yes, the function canonizes the string before looking for a translation, and wraps the result.
de: Logische Variable, die angibt, ob davon ausgegangen werden kann, dass Leerzeichen in Zeichenketten nicht wichtig sind. Falls ja, überführt die Funktion die Zeichenkette in eine kanonische Form, bevor sie nach einer Übersetzung sucht, und bricht das Ergebnis um.

note: type: textblock
en: the column at which we should wrap (default: 76).
de: die Spalte, an der umgebrochen werden soll (standardmäßig 76)

note: type: textblock
en: Returns statistics about the hit ratio of gettext since the last time that stats_clear() was called. Please note that it's not the same statistics than the one printed by msgfmt --statistic. Here, it's statistics about recent usage of the PO file, while msgfmt reports the status of the file.  Example of use:
de: Liefert Statistiken über das Trefferverhältnis von Gettext seit dem letzten Aufruf von stats_clear() zurück. Beachten Sie, dass dies nicht die gleiche Statistik ist, die von »msgfmt --statistic« ausgegeben wird. Hier berichtet die Statistik über die kürzliche Verwendung der PO-Datei, während Msgfmt über den Status der Datei berichtet. Beispiel:

note: type: verbatim
en:     [some use of the PO file to translate stuff]
de:     [einige Arbeiten mit der PO-Datei, um Zeugs zu übersetzen]

note: type: verbatim
en:     ($percent,$hit,$queries) = $pofile->stats_get();
        print "So far, we found translations for $percent\%  ($hit of $queries) of strings.\n";
de:     ($percent,$hit,$queries) = $pofile->stats_get();
        print "Bisher wurden Übersetzungen für $percent\% ($hit von $queries) der Zeichenketten gefunden.\n";

note: type: textblock
en: Clears the statistics about gettext hits.
de: bereinigt die Statistiken über Gettext-Treffer

note: type: =head1
en: Functions to build a message catalog
de: Funktionen, um einen Katalog mit Meldungen aufzubauen

note: type: textblock
en: Push a new entry at the end of the current catalog. The arguments should form a hash table. The valid keys are:
de: Schiebt einen neuen Eintrag an das Ende des aktuellen Katalogs. Die Argumente sollten eine Hash-Tabelle darstellen. Die gültigen Schlüssel sind:

note: type: textblock
en: the string in original language.
de: die Zeichenkette in der Ursprungssprache

note: type: textblock
en: the translation.
de: die Übersetzung

note: type: textblock
en: an indication of where this string was found. Example: file.c:46 (meaning in 'file.c' at line 46). It can be a space-separated list in case of multiple occurrences.
de: eine Angabe, wo die Zeichenkette gefunden wurde. Beispiel: Datei.c:46 (d.h. in Datei.c, Zeile 46). Es kann eine durch Leerzeichen getrennte Liste sein, falls die Zeichenkette mehrfach vorkommt.

note: type: textblock
en: a comment added here manually (by the translators). The format here is free.
de: ein manuell (vom Übersetzer) hinzugefügter Kommentar. Das Format ist hier frei.

note: type: textblock
en: a comment which was automatically added by the string extraction program. See the B<--add-comments> option of the B<xgettext> program for more information.
de: ein automatisch hinzugefügter Kommentar, der vom Zeichenkettenausleseprogramm hinzugefügt wurde. Lesen Sie zu der Option »B<--add-comments>« des Programms B<xgettext> für weitere Informationen hierzu.

note: type: textblock
en: space-separated list of all defined flags for this entry.
de: durch Leerzeichen getrennte Liste aller definierten Schalter für diesen Eintrag.

note: type: textblock
en: Valid flags are: B<c-text>, B<python-text>, B<lisp-text>, B<elisp-text>, B<librep-text>, B<smalltalk-text>, B<java-text>, B<awk-text>, B<object-pascal-text>, B<ycp-text>, B<tcl-text>, B<wrap>, B<no-wrap> and B<fuzzy>.
de: Gültige Schalter sind: B<c-text>, B<python-text>, B<lisp-text>, B<elisp-text>, B<librep-text>, B<smalltalk-text>, B<java-text>, B<awk-text>, B<object-pascal-text>, B<ycp-text>, B<tcl-text>, B<wrap>, B<no-wrap> und B<fuzzy>.

note: type: textblock
en: See the gettext documentation for their meaning.
de: Lesen Sie die Getttext-Dokumentation bezüglich ihrer Bedeutung.

note: type: textblock
en: this is mostly an internal argument: it is used while gettextizing documents. The idea here is to parse both the original and the translation into a PO object, and merge them, using one's msgid as msgid and the other's msgid as msgstr. To make sure that things get ok, each msgid in PO objects are given a type, based on their structure (like "chapt", "sect1", "p" and so on in DocBook). If the types of strings are not the same, that means that both files do not share the same structure, and the process reports an error.
de: Dies ist hauptsächlich ein internes Argument: Es wird beim Einbau von Gettext in Dokumente verwandt. Die Idee hierbei ist, sowohl das Original als auch die Übersetzung in ein PO-Objekt auszuwerten und sie dann zusammenzuführen, wobei die Mgsids des einen die Msgids werden und die Mgsgids des anderen die Msgstr. Um sicherzustellen, dass alles stimmig wird, wird jeder Msgid in PO-Objekten ein Typ vergeben, basierend auf ihrer Struktur (wie »chapt«, »sect1«, »p« und so weiter in Docbook). Falls die Typen der Zeichenketten nicht übereinstimmen, bedeutet dies, dass die beiden Dateien nicht über die gleiche Struktur verfügen. Der Prozess liefert dann eine Fehlermeldung.

note: type: textblock
en: This information is written as automatic comment in the PO file since this gives to translators some context about the strings to translate.
de: Diese Information wird als automatischer Kommentar in die PO-Datei geschrieben, da dies den Übersetzern Kontext zu den zu übersetzenden Zeichenketten liefert.

note: type: textblock
en: boolean indicating whether whitespaces can be mangled in cosmetic reformattings. If true, the string is canonized before use.
de: Logische Variable, die angibt, ob Leerzeichen bei kosmetischen Neuformatierungen gequetscht werden dürfen. Falls wahr, wird die Zeichenkette vor der Verwendung in eine kanonische Form gebracht.

note: type: textblock
en: This information is written to the PO file using the B<wrap> or B<no-wrap> flag.
de: Diese Information wird mit dem Schalter B<wrap> oder B<no-wrap> in die PO-Datei geschrieben.

note: type: textblock
en: This information is not written to the PO file.
de: Diese Information wird nicht in die PO-Datei geschrieben.

note: type: =head1
en: Miscellaneous functions
de: Verschiedene Funktionen

note: type: textblock
en: Returns the number of entries in the catalog (without the header).
de: liefert die Anzahl an Einträgen im Katalog (ohne die Kopfzeilen)

note: type: textblock
en: Returns the number of entries in document. If a string appears multiple times in the document, it will be counted multiple times.
de: Liefert die Anzahl der Einträge im Dokument. Falls eine Zeichenkette mehrfach im Dokument auftaucht, wird sie auch mehrfach gezählt.

note: type: textblock
en: Returns the msgid of the given number.
de: liefert die Msgid der angegebenen Nummer

note: type: textblock
en: Returns the msgid with the given position in the document.
de: liefert die Msgid mit der angegebenen Position im Dokument

note: type: textblock
en: Returns the type of the msgid with the given position in the document. This is probably only useful to gettextization, and it's stored separately from {$msgid}{'type'} because the later location may be overwritten by another type when the $msgid is duplicated in the master document.
de: Liefert den Typ der Msgid mit der angegebenen Position im Dokument zurück. Dies ist wahrscheinlich nur für die Gettextisierung nützlich, und es wird separat von {$msgid}{'type'} gespeichert, da letzterer Ort durch einen anderen Typ überschrieben werden könnte, falls die $msgid im Master-Dokument mehrfach vorkommt.

note: type: textblock
en: Returns the character set specified in the PO header. If it hasn't been set, it will return "UTF-8".
de: gibt den in den PO-Kopfzeilen definierten Zeichensatz zurück. Falls er nicht gesetzt wurde, wird »UTF-8« zurückgegeben.

note: type: textblock
en: This sets the character set of the PO header to the value specified in its first argument. If you never call this function (and no file with a specified character set is read), the default value is left to "UTF-8". This value doesn't change the behavior of this module, it's just used to fill that field in the header, and to return it in get_charset().
de: Dies setzt den Zeichensatz der PO-Kopfzeilen auf den Wert, der im ersten Argument angegeben wurde. Falls Sie diese Funktion nie aufrufen (und keine Datei mit einem angegebenen Zeichensatz gelesen wird), wird der Standardwert auf »UTF-8« belassen. Dieser Wert ändert nicht das Verhalten dieses Moduls, er wird nur benutzt, um das Feld in den Kopfzeilen zu füllen und es in get_charset() zurückzuliefern.

note: type: textblock
en: Locale::Po4a::Pod - convert POD data from/to PO files
de: Locale::Po4a::Pod - konvertiert POD-Daten von/in PO-Dateien

note: type: verbatim
en:     # Read POD from STDIN and write to STDOUT.
        $parser->parse_from_filehandle;
de:     # POD von STDIN lesen und nach STDOUT schreiben
        $parser->parse_from_filehandle;

note: type: verbatim
en:     # Read POD from file.pod and write to file.txt.
        $parser->parse_from_file ('file.pod', 'file.txt');
de:     # POD aus Datei.pod lesen und nach Datei.txt schreiben
        $parser->parse_from_file ('Datei.pod', 'Datei.txt');

note: type: textblock
en: Locale::Po4a::Pod is a module to help the translation of documentation in the POD format (the preferred language for documenting Perl) into other [human] languages.
de: Locale::Po4a::Pod ist ein Modul, um bei der Übersetzung von Dokumentation in dem POD-Format (dem für Perl-Dokumentierung bevorzugten Format) in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: I think that this module is rock stable, and there is only one known bug with F</usr/lib/perl5/Tk/MainWindow.pod> (and some other pages, see below) which contains:
de: Ich denke, dieses Modul ist stabil wie ein Felsen und es gibt nur einen bekannten Fehler mit F</usr/lib/perl5/Tk/MainWindow.pod> (und einigen anderen Seiten, siehe unten), in der Folgendes steht:

note: type: textblock
en: Lack of luck, in the po4a version, this was split on the space by the wrapping. As result, in the original version, the man page contains
de: Durch fehlendes Glück wurde in der Po4a-Version dies beim Leerzeichen umgebrochen. Dadurch enthielt die Ursprungsversion des Handbuchs

note: type: textblock
en: and mine contains
de: und meine enthielt

note: type: textblock
en: which is logic since CE<lt>foobarE<gt> is rewritten "foobar".
de: was logisch ist, da CE<lt>foobarE<gt> in "foobar" umgeschrieben wird.

note: type: textblock
en: Complete list of pages having this problem on my box (from 564 pages; note that it depends on the chosen wrapping column): /usr/lib/perl5/Tk/MainWindow.pod /usr/share/perl/5.8.0/overload.pod /usr/share/perl/5.8.0/pod/perlapi.pod /usr/share/perl/5.8.0/pod/perldelta.pod /usr/share/perl/5.8.0/pod/perlfaq5.pod /usr/share/perl/5.8.0/pod/perlpod.pod /usr/share/perl/5.8.0/pod/perlre.pod /usr/share/perl/5.8.0/pod/perlretut.pod
de: Vollständige Liste von Seiten, die auf meiner Maschine dieses Problem haben (von 564 Seiten, beachten Sie, dass dies von der gewählten Umbruchspalte abhängt): /usr/lib/perl5/Tk/MainWindow.pod /usr/share/perl/5.8.0/overload.pod /usr/share/perl/5.8.0/pod/perlapi.pod /usr/share/perl/5.8.0/pod/perldelta.pod /usr/share/perl/5.8.0/pod/perlfaq5.pod /usr/share/perl/5.8.0/pod/perlpod.pod /usr/share/perl/5.8.0/pod/perlre.pod /usr/share/perl/5.8.0/pod/perlretut.pod

note: type: =head1
en: INTERNALS
de: INTERNA

note: type: textblock
en: As a derived class from Pod::Parser, Locale::Po4a::Pod supports the same methods and interfaces.  See L<Pod::Parser> for all the details; briefly, one creates a new parser with C<< Locale::Po4a::Pod->new() >> and then calls either parse_from_filehandle() or parse_from_file().
de: Als abgeleitete Klasse von Pod::Parser unterstützt Locale::Po4a::Pod die gleichen Methoden und Schnittstellen. Lesen Sie L<Pod::Parser> für alle Details; in Kürze, ein neuer Parser wird mit C<< Locale::Po4a::Pod->new() >> erstellt und dann wird entweder parse_from_filehandle() oder parse_from_file() aufgerufen.

note: type: textblock
en: new() can take options, in the form of key/value pairs, that control the behavior of the parser.  The recognized options common to all Pod::Parser children are:
de: new() akzeptiert Optionen in der Form von Schlüssel/Wert-Paaren, die das Verhalten des Parsers steuern. Die von allen Pod::Parser-Kindern erkannten Optionen sind:

note: type: textblock
en: If set to a true value, selects an alternate output format that, among other things, uses a different heading style and marks B<=item> entries with a colon in the left margin.  Defaults to false.
de: Falls dies auf einen wahren Wert gesetzt wird, wird unter anderem ein alternatives Ausgabeformat ausgewählt, ein anderer Stil für Überschriften gewählt und B<=item>-Einträge mit einem Doppelpunkt in der linken Spalte markiert. Standardmäßig »false«.

note: type: textblock
en: If set to a true value, the non-POD parts of the input file will be included in the output.  Useful for viewing code documented with POD blocks with the POD rendered and the code left intact.
de: Falls dies auf einen wahren Wert gesetzt wird, wird der nicht POD-Teil der Eingabedatei in der Ausgabe eingeschlossen. Nützlich, um Code, der mit POD-Blöcken dokumentiert ist, mit dem dargestellten POD und dem inktakt verbliebenen Code anzuschauen.

note: type: textblock
en: The number of spaces to indent regular text, and the default indentation for B<=over> blocks.  Defaults to 4.
de: Die Anzahl der Leerzeichen, um regulären Text einzurücken sowie die Vorgabe für die Einrückung für B<=over>-Blöcke. Standardmäßig 4.

note: type: textblock
en: If set to a true value, a blank line is printed after a B<=head1> heading.  If set to false (the default), no blank line is printed after B<=head1>, although one is still printed after B<=head2>.  This is the default because it's the expected formatting for manual pages; if you're formatting arbitrary text documents, setting this to true may result in more pleasing output.
de: Falls dies auf einen wahren Wert gesetzt wird, wird eine Leerzeile nach einer B<=head>-Zeile ausgegeben. Falls auf den Standardwert »false« gesetzt, wird keine Leerzeile nach B<=head1> ausgegeben, obwohl nach B<=head2> weiterhin eine ausgegeben wird. Dies ist die Vorgabe, da dies der bei Handbuchseiten erwarteten Formatierung entspricht; falls Sie beliebige Texte formatieren, könnte das Setzen auf »true« zu einer schöneren Ausgabe führen.

note: type: textblock
en: Sets the quote marks used to surround CE<lt>> text.  If the value is a single character, it is used as both the left and right quote; if it is two characters, the first character is used as the left quote and the second as the right quote; and if it is four characters, the first two are used as the left quote and the second two as the right quote.
de: Setzt die Anführungszeichen, die CE<lt>>-Text umfassen sollen. Falls der Wert ein einzelnes Zeichen ist, wird dieses sowohl als linkes als auch als rechtes Anführungszeichen verwandt. Falls es sich um zwei Zeichen handelt, wird das erste als öffnendes Anführungszeichen (links) und das zweite als schließendes Anführungszeichen (rechts) verwandt. Falls es sich um vier Zeichen handelt, werden die ersten zwei als öffnende und die anderen zwei als schließende Anführungszeichen verwandt.

note: type: textblock
en: This may also be set to the special value B<none>, in which case no quote marks are added around CE<lt>> text.
de: Dies kann auch auf den speziellen Wert B<none> gesetzt werden. In diesem Fall werden um CE<lt>>-Text keine Anführungszeichen gesetzt.

note: type: textblock
en: If set to a true value, Locale::Po4a::Pod will assume that each sentence ends in two spaces, and will try to preserve that spacing.  If set to false, all consecutive whitespace in non-verbatim paragraphs is compressed into a single space.  Defaults to true.
de: Falls dies auf einen wahren Wert gesetzt wird, wird Locale::Po4a::Pod annehmen, dass jeder Satz mit zwei Leerzeichen endet und versuchen, diese Leerzeichen zu erhalten. Falls auf »false« gesetzt, werden alle direkt aufeinander folgenden Leerzeichen in Absätzen, die nicht direkt ausgegeben werden, in ein einzelnes Leerzeichen zusammengefasst. Standardmäßig »true«.

note: type: textblock
en: The column at which to wrap text on the right-hand side.  Defaults to 76.
de: Die Spalte, an der Text auf der rechten Seite umgebrochen werden soll. Standardmäßig 76.

note: type: textblock
en: Locale::Po4a::RubyDoc -- Convert Ruby Document data from/to PO files
de: Locale::Po4a::RubyDoc - konvertiert Ruby Document-Daten von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::RubyDoc is a module to help the translation of documentation in the Ruby Document (RD) format (a language used to document Ruby) into other [human] languages.
de: Locale::Po4a::RubyDoc ist ein Modul, um bei der Übersetzung von Dokumentation in dem Ruby Document- (RD-)Format (einer Sprache zur Dokumentation von Ruby) in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: This module has been successfully tested on simple Ruby Document files covering a good part of the format syntax.
de: Dieses Modul wurde erfolgreich mit einfachen Ruby Document-Dateien getestet, die einen guten Anteil der Formatsyntax abdecken.

note: type: textblock
en: A known limitation is that it fails to properly recognize the stacked structure of input Ruby Document: this implies that when, for instance, an EnumListItem consists of more than one Block, only the first Block is actually recognized as EnumListItem, while the subsequent ones are considered just as TextBlocks...
de: Eine bekannte Einschränkung ist, dass es die geschichtete Struktur eines Eingabe-Ruby-Dokuments nicht korrekt erkennt: wenn beispielsweise ein EnumListItem aus mehr als einem Block besteht, impliziert dies, dass nur der erste Block tatsächlich als EnumListItem erkannt wird, während nachfolgende nur als TextBlocks betrachtet werden…

note: type: textblock
en: This module supports the following option:
de: Dieses Modul unterstützt die folgenden Optionen:

note: type: textblock
en: Handle files entirely made of Ruby Document formatted text (without any "=begin" line).
de: Handhabt Dateien, die komplett aus formatierten Ruby Document-Text bestehen (ohne eine »=begin«-Zeile).

note: type: textblock
en: By default, this module only handles Ruby Document formatted text between "=begin" and "=end" lines (hence ignoring, among other things, everything that precedes the first "=begin" line).
de: Standardmäßig handhabt dieses Modul nur formatierten Ruby Document-Text zwischen »=begin«- und »=end«-Zeilen (damit wird unter anderem alles vor der ersten »=begin«-Zeile ignoriert).

note: type: textblock
en: Parts of the code (such as many regular expressions) were adapted from the source of rdtool, under the terms of the GNU General Public License, version 2 or later.  These parts are originally:
de: Teile des Codes (wie beispielsweise viele reguläre Ausdrücke) wurden aus dem Quelltext von Rdtool unter den Bedingungen der GNU General Public License, Version 2 oder neuer, adaptiert. Diese Teile sind ursprünglich:

note: type: textblock
en: The initialize code was adapted from the source of Locale::Po4a::Text, under the terms of the GNU General Public License, version 2 or later.  This code was originally:
de: Der Initialisierungs-Code wurde aus dem Quelltext von Locale::Po4a::Text, unter den Bedingungen der GNU General Public License, Version 2 oder neuer, adaptiert. Dieser Code war ursprünglich:

note: type: textblock
en: Locale::Po4a::Sgml - convert SGML documents from/to PO files
de: Locale::Po4a::Sgml - konvertiert SGML-Dokumente von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Sgml is a module to help the translation of documentation in the SGML format into other [human] languages.
de: Locale::Po4a::Sgml ist ein Modul, um bei der Übersetzung von Dokumentation im SGML-Format in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: This module uses B<onsgmls>(1) to parse the SGML files. Make sure it is installed.  Also make sure that the DTD of the SGML files are installed in the system.
de: Dieses Module verwendet B<onsgmls>(1), um SGML-Dateien auszuwerten. Stellen Sie daher sicher, dass es installiert ist. Stellen Sie auch sicher, dass die DTD- der SGML-Dateien im System installiert sind.

note: type: textblock
en: Space separated list of keywords indicating which part you want to debug. Possible values are: tag, generic, entities and refs.
de: Durch Leerzeichen getrennte Liste von Schlüsselwörtern, die angeben, welchen Teil Sie auf Fehler prüfen wollen. Mögliche Werte sind: tag, generic, entities und refs.

note: type: textblock
en: Give more information about what's going on.
de: mehr Informationen darüber ausgeben, was vorgeht

note: type: textblock
en: Space separated list of extra tags (beside the DTD provided ones) whose content should form an extra msgid.
de: durch Leerzeichen getrennte Liste von zusätzlichen Markierungen (»Tags«) (neben denen von der DTD vorgegebenen), deren Inhalt eine zusätzliche »msgid« ergeben soll

note: type: textblock
en: Space separated list of extra tags (beside the DTD provided ones)  containing other tags, some of them being of category B<translate>.
de: durch Leerzeichen getrennte Liste von zusätzlichen Markierungen (»Tags«) (neben denen von der DTD vorgegebenen), die andere Markierungen enthalten, wobei einige in die Kategorie B<translate> fallen

note: type: textblock
en: Space separated list of tags which increase the indentation level.
de: durch Leerzeichen getrennte Liste von Markierungen (»Tags«), die die Einzugsstufe erhöhen

note: type: textblock
en: The layout within those tags should not be changed. The paragraph won't get wrapped, and no extra indentation space or new line will be added for cosmetic purpose.
de: Das Layout innerhalb dieser Markierungen (»Tags«) sollte nicht geändert werden. Der Absatz erfährt keinen Zeilenumbruch und keine zusätzliche Einrückung und keine zusätzliche Zeilen werden für kosmetische Zwecke eingefügt.

note: type: textblock
en: Tags not needing to be closed.
de: Markierungen (»Tags«), die nicht geschlossen werden müssen

note: type: textblock
en: Tags ignored and considered as plain char data by po4a. That is to say that they can be part of an msgid. For example, E<lt>bE<gt> is a good candidate for this category since putting it in the translate section would create msgids not being whole sentences, which is bad.
de: Markierungen (»Tags«), die von Po4a ignoriert und als reine Zeichendaten betrachtet werden. Das bedeutet, dass sie Teil einer Msgid sein können. Beispielsweise ist E<lt>bE<gt> ein guter Kandidat für diese Kategorie, da das Hinzufügen in den Abschnitt »translate« Msgids erzeugen würde, die keine kompletten Sätze sind, was nicht gut wäre.

note: type: textblock
en: A space separated list of attributes that need to be translated. You can specify the attributes by their name (for example, "lang"), but you can also prefix it with a tag hierarchy, to specify that this attribute will only be translated when it is into the specified tag. For example: E<lt>bbbE<gt>E<lt>aaaE<gt>lang specifies that the lang attribute will only be translated if it is in an E<lt>aaaE<gt> tag, which is in a E<lt>bbbE<gt> tag.  The tag names are actually regular expressions so you can also write things like E<lt>aaa|bbbbE<gt>lang to only translate lang attributes that are in an E<lt>aaaE<gt> or a E<lt>bbbE<gt> tag.
de: Eine durch Leerzeichen getrennte Liste von Attributen, die nicht übersetzt werden müssen. Sie können die Attribute mit ihrem Namen (beispielsweise »lang«) angeben, aber Sie können ihnen auch eine Markierungs- (»Tag«-)Hierarchie voranstellen, um anzugeben, dass dieses Attribut nur übersetzt wird, wenn es Teil der angegebenen Markierung ist. Beispielsweise spezifiziert E<lt>bbbE<gt>E<lt>aaaE<gt>lang, dass das Attribut »lang« nur übersetzt werden soll, wenn es Teil der Markierung E<lt>aaaE<gt>, die wiederum Teil der Markierung E<lt>bbbE<gt> ist. Die Namen der Markierungen sind eigentlich reguläre Ausdrücke, daher können Sie auch Formulierungen wie E<lt>aaa|bbbbE<gt>lang wählen, um das Attribut »lang« nur zu übersetzen, wenn es sich in der Markierung E<lt>aaaE<gt> oder E<lt>bbbE<gt> befindet.

note: type: textblock
en: A space separated list of attributes for which the translation must be qualified by the attribute name. Note that this setting automatically adds the given attribute into the 'attributes' list too.
de: Eine durch Leerzeichen getrennte Liste von Attributen, für die die Übersetzung über den Attributnamen qualifiziert werden muss. Beachten Sie, dass diese Einstellung das angegebene Attribut auch automatisch zu der Liste »attributes« hinzufügt.

note: type: textblock
en: Proceed even if the DTD is unknown or if onsgmls finds errors in the input file.
de: fortfahren, selbst falls die DTD unbekannt ist oder falls Onsgmls Fehler in der Eingabedatei findet

note: type: textblock
en: By default, msgids containing only one entity (like '&version;') are skipped for the translator comfort. Activating this option prevents this optimisation. It can be useful if the document contains a construction like "<title>&Aacute;</title>", even if I doubt such things to ever happen...
de: Standardmäßig werden Msgids, die nur eine Entität enthalten (wie »&version;«) für angenehmeres Übersetzen übersprungen. Durch Aktivierung dieser Option wird diese Optimierung vermieden. Dies könnte nützlich sein, falls das Dokumente Konstrukte wie »<title>&Aacute;</title>« enthält, selbst wenn ich daran zweifle, dass das jemals passieren wird …

note: type: textblock
en: Space separated list of entities that won't be inlined.  Use this option with caution: it may cause onsgmls (used internally) to add tags and render the output document invalid.
de: Durch Leerzeichen getrennte Liste, die nicht eingefügt wird. Benutzen Sie diese Option mit Vorsicht: Sie könnte Onsgmls (intern benutzt) veranlassen, Markierungen hinzuzufügen und das Ausgabedokument ungültig zu berechnen.

note: type: textblock
en: The result is perfect. I.e., the generated documents are exactly the same. But there are still some problems:
de: Das Ergebnis ist perfekt, d.h. die erstellten Dokumente sind identisch. Aber es gibt noch ein paar Probleme:

note: type: textblock
en: The error output of onsgmls is redirected to /dev/null by default, which is clearly bad. I don't know how to avoid that.
de: Die Fehlerausgabe von Onsgmls wird standardmäßig nach /dev/null umgeleitet. Dies ist eindeutig schlecht. Ich weiß nicht, wie ich das vermeiden kann.

note: type: textblock
en: The problem is that I have to "protect" the conditional inclusions (i.e. the C<E<lt>! [ %foo [> and C<]]E<gt>> stuff) from onsgmls. Otherwise onsgmls eats them, and I don't know how to restore them in the final document. To prevent that, I rewrite them to C<{PO4A-beg-foo}> and C<{PO4A-end}>.
de: Das Problem liegt darin, dass ich die bedingte Einbindung (d.h. das Zeug C<E<lt>! [ %foo [> und C<]]E<gt>>) vor Onsgmls »schützen« muss. Andernfalls futtert Onsgmls das auf und ich weiß nicht, wie ich das im letztendlichen Dokument wieder herstellen kann. Um das zu vermeiden, schreibe ich sie in C<{PO4A-beg-foo}> und C<{PO4A-end}> um.

note: type: textblock
en: The problem with this is that the C<{PO4A-end}> and such I add are invalid in the document (not in a E<lt>pE<gt> tag or so).
de: Das Problem dabei ist, dass C<{PO4A-end}> und so etwas im Dokument ungültig sind (nicht in einer E<lt>pE<gt>-Markierung oder so).

note: type: textblock
en: If you want to view the onsgmls output, just add the following to your command line (or po4a configuration line):
de: Falls Sie die Onsgmls-Ausgabe sehen wollen, fügen Sie einfach Folgendes zu Ihrer Befehlszeile (oder der Po4a-Konfigurationszeile) hinzu:

note: type: textblock
en: It does work only with the DebianDoc and DocBook DTD. Adding support for a new DTD should be very easy. The mechanism is the same for every DTD, you just have to give a list of the existing tags and some of their characteristics.
de: Es funktioniert nur mit der DebianDoc- und DocBook-DTD. Hinzunahme der Unterstützung für eine neue DTD sollte sehr leicht sein. Der Mechanismus ist für alle DTD identisch, Sie müssen nur eine Liste der existierenden Markierungen und einige ihrer Charakteristika angeben.

note: type: textblock
en: I agree, this needs some more documentation, but it is still considered as beta, and I hate to document stuff which may/will change.
de: Ich stimme zu, dass dies weitere Dokumentation benötigt, aber es wird immer noch als Beta betrachtet und ich hasse es, Zeug zu dokumentieren, dass sich noch ändern kann oder wird.

note: type: textblock
en: Warning, support for DTDs is quite experimental. I did not read any reference manual to find the definition of every tag. I did add tag definition to the module 'till it works for some documents I found on the net. If your document use more tags than mine, it won't work. But as I said above, fixing that should be quite easy.
de: Warnung: Die Unterstützung für DTDs ist noch recht experimentell. Ich habe kein Referenzhandbuch gelesen, um die Definition jeder Markierung herauszufinden. Ich habe die Makierungsdefinitionen zum Modul hinzugefügt, bis es für einige Dokumente funktionierte, die ich im Netz fand. Falls Ihr Dokument mehr Markierungen verwendet als meins, wird es nicht funktionieren. Aber wie oben geschrieben, sollte das leicht zu beheben sein.

note: type: textblock
en: I did test DocBook against the SAG (System Administrator Guide) only, but this document is quite big, and should use most of the DocBook specificities.
de: Ich habe DocBook nur mit der SAG (System Administrator Guide) getestet, allerdings ist dieses Dokument sehr groß und sollte den Großteil der DocBook-Spezialitäten verwenden.

note: type: textblock
en: For DebianDoc, I tested some of the manuals from the DDP, but not all yet.
de: Für DebianDoc habe ich einige der Handbücher vom DDP getestet, aber noch nicht alle.

note: type: textblock
en: In case of file inclusion, string reference of messages in PO files (i.e. lines like C<#: en/titletoc.sgml:9460>) will be wrong.
de: Im Falle von Dateieinbindungen werden Zeichenkettenreferenzen von Meldungen in PO-Dateien (d.h. Zeilen der Art C<#: en/titletoc.sgml:9460>) falsch sein.

note: type: textblock
en: This is because I preprocess the file to protect the conditional inclusion (i.e. the C<E<lt>! [ %foo [> and C<]]E<gt>> stuff) and some entities (like &version;) from onsgmls because I want them verbatim to the generated document. For that, I make a temp copy of the input file and do all the changes I want to this before passing it to onsgmls for parsing.
de: Dies rührt daher, dass die Datei vorbearbeitet wird, um die bedingten Einbindungen (d.h. das C<E<lt>! [ %foo [> und C<]]E<gt>> Zeug) und einige Entitäten (wie &version) vor Onsgmls zu schützen, da ich sie unverändert im automatisch erstellten Dokument bekommen möchte. Daher wird eine temporäre Kopie der Eingabedatei angelegt und alle Änderungen werden daran vorgenommen, bevor sie an Onsgmls zur Auswertung übergeben wird.

note: type: textblock
en: So that it works, I replace the entities asking for a file inclusion by the content of the given file (so that I can protect what needs to be in a subfile also). But nothing is done so far to correct the references (i.e., filename and line number) afterward. I'm not sure what the best thing to do is.
de: Damit dies funktioniert, werden die Entitäten, die eine Dateieinbindung durch den Inhalt der angegebenen Datei erbitten, ersetzt (so dass auch geschützt werden kann, was in einer Unterdatei ist). Allerdings erfolgt derzeit anschließend nichts, um die Referenzen zu schützen (d.h. Dateiname und Zeilennummer). Mir ist nicht klar, was hier das beste Vorgehen ist.

note: type: textblock
en: This module is an adapted version of sgmlspl (SGML postprocessor for the ONSGMLS parser) which was:
de: Dieses Modul ist eine angepasste Version von Sgmlspl (SGML postprocessor for the ONSGMLS parsers), für den galt:

note: type: textblock
en: The adaptation for po4a was done by:
de: Die Anpassung für Po4a wurde erledigt durch:

note: type: textblock
en: Locale::Po4a::TeX - convert TeX documents and derivatives from/to PO files
de: Locale::Po4a::TeX - konvertiert TeX-Dokumente und Derivate von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::TeX is a module to help the translation of TeX documents into other [human] languages. It can also be used as a base to build modules for TeX-based documents.
de: Locale::Po4a::TeX ist ein Modul, um bei der Übersetzung von TeX-Dokumenten in andere [natürliche] Sprachen zu helfen. Es kann auch als Grundlage für die Entwicklung von Modulen für TeX-basierte Dokumente verwandt werden.

note: type: textblock
en: Users should probably use the LaTeX module, which inherits from the TeX module and contains the definitions of common LaTeX commands.
de: Benutzer sollten wahrscheinlich das LaTeX-Modul verwenden, das vom TeX-Modul abgeleitet ist und die Definitionen von typischen LaTeX-Befehlen enthält.

note: type: =head1
en: TRANSLATING WITH PO4A::TEX
de: ÜBERSETZEN MIT PO4A::TEX

note: type: textblock
en: This module can be used directly to handle generic TeX documents.  This will split your document in smaller blocks (paragraphs, verbatim blocks, or even smaller like titles or indexes).
de: Dieses Modul kann direkt verwandt werden, um mit generischen TeX-Dokumenten umzugehen. Es wird Ihr Dokument in kleinere Blöcke (Absätze, »verbatim«-Blöcke oder sogar kleinere wie Titel oder Indices) teilen.

note: type: textblock
en: There are some options (described in the next section) that can customize this behavior.  If this doesn't fit to your document format you're encouraged to write your own derivative module from this, to describe your format's details.  See the section B<WRITING DERIVATIVE MODULES> below, for the process description.
de: Es gibt einige Optionen (die im nächsten Abschnitt beschrieben werden), die dieses Verhalten anpassen lassen. Falls dies nicht auf Ihr Dokumentenformat passt, ermutigen wir Sie, Ihr eigenes, von diesem Modul abgeleitetes Modul zu schreiben, um die Details Ihres Formats zu beschreiben. Lesen Sie den Abschnitt B<SCHREIBEN ABGELEITETER MODULE> weiter unten für die Beschreibung des Prozesses.

note: type: textblock
en: This module can also be customized by lines starting with "% po4a:" in the TeX file. This process is described in the B<INLINE CUSTOMIZATION> section.
de: Dieses Modul kann auch durch Zeilen in der TeX-Datei, die mit »% po4a:« beginnen, angepasst werden. Dieser Prozess wird im Abschnitt B<ANPASSUNGEN IM DOKUMENT> beschrieben.

note: type: textblock
en: Comma-separated list of environments which should not be re-wrapped.
de: durch Kommata getrennte Liste von Umgebungen, die nicht neu umgebrochen werden sollen

note: type: textblock
en: Note that there is a difference between verbatim and no_wrap environments.  There is no command and comments analysis in verbatim blocks.
de: Beachten Sie, dass es zwischen den Umgebungen »verbatim« und »no_wrap« einen Unterschied gibt. In »verbatim«-Blöcken erfolgt keine Befehls- und Inhaltsanalyse.

note: type: textblock
en: If this environment was not already registered, po4a will consider that this environment does not take any parameters.
de: Falls diese Umgebung noch nicht registriert war, wird Po4a annehmen, dass diese Umgebung keine Parameter erwartet.

note: type: textblock
en: Colon-separated list of files that should not be included by \input and \include.
de: durch Doppelpunkte getrennte Liste von Dateien, die nicht von \input und \include eingeschlossen werden sollten

note: type: textblock
en: Comma-separated list of environments which should be taken as verbatim.
de: durch Kommata getrennte Liste von Umgebungen, die »verbatim« angenommen werden sollten

note: type: textblock
en: Use these options to override the default behavior of the defined commands.
de: Verwenden Sie diese Optionen, um das Standardverhalten der definierten Befehle zu überschreiben.

note: type: textblock
en: The TeX module can be customized with lines starting by B<% po4a:>.  These lines are interpreted as commands to the parser.  The following commands are recognized:
de: Das TeX-Modul kann durch Zeilen, die mit B<% po4a:> beginnen, angepasst werden. Diese Zeilen werden vom Parser als Befehle interpretiert. Die folgenden Befehle werden erkannt:

note: type: =item
en: B<% po4a: command> I<command1> B<alias> I<command2>
de: B<% po4a: command> I<Befehl1> B<alias> I<Befehl2>

note: type: textblock
en: Indicates that the arguments of the I<command1> command should be treated as the arguments of the I<command2> command.
de: zeigt an, dass die Argumente des Befehls I<Befehl1> als Argumente des Befehls I<Befehl2> behandelt werden sollen

note: type: =item
en: B<% po4a: command> I<command1> I<parameters>
de: B<% po4a: command> I<Befehl1> I<Parameter>

note: type: textblock
en: This describes in detail the parameters of the I<command1> command.  This information will be used to check the number of arguments and their types.
de: Dies beschreibt die Parameter des Befehls I<Befehl1> im Detail. Diese Information wird zur Überprüfung der Anzahl der Argumente und ihrer Typen verwandt.

note: type: textblock
en: You can precede the I<command1> command by
de: Sie können Folgendes dem Befehl I<Befehl1> voranstellen:

note: type: =item
en: an asterisk (B<*>)
de: einen Stern (B<*>)

note: type: textblock
en: po4a will extract this command from paragraphs (if it is located at the beginning or the end of a paragraph).  The translators will then have to translate the parameters that are marked as translatable.
de: Po4a wird diesen Befehl aus Absätzen herauslesen (falls er sich am Anfang oder Ende eines Absatzes befindet). Der Übersetzer muss dann die Parameter übersetzen, die als übersetzbar markiert sind.

note: type: =item
en: a plus (B<+>)
de: ein Plus (B<+>)

note: type: textblock
en: As for an asterisk, the command will be extracted if it appear at an extremity of a block, but the parameters won't be translated separately.  The translator will have to translate the command concatenated to all its parameters.  This keeps more context, and is useful for commands with small words in parameter, which can have multiple meanings (and translations).
de: Wie bei einem Stern wird der Befehl herausgelesen, falls er an den Endpunkten eines Blocks erscheint, aber die Parameter werden nicht separat übersetzt. Der Übersetzer muss den Befehl, zusammengesetzt mit allen seinen Parametern, übersetzen. Dies erhält mehr Kontext und ist für Befehle nützlich, die kleine Wörter in ihren Parametern enthalten, die mehrere Bedeutungen (und Übersetzungen) haben können.

note: type: textblock
en: Note: In this case you don't have to specify which parameters are translatable, but po4a must know the type and number of parameters.
de: Hinweis: In diesem Fall müssen Sie nicht angeben, welche Parameter übersetzbar sind, aber Po4a muss die Anzahl und den Typ der Parameter wissen.

note: type: =item
en: a minus (B<->)
de: ein Minus (B<->)

note: type: textblock
en: In this case, the command won't be extracted from any block.  But if it appears alone on a block, then only the parameters marked as translatable will be presented to the translator.  This is useful for font commands.  These commands should generally not be separated from their paragraph (to keep the context), but there is no reason to annoy the translator with them if a whole string is enclosed in such a command.
de: In diesem Fall wird der Befehl aus keinem Block herausgelesen. Falls er aber alleine in einem Block erscheint, werden nur die als übersetzbar markierten Parameter dem Übersetzer angeboten. Dies ist für Schriftsatzbefehle nützlich. Diese Befehle sollten im Allgemeinen nicht von ihrem Absatz getrennt werden (um den Kontext zu erhalten), aber es gibt keinen Grund, den Übersetzer damit zu belästigen, falls die gesamte Zeichenkette in einem solchen Befehl eingeschlossen ist.

note: type: verbatim
en: The I<parameters> argument is a set of [] (to indicate an optional
    argument) or {} (to indicate a mandatory argument).
    You can place an underscore (_) between these brackets to indicate that
    the parameter must be translated. For example:
     % po4a: command *chapter [_]{_}
de: Das Argument I<Parameter> ist ein Satz von [] (um ein optionales Argument
    anzuzeigen) oder {} (um ein verpflichtendes Argument anzuzeigen).
    Sie können einen Unterstrich (_) zwischen diese Klammern setzen, um anzugeben,
    dass der Parameter übersetzt werden muss. Beispiel:
     % po4a: command *chapter [_]{_}

note: type: verbatim
en: This indicates that the chapter command has two parameters: an optional
    (short title) and a mandatory one, which must both be translated.
    If you want to specify that the href command has two mandatory parameters,
    that you don't want to translate the URL (first parameter), and that you
    don't want this command to be separated from its paragraph (which allow
    the translator to move the link in the sentence), you can use:
     % po4a: command -href {}{_}
de: Dies zeigt an, dass der Befehl »chapter« zwei Parameter erwartet: einen
    optionalen (den kurzen Titel) und einen verpflichtenden, wobei beide
    übersetzt werden müssen. Falls Sie angeben möchten, dass der Befehl »href«
    zwei verpflichtende Parameter hat, dass Sie die URL nicht übersetzen möchten
    (den ersten Parameter) und dass Sie nicht möchten, dass der Befehl von seinem
    Absatz getrennt wird (was dem Übersetzer erlaubt, den Link im Satz zu
    verschieben), können Sie folgendes verwenden:
     % po4a: command -href {}{_}

note: type: textblock
en: In this case, the information indicating which arguments must be translated is only used if a paragraph is only composed of this href command.
de: In diesem Fall wird die Information, welche Argumente übersetzt werden müssen, nur verwandt, falls ein Absatz nur aus diesem href-Befehl besteht.

note: type: =item
en: B<% po4a: environment> I<env> I<parameters>
de: B<% po4a: environment> I<Umgeb> I<Parameter>

note: type: verbatim
en: This defines the parameters accepted by the I<env> environment and specifies the ones to be translated.
    This information is later used to check the number of arguments of the
    \begin command.
    The syntax of the I<parameters> argument is the same as described for the
    others commands.
    The first parameter of the \begin command is the name of the environment.
    This parameter must not be specified in the list of parameters. Here are
    some examples:
     % po4a: environment multicols {}
     % po4a: environment equation
de: Dies definiert die von der Umgebung I<Umgeb> akzeptierten Parameter und legt
    die zu übersetzenden fest. Diese Information wird später zum Überprüfen der
    Anzahl der Argumente des \begin-Befehls verwandt.
    Die Syntax ist die gleiche, wie sie für die anderen Befehle beschrieben ist.
    Der erste Parameter des Befehls \begin ist der Name der Umgebung. Dieser
    Parameter darf nicht in der Liste der Parameter spezifziert werden. Einige
    Beispiele:
     % po4a: environment multicols {}
     % po4a: environment equation

note: type: textblock
en: As for the commands, I<env> can be preceded by a plus (+) to indicate that the \begin command must be translated with all its arguments.
de: Wie bei den Befehlen kann I<Umgeb> ein Plus (+) vorangestellt werden, um anzuzeigen, dass der Befehl \begin mit allen seinen Argumenten übersetzt werden muss.

note: type: =item
en: B<% po4a: separator> I<env> B<">I<regex>B<">
de: B<% po4a: separator> I<Umgeb> B<">I<RegAus>B<">

note: type: textblock
en: Indicates that an environment should be split according to the given regular expression.
de: zeigt an, dass die Umgebung entsprechend des übergebenen regulären Ausdruckes aufgeteilt werden soll

note: type: textblock
en: The regular expression is delimited by quotes.  It should not create any back-reference.  You should use (?:) if you need a group.  It may also need some escapes.
de: Der reguläre Ausdruck wird durch Anführungszeichen begrenzt. Er sollte keine Rückreferenzen erstellen. Sie sollten (?:) verwenden, falls Sie Gruppen benötigen. Es könnte auch notwendig sein, Teile zu schützen.

note: type: textblock
en: For example, the LaTeX module uses the "(?:&|\\\\)" regular expression to translate separately each cell of a table (lines are separated by '\\' and cells by '&').
de: Beispielsweise verwendet das LaTeX-Modul den regulären Ausdruck »(?:&|\\\\)«, um jede Zelle einer Tabelle zu trennen (Zeilen werden durch »\\«, Zellen durch »&« getrennt).

note: type: textblock
en: The notion of environment is expanded to the type displayed in the PO file.  This can be used to split on "\\\\" in the first mandatory argument of the title command.  In this case, the environment is title{#1}.
de: Der Begriff der Umgebung wird auf den in der PO-Datei angezeigten Typ erweitert. Dies kann benutzt werden, um auf »\\\\« im ersten zwingenden Argument des Titelbefehls zu unterteilen. In diesem Fall ist die Umgebung Title{#1}.

note: type: =item
en: B<% po4a: verbatim environment> I<env>
de: B<% po4a: verbatim environment> I<Umgeb>

note: type: textblock
en: Indicate that I<env> is a verbatim environment.  Comments and commands will be ignored in this environment.
de: Zeigt an, dass I<Umgeb> eine »verbatim«-Umgebung ist. Kommentare und Befehle werden innerhalb dieser Umgebung ignoriert.

note: type: =head1
en: WRITING DERIVATE MODULES
de: SCHREIBEN ABGELEITETER MODULE

note: type: textblock
en: Add a string as a comment to be added around the next translated element.  This is mostly useful to the texinfo module, as comments are automatically handled in TeX.
de: Fügt einen Zeichensatz als Kommentar hinzu, der um das nächste übersetzte Element herum hinzugefügt werden soll. Dies ist hauptsächlich für das Texinfo-Modul nützlich, da Kommentare in TeX automatisch gehandhabt werden.

note: type: textblock
en: Wrapper around Transtractor's translate, with pre- and post-processing filters.
de: Wrapper um die Übersetzung von TransTractor, mit Vor- und Nachverarbeitungsfiltern.

note: type: textblock
en: Comments of a paragraph are inserted as a PO comment for the first translated string of this paragraph.
de: Kommentare eines Absatzes werden als PO-Kommentare bei der ersten übersetzten Zeichenkette dieses Absatzes eingefügt.

note: type: textblock
en: This function returns:
de: Diese Funktion liefert folgendes zurück:

note: type: =item
en: A command name
de: Einen Befehlsnamen

note: type: textblock
en: If no command is found at the beginning of the given buffer, this string will be empty.  Only commands that can be separated are considered.  The %separated_command hash contains the list of these commands.
de: Falls kein Befehl am Anfang des Puffers gefunden wird, wird diese Zeichenkette leer sein. Nur Befehle, die getrennt werden können, werden betrachtet. Der Hash %separated_command enthält eine Liste dieser Befehle.

note: type: =item
en: A variant
de: Eine Variante

note: type: textblock
en: This indicates if a variant is used.  For example, an asterisk (*) can be added at the end of sections command to specify that they should not be numbered.  In this case, this field will contain "*".  If there is no variant, the field is an empty string.
de: Dies zeigt an, ob eine Variante benutzt wurde. Beispielsweise kann ein Stern (*) am Ende eines »section«-Befehls verwendet werden, um anzugeben, dass diese nicht nummeriert werden sollen. In diesem Fall wird dieses Feld »*« enthalten. Falls es keine Variante gibt, enthält dieses Feld die leere Zeichenkette.

note: type: =item
en: An array of tuples (type of argument, argument)
de: Ein Feld von Tupeln (Argumenttyp, Argument)

note: type: textblock
en: The type of argument can be either '{' (for mandatory arguments) or '[' (for optional arguments).
de: Der Typ des Arguments kann entweder »{« (für verpflichtende Argumente) oder »[« (für optionale Argumente) sein.

note: type: =item
en: The remaining buffer
de: Der verbleibende Puffer

note: type: textblock
en: The rest of the buffer after the removal of this leading command and its arguments.  If no command is found, the original buffer is not touched and returned in this field.
de: Der Rest des Puffers nach der Entfernung des führenden Befehls und seiner Argumente. Falls kein Befehl gefunden wird, wird der ursprüngliche Puffer nicht angerührt und in diesem Feld zurückgeliefert.

note: type: textblock
en: The same as B<get_leading_command>, but for commands at the end of a buffer.
de: identisch zu B<get_leading_command>, allerdings für Befehle am Ende des Puffers

note: type: textblock
en: Recursively translate a buffer by separating leading and trailing commands (those which should be translated separately) from the buffer.
de: rekursives Übersetzen eins Puffers durch Trennung von führenden and abschließenden Befehlen (solche, die separat übersetzt werden sollten) aus dem Puffer

note: type: textblock
en: If a function is defined in %translate_buffer_env for the current environment, this function will be used to translate the buffer instead of translate_buffer().
de: Falls eine Funktion in %translate_buffer_env  für die aktuelle Umgebung definiert ist, wird diese Funktion zur Übersetzung des Puffers (statt translate_buffer()) verwandt.

note: type: textblock
en: Overloads Transtractor's read().
de: überlädt Transtractors read().

note: type: textblock
en: Recursively read a file, appending included files which are not listed in the @exclude_include array.  Included files are searched using the B<kpsewhich> command from the Kpathsea library.
de: Liest rekursiv eine Datei und hängt eingebundene Dateien, die nicht im Feld @exclude_include aufgeführt sind, an. Eingebundene Dateien werden mittels des Befehls B<kpsewhich> aus der Bibliothek Kpathsea gesucht.

note: type: textblock
en: Except from the file inclusion part, it is a cut and paste from Transtractor's read.
de: Abgesehen von dem Teil der Einbindung von Dateien ist es eine eingefügte Kopie aus Transtractors read.

note: type: textblock
en: Subroutine for parsing a file with po4a directives (definitions for new commands).
de: Subroutine zum Auswerten einer Datei mit Po4a-Direktiven (Definitionen für neue Befehle).

note: type: textblock
en: Parse a definition line of the form "% po4a: ".
de: eine Definitionszeile der Form »% po4a: « auswerten

note: type: textblock
en: See the B<INLINE CUSTOMIZATION> section for more details.
de: Lesen Sie den Abschnitt B<ANPASSUNGEN IM DOKUMENT> für weitere Details.

note: type: =head1
en: INTERNAL FUNCTIONS used to write derivative parsers
de: INTERNE FUNKTIONEN, die zum Schreiben abgeleiteter Parser verwendet werden

note: type: textblock
en: Command and environment functions take the following arguments (in addition to the $self object):
de: Befehls- und Umgebungsfunktionen erwarten die folgenden Argumente (zusätzlich zum Objekt $self):

note: type: =item
en: An array of (type, argument) tuples
de: Ein Feld von (Typ, Argument)-Tupeln

note: type: =item
en: The current environment
de: Die aktuelle Umgebung

note: type: textblock
en: The first 3 arguments are extracted by get_leading_command or get_trailing_command.
de: Die ersten drei Argumente werden durch get_leading_command oder get_trailing_command herausgelöst.

note: type: textblock
en: Command and environment functions return the translation of the command with its arguments and a new environment.
de: Befehls- und Umgebungsfunktionen liefern die Übersetzung des Befehls mit seinen Argumenten und eine neue Umgebung zurück.

note: type: textblock
en: Environment functions are called when a \begin command is found. They are called with the \begin command and its arguments.
de: Umgebungsfunktionen werden aufgerufen, wenn ein \begin gefunden wird. Sie werden mit dem Befehl \begin und seinen Argumenten aufgerufen.

note: type: textblock
en: The TeX module only proposes one command function and one environment function: generic_command and generic_environment.
de: Das TeX-Modul schlägt nur eine Befehlsfunktion und eine Umgebungsfunktion vor: generic_command und generic_environment.

note: type: verbatim
en: generic_command uses the information specified by
    register_generic_command or by adding definition to the TeX file:
     % po4a: command I<command1> I<parameters>
de: generic_command verwendet die durch register_generic_command spezifizierte
    Information oder durch Hinzufügen von Definitionen zu der TeX-Datei:
     % po4a: command I<Befehl> I<Parameter>

note: type: verbatim
en: generic_environment uses the information specified by
    register_generic_environment or by adding definition to the TeX file:
     % po4a: environment I<env> I<parameters>
de: generic_environment verwendet die durch register_generic_environment
    spezifizierte Information oder durch Hinzufügen von Definitionen zu der
    TeX-Datei:
     % po4a: environment I<Umgeb> I<Parameter>

note: type: textblock
en: Both functions will only translate the parameters that were specified as translatable (with a '_').  generic_environment will append the name of the environment to the environment stack and generic_command will append the name of the command followed by an identifier of the parameter (like {#7} or [#2]).
de: Beide Funktionen werden nur die als übersetzbar (mit einem »_«) angegebenen Parameter übersetzen. generic_environment wird den Namen der Umgebung an den Umgebungsstapel anhängen und generic_command wird den Namen des Befehls gefolgt von einer Kennung des Parameters (wie{#7} oder [#2]) anhängen.

note: type: textblock
en: This module needs more tests.
de: Dieses Modul benötigt weitere Tests.

note: type: textblock
en: It was tested on a book and with the Python documentation.
de: Es wurde mit einem Buch und mit der Python-Dokumentation getestet.

note: type: =head1
en: TODO LIST
de: TODO-LISTE

note: type: =item
en: Automatic detection of new commands
de: Automatische Erkennung neuer Befehle

note: type: textblock
en: The TeX module could parse the newcommand arguments and try to guess the number of arguments, their type and whether or not they should be translated.
de: Das TeX-Modul könnte die »newcommand«-Argumente auswerten und versuchen, die Anzahl der Argumente, ihren Typ und ob (oder ob nicht) sie übersetzt werden sollten, zu raten.

note: type: =item
en: Translation of the environment separator
de: Übersetzung des Umgebungstrenners

note: type: textblock
en: When \item is used as an environment separator, the item argument is attached to the following string.
de: Wird \item als Trenner für Umgebungen verwandt, dann wird das Argument von »item« an die folgenden Zeichenkette angefügt.

note: type: =item
en: Some commands should be added to the environment stack
de: Einige Befehle sollten dem Umgebungsstapel hinzugefügt werden.

note: type: =item
en: Others
de: Weitere

note: type: textblock
en: Various other points are tagged TODO in the source.
de: Verschiedene andere Punkte werden in der Quelle als TODO gekennzeichnet.

note: type: =head1
en: KNOWN BUGS
de: BEKANNTE FEHLER

note: type: textblock
en: Various points are tagged FIXME in the source.
de: Verschiedene Punkte werden in der Quelle als FIXME gekennzeichnet.

note: type: textblock
en: Locale::Po4a::Texinfo - convert Texinfo documents and derivates from/to PO files
de: Locale::Po4a::Texinfo - konvertiert Texinfo-Dokumente und -Derivate von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Texinfo is a module to help the translation of Texinfo documents into other [human] languages.
de: Locale::Po4a::Texinfo ist ein Modul, um bei der Übersetzung von Texinfo-Dokumenten in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: This module contains the definitions of common Texinfo commands and environments.
de: Dieses Modul enthält die Definitionen von allgemeinen Texinfo-Befehlen und -Umgebungen.

note: type: textblock
en: Only the comments starting with 'TRANSLATORS' are added to the PO files to guide the translators.
de: Nur die mit »TRANSLATORS« beginnenden Kommentare werden zu den PO-Dateien als Anleitung für die Übersetzer hinzugefügt.

note: type: textblock
en: Locale::Po4a::Text - convert text documents from/to PO files
de: Locale::Po4a::Text - konvertiert Textdokumente von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Text is a module to help the translation of text documents into other [human] languages.
de: Locale::Po4a::Text ist ein Modul, um bei der Übersetzung von Textdokumenten in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: Paragraphs are split on empty lines (or lines containing only spaces or tabulations).
de: Absätze werden durch Leerzeilen getrennt (oder Zeilen, die nur Leerzeichen und Tabulatoren enthalten).

note: type: textblock
en: If a paragraph contains a line starting by a space (or tabulation), this paragraph won't be rewrapped.
de: Falls ein Absatz eine Zeile enthält, die mit einem Leerzeichen (oder Tabulator) anfängt, wird dieser Absatz nicht neu umgebrochen.

note: type: textblock
en: Treat paragraphs that look like a key value pair as verbatim (with the no-wrap flag in the PO file).  Key value pairs are defined as a line containing one or more non-colon and non-space characters followed by a colon followed by at least one non-space character before the end of the line.
de: Absätze, die wie ein Schlüssel-Wert-Paar aussehen, werden als wörtlich behandelt (mit dem Schalter »no-wrap« in der PO-Datei). Schlüssel-Wert-Paare werden als Zeile definiert, die eines oder mehr Zeichen enthalten, die weder Doppelpunkt noch Leerraumzeichen sind, gefolgt von einem Doppelpunkt, gefolgt von mindestens einem Zeichen, das sich von einem Leerraumzeichen unterscheidet, vor dem Ende der Zeile.

note: type: textblock
en: Deactivate the detection of bullets.
de: Deaktiviert die Erkennung von Aufzählungszeichen

note: type: textblock
en: By default, when a bullet is detected, the bullet paragraph is not considered as a verbatim paragraph (with the no-wrap flag in the PO file). Instead, the corresponding paragraph is rewrapped in the translation.
de: Standardmäßig wird bei der Erkennung von Aufzählungszeichen der betroffene Absatz nicht als wörtlicher Absatz betrachtet (mit dem Schalter »no-wrap« in der PO-Datei). Stattdessen wird der entsprechende Absatz in der Übersetzung neu umgebrochen.

note: type: =item
en: B<tabs=>I<mode>
de: B<tabs=>I<Modus>

note: type: textblock
en: Specify how tabulations shall be handled. The I<mode> can be any of:
de: Regelt den Umgang mit Tabulatoren. I<Modus> kann eines der folgenden sein:

note: type: textblock
en: Lines with tabulations introduce breaks in the current paragraph.
de: Zeilen mit Tabulatoren leiten Umbrüche im aktuellen Absatz ein.

note: type: textblock
en: Paragraph containing tabulations will not be re-wrapped.
de: Zeilen mit Tabulatoren werden nicht neu umgebrochen.

note: type: textblock
en: By default, tabulations are considered as spaces.
de: Standardmäßig werden Tabulatoren als Leerzeichen betrachtet.

note: type: =item
en: B<breaks=>I<regex>
de: B<breaks=>I<regAusd>

note: type: textblock
en: A regular expression matching lines which introduce breaks.  The regular expression will be anchored so that the whole line must match.
de: Ein regulärer Ausdruck, der auf Zeilen passt, die Umbrüche einleiten. Der reguläre Ausdruck wird so verankert, dass die gesamte Zeile passen muss.

note: type: textblock
en: Handle the header and footer of released versions, which only contain non translatable information.
de: Umgang mit den Kopf- und Fußzeilen von veröffentlichten Versionen, die nur nicht übersetzbare Informationen enthalten.

note: type: textblock
en: Handle the fortunes format, which separate fortunes with a line which consists in '%' or '%%', and use '%%' as the beginning of a comment.
de: Umgang mit dem »fortunes«-Format, das Glückssprüche (»fortunes«) mit einer Zeile trennt, die nur aus »%« oder aus »%%« besteht und »%%« als Einleitung für Kommentare verwendet.

note: type: textblock
en: Handle some special markup in Markdown-formatted texts.
de: Umgang mit bestimmter spezieller Auszeichnung in Markdown-formatierten Texten.

note: type: =item
en: B<yfm_keys> (markdown-only)
de: B<yfm_keys> (nur Markdown)

note: type: =item
en: B<yfm_lenient> (markdown only)
de: B<yfm_lenient> (nur Markdown)

note: type: textblock
en: Allow the YAML Front Matter parser to fail on malformated headers. This is particularly helpful when your file starts with a horizontal ruler instead of a YAML Front Matter, but you insist on using three dashes only for your ruler.
de: Erlaubt dem YAML-Titelei-Auswerter, bei ungültigen Kopfzeilen fehlzuschlagen. Dies ist besonders hilfreich, wenn Ihre Datei mit einem horizontalen Linie statt einer YAML-Titelei beginnt, aber Sie darauf bestehen, nur drei Gedankenstriche für ihre Linie zu verwenden.

note: type: =item
en: B<yfm_skip_array> (markdown-only)
de: B<yfm_skip_array> (nur Markdown)

note: type: =item
en: B<control>[B<=>I<taglist>]
de: B<control>[B<=>I<Markierungen-Liste>]

note: type: textblock
en: Handle control files.  A comma-separated list of tags to be translated can be provided.
de: Handhabt Steuerdateien. Es kann eine durch Kommata getrennte Liste von Markierungen, die übersetzt werden sollen, bereitgestellt werden.

note: type: textblock
en: Prevent po4a from wrapping any lines. This means that every content is handled verbatim, even simple paragraphs.
de: Verhindert, dass Po4a irgendwelche Zeilen umbricht. Das bedeutet, dass jeder Inhalt wortgetreu verarbeitet wird, selbst einfache Absätze.

note: type: textblock
en: Tested successfully on simple text files and NEWS.Debian files.
de: Erfolgreich bei einigen einfachen Textdateien und News.Debian-Dateien getestet.

note: type: textblock
en: Locale::Po4a::TransTractor - generic trans(lator ex)tractor.
de: Locale::Po4a::TransTractor - generischer Übersetzungs-Ausleser

note: type: textblock
en: This class is the ancestor of every po4a parser used to parse a document, to search translatable strings, to extract them to a PO file and to replace them by their translation in the output document.
de: Diese Klasse ist Vorfahr jedes Po4a-Parsers. Sie wird zum Auswerten eines Dokuments, zur Suche nach übersetzbaren Zeichenketten, zum Auslesen in eine PO-Datei und zur Ersetzung durch ihre Übersetzung im Ausgabedokument, verwandt.

note: type: textblock
en: More formally, it takes the following arguments as input:
de: Oder formaler, sie erwartet die folgenden Argumente als Eingabe:

note: type: textblock
en: a document to translate;
de: ein zu übersetzendes Dokument

note: type: textblock
en: a PO file containing the translations to use.
de: eine PO-Datei, die die zu verwendende Übersetzung enthält.

note: type: textblock
en: As output, it produces:
de: Als Ausgabe produziert sie:

note: type: textblock
en: another PO file, resulting of the extraction of translatable strings from the input document;
de: eine weitere PO-Datei, die aus der Auslösung der übersetzbaren Zeichenketten aus dem Eingabedokument entsteht

note: type: textblock
en: a translated document, with the same structure than the one in input, but with all translatable strings replaced with the translations found in the PO file provided in input.
de: ein übersetztes Dokument mit der gleichen Struktur wie das der Eingabe, bei der aber alle übersetzbaren Zeichenketten mit den in der als Eingabe bereitgestellten PO-Datei gefundenen Übersetzungen ersetzt wurden.

note: type: textblock
en: Here is a graphical representation of this:
de: Dies ist eine graphische Darstellung davon:

note: type: verbatim
en:    Input document --\                             /---> Output document
                         \                           /       (translated)
                          +-> parse() function -----+
                         /                           \
       Input PO --------/                             \---> Output PO
                                                             (extracted)
de:    Eingabedokument --\                             /---> Ausgabedokument
                          \                           /        (übersetzt)
                           +-> parse()-Funktion -----+
                          /                           \
       Eingabe-PO -------/                             \---> Ausgabe-PO
                                                             (herausgelöst)

note: type: =head1
en: FUNCTIONS YOUR PARSER SHOULD OVERRIDE
de: FUNCTIONEN, DIE IHR PARSER ÜBERSCHREIBEN SOLLTE

note: type: textblock
en: This is where all the work takes place: the parsing of input documents, the generation of output, and the extraction of the translatable strings. This is pretty simple using the provided functions presented in the section B<INTERNAL FUNCTIONS> below. See also the B<SYNOPSIS>, which presents an example.
de: Hier findet die gesamte Arbeit statt: das Auswerten der Eingabedokumente, die Erstellung der Ausgabe und das Herauslösen der übersetzbaren Zeichenketten. Das ist mit den in Abschnitt B<INTERNE FUNKTIONEN> weiter unten vorgestellten angebotenen Funktionen recht einfach. Lesen Sie auch die B<ÜBERSICHT>, in der ein Beispiel vorgestellt wird.

note: type: textblock
en: This function is called by the process() function below, but if you choose to use the new() function, and to add content manually to your document, you will have to call this function yourself.
de: Diese Funktion wird von der unten beschriebenen process()-Funktion aufgerufen. Falls Sie sich aber entscheiden, die new()-Funktion zu verwenden und den Inhalt manuell zu Ihrem Dokument hinzuzufügen, müssen Sie diese Funktion selbst aufrufen.

note: type: textblock
en: This function returns the header we should add to the produced document, quoted properly to be a comment in the target language.  See the section B<Educating developers about translations>, from L<po4a(7)|po4a.7>, for what it is good for.
de: Diese Funktion gibt den Header zurück und sollte dem erzeugten Dokument hinzugefügt werden, ordentlich zitiert, so dass sie in der Zielsprache ein Kommentar wird. Lesen Sie den Abschnitt B<Entwickler über Übersetzungen schulen>, von L<po4a(7)|po4a.7>, um zu erfahren, wozu dies benutzt wird.

note: type: textblock
en: The following example parses a list of paragraphs beginning with "<p>". For the sake of simplicity, we assume that the document is well formatted, i.e. that '<p>' tags are the only tags present, and that this tag is at the very beginning of each paragraph.
de: Das folgende Beispiel wertet eine Liste von Absätzen aus, die mit »<p>» beginnen. Der Einfachheit halber wird angenommen, dass das Dokument gut formatiert ist, d.h. dass »<p>«-Markierungen die einzigen vorhandene Markierungen sind und dass diese Markierung ganz am Anfang jedes Absatzes steht.

note: type: verbatim
en:    PARAGRAPH: while (1) {
           my ($paragraph,$pararef)=("","");
           my $first=1;
           my ($line,$lref)=$self->shiftline();
           while (defined($line)) {
               if ($line =~ m/<p>/ && !$first--; ) {
                   # Not the first time we see <p>.
                   # Reput the current line in input,
                   #  and put the built paragraph to output
                   $self->unshiftline($line,$lref);
de:    PARAGRAPH: while (1) {
           my ($paragraph,$pararef)=("","");
           my $first=1;
           my ($line,$lref)=$self->shiftline();
           while (defined($line)) {
               if ($line =~ m/<p>/ && !$first--; ) {
                   # <p>taucht nicht zum ersten Mal auf.
                   # Fügen Sie die aktuelle Zeile erneut in die Eingabe,
                   #  und fügen Sie den erstellten Absatz in die Ausgabe.
                   $self->unshiftline($line,$lref);

note: type: verbatim
en:                # Now that the document is formed, translate it:
                   #   - Remove the leading tag
                   $paragraph =~ s/^<p>//s;
de:                # Nun ist das Dokument ausgestaltet, es wird übersetzt:
                   #   - Die führende Markierung entfernen
                   $paragraph =~ s/^<p>//s;

note: type: verbatim
en:                #   - push to output the leading tag (untranslated) and the
                   #     rest of the paragraph (translated)
                   $self->pushline(  "<p>"
                                   . $self->translate($paragraph,$pararef)
                                   );
de:                #   - die Ausgabe der führenden Markierung (unübersetzt) und des
                      #     Rests des Absatzes (unübersetzt) anstoßen
                   $self->pushline(  "<p>"
                                   . $self->translate($paragraph,$pararef)
                                   );

note: type: verbatim
en:                next PARAGRAPH;
               } else {
                   # Append to the paragraph
                   $paragraph .= $line;
                   $pararef = $lref unless(length($pararef));
               }
de:                next PARAGRAPH;
               } else {
                   # an den Absatz anhängen
                   $paragraph .= $line;
                   $pararef = $lref unless(length($pararef));
               }

note: type: verbatim
en:            # Reinit the loop
               ($line,$lref)=$self->shiftline();
           }
           # Did not get a defined line? End of input file.
           return;
       }
     }
de:            # Die Schleife neu initialisieren
               ($line,$lref)=$self->shiftline();
           }
           # Keine definierte Zeile erhalten? Ende der Eingabedatei
           return;
       }
     }

note: type: textblock
en: Once you've implemented the parse function, you can use your document class, using the public interface presented in the next section.
de: Sobald Sie die Funktion zum Auswerten implementiert haben, können Sie Ihre Dokumentenklasse verwenden, die die öffentliche Schnittstelle benutzt, die im nächsten Abschnitt vorgestellt wird.

note: type: =head1
en: PUBLIC INTERFACE for scripts using your parser
de: ÖFFENTLICHE SCHNITTSTELLE für Skripte, die Ihren Parser benutzen

note: type: =head2
en: Constructor
de: Konstruktor

note: type: textblock
en: This function can do all you need to do with a po4a document in one invocation. Its arguments must be packed as a hash. ACTIONS:
de: Diese Funktion kann alles tun, was Sie mit einem Po4a-Dokument in einem Aufruf tun müssen. Ihre Argumente müssen als ein Hash gepackt sein. AKTIONEN:

note: type: textblock
en: Reads all the PO files specified in po_in_name
de: liest alle PO-Dateien, die in po_in_name angegeben sind

note: type: textblock
en: Reads all original documents specified in file_in_name
de: liest alle Originaldokumente, die in file_in_name angegeben sind

note: type: textblock
en: Parses the document
de: wertet das Dokument aus

note: type: textblock
en: Reads and applies all the addenda specified
de: liest alle angegebenen Addenda und wendet sie an

note: type: textblock
en: Writes the translated document to file_out_name (if given)
de: schreibt das übersetzte Dokument in file_out_name (falls angegeben)

note: type: textblock
en: Writes the extracted PO file to po_out_name (if given)
de: schreibt die extrahierte PO-Datei nach po_out_name (falls angegeben)

note: type: textblock
en: ARGUMENTS, beside the ones accepted by new() (with expected type):
de: ARGUMENTE jenseits der durch new() akzeptierten (mit erwartetem Typ):

note: type: textblock
en: List of filenames where we should read the input document.
de: Liste der Dateinamen, bei denen das Eingabedokument gelesen werden sollte

note: type: textblock
en: Charset used in the input document (if it isn't specified, it will try to detect it from the input document).
de: im Eingabedokument benutzter Zeichensatz (falls er nicht angegeben wurde, wird versucht, ihn aus dem Eingabedokument zu bestimmen).

note: type: textblock
en: Filename where we should write the output document.
de: Name der Datei, in den das Ausgabedokument geschrieben werden soll

note: type: textblock
en: Charset used in the output document (if it isn't specified, it will use the PO file charset).
de: im Ausgabedokument benutzter Zeichensatz (falls er nicht angegeben wurde, wird der der PO-Datei benutzt).

note: type: textblock
en: List of filenames where we should read the input PO files from, containing the translation which will be used to translate the document.
de: Liste der Dateinamen, von denen die Eingabe-PO-Dateien gelesen werden sollen; enthält die Übersetzung, die benutzt wird, um das Dokument zu übersetzen

note: type: textblock
en: Filename where we should write the output PO file, containing the strings extracted from the input document.
de: Name der Datei, in den die Ausgabe-PO-Datei geschrieben werden soll; enthält die aus dem Eingabedokument extrahierten Zeichenketten.

note: type: textblock
en: List of filenames where we should read the addenda from.
de: Liste der Dateinamen, aus denen die Addenda gelesen werden

note: type: textblock
en: Charset for the addenda.
de: Zeichensatz für die Addenda

note: type: textblock
en: Create a new po4a document. Accepted options (in the hash passed as a parameter):
de: erstellt ein neues Po4a-Dokument; akzeptiert Optionen (in dem als Parameter übergebenen Hash):

note: type: textblock
en: Sets the verbosity.
de: setzt die Detailstufe

note: type: textblock
en: Sets the debugging.
de: setzt die Debugging-Stufe

note: type: =head2
en: Manipulating document files
de: Manipulieren von Dokumentdateien

note: type: textblock
en: Add another input document data at the end of the existing array C<< @{$self->{TT}{doc_in}} >>. The argument is the filename to read. If a second argument is provided, it is the filename to use in the references.
de: fügt am Ende des existierenden Feldes C<< @{$self->{TT}{doc_in}} >> ein weiteres Eingabedokument ein. Das Argument ist der zu lesende Dateiname. Falls ein zweiter Dateiname bereitgestellt wird, ist dies der in der Referenz zu verwendende Dateiname.

note: type: verbatim
en: This array C<< @{$self->{TT}{doc_in}} >> holds this input document data as an
    array of strings with alternating meanings.
     * The string C<$textline> holding each line of the input text data.
     * The string C<< $filename:$linenum >> holding its location and called as
       "reference" (C<linenum> starts with 1).
de: Das Feld C<< @{$self->{TT}{doc_in}} >> hält die Eingabedokumentdaten als ein
    Feld von Zeichenketten mit abwechselnden Bedeutungen.
     * Die Zeichenkette C<$textline> hält jede Zeile der Eingabetextdaten.
     * Die Zeichenkette C<< $filename:$linenum >> hält ihren Ort und wird
       »reference« genannt (C<linenum> beginnt mit 1).

note: type: textblock
en: Please note that it does not parse anything. You should use the parse()  function when you're done with packing input files into the document.
de: Bitte beachten Sie, dass es nichts auswertet. Sie sollten die Funktion parse() benutzen, wenn Sie damit fertig sind, Eingabedateien in das Dokument zu packen.

note: type: textblock
en: Write the translated document to the given filename.
de: schreibt das übersetzte Dokument in den angegebene Dateinamen

note: type: verbatim
en: This translated document data are provided by:
     * C<< $self->docheader() >> holding the header text for the plugin, and
     * C<< @{$self->{TT}{doc_out}} >> holding each line of the main translated text in the array.
de: Diese übersetzten Dokumentdaten werden bereitgestellt durch:
     * C<< $self->docheader() >> hält den Kopftext für die Erweiterung und
     * C<< @{$self->{TT}{doc_out}} >> hält jede Zeile des übersetzten Haupttextes in dem Feld.

note: type: =head2
en: Manipulating PO files
de: PO-Dateien bearbeiten

note: type: textblock
en: Add the content of a file (which name is passed as argument) to the existing input PO. The old content is not discarded.
de: fügt den Inhalt einer Datei (deren Name als Argument übergeben wird) der existierenden Eingabe-PO-Datei hinzu. Der alte Inhalt wird nicht verworfen.

note: type: textblock
en: Write the extracted PO file to the given filename.
de: schreibt die extrahierte PO-Datei in den angegebene Dateinamen

note: type: textblock
en: Returns some statistics about the translation done so far. Please note that it's not the same statistics than the one printed by msgfmt --statistic. Here, it's stats about recent usage of the PO file, while msgfmt reports the status of the file. It is a wrapper to the Locale::Po4a::Po::stats_get function applied to the input PO file. Example of use:
de: gibt einige Statistiken über bisher erledigte Übersetzungen zurück. Bitte beachten Sie, dass es sich nicht um die gleichen Statistiken handelt, die »msgfmt --statistics« ausgibt. Hier geht es um den aktuellen Gebrauch der PO-Datei, während Msgfmt den Status der Datei ausgibt. Es ist ein Wrapper für die Funktion Locale::Po4a::Po::stats_get, die auf die Eingabe-PO-Datei angewandt wird. Beispiel für die Benutzung:

note: type: verbatim
en:     [normal use of the po4a document...]
de:     [normale Benutzung des Po4a-Dokuments …]

note: type: verbatim
en:     ($percent,$hit,$queries) = $document->stats();
        print "We found translations for $percent\%  ($hit from $queries) of strings.\n";
de:     ($percent,$hit,$queries) = $document->stats();
        print "Es wurden Übersetzungen für $percent\%  ($hit von $queries) der Zeichenketten gefunden.\n";

note: type: =head2
en: Manipulating addenda
de: Addenda manipulieren

note: type: textblock
en: Please refer to L<po4a(7)|po4a.7> for more information on what addenda are, and how translators should write them. To apply an addendum to the translated document, simply pass its filename to this function and you are done ;)
de: Weitere Informationen, was Addenda sind und wie Übersetzer sie schreiben sollten, finden Sie unter L<po4a(7)|po4a.7>. Um ein Addendum auf ein übersetztes Dokument anzuwenden, übergeben Sie einfach dieser Funktion seinen Dateinamen und Sie sind fertig. ;)

note: type: textblock
en: This function returns a non-null integer on error.
de: Diese Funktion gibt bei einem Fehler eine Ganzzahl ungleich Null zurück.

note: type: =head2
en: Getting input, providing output
de: Eingaben erhalten, Ausgaben bereitstellen

note: type: textblock
en: Four functions are provided to get input and return output. They are very similar to shift/unshift and push/pop of Perl.
de: Es werden vier Funktionen bereitgestellt, um Eingaben zu erhalten und Ausgaben zurückzuliefern. Sie sind den Funktionen shift/unshift und push/pop von Perl sehr ähnlich.

note: type: verbatim
en:  * Perl shift returns the first array item and drop it from the array.
     * Perl unshift prepends an item to the array as the first array item.
     * Perl pop returns the last array item and drop it from the array.
     * Perl push appends an item to the array as the last array item.
de:  * Perl shift liefert den ersten Feldeintrag zurück und entfernt ihn aus dem Feld.
     * Perl unshift hängt einen Eintrag als ersten Feldeintrag vor das Feld.
     * Perl pop liefert den letzten Feldeintrag zurück und entfernt ihn aus dem Feld.
     * Perl push hängt einen Eintrag als letzten Feldeintrag an das Feld an.

note: type: textblock
en: The first pair is about input, while the second is about output. Mnemonic: in input, you are interested in the first line, what shift gives, and in output you want to add your result at the end, like push does.
de: Das erste Paar handelt von der Eingabe, während das Zweite von der Ausgabe handelt. Merkhilfe: In der Eingabe sind Sie an der ersten Zeile interessiert, was Shift ausgibt und in der Ausgabe möchten Sie Ihr Ergebnis an das Ende hinzufügen, wie dies Push tut.

note: type: textblock
en: This function returns the first line to be parsed and its corresponding reference (packed as an array) from the array C<< @{$self->{TT}{doc_in}} >> and drop these first 2 array items.  Here, the reference is provided by a string C<< $filename:$linenum >>.
de: Diese Funktion liefert die erste auszuwertende Zeile und ihre entsprechende Referenz (als Feld gepackt) aus dem Feld C<< @{$self->{TT}{doc_in}} >> zurück und entfernt diese ersten zwei Feldeinträge. Hier wird die Referenz durch eine Zeichenkette C<< $filename:$linenum >> bereitgestellt.

note: type: textblock
en: Unshifts the last shifted line of the input document and its corresponding reference back to the head of C<< {$self->{TT}{doc_in}} >>.
de: Schiebt die letzte geschobene Zeile des Eingabedokuments und seiner entsprechenden Referenz an den Kopf von C<< {$self->{TT}{doc_in}} >> zurück.

note: type: textblock
en: Push a new line to the end of C<< {$self->{TT}{doc_out}} >>.
de: Schiebt eine neue Zeile an das Ende von C<< {$self->{TT}{doc_out}} >>.

note: type: textblock
en: Pop the last pushed line from the end of C<< {$self->{TT}{doc_out}} >>.
de: Holt die zuletzt geschobene Zeile vom Ende von C<< {$self->{TT}{doc_out}} >>.

note: type: =head2
en: Marking strings as translatable
de: Zeichenketten als übersetzbar markieren

note: type: textblock
en: One function is provided to handle the text which should be translated.
de: Eine Funktion wird bereitgestellt, um den Text zu handhaben, der übersetzt werden soll.

note: type: textblock
en: Mandatory arguments:
de: vorgeschriebene Argumente:

note: type: textblock
en: A string to translate
de: eine zu übersetzende Zeichenkette

note: type: textblock
en: The reference of this string (i.e. position in inputfile)
de: die Referenz dieser Zeichenkette (d.h. Position in der Eingabedatei)

note: type: textblock
en: The type of this string (i.e. the textual description of its structural role; used in Locale::Po4a::Po::gettextization(); see also L<po4a(7)|po4a.7>, section B<Gettextization: how does it work?>)
de: der Typ der Zeichenkette (d.h. die inhaltliche Beschreibung ihrer strukturellen Rolle; benutzt in Locale::Po4a::Po::gettextization(); siehe auch L<po4a(7)|po4a.7>, Abschnitt B<Gettextisierung: Wie funktioniert das?>)

note: type: textblock
en: This function can also take some extra arguments. They must be organized as a hash. For example:
de: Diese Funktion kann außerdem einige zusätzliche Argumente entgegennehmen. Sie müssen als Hash organisiert sein. Zum Beispiel:

note: type: textblock
en: boolean indicating whether we can consider that whitespaces in string are not important. If yes, the function canonizes the string before looking for a translation or extracting it, and wraps the translation.
de: logische Variable, ob die Leerzeichen in der Zeichenkette als unwichtig betrachtet werden können. Falls ja, wird die Funktion die Zeichenkette in eine kanonische Form bringen, bevor nach einer Übersetzungen gesucht oder diese extrahiert wird und ein Zeilenumbruch wird durchgeführt.

note: type: textblock
en: an extra comment to add to the entry.
de: ein zusätzlicher Kommentar, der zum Eintrag hinzugefügt wird

note: type: textblock
en: Actions:
de: Aktionen:

note: type: textblock
en: Pushes the string, reference and type to po_out.
de: schiebt die Zeichenkette, die Referenz und den Typ nach po_out

note: type: textblock
en: Returns the translation of the string (as found in po_in) so that the parser can build the doc_out.
de: gibt die Übersetzung der Zeichenkette (wie sie in po_in gefunden wurde) zurück, so dass der Parser das doc_out bauen kann

note: type: textblock
en: Handles the charsets to recode the strings before sending them to po_out and before returning the translations.
de: handhabt die Zeichensätze, um den Zeichensatz der Zeichenkette umzuwandeln, bevor sie an po_out gesandt werden und bevor die Übersetzungen zurückgegeben werden

note: type: =head2
en: Misc functions
de: Verschiedene Funktionen

note: type: textblock
en: Returns if the verbose option was passed during the creation of the TransTractor.
de: kehrt zurück, falls die Option »verbose« während der Erstellung von TransTractor übergeben wurde

note: type: textblock
en: Returns if the debug option was passed during the creation of the TransTractor.
de: kehrt zurück, falls die Option »debug« während der Erstellung von TransTractor übergeben wurde

note: type: textblock
en: This tells TransTractor that a new charset (the first argument) has been detected from the input document. It can usually be read from the document header. Only the first charset will remain, coming either from the process() arguments or detected from the document.
de: Dies teilt TransTractor mit, dass ein neuer Zeichensatz (das erste Argument) vom Eingabedokument festgestellt wurde. Er kann üblicherweise aus den Kopfzeilen des Dokuments gelesen werden. Nur der erste Zeichensatz, der entweder von dem process()-Argumenten kommt oder aus dem Dokumente ermittelt wird, wird übrigbleiben.

note: type: textblock
en: This function will return the charset that should be used in the output document (usually useful to substitute the input document's detected charset where it has been found).
de: Diese Funktion wird den Zeichensatz zurückgeben, der im ausgegebenen Dokument benutzt werden sollte (üblicherweise nützlich, um den ermittelten Zeichensatz des Eingabedokuments zu ersetzen, wo er gefunden wurde).

note: type: textblock
en: It will use the output charset specified in the command line. If it wasn't specified, it will use the input PO's charset, and if the input PO has the default "CHARSET", it will return the input document's charset, so that no encoding is performed.
de: Sie wird den auf der Befehlszeile angegebenen Zeichensatz verwenden. Falls er nicht angegeben wurde, wird sie den Zeichensatz der Eingabe-PO-Datei benutzen und falls die Eingabe-PO-Datei die Vorgabe »CHARSET« hat, wird sie den Zeichensatz des Eingabedokuments zurückgeben, so dass die Kodierung durchgeführt wird.

note: type: textblock
en: This function returns the recoded text passed as argument, from the input document's charset to the output document's one. This isn't needed when translating a string (translate() recodes everything itself), but it is when you skip a string from the input document and you want the output document to be consistent with the global encoding.
de: Diese Funktion gibt den vom Zeichensatz des Eingabedokuments in den Zeichensatz des Ausgabedokuments neu kodierten Text zurück, der als Argument übergeben wurde. Dies ist nicht nötig, wenn eine Zeichenkette übersetzt wird (translate() kodiert selbst alles neu), aber es ist nötig, wenn Sie eine Zeichenkette des Eingabedokuments überspringen und wenn Sie wollen, dass das Ausgabedokument über eine einheitliche globale Kodierung verfügt.

note: type: =head1
en: FUTURE DIRECTIONS
de: ZUKÜNFTIGE ENTWICKLUNGEN

note: type: textblock
en: One shortcoming of the current TransTractor is that it can't handle translated document containing all languages, like debconf templates, or .desktop files.
de: Ein Mangel des aktuellen Transtractors ist, dass er keine übersetzten Dokumente handhaben kann, die alle Sprachen enthalten, wie Debconf-Schablonen oder Desktop-Dateien.

note: type: textblock
en: To address this problem, the only interface changes needed are:
de: Um dieses Problem anzugehen, sind nur bestimmte Schnittstellenänderungen notwendig:

note: type: textblock
en: take a hash as po_in_name (a list per language)
de: einen Hash in po_in_name nehmen (eine Liste pro Sprache)

note: type: textblock
en: add an argument to translate to indicate the target language
de: ein zu übersetzendes Argument hinzufügen, um die Zielsprache anzugeben

note: type: textblock
en: make a pushline_all function, which would make pushline of its content for all languages, using a map-like syntax:
de: ein Funktion pushline_all erstellen, die pushline ihres Inhalts für alle Sprachen unter Benutzung einer kartenähnlichen Syntax ausführen würde:

note: type: textblock
en: Will see if it's enough ;)
de: Es wird sich zeigen, ob das ausreicht. ;)

note: type: textblock
en: Locale::Po4a::Wml - convert WML (web markup language) documents from/to PO files
de: Locale::Po4a::Wml - konvertiert WML- (Web Markup Language) Dokumente von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Wml is a module to help the translation of WML documents into other [human] languages. Do not mixup the WML we are speaking about here (web markup language) and the WAP crap used on cell phones.
de: Locale::Po4a::Wml ist ein Modul, um bei der Übersetzung von WML-Dokumenten in andere [natürliche] Sprachen zu helfen. Bringen Sie nicht das WML (die Web Markup Language), über die hier geschrieben wird, mit dem WAP-Müll durcheinander, der auf Handys verwandt wird.

note: type: textblock
en: Please note that this module relies upon the Locale::Po4a::Xhtml module, which also relies upon the Locale::Po4a::Xml module.  This means that all tags for web page expressions are assumed to be written in the XHTML syntax.
de: Bitte beachten Sie, dass dieses Modul sich auf das Modul Locale::Po4a::Xhtml stützt, das sich wiederum auf das Modul Locale::Po4a::Xml stützt. Dies bedeutet, dass für alle Markierungen für Webseitenausdrücke angenommen wird, dass sie in der XHTML-Syntax geschrieben sind.

note: type: textblock
en: This module works for some simple documents, but is still young.  Currently, the biggest issue of the module is probably that it cannot handle documents that contain non-XML inline tags such as <email "foo@example.org">, which are often defined in the WML.  Improvements will be added in the future releases.
de: Das Modul funktioniert für einige einfache Dokumente, ist aber noch jung. Derzeit ist das größte Problem des Moduls wahrscheinlich, dass es mit keinen Dokumenten umgehen kann, die nicht XML-innenliegende-Markierungen verwenden, wie <email "foo@example.org">, die oft in WML definiert sind. Verbesserungen werden in zukünftigen Veröffentlichungen hinzugefügt.

note: type: textblock
en: Locale::Po4a::Xhtml - convert XHTML documents from/to PO files
de: Locale::Po4a::Xhtml - konvertiert XHTML-Dokumente von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Xhtml is a module to help the translation of XHTML documents into other [human] languages.
de: Locale::Po4a::Xhtml ist ein Modul, dass bei der Übersetzung von XHTML-Dokumenten in andere [natürliche] Sprachen hilft.

note: type: =item
en: B<includessi>[B<=>I<rootpath>]
de: B<includessi>[B<=>I<Wurzelpfad>]

note: type: textblock
en: Include files specified by an include SSI (Server Side Includes) element (e.g. <!--#include virtual="/foo/bar.html" -->).
de: fügt durch SSI (Server Side Includes) eingebundene Elemente hinzu (z.B. <!--#include virtual="/foo/bar.html" -->)

note: type: textblock
en: B<Note:> You should use it only for static files.
de: B<Hinweis:> Sie sollten dies nur für statische Dateien verwenden.

note: type: textblock
en: An additional I<rootpath> parameter can be specified. It specifies the root path to find files included by a B<virtual> attribute.
de: Zusätzlich kann ein I<Wurzelpfad>-Parameter angegeben werden. Er spezifiert den Wurzelpfad, um Dateien zu finden, die durch das Attribut B<virtual> aufgenommen werden.

note: type: textblock
en: "It works for me", which means I use it successfully on my personal Web site.  However, YMMV: please let me know if something doesn't work for you.
de: »Funktioniert für mich«, das bedeutet, ich habe es erfolgreich auf meinen persönlichen Webseiten angewandt. Allerdings kann Ihr Erfolg anders aussehen: Bitte informieren Sie mich, ob etwas für Sie nicht funktioniert.

note: type: textblock
en: Locale::Po4a::Xml - convert XML documents and derivates from/to PO files
de: Locale::Po4a::Xml - konvertiert XML-Dokumente und -Derivate von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Xml is a module to help the translation of XML documents into other [human] languages. It can also be used as a base to build modules for XML-based documents.
de: Locale::Po4a::Xml ist ein Modul, um bei der Übersetzung von XML-Dokumenten in andere [natürliche] Sprachen zu helfen. Es kann auch als Basis verwandt werden, um Module für XML-basierte Dokumente zu erstellen.

note: type: =head1
en: TRANSLATING WITH PO4A::XML
de: ÜBERSETZEN MIT PO4A::XML

note: type: textblock
en: This module can be used directly to handle generic XML documents.  This will extract all tag's content, and no attributes, since it's where the text is written in most XML based documents.
de: Dieses Modul kann direkt zum Umgang mit generischen XML-Dokumenten verwandt werden. Dabei werden die Inhalte aller Markierungen (»Tags«) aber keiner Attribute ausgelesen, da sich dort in den meisten XML-basierten Dokumenten der geschriebene Text befindet.

note: type: textblock
en: There are some options (described in the next section) that can customize this behavior.  If this doesn't fit to your document format you're encouraged to write your own module derived from this, to describe your format's details.  See the section B<WRITING DERIVATE MODULES> below, for the process description.
de: Es gibt einige Optionen (die im nächsten Abschnitt beschrieben werden), die dieses Verhalten anpassen lassen. Falls dies nicht auf Ihr Dokumentenformat passt, ermutigen wir Sie, Ihr eigenes, von diesem Modul abgeleitetes Modul zu schreiben, um die Details Ihres Formats zu beschreiben. Lesen Sie den Abschnitt B<SCHREIBEN ABGELEITETER MODULE> weiter unten für die Beschreibung des Prozesses.

note: type: textblock
en: The global debug option causes this module to show the excluded strings, in order to see if it skips something important.
de: Die globale Option »debug« führt dazu, dass das Module ausgeschlossene Zeichenketten anzeigt, um zu erkennen, ob etwas Wichtiges übersprungen wird.

note: type: textblock
en: Prevents it to strip the spaces around the extracted strings.
de: verhindert, dass es Leerzeichen um herausgelöste Zeichenketten entfernt

note: type: textblock
en: Canonicalizes the string to translate, considering that whitespaces are not important, and wraps the translated document. This option can be overridden by custom tag options. See the B<translated> option below.
de: Erstellt eine kanonische Form der zu übersetzenden Zeichenketten, berücksichtigt dabei, dass Leerzeichen nicht wichtig sind, und bricht das übersetzte Dokument um. Diese Option kann mit angepassten »tag«-Optionen überschrieben werden. Lesen Sie dazu über die Option B<translated> weiter unten.

note: type: textblock
en: Attributes are wrapped by default. This option disables wrapping.
de: Attribute werden standardmäßig zeilenumgebrochen. Diese Option unterbindet Zeilenumbrüche.

note: type: textblock
en: It makes the tags and attributes searching to work in a case insensitive way.  If it's defined, it will treat E<lt>BooKE<gt>laNG and E<lt>BOOKE<gt>Lang as E<lt>bookE<gt>lang.
de: Damit funktioniert die Suche nach Markierungen und Attributen unabhängig von der Groß-/Kleinschreibung. Falls es definiert ist, wird es E<lt>BooKE<gt>laNG und E<lt>BOOKE<gt>Lang als E<lt>bookE<gt>lang behandeln.

note: type: textblock
en: Escape quotes in output strings.  Necessary, for example, for creating string resources for use by Android build tools.
de: Maskiert Anführungszeichen in Ausgabezeichenketten. Dies ist zum Beispiel für die Erstellung von Zeichenkettenressourcen zur Verwendung mit den Android-Bauwerkzeugen notwendig.

note: type: textblock
en: See also: https://developer.android.com/guide/topics/resources/string-resource.html
de: Siehe auche: https://developer.android.com/guide/topics/resources/string-resource.html

note: type: textblock
en: When defined, external entities are included in the generated (translated)  document, and for the extraction of strings.  If it's not defined, you will have to translate external entities separately as independent documents.
de: Wenn definiert, werden externe Entitäten in das erstellte (übersetzte) Dokument und für die Herauslösung der Zeichenketten aufgenommen. Falls es nicht definiert ist, müssen Sie externe Entitäten separat als unabhängige Dokumente übersetzen.

note: type: textblock
en: This option defines the behavior of the module when it encounters invalid XML syntax (a closing tag which does not match the last opening tag).  It can take the following values:
de: Diese Option defniert das Verhalten des Moduls, wenn es auf eine ungültige XML-Syntax trifft (eine schließende Markierung (»Tag«), die nicht zur letzten öffnenden Markierung passt). Sie kann die folgenden Werte annehmen:

note: type: textblock
en: This is the default value.  The module will exit with an error.
de: Dies ist der Standardwert. Das Modul wird sich mit einem Fehler beenden.

note: type: textblock
en: The module will continue, and will issue a warning.
de: Das Modul wird fortfahren und eine Warnung ausgeben.

note: type: textblock
en: The module will continue without any warnings.
de: Das Modul wird ohne Warnungen fortfahren.

note: type: textblock
en: Be careful when using this option.  It is generally recommended to fix the input file.
de: Seien Sie vorsichtig, wenn Sie diese Option verwenden. Im Allgemeinen wird empfohlen, die Eingabedatei zu reparieren.

note: type: textblock
en: Note: This option is deprecated.
de: Hinweis: Diese Option wurde missbilligt.

note: type: textblock
en: Extracts only the specified tags in the B<tags> option.  Otherwise, it will extract all the tags except the ones specified.
de: extrahiert nur die angegebenen Markierungen in der Option B<tags>. Andernfalls wird es nur die Markierungen extrahieren mit Ausnahme derjenigen, die angegeben wurden.

note: type: textblock
en: String that will try to match with the first line of the document's doctype (if defined). If it doesn't, a warning will indicate that the document might be of a bad type.
de: Zeichenkette, bei der ausprobiert wird, ob sie zu der ersten Zeile des Dokumenttyps passt (falls definiert). Falls nicht, wird eine Warnung angezeigt, dass das Dokument vom falschen Typ ist.

note: type: textblock
en: String indicating the path (e.g. E<lt>bbbE<gt>E<lt>aaaE<gt>) of a tag where a lang="..." attribute shall be added. The language will be defined as the basename of the PO file without any .po extension.
de: Zeichenkette, die den Pfad einer Markierung (z.B. E<lt>bbbE<gt>E<lt>aaaE<gt>) angibt, zu dem ein Attribut lang="…" hinzugefügt werden soll. Die Sprache wird als Basisname der PO-Datei ohne irgendeine .po-Erweiterung definiert sein.

note: type: textblock
en: Boolean indicating whether closing tags are optional (as in HTML). By default, missing closing tags raise an error handled according to B<ontagerror>.
de: Logischer Wert, der angibt, ob schließende Markierungen optional sind (wie in HTML). Standardmäßig lösen fehlende schließende Markierungen einen Fehler aus, der entsprechend B<ontagerror> behandelt wird.

note: type: textblock
en: Note: This option is deprecated.  You should use the B<translated> and B<untranslated> options instead.
de: Hinweis: Diese Option wurde missbilligt. Sie sollten stattdessen die Optionen B<translated> und B<untranslated> verwenden.

note: type: textblock
en: Space-separated list of tags you want to translate or skip.  By default, the specified tags will be excluded, but if you use the "tagsonly" option, the specified tags will be the only ones included.  The tags must be in the form E<lt>aaaE<gt>, but you can join some (E<lt>bbbE<gt>E<lt>aaaE<gt>) to say that the content of the tag E<lt>aaaE<gt> will only be translated when it's into a E<lt>bbbE<gt> tag.
de: leerzeichengetrennte Liste der Markierungen, die Sie übersetzen oder überspringen möchten. Standardmäßig werden die angegebenen Markierungen ausgenommen, falls Sie aber die Option »tagsonly« verwenden, werden nur die angegebenen Markierungen einbezogen. Die Markierungen müssen die Form E<lt>aaaE<gt> haben, Sie können aber einige verbinden (E<lt>bbbE<gt>E<lt>aaaE<gt>), um anzugeben, dass der Inhalt der Markierung E<lt>aaaE<gt> nur übersetzt wird, wenn er in einer E<lt>bbbE<gt>-Markierung liegt.

note: type: textblock
en: You can also specify some tag options by putting some characters in front of the tag hierarchy. For example, you can put I<w> (wrap) or I<W> (don't wrap)  to override the default behavior specified by the global B<wrap> option.
de: Sie können außerdem einige Markierungsoptionen angeben, indem Sie ein paar Zeichen an den Anfang der Markierungshierarchie stellen. Sie können zum Beispiel I<w> (Zeilenumbruch) oder I<W> (kein Zeilenumbruch) setzen, um das Standardverhalten, das durch die globale Option B<wrap> angegeben wurde, außer Kraft zu setzen.

note: type: textblock
en: Example: WE<lt>chapterE<gt>E<lt>titleE<gt>
de: Beispiel: WE<lt>KapitelE<gt>E<lt>TitelE<gt>

note: type: textblock
en: Space-separated list of tag's attributes you want to translate.  You can specify the attributes by their name (for example, "lang"), but you can prefix it with a tag hierarchy, to specify that this attribute will only be translated when it's in the specified tag. For example: E<lt>bbbE<gt>E<lt>aaaE<gt>lang specifies that the lang attribute will only be translated if it's in an E<lt>aaaE<gt> tag, and it's in a E<lt>bbbE<gt> tag.
de: leerzeichengetrennte Liste der Markierungsattribute, die Sie übersetzen wollen. Sie können die Attribute mittels ihres Namens angeben (zum Beispiel »lang«), aber Sie können ihnen eine Markierung voranstellen, um anzugeben, dass das Attribut nur übersetzt wird, wenn es sich in der angegebenen Markierung befindet. Zum Beispiel: E<lt>bbbE<gt>E<lt>aaaE<gt>lang gibt an, dass das Attribut lang nur übersetzt wird, falls es in einer E<lt>aaaE<gt> und einer E<lt>aaaE<gt>-Markierung steht.

note: type: textblock
en: Do not translate attributes in inline tags.  Instead, replace all attributes of a tag by po4a-id=<id>.
de: Attribute in innenliegenden Markierungen nicht übersetzen; stattdessen alle Attribute einer Markierung durch po4a-id=<Kennzahl> ersetzen

note: type: textblock
en: This is useful when attributes shall not be translated, as this simplifies the strings for translators, and avoids typos.
de: Dies ist nützlich, wenn Attribute nicht übersetzt werden sollen, da dies die Zeichenketten für Übersetzer vereinfacht und Tippfehler vermeidet.

note: type: textblock
en: Space-separated list of tags which should not be treated as tags.  These tags are treated as inline, and do not need to be closed.
de: leerzeichengetrennte Liste der Markierungen, die nicht als Markierungen betrachtet werden. Diese Markierungen werden als innenliegend angesehen und müssen nicht geschlossen werden.

note: type: textblock
en: Space-separated list of tags which should break the sequence.  By default, all tags break the sequence.
de: leerzeichengetrennte Liste der Markierungen, die die Abfolge unterbrechen sollen. Standardmäßig unterbrechen alle Markierungen die Abfolge.

note: type: textblock
en: The tags must be in the form <aaa>, but you can join some (<bbb><aaa>), if a tag (<aaa>) should only be considered when it's within another tag (<bbb>).
de: Die Markierungen müssen in der Form <aaa> vorliegen, Sie können aber einige verbinden (<bbb><aaa>), falls eine Markierung nur berücksichtigt werden soll, wenn sie innerhalb einer anderen Markierung liegt (<bbb>).

note: type: textblock
en: Please note a tag should be listed in only one of the B<break>, B<inline> B<placeholder>, or B<customtag> setting string.
de: Bitte beachten Sie, dass eine Markierung nur in einer der Einstellungszeichenketten B<break>, B<inline> B<placeholder> oder B<customtag> aufgeführt sein soll.

note: type: textblock
en: Space-separated list of tags which should be treated as inline.  By default, all tags break the sequence.
de: leerzeichengetrennte Liste der Markierungen, die als innenliegend betrachtet werden sollen. Standardmäßig unterbrechen alle Markierungen die Abfolge.

note: type: textblock
en: Space-separated list of tags which should be treated as placeholders.  Placeholders do not break the sequence, but the content of placeholders is translated separately.
de: leerzeichengetrennte Liste der Markierungen, die als Platzhalter betrachtet werden sollen. Platzhalter unterbrechen die Abfolge nicht, der Inhalt der Platzhalter wird aber separat übersetzt.

note: type: textblock
en: The location of the placeholder in its block will be marked with a string similar to:
de: Die Lage des Platzhalters in seinem Block wird mit einer Zeichenkette ähnlich der Folgenden markiert:

note: type: textblock
en: By default, Processing Instructions (i.e., C<E<lt>? ... ?E<gt>> tags) are handled as inline tags.  Pass this option if you want the PI to be handled as breaking tag.  Note that unprocessed PHP tags are handled as Processing Instructions by the parser.
de: Standardmäßig werden Verarbeitungsanweisungen (d.h. C<E<lt>? … ?E<gt>>-Markierungen) als innenliegende Markierungen behandelt. Übergeben Sie diese Option, wenn Sie möchten, dass die Verarbeitungshinweise als unterbrechende Markierungen behandelt werden sollen. Beachten Sie, dass unkomprimierte PHP-Markierungen durch das Auswertprogramm als Verarbeitungsanweisungen gehandhabt werden.

note: type: textblock
en: Space separated list of tags that the module should not try to set by default in any category.
de: leerzeichengetrennte Liste der Markierungen, die das Modul nicht standardmäßig in jeder Kategorie zu setzen versuchen sollte.

note: type: textblock
en: If you have a tag which has its default setting by the subclass of this module but you want to set alternative setting, you need to list that tag as a part of the B<nodefault> setting string.
de: Falls Sie eine Markierung einsetzen, deren Vorgabeeinstellung in einer Unterklasse dieses Moduls ist, Sie aber eine alternative Einstellung wählen möchten, müssen Sie diese Markierung als Teil der Einstellungszeichenkette B<nodefault> aufführen.

note: type: textblock
en: Support C preprocessor directives.  When this option is set, po4a will consider preprocessor directives as paragraph separators.  This is important if the XML file must be preprocessed because otherwise the directives may be inserted in the middle of lines if po4a consider it belong to the current paragraph, and they won't be recognized by the preprocessor.  Note: the preprocessor directives must only appear between tags (they must not break a tag).
de: C-Präprozessordirektiven unterstützen. Wenn diese Option gesetzt ist, wird Po4a Präprozessordirektiven als Absatztrenner betrachten. Dies ist wichtig, falls die XML-Datei vorher bearbeitet werden muss, weil die Direktiven andernfalls in die Mitte der Zeilen eingefügt werden könnten, falls Po4a sie zum aktuellen Absatz gehörig ansieht und sie nicht durch den Präprozessor erkannt würden. Hinweis: Die Präprozessordirektiven dürfen nur zwischen Markierungen erscheinen (sie dürfen keine Markierung unterbrechen).

note: type: textblock
en: Space-separated list of tags you want to translate.
de: leerzeichengetrennte Liste der Markierungen, die Sie übersetzen möchten

note: type: textblock
en: You can also specify some tag options by putting some characters in front of the tag hierarchy.  This overrides the default behavior specified by the global B<wrap> and B<defaulttranslateoption> option.
de: Sie können außerdem einige Markierungsoptionen angeben, indem Sie ein paar Zeichen an den Anfang der Markierungshierarchie stellen. Dies setzt das durch die globalen Optionen B<wrap> und B<defaulttranslateoption> festgelegte Vorgabeverhalten außer Kraft.

note: type: textblock
en: Tags should be translated and content can be re-wrapped.
de: Markierungen sollten übersetzt werden und Inhalt kann neu umgebrochen werden

note: type: textblock
en: Tags should be translated and content should not be re-wrapped.
de: Markierungen sollten übersetzt werden und Inhalt sollte nicht neu umgebrochen werden

note: type: textblock
en: Tags should be translated inline.
de: Markierungen sollten innenliegend übersetzt werden

note: type: textblock
en: Tags should be translated as placeholders.
de: Markierungen sollten als Platzhalter übersetzt werden

note: type: textblock
en: Internally, the XML parser only cares about these four options: I<w> I<W> I<i> I<p>.
de: Intern kümmert sich der XML-Parser nur um diese vier Optionen: I<w> I<W> I<i> I<p>.

note: type: textblock
en: * Tags listed in B<break> are set to I<w> or I<W> depending on the B<wrap> option.
de: * In B<break> aufgeführte Markierungen werden abhängig von der Option B<wrap> auf I<w> oder I<W> gesetzt.

note: type: textblock
en: * Tags listed in B<inline> are set to I<i>.
de: * In B<inline> aufgeführte Markierungen werden auf I<i> gesetzt.

note: type: textblock
en: * Tags listed in B<placeholder> are set to I<p>.
de: * In B<placeholder> aufgeführte Markierungen werden auf I<p> gesetzt.

note: type: textblock
en: * Tags listed in B<untranslated> are without any of these options set.
de: * In B<untranslated> aufgeführte Markierungen sind ohne eine dieser gesetzten Optionen.

note: type: textblock
en: You can verify actual internal parameter behavior by invoking B<po4a> with B<--debug> option.
de: Das tatsächliche interne Parameterverhalten können Sie durch Aufruf von B<po4a> mit der Option B<--debug> überprüfen.

note: type: textblock
en: Please note a tag should be listed in either B<translated> or B<untranslated> setting string.
de: Bitte beachten Sie, dass eine Markeirung entweder in der Einstellungszeichenkette B<translated> oder B<untranslated> aufgeführt sein sollte.

note: type: textblock
en: Space-separated list of tags you do not want to translate.
de: leerzeichengetrennte Liste der Markierungen, die Sie nicht übersetzen möchten

note: type: textblock
en: Please note a translatable inline tag in an untranslated tag is treated as a translatable breaking tag, I<i> setting is dropped and I<w> or I<W> is set depending on the B<wrap> option.
de: Bitte beachten Sie, dass eine übersetzbare innenliegende Markierung in einer unübersetzbaren Markierung als eine übersetzbare unterbrechende Markierung behandelt wird, die Einstellung I<i> entfällt und I<w> oder I<W> werden abhängig von der Option B<wrap> gesetzt.

note: type: textblock
en: The default categories for tags that are not in any of the translated, untranslated, break, inline, or placeholder.
de: die Standardkategorie für Markierungen, die sich nicht in »translated«, »untranslated«, »break«, »inline« oder »placeholder« befinden

note: type: textblock
en: This is a set of letters as defined in B<translated> and this setting is only valid for translatable tags.
de: Dies ist eine Gruppe von in B<translated> definierten Buchstaben und diese Einstellung ist nur für übersetzbare Markierungen gültig.

note: type: =head1
en: WRITING DERIVATIVE MODULES
de: SCHREIBEN ABGELEITETER MODULE

note: type: =head2
en: DEFINE WHAT TAGS AND ATTRIBUTES TO TRANSLATE
de: DEFINIERT, WELCHE MARKIERUNGEN UND ATTRIBUTE ZU ÜBERSETZEN SIND

note: type: textblock
en: The simplest customization is to define which tags and attributes you want the parser to translate.  This should be done in the initialize function.  First you should call the main initialize, to get the command-line options, and then, append your custom definitions to the options hash.  If you want to treat some new options from command line, you should define them before calling the main initialize:
de: Die einfachste Anpassung ist, zu definieren, welche Markierungen und Attribute der Parser übersetzen soll. Dies sollte in der Funktion »initialize« erledigt werden. Zuerst sollten Sie die Haupt-»initialize«-Funktion aufrufen, um die Befehlszeilenoptionen zu erhalten und dann Ihre angepassten Definitionen an den Options-Hash anhängen. Falls Sie einige neue Optionen von der Befehlszeile bearbeiten möchten, sollten Sie sie vor dem Aufruf der Haupt-»initialize«-Funktion definieren:

note: type: textblock
en: You should use the B<_default_inline>, B<_default_break>, B<_default_placeholder>, B<_default_translated>, B<_default_untranslated>, and B<_default_attributes> options in derivative modules. This allow users to override the default behavior defined in your module with command line options.
de: Sie sollten in abgeleiteten Modulen die Optionen B<_default_inline>, B<_default_break>, B<_default_placeholder>, B<_default_translated>, B<_default_untranslated> und B<_default_attributes> benutzen. Dies ermöglicht Anwendern, das in Ihrem Modul definierte Verhalten mit Befehlszeilenoptionen außer Kraft zu setzen.

note: type: textblock
en: If you don't like the default behavior of this xml module and its derivative modules, you can provide command line options to change their behavior.
de: Falls Sie das Vorgabeverhalten dieses XML-Moduls und seiner abgeleiteten Module nicht mögen, können Sie Befehlszeilenoptionen zur Änderung ihres Verhaltens bereitstellen.

note: type: textblock
en: See L<Locale::Po4a::Docbook(3pm)|Locale::Po4a::Docbook>,
de: Siehe L<Locale::Po4a::Docbook(3pm)|Locale::Po4a::Docbook>,

note: type: =head2
en: OVERRIDING THE found_string FUNCTION
de: DIE FUNKTION found_string AUßER KRAFT SETZEN

note: type: textblock
en: Another simple step is to override the function "found_string", which receives the extracted strings from the parser, in order to translate them.  There you can control which strings you want to translate, and perform transformations to them before or after the translation itself.
de: Ein weiterer einfacher Schritt ist es, die Funktion »found_string« außer Kraft zu setzen, die die extrahierten Zeichenketten vom Parser erhält, um sie zu übersetzen. Dort können Sie steuern, welche Zeichenketten Sie übersetzen möchten und Umwandlungen in diese vor oder nach der Übersetzung selbst durchführen.

note: type: textblock
en: It receives the extracted text, the reference on where it was, and a hash that contains extra information to control what strings to translate, how to translate them and to generate the comment.
de: Sie erhält den extrahierten Text, die Referenz, von wo sie stammt und einen Hash, der zusätzliche Informationen enthält, um zu steuern, welche Zeichenketten zu übersetzen sind, wie sie zu übersetzen sind und um den Kommentar zu erzeugen.

note: type: textblock
en: The content of these options depends on the kind of string it is (specified in an entry of this hash):
de: Der Inhalt dieser Optionen hängt von der Art der Zeichenkette ab (angegeben in einem Eintrag dieses Hashs):

note: type: =item
en: type="tag"
de: type="Markierung"

note: type: textblock
en: The found string is the content of a translatable tag. The entry "tag_options" contains the option characters in front of the tag hierarchy in the module "tags" option.
de: Die gefundene Zeichenkette ist der Inhalt einer übersetzbaren Markierung. Der Eintrag »tag_options« enthält die Optionszeichen am Anfang der Markierungshierarchie in der Moduloption »tags«.

note: type: =item
en: type="attribute"
de: type="Attribut"

note: type: textblock
en: Means that the found string is the value of a translatable attribute. The entry "attribute" has the name of the attribute.
de: bedeutet, dass die gefundene Zeichenkette der Wert eines übersetzbaren Attributs ist. Der Eintrag »Attribut« erhält den Namen des Attributs.

note: type: textblock
en: It must return the text that will replace the original in the translated document. Here's a basic example of this function:
de: Sie muss den Text zurückgeben, der das Original im übersetzten Dokument ersetzt. Hier ein grundlegendes Beispiel dieser Funktion:

note: type: textblock
en: There's another simple example in the new Dia module, which only filters some strings.
de: Im neuen Modul Dia ist ein weiteres einfaches Beispiel, das nur einige Zeichenketten filtert.

note: type: =head2
en: MODIFYING TAG TYPES (TODO)
de: ÄNDERN VON KENNZEICHENTYPEN (ZU ERLEDIGEN)

note: type: textblock
en: This is a more complex one, but it enables a (almost) total customization.  It's based on a list of hashes, each one defining a tag type's behavior. The list should be sorted so that the most general tags are after the most concrete ones (sorted first by the beginning and then by the end keys). To define a tag type you'll have to make a hash with the following keys:
de: Dies ist ein komplexeres Modul, das aber eine (fast) vollständige Anpassung ermöglicht. Es basiert auf einer Liste von Hashes, von denen jeder das Verhalten eines Markierungstyps definiert. Die Liste sollte sortiert sein, so dass die allgemeinsten Markierungen hinter den konkretesten stehen (zuerst nach den beginnenden und dann nach den endenden Schlüsseln sortiert). Um eine Markierung zu definieren, müssen Sie einen Hash mit den folgenden Schlüsseln erstellen:

note: type: textblock
en: Specifies the beginning of the tag, after the "E<lt>".
de: gibt den Anfang der Markierung an, nach dem »E<lt>«

note: type: textblock
en: Specifies the end of the tag, before the "E<gt>".
de: gibt das Ende der Markierung an, vor dem »E<gt>«

note: type: textblock
en: It says if this is a breaking tag class.  A non-breaking (inline) tag is one that can be taken as part of the content of another tag.  It can take the values false (0), true (1) or undefined.  If you leave this undefined, you'll have to define the f_breaking function that will say whether a concrete tag of this class is a breaking tag or not.
de: teilt mit, ob dies eine unterbrechende Markierungsklasse ist. Eine nicht unterbrechende (innenliegende) Markierung ist eine, die nicht als Teil des Inhalts einer anderen Markierung genommen werden kann. Sie kann die Werte false (0), true (1) oder undefiniert annehmen. Falls Sie dies undefiniert lassen, müssen Sie die Funktion f_breaking definieren, die aussagt, ob eine bestimmte Markierung dieser Klasse eine unterbrechende Markierung ist oder nicht.

note: type: textblock
en: It's a function that will tell if the next tag is a breaking one or not.  It should be defined if the B<breaking> option is not.
de: Es ist eine Funktion, die mitteilen wird, ob die nächste Markierung unterbrechend ist oder nicht. Sie sollte definiert sein, wenn die Option B<breaking> nicht definiert ist.

note: type: textblock
en: If you leave this key undefined, the generic extraction function will have to extract the tag itself.  It's useful for tags that can have other tags or special structures in them, so that the main parser doesn't get mad.  This function receives a boolean that says if the tag should be removed from the input stream or not.
de: Falls Sie diesen Schlüssel undefiniert lassen, muss die generische Extrahierfunktion die Markierung selbst extrahieren. Das ist nützlich für Markierungen, die andere Markierungen oder besondere Strukturen beinhalten können, so dass der Haupt-Parser nicht durchdreht. Diese Funktion bekommt einen logischen Wert, der aussagt, ob die Markierung aus dem Eingabedatenstrom entfernt werden soll oder nicht.

note: type: textblock
en: This function receives the tag (in the get_string_until() format) and returns the translated tag (translated attributes or all needed transformations) as a single string.
de: Diese Funktion erhält die Markierung (im Format get_string_until()) und gibt die übersetzte Markierung (übersetzte Attribute oder alle nötigen Umbildungen) als eine einzelne Zeichenkette zurück.

note: type: =head2
en: WORKING WITH TAGS
de: ARBEITEN MIT KENNZEICHEN

note: type: textblock
en: This function returns the path to the current tag from the document's root, in the form E<lt>htmlE<gt>E<lt>bodyE<gt>E<lt>pE<gt>.
de: Diese Funktion gibt den Pfad zur aktuellen Markierung von der Wurzel des Dokuments in der Form E<lt>htmlE<gt>E<lt>bodyE<gt>E<lt>pE<gt> zurück.

note: type: textblock
en: An additional array of tags (without brackets) can be passed as argument.  These path elements are added to the end of the current path.
de: Ein zusätzliches Feld von Markierungen (ohne Klammern) kann als Argument übergeben werden. Diese Pfadelemente werden am Ende des aktuellen Pfades hinzugefügt.

note: type: textblock
en: This function returns the index from the tag_types list that fits to the next tag in the input stream, or -1 if it's at the end of the input file.
de: Diese Funktion gibt den Index der Liste tag_types zurück, die zur nächsten Markierung des Eingabedatenstroms passt oder -1, falls es am Ende der Eingabedatei liegt.

note: type: textblock
en: Here, the tag has structure started by E<lt> and end by E<gt> and it can contain multiple lines.
de: Hier hat die Markierung eine Struktur, die mit E<lt> beginnt und E<gt> endet und mehrere Zeilen enthalten kann.

note: type: textblock
en: This works on the array C<< @{$self->{TT}{doc_in}} >> holding input document data and reference indirectly via C<< $self->shiftline() >> and C<< $self->unshiftline($$) >>.
de: Dies funktioniert auf dem Feld C<< @{$self->{TT}{doc_in}} >>, das Eingabedokumentdaten und indirekt mittels C<< $self->shiftline() >> und C<< $self->unshiftline($$) >> Referenzen enthält.

note: type: textblock
en: This function returns the next tag from the input stream without the beginning and end, in an array form, to maintain the references from the input file.  It has two parameters: the type of the tag (as returned by tag_type) and a boolean, that indicates if it should be removed from the input stream.
de: Diese Funktion gibt die nächste Markierung des Eingabedatenstroms ohne Anfang und Ende in Form eines Feldes zurück, um die Referenzen der Eingabedatei zu verwalten. Sie hat zwei Parameter: den Typ der Markierung (wie er von tag_type zurückgegeben wird) und einen logischen Wert, der angibt, ob die Markierung aus dem Eingabedatenstrom entfernt werden soll.

note: type: textblock
en: This function returns the name of the tag passed as an argument, in the array form returned by extract_tag.
de: Diese Funktion gibt den Namen der als Argument übergebenen Markierung in der Form eines durch extract_tag zurückgegebenen Feldes zurück.

note: type: textblock
en: This function returns a boolean that says if the next tag in the input stream is a breaking tag or not (inline tag).  It leaves the input stream intact.
de: Diese Funktion gibt einen logischen Wert zurück, der angibt, ob die nächste Markierung im Eingabedatenstrom eine unterbrechende Markierung ist oder nicht (innenliegende Markierung). Sie läßt den Eingabedatenstrom intakt.

note: type: textblock
en: This function translates the next tag from the input stream.  Using each tag type's custom translation functions.
de: Diese Funktion übersetzt die nächste Markierung des Eingabedatenstroms. Dabei benutzt sie die angepassten Übersetzungsfunktionen jedes Markierungstyps.

note: type: textblock
en: This function returns a string value that says if the first argument (a tag hierarchy) matches any of the tags from the second argument (a list of tags or tag hierarchies). If it doesn't match, it returns 0. Else, it returns the matched tag's options (the characters in front of the tag) or 1 (if that tag doesn't have options).
de: Diese Funktion gibt eine Zeichenkette zurück, die angibt, ob das erste Argument (eine Markierungshierarchie) zu einem der Markierungen des zweiten Arguments passt (eine Liste von Markierungen oder Markierungshierarchien). Falls es nicht passt, gibt sie 0 zurück. Ansonsten gibt sie die Optionen der passenden Markierung zurück (die Zeichen an Anfang der Markierung) oder 1 (falls die Markierung keine Optionen hat).

note: type: =head2
en: WORKING WITH ATTRIBUTES
de: MIT ATTRIBUTEN ARBEITEN

note: type: textblock
en: This function handles the translation of the tags' attributes. It receives the tag without the beginning / end marks, and then it finds the attributes, and it translates the translatable ones (specified by the module option B<attributes>).  This returns a plain string with the translated tag.
de: Diese Funktion handhabt die Übersetzung der Attribute von Markierungen. Sie erhält die Markierung ohne die Anfangs-/Endmarkierungen, sucht dann die Attribute und übersetzt die, die übersetzbar sind (angegeben durch die Moduloption B<attributes>). Dies gibt eine einfache Zeichenkette mit der übersetzten Markierung zurück.

note: type: =head2
en: WORKING WITH TAGGED CONTENTS
de: ARBEITEN MIT MARKIERTEN INHALTEN

note: type: textblock
en: This function gets the text until the next breaking tag (not inline) from the input stream.  Translate it using each tag type's custom translation functions.
de: Diese Funktion erhält Text aus dem Eingabedatenstrom bis zur nächsten unterbrechenden Markierung (nicht innenliegende). Übersetzen Sie ihn mittels der angepassten Übersetzungsfunktionen jedes Markierungstyps.

note: type: =head2
en: WORKING WITH THE MODULE OPTIONS
de: MIT DEN MODULOPTIONEN ARBEITEN

note: type: textblock
en: This function fills the internal structures that contain the tags, attributes and inline data with the options of the module (specified in the command-line or in the initialize function).
de: Diese Funktion füllt die internen Strukturen, die die Markierung, Attribute und innenliegenden Daten enthalten, mit den Optionen des Moduls (angegeben auf der Befehlszeile oder in der Initialisierungsfunktion).

note: type: =head2
en: GETTING TEXT FROM THE INPUT DOCUMENT
de: TEXT AUS DEM EINGABEDOKUMENT ERHALTEN

note: type: textblock
en: This function returns an array with the lines (and references) from the input document until it finds the first argument.  The second argument is an options hash. Value 0 means disabled (the default) and 1, enabled.
de: Diese Funktion gibt ein Feld mit den Zeilen (und Referenzen) vom Eingabedokument zurück, bis es das erste Argument findet. Das zweite Argument ist ein Options-Hash. Der Wert 0 bedeutet »deaktiviert« (die Vorgabe) und 1 »aktiviert«.

note: type: textblock
en: The valid options are:
de: Die gültigen Optionen sind:

note: type: textblock
en: This makes the returned array to contain the searched text
de: Dies sorgt dafür, dass das zurückgegebene Feld den gesuchten Text erhält.

note: type: textblock
en: This removes the returned stream from the input
de: Dies entfernt den zurückgegebenen Datenstrom aus der Eingabe.

note: type: textblock
en: This ensures that the searched text is outside any quotes
de: Dies stellt sicher, dass der gesuchte Text außerhalb irgendwelcher Anführungszeichen steht.

note: type: =item
en: B<regex>
de: B<RegAus>

note: type: textblock
en: This denotes that the first argument is a regular expression rather than an plain string
de: Dies zeigt an, dass das erste Argument ein regulärer Ausdruck statt einer einfachen Zeichenkette ist.

note: type: textblock
en: This function receives as argument the reference to a paragraph (in the format returned by get_string_until), skips his heading spaces and returns them as a simple string.
de: Diese Funktion erhält als Argument die Referenz eines Absatzes (im Format, das von get_string_until zurückgegeben wird), überspringt dessen führende Leerzeichen und gibt sie als einfache Zeichenkette zurück.

note: type: textblock
en: This function returns a simple string with the text from the argument array (discarding the references).
de: Diese Funktion liefert eine einfache Zeichenkette mit dem Text aus dem Argument-Feld (die Referenzen werden weggelassen).

note: type: textblock
en: This module can translate tags and attributes.
de: Dieses Modul kann Markierungen und Attribute übersetzen.

note: type: textblock
en: DOCTYPE (ENTITIES)
de: DOKUMENTENART (ENTITÄTEN)

note: type: textblock
en: There is a minimal support for the translation of entities. They are translated as a whole, and tags are not taken into account. Multilines entities are not supported and entities are always rewrapped during the translation.
de: Es gibt dort eine minimale Unterstützung für die Übersetzung vom Instanzen. Sie werden als Ganzes übersetzt und Markierungen werden nicht berücksichtigt. Mehrzeilige Entitäten werden nicht unterstützt und Entitäten werden während der Übersetzung immer neu umgebrochen.

note: type: textblock
en: MODIFY TAG TYPES FROM INHERITED MODULES (move the tag_types structure inside the $self hash?)
de: KENNZEICHENTYPEN VON GEERBTEN MODULEN (die Struktur tag_types innerhalb des Hashs $self verschieben?)

note: type: textblock
en: Locale::Po4a::Yaml - convert YAML files from/to PO files
de: Locale::Po4a::Yaml - konvertiert YAML-Dateien von/in PO-Dateien

note: type: textblock
en: Locale::Po4a::Yaml is a module to help the translation of Yaml files into other [human] languages.
de: Locale::Po4a::Yaml ist ein Modul, um bei der Übersetzung von Yaml-Dateien in andere [natürliche] Sprachen zu helfen.

note: type: textblock
en: The module extracts the value of YAML hashes and arrays. Hash keys are not extracted.
de: Dieses Modul zieht den Wert von YAML-Hashes und -Felder heraus. Hash-Schlüssel werden nicht herausgezogen.

note: type: textblock
en: NOTE: This module parses the YAML file with YAML::Tiny.
de: HINWEIS: Dieses Modul wertet die YAML-Datei mit YAML::Tiny aus.

note: type: textblock
en: Do not translate array values.
de: Keine Feldwerte übersetzen.
