po4a 0.73 - en to ro translation catalogue (1098 entries)

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

note: type: Content of: <refentry><refentryinfo>
en: <date>2006-04-08</date>
ro: <date>8 aprilie 2006</date>

note: type: Content of: <refentry><refmeta><refmiscinfo>
en: 2020-04-19
ro: 19 aprilie 2020

note: type: Content of: <refentry><refmeta><refmiscinfo>
en: Po4a Tools
ro: Instrumente po4a

note: type: Content of: <refentry><refnamediv><refpurpose>
en: display a translated man page according to a PO
ro: afișează o pagină de manual tradusă în conformitate cu un fișier PO

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>
ro: <command>po4a-display-man</command> <arg choice='plain'><option>-p</option> </arg> <arg choice='plain'><replaceable>FIȘIER_PO</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-m</option> </arg><arg choice='plain'><replaceable>FIȘIER_PRINCIPAL</replaceable></arg></arg> <arg choice='opt'><arg choice='plain'><option>-o</option> </arg><arg choice='plain'><replaceable>OPȚIUNI_PO4A</replaceable></arg></arg>

note: type: =head1
en: DESCRIPTION
ro: DESCRIERE

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.
ro: Traducătorii pot utiliza <command>po4a-display-man</command> pentru a vedea cum va fi redată utilizatorilor finali traducerea lor a unei pagini de manual, fără a recompila și reinstala întregul proiect.

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.
ro: Acest script funcționează numai cu pagini de manual scrise direct în <emphasis remap='I'>nroff</emphasis> și gestionate de modulul <emphasis remap='I'>man</emphasis> al po4a. Paginile manuale generate din alte formate, cum ar fi DocBook sau POD, nu sunt acceptate. Consultați <citerefentry><refentrytitle>po4a-display-pod</refentrytitle><manvolnum>1</manvolnum></citerefentry> pentru un echivalent care acceptă documentele <emphasis remap='I'>POD</emphasis>.

note: type: =head1
en: OPTIONS
ro: OPȚIUNI

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-p </option><replaceable>PO_FILE</replaceable>
ro: <option>-p </option><replaceable>FIȘIER_PO</replaceable>

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The PO file containing the translations.
ro: Fișierul PO care conține traducerile.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-m </option><replaceable>MASTER_FILE</replaceable>
ro: <option>-m </option><replaceable>FIȘIER_PRINCIPAL</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.
ro: Pagina de manual originală. Aceasta poate fi ruta absolută sau relativă către pagina de manual originală (comprimată cu «gzip» sau nu), numele paginii de manual sau numele și secțiunea paginii de manual (utilizând formatul man.secțiune). Atunci când documentul principal nu este prevăzut cu opțiunea <option>-m</option>, <command>po4a-display-man</command> încearcă să găsească pagina man originală pe baza referinței de linie a primului șir din PO.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-o </option><replaceable>PO4A_OPT</replaceable>
ro: <option>-o </option><replaceable>OPȚIUNI_PO4A</replaceable>

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>.
ro: Unele opțiuni de transmis către <citerefentry><refentrytitle>po4a-translate</refentrytitle><manvolnum>1</manvolnum></citerefentry>.

note: type: =head1
en: SEE ALSO
ro: CONSULTAȚI ȘI

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

note: type: Content of: <refentry><refentryinfo>
en: <date>2009-03-16</date>
ro: <date>16 martie 2009</date>

note: type: Content of: <refentry><refmeta><refmiscinfo>
en: 2009-03-16
ro: 16 martie 2009

note: type: Content of: <refentry><refnamediv><refpurpose>
en: display of a translated POD file according to a PO
ro: afișarea unui fișier POD tradus în conformitate cu un PO

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>
ro: <command>po4a-display-pod</command> <arg choice='plain'><option>-p </option></arg> <arg choice='plain'><replaceable>FIȘIER_PO</replaceable></arg> <arg choice='plain'><option>-m </option></arg> <arg choice='plain'><replaceable>FIȘIER_POD</replaceable></arg> <arg choice='opt'><arg choice='plain'><option>-o </option></arg><arg choice='plain'><replaceable>OPȚIUNI_PO4A</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.
ro: Traducătorii pot utiliza <command>po4a-display-pod</command> pentru a vedea cum va fi redată utilizatorilor finali traducerea lor a unei pagini de manual, fără a recompila și reinstala întregul proiect. De cele mai multe ori, fișierul POD este disponibil doar în pachetul sursă sau încorporat în scriptul Perl.

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><term>
en: <option>-m </option><replaceable>POD_FILE</replaceable>
ro: <option>-m </option><replaceable>FIȘIER_POD</replaceable>

note: type: Content of: <refentry><refsect1><variablelist><varlistentry><listitem><para>
en: The original POD file used by po4a to generate PO file.
ro: Fișierul POD original utilizat de po4a pentru a genera fișierul PO.

note: type: =head1
en: NAME
ro: NUME

note: type: textblock
en: po4a - update both the PO files and translated documents in one shot
ro: po4a - actualizează atât fișierele PO, cât și documentele traduse dintr-o singură lovitură

note: type: =head1
en: SYNOPSIS
ro: SINOPSIS

note: type: textblock
en: B<po4a> [I<options>] I<config_file>
ro: B<po4a> [I<opțiuni>] I<fișier-configurare>

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.
ro: po4a (PO pentru orice) facilitează întreținerea traducerii documentației utilizând instrumentele clasice gettext. Principala caracteristică a po4a este că decuplează traducerea conținutului de structura documentului. Vă rugăm să consultați pagina L<po4a(7)> pentru o introducere ușoară în acest proiect.

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.
ro: La execuție, B<po4a> analizează toate fișierele de documentație specificate în fișierul său de configurare. Acesta actualizează fișierele PO (care conțin traducerea) pentru a reflecta orice modificare a documentației și produce o documentație tradusă prin injectarea traducerii conținutului (găsit în fișierele PO) în structura documentului principal original.

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.
ro: La început, fișierele PO conțin doar șirurile care trebuie traduse din documentația originală. Acest format de fișier permite traducătorilor să furnizeze manual o traducere pentru fiecare paragraf extras de B<po4a>. Dacă documentația este modificată după traducere, B<po4a> marchează traducerile corespunzătoare ca „fuzzy” (traduceri aproximative) în fișierul PO pentru a solicita o revizuire manuală de către traducători. Traducătorii pot furniza, de asemenea, așa-numitele „addendum”, care sunt conținuturi suplimentare care precizează, de exemplu, cine a realizat traducerea și cum se pot raporta erorile.

note: type: verbatim
en:  master documents ---+---->-------->---------+
      (doc authoring)    |                       |
                         V   (po4a executions)   >-----+--> translated
                         |                       |     |     documents
     existing PO files -->--> updated PO files >-+     |
          ^                            |               |
          |                            V               |
          +----------<---------<-------+               ^
           (manual translation process)                |
                                                       |
     addendum -->--------------------------------------+
ro:  documente principale ---+---->-------->------->-------+
      (doc. redactate)       |                             |
                             V       (execuții po4a)       >-----+--> documente
                             |                             |     |     traduse
     fișiere PO existente  -->--> fişiere PO actualizate >-+     |
             ^                            |                      |
             |                            V                      |
             +----------<---------<-------+                      ^
             (procesul manual de traducere)                      |
                                                                 |
     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.
ro: Fluxul de lucru al B<po4a> este asincron, potrivit proiectelor de cod-sursă deschis. Autorii documentației scriu documentele principale în ritmul lor propriu. Traducătorii revizuiesc și actualizează traducerile din fișierele PO. Responsabilii de întreținere reiau B<po4a> la nevoie, pentru a reflecta în fișierele PO orice modificare a documentației originale și pentru a produce traduceri actualizate ale documentației, prin injectarea celei mai recente traduceri în cea mai recentă structură a documentului.

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.
ro: În mod implicit, un anumit document tradus este produs atunci când cel puțin 80% din conținutul său este tradus. Textul netradus este păstrat în limba originală. Documentația produsă amestecă astfel limbile dacă traducerea nu este completă. Puteți modifica pragul de 80% cu opțiunea I<--keep> descrisă mai jos. Rețineți totuși că eliminarea traducerilor de îndată ce acestea nu sunt 100% poate fi descurajantă pentru traducătorii a căror muncă nu va fi aproape niciodată prezentată utilizatorilor, în timp ce prezentarea „traducerilor” care sunt prea incomplete poate fi deranjantă pentru utilizatorii finali.

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.
ro: Stocarea fișierelor documentației traduse în sistemul de control al versiunii este probabil o idee proastă, deoarece acestea sunt generate automat. Fișierele prețioase sunt fișierele PO, care conțin munca grea a colegilor traducători. De asemenea, unele persoane consideră că este mai ușor să interacționeze cu traducătorii printr-o platformă activă în Internet, cum ar fi S<weblate>, dar acest lucru este, desigur, complet opțional.

note: type: =head2
en: Quick start tutorial
ro: Tutorial de inițiere rapidă

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.
ro: Să presupunem că mențineți un program numit B<foo> care are o pagină de manual F<man/foo.1> scrisă în limba engleză (limba punte în majoritatea proiectelor de cod sursă deschis, dar B<po4a> poate fi utilizat din sau către orice limbă). Cu ceva timp în urmă, cineva a furnizat o traducere în limba germană numită F<man/foo.de.1> și a dispărut. Aceasta este o problemă pentru că tocmai ați primit un raport de eroare care spune că documentația dvs. conține o informație grav-înșelătoare care trebuie corectată în toate limbile, dar nu vorbiți germana, deci puteți modifica doar originalul, nu și traducerea. Acum, un alt contribuitor dorește să contribuie cu o traducere în japoneză, o limbă pe care nici tu nu o stăpânești.

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.
ro: Este timpul să vă convertiți documentația în B<po4a> pentru a vă rezolva coșmarurile legate de întreținerea documentației. Doriți să actualizați documentația atunci când este necesar, doriți să ușurați munca colegilor dvs. traducători și doriți să vă asigurați că utilizatorii dvs. nu văd niciodată o documentație învechită și, prin urmare, înșelătoare.

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.
ro: Conversia include două etape: configurarea infrastructurii po4a și convertirea traducerii germane anterioare pentru a salva munca anterioară. Această ultimă parte este realizată utilizând S<po4a-gettextize>, după cum urmează. După cum se detaliază în documentația L<po4a-gettextize(1)>, acest proces rareori este complet automat, dar odată realizat, fișierul B<de.po> care conține traducerea germană poate fi integrat în fluxul de lucru po4a.

note: type: textblock
en: Let's now configure po4a. With the appropriate file layout, your configuration file could be as simple as this:
ro: Să configurăm acum po4a. Cu aspectul corespunzător al fișierului, fișierul dvs. de configurare ar putea fi la fel de simplu ca acesta:

note: type: textblock
en: It specifies that all PO files (containing the work of the translators) are in 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>.
ro: Aceasta specifică faptul că toate fișierele PO (care conțin munca traducătorilor) se află în directorul F<man/po4a/> și că aveți un singur fișier principal, F<man/foo.1>. Dacă ați avea mai multe fișiere principale, ați avea mai multe linii similare celei de-a doua. Fiecare astfel de linie specifică, de asemenea, unde să se scrie fișierele de traducere corespunzătoare. Aici, traducerea în limba germană a fișierului F<man/foo.1> este în 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.
ro: Ultimul lucru de care avem nevoie pentru a finaliza configurarea B<po4a> este un fișier POT care conține materialul șablon care ar trebui utilizat pentru a începe o nouă traducere. Creați pur și simplu un fișier gol cu extensia S<.pot> în directorul S<po_directory> specificat (de exemplu, F<man/po4a/foo.pot>), iar B<po4a> îl va umple cu conținutul așteptat.

note: type: textblock
en: Here is a recap of the files in this setup:
ro: Iată o recapitulare a fișierelor din această configurație:

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
ro:   ├── man/
      │   ├── foo.1        <- Pagina de manual originală, în limba engleză
      │   ├── po4a/
      │   │   ├── de.po    <- Traducerea PO în limba germană, de la gettextizare
      │   │   └── foo.pot  <- Șablonul POT al viitoarelor traduceri (gol la început)
      │   └── translated/  <- Directorul în care vor fi create traducerile
      └── po4a.cfg         <- Fișierul de configurare

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:
ro: Odată configurat, execuția B<po4a> va analiza documentația, va actualiza fișierul șablon POT, îl va utiliza pentru a actualiza fișierele de traducere PO și le va utiliza pentru a actualiza fișierele de traducere a documentației. Totul într-o singură comandă:

note: type: textblock
en: This is 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 a Japanese translator wants to contribute a new translation, she should rename the S<foo.pot> into S<ja.po> and complete the translation. Once you have this file, just drop it in F<man/po4a/po/>. A translated page will appear as F<man/translated/foo.ja.1> (provided that enough content is translated) when you run B<po4a> again.
ro: Asta este tot. B<po4a> este acum complet configurat. După ce ați corectat eroarea din F<man/foo.1>, paragraful incorect din traducerea în germană va fi înlocuit cu textul corectat în engleză. Amestecarea limbilor nu este optimă, dar este singura modalitate de a elimina erorile din traduceri pe care nici măcar nu le înțelegeți și de a vă asigura că conținutul prezentat utilizatorilor nu este niciodată înșelător. Actualizarea traducerii în limba germană este, de asemenea, mult mai ușoară în fișierul PO corespunzător, astfel încât amestecul de limbi poate să nu dureze mult. În cele din urmă, atunci când un traducător japonez dorește să contribuie cu o nouă traducere, ar trebui să redenumească fișierul S<foo.pot> în S<ja.po> și să completeze traducerea. Odată ce aveți acest fișier, introduceți-l în F<man/po4a/po/>. O pagină tradusă va apărea ca F<man/translated/foo.ja.1> (cu condiția ca o cantitate suficientă de conținut să fie tradusă) atunci când executați din nou B<po4a>.

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.
ro: Pragul minim pentru procentul de traducere pentru a păstra (adică a scrie) fișierul rezultat (implicit: 80). Adică, în mod implicit, fișierele trebuie să fie traduse la cel puțin 80% pentru a fi scrise pe disc.

note: type: textblock
en: Column at which we should wrap the resulting file if the format supports it (default: 76).
ro: Coloana la care ar trebui să încadrăm fișierul rezultat dacă formatul acceptă acest lucru (implicit: 76).

note: type: textblock
en: Show a short help message.
ro: Afișează un scurt mesaj de ajutor.

note: type: textblock
en: Charset of the files containing the documents to translate. Note that all master documents must use the same charset.
ro: Setul de caractere al fișierelor care conțin documentele de tradus. Rețineți că toate documentele principale trebuie să utilizeze același set de caractere.

note: type: textblock
en: Charset of the files containing the localized documents. Note that all translated documents will use the same charset.
ro: Setul de caractere al fișierelor care conțin documentele de tradus. Rețineți că toate documentele traduse vor utiliza același set de caractere.

note: type: textblock
en: Charset of the addenda. Note that all the addenda should be in the same charset.
ro: Setul de caractere al addendei. Rețineți că toate addendele trebuie să fie în același set de caractere.

note: type: textblock
en: Display the version of the script and exit.
ro: Afișează versiunea scriptului și iese.

note: type: textblock
en: Increase the verbosity of the program.
ro: Crește nivelul de detaliere al programului.

note: type: textblock
en: Decrease the verbosity of the program.
ro: Reduce nivelul de detaliere al programului.

note: type: textblock
en: Output some debugging information.
ro: Afișează unele informații de depanare.

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'.
ro: Opțiuni suplimentare pe care să le transmiteți modulului de format. Consultați documentația fiecărui modul pentru mai multe informații despre opțiunile valide și semnificațiile acestora. De exemplu, ați putea transmite „-o tablecells” analizatorului AsciiDoc, în timp ce analizatorul de text ar accepta „-o tabs=split”.

note: type: textblock
en: Always generate the POT and PO files, even if B<po4a> considers it is not necessary.
ro: Generează întotdeauna fișierele POT și PO, chiar dacă B<po4a> consideră că nu este necesar.

note: type: textblock
en: The default behavior (when B<--force> is not specified) is the following:
ro: Comportamentul implicit (atunci când opțiunea B<--force> nu este specificată) este următorul:

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.
ro: În cazul în care fișierul POT există deja, acesta este regenerat dacă un document principal sau fișierul de configurare este mai recent (cu excepția cazului în care se furnizează B<--no-update>). De asemenea, fișierul POT este scris într-un document temporar, iar B<po4a> verifică dacă modificările sunt într-adevăr necesare.

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>).
ro: De asemenea, o traducere este regenerată numai dacă documentul său principal, fișierul PO, unul dintre addenda sau fișierul de configurare este mai recent. Pentru a evita încercarea de regenerare a traducerilor care nu trec testul pragului (a se vedea B<--keep>), poate fi creat un fișier cu extensia F<.po4a-stamp> (a se vedea 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.
ro: Dacă un document principal include fișiere, trebuie să utilizați marcajul B<--force> deoarece timpul de modificare al acestor fișiere incluse nu este luat în considerare.

note: type: textblock
en: The PO files are always re-generated based on the POT with B<msgmerge -U>.
ro: Fișierele PO sunt întotdeauna re-generate pe baza POT cu B<msgmerge -U>.

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.
ro: Îi indică lui B<po4a> să creeze fișiere ștampilă (marcă-de-timp) atunci când o traducere nu este generată deoarece nu atinge pragul. Aceste fișiere ștampilă sunt denumite în funcție de documentul tradus așteptat, cu extensia F<.po4a-stamp>.

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.
ro: Notă: Aceasta activează doar crearea fișierelor F<.po4a-stamp>. Fișierele ștampilă sunt întotdeauna utilizate dacă există și sunt eliminate cu B<--rm-translations> sau atunci când fișierul este tradus definitiv.

note: type: textblock
en: Do not generate the translated documents, only update the POT and PO files.
ro: Nu generează documentele traduse, ci doar actualizează fișierele POT și PO.

note: type: textblock
en: Do not change the POT and PO files, only the translation may be updated.
ro: Nu modifică fișierele POT și PO, doar traducerea poate fi actualizată.

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.
ro: Păstrează fișierele de traducere existente chiar dacă traducerea nu atinge pragul specificat de B<--keep>. Această opțiune nu creează noi fișiere de traducere cu conținut redus, dar va salva traducerile existente care se degradează din cauza modificărilor aduse fișierelor principale.

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.
ro: AVERTISMENT: Această opțiune schimbă comportamentul po4a într-un mod destul de drastic: fișierele dvs. traduse nu vor fi actualizate deloc până când traducerea nu se îmbunătățește. Utilizați această opțiune numai dacă preferați să trimiteți o documentație tradusă învechită în loc să trimiteți o documentație netradusă corectă.

note: type: textblock
en: Remove the translated files (implies B<--no-translations>).
ro: Elimină fișierele traduse (implică B<--no-translations>).

note: type: textblock
en: This flag does nothing since 0.41, and may be removed in later releases.
ro: Această opțiune nu are niciun efect de la versiunea 0.41 și poate fi eliminată în versiunile ulterioare.

note: type: =item
en: B<--translate-only> I<translated-file>
ro: B<--translate-only> I<fișier-traducere>

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.
ro: Traduce numai fișierul specificat. Aceasta poate fi utilă pentru a accelera procesarea dacă un fișier de configurare conține multe fișiere. Rețineți că această opțiune nu actualizează fișierele PO și POT. Această opțiune poate fi utilizată de mai multe ori.

note: type: =item
en: B<--variable> I<var>B<=>I<value>
ro: B<--variable> I<variabilă>B<=>I<valoare>

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.
ro: Definește o variabilă care va fi extinsă în fișierul de configurare B<po4a>. Fiecare apariție a lui I<$(var)> va fi înlocuită cu I<valoare>. Această opțiune poate fi utilizată de mai multe ori.

note: type: =item
en: B<--srcdir> I<SRCDIR>
ro: B<--srcdir> I<DIR_SURSĂ>

note: type: textblock
en: Set the base directory for all input documents specified in the B<po4a> configuration file.
ro: Definește directorul de bază pentru toate documentele de intrare specificate în fișierul de configurare B<po4a>.

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.
ro: Dacă sunt specificate atât I<DIR_DESTINAȚIE>, cât și I<DIR_SURSĂ>, fișierele de intrare sunt căutate în următoarele directoare, în ordine: I<DIR_DESTINAȚIE>, directorul curent și I<DIR_SURSĂ>. Fișierele de ieșire sunt scrise în I<DIR_DESTINAȚIE>, dacă este specificat, sau în directorul curent.

note: type: =item
en: B<--destdir> I<DESTDIR>
ro: B<--destdir> I<DIR_DESTINAȚIE>

note: type: textblock
en: Set the base directory for all the output documents specified in the B<po4a> configuration file (see B<--srcdir> above).
ro: Definește directorul de bază pentru toate documentele de ieșire specificate în fișierul de configurare B<po4a> (a se vedea opțiunea B<--srcdir> de mai sus).

note: type: =head2
en: Options modifying the POT header
ro: Opțiuni ce modifică antetul POT

note: type: =item
en: B<--porefs> I<type>
ro: B<--porefs> I<tip>

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).
ro: Specifică formatul referinței. Argumentul I<tip> poate fi unul dintre B<never> pentru a nu produce nicio referință, B<file> pentru a specifica doar fișierul fără numărul de linie, B<counter> pentru a înlocui numărul de linie cu un contor crescător și B<full> pentru a include referințe complete (implicit: full).

note: type: =item
en: B<--wrap-po> B<no>|B<newlines>|I<number> (default: 76)
ro: B<--wrap-po> B<no>|B<newlines>|I<număr> (implicit: 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.
ro: Specifică modul în care liniile din fișierul po ar trebui să fie încadrate. Acest lucru oferă posibilitatea de a alege între fișiere care sunt bine ajustate ca încadrare, dar ar putea duce la conflicte git, sau fișiere care sunt mai ușor de gestionat automat, dar mai greu de citit pentru oameni.

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.
ro: Din punct de vedere istoric, suita gettext a reformatat fișierele po la a 77-a coloană pentru cosmetică. Această opțiune specifică comportamentul lui po4a. Dacă este definită la o valoare numerică, po4a va împacheta fișierul po după această coloană și după noile linii din conținut. Dacă este definită la B<newlines>, po4a va împărți doar msgid și msgstr după linii noi din conținut. Dacă este definită la B<no>, po4a nu va încadra deloc fișierul po. Comentariile de referință sunt întotdeauna încadrate de instrumentele gettext pe care le folosim intern.

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.
ro: Rețineți că această opțiune nu are niciun impact asupra modului în care msgid și msgstr sunt încadrate, adică asupra modului în care sunt adăugate linii noi la conținutul acestor șiruri.

note: type: textblock
en: Language of the source files containing the documents to translate. Note that all master documents must use the same language.
ro: Limba fișierelor sursă care conțin documentele de tradus. Rețineți că toate documentele principale trebuie să utilizeze aceeași limbă.

note: type: =item
en: B<--msgid-bugs-address> I<email@address>
ro: B<--msgid-bugs-address> I<adresă@poștă.electronică>

note: type: textblock
en: Set the report address for msgid bugs. By default, the created POT files have no Report-Msgid-Bugs-To fields.
ro: Definește adresa de raportare pentru erori din msgid. În mod implicit, fișierele POT create nu au câmpuri Report-Msgid-Bugs-To.

note: type: =item
en: B<--copyright-holder> I<string>
ro: B<--copyright-holder> I<șir>

note: type: textblock
en: Set the copyright holder in the POT header. The default value is "Free Software Foundation, Inc."
ro: Definește deținătorul drepturilor de autor în antetul POT. Valoarea implicită este „Free Software Foundation, Inc.”

note: type: =item
en: B<--package-name> I<string>
ro: B<--package-name> I<șir>

note: type: textblock
en: Set the package name for the POT header. The default is "PACKAGE".
ro: Definește numele pachetului pentru antetul POT. Valoarea implicită este „PACKAGE”.

note: type: =item
en: B<--package-version> I<string>
ro: B<--package-version> I<șir>

note: type: textblock
en: Set the package version for the POT header. The default is "VERSION".
ro: Definește versiunea pachetului pentru antetul POT. Valoarea implicită este „VERSION”.

note: type: =head2
en: Options to modify the PO files
ro: Opțiuni pentru modificarea fișierelor PO

note: type: =item
en: B<--msgmerge-opt> I<options>
ro: B<--msgmerge-opt> I<opțiuni>

note: type: textblock
en: Extra options for B<msgmerge>(1).
ro: Opțiuni suplimentare pentru B<msgmerge>(1).

note: type: textblock
en: Note: B<$lang> will be extended to the current language.
ro: Notă: B<$lang> va fi extins la limba curentă.

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.
ro: Această opțiune elimină B<--previous> din opțiunile transmise către B<msgmerge>. Acest lucru este necesar pentru a oferi suport versiunilor de B<gettext> anterioare versiunii 0.16.

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.
ro: Această opțiune adaugă B<--previous> la opțiunile transmise către B<msgmerge>. Aceasta necesită B<gettext> 0.16 sau o versiune ulterioară și este activată implicit.

note: type: =head1
en: CONFIGURATION FILE
ro: FIȘIERUL DE CONFIGURARE

note: type: textblock
en: po4a expects a configuration file as argument. This file must contain the following elements:
ro: po4a așteaptă ca argument un fișier de configurare. Acest fișier trebuie să conțină următoarele elemente:

note: type: textblock
en: The path to the PO files and the list of languages existing in the project;
ro: Ruta către fișierele PO și lista de limbi existente în proiect;

note: type: textblock
en: Optionally, some global options and so-called configuration aliases that are used as templates to configure individual master files;
ro: Opțional, unele opțiuni globale și așa-numitele alias de configurare care sunt utilizate ca șabloane pentru a configura fișiere principale individual;

note: type: textblock
en: The list of each master file to translate, along with specific parameters.
ro: Lista fiecărui fișier principal de tradus, împreună cu parametrii specifici.

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.
ro: Toate liniile conțin o comandă între paranteze drepte, urmată de parametrii acesteia. Comentariile încep cu caracterele „#” și continuă până la sfârșitul liniei. Puteți eluda sfârșitul liniei pentru a întinde o comandă pe mai multe linii.

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.
ro: Unele exemple complete sunt prezentate pe această pagină, în timp ce alte exemple pot fi găsite în directorul C<t/cfg> al distribuției sursă.

note: type: =head2
en: Finding the PO and POT files
ro: Găsirea fișierelor PO și POT

note: type: textblock
en: The simplest solution is to explicitly give the path to POT and PO files, as follows:
ro: Cea mai simplă soluție este de a indica în mod explicit ruta către fișierele POT și PO, după cum urmează:

note: type: textblock
en: This specifies the path to the POT file first, and then the paths to the German and French PO files.
ro: Aceasta specifică mai întâi ruta către fișierul POT și apoi rutele către fișierele PO în limbile germană și franceză.

note: type: textblock
en: The same information can be written as follows to reduce the risk of copy/paste errors:
ro: Aceleași informații pot fi scrise după cum urmează pentru a reduce riscul de erori de copiere/lipire:

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.
ro: Componenta C<$lang> este extinsă automat folosind lista de limbi furnizată, reducând riscul de erori de copiere/lipire atunci când este adăugată o limbă nouă.

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.
ro: Puteți compacta în continuare aceleași informații furnizând doar ruta către directorul care conține proiectul dvs. de traducere, după cum urmează.

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).
ro: Directorul furnizat trebuie să conțină un set de fișiere PO, fiecare denumit F<XX.po>, C<XX> fiind codul ISO 639-1 al limbii utilizate în acest fișier. Directorul trebuie să conțină, de asemenea, un singur fișier POT, cu extensia de fișier C<.pot>. Pentru prima rulare, acest fișier poate fi gol, dar trebuie să existe (po4a nu poate ghici numele de utilizat înainte de extensie).

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.
ro: Rețineți că trebuie să alegeți doar una dintre variantele C<po_directory> și C<po4a_paths>. Prima (C<po_directory>) este mai compactă, reduce și mai mult riscul erorilor de copiere/lipire, dar vă obligă să utilizați structura de proiect și numele de fișiere așteptate. A doua (C<po4a_paths>), este mai explicită, probabil mai ușor de citit și este recomandată atunci când configurați primul proiect cu po4a.

note: type: =head3
en: Centralized or split PO files?
ro: Fișiere PO centralizate sau divizate?

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.
ro: În mod implicit, po4a produce un singur fișier PO pentru fiecare limbă țintă, conținând întregul conținut al proiectului dvs. de traducere. Pe măsură ce proiectul dumneavoastră crește, dimensiunea acestor fișiere poate deveni problematică. Atunci când utilizați weblate, este posibil să specificați priorități pentru fiecare segment de traducere (de exemplu, msgid), astfel încât cele importante să fie traduse primele. Totuși, unele echipe de traducători preferă să împartă conținutul în mai multe fișiere.

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.
ro: Pentru a avea un fișier PO pentru fiecare fișier principal, trebuie doar să utilizați șirul C<$master> în numele fișierelor PO de pe linia C<[po4a_paths]>, după cum urmează.

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.
ro: Cu această linie, po4a va produce fișiere POT și PO separate pentru fiecare document de tradus. De exemplu, dacă aveți 3 documente și 5 limbi, aceasta va avea ca rezultat 3 fișiere POT și 15 fișiere PO. Aceste fișiere sunt denumite după cum se specifică în șablonul C<po4a_paths>, cu C<$master> înlocuit cu numele de bază al fiecărui document de tradus. În caz de conflict de nume, puteți specifica fișierul POT de utilizat după cum urmează, cu parametrul C<pot=>.

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>).
ro: Această caracteristică poate fi utilizată și pentru a grupa mai multe fișiere traduse în același fișier POT. Următorul exemplu produce doar 2 fișiere POT: F<l10n/po/foo.pot> (conținând materialul din F<foo/gui.xml>) și F<l10n/po/bar.pot> (conținând materialul din F<bar/gui.xml> și F<bar/cli.xml>).

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.
ro: În modul divizare, B<po4a> construiește un compendiu temporar în timpul actualizării PO, pentru a partaja traducerile între toate fișierele PO. În cazul în care două fișiere PO au traduceri diferite pentru același șir de caractere, B<po4a> va marca acest șir ca fiind fuzzy și va prezenta ambele traduceri în toate fișierele PO care conțin acest șir de caractere. În cazul în care traductorul a eliminat fuzzy-ul, traducerea este utilizată automat în toate fișierele PO.

note: type: =head2
en: Specifying the documents to translate
ro: Specificarea documentelor de tradus

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. File names should be quoted or escaped if they contain spaces. Here is an example:
ro: De asemenea, trebuie să listați documentele care trebuie traduse. Pentru fiecare fișier principal, trebuie să specificați analizatorul de format care urmează să fie utilizat, locația documentului tradus care urmează să fie produs și, opțional, o anumită configurare. Numele fișierelor trebuie să fie puse între ghilimele sau eludate dacă conțin spații. Iată un exemplu:

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:
ro: Dar, din nou, aceste linii complexe sunt dificil de citit și de modificat, de exemplu atunci când se adaugă un nou limbaj. Este mult mai simplu să reorganizați lucrurile folosind șablonul C<$lang> după cum urmează:

note: type: =head2
en: Specifying options
ro: Specificarea opțiunilor

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.
ro: Există două tipuri de opțiuni: I<opțiuni po4a> sunt valorile implicite ale opțiunilor din linia de comandă po4a, în timp ce I<opțiuni format> sunt utilizate pentru a modifica comportamentul analizatorilor de format. Ca I<opțiuni po4a>, ați putea, de exemplu, să specificați în fișierul dvs. de configurare că valoarea implicită a parametrului de linie de comandă B<--keep> este 50% în loc de 80%. I<Opțiunile de format> sunt documentate pe pagina specifică a fiecărui modul de analizare, de exemplu L<Locale::Po4a::Xml(3pm)>. Ați putea, de exemplu, să treceți B<nostrip> analizorului XML pentru a nu elimina spațiile din jurul șirurilor extrase.

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).
ro: Puteți trece aceste opțiuni pentru un anumit fișier principal sau chiar pentru o anumită traducere a fișierului respectiv, utilizând C<opt:> și C<opt_XX:> pentru limba C<XX>. În exemplul următor, opțiunea B<nostrip> este transmisă analizatorului XML (pentru toate limbile), în timp ce pragul va fi redus la 0% pentru traducerea în franceză (care este astfel păstrată întotdeauna).

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:
ro: În orice caz, aceste bucăți de configurare trebuie să fie situate la sfârșitul liniei. Declarația fișierelor trebuie să fie prima, apoi addendumul, dacă există (a se vedea mai jos), și apoi doar opțiunile. Gruparea bucăților de configurare nu este foarte importantă, deoarece elementele sunt concatenate intern ca șiruri de caractere. Exemplele următoare sunt toate echivalente:

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.
ro: Rețineți că opțiunile specifice fiecărei limbi nu sunt utilizate la crearea fișierului POT. De exemplu, este imposibil să transmiteți B<nostrip> analizatorului doar atunci când creați traducerea în franceză, deoarece același fișier POT este utilizat pentru actualizarea fiecărei limbi. Prin urmare, singurele opțiuni care pot fi specifice unei limbi sunt cele care sunt utilizate la realizarea traducerii, cum ar fi opțiunea C<--keep>.

note: type: =head3
en: Configuration aliases
ro: Alias de configurare

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.
ro: Pentru a transmite aceleași opțiuni mai multor fișiere, cel mai bine este să definiți un alias de tip după cum urmează. În exemplul următor, C<--keep 0> este transmis la fiecare traducere italiană folosind acest tip C<test>, adică o extensie a tipului C<man>.

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.
ro: De asemenea, puteți extinde un tip existent reutilizând același nume pentru alias, după cum urmează. Aceasta nu este interpretată ca o definiție recursivă eronată.

note: type: =head3
en: Global default options
ro: Opțiuni implicite globale

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.
ro: De asemenea, puteți utiliza liniile C<[options]> pentru a defini opțiuni care trebuie utilizate pentru toate fișierele, indiferent de tipul acestora.

note: type: textblock
en: As with the command line options, you can abbreviate the parameters passed in the configuration file:
ro: Ca și în cazul opțiunilor din linia de comandă, puteți abrevia parametrii trecuți în fișierul de configurare:

note: type: =head3
en: Option priorities
ro: Prioritatea opțiunilor

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:
ro: Opțiunile fiecărei surse sunt concatenate, asigurându-se că valorile implicite pot fi ușor anulate prin opțiuni mai specifice. Ordinea este următoarea:

note: type: textblock
en: C<[options]> lines provide default values that can be overridden by any other source.
ro: Liniile C<[options]> furnizează valori implicite care pot fi anulate de orice altă sursă.

note: type: textblock
en: Type aliases are then used. Language specific settings override the ones applicable to all languages.
ro: Se utilizează apoi alias de tip. Opțiuniile specifice limbii prevalează asupra celor aplicabile tuturor limbilor.

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.
ro: Opțiunile specifice unui anumit fișier principal prevalează atât asupra celor implicite, cât și asupra celor care provin din pseudonimul de tip. De asemenea, în acest caz, opțiunile specifice limbii prevalează asupra celor globale.

note: type: textblock
en: Finally, parameters provided on the B<po4a> command line override any settings from the configuration file.
ro: În cele din urmă, parametrii furnizați în linia de comandă B<po4a> prevalează asupra oricăror opțiuni din fișierul de configurare.

note: type: =head3
en: Example
ro: Exemplu

note: type: textblock
en: Here is an example showing how to quote the spaces and quotes:
ro: Iată un exemplu care arată cum să citați spațiile și ghilimelele:

note: type: =head2
en: Addendum: Adding extra content in the translation
ro: Addendum: Adăugarea de conținut suplimentar în traducere

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.
ro: Dacă doriți să adăugați o secțiune suplimentară la traducere, de exemplu pentru a acorda mulțumiri traducătorului, atunci trebuie să definiți un addendum la linia care definește fișierul principal. Vă rugăm să consultați pagina L<po4a(7)> pentru mai multe detalii privind sintaxa fișierelor addendum.

note: type: textblock
en: You can also use language templates as follow:
ro: De asemenea, puteți utiliza șabloane de limbă după cum urmează:

note: type: textblock
en: If an addendum fails to apply, the translation is discarded.
ro: Dacă un addendum eșuează la aplicare, traducerea este respinsă.

note: type: =head3
en: Modifiers for the addendum declaration
ro: Modificatori pentru declarația de addendum

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.
ro: Modificatorii de addendum pot simplifica fișierul de configurare în cazul în care nu toate limbile furnizează un addendum sau atunci când lista de addendumuri se modifică de la o limbă la alta. Modificatorul este un singur caracter situat înaintea numelui fișierului.

note: type: textblock
en: Include I<addendum_path> if this file does exist, otherwise do nothing.
ro: Include I<ruta_la_addendum> dacă acest fișier există, altfel nu face nimic.

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.
ro: I<ruta_la_addendum> nu este un addendum obișnuit, ci un fișier care conține o listă de addenda, rând pe rând. Fiecare addendum poate fi precedat de modificatori.

note: type: textblock
en: I<addendum_path> is discarded, it is not loaded and will not be loaded by any further addendum specification.
ro: I<ruta_la_addendum> (fișierul către care arată) este înlăturat, nu este încărcat și nu va fi încărcat de nicio altă specificație de addendum.

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.
ro: Următoarele includ un addendum în orice limbă, dar numai dacă acesta există. Nu este raportată nicio eroare dacă addendumul nu există.

note: type: textblock
en: The following includes a list of addendum for every language:
ro: Următoarele includ o listă de addendumuri pentru fiecare limbă:

note: type: =head2
en: Filtering the translated strings
ro: Filtrarea șirurilor traduse

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:
ro: Uneori, doriți să ascundeți anumite șiruri de caractere de procesul de traducere. În acest scop, puteți oferi un parametru C<pot_in> fișierului principal pentru a specifica numele fișierului care urmează să fie utilizat în locul fișierului principal real la construirea fișierului POT. Iată un exemplu:

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.
ro: Cu această configurare, șirurile de caractere de tradus vor fi extrase din F<book-filtered.xml> (care trebuie produs înainte de a apela B<po4a>), în timp ce fișierele traduse vor fi construite din F<book.xml>. Ca urmare, orice șir care face parte din F<book.xml>, dar nu din F<book-filtered.xml> nu va fi inclus în fișierele PO, împiedicând traducătorii să furnizeze o traducere pentru acestea. Astfel, aceste șiruri de caractere vor rămâne nemodificate la producerea documentelor traduse. Acest lucru scade în mod natural nivelul de traducere, astfel încât este posibil să aveți nevoie de opțiunea C<--keep> pentru a vă asigura că documentul este produs oricum.

note: type: =head1
en: AUTHORS
ro: AUTORI

note: type: =head1
en: COPYRIGHT AND LICENSE
ro: DREPTURI DE AUTOR și LICENȚĂ

note: type: textblock
en: Copyright 2002-2023 by SPI, inc.
ro: Drepturi de autor 2002-2023 pentru SPI, inc.

note: type: textblock
en: This program is free software; you may redistribute it and/or modify it under the terms of GPL v2.0 or later (see the COPYING file).
ro: Acest program este software liber; îl puteți redistribui și/sau modifica în conformitate cu termenii GPL v2.0 sau o versiune ulterioară (consultați fișierul COPYING).

note: type: textblock
en: po4a-gettextize - convert an original file (and its translation) to a PO file
ro: po4a-gettextize - convertește un fișier original (și traducerea sa) într-un fișier PO

note: type: textblock
en: B<po4a-gettextize> B<-f> I<fmt> B<-m> I<master.doc> B<-l> I<XX.doc> B<-p> I<XX.po>
ro: B<po4a-gettextize> B<-f> I<fmt> B<-m> I<principal.doc> B<-l> I<XX.doc> B<-p> I<XX.po>

note: type: textblock
en: (I<XX.po> is the output, all others are inputs)
ro: (I<XX.po> este ieșirea, toate celelalte sunt intrările)

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.
ro: Scriptul B<po4a-gettextize> vă ajută să convertiți traducerile existente anterior într-un flux de lucru bazat pe po4a. Acest lucru trebuie făcut o singură dată pentru a salva o traducere existentă în timpul conversiei în po4a, nu în mod regulat după conversia proiectului dvs. Acest proces anevoios este explicat în detaliu în secțiunea „Conversia unei traduceri manuale în po4a” de mai jos.

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.
ro: Trebuie să furnizați atât un fișier principal (de exemplu, sursa în limba engleză), cât și un fișier tradus existent (de exemplu, o încercare anterioară de traducere fără po4a). Dacă furnizați mai multe fișiere principale sau de traducere, acestea vor fi utilizate în succesiune, dar poate fi mai ușor să „gettextizați” fiecare pagină sau capitol separat și apoi să utilizați B<msgmerge> pentru a fuziona toate fișierele PO produse. După cum doriți.

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.
ro: Dacă documentul principal are caractere non-ASCII, noul fișier PO generat va fi în UTF-8. Dacă documentul principal este complet în ASCII, PO generat va utiliza codificarea documentului de intrare tradus.

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.
ro: Formatul documentației pe care doriți să o gestionați. Utilizați opțiunea B<--help-format> pentru a vedea lista de formate disponibile.

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.
ro: Fișier care conține documentul principal de tradus. Puteți utiliza această opțiune de mai multe ori dacă doriți să „gettextizați” mai multe documente.

note: type: textblock
en: Charset of the file containing the document to translate.
ro: Setul de caractere al fișierului care conține documentul de tradus.

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.
ro: Fișier care conține documentul localizat (tradus). Dacă ați furnizat mai multe fișiere principale, este posibil să doriți să furnizați mai multe fișiere localizate prin utilizarea acestei opțiuni de mai multe ori.

note: type: textblock
en: Charset of the file containing the localized document.
ro: Setul de caractere al fișierului care conține documentul localizat.

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.
ro: Fișier în care ar trebui scris catalogul de mesaje. Dacă nu este dat, catalogul de mesaje va fi scris la ieșirea standard.

note: type: textblock
en: List the documentation formats understood by po4a.
ro: Enumeră formatele de documentație înțelese de po4a.

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.
ro: Păstrează fișierele principale temporare și fișierele POT localizate construite înainte de fuzionare. Acest lucru poate fi util pentru a înțelege de ce aceste fișiere se desincronizează, ducând la probleme de gettextizare.

note: type: =head2
en: Converting a manual translation to po4a
ro: Conversia unei traduceri manuale în 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.
ro: B<po4a-gettextize> sincronizează fișierele principale și localizate pentru a extrage conținutul acestora într-un fișier PO. Conținutul fișierului principal dă B<msgid>, în timp ce conținutul fișierului localizat dă B<msgstr>. Acest proces este oarecum fragil: al N-lea șir din fișierul tradus ar trebui să fie traducerea celui de-al N-lea șir din original.

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.
ro: Gettextizarea funcționează cel mai bine dacă reușiți să recuperați versiunea exactă a documentului original care a fost utilizat pentru traducere. Chiar și așa, este posibil să fie nevoie să vă descurcați atât cu fișierele principale, cât și cu cele localizate pentru a le alinia structura dacă aceasta a fost modificată de traducătorul original, astfel încât este recomandat să lucrați pe copii ale fișierelor.

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.
ro: La nivel intern, fiecare analizator po4a raportează tipul sintactic al fiecărui șir de caractere extras. Acesta este modul în care sunt detectate desincronizările în timpul gettextizării. În exemplul prezentat mai jos, este foarte puțin probabil ca al 4-lea șir din traducere (de tip „capitol”) să fie traducerea celui de-al 4-lea șir din original (de tip „paragraf”). Este mai probabil ca un nou paragraf să fi fost adăugat la original sau ca două paragrafe originale să fi fost fuzionate în traducere.

note: type: verbatim
en:     Original         Translation
ro:     Original         Traducerea

note: type: verbatim
en:   chapter            chapter
        paragraph          paragraph
        paragraph          paragraph
        paragraph        chapter
      chapter              paragraph
        paragraph          paragraph
ro:   capitol            capitol
        paragraf           paragraf
        paragraf           paragraf
        paragraf         capitol
      capitol              paragraf
        paragraf           paragraf

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.
ro: B<po4a-gettextize> va diagnostica foarte detaliat orice desincronizare a structurii. Atunci când se întâmplă acest lucru, ar trebui să editați manual fișierele pentru a adăuga paragrafe false sau pentru a elimina unele conținuturi ici și colo până când structura ambelor fișiere se potrivește cu adevărat. Mai jos sunt prezentate câteva trucuri pentru a salva cea mai mare parte din traducerea existentă în acest timp.

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.
ro: Dacă sunteți suficient de norocos să aveți o potrivire perfectă în structurile de fișiere din cutie, construirea unui fișier PO corect este o chestiune de secunde. În caz contrar, veți înțelege în curând de ce acest proces are un nume atât de urât :) Chiar și așa, „gettextizarea” rămâne adesea mai rapidă decât traducerea din nou a tot. Am „gettextizat” traducerea în franceză a întregii documentații Perl într-o singură zi, în ciuda I<multor> probleme de sincronizare. Având în vedere cantitatea de text (2 Mo de text original), reînceperea traducerii fără a salva mai întâi vechile traduceri ar fi necesitat mai multe luni de muncă. În plus, această muncă brută este prețul de plătit pentru a obține confortul po4a. Odată convertită, sincronizarea între documentele principale și traduceri va fi întotdeauna complet automată.

note: type: textblock
en: After a successful gettextization, the produced documents should be manually checked for undetected disparities and silent errors, as explained below.
ro: După o gettextizare reușită, documentele produse ar trebui să fie verificate manual pentru disparități nedetectate și erori silențioase, după cum se explică mai jos.

note: type: =head3
en: Hints and tricks for the gettextization process
ro: Sfaturi și trucuri pentru procesul de „gettextizare”

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.
ro: Gettextizarea se oprește imediat ce este detectată o desincronizare. Când se întâmplă acest lucru, trebuie să editați fișierele atât cât este necesar pentru a realinia structurile fișierelor. B<po4a-gettextize> este destul de „guraliv” atunci când lucrurile merg prost. Acesta raportează șirurile care nu se potrivesc, pozițiile lor în text și tipul fiecăruia dintre ele. În plus, fișierul PO generat până acum este transferat ca F<gettextization.failed.po> pentru o inspecție ulterioară.

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:
ro: Iată câteva trucuri pentru a vă ajuta în acest proces anevoios și pentru a vă asigura că salvați cea mai mare parte din traducerea anterioară:

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 addenda (see L<po4a(7)>).
ro: Eliminați tot conținutul suplimentar al traducerilor, cum ar fi secțiunea care oferă credite (recunoașterea meritelor, mulțumiri, ș.a.) traducătorilor. Acestea ar trebui adăugate separat la B<po4a> ca addenda (a se vedea 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.
ro: Când editați fișierele pentru a le alinia structurile, preferați editarea traducerii, dacă este posibil. Într-adevăr, dacă modificările aduse originalului sunt prea intruzive, versiunile veche și nouă nu vor fi comparate în timpul primei execuții po4a după „gettextizarea” (a se vedea mai jos). Orice traducere nepotrivită va fi oricum abandonată. Acestea fiind spuse, doriți în continuare să editați documentul original în cazul în care este prea greu să obțineți „gettextizarea” pentru a continua altfel, chiar dacă aceasta înseamnă că un paragraf din traducere este aruncat. Important este să obțineți un prim fișier PO pentru a începe.

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.
ro: Nu ezitați să eliminați orice conținut original care nu ar exista în versiunea tradusă. Acest conținut va fi reintrodus automat ulterior, la sincronizarea fișierului PO cu documentul.

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.
ro: Probabil că ar trebui să informați autorul original cu privire la orice modificare structurală în traducere care pare justificată. Problemele din documentul original ar trebui raportate autorului. Rezolvarea lor în traducerea dvs. le rezolvă doar pentru o parte a comunității. În plus, este imposibil să faceți acest lucru atunci când utilizați po4a ;) Dar probabil doriți să așteptați până la sfârșitul conversiei la B<po4a> înainte de a modifica fișierele originale.

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.
ro: Uneori, conținutul paragrafelor se potrivește, dar nu și tipurile lor. Rezolvarea depinde mai degrabă de format. În POD și man, aceasta provine adesea din faptul că unul dintre ele conține un rând care începe cu un spațiu alb, în timp ce celălalt nu. În aceste formate, un astfel de paragraf nu poate fi încadrat și devine astfel un tip diferit. Îndepărtați spațiul și sunteți în regulă. De asemenea, poate fi vorba de o greșeală de dactilografiere a numelui etichetei în XML.

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.
ro: De asemenea, două paragrafe pot fi îmbinate în POD atunci când linia de separare conține câteva spații sau când nu există o linie goală între linia B<=item> și conținutul articolului.

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.
ro: Uneori, mesajul de desincronizare pare ciudat deoarece traducerea este atașată la paragraful original greșit. Acesta este semnul unei probleme nedetectate mai devreme în proces. Căutați punctul real de desincronizare prin inspectarea fișierului F<gettextization.failed.po> care a fost produs și rezolvați problema acolo unde este cu adevărat.

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.
ro: Alte probleme pot proveni din șiruri de caractere duplicate, fie în original, fie în traducere. Șirurile duplicate sunt fuzionate în fișierele PO, cu două referințe. Acest lucru constituie o dificultate pentru algoritmul de gettextizare, care este o simplă împerechere unu la unu între B<msgid>-urile din fișierele principale și cele localizate. Cu toate acestea, se crede că versiunile recente ale po4a tratează în mod corespunzător șirurile duplicate, astfel încât ar trebui să raportați orice problemă rămasă pe care o puteți întâlni.

note: type: =head2
en: Reviewing files produced by B<po4a-gettextize>
ro: Revizuirea fișierelor produse de B<po4a-gettextize>

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.
ro: Orice fișier produs de B<po4a-gettextize> trebuie revizuit manual, chiar și atunci când scriptul se încheie cu succes. Ar trebui să treceți cu vederea fișierul PO, asigurându-vă că B<msgid> și B<msgstr> corespund efectiv. Nu este încă necesar să vă asigurați că traducerea este perfect corectă, deoarece toate intrările sunt oricum marcate ca traduceri neclare. Trebuie doar să verificați dacă există probleme evidente de potrivire, deoarece traducerile cu potrivire proastă vor fi abandonate în etapele următoare, în timp ce ceea ce doriți, este să le salvați.

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.
ro: Din fericire, acest pas nu necesită cunoașterea limbilor țintă, deoarece doriți doar să recunoașteți elemente similare în fiecare B<msgid> și B<msgstr> corespunzător. În calitate de vorbitor de franceză, engleză și ceva germană, pot face acest lucru cel puțin pentru toate limbile europene, chiar dacă nu pot spune un cuvânt din majoritatea acestor limbi. Uneori reușesc să detectez probleme de potrivire în limbile non-latine uitându-mă la lungimea șirurilor de caractere, la structura frazelor (se potrivește cantitatea de semne de interogație?) și la alte indicii, dar prefer ca altcineva să revizuiască aceste limbi.

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.
ro: Dacă detectați o nepotrivire, editați fișierele original și de traducere ca și cum B<po4a-gettextize> ar fi raportat o eroare și încercați din nou. Odată ce aveți un fișier PO decent pentru traducerea dvs. anterioară, faceți o copie de rezervă a acestuia până când po4a funcționează corect.

note: type: =head2
en: Running B<po4a> for the first time
ro: Rulând B<po4a> pentru prima dată

note: type: textblock
en: The easiest way to setup po4a is to write a B<po4a.conf> configuration file, and use the integrated B<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.
ro: Cel mai simplu mod de a configura po4a este să scrieți un fișier de configurare B<po4a.conf> și să utilizați programul integrat B<po4a> (B<po4a-updatepo> și B<po4a-translate> sunt depreciate). Vă rugăm să consultați secțiunea „FIȘIERUL DE CONFIGURARE” din documentația L<po4a(1)> pentru mai multe detalii.

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.
ro: Când B<po4a> rulează pentru prima dată, versiunea curentă a documentelor principale va fi utilizată pentru a actualiza fișierele PO care conțin traducerile vechi pe care le-ați salvat prin „gettextizare”. Acest lucru poate dura destul de mult timp, deoarece multe dintre B<msgid>-urile de la „gettextizare” nu corespund exact elementelor din fișierul POT construit din fișierele principale recente. Acest lucru forțează gettext să caute cel mai apropiat folosind un algoritm costisitor de proximitate a șirurilor. De exemplu, prima rulare a traducerii în franceză a documentației Perl (fișier PO de 5,5 MB) a durat aproximativ 48 de ore (da, două zile), în timp ce cele ulterioare durează doar câteva secunde.

note: type: =head2
en: Moving your translations to production
ro: Trecerea traducerilor dvs. în producție

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.
ro: După această primă execuție, fișierele PO sunt gata pentru a fi revizuite de traducători. Toate intrările au fost marcate ca aproximative (fuzzy) în fișierul PO de către B<po4a-gettextization>, forțând revizuirea lor atentă înainte de utilizare. Traducătorii trebuie să examineze fiecare intrare pentru a verifica dacă traducerea salvată corespunde de fapt textului original actual, să actualizeze traducerea în funcție de necesități și să elimine marcajele de traducere aproximativă.

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.
ro: Odată ce sunt eliminate suficiente marcaje „fuzzy” (de traducere aproximativă), B<po4a> va începe să genereze fișierele de traducere pe disc și sunteți gata să treceți fluxul de lucru de traducere la producție. Unele proiecte consideră că este util să se bazeze pe weblate pentru coordonarea între traducători și întreținători, dar acest lucru depășește domeniul de aplicare al B<po4a>.

note: type: textblock
en: po4a-normalize - normalize a documentation file by parsing it in po4a, and writing it back
ro: po4a-normalize - normalizează un fișier de documentație analizându-l în po4a și scriindu-l înapoi

note: type: textblock
en: B<po4a-normalize> B<-f> I<fmt> I<master.doc>
ro: B<po4a-normalize> B<-f> I<fmt> I<principal.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.
ro: Scopul proiectului po4a (PO pentru orice) este de a ușura traducerile (și mai interesant, întreținerea traducerilor) folosind instrumente gettext în domenii în care nu erau așteptate, cum ar fi documentația.

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.
ro: Scriptul B<po4a-normalize> este un instrument de depanare utilizat pentru a se asigura că po4a nu modifică documentul atunci când nu ar trebui să o facă. Utilizați-l numai dacă dezvoltați un modul nou sau dacă vă îndoiți de corectitudinea instrumentelor.

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.
ro: Documentul generat va fi scris în F<po4a-normalize.output> în timp ce fișierul POT generat va fi scris în F<po4a-normalize.po> în mod implicit, dar puteți utiliza opțiunile B<--localized> și B<--pot> pentru a schimba acest lucru.

note: type: textblock
en: Create a blank translated document.  The generated translated document will be generated assuming all messages are translated by a space or new line.
ro: Creează un document tradus gol. Documentul tradus generat va fi generat presupunând că toate mesajele sunt traduse printr-un spațiu sau o linie nouă.

note: type: textblock
en: This is useful to check what parts of the document cannot be translated.
ro: Acest lucru este util pentru a verifica ce părți ale documentului nu pot fi traduse.

note: type: textblock
en: Both B<--blank> and B<--capitalize> can't be specified at the same time.
ro: Nu pot fi specificate în același timp atât B<--blank>, cât și B<--capitalize>.

note: type: textblock
en: Create a translated document and corresponding po-file with original strings translated as their capitalized versions.
ro: Creează un document tradus și un fișier po corespunzător cu șirurile originale traduse ca versiunile lor cu majuscule.

note: type: textblock
en: This is useful to check what parts of the document cannot be translated and generate test data for po4a.
ro: Acest lucru este util pentru a verifica ce părți ale documentului nu pot fi traduse și pentru a genera date de testare pentru po4a.

note: type: textblock
en: Name of the normalized file to produce (I<po4a-normalize.output> by default).
ro: Numele fișierului normalizat care urmează să fie produs (I<po4a-normalize.output> în mod implicit).

note: type: textblock
en: Pot file to produce (I<po4a-normalize.po> by default).
ro: Fișierul Pot de produs (I<po4a-normalize.po> implicit).

note: type: textblock
en: po4a-translate - convert a PO file back to documentation format
ro: po4a-translate - convertește un fișier PO înapoi în formatul documentației

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>
ro: B<po4a-translate> B<-f> I<fmt> B<-m> I<principal.doc> B<-p> I<XX.po> B<-l> I<XX.doc>

note: type: textblock
en: (I<XX.doc> is the output, all others are inputs)
ro: (I<XX.doc> este ieșirea, toate celelalte sunt intrările)

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)>.
ro: Scriptul B<po4a-translate> are sarcina de a converti traducerea (care a fost realizată într-un fișier PO) înapoi în formatul documentației. Fișierul PO furnizat trebuie să fie traducerea fișierului POT care a fost produs de L<po4a-gettextize(1)>.

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)>).
ro: Adaugă un fișier la fișierul rezultat (pentru a pune numele traducătorului sau o secțiune „Despre această traducere”, de exemplu). Primul rând al fișierului de inserat trebuie să fie un antet PO4A care să indice unde trebuie adăugat (a se vedea secțiunea B<CUM se adaugă text suplimentar la traduceri> în L<po4a(7)>).

note: type: textblock
en: File containing the master document to translate.
ro: Fișierul care conține documentul principal de tradus.

note: type: textblock
en: File where the localized (translated) document should be written.
ro: Fișierul în care trebuie să fie scris documentul localizat (tradus).

note: type: textblock
en: File from which the message catalog should be read.
ro: Fișier din care trebuie să fie citit catalogul de mesaje.

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.
ro: Pragul minim al procentului de traducere pentru a păstra (adică a scrie) fișierul rezultat (implicit: 80). Adică, în mod implicit, fișierele trebuie să fie traduse la cel puțin 80% pentru a fi scrise.

note: type: =item
en: B<--porefs> I<type>[,B<wrap>|B<nowrap>]
ro: B<--porefs> I<tip>[,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.
ro: Argumentul poate fi urmat de o virgulă și de cuvântul-cheie B<wrap> sau B<nowrap>. Referințele sunt scrise implicit pe o singură linie. Opțiunea B<wrap> include referințele pe mai multe linii, pentru a imita instrumentele B<gettext> (B<xgettext> și B<msgmerge>). Această opțiune va deveni cea implicită într-o versiune viitoare, deoarece este mai sensibilă. Opțiunea B<nowrap> este disponibilă astfel încât utilizatorii care doresc să păstreze vechiul comportament să poată face acest lucru.

note: type: =head1
en: Adding content (beside translations) to generated files
ro: Adăugarea de conținut (pe lângă traduceri) la fișierele generate

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.
ro: Pentru a adăuga un conținut suplimentar la documentul generat, pe lângă ceea ce ați tradus (cum ar fi numele traducătorului sau o secțiune „Despre această traducere”), trebuie să utilizați opțiunea B<--addendum>.

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.
ro: Prima linie a addendumului trebuie să fie un antet care să indice locul în document (poate fi înainte sau după o anumită parte a documentului). Restul fișierului va fi adăugat textual la fișierul rezultat, fără prelucrare suplimentară.

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).
ro: Rețineți că, în cazul în care po4a-translate nu reușește să adauge unul dintre fișierele date, aceasta respinge întreaga traducere (deoarece fișierul lipsă ar putea fi cel care indică autorul, ceea ce ar împiedica utilizatorii să îl contacteze pentru a raporta erori în traducere).

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.
ro: Antetul are o sintaxă destul de rigidă. Pentru mai multe informații despre cum să utilizați această caracteristică și cum funcționează, consultați pagina de manual L<po4a(7)>.

note: type: textblock
en: po4a-updatepo - update the translation (in PO format) of documentation
ro: po4a-updatepo - actualizează traducerea (în format PO) a documentației

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

note: type: textblock
en: (I<XX.po> are the outputs, all others are inputs)
ro: (I<XX.po> sunt ieșirile, toate celelalte sunt intrările)

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.
ro: Scriptul B<po4a-updatepo> se ocupă de actualizarea fișierelor PO pentru a le face să reflecte modificările aduse fișierului original de documentație. Pentru aceasta, acesta convertește fișierul de documentație într-un fișier POT și apelează L<msgmerge(1)> pe acest nou POT și pe fișierele PO furnizate.

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).
ro: Este posibil să furnizați mai mult de un fișier PO (dacă doriți să actualizați mai multe limbi simultan) și mai multe fișiere de documentație (dacă doriți să stocați traducerile mai multor documente în același fișier PO).

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.
ro: Dacă documentul principal are caractere non-ASCII, acest script va converti fișierele PO în UTF-8 (dacă nu au fost deja), pentru o gestionare transparentă a caracterelor non-standard.

note: type: textblock
en: File(s) containing the master document to translate.
ro: Fișierul (fișierele) care conține (conțin) documentul principal de tradus.

note: type: textblock
en: Charset of the files containing the document to translate. Note that all files must have the same charset.
ro: Setul de caractere al fișierelor care conțin documentul de tradus. Rețineți că toate fișierele trebuie să aibă același set de caractere.

note: type: textblock
en: PO file(s) to update. If these files do not exist, they are created by B<po4a-updatepo>.
ro: Fișierul (fișierele) PO care urmează să fie actualizate. Dacă aceste fișiere nu există, ele sunt create de B<po4a-updatepo>.

note: type: textblock
en: This option removes B<--previous> from the options passed to B<msgmerge>.  This helps supporting old versions of B<gettext> (before v0.16).
ro: Această opțiune elimină B<--previous> din opțiunile transmise către B<msgmerge>. Acest lucru ajută la asigurarea suportului pentru versiunile vechi ale B<gettext> (înainte de v0.16).

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.
ro: Din punct de vedere istoric, suita gettext a reformatat fișierele po la a 77-a coloană pentru cosmetică. Această opțiune specifică comportamentul lui po4a. Dacă este stabilită la o valoare numerică, po4a va încadra fișierul po după această coloană și după noile linii din conținut. Dacă este stabilită la B<newlines>, po4a va împărți doar msgid și msgstr după linii noi în conținut. Dacă este stabilită la B<no>, po4a nu va încadra deloc fișierul po. Încadrarea comentariilor de referință este controlată de opțiunea B<--porefs>.

note: type: textblock
en: msguntypot - update PO files when a typo is fixed in POT file
ro: msguntypot - actualizează fișierele PO atunci când o greșeală de dactilografiere este corectată în fișierul POT

note: type: textblock
en: B<msguntypot> B<-o> I<old_pot> B<-n> I<new_pot> I<pofiles> ...
ro: B<msguntypot> B<-o> I<vechiul_pot> B<-n> I<noul_pot> I<fișiere-po> ...

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.
ro: Atunci când remediați o eroare banală care cu siguranță nu afectează traducerile (de exemplu, o greșeală de dactilografiere) într-un fișier POT, ar trebui să eliminați marcajul de traducere aproximativă al msgstr-ului corespunzător în fișierele PO traduse pentru a evita munca suplimentară a traducătorilor.

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.
ro: Această sarcină este dificilă și predispusă la erori atunci când este efectuată manual, iar acest instrument este acolo pentru a ajuta la efectuarea corectă a acesteia. Trebuie doar să furnizați cele două versiuni ale fișierului POT: înainte de editare și după, după cum se indică în sinopsisul de mai sus, și totul devine automat.

note: type: =head1
en: HOW TO USE IT
ro: CUM SE UTILIZEAZĂ

note: type: textblock
en: In short, when you discover a typo in one of your [english] message, do the following:
ro: Pe scurt, atunci când descoperiți o greșeală de dactilografiere într-unul dintre mesajele dvs. [în limba engleză], procedați în felul următor:

note: type: =item
en: - Regenerate your POT and PO files.
ro: - Regenerați fișierele POT și PO.

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
ro:   make -C po/ update-po # pentru traducerile mesajelor din program
      debconf-updatepo      # pentru traducerile debconf
      po4a po4a.conf        # pentru traducerile documentației bazate pe po4a

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??
ro: sau altceva, în funcție de parametrii de construcție ai proiectului dvs. Știți cum să vă asigurați că fișierele POT și PO sunt actualizate, nu-i așa??

note: type: =item
en: - Make a copy of your POT file.
ro: - Faceți o copie a fișierului POT.

note: type: verbatim
en:   cp myfile.pot myfile.pot.orig
ro:   cp fișierul-meu.pot fișierul-meu.pot.orig

note: type: =item
en: - Make a copy of all your PO files.
ro: - Faceți o copie a tuturor fișierelor PO.

note: type: verbatim
en:   mkdir po_fridge; cp *.po po_fridge
ro:   mkdir sertar-copii_po; cp *.po sertar-copii_po

note: type: =item
en: - Fix your typo.
ro: - Corectați greșeala de tastare.

note: type: textblock
en: $EDITOR the_file_in_which_there_is_a_typo
ro: $EDITOR fișierul_în_care_există_o_greșeală_de_tastare

note: type: textblock
en: See above.
ro: A se vedea mai sus.

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.
ro: În acest moment, corecția greșelii de tastare a estompat toate traducerile, iar această modificare nefericită este singura dintre fișierele PO din directorul principal și cel din sertar-copii. Iată cum să rezolvați acest lucru.

note: type: =item
en: - Discard fuzzy translation, restore the ones from the fridge.
ro: - Eliminați traducerile aproximative, restabiliți-le pe cele din sertar-copii.

note: type: verbatim
en:   cp po_fridge/*.po .
ro:   cp sertar-copii_po/*.po .

note: type: =item
en: - Manually merge the PO files with the new POT file, but taking the useless fuzzy into account.
ro: - Fuzionați manual fișierele PO cu noul fișier POT, dar ținând cont de traducerile aproximative nefolositoare.

note: type: verbatim
en:   msguntypot -o myfile.pot.orig -n myfile.pot *.po
ro:   msguntypot -o fișierul-meu.pot.orig -n fișierul-meu.pot *.po

note: type: =item
en: - Cleanups.
ro: - Curățenie.

note: type: verbatim
en:   rm -rf myfile.pot.orig po_fridge
ro:   rm -rf fișierul-meu.pot.orig sertar-copii_po

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.
ro: Ați terminat. Eroarea de tastare a fost eradicată din msgstr atât din fișierele POT, cât și din fișierele PO, iar mesajele din fișierele PO nu au fost marcate ca aproximative în acest proces. Traducătorii dvs. vă iubesc deja.

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:
ro: În ciuda numelui său, acest instrument nu face parte din suita de instrumente gettext. În schimb, face parte din po4a. Mai exact, este un script Perl aleatoriu care utilizează modulele po4a. Pentru mai multe informații despre po4a, vă rugăm să consultați:

note: type: textblock
en: Copyright 2005 by SPI, inc.
ro: Drepturi de autor 2005 pentru SPI, inc.

note: type: textblock
en: po4a - framework to translate documentation and other materials
ro: po4a - cadru pentru traducerea documentației și a altor materiale

note: type: =head1
en: Introduction
ro: Introducere

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.
ro: po4a (PO pentru orice) facilitează întreținerea traducerii documentației utilizând instrumentele clasice gettext. Principala caracteristică a po4a este că decuplează traducerea conținutului de structura documentului său.

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.
ro: Acest document servește drept introducere la proiectul po4a, cu accent pe utilizatorii potențiali care se gândesc dacă să utilizeze acest instrument și pe cei curioși care doresc să înțeleagă de ce lucrurile sunt așa cum sunt.

note: type: =head1
en: Why po4a?
ro: De ce 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.
ro: Filozofia software-ului liber este de a face tehnologia cu adevărat disponibilă pentru toată lumea. Dar licențierea nu este singurul aspect de luat în considerare: software-ul liber netradus este inutil pentru cei care nu vorbesc limba engleză. Prin urmare, mai avem încă ceva de lucru pentru a face software-ul disponibil pentru toată lumea.

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.
ro: Această situație este bine înțeleasă de majoritatea proiectelor și toată lumea este acum convinsă de necesitatea de a traduce totul. Cu toate acestea, traducerile efective reprezintă un efort uriaș al multor persoane, paralizat de mici dificultăți tehnice.

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.
ro: Din fericire, software-ul Open Source este de fapt foarte bine tradus cu ajutorul suitei de instrumente gettext. Aceste instrumente sunt utilizate pentru a extrage șirurile de caractere de tradus dintr-un program și pentru a le prezenta într-un format standardizat (denumit fișiere PO sau cataloage de traducere). Un întreg ecosistem de instrumente a apărut pentru a ajuta traducătorii să traducă efectiv aceste fișiere PO. Rezultatul este apoi utilizat de gettext în timpul execuției pentru a afișa mesaje traduse utilizatorilor finali.

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.
ro: Cu toate acestea, în ceea ce privește documentația, situația este încă oarecum dezamăgitoare. La început, traducerea documentației poate părea mai ușoară decât traducerea unui program, deoarece s-ar părea că trebuie doar să copiați fișierul sursă al documentației și să începeți să traduceți conținutul. Cu toate acestea, atunci când documentația originală este modificată, urmărirea modificărilor se transformă rapid într-un coșmar pentru traducători. Dacă este efectuată manual, această sarcină este neplăcută și predispusă la erori.

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.
ro: Traducerile învechite sunt adesea mai rele decât lipsa oricărei traduceri. Utilizatorii finali pot fi înșelați de documentația care descrie un comportament vechi al programului. În plus, aceștia nu pot interacționa direct cu cei care se ocupă de întreținere, deoarece nu vorbesc engleza. În plus, responsabilul cu întreținerea nu poate rezolva problema, deoarece nu cunoaște toate limbile în care este tradusă documentația sa. Aceste dificultăți, cauzate adesea de un instrumentar slab, pot submina motivația traducătorilor voluntari, agravând și mai mult problema.

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>.
ro: B<Obiectivul proiectului po4a este de a ușura munca traducătorilor de documentație>. În special, acesta face traducerile de documentație I<ușor de întreținut>.

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.
ro: Ideea este de a reutiliza și adapta abordarea gettext la acest domeniu. Ca și în cazul gettext, textele sunt extrase din locațiile lor originale și prezentate traducătorilor sub formă de cataloage de traduceri PO. Traducătorii pot utiliza instrumentele clasice gettext pentru a monitoriza munca de făcut, a colabora și a se organiza ca echipe. po4a injectează apoi traducerile direct în structura documentației pentru a produce fișiere sursă traduse care pot fi prelucrate și distribuite la fel ca fișierele în limba engleză. Orice paragraf care nu este tradus este lăsat în limba engleză în documentul rezultat, asigurându-se că utilizatorii finali nu văd niciodată o traducere învechită în documentație.

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.
ro: Acest lucru automatizează cea mai mare parte a muncii de întreținere a traducerii. Descoperirea paragrafelor care necesită o actualizare devine foarte ușoară, iar procesul este complet automatizat atunci când elementele sunt reordonate fără alte modificări. Verificarea specifică poate fi, de asemenea, utilizată pentru a reduce șansele de erori de formatare care ar conduce la un document defectuos.

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.
ro: Pentru o listă mai completă a avantajelor și dezavantajelor acestei abordări, consultați și secțiunea B<Întrebări și răspunsuri frecvente> de mai jos din acest document.

note: type: =head2
en: Supported formats
ro: Formatele acceptate

note: type: textblock
en: Currently, this approach has been successfully implemented to several kinds of text formatting formats:
ro: În prezent, această abordare a fost implementată cu succes pentru mai multe tipuri de formate de formatare a textului:

note: type: =item
en: man (mature parser)
ro: man (analizator matur)

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.
ro: Vechiul format de pagini de manual, folosit de atât de multe programe. Sprijinul po4a este foarte binevenit aici, deoarece acest format este oarecum dificil de utilizat și nu este foarte prietenos pentru începători.

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).
ro: Modulul L<Locale::Po4a::Man(3pm)|Man> acceptă, de asemenea, formatul mdoc, utilizat de paginile man BSD (acestea sunt destul de comune și în Linux).

note: type: =item
en: AsciiDoc (mature parser)
ro: AsciiDoc (analizator matur)

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.
ro: Acest format este un format de marcare simplificat menit să faciliteze crearea documentației. De exemplu, este utilizat pentru documentarea sistemului git. Aceste pagini de manual sunt traduse folosind po4a.

note: type: textblock
en: See L<Locale::Po4a::AsciiDoc> for details.
ro: Consultați L<Locale::Po4a::AsciiDoc> pentru detalii.

note: type: =item
en: pod (mature parser)
ro: pod (analizator matur)

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.
ro: Acesta este formatul documentației în linie Perl. Limbajul și extensiile în sine sunt documentate folosind acest format, în plus față de majoritatea scripturilor Perl existente. Acesta facilitează păstrarea documentației aproape de codul real prin încorporarea ambelor în același fișier. Face viața programatorului mai ușoară, dar, din păcate, nu și pe cea a traducătorului, până când nu utilizați po4a.

note: type: textblock
en: See L<Locale::Po4a::Pod> for details.
ro: Consultați L<Locale::Po4a::Pod> pentru detalii.

note: type: =item
en: sgml (mature parser)
ro: sgml (analizator matur)

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.
ro: Chiar dacă a fost înlocuit de XML în prezent, acest format este încă utilizat pentru documentele care au mai mult de câteva ecrane. Acesta poate fi utilizat chiar și pentru cărți complete. Actualizarea documentelor de această lungime poate fi foarte dificilă. B<diff> se dovedește adesea inutil atunci când textul original a fost reindentat după actualizare. Din fericire, po4a vă poate ajuta după acest proces.

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.
ro: În prezent, numai DTD DebianDoc și DTD DocBook sunt acceptate, dar adăugarea suportului pentru unul nou este foarte ușoară. Este chiar posibil să utilizați po4a pe un DTD SGML necunoscut fără a modifica codul, furnizând informațiile necesare pe linia de comandă. Consultați L<Locale::Po4a::Sgml(3pm)> pentru detalii.

note: type: =item
en: TeX / LaTeX (mature parser)
ro: TeX / LaTeX (analizator matur)

note: type: textblock
en: The LaTeX format is a major documentation format used in the Free Software world and for publications.
ro: Formatul LaTeX este un format important de documentație utilizat în lumea software-ului liber și pentru publicații.

note: type: textblock
en: The L<Locale::Po4a::LaTeX(3pm)|LaTeX> module was tested with the Python documentation, a book and some presentations.
ro: Modulul L<Locale::Po4a::LaTeX(3pm)|LaTeX> a fost testat cu documentația Python, o carte și câteva prezentări.

note: type: =item
en: text (mature parser)
ro: text (analizator matur)

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.
ro: Formatul Text este formatul de bază pentru multe formate care includ blocuri lungi de text, inclusiv Markdown, fortunes, secțiunea de introducere YAML, debian/changelog și 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.
ro: Acesta acceptă formatul comun utilizat în generatoarele de situri statice, README-uri și alte sisteme de documentare. Consultați L<Locale::Po4a::Text(3pm)|Text> pentru detalii.

note: type: =item
en: xml and XHMTL (probably mature parser)
ro: xml și XHMTL (probabil un analizator matur)

note: type: textblock
en: The XML format is a base format for many documentation formats.
ro: Formatul XML este un format de bază pentru multe formate de documentație.

note: type: textblock
en: Currently, the DocBook DTD (see L<Locale::Po4a::Docbook(3pm)> for details) and XHTML are supported by po4a.
ro: În prezent, po4a acceptă DTD DocBook (consultați L<Locale::Po4a::Docbook(3pm)> pentru detalii) și XHTML.

note: type: =item
en: BibTex (probably mature parser)
ro: BibTex (probabil un analizator matur)

note: type: textblock
en: The BibTex format is used alongside LaTex for formatting lists of references (bibliographies).
ro: Formatul BibTex este utilizat împreună cu LaTex pentru formatarea listelor de referințe (bibliografii).

note: type: textblock
en: See L<Locale::Po4a::BibTex> for details.
ro: Consultați L<Locale::Po4a::BibTex> pentru detalii.

note: type: =item
en: Docbook (probably mature parser)
ro: Docbook (probabil un analizator matur)

note: type: textblock
en: A XML-based markup language that uses semantic tags to describe documents.
ro: Un limbaj de marcare bazat pe XML care utilizează etichete semantice pentru a descrie documentele.

note: type: textblock
en: See L<Locale::Po4a:Docbook> for greater details.
ro: Consultați L<Locale::Po4a:Docbook> pentru informații mai detaliate.

note: type: =item
en: Guide XML (probably mature parser)
ro: Guide XML (probabil un analizator matur)

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.
ro: Un format de documentație XML. Acest modul a fost dezvoltat special pentru a ajuta la susținerea și menținerea traducerilor documentației Gentoo Linux cel puțin până în martie 2016 (Conform datelor din situl Wayback Machine). De atunci, Gentoo a trecut la formatul DevBook XML.

note: type: textblock
en: See L<Locale::Po4a:Guide> for greater details.
ro: Consultați L<Locale::Po4a:Guide> pentru informații mai detaliate.

note: type: =item
en: Wml (probably mature parser)
ro: Wml (probabil un analizator matur)

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.
ro: Limbajul de marcare web, nu confundați WML cu WAP-ul utilizat pe telefoanele mobile. Acest modul se bazează pe modulul Xhtml, care la rândul său se bazează pe modulul XmL.

note: type: textblock
en: See L<Locale::Po4a::Wml> for greater details.
ro: Consultați L<Locale::Po4a::Wml> pentru informații mai detaliate.

note: type: =item
en: Yaml (probably mature parser)
ro: Yaml (probabil un analizator matur)

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.
ro: Un superset strict al JSON. YAML este adesea utilizat ca sisteme sau proiecte de configurare. YAML se află la baza Ansible de la Red Hat.

note: type: textblock
en: See L<Locale::Po4a::Yaml> for greater details.
ro: Consultați L<Locale::Po4a::Yaml> pentru informații mai detaliate.

note: type: =item
en: RubyDoc (probably mature parser)
ro: RubyDoc (probabil un analizator matur)

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.
ro: Formatul Ruby Document (RD), inițial formatul implicit de documentare pentru Ruby și proiectele Ruby înainte de a fi convertit în RDoc în 2002. Deși se pare că versiunea japoneză a manualului de referință Ruby încă utilizează RD.

note: type: textblock
en: See L<Locale::Po4a::RubyDoc> for greater details.
ro: Consultați L<Locale::Po4a::RubyDoc> pentru informații mai detaliate.

note: type: =item
en: Halibut (probably experimental parser)
ro: Halibut (probabil un analizator într-un stadiu experimental)

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.
ro: Un sistem de producție a documentației, cu elemente similare TeX, debiandoc-sgml, TeXinfo și altele, dezvoltat de Simon Tatham, dezvoltatorul PuTTY.

note: type: textblock
en: See L<Locale::Po4a:Halibut> for greater details.
ro: Consultați L<Locale::Po4a:Halibut> pentru informații mai detaliate.

note: type: =item
en: Ini (probably experimental parser)
ro: Ini (probabil un analizator într-un stadiu experimental)

note: type: textblock
en: Configuration file format popularized by MS-DOS.
ro: Format de fișier de configurare popularizat de MS-DOS.

note: type: textblock
en: See L<Locale::Po4a::Ini> for greater details.
ro: Consultați L<Locale::Po4a::Ini> pentru informații mai detaliate.

note: type: =item
en: texinfo (very highly experimental parser)
ro: texinfo (analizator într-un stadiu foarte experimental)

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.
ro: Toată documentația GNU este scrisă în acest format (este chiar una dintre cerințele pentru a deveni un proiect GNU oficial). Suportul pentru L<Locale::Po4a::Texinfo(3pm)|Texinfo> în po4a este încă la început. Vă rugăm să raportați erori și solicitări de caracteristici.

note: type: =item
en: gemtext (very highly experimental parser)
ro: gemtext (analizator într-un stadiu foarte experimental)

note: type: textblock
en: The native plain text format of the Gemini protocol.  The extension ".gmi" is commonly used.  Support for this module in po4a is still in its infancy.  If you find anything, please file a bug or feature request.
ro: Formatul nativ de text simplu al protocolului Gemini. Extensia „.gmi” este frecvent utilizată. Suportul pentru acest modul în po4a este încă în fază incipientă. Dacă găsiți ceva, vă rugăm să depuneți un raport de eroare sau o cerere de caracteristică.

note: type: =item
en: Others supported formats
ro: Alte formate acceptate

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.
ro: Po4a poate gestiona și unele formate mai rare sau specializate, cum ar fi documentația opțiunilor de compilare pentru nucleele Linux 2.4+ (L<Locale::Po4a::KernelHelp>) sau diagramele produse de instrumentul dia (L<Locale::Po4a::Dia>). Adăugarea unui nou format este adesea foarte ușoară, iar sarcina principală este de a veni cu un analizator pentru formatul țintă. Consultați L<Locale::Po4a::TransTractor(3pm)> pentru mai multe informații despre acest lucru.

note: type: =item
en: Unsupported formats
ro: Formate neacceptate

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.
ro: Din păcate, po4a nu oferă încă suport pentru mai multe formate de documentație. Multe dintre acestea ar fi ușor de acceptat în po4a. Aceasta include formate care nu sunt utilizate doar pentru documentație, cum ar fi, descrieri de pachete (deb și rpm), întrebări privind scripturile de instalare a pachetelor, jurnale de modificări ale pachetelor și toate formatele de fișiere specializate utilizate de programe, cum ar fi scenariile de jocuri sau fișierele de resurse pentru «wine».

note: type: =head1
en: Using po4a
ro: Folosind po4a

note: type: textblock
en: The easiest way to use this tool in your project is to write a configuration file for the B<po4a> program, and only interact with this program. Please refer to its documentation, in L<po4a(1)>. The rest of this section provides more details for the advanced users of po4a wanting to deepen their understanding.
ro: Cel mai simplu mod de a utiliza acest instrument în proiectul dumneavoastră este să scrieți un fișier de configurare pentru programul B<po4a> și să interacționați numai cu acest program. Vă rugăm să consultați documentația acestuia, în L<po4a(1)>. Restul acestei secțiuni oferă mai multe detalii pentru utilizatorii avansați ai po4a care doresc să își aprofundeze cunoștințele.

note: type: =head2
en: Detailed schema of the po4a workflow
ro: Schema detaliată a fluxului de lucru po4a

note: type: textblock
en: Make sure to read L<po4a(1)> before this overly detailed section to get a simplified overview of the po4a workflow. Come back here when you want to get the full scary picture, with almost all details.
ro: Asigurați-vă că citiți L<po4a(1)> înainte de această secțiune excesiv de detaliată pentru a obține o imagine de ansamblu simplificată a fluxului de lucru po4a. Reveniți aici când doriți să obțineți imaginea înfricoșătoare în ansamblu, cu aproape toate detaliile.

note: type: textblock
en: In the following schema, 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 AsciidDoc file, etc); the translators will be mostly concerned with the PO file, while the end users will only see the F<XX.doc> file.
ro: În următoarea schemă, F<principal.doc> este un nume de exemplu pentru documentația care urmează să fie tradusă; F<XX.doc> este același document tradus în limba XX, în timp ce F<doc.XX.po> este catalogul de traducere pentru documentul respectiv în limba XX. Autorii documentației vor fi preocupați în principal de F<principal.doc> (care poate fi o pagină de manual, un document XML, un fișier AsciidDoc etc.); traducătorii vor fi preocupați în principal de fișierul PO, în timp ce utilizatorii finali vor vedea doar fișierul F<XX.doc>.

note: type: textblock
en: Transitions with square brackets such as C<[po4a updates po]> represent the execution of a po4a tool while transitions with curly brackets such as C<{update of master.doc}> represent a manual modification of the project's files.
ro: Tranzițiile cu paranteze drepte precum C<[po4a actualizări po]> reprezintă executarea unui instrument po4a, în timp ce tranzițiile cu acolade precum C<{actualizare de principal.doc}> reprezintă o modificare manuală a fișierelor proiectului.

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 updates po]                  |
              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 updates translations]
                                                      |
                                                      V
                                                    XX.doc
                                                 (up-to-date)
ro:                                   principal.doc
                                           |
                                           V
         +<-----<----+<-----<-----<--------+------->-------->-------+
         :           |                     |                        :
    {traducere}      |       {actualizare de principal.doc}         :
         :           |                     |                        :
       XX.doc        |                     V                        V
     (opțional)      |              principal.doc ->-------->------>+
         :           |                   (nou)                      |
         V           V                     |                        |
      [po4a-gettextize]   doc.XX.po -->+   |                        |
              |           (vechi)      |   |                        |
              |              ^         V   V                        |
              |              |  [po4a actualizează po]              |
              V              |           |                          V
        traducere.pot        ^           V                          |
              |              |        doc.XX.po                     |
              |              |  (trad. aprox. „fuzzy”)              |
         {traducere}         |           |                          |
              |              ^           V                          V
              |              |     {editare manuală}                 |
              |              |           |                          |
              V              |           V                          V
          doc.XX.po --->---->+<---<-- doc.XX.po    addendum     master.doc
          (inițial)                 (actualizat)  (opțional)   (actualizat)
              :                          |            |             |
              :                          V            |             |
              +----->----->----->------> +            |             |
                                         |            |             |
                                         V            V             V
                                         +------>-----+------<------+
                                                      |
                                                      V
                                       [po4a actualizează traducerile]
                                                      |
                                                      V
                                                    XX.doc
                                                 (actualizat)

note: type: textblock
en: Again, this schema is overly complicated. Check on L<po4a(1)> for a simplified overview.
ro: Din nou, această schemă este excesiv de complicată. Consultați L<po4a(1)> pentru o prezentare simplificată.

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.
ro: Partea din stânga descrie modul în care L<po4a-gettextize(1)> poate fi utilizat pentru a converti un proiect de traducere existent la infrastructura po4a. Acest script ia un document original și omologul său tradus și încearcă să construiască fișierul PO corespunzător. O astfel de conversie manuală este destul de greoaie (consultați documentația L<po4a-gettextize(1)> pentru mai multe detalii), dar este necesară o singură dată pentru a vă converti traducerile existente. Dacă nu aveți nicio traducere de convertit, puteți să uitați de acest lucru și să vă concentrați pe partea dreaptă a schemei.

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 updates of translation files: 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.
ro: În partea dreaptă sus, este descrisă acțiunea autorului original, care actualizează documentația. Partea din dreapta mijloc prezintă actualizările automate ale fișierelor de traducere: materialul nou este extras și comparat cu traducerea existentă. Traducerea anterioară este utilizată pentru părțile care nu s-au schimbat, în timp ce părțile parțial modificate sunt conectate la traducerea anterioară cu un marcaj „fuzzy” (traducere aproximativă) care indică faptul că traducerea trebuie actualizată. Materialele noi sau puternic modificate sunt lăsate netraduse.

note: type: textblock
en: Then, the I<manual editing> block 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.
ro: Apoi, blocul I<editare manuală> descrie acțiunea traducătorilor, care modifică fișierele PO pentru a furniza traduceri pentru fiecare șir și paragraf original. Acest lucru se poate face fie utilizând un editor specific, cum ar fi B<GTranslator>, B<Lokalize> de la KDE sau B<poedit>, fie utilizând o platformă de localizare din Internet, cum ar fi B<weblate> sau B<pootle>. Rezultatul traducerii este un set de fișiere PO, unul pentru fiecare limbă. Vă rugăm să consultați documentația gettext pentru mai multe detalii.

note: type: textblock
en: The bottom part of the figure shows how B<po4a> 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.
ro: Partea de jos a figurii arată cum B<po4a> creează un document sursă tradus din documentul original F<principal.doc> și catalogul de traduceri F<doc.XX.po> care a fost actualizat de traducători. Structura documentului este reutilizată, în timp ce conținutul original este înlocuit cu omologul său tradus. Opțional, un addendum poate fi utilizat pentru a adăuga text suplimentar la traducere. Acesta este adesea utilizat pentru a adăuga numele traducătorului la documentul final. A se vedea mai jos pentru detalii.

note: type: textblock
en: Upon invocation, B<po4a> updates both the translation files and the translated documentation files automatically.
ro: La invocare, B<po4a> actualizează automat atât fișierele de traducere, cât și fișierele de documentație traduse.

note: type: =head2
en: Starting a new translation project
ro: Începerea unui nou proiect de traducere

note: type: textblock
en: If you start from scratch, you just have to write a configuration file for po4a, and you are set.  The relevant templates are created for the missing files, allowing your contributors to translate your project to their language. Please refer to L<po4a(1)> for a quick start tutorial and for all details.
ro: Dacă începeți de la zero, trebuie doar să scrieți un fișier de configurare pentru po4a și ați terminat. Șabloanele relevante sunt create pentru fișierele lipsă, permițând colaboratorilor dvs. să traducă proiectul dvs. în limba lor. Vă rugăm să consultați L<po4a(1)> pentru un tutorial de pornire rapidă și pentru toate detaliile.

note: type: textblock
en: If you have an existing translation, i.e. a documentation file that was translated manually, you can integrate its content in your po4a workflow using B<po4a-gettextize>. This task is a bit cumbersome (as described in the tool's manpage), but once your project is converted to po4a workflow, everything will be updated automatically.
ro: Dacă aveți o traducere existentă, adică un fișier de documentație care a fost tradus manual, puteți integra conținutul său în fluxul de lucru po4a utilizând B<po4a-gettextize>. Această sarcină este un pic greoaie (așa cum este descris în pagina de manual a instrumentului), dar odată ce proiectul dvs. este convertit în fluxul de lucru po4a, totul va fi actualizat automat.

note: type: =head2
en: Updating the translations and documents
ro: Actualizarea traducerilor și a documentelor

note: type: textblock
en: Once setup, invoking B<po4a> is enough to update both the translation PO files and translated documents. You may pass the C<--no-translations> to B<po4a> to not update the translations (thus only updating the PO files) or C<--no-update> to not update the PO files (thus only updating the translations). This roughly corresponds to the individual B<po4a-updatepo> and B<po4a-translate> scripts which are now deprecated (see "Why are the individual scripts deprecated" in the FAQ below).
ro: Odată configurat, invocarea B<po4a> este suficientă pentru a actualiza atât fișierele PO de traducere, cât și documentele traduse. Puteți trece C<--no-translations> la B<po4a> pentru a nu actualiza traducerile (actualizând astfel doar fișierele PO) sau C<--no-update> pentru a nu actualiza fișierele PO (actualizând astfel doar traducerile). Aceasta corespunde aproximativ scripturilor individuale B<po4a-updatepo> și B<po4a-translate> care sunt acum depreciate (a se vedea „De ce sunt depreciate scripturile individuale?” în secțiunea de mai jos).

note: type: =head2
en: Using addenda to add extra text to translations
ro: CUM se utilizează addenda pentru a adăuga text suplimentar la traduceri

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.
ro: Adăugarea de text nou la traducere este probabil singurul lucru care este mai ușor pe termen lung atunci când traduceți manual fișiere :). Acest lucru se întâmplă atunci când doriți să adăugați o secțiune suplimentară la documentul tradus, care nu corespunde niciunui conținut din documentul original. Cazul clasic de utilizare este de a acorda credite (mulțumiri, recunoașterea muncii depuse, ș.a.) echipei de traducere și de a indica modul de raportare a problemelor specifice traducerii.

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.
ro: Cu po4a, trebuie să specificați fișiere B<addendum>, care pot fi privite conceptual ca plasturi (patches) aplicați documentului localizat(tradus) după procesare. Fiecare addendum trebuie să fie furnizat ca fișier separat, al cărui format este totuși foarte diferit de cel al plasturilor clasice. Prima linie este o I<linie de antet>, care definește punctul de inserție al addendumului (cu o sintaxă din păcate criptică - a se vedea mai jos), în timp ce restul fișierului este adăugat textual la poziția stabilită.

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.
ro: Linia de antet trebuie să înceapă cu șirul B<PO4A-HEADER:>, urmat de o listă de câmpuri I<cheie>B<=>I<valoare> separate prin punct și virgulă.

note: type: textblock
en: For example, the following header declares an addendum that must be placed at the very end of the translation.
ro: De exemplu, următorul antet declară un addendum care trebuie plasat chiar la sfârșitul traducerii.

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.
ro: Lucrurile sunt mai complexe atunci când doriți să adăugați conținut suplimentar în mijlocul documentului. Următorul antet declară un addendum care trebuie plasat după secțiunea XML care conține șirul C<Despre acest document> în traducere.

note: type: verbatim
en:  PO4A-HEADER: position=About this document; mode=after; endboundary=</section>
ro:  PO4A-HEADER: position=Despre acest document; 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.
ro: În practică, atunci când încearcă să aplice un addendum, po4a caută prima linie care corespunde argumentului C<poziție> (acesta poate fi o expresie regulată „expreg”). Nu uitați că po4a ia în considerare aici documentul B<tradus>. Această documentație este în limba engleză, dar linia dvs. ar trebui probabil să sune după cum urmează dacă intenționați ca addendumul dvs. să se aplice traducerii în franceză a documentului.

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).
ro: Odată ce C<poziția> este găsită în documentul țintă, po4a caută următoarea linie după C<poziția> care corespunde C<endboundary> furnizată. Addendumul este adăugat chiar B<după> acea linie (deoarece am furnizat un I<endboundary>, adică o limită care încheie secțiunea curentă).

note: type: textblock
en: The exact same effect could be obtained with the following header, that is equivalent:
ro: Exact același efect ar putea fi obținut cu următorul antet, care este echivalent:

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 placing 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> >>.
ro: Aici, po4a caută prima linie care corespunde C<< <section> >> după linia care corespunde C<About this document> din traducere și adaugă addendumul B<înainte> de această linie, deoarece am furnizat un I<beginboundary>, adică o limită care marchează începutul secțiunii următoare. Așadar, această linie de antet necesită plasarea addendumului după secțiunea care conține C<About this document>, și să instruim po4a că o secțiune începe cu o linie care conține eticheta C<< <section> >>. Acest lucru este echivalent cu exemplul anterior, deoarece ceea ce doriți cu adevărat este să adăugați acest addendum fie după C<< </section> >>, fie înainte de C<< <section> >>.

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 is 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 is the last potential boundary line before the C<position>.
ro: De asemenea, puteți stabili inserția I<mod> la valoarea C<before>, cu o semantică similară: combinarea C<mode=before> cu un C<endboundary> va plasa addendum-ul chiar B<after> (după) limita care corespunde, adică ultima linie de limită potențială înainte de C<position>. Combinarea C<mode=before> cu un C<beginboundary> va plasa addendumul chiar B<before> (înainte) față de limita corespunzătoare, adică ultima linie de limită potențială înainte de 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
ro:   Mod    | Tipul de limită |       Limita utilizată       | Punctul de inserție în raport cu limita
     ========|=================|==============================|=========================================
     'before'|  'endboundary'  | ultima înainte de 'position' | Imediat după limita selectată
     'before'| 'beginboundary' | ultima înainte de 'position' | Chiar înainte de limita selectată
     'after' |  'endboundary'  |    prima după 'position'     | Imediat după limita selectată
     'after' | 'beginboundary' |    prima după 'position'     | Chiar înainte de limita selectată
     'eof'   |   (niciunul)    |    nedeclarată               | Sfârșitul fișierului

note: type: =head3
en: Hint and tricks about addenda
ro: Sfaturi și trucuri despre 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$>.
ro: Amintiți-vă că acestea sunt expresii regulate. De exemplu, dacă doriți să potriviți sfârșitul unei secțiuni nroff care se termină cu linia C<.fi>, nu utilizați C<.fi> ca B<endboundary>, deoarece se va potrivi cu C<the[ fi]le>, ceea ce evident nu este ceea ce vă așteptați. B<endboundary> corect în acest caz este: C<^\.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.
ro: Spațiile albe SUNT importante în conținutul poziției C<position> și al limitelor. Astfel, cele două linii următoare B<sunt diferite>. Cea de-a doua va fi găsită numai dacă există suficiente spații la final în documentul tradus.

note: type: verbatim
en:  PO4A-HEADER: position=About this document; mode=after; beginboundary=<section>
     PO4A-HEADER: position=About this document ; mode=after; beginboundary=<section>
ro:  PO4A-HEADER: position=Despre acest document; mode=after; beginboundary=<section>
     PO4A-HEADER: position=Despre acest document ; 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.
ro: Deși se poate considera că această căutare contextuală operează aproximativ pe fiecare linie a documentului B<tradus>, ea operează de fapt pe șirul intern de date al documentului tradus. Acest șir de date interne poate fi un text care se întinde pe un paragraf conținând mai multe linii sau poate fi doar o etichetă XML. I<punctul de inserție> exact al addendumului trebuie să fie înainte sau după șirul intern de date și nu poate fi în interiorul șirului intern de date.

note: type: textblock
en: Pass the C<-vv> argument to B<po4a> to understand how the addenda are added to the translation. It may also help to run B<po4a> in debug mode to see the actual internal data string when your addendum does not apply.
ro: Treceți argumentul C<-vv> la B<po4a> pentru a înțelege cum sunt adăugate addendele la traducere. De asemenea, poate fi util să rulați B<po4a> în modul de depanare pentru a vedea șirul de date interne reale atunci când addendumul dvs. nu se aplică.

note: type: =head3
en: Addenda examples
ro: Exemple de addenda

note: type: textblock
en: If you want to add something after the following nroff section:
ro: Dacă doriți să adăugați ceva după următoarea secțiune nroff:

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:
ro: Ar trebui să selectați o abordare în doi pași prin definirea B<mode=after>. Apoi ar trebui să restrângeți căutarea la linia de după B<AUTHORS> cu expresia regulată a argumentului B<position>. Apoi, ar trebui să potriviți începutul următoarei secțiuni (și anume, B<^\.SH>) cu expresia regulată a argumentului B<beginboundary>. Adică:

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.
ro: Dacă doriți să adăugați ceva imediat după o anumită linie (de exemplu, după linia „Drepturi de autor Băiat Deștept”), utilizați un argument B<position> care corespunde acestei linii, definiți B<mode=after> și dați un B<beginboundary> care corespunde oricărei linii.

note: type: verbatim
en:  PO4A-HEADER:mode=after;position=Copyright Big Dude, 2004;beginboundary=^
ro:  PO4A-HEADER:mode=after;position=Drepturi de autor Băiat Deștept, 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.
ro: Dacă doriți să adăugați ceva la sfârșitul documentului, dați un argument B<position> care să corespundă oricărei linii din document (dar numai unei linii. Po4a nu va continua dacă nu este unic) și dați un argument B<endboundary> care să nu se potrivească cu nimic. Nu folosiți aici șiruri simple precum B<„EOF”>, ci preferați-le pe cele care au mai puține șanse să se afle în documentul dumneavoastră.

note: type: verbatim
en:  PO4A-HEADER:mode=after;position=About this document;beginboundary=FakePo4aBoundary
ro:  PO4A-HEADER:mode=after;position=Despre acest document;beginboundary=FakePo4aBoundary

note: type: =head3
en: More detailed example
ro: Un exemplu mai detaliat

note: type: textblock
en: Original document (POD formatted):
ro: Documentul original (formatat POD):

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").
ro: Apoi, următorul addendum va asigura adăugarea unei secțiuni (în franceză) despre traducător la sfârșitul dosarului (în franceză, „TRADUCTEUR” înseamnă „TRADUCĂTOR”, iar „moi” înseamnă „eu”).

note: type: textblock
en: To put your addendum before the AUTHOR, use the following header:
ro: Pentru a plasa addendumul înainte de AUTOR, utilizați următorul antet:

note: type: textblock
en: This works because the next line matching the B<beginboundary> C</^=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.
ro: Acest lucru funcționează deoarece următoarea linie care se potrivește cu B<beginboundary> C</^=head1/> după secțiunea „NAME” (tradusă prin „NOM” în franceză), este cea care declară autorii. Deci, addendumul va fi pus între cele două secțiuni. Rețineți că, dacă ulterior se adaugă o altă secțiune între secțiunile „NAME” și „AUTHOR”, po4a va plasa în mod eronat addenda înaintea noii secțiuni.

note: type: textblock
en: To avoid this you may accomplish the same using B<mode>=I<before>:
ro: Pentru a evita acest lucru, puteți realiza același lucru folosind B<mode>=I<before>:

note: type: =head1
en: How does it work?
ro: Cum funcționează acesta?

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 to maintain and to improve it. It may also help you to understand why it does not do what you expected, and how to solve your problems.
ro: Acest capitol vă oferă o scurtă prezentare generală a componentelor interne ale po4a, astfel încât să vă simțiți mai încrezători și să ne ajutați să îl menținem și să îl îmbunătățim. De asemenea, vă poate ajuta să înțelegeți de ce nu face ceea ce vă așteptați și cum să soluționați problemele ce pot apărea.

note: type: =head2
en: TransTractors and project architecture
ro: TransTractors și arhitectura proiectului

note: type: textblock
en: At the core of the po4a project, 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.
ro: La baza proiectului po4a, clasa L<Locale::Po4a::TransTractor(3pm)|TransTractor> este strămoșul comun al tuturor analizatorilor po4a. Acest nume ciudat provine din faptul că se ocupă în același timp de traducerea documentelor și de extragerea șirurilor de caractere.

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 as the input one, but with all translatable strings replaced with content of the input PO). Here is a graphical representation of this:
ro: Mai formal, acesta ia un document de tradus plus un fișier PO care conține traducerile de utilizat ca intrare, producând în același timp două rezultate separate: un alt fișier PO (rezultat din extragerea șirurilor traductibile din documentul de intrare) și un document tradus (cu aceeași structură ca cel de intrare, dar cu toate șirurile traductibile înlocuite cu conținutul PO de intrare). Iată o reprezentare grafică a acestui lucru:

note: type: verbatim
en:    Input document --\                             /---> Output document
                         \      TransTractor::       /       (translated)
                          +-->--   parse()  --------+
                         /                           \
       Input PO --------/                             \---> Output PO
                                                           (extracted)
ro:    Document intrare --\                             /---> Document ieșire
                           \      TransTractor::       /         (tradus)
                            +-->--   parse()  --------+
                           /                           \
       PO intrare --------/                             \---> PO ieșire
                                                              (extras)

note: type: textblock
en: This little bone is the core of all the po4a architecture. If you provide both input and disregard the output PO, you get B<po4a-translate>. If you disregard the output document instead, you get B<po4a-updatepo>. The B<po4a> uses a first TransTractor to get an up-to-date output POT file (disregarding the output documents), calls B<msgmerge -U> to update the translation PO files on disk, and builds a second TransTractor with these updated PO files to update the output documents. In short, B<po4a> provides one-stop solution to update what needs to be, using a single configuration file.
ro: Acest mic os este nucleul întregii arhitecturi „scheletului” po4a. Dacă furnizați ambele documente de intrare și nu țineți cont de PO de ieșire, obțineți B<po4a-translate>. Dacă în schimb desconsiderați documentul de ieșire, obțineți B<po4a-updatepo>. B<po4a> utilizează un prim TransTractor pentru a obține un fișier POT de ieșire actualizat (fără a ține cont de documentele de ieșire), apelează la B<msgmerge -U> pentru a actualiza fișierele PO de traducere de pe disc și construiește un al doilea TransTractor cu aceste fișiere PO actualizate pentru a actualiza documentele de ieșire. Pe scurt, B<po4a> oferă o soluție unică pentru a actualiza ceea ce este necesar, utilizând un singur fișier de configurare.

note: type: textblock
en: B<po4a-gettextize> also uses two TransTractors, but another way: It builds one TransTractor per language, and then build a new PO file using the msgids of the original document as msgids, and the msgids of the translated document as msgstrs. Much care is needed to ensure that the strings matched this way actually match, as described in L<po4a-gettextize(1)>.
ro: B<po4a-gettextize> utilizează, de asemenea, două TransTractors, dar într-un alt mod: Construiește un TransTractor pentru fiecare limbă, iar apoi construiește un nou fișier PO folosind msgids din documentul original ca msgids și msgids din documentul tradus ca msgstrs. Este nevoie de multă atenție pentru a se asigura că șirurile potrivite în acest mod corespund într-adevăr, după cum se descrie în L<po4a-gettextize(1)>.

note: type: =head2
en: Format-specific parsers
ro: Analizatori specifici formatului

note: type: textblock
en: All po4a format parsers are implemented on top of the TransTractor. Some of them are very simple, such as the Text, Markdown and AsciiDoc ones. They load the lines one by one using C<TransTractor::shiftline()>, accumulate the paragraphs' content or whatever. Once a string is completely parsed, the parser uses C<TransTractor::translate()> to (1) add this string to the output PO file and (2) get the translation from the input PO file. The parser then pushes the result to the output file using C<TransTractor::pushline()>.
ro: Toți analizatorii de format po4a sunt implementați pe partea de sus a TransTractor. Unii dintre ei sunt foarte simpli, cum ar fi cei Text, Markdown și AsciiDoc. Aceștia încarcă liniile una câte una folosind C<TransTractor::shiftline()>, acumulează conținutul paragrafelor sau orice altceva. Odată ce un șir de caractere este complet analizat, analizatorul utilizează C<TransTractor::translate()> pentru (1) a adăuga acest șir la fișierul PO de ieșire și (2) pentru a obține traducerea din fișierul PO de intrare. Analizatorul apoi introduce rezultatul în fișierul de ieșire utilizând C<TransTractor::pushline()>.

note: type: textblock
en: Some other parsers are more complex because they rely on an external parser to analyze the input document. The Xml, HTML, SGML and Pod parsers are built on top of SAX parsers. They declare callbacks to events such as "I found a new title which content is the following" to update the output document and output POT files according to the input content using C<TransTractor::translate()> and C<TransTractor::pushline()>. The Yaml parser is similar but different: it serializes a data structure produced by the YAML::Tiny parser. This is why the Yaml module of po4a fails to declare the reference lines: the location of each string in the input file is not kept by the parser, so we can only provide "$filename:1" as a string location. The SAX-oriented parsers use globals and other tricks to save the file name and line numbers of references.
ro: Alți analizatori sunt mai complecși deoarece se bazează pe un analizator extern pentru a analiza documentul de intrare. Analizatorii Xml, HTML, SGML și Pod sunt construiți pe baza analizatorilor SAX. Aceștia declară reapeluri la evenimente precum „Am găsit un titlu nou al cărui conținut este următorul” pentru a actualiza documentul de ieșire și fișierele POT de ieșire în funcție de conținutul de intrare utilizând C<TransTractor::translate()> și C<TransTractor::pushline()>. Analizatorul Yaml este similar, dar diferit: acesta serializează o structură de date produsă de analizatorul YAML::Tiny. Acesta este motivul pentru care modulul Yaml din po4a nu reușește să declare liniile de referință: locația fiecărui șir de caractere din fișierul de intrare nu este păstrată de analizator, astfel încât nu putem furniza decât „$filename:1” ca locație a șirului. Analizatorii orientați pe SAX utilizează caractere joker și alte trucuri pentru a salva numele fișierului și numerele de linie ale referințelor.

note: type: textblock
en: One specific issue arises from file encodings and BOM markers. Simple parsers can forget about this issue, that is handled by C<TransTractor::read()> (used internally to get the lines of an input document), but the modules relying on an external parser must ensure that all files are read with an appropriate PerlIO decoding layer. The easiest is to open the file yourself, and provide an filehandle or directly the full string to your external parser. Check on C<Pod::read()> and C<Pod::parse()> for an example. The content read by the TransTractor is ignored, but a fresh filehandle is passed to the external parser. The important part is the C<< "<:encoding($charset)" >> mode that is passed to the B<open()> perl function.
ro: O problemă specifică provine din codificarea fișierelor și marcatorii BOM. Analizatorii simpli pot uita de această problemă, care este tratată de C<TransTractor::read()> (utilizat intern pentru a obține liniile unui document de intrare), dar modulele care se bazează pe un analizator extern trebuie să se asigure că toate fișierele sunt citite cu un strat de decodificare PerlIO adecvat. Cel mai simplu este să deschideți chiar dvs. fișierul și să furnizați un identificator de fișier sau direct șirul complet analizatorului dvs. extern. Consultați C<Pod::read()> și C<Pod::parse()> pentru un exemplu. Conținutul citit de TransTractor este ignorat, dar un identificator de fișier nou este transmis analizatorului extern. Partea importantă este modul C<< „<:encoding($charset)” >> care este transmis funcției perl B<open()>.

note: type: =head2
en: Po objects
ro: Obiecte PO

note: type: textblock
en: The L<Locale::Po4a::Po(3pm)|Po> class is in charge of loading and using PO and POT files. Basically, you can read a file, add entries, get translations with the B<gettext()> method, write the PO into a file. More advanced features such as merging a PO file against a POT file or validating a file are delegated to B<msgmerge> and B<msgfmt> respectively.
ro: Clasa L<Locale::Po4a::Po(3pm)|Po> este responsabilă de încărcarea și utilizarea fișierelor PO și POT. Practic, puteți citi un fișier, adăuga intrări, obține traduceri cu metoda B<gettext()>, scrie PO într-un fișier. Funcțiile mai avansate, cum ar fi fuzionarea unui fișier PO cu un fișier POT sau validarea unui fișier, sunt delegate către B<msgmerge> și, respectiv, B<msgfmt>.

note: type: =head2
en: Contributing to po4a
ro: Contribuind la po4a

note: type: textblock
en: Even if you have never contributed to any Open Source project in the past, you are welcome: we are willing to help and mentor you here. po4a is best maintained by its users nowadays. As we lack manpower, we try to make the project welcoming by improving the doc and the automatic tests to make you confident in contributing to the project. Please refer to the CONTRIBUTING.md file for more details.
ro: Chiar dacă nu ați contribuit niciodată în trecut la vreun proiect Open Source, sunteți binevenit: suntem dispuși să vă ajutăm și să vă îndrumăm aici. po4a este cel mai bine întreținut de utilizatorii săi în zilele noastre. Deoarece nu dispunem de personal, încercăm să facem proiectul primitor prin îmbunătățirea documentației și a testelor automate pentru a vă face încrezători în contribuția la proiect. Vă rugăm să consultați fișierul CONTRIBUTING.md pentru mai multe detalii.

note: type: =head1
en: Open-source projects using po4a
ro: Proiecte cu cod-sursă deschis „open-source” care utilizează po4a

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).
ro: Iată o listă foarte parțială a proiectelor care utilizează po4a în producție pentru documentația lor. Dacă doriți să vă adăugați proiectul la listă, trimiteți-ne un e-mail (sau o cerere de îmbinare „merge request”).

note: type: textblock
en: adduser (man): users and groups management tool.
ro: adduser (man): instrument de gestionare a utilizatorilor și a grupurilor.

note: type: textblock
en: apt (man, docbook): Debian package manager.
ro: apt (man, docbook): Gestionarul de pachete Debian.

note: type: textblock
en: aptitude (docbook, svg): terminal-based package manager for Debian
ro: aptitude (docbook, svg): gestionar de pachete bazat pe terminal pentru Debian

note: type: textblock
en: L<F-Droid website|https://gitlab.com/fdroid/fdroid-website> (markdown): installable catalog of FOSS (Free and Open Source Software) applications for the Android platform.
ro: L<F-Droid website|https://gitlab.com/fdroid/fdroid-website> (markdown): catalog instalabil de aplicații de software liber și cod-sursă deschis („Free and Open Source Software”: FOSS) pentru platforma Android.

note: type: textblock
en: L<git|https://github.com/jnavila/git-manpages-l10n> (asciidoc): distributed version-control system for tracking changes in source code.
ro: L<git|https://github.com/jnavila/git-manpages-l10n> (asciidoc): sistem distribuit de control al versiunilor pentru urmărirea modificărilor în codul sursă.

note: type: textblock
en: L<Linux manpages|https://salsa.debian.org/manpages-l10n-team/manpages-l10n> (man)
ro: L<Linux manpages|https://salsa.debian.org/manpages-l10n-team/manpages-l10n> (pagini de manual)

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).
ro: Acest proiect oferă o infrastructură pentru traducerea multor pagini de manual în diferite limbi, gata de integrare în câteva distribuții majore (Arch Linux, Debian, Fedora, Mageia, openSUSE și derivatele acestora).

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.
ro: L<Stellarium|https://github.com/Stellarium/stellarium> (HTML): un planetariu cu cod-sursă deschis, gratuit pentru calculatorul dumneavoastră. po4a este utilizat pentru a traduce descrierile obiectelor cerești.

note: type: textblock
en: L<Jamulus|https://jamulus.io/> (markdown, yaml, HTML): a FOSS application for online jamming in real time. The website documentation is maintained in multiple languages using po4a.
ro: L<Jamulus|https://jamulus.io/> (markdown, yaml, HTML): o aplicație FOSS pentru bruiaj în linie în timp real. Documentația sitului web este menținută în mai multe limbi utilizând po4a.

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>
ro: Alt element de rezolvat: L<https://gitlab.com/fdroid/fdroid-website/> L<https://github.com/fsfe/reuse-docs/pull/61>

note: type: =head1
en: FAQ
ro: Întrebări și răspunsuri frecvente

note: type: =head2
en: How do you pronounce po4a?
ro: Cum se pronunță po4a?

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 :)
ro: Eu personal o vocalizez ca L<pouah|https://en.wiktionary.org/wiki/pouah>, care este o onomatopee franceză pe care o folosim în loc de expresie de dezgust :) Poate că am un simț al umorului ciudat :)

note: type: =head2
en: Why are the individual scripts deprecated?
ro: De ce sunt depreciate scripturile individuale?

note: type: textblock
en: Indeed, B<po4a-updatepo> and B<po4a-translate> are deprecated in favor of B<po4a>. The reason is that while B<po4a> can be used as a drop-in replacement to these scripts, there is quite a lot of code duplication here. Individual scripts last around 150 lines of codes while the B<po4a> program lasts 1200 lines, so they do a lot in addition of the common internals. The code duplication results in bugs occuring in both versions and needing two fixes. One example of such duplication are the bugs #1022216 in Debian and the issue #442 in GitHub that had the exact same fix, but one in B<po4a> and the other B<po4a-updatepo>.
ro: Într-adevăr, B<po4a-updatepo> și B<po4a-translate> sunt depreciate în favoarea lui B<po4a>. Motivul este că, deși B<po4a> poate fi utilizat ca înlocuitor al acestor scripturi, există destul de multe duplicații de cod aici. Scripturile individuale au în jur de 150 de linii de cod, în timp ce programul B<po4a> are 1200 de linii, astfel încât acestea fac multe lucruri în plus față de elementele interne comune. Duplicarea codului duce la apariția unor erori în ambele versiuni și la necesitatea a două remedieri. Un exemplu de astfel de duplicare sunt bug-urile #1022216 din Debian și problema #442 din GitHub care au avut exact același remediu, dar unul în B<po4a> și celălalt B<po4a-updatepo>.

note: type: textblock
en: In the long run, I would like to drop the individual scripts and only maintain one version of this code. The sure thing is that the individual scripts will not get improved anymore, so only B<po4a> will get the new features. That being said, there is no deprecation urgency. I plan to keep the individual scripts as long as possible, and at least until 2030. If your project still use B<po4a-updatepo> and B<po4a-translate> in 2030, you may have a problem.
ro: Pe termen lung, aș dori să renunț la scripturile individuale și să mențin o singură versiune a acestui cod. Lucrul sigur este că scripturile individuale nu vor mai fi îmbunătățite, astfel încât doar B<po4a> va beneficia de noile caracteristici. Acestea fiind spuse, nu există nicio urgență de depreciere. Intenționez să păstrez scripturile individuale cât de mult posibil și cel puțin până în 2030. Dacă proiectul dvs. utilizează încă B<po4a-updatepo> și B<po4a-translate> în 2030, s-ar putea să aveți o problemă.

note: type: textblock
en: We may also remove the deprecation of these scripts at some point, if a refactoring reduces the code duplication to zero. If you have an idea (or better: a patch), your help is welcome.
ro: De asemenea, am putea elimina deprecierea acestor scripturi la un moment dat, dacă o refactorizare reduce duplicarea codului la zero. Dacă aveți o idee (sau mai bine: un plasture „patch” :)), ajutorul dvs. este binevenit.

note: type: =head2
en: What about the other translation tools for documentation using gettext?
ro: Ce se întâmplă cu celelalte instrumente de traducere pentru documentație care utilizează gettext?

note: type: textblock
en: There are a few of them. Here is a possibly incomplete list, and more tools are coming at the horizon.
ro: Există câteva dintre ele. Iată o listă posibil incompletă, și multe alte instrumente apar la orizont.

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.
ro: Acesta este instrumentul dezvoltat de cei de la KDE pentru a gestiona DocBook XML. AFAIK, a fost primul program care a extras șiruri de caractere pentru a le traduce din documentație în fișiere PO și le-a injectat înapoi după traducere.

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.
ro: Poate gestiona doar XML și doar un anumit DTD. Sunt destul de nemulțumit de gestionarea listelor, care se termină cu un msgid mare. Când lista devine mare, fragmentul devine mai greu de înghițit.

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.
ro: Acest program realizat de Denis Barbier este un fel de precursor al modulului SGML po4a, care îl depreciază mai mult sau mai puțin. După cum spune și numele, acesta gestionează doar DTD-ul DebianDoc, care este mai mult sau mai puțin un DTD depreciat.

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.
ro: Folosit de echipa de documentare GIMP din 2004, funcționează destul de bine, chiar dacă, după cum sugerează și numele, funcționează doar cu fișiere XML și are nevoie de fișiere makefile configurate special.

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.
ro: Proiectul de documentare Sphinx utilizează, de asemenea, gettext în mod extensiv pentru a-și gestiona traducerile. Din păcate, acesta funcționează doar pentru câteva formate de text, rest și markdown, deși este probabil singurul instrument care gestionează întregul proces de traducere.

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.
ro: Principalele avantaje ale po4a față de acestea sunt ușurința de a adăuga conținut suplimentar (care este chiar mai rău acolo) și capacitatea de a realiza gettextizarea.

note: type: =head2
en: SUMMARY of the advantages of the gettext based approach
ro: REZUMAT al avantajelor abordării bazate pe gettext

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.
ro: Traducerile nu sunt stocate împreună cu originalul, ceea ce face posibilă detectarea dacă traducerile devin neactualizate.

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.
ro: Traducerile sunt stocate în fișiere separate unele de altele, ceea ce previne interferența între traducătorii din limbi diferite, atât atunci când își trimit modificările, cât și la nivelul codificării fișierelor.

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.
ro: Acesta se bazează intern pe B<gettext> (dar B<po4a> oferă o interfață foarte simplă, astfel încât nu trebuie să înțelegeți elementele interne pentru a-l utiliza). În acest fel, nu trebuie să reinventăm roata și, datorită utilizării lor pe scară largă, putem crede că aceste instrumente sunt mai mult sau mai puțin lipsite de erori.

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.
ro: Nu s-a schimbat nimic pentru utilizatorul final (în afară de faptul că traducerile vor fi, sperăm, mai bine întreținute). Fișierul de documentație rezultat distribuit este exact același.

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.
ro: Nu este nevoie ca traducătorii să învețe o nouă sintaxă de fișier, iar editorul lor preferat de fișiere PO (cum ar fi modul PO din Emacs, Lokalize sau Gtranslator) va funcționa foarte bine.

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:
ro: gettext oferă o modalitate simplă de a obține statistici despre ceea ce este făcut, ceea ce ar trebui revizuit și actualizat și ceea ce mai este de făcut. Unele exemple pot fi găsite la aceste adrese:

note: type: textblock
en: But everything isn't green, and this approach also has some disadvantages we have to deal with.
ro: Dar nu totul este „în roz”, iar această abordare are și unele dezavantaje cu care trebuie să ne confruntăm.

note: type: textblock
en: Addenda are somewhat strange at the first glance.
ro: Addenda este oarecum ciudată la prima vedere.

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.
ro: Nu puteți adapta textul tradus la preferințele dvs., cum ar fi divizarea unui paragraf aici și unirea altor două acolo. Dar, într-un anumit sens, dacă există o problemă cu originalul, aceasta ar trebui oricum raportată ca eroare.

note: type: textblock
en: Even with an easy interface, it remains a new tool people have to learn.
ro: Chiar și cu o interfață ușoară, acesta rămâne un instrument nou pe care oamenii trebuie să îl învețe.

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.
ro: Unul dintre visele mele ar fi să integrez cumva po4a la Gtranslator sau Lokalize. Când se deschide un fișier de documentație, șirurile de caractere sunt extrase automat, iar un fișier tradus + fișier po poate fi scris pe disc. Dacă reușim să facem un modul MS Word (TM) (sau cel puțin RTF), traducătorii profesioniști ar putea chiar să-l folosească.

note: type: textblock
en: The documentation of the all-in-one tool that you should use: L<po4a(1)>.
ro: Documentația instrumentului „totul în unul” pe care ar trebui să o utilizați: 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)>.
ro: Documentația scripturilor individuale po4a: 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)>.
ro: Scripturile de ajutor suplimentare: 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)>.
ro: Analizatorii fiecărui format, în special pentru a vedea opțiunile acceptate de fiecare dintre ei: 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.
ro: Implementarea infrastructurii de bază: L<Locale::Po4a::TransTractor(3pm)> (deosebit de important pentru a înțelege organizarea codului), L<Locale::Po4a::Chooser(3pm)>, L<Locale::Po4a::Po(3pm)>, L<Locale::Po4a::Common(3pm)>. Vă rugăm să verificați și fișierul F<CONTRIBUTING.md> din arborele codului sursă.

note: type: textblock
en: Locale::Po4a::AsciiDoc - convert AsciiDoc documents from/to PO files
ro: Locale::Po4a::AsciiDoc - convertește documente AsciiDoc din/în fișiere PO

note: type: textblock
en: Locale::Po4a::AsciiDoc is a module to help the translation of documentation in the AsciiDoc format.
ro: Locale::Po4a::AsciiDoc este un modul care ajută la traducerea documentației în formatul AsciiDoc.

note: type: =head1
en: OPTIONS ACCEPTED BY THIS MODULE
ro: OPȚIUNI ACCEPTATE DE ACEST MODUL

note: type: textblock
en: These are this module's particular options:
ro: Acestea sunt opțiunile particulare ale acestui modul:

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.
ro: Numele unui fișier care conține definiții pentru po4a, astfel cum sunt definite în secțiunea B<PERSONALIZARE INLINE>. Puteți utiliza această opțiune dacă nu este posibil să introduceți definițiile în documentul tradus.

note: type: textblock
en: In a definitions file, lines must not start by two slashes, but directly by B<po4a:>.
ro: Într-un fișier de definiții, liniile nu trebuie să înceapă cu două bare oblice, ci direct cu B<po4a:>.

note: type: textblock
en: Space-separated list of attribute entries you want to translate.  By default, no attribute entries are translatable.
ro: Listă separată prin spații a intrărilor de atribute pe care doriți să le traduceți. În mod implicit, nicio intrare de atribut nu poate fi tradusă.

note: type: textblock
en: Space-separated list of macro definitions.
ro: Listă de definiții de macro-uri separate prin spațiu.

note: type: textblock
en: Space-separated list of style definitions.
ro: Listă de definiții de stiluri separate prin spații.

note: type: textblock
en: Enable automatic line wrapping in non-verbatim blocks, even if the result could be misinterpreted by AsciiDoc formatters.
ro: Activează încadrarea automată a liniilor în blocuri non-verbatim, chiar dacă rezultatul ar putea fi interpretat greșit de formatatori AsciiDoc.

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:
ro: În mod implicit, po4a nu va încadra fișierele AsciiDoc produse deoarece este necesară o inspecție manuală pentru a se asigura că încadrarea nu modifică formatarea. Luați în considerare, de exemplu, următorul element de listă:

note: type: verbatim
en:  * a long sentence that is ending with a number 1. A second sentence.
ro:  * o propoziție lungă care se termină cu un număr 1. O a doua propoziție.

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.
ro: Dacă încadrarea conduce la următoarea prezentare, elementul este împărțit într-o sublistă numerotată. Pentru a înrăutăți lucrurile, numai vorbitorii limbii utilizate în traducere pot inspecta situația.

note: type: verbatim
en:  * a long sentence that is ending with a number
       1. A second sentence.
ro:  * o propoziție lungă care se termină cu un număr
       1. O a doua propoziție.

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.
ro: Rețineți că neincluderea fișierelor produse de po4a nu ar trebui să fie o problemă, deoarece aceste fișiere sunt menite să fie prelucrate automat. Oricum, acestea nu ar trebui să fie considerate fișiere sursă.

note: type: textblock
en: With this option, po4a will produce better-looking AsciiDoc files, but it may lead to possibly erroneous formatted outputs.
ro: Cu această opțiune, po4a va produce fișiere AsciiDoc mai aspectuoase, dar poate duce la rezultate formatate eronat.

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.
ro: În mod implicit, țintele imaginilor bloc sunt traductibile pentru a oferi posibilitatea de a face conținutul să indice imagini traduse. Acest lucru poate fi oprit prin definirea acestei opțiuni.

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.
ro: Această opțiune este un fanion care permite segmentarea sub-tabelului în conținutul celulelor. Segmentarea este limitată la conținutul celulei, fără nicio analiză în interiorul acesteia.

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.
ro: Schimbă regulile de analizare pentru compatibilitate cu diferite instrumente. Opțiunile disponibile sunt „asciidoc” sau „asciidoctor”. Asciidoctor are reguli de parsare mai stricte, cum ar fi egalitatea lungimii blocurilor de deschidere și de închidere.

note: type: textblock
en: Disable linting messages. When the source code cannot be fixed for clearer document structure, these messages are useless.
ro: Dezactivează mesajele de verificare. Atunci când codul sursă nu poate fi fixat pentru o structură mai clară a documentului, aceste mesaje sunt inutile.

note: type: textblock
en: Remove extra spaces from the source segments in no-wrap mode. This is useful when the translation tools are sensitive to the number of spaces.
ro: Elimină spațiile suplimentare din segmentele sursă în modul „no-wrap”. Acest lucru este util atunci când instrumentele de traducere sunt sensibile la numărul de spații.

note: type: textblock
en: Comma-separated list of keys to process for translation in the YAML Front Matter section. All other keys are skipped. Keys are matched with a case-sensitive match. If B<yfm_paths> and B<yfm_keys> are used together, values are included if they are matched by at least one of the options. Array values are always translated, unless the B<yfm_skip_array> option is provided.
ro: Listă de chei separate prin virgule care urmează să fie procesate pentru traducere în secțiunea de prezentare (introductivă) YAML. Toate celelalte chei sunt ignorate. Cheile sunt comparate cu o potrivire sensibilă la majuscule. Dacă B<yfm_paths> și B<yfm_keys> sunt utilizate împreună, valorile sunt incluse dacă se potrivesc cu cel puțin una dintre opțiuni. Valorile din matrice sunt întotdeauna traduse, cu excepția cazului în care este furnizată opțiunea B<yfm_skip_array>.

note: type: textblock
en: Do not translate array values in the YAML Front Matter section.
ro: Nu traduce valorile matricei din secțiunea de prezentare YAML.

note: type: textblock
en: Comma-separated list of hash paths to process for extraction in the YAML Front Matter section, all other paths are skipped. Paths are matched with a case-sensitive match. If B<yfm_paths> and B<yfm_keys> are used together, values are included if they are matched by at least one of the options.  Arrays values are always returned unless the B<yfm_skip_array> option is provided.
ro: Listă separată prin virgule de rute hash care urmează să fie procesate pentru extragere în secțiunea de prezentare YAML, toate celelalte rute sunt ignorate. Rutele sunt comparate cu o potrivire sensibilă la majuscule. Dacă B<yfm_paths> și B<yfm_keys> sunt utilizate împreună, valorile sunt incluse dacă sunt potrivite cu cel puțin una dintre opțiuni. Valorile matricelor sunt întotdeauna returnate, cu excepția cazului în care este furnizată opțiunea B<yfm_skip_array>.

note: type: =head1
en: INLINE CUSTOMIZATION
ro: PERSONALIZARE INLINE

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:
ro: Modulul AsciiDoc poate fi personalizat cu linii care încep cu B<//po4a:>. Aceste linii sunt interpretate drept comenzi pentru analizator. Sunt recunoscute următoarele comenzi:

note: type: =item
en: B<//po4a: macro >I<name>B<[>I<attribute list>B<]>
ro: B<//po4a: macro >I<nume>B<[>I<listă-atribute>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.
ro: Acesta descrie în detaliu parametrii unei B<macro>; I<nume> trebuie să fie un nume de macro valid și se termină cu un caracter de subliniere dacă ținta trebuie tradusă.

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.
ro: Argumentul I<listă-atribute> este o listă separată prin virgule care conține informații despre argumentele traductibile. Această listă conține fie numere, pentru a defini parametrii poziționali, fie atribute numite.

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.
ro: Dacă un semn plus (B<+>) este anexat la I<nume>, atunci macro-ul și argumentele sale sunt traduse ca un întreg. Nu este necesară definirea listei de atribute în acest caz, dar parantezele trebuie să fie prezente.

note: type: =item
en: B<//po4a: style >B<[>I<attribute list>B<]>
ro: B<//po4a: style >B<[>I<listă-atribute>B<]>

note: type: textblock
en: This describes in detail which attributes of a style must be translated.
ro: Aceasta descrie în detaliu care atribute ale unui stil trebuie traduse.

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.
ro: Argumentul I<listă-atribute> este o listă separată prin virgule care conține informații despre argumentele traductibile. Această listă conține fie numere, pentru a defini parametrii poziționali, fie atribute numite. Primul atribut este numele stilului, acesta nu va fi tradus.

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.
ro: Dacă numele stilului este precedat de un semn plus (B<+>), atunci lista de atribute este tradusă ca întreg. Nu este necesar să se definească atribute traductibile.

note: type: textblock
en: If a minus sign (B<->) is prepended to the style name, then this attribute is not translated.
ro: Dacă numele stilului este precedat de un semn minus (B<->), atunci acest atribut nu este tradus.

note: type: =item
en: B<//po4a: entry >I<name>
ro: B<//po4a: entry >I<nume>

note: type: textblock
en: This declares an attribute entry as being translatable.  By default, they are not translated.
ro: Aceasta declară o intrare de atribut ca fiind traductibilă. În mod implicit, acestea nu sunt traduse.

note: type: =head1
en: STATUS OF THIS MODULE
ro: STAREA ACESTUI MODUL

note: type: textblock
en: Tested successfully on simple AsciiDoc files.
ro: Testat cu succes pe fișiere AsciiDoc simple.

note: type: verbatim
en:  Copyright © 2005-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
     Copyright © 2012 Denis BARBIER <barbier@linuxfr.org>.
     Copyright © 2017 Martin Quinson <mquinson#debian.org>.
ro:  Drepturi de autor © 2005-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
     Drepturi de autor © 2012 Denis BARBIER <barbier@linuxfr.org>.
     Drepturi de autor © 2017 Martin Quinson <mquinson#debian.org>.

note: type: textblock
en: Locale::Po4a::BibTeX - convert BibTeX documents from/to PO files
ro: Locale::Po4a::BibTeX - convertește documente BibTeX din/în fișiere PO

note: type: textblock
en: Locale::Po4a::BibTeX is a module to help the translation of bibliographies in the BibTeX format into other [human] languages.
ro: Locale::Po4a::BibTeX este un modul care ajută la traducerea bibliografiilor în format BibTeX în alte limbi [umane].

note: type: textblock
en: Fields values are extracted and proposed for translation.
ro: Valorile câmpurilor sunt extrase și propuse pentru traducere.

note: type: textblock
en: NONE.
ro: NICIUNA.

note: type: textblock
en: It is a very simple module, but still young.
ro: Este un modul foarte simplu, dar încă tânăr.

note: type: verbatim
en:  Copyright © 2006 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
ro:  Drepturi de autor © 2006 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.

note: type: textblock
en: Locale::Po4a::Chooser - manage po4a modules
ro: Locale::Po4a::Chooser - gestionează modulele po4a

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.
ro: Locale::Po4a::Chooser este un modul pentru gestionarea modulelor po4a. Anterior, toate binarele po4a obișnuiau să cunoască toate modulele po4a (pod, man, sgml etc.). Acest lucru făcea ca adăugarea unui nou modul să fie anevoioasă, deoarece trebuia să vă asigurați că documentația este sincronizată în toate modulele și că fiecare dintre ele poate accesa noul modul.

note: type: textblock
en: Now, you just have to call the Locale::Po4a::Chooser::new() function, passing the name of module as argument.
ro: Acum, trebuie doar să apelați funcția Locale::Po4a::Chooser::new(), trecând numele modulului ca argument.

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.
ro: Funcția Locale::Po4a::Chooser::list() enumeră formatele disponibile și iese cu valoarea trecută ca argument. Astfel, apelăm Locale::Po4a::Chooser::list(0) atunci când este solicitată lista de formate și Locale::Po4a::Chooser::list(1) atunci când este transmis un nume de format nevalid.

note: type: =item
en: About po4a:
ro: Despre po4a:

note: type: =item
en: About modules:
ro: Despre module:

note: type: textblock
en: L<Locale::Po4a::Dia(3pm)>, L<Locale::Po4a::Docbook(3pm)>, L<Locale::Po4a::Guide(3pm)>, L<Locale::Po4a::Halibut(3pm)>, L<Locale::Po4a::Ini(3pm)>, L<Locale::Po4a::KernelHelp(3pm)>, L<Locale::Po4a::LaTeX(3pm)>, L<Locale::Po4a::Man(3pm)>, L<Locale::Po4a::Pod(3pm)>, L<Locale::Po4a::RubyDoc(3pm)>, L<Locale::Po4a::Sgml(3pm)>, L<Locale::Po4a::TeX(3pm)>, L<Locale::Po4a::Texinfo(3pm)>, L<Locale::Po4a::Text(3pm)>, L<Locale::Po4a::Wml(3pm)>.  L<Locale::Po4a::Xhtml(3pm)>, L<Locale::Po4a::Xml(3pm)>, L<Locale::Po4a::Wml(3pm)>, L<Locale::Po4a::Yaml(3pm)>.
ro: L<Locale::Po4a::Dia(3pm)>, L<Locale::Po4a::Docbook(3pm)>, L<Locale::Po4a::Guide(3pm)>, L<Locale::Po4a::Halibut(3pm)>, L<Locale::Po4a::Ini(3pm)>, L<Locale::Po4a::KernelHelp(3pm)>, L<Locale::Po4a::LaTeX(3pm)>, L<Locale::Po4a::Man(3pm)>, L<Locale::Po4a::Pod(3pm)>, L<Locale::Po4a::RubyDoc(3pm)>, L<Locale::Po4a::Sgml(3pm)>, L<Locale::Po4a::TeX(3pm)>, L<Locale::Po4a::Texinfo(3pm)>, L<Locale::Po4a::Text(3pm)>, L<Locale::Po4a::Wml(3pm)>. L<Locale::Po4a::Xhtml(3pm)>, L<Locale::Po4a::Xml(3pm)>, L<Locale::Po4a::Wml(3pm)>, L<Locale::Po4a::Yaml(3pm)>.

note: type: textblock
en: Copyright © 2002-2005, 2014, 2017 SPI, Inc.
ro: Drepturi de autor © 2002-2005, 2014, 2017 SPI, Inc.

note: type: textblock
en: Locale::Po4a::Common - common parts of the po4a scripts and utils
ro: Locale::Po4a::Common - părți comune ale scripturilor și instrumentelor po4a

note: type: textblock
en: Locale::Po4a::Common contains common parts of the po4a scripts and some useful functions used along the other modules.
ro: Locale::Po4a::Common conține părți comune ale scripturilor po4a și unele funcții utile utilizate împreună cu alte module.

note: type: textblock
en: If needed, you can disable the use of Text::WrapI18N as such:
ro: Dacă este necesar, puteți dezactiva utilizarea Text::WrapI18N în acest mod:

note: type: textblock
en: instead of:
ro: în loc de:

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.
ro: Ordinea este importantă aici: deoarece majoritatea modulelor Locale::Po4a încarcă ele însele Locale::Po4a::Common, prima dată când acest modul este încărcat determină dacă Text::WrapI18N este utilizat.

note: type: =head1
en: FUNCTIONS
ro: FUNCȚII

note: type: =head2
en: Showing output messages
ro: Afișarea mesajelor de ieșire

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.
ro: Afișează versiunea curentă a scriptului și un scurt mesaj de drepturi de autor. Primește numele scriptului ca 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.
ro: Această funcție afișează un mesaj în același mod ca sprintf(), dar încadrează rezultatul astfel încât să arate bine pe terminal.

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.
ro: Această funcție funcționează ca wrap_msg(), dar ia un nume de modul ca prim argument și lasă un spațiu în stânga mesajului.

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.
ro: Această funcție funcționează ca wrap_msg(), dar ia o referință fișier:linie ca prim argument, un nume de modul ca al doilea și lasă un spațiu în stânga mesajului.

note: type: =head2
en: Wrappers for other modules
ro: Module de învăluire pentru alte 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.
ro: Atunci când modulul Locale::Gettext nu poate fi încărcat, acest modul oferă o implementare fictivă (goală) a următoarelor funcții. În acest caz, mesajele po4a nu vor fi traduse, dar programul va continua să funcționeze.

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.
ro: Dacă Locale::gettext este prezent, acest wrapper solicită, de asemenea, setlocale(LC_MESSAGES, ""), astfel încât apelanții să nu depindă de modulul POSIX.

note: type: textblock
en: Copyright © 2005 SPI, Inc.
ro: Drepturi de autor © 2005 SPI, Inc.

note: type: textblock
en: Locale::Po4a::Dia - convert uncompressed Dia diagrams from/to PO files
ro: Locale::Po4a::Dia - convertește diagrame Dia necomprimate din/în fișiere PO

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.
ro: Locale::Po4a::Dia este un modul care ajută la traducerea diagramelor în format Dia necomprimat în alte limbi [umane].

note: type: verbatim
en: You can get Dia (the graphical editor for these diagrams) from:
      http://www.gnome.org/projects/dia/
ro: Puteți obține Dia (editorul grafic pentru aceste diagrame) de la:
      http://www.gnome.org/projects/dia/

note: type: =head1
en: TRANSLATING WITH PO4A::DIA
ro: TRADUCEREA CU 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.
ro: Acest modul traduce numai diagramele Dia necomprimate. Puteți salva diagramele necomprimate chiar cu Dia, debifând opțiunea „Comprimați fișierele diagramă” din caseta de dialog „Salvați diagrama”.

note: type: verbatim
en: Another way is to uncompress the dia files from command line with:
      gunzip < original.dia > uncompressed.dia
ro: O altă modalitate este de a decomprima fișierele dia din linia de comandă cu:
      gunzip < original.dia > decomprimat.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.
ro: Acest modul este complet funcțional, deoarece se bazează pe modulul L<Locale::Po4a::Xml>. Acesta definește doar etichetele traductibile (E<lt>dia:stringE<gt>) și filtrează șirurile interne (conținutul etichetei E<lt>dia:diagramdataE<gt>), neinteresante pentru traducere.

note: type: textblock
en: Copyright © 2004 Jordi Vilalta <jvprat@gmail.com>
ro: Drepturi de autor © 2004 Jordi Vilalta <jvprat@gmail.com>

note: type: textblock
en: Locale::Po4a::Docbook - convert DocBook XML documents from/to PO files
ro: Locale::Po4a::Docbook - convertește documente DocBook XML din/în fișiere PO

note: type: textblock
en: Locale::Po4a::Docbook is a module to help the translation of DocBook XML documents into other [human] languages.
ro: Locale::Po4a::Docbook este un modul care ajută la traducerea documentelor DocBook XML în alte limbi [umane].

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.
ro: Acest modul este complet funcțional, deoarece se bazează pe modulul L<Locale::Po4a::Xml>. Acesta definește doar etichetele și atributele traductibile.

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.
ro: Singura problemă cunoscută este că nu se ocupă încă de entități, iar acest lucru include entitățile de includere a fișierelor, dar puteți traduce majoritatea acestor fișiere singure (cu excepția fișierelor tipice de entități) și, de obicei, este mai bine să le păstrați separate.

note: type: =head2
en: OVERRIDE THE DEFAULT BEHAVIOR WITH COMMAND LINE OPTIONS
ro: SUPRASCRIE COMPORTAMENTUL IMPLICIT CU OPȚIUNI DE LINIE DE COMANDĂ

note: type: textblock
en: The default behavior of system provided modules is set to be on the safe side.
ro: Comportamentul implicit al modulelor furnizate de sistem este stabilit pentru a fi pe partea de siguranță.

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.
ro: De exemplu, eticheta B<< <author> >> are ca scop implicit să apară sub B<< <para> >>. Dar este posibil să o utilizați numai sub B<< <bookinfo> >>. Pentru acest caz, este posibil să doriți să o traduceți independent pentru fiecare autor.

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:
ro: Dacă nu vă place comportamentul implicit al modulului xml și al modulelor sale derivate, puteți furniza opțiuni de linie de comandă pentru a le modifica comportamentul. De exemplu, puteți adăuga următoarele la fișierul de configurare po4a:

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.
ro: Acest lucru anulează comportamentul implicit pentru B<< <bookinfo> >> și B<< <author> >>, definește ca B<< <bookinfo> >> și B<< <author> >> să întrerupă fluxul de date de intrare pe aceste etichete, definește  ca B<< <bookinfo> >> să nu traducă conținutul său etichetat și definește ca B<< <author> >> să traducă conținutul său etichetat.

note: type: verbatim
en:  Copyright © 2004 Jordi Vilalta  <jvprat@gmail.com>
     Copyright © 2007-2009 Nicolas François <nicolas.francois@centraliens.net>
ro:  Drepturi de autor © 2004 Jordi Vilalta <jvprat@gmail.com>
     Drepturi de autor © 2007-2009 Nicolas François <nicolas.francois@centraliens.net>

note: type: textblock
en: Locale::Po4a::Guide - convert Guide XML documents from/to PO files
ro: Locale::Po4a::Guide - convertește documentele XML Guide din/în fișiere PO

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.
ro: Locale::Po4a::Guide este un modul care ajută la traducerea documentației Gentoo Linux în format XML Guide în alte limbi [umane].

note: type: textblock
en: This format is documented here: http://www.gentoo.org/doc/en/xml-guide.xml
ro: Acest format este documentat aici: 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.
ro: Singura problemă cunoscută este că nu include fișiere cu eticheta <include href=„...”>, dar puteți traduce toate aceste fișiere singure și, de obicei, este mai bine să le aveți separate.

note: type: textblock
en: Locale::Po4a::Halibut - convert Halibut documents and derivates from/to PO files
ro: Locale::Po4a::Halibut - convertește documentele Halibut și derivatele din/în fișiere PO

note: type: textblock
en: Locale::Po4a::Halibut is a module to help the translation of Halibut documents into other [human] languages.
ro: Locale::Po4a::Halibut este un modul care ajută la traducerea documentelor Halibut în alte limbi [umane].

note: type: textblock
en: This module contains the definitions of common Halibut commands and environments.
ro: Acest modul conține definițiile comenzilor și mediilor Halibut comune.

note: type: textblock
en: This module is still beta.  Please send feedback and feature requests.
ro: Acest modul este încă beta. Vă rugăm să trimiteți opinii și cereri de caracteristici.

note: type: =head1
en: CAVEAT
ro: AVERTISMENT

note: type: textblock
en: Some constructs are badly supported. The known ones are documented below.
ro: Unele construcții nu sunt complet compatibile. Cele cunoscute sunt documentate mai jos.

note: type: =head2
en: Verbatim blocks
ro: Blocuri verbatim (textuale, sau mai bine zis de text formatat)

note: type: textblock
en: The verbatim block is not considered as a whole. Each line will be translated separately.
ro: Blocul verbatim nu este considerat ca un întreg. Fiecare rând va fi tradus separat.

note: type: textblock
en: Copyright © 2004-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
ro: Drepturi de autor © 2004-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.

note: type: textblock
en: Locale::Po4a::Ini - convert INI files from/to PO files
ro: Locale::Po4a::Ini - convertește fișiere INI din/în fișiere PO

note: type: textblock
en: Locale::Po4a::Ini is a module to help the translation of INI files into other [human] languages.
ro: Locale::Po4a::Ini este un modul care ajută la traducerea fișierelor INI în alte limbi [umane].

note: type: textblock
en: The module searches for lines of the following format and extracts the quoted text:
ro: Modulul caută linii cu următorul format și extrage textul aflat între ghilimele:

note: type: textblock
en: identificator="text than can be translated"
ro: identificator="text care poate fi tradus"

note: type: textblock
en: NOTE: If the text is not quoted, it will be ignored.
ro: NOTĂ: Dacă textul nu este pus între ghilimele, acesta va fi ignorat.

note: type: textblock
en: Copyright © 2006 BitDefender
ro: Drepturi de autor © 2006 BitDefender

note: type: textblock
en: Locale::Po4a::KernelHelp - convert kernel configuration help from/to PO files
ro: Locale::Po4a::KernelHelp - convertește ajutorul de configurare a nucleului din/în fișiere PO

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.
ro: Locale::Po4a::KernelHelp este un modul care ajută la traducerea documentației pentru opțiunile de configurare a nucleului Linux în alte limbi [umane].

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.
ro: Acest modul este abia scris și are nevoie de mai multe teste. Cea mai mare parte a muncii necesare se va referi la instrumentele utilizate pentru analizarea acestui fișier (și configurarea nucleului), astfel încât acestea să accepte să citească documentația dintr-un alt fișier (tradus).

note: type: textblock
en: Copyright © 2002 SPI, Inc.
ro: Drepturi de autor © 2002 SPI, Inc.

note: type: textblock
en: Locale::Po4a::LaTeX - convert LaTeX documents and derivates from/to PO files
ro: Locale::Po4a::LaTeX - convertește documente LaTeX și derivate din/în fișiere PO

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.
ro: Locale::Po4a::LaTeX este un modul care ajută la traducerea documentelor LaTeX în alte limbi [umane]. De asemenea, poate fi folosit ca bază pentru a construi module pentru documente bazate pe LaTeX.

note: type: textblock
en: This module contains the definitions of common LaTeX commands and environments.
ro: Acest modul conține definițiile comenzilor și mediilor LaTeX uzuale.

note: type: textblock
en: See the L<Locale::Po4a::TeX(3pm)|Locale::Po4a::TeX> manpage for the list of recognized options.
ro: Consultați pagina de manual L<Locale::Po4a::TeX(3pm)|Locale::Po4a::TeX> pentru lista de opțiuni recunoscute.

note: type: textblock
en: Copyright © 2004, 2005 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
ro: Drepturi de autor © 2004, 2005 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.

note: type: textblock
en: Locale::Po4a::Man - convert manual pages from/to PO files
ro: Locale::Po4a::Man - convertește pagini de manual din/în fișiere PO

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.
ro: Locale::Po4a::Man este un modul care ajută la traducerea documentației în format nroff (limba paginilor de manual) în alte limbi [umane].

note: type: =head1
en: TRANSLATING WITH PO4A::MAN
ro: TRADUCEREA CU 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.
ro: Acest modul încearcă din răsputeri să facă viața traducătorului mai ușoară. Pentru aceasta, textul prezentat traducătorilor nu este o copie literală a textului găsit în pagina de manual. Într-adevăr, părțile mai grosolane ale formatului nroff sunt ascunse, astfel încât traducătorii să nu se poată încurca cu ele.

note: type: =head2
en: Text wrapping
ro: Încadrarea textului

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.
ro: Paragrafele neindentate sunt în mod automat re-încadrate pentru traducător. Acest lucru poate duce la unele diferențe minore în rezultatul generat, deoarece regulile de reformulare utilizate de groff nu sunt foarte clare. De exemplu, două spații după o paranteză sunt uneori păstrate.

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.
ro: Oricum, diferența va fi doar în ceea ce privește poziția spațiilor suplimentare în paragraful încadrat, și cred că merită.

note: type: =head2
en: Font specification
ro: Specificarea fontului

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:
ro: Prima modificare se referă la specificațiile de schimbare a fontului.  În nroff, există mai multe modalități de a specifica dacă un anumit cuvânt ar trebui să fie scris cu litere mici, aldine sau cursive. În textul de tradus, există o singură modalitate, împrumutată din formatul POD (documentația în linie Perl):

note: type: =item
en: IE<lt>textE<gt> -- italic text
ro: IE<lt>textE<gt> -- text cursiv

note: type: textblock
en: equivalent to \fItext\fP or ".I text"
ro: echivalent cu \fItext\fP sau ".I text"

note: type: =item
en: BE<lt>textE<gt> -- bold text
ro: BE<lt>textE<gt> -- text aldin

note: type: textblock
en: equivalent to \fBtext\fP or ".B text"
ro: echivalent cu \fBtext\fP sau ".B text"

note: type: =item
en: RE<lt>textE<gt> -- roman text
ro: RE<lt>textE<gt> -- text normal (roman)

note: type: textblock
en: equivalent to \fRtext\fP
ro: echivalent cu \fRtext\fP

note: type: =item
en: CWE<lt>textE<gt> -- constant width text
ro: CWE<lt>textE<gt> -- text cu lățime constantă

note: type: textblock
en: equivalent to \f(CWtext\fP or ".CW text"
ro: echivalent cu \f(CWtext\fP sau ".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.
ro: Observație: Aspectul CW al fontului nu este disponibil pentru toate dispozitivele Groff. Nu este recomandată utilizarea acestuia. Acesta este furnizat pentru confortul dumneavoastră.

note: type: =head2
en: Automatic characters transliteration
ro: Transliterarea automată a caracterelor

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:
ro: Po4a translitera automat unele caractere pentru a facilita traducerea sau revizuirea traducerii. Aici este lista transliterărilor:

note: type: =item
en: hyphens
ro: cratime

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.
ro: Cratimele (-) și semnele minus (\-) din paginile de manual sunt toate transliterate ca liniuțe simple (-) în fișierul PO.  Apoi, toate liniuțele sunt transliterate în semne minus roff (\-) atunci când traducerea este inserată în documentul de ieșire.

note: type: textblock
en: Translators can force an hyphen by using the roff glyph '\[hy]' in their translations.
ro: Traducătorii pot forța o cratimă prin utilizarea glifului roff „\[hy]” în traducerile lor.

note: type: =item
en: non-breaking spaces
ro: spații rigide

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 ('\ ').
ro: Traducătorii pot utiliza spații fără pauză în traducerile lor. Aceste spații rigide (0xA0 în latin1) vor fi transliterate într-un spațiu fără pauză roff ('\ ').

note: type: =item
en: quotes transliterations
ro: transliterații de ghilimele

note: type: textblock
en: `` and '' are respectively tranliterated into \*(lq and \*(rq.
ro: Ghilimelele `` și '' sunt transliterate în \*(lq și respectiv \*(rq.

note: type: textblock
en: To avoid these transliterations, translators can insert a zero width roff character (i.e., using `\&` or '\&' respectively).
ro: Pentru a evita aceste transliterări, traducătorii pot introduce un caracter roff de lățime zero (de exemplu, folosind „\&” sau, respectiv, „\&”).

note: type: =head2
en: Putting 'E<lt>' and 'E<gt>' in translations
ro: Introducerea „E<lt>” și „E<gt>” în traduceri

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).
ro: Deoarece aceste caractere sunt utilizate pentru a delimita părțile în care se modifică fontul, nu le puteți utiliza textual. Utilizați în schimb EE<lt>ltE<gt> și EE<lt>gtE<gt> (ca în POD, încă o dată).

note: type: textblock
en: Activate debugging for some internal mechanisms of this module.  Use the source to see which parts can be debugged.
ro: Activează depanarea pentru unele mecanisme interne ale acestui modul. Utilizați sursa pentru a vedea care părți pot fi depanate.

note: type: textblock
en: Increase verbosity.
ro: Mărește nivelul de detaliere al ieșirii.

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:
ro: Această opțiune controlează comportamentul modulului atunci când întâlnește o secțiune .de, .ie sau .if. Aceasta poate lua următoarele valori:

note: type: textblock
en: This is the default value.  The module will fail when a .de, .ie or .if section is encountered.
ro: Aceasta este valoarea implicită. Modulul va eșua atunci când este întâlnită o secțiune .de, .ie sau .if.

note: type: textblock
en: Indicates that the .de, .ie or .if sections must be copied as is from the original to the translated document.
ro: Indică faptul că secțiunile .de, .ie sau .if trebuie copiate ca atare din original în documentul tradus.

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.
ro: Indică faptul că secțiunile .de, .ie sau .if vor fi propuse pentru traducere. Ar trebui să utilizați această opțiune numai dacă un șir traductibil este conținut în una dintre aceste secțiuni. În caz contrar, ar trebui preferată opțiunea I<verbatim>.

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.
ro: Această opțiune specifică faptul că fișierul a fost generat și că po4a nu trebuie să încerce să detecteze dacă paginile de manual au fost generate din alt format. Această opțiune este obligatorie pentru a utiliza po4a pe paginile de manual generate. Rețineți că traducerea paginilor generate în locul celor sursă este adesea mai fragilă și, prin urmare, o idee proastă.

note: type: textblock
en: This option is only useful for mdoc pages.
ro: Această opțiune este utilă numai pentru paginile mdoc.

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.
ro: Aceasta selectează un suport mai strict al formatului mdoc, spunându-i lui po4a să nu traducă secțiunea „NAME”. Paginile mdoc a căror secțiune „NAME” este tradusă nu vor genera niciun antet sau notă de subsol.

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
ro: Conform paginii groff_mdoc, secțiunile NAME, SYNOPSIS și DESCRIPTION
    sunt obligatorii.
    Nu există probleme cunoscute cu secțiunile SYNOPSIS sau DESCRIPTION traduse,
    dar puteți specifica aceste secțiuni și în acest mod:
     -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"
ro: Această problemă mdoc poate fi rezolvată și cu un addendum ca acesta:
     PO4A-HEADER:mode=before;position=^.Dd
     .TH DOCUMENT_TITLE 1 „Luna ziua, anul” OS „Numele secțiunii”

note: type: textblock
en: The following options specify the behavior of a user-defined macro (with a .de request), or of a classical macro that is not supported by po4a.  They take as argument a comma-separated list of macros.  For example:
ro: Următoarele opțiuni specifică comportamentul unei macrodefiniții definite de utilizator (cu o cerere .de) sau al unei macrodefiniții clasice care nu este acceptată de po4a. Acestea iau ca argument o listă de nume de macrodefiniții separate prin virgulă. De exemplu:

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.
ro: Notă: dacă o macrodefiniție nu este acceptată de po4a și dacă considerați că este o macrodefiniție roff standard, trebuie să o trimiteți echipei de dezvoltare po4a.

note: type: textblock
en: B<untranslated> indicates that this macro (at its arguments) don't have to be translated.
ro: B<untranslated> indică faptul că această macrodefiniție (sau argumentele sale) nu trebuie să fie tradusă.

note: type: textblock
en: B<noarg> is like B<untranslated>, except that po4a will verify that no argument is added to this macro.
ro: B<noarg> este ca B<untranslated>, cu excepția faptului că po4a va verifica dacă nu este adăugat niciun argument la această macrodefiniție.

note: type: textblock
en: B<translate_joined> indicates that po4a must propose to translate the arguments of the macro.
ro: B<translate_joined> indică faptul că po4a trebuie să propună traducerea argumentelor macrodefiniției.

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.
ro: Cu B<translate_each>, argumentele vor fi, de asemenea, propuse pentru traducere, doar că fiecare va fi tradus separat.

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.
ro: Această opțiune primește ca argument o listă de cupluri separate prin virgulă I<begin>:I<end>, unde I<begin> și I<end> sunt comenzi care delimitează începutul și sfârșitul unei secțiuni care nu ar trebui să fie reîncadrată.

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.
ro: Notă: nu se efectuează niciun test pentru a se asigura că o comandă I<end> corespunde comenzii sale I<begin>; orice comandă de sfârșit oprește modul no_wrap. Dacă aveți o macrocomandă I<begin> (respectiv I<end>) care nu are I<end> (respectiv I<begin>), puteți specifica o macrocomandă I<end> ( precum fi) sau I<begin> (precum nf) existentă ca o contrapartidă  Aceste macrocomenzi (și argumentele lor) nu vor fi traduse.

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.
ro: Această opțiune specifică o listă de macro-uri separate prin virgulă care nu trebuie să despartă paragraful curent. Șirul de caractere de tradus va conține atunci I<foo E<lt>.bar baz quxE<gt> quux>, unde I<bar> este comanda care trebuie introdusă, iar I<baz qux> argumentele sale.

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).
ro: Această opțiune indică modul în care po4a ar trebui să se comporte atunci când este găsită o macrocomandă necunoscută. În mod implicit, po4a eșuează cu un avertisment. Aceasta poate lua următoarele valori: B<failed> (valoarea implicită), B<untranslated>, B<noarg>, B<translate_joined> sau B<translate_each> ( a se vedea mai sus pentru o explicație a acestor valori).

note: type: =head1
en: AUTHORING MAN PAGES COMPLIANT WITH PO4A::MAN
ro: CREAREA DE PAGINI DE MANUAL CONFORME CU PO4A::MAN

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.
ro: Acest modul este încă foarte limitat, și va fi întotdeauna, deoarece nu este un interpret nroff real. Ar fi posibil să realizăm un interpret nroff real, pentru a permite autorilor să utilizeze toate macrocomenzile existente sau chiar să definească altele noi în paginile lor, dar nu am dorit acest lucru. Ar fi prea dificil și am considerat că nu este necesar. Ne gândim că, dacă autorii paginilor de manual doresc ca produsele lor să fie traduse, ar trebui să se adapteze pentru a ușura munca traducătorilor.

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.
ro: Așadar, analizatorul man implementat în po4a are unele limitări cunoscute pe care nu prea suntem înclinați să le corectăm și care vor constitui unele capcane pe care va trebui să le evitați dacă doriți ca traducătorii să aibă grijă de documentația dumneavoastră.

note: type: =head2
en: Don't program in nroff
ro: Nu programați în 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).
ro: nroff este un limbaj de programare complet, cu definiție macro, condiționale și așa mai departe. Deoarece acest analizator nu este un interpret nroff complet, el va eșua pe paginile care utilizează aceste facilități (există aproximativ 200 de astfel de pagini pe calculatorul meu).

note: type: =head2
en: Use the plain macro set
ro: Utilizați un set de macrocomenzi simplu

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.
ro: Există încă unele macrocomenzi care nu sunt acceptate de po4a::man. Acest lucru se datorează doar faptului că nu am reușit să găsesc nicio documentație despre acestea. Iată lista macrocomenzilor neacceptate utilizate pe calculatorul meu. Rețineți că această listă nu este exhaustivă, deoarece programul eșuează la prima macrocomandă neacceptată întâlnită. Dacă aveți informații despre unele dintre aceste macrocomenzi, voi adăuga cu plăcere suport pentru acestea. Din cauza acestor macrocomenzi, aproximativ 250 de pagini din calculatorul meu sunt inaccesibile pentru po4a::man.

note: type: =head2
en: Hiding text from po4a
ro: Ascunderea textului de po4a

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.
ro: Uneori, autorul știe că unele părți nu sunt traductibile și nu ar trebui extrase de po4a. De exemplu, o opțiune poate accepta un argument I<other>, iar I<other> poate apărea și ca ultimul element al unei liste. În primul caz, I<other> nu ar trebui să poată fi tradus. Iar în al doilea caz, I<other> ar trebui să fie tradus.

note: type: textblock
en: In such case, the author can avoid po4a to extract some strings, using some special groff constructs:
ro: În acest caz, autorul poate evita po4a pentru a extrage unele șiruri de caractere, folosind unele construcții groff speciale:

note: type: textblock
en: (this will require the B<-o groff_code=verbatim> option)
ro: (aceasta va necesita opțiunea B<-o groff_code=verbatim>)

note: type: verbatim
en: A new macro can also be defined to automate this:
     .de IR_untranslated
     .    IR \\$@
     ..
ro: De asemenea, poate fi definit o nouă macrocomandă pentru a automatiza acest lucru:
     .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)
ro: (aceasta va necesita opțiunile B<-o groff_code=verbatim> și B<-o untranslated=IR_untranslated>; cu această construcție, condiționalul B<.if !'po4a'hide'> nu este strict necesar deoarece po4a nu va analiza interiorul definiției macro)

note: type: verbatim
en: or using an alias:
     .als IR_untranslated IR
ro: sau folosind un alias:
     .als IR_untranslated IR

note: type: textblock
en: This will require the B<-o untranslated=als,IR_untranslated> option.
ro: Acesta va necesita opțiunea B<-o untranslated=als,IR_untranslated>.

note: type: =head2
en: Conclusion
ro: Concluzie

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.
ro: Pentru a rezuma această secțiune, păstrați simplitatea și nu încercați să fiți inteligenți atunci când vă scrieți paginile de manual. O mulțime de lucruri sunt posibile în nroff și nu sunt acceptate de acest analizator. De exemplu, nu încercați să vă jucați cu \c pentru a întrerupe procesarea textului (așa cum fac 40 de pagini de pe calculatorul meu). Sau, asigurați-vă că puneți argumentele macro pe aceeași linie cu macroul în sine. Știu că este valabil în nroff, dar ar complica prea mult analizatorul pentru a fi gestionat.

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.
ro: Desigur, o altă posibilitate este de a utiliza un alt format, mai ușor de tradus (cum ar fi POD folosind po4a::pod, sau unul din familia XML cum ar fi SGML), dar datorită po4a::man nu mai este necesar. Acestea fiind spuse, dacă formatul sursă al documentației dvs. este POD sau XML, poate fi inteligent să traduceți formatul sursă și nu acest format generat. În majoritatea cazurilor, po4a::man va detecta paginile generate și va emite un avertisment. Acesta va refuza chiar să proceseze paginile generate de POD, deoarece aceste pagini sunt gestionate perfect de po4a::pod și deoarece omologul lor nroff definește o mulțime de macrocomenzi noi pentru care nu am vrut să scriu suport. Pe calculatorul meu, 1432 din cele 4323 de pagini sunt generate de POD și vor fi ignorate de po4a::man.

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…
ro: În majoritatea cazurilor, po4a::man va detecta problema și va refuza să proceseze pagina, emițând un mesaj adaptat. În unele cazuri rare, programul se va finaliza fără avertisment, dar rezultatul va fi greșit. Astfel de cazuri sunt numite „erori” ;) Dacă întâlniți un astfel de caz, asigurați-vă că raportați acest lucru, împreună cu o remediere atunci când este posibil…

note: type: textblock
en: This module can be used for most of the existing man pages.
ro: Acest modul poate fi utilizat pentru majoritatea paginilor de manual existente.

note: type: textblock
en: Some tests are regularly run on Linux boxes:
ro: Unele teste sunt efectuate în mod regulat pe cutii Linux:

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).
ro: o treime din pagini sunt refuzate deoarece au fost generate dintr-un alt format acceptat de po4a (de exemplu, POD sau SGML).

note: type: textblock
en: 10% of the remaining pages are rejected with an error (e.g. a groff macro is not supported).
ro: 10% din paginile rămase sunt respinse cu o eroare (de exemplu, macrocomanda groff nu este acceptată).

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)
ro: Apoi, mai puțin de 1% din pagini sunt acceptate silențios de po4a, dar cu probleme semnificative (de exemplu, cuvinte lipsă sau cuvinte noi introduse)

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).
ro: Celelalte pagini sunt, de obicei, tratate fără diferențe mai importante decât diferențele de spațiere sau de linie (probleme de font în mai puțin de 10% din paginile procesate).

note: type: textblock
en: Copyright © 2002-2008 SPI, Inc.
ro: Drepturi de autor © 2002-2008 SPI, Inc.

note: type: textblock
en: Locale::Po4a::Po - PO file manipulation module
ro: Locale::Po4a::Po - modul de manipulare a fișierelor PO

note: type: verbatim
en:     # Read PO file
        $pofile->read('file.po');
ro:     # Citește fișierul PO
        $pofile->read('fișier.po');

note: type: verbatim
en:     # Add an entry
        $pofile->push('msgid' => 'Hello', 'msgstr' => 'bonjour',
                      'flags' => "wrap", 'reference'=>'file.c:46');
ro:     # Adaugă o intrare
        $pofile->push('msgid' => 'Hello', 'msgstr' => 'bună ziua',
                      'flags' => "wrap", 'reference'=>'file.c:46');

note: type: verbatim
en:     # Extract a translation
        $pofile->gettext("Hello"); # returns 'bonjour'
ro:     # Extrage o traducere
        $pofile->gettext("Hello"); # returns 'bună ziuar'

note: type: verbatim
en:     # Write back to a file
        $pofile->write('otherfile.po');
ro:     # Scrie înapoi într-un fișier
        $pofile->write('alt-fișier.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.
ro: Locale::Po4a::Po este un modul care vă permite să manipulați cataloagele de mesaje. Puteți încărca și scrie din/într-un fișier (a cărui extensie este adesea I<po>), puteți construi noi intrări din mers sau solicita traducerea unui șir de caractere.

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"').
ro: Pentru o descriere mai completă a cataloagelor de mesaje în format PO și a utilizării acestora, consultați documentația info a programului gettext (nodul „`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.
ro: Acest modul face parte din proiectul po4a, al cărui obiectiv este de a utiliza fișierele PO (concepute la origine pentru a facilita traducerea mesajelor de program) pentru a traduce totul, inclusiv documentația (pagina man, manualul info), descrierea pachetului, șabloanele debconf și tot ceea ce se poate beneficia de acest lucru.

note: type: =head1
en: Functions concerning entire message catalogs
ro: Funcții privind cataloage întregi de mesaje

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.
ro: Creează un nou catalog de mesaje. Dacă este furnizat un argument, acesta este numele unui fișier PO pe care ar trebui să îl încărcăm.

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.
ro: Citește un fișier PO (al cărui nume este dat ca argument).  Intrările existente anterior în acesta nu sunt eliminate, cele noi sunt adăugate la sfârșitul catalogului.

note: type: textblock
en: Writes the current catalog to the given file.
ro: Scrie catalogul curent în fișierul dat.

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).
ro: Precum „write($)”, dar dacă fișierul PO sau POT există deja, obiectul va fi scris într-un fișier temporar care va fi comparat cu fișierul existent pentru a verifica dacă actualizarea este necesară (astfel se evită modificarea unui POT doar pentru a actualiza o referință de linie sau câmpul POT-Creation-Date).

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.
ro: Această funcție extrage un catalog dintr-unul existent. Doar intrările care au o referință în fișierul dat vor fi plasate în catalogul rezultat.

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.
ro: Această funcție analizează argumentul său, îl convertește într-o definiție de funcție Perl, verifică această definiție și filtrează câmpurile pentru care această funcție returnează „true”.

note: type: textblock
en: I love Perl sometimes ;)
ro: Iubesc Perl uneori ;)

note: type: =head1
en: Functions to use a message catalog for translations
ro: Funcții pentru utilizarea unui catalog de mesaje pentru traduceri

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.
ro: Solicită traducerea șirului de caractere dat ca argument în catalogul curent. Funcția returnează șirul original (netradus) dacă șirul nu a fost găsit.

note: type: textblock
en: After the string to translate, you can pass a hash of extra arguments. Here are the valid entries:
ro: După șirul de caractere de tradus, puteți trece o serie de argumente suplimentare. Iată intrările valide:

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.
ro: argument boolean care indică dacă putem considera că spațiile albe din șir nu sunt importante. Dacă da, funcția canonizează șirul înainte de a căuta o traducere și încadrează rezultatul.

note: type: textblock
en: the column at which we should wrap (default: 76).
ro: coloana la care ar trebui să se facă încadrarea (implicit: 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:
ro: Returnează statistici despre rata de succes a gettext de la ultima dată când a fost apelat stats_clear(). Vă rugăm să rețineți că nu este vorba de aceleași statistici ca cele afișate de msgfmt --statistic. Aici, este vorba de statistici despre utilizarea recentă a fișierului PO, în timp ce msgfmt raportează starea fișierului.  Exemplu de utilizare:

note: type: verbatim
en:     [some use of the PO file to translate stuff]
ro:     [unele utilizări ale fișierului PO pentru a traduce lucruri]

note: type: verbatim
en:     ($percent,$hit,$queries) = $pofile->stats_get();
        print "So far, we found translations for $percent\%  ($hit of $queries) of strings.\n";
ro:     ($percent,$hit,$queries) = $pofile->stats_get();
        print "Până acum, am găsit traduceri pentru $percent\% ($hit din $queries) de șiruri.\n";

note: type: textblock
en: Clears the statistics about gettext hits.
ro: Șterge statisticile privind rezultatele (găsirile de șiruri) gettext.

note: type: =head1
en: Functions to build a message catalog
ro: Funcții pentru a construi un catalog de mesaje

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:
ro: Introduce o nouă intrare la sfârșitul catalogului curent. Argumentele trebuie să formeze un tabel de elemente asociative. Cheile valide sunt:

note: type: textblock
en: the string in original language.
ro: șirul de caractere în limba originală.

note: type: textblock
en: the translation.
ro: traducerea.

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.
ro: o indicație a locului în care a fost găsit acest șir de caractere. Exemplu: file.c:46 (adică în „file.c” la linia 46). Poate fi o listă separată prin spații în cazul ocurențelor multiple.

note: type: textblock
en: a comment added here manually (by the translators). The format here is free.
ro: un comentariu adăugat aici manual (de către traducători). Formatul acestuia este liber.

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.
ro: un comentariu care a fost adăugat automat de programul de extragere a șirurilor de caractere. Consultați opțiunea B<--add-comments> a programului B<xgettext> pentru mai multe informații.

note: type: textblock
en: space-separated list of all defined flags for this entry.
ro: listă separată prin spații a tuturor fanioanelor definite pentru această intrare.

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>.
ro: Fanioanele valide sunt: 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> și B<fuzzy>.

note: type: textblock
en: See the gettext documentation for their meaning.
ro: Consultați documentația gettext pentru semnificația acestora.

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.
ro: acesta este în principal un argument intern: este utilizat în timpul gettextizării documentelor. Ideea aici este de a analiza atât originalul, cât și traducerea într-un obiect PO și de a le uni, folosind msgid-ul unuia ca msgid și msgid-ul celuilalt ca msgstr. Pentru a ne asigura că lucrurile merg bine, fiecărui msgid din obiectele PO i se atribuie un tip, bazat pe structura lor (precum „chapt”, „sect1”, „p” și așa mai departe în DocBook). Dacă tipurile de șiruri de caractere nu sunt identice, înseamnă că ambele fișiere nu au aceeași structură, iar procesul raportează o eroare.

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.
ro: Aceste informații sunt scrise ca un comentariu automat în fișierul PO, deoarece oferă traducătorilor un anumit context cu privire la șirurile de caractere de tradus.

note: type: textblock
en: boolean indicating whether whitespaces can be mangled in cosmetic reformattings. If true, the string is canonized before use.
ro: boolean care indică dacă spațiile albe pot fi manipulate în reformatările cosmetice. Dacă este adevărat, șirul este canonizat înainte de utilizare.

note: type: textblock
en: This information is written to the PO file using the B<wrap> or B<no-wrap> flag.
ro: Aceste informații sunt scrise în fișierul PO cu ajutorul fanionului B<wrap> sau B<no-wrap>.

note: type: textblock
en: ignored; the key is kept for backward computability.
ro: ignorat; cheia este păstrată pentru compatibilitatea cu versiunile anterioare.

note: type: =head1
en: Miscellaneous functions
ro: Funcții diverse

note: type: textblock
en: Returns the number of entries in the catalog (without the header).
ro: Returnează numărul de intrări din catalog (fără antet).

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.
ro: Returnează numărul de intrări din document. Dacă un șir de caractere apare de mai multe ori în document, acesta va fi numărat de mai multe ori.

note: type: textblock
en: Returns the msgid of the given number.
ro: Returnează msgid-ul numărului dat.

note: type: textblock
en: Returns the msgid with the given position in the document.
ro: Returnează msgid-ul cu poziția dată în document.

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.
ro: Returnează tipul msgidului cu poziția dată în document. Acest lucru este probabil util doar pentru gettextizare și este stocat separat de {$msgid}{'type'} deoarece locația ulterioară poate fi suprascrisă de un alt tip atunci când $msgid este duplicat în documentul principal.

note: type: textblock
en: Returns the character set specified in the PO header. If it hasn't been set, it will return "UTF-8".
ro: Returnează setul de caractere specificat în antetul PO. Dacă nu a fost definit, se va returna „UTF-8”.

note: type: textblock
en: Locale::Po4a::Pod - convert POD data from/to PO files
ro: Locale::Po4a::Pod - convertește datele POD din/în fișiere PO

note: type: verbatim
en:     # Read POD from STDIN and write to STDOUT.
        $parser->parse_from_filehandle;
ro:     # Citește POD de la intrarea standard și scrie la ieșirea standard.
        $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');
ro:     # Citește POD din fișier.pod și scrie în fișier.txt.
        $parser->parse_from_file ('fișier.pod', 'fișier.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.
ro: Locale::Po4a::Pod este un modul care ajută la traducerea documentației în format POD (limbajul preferat pentru documentarea Perl) în alte limbi [umane].

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:
ro: Cred că acest modul este foarte stabil și există o singură eroare cunoscută cu F</usr/lib/perl5/Tk/MainWindow.pod> (și alte câteva pagini, a se vedea mai jos) care conține:

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:
ro: Lipsă de noroc, în versiunea po4a, acest lucru a fost împărțit pe spațiu de încadrare. Ca rezultat, în versiunea originală, pagina de manual conține:

note: type: textblock
en: and mine contains:
ro: iar al meu conține:

note: type: textblock
en: which is logic since CE<lt>foobarE<gt> is rewritten "foobar".
ro: ceea ce este logic, deoarece CE<lt>foobarE<gt> este rescris "foobar".

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):
ro: Lista completă a paginilor care au această problemă pe calculatorul meu (din 564 de pagini; rețineți că depinde de coloana de încadrare aleasă):

note: type: =head1
en: INTERNALS
ro: FUNCȚIONARE INTERNĂ

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().
ro: Fiind o clasă derivată din Pod::Parser, Locale::Po4a::Pod utilizează aceleași metode și interfețe. Consultați L<Pod::Parser> pentru toate detaliile; pe scurt, se creează un nou analizator cu C<< Locale::Po4a::Pod->new() >> și apoi se apelează fie parse_from_filehandle() sau parse_from_file().

note: type: textblock
en: Locale::Po4a::RubyDoc -- Convert Ruby Document data from/to PO files
ro: Locale::Po4a::RubyDoc -- Convertește datele documentelor Ruby din/în fișiere PO

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.
ro: Locale::Po4a::RubyDoc este un modul care ajută la traducerea documentației în formatul Ruby Document (RD) (un limbaj utilizat pentru a documenta Ruby) în alte limbi [umane].

note: type: textblock
en: This module has been successfully tested on simple Ruby Document files covering a good part of the format syntax.
ro: Acest modul a fost testat cu succes pe fișiere simple Ruby Document, acoperind o bună parte din sintaxa formatului.

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...
ro: O limitare cunoscută este că nu reușește să recunoască în mod corespunzător structura stivuită a documentului Ruby de intrare: acest lucru implică faptul că atunci când, de exemplu, un EnumListItem este format din mai multe blocuri, numai primul bloc este de fapt recunoscut ca EnumListItem, în timp ce cele ulterioare sunt considerate doar ca TextBlocks...

note: type: textblock
en: This module supports the following option:
ro: Acest modul acceptă următoarea opțiune:

note: type: textblock
en: Handle files entirely made of Ruby Document formatted text (without any "=begin" line).
ro: Gestionează fișiere alcătuite în întregime din text formatat Ruby Document (fără nicio linie „=begin”).

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).
ro: În mod implicit, acest modul gestionează doar textul formatat Ruby Document între liniile „=begin” și „=end” (ignorând astfel, printre altele, tot ceea ce precede prima linie „=begin”).

note: type: verbatim
en:  Copyright © 2016-2017 Francesco Poli <invernomuto@paranoici.org>
ro:  Drepturi de autor © 2016-2017 Francesco Poli <invernomuto@paranoici.org>

note: type: textblock
en: This work is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
ro: Această lucrare este software liber; o puteți redistribui și/sau modifica în conformitate cu termenii Licenței Publice Generale GNU publicată de Free Software Foundation; fie versiunea 2 a Licenței, fie (la alegerea dumneavoastră) orice versiune ulterioară.

note: type: textblock
en: This work is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
ro: Această lucrare este distribuită în speranța că va fi utilă, dar FĂRĂ NICI O GARANȚIE; fără nici măcar garanția implicită de COMERCIALIZARE sau ADECVARE PENTRU UN ANUMIT SCOP. Consultați Licența publică generală GNU pentru mai multe detalii.

note: type: textblock
en: You should have received a copy of the GNU General Public License along with this work; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
ro: Ar trebui să fi primit o copie a Licenței Publice Generale GNU împreună cu această lucrare; dacă nu, scrieți la Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 SUA.

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:
ro: Părți din cod (cum ar fi multe expresii regulate) au fost adaptate din sursa rdtool, în conformitate cu termenii Licenței Publice Generale GNU, versiunea 2 sau ulterioară. Aceste părți sunt originale:

note: type: verbatim
en:  Copyright © 2004      MoonWolf <moonwolf@moonwolf.com>
     Copyright © 2011-2012 Youhei SASAKI <uwabami@gfd-dennou.org>
ro:  Drepturi de autor © 2004 MoonWolf <moonwolf@moonwolf.com>
     Drepturi de autor © 2011-2012 Youhei SASAKI <uwabami@gfd-dennou.org>

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:
ro: Codul de inițializare a fost adaptat din sursa Locale::Po4a::Text, sub termenii Licenței Publice Generale GNU, versiunea 2 sau ulterioară. Acest cod era inițial:

note: type: verbatim
en:  Copyright © 2005-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>
ro:  Drepturi de autor © 2005-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>

note: type: textblock
en: Locale::Po4a::Sgml - convert SGML documents from/to PO files
ro: Locale::Po4a::Sgml - convertește documente SGML din/în fișiere PO

note: type: textblock
en: Locale::Po4a::Sgml is a module to help the translation of documentation in the SGML format into other [human] languages.
ro: Locale::Po4a::Sgml este un modul care ajută la traducerea documentației în format SGML în alte limbi [umane].

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.
ro: Acest modul utilizează B<onsgmls>(1) pentru a analiza fișierele SGML. Asigurați-vă că acesta este instalat. De asemenea, asigurați-vă că DTD-ul fișierelor SGML este instalat în sistem.

note: type: textblock
en: Space-separated list of keywords indicating which category of extra debug messages should be shown. Possible values are: C<entities>, C<generic>, C<onsgml>, C<refs> and C<tag>.
ro: Listă de cuvinte cheie separate prin spații care indică categoria de mesaje suplimentare de depanare care ar trebui afișate. Valorile posibile sunt: C<entities>, C<generic>, C<onsgml>, C<refs> și C<tag>.

note: type: textblock
en: Give more information about what's going on.
ro: Oferă mai multe informații despre ceea ce se întâmplă.

note: type: textblock
en: Space-separated list of extra tags (beside the DTD provided ones) whose content should form an extra msgid, i.e that should be translated.
ro: Listă separată prin spații de etichete suplimentare (pe lângă cele furnizate de DTD) al căror conținut ar trebui să formeze un msgid suplimentar, adică care ar trebui tradus.

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>.
ro: Listă separată prin spații de etichete suplimentare (pe lângă cele furnizate de DTD) care conțin alte etichete, unele dintre ele fiind din categoria B<translate>.

note: type: textblock
en: Space-separated list of tags which increase the indentation level. This will affect the identation in the resulting document.
ro: Listă de etichete separate prin spații care măresc nivelul de indentare. Acest lucru va afecta identarea în documentul rezultat.

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.
ro: Aspectul din cadrul acestor etichete nu trebuie modificat. Paragraful nu va fi încadrat și nu vor fi adăugate spații suplimentare de indentare sau linii noi în scop cosmetic.

note: type: textblock
en: Tags not needing to be closed.
ro: Etichetele nu trebuie să fie închise.

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 B<translate> section would create a msgids with only its content, (and it's ususally not a whole sentence), which is bad.
ro: Etichete ignorate și considerate de po4a ca date simple de tip caracter. Aceasta înseamnă că ele pot face parte dintr-un msgid. De exemplu, E<lt>bE<gt> este un bun candidat pentru această categorie, deoarece plasarea sa în secțiunea B<translate> ar crea un msgids numai cu conținutul său, (și de obicei nu este o propoziție întreagă), ceea ce este greșit.

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, C<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: C<< <bbb><aaa>lang >> specifies that the lang attribute will only be translated if it is in an C<< <aaa> >> tag, which is in a C<< <bbb> >> tag.  The tag names are actually regular expressions so you can also write things like C<< <aaa|bbb>lang >> to only translate C<lang> attributes that are in an C<< <aaa> >> or a C<< <bbb> >> tag.
ro: O listă de atribute separate prin spații care trebuie să fie traduse. Puteți specifica atributele după numele lor (de exemplu, C<lang>), dar puteți, de asemenea, să le prefixați cu o ierarhie de etichete, pentru a specifica faptul că acest atribut va fi tradus numai atunci când se află în eticheta specificată. De exemplu: C<< <bbb><aaa>lang >> specifică faptul că atributul lang va fi tradus numai dacă se află într-un tag C<< <aaa> >>, care se află într-un tag C<< <bbb> >>.  Numele etichetelor sunt de fapt expresii regulate, astfel încât puteți scrie și lucruri precum C<< <aaa|bbb>lang >> pentru a traduce numai atributele C<lang> care sunt într-o etichetă C<< <aaa> >> sau C<< <bbb> >>.

note: type: textblock
en: A space-separated list of attributes for which the translation must be qualified by the attribute name, i.e. the text extracted for the transalation will include both the attributes name and it's value. e.g. for a tag like C<< <aaa lang_en="foo"> >> translators will be presented with the string C<lang_en="foo">. Note that this also automatically adds the given attribute into the B<attributes> list too.
ro: O listă de atribute separate prin spații pentru care traducerea trebuie calificată prin numele atributului, adică textul extras pentru traducere va include atât numele atributului, cât și valoarea acestuia. de exemplu, pentru o etichetă precum C<< <aaa lang_en=„foo”> >> traducătorilor li se va prezenta șirul C<lang_en=„foo”>. Rețineți că acest lucru adaugă automat atributul dat și în lista B<attributes>.

note: type: textblock
en: Proceed even if the DTD is unknown or if B<onsgmls> finds errors in the input file.
ro: Continuă chiar dacă DTD-ul este necunoscut sau dacă B<onsgmls> găsește erori în fișierul de intrare.

note: type: textblock
en: By default, msgids containing only one entity (like C<&version;>) are skipped for the translators' comfort. Activating this option prevents this optimisation. It can be useful if the document contains a construction like C<< <title>&Aacute;</title> >>, even if I doubt such things to ever happen...
ro: În mod implicit, msgid-urile care conțin o singură entitate (precum C<&version;>) sunt ignorate pentru confortul traducătorilor. Activarea acestei opțiuni împiedică această optimizare. Poate fi utilă dacă documentul conține o construcție precum C<< <title>&Aacute;</title> >>, chiar dacă mă îndoiesc că astfel de lucruri se vor întâmpla vreodată...

note: type: textblock
en: Space-separated list of entities that won't be inlined.  Use this option with caution: it may cause B<onsgmls> (used internally) to add tags and render the output document invalid.
ro: Listă de entități separate prin spații care nu vor fi inserate.  Utilizați această opțiune cu precauție: poate determina B<onsgmls> (utilizat intern) să adauge etichete și să facă documentul de ieșire nevalid.

note: type: textblock
en: The result is perfect. I.e., the generated documents are exactly the same as the originals. But there are still some problems:
ro: Rezultatul este perfect. Adică, documentele generate sunt exact la fel ca originalele. Dar există încă unele probleme:

note: type: textblock
en: The error output of B<onsgmls> is redirected to /dev/null by default, which is clearly bad. I don't know how to avoid that.
ro: Ieșirea de eroare a B<onsgmls> este redirecționată implicit către „/dev/null”, ceea ce este clar rău. Nu știu cum să evit asta.

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 B<onsgmls>. Otherwise B<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}>.
ro: Problema este că trebuie să „protejez” incluziunile condiționate (adică chestiile C<E<lt>! [ %foo [> și C<]]E<gt>>) de B<onsgmls>. În caz contrar, B<onsgmls> le mănâncă, iar eu nu știu cum să le restaurez în documentul final. Pentru a preveni acest lucru, le rescriu în C<{PO4A-beg-foo}> și C<{PO4A-end}>.

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).
ro: Problema este că C<{PO4A-end}> și altele pe care le adaug nu sunt valide în document (nu într-o etichetă E<lt>pE<gt> sau așa ceva).

note: type: textblock
en: If you want to view the B<onsgmls> output, just add the following to your command line (or po4a configuration line):
ro: Dacă doriți să vizualizați rezultatul B<onsgmls>, trebuie doar să adăugați următorul text la linia de comandă (sau la linia de configurare po4a):

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.
ro: Funcționează numai cu DTD-urile DebianDoc și DocBook. Adăugarea suportului pentru un nou DTD ar trebui să fie foarte ușoară. Mecanismul este același pentru fiecare DTD, trebuie doar să furnizați o listă a etichetelor existente și unele dintre caracteristicile lor.

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.
ro: Sunt de acord, acest lucru are nevoie de mai multă documentație, dar este încă considerat beta și nu-mi place să documentez lucruri care se pot/vor schimba.

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.
ro: Atenție, suportul pentru DTD-uri este destul de experimental. Nu am citit niciun manual de referință pentru a găsi definiția fiecărei etichete. Am adăugat definiții de etichete la modul până când a funcționat pentru unele documente pe care le-am găsit în internet. Dacă documentul dvs. utilizează mai multe etichete decât al meu, nu va funcționa. Dar, așa cum am spus mai sus, remedierea acestui lucru ar trebui să fie destul de ușoară.

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.
ro: Am testat DocBook doar pe SAG („System Administrator Guide”: Ghidul administratorului de sistem), dar acest document este destul de mare și ar trebui să utilizeze majoritatea specificităților DocBook.

note: type: textblock
en: For DebianDoc, I tested some of the manuals from the DDP, but not all yet.
ro: Pentru DebianDoc, am testat unele dintre manualele din DDP, dar nu toate încă.

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.
ro: În cazul includerii unui fișier, referința de șir de caractere a mesajelor din fișierele PO (de exemplu, linii precum C<#: en/titletoc.sgml:9460>) va fi greșită.

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 C<&version;>) from B<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 B<onsgmls> for parsing.
ro: Acest lucru se datorează faptului că preprocesez fișierul pentru a proteja includerea condiționată (de exemplu, chestiunea C<E<lt>! [ %foo [> and C<]]E<gt>>) și unele entități (cum ar fi C<&version;>) de B<onsgmls>, deoarece le vreau textuale pentru documentul generat. Pentru aceasta, fac o copie temporară a fișierului de intrare și efectuez toate modificările pe care le doresc la acesta înainte de a-l transmite lui B<onsgmls> pentru analizare.

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.
ro: Pentru a funcționa, înlocuiesc entitățile care solicită includerea unui fișier cu conținutul fișierului dat (astfel încât să pot proteja și ceea ce trebuie să fie într-un subfișier). Dar nimic nu se face până acum pentru a corecta referințele (adică numele fișierului și numărul liniei) după aceea. Nu sunt sigur care este cel mai bun lucru de făcut.

note: type: textblock
en: This module is an adapted version of sgmlspl (SGML postprocessor for the ONSGMLS parser) which was:
ro: Acest modul este o versiune adaptată a sgmlspl (postprocesor SGML pentru analizatorul ONSGMLS) care a avut:

note: type: verbatim
en:  Copyright © 1995 David Megginson <dmeggins@aix1.uottawa.ca>
ro:  Drepturi de autor © 1995 David Megginson <dmeggins@aix1.uottawa.ca>.

note: type: textblock
en: The adaptation for po4a was done by:
ro: Adaptarea pentru po4a a fost făcută de:

note: type: verbatim
en:  Copyright © 1995 David Megginson <dmeggins@aix1.uottawa.ca>.
     Copyright © 2002-2005 SPI, Inc.
ro:  Drepturi de autor © 1995 David Megginson <dmeggins@aix1.uottawa.ca>.
     Drepturi de autor © 2002-2005 SPI, Inc.

note: type: textblock
en: Locale::Po4a::TeX - convert TeX documents and derivatives from/to PO files
ro: Locale::Po4a::TeX - convertește documente TeX și derivate din/în fișiere PO

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.
ro: Locale::Po4a::TeX este un modul care ajută la traducerea documentelor TeX în alte limbi [umane]. De asemenea, poate fi folosit ca bază pentru a construi module pentru documente bazate pe TeX.

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.
ro: Utilizatorii ar trebui să folosească probabil modulul LaTeX, care moștenește din modulul TeX și conține definițiile comenzilor LaTeX comune.

note: type: =head1
en: TRANSLATING WITH PO4A::TEX
ro: TRADUCEREA CU 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).
ro: Acest modul poate fi utilizat direct pentru a gestiona documente TeX generice.  Acesta va împărți documentul în blocuri mai mici (paragrafe, blocuri verbatim sau chiar mai mici, cum ar fi titluri sau indexuri).

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.
ro: Există câteva opțiuni (descrise în secțiunea următoare) care pot personaliza acest comportament. Dacă acest lucru nu se potrivește formatului dvs. de document, sunteți încurajat să scrieți propriul dvs. modul derivat din acesta, pentru a descrie detaliile formatului dvs. Pentru descrierea procesului, consultați secțiunea B<SCRIEREA MODULELOR DERIVATE> de mai jos.

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.
ro: Acest modul poate fi, de asemenea, personalizat prin linii care încep cu „% po4a:” în fișierul TeX. Acest proces este descris în secțiunea B<PERSONALIZARE INLINE>.

note: type: textblock
en: Comma-separated list of environments which should not be re-wrapped.
ro: Listă separată prin virgule de medii care nu ar trebui să fie redimensionate.

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.
ro: Rețineți că există o diferență între mediile verbatim și no_wrap. Nu există o analiză a comenzilor și comentariilor în blocurile verbatim.

note: type: textblock
en: If this environment was not already registered, po4a will consider that this environment does not take any parameters.
ro: Dacă acest mediu nu a fost deja înregistrat, po4a va considera că acest mediu nu primește niciun parametru.

note: type: textblock
en: Colon-separated list of files that should not be included by \input and \include.
ro: Lista de fișiere separate prin două puncte (:) care nu ar trebui incluse de „\input” și „\include”.

note: type: textblock
en: Comma-separated list of environments which should be taken as verbatim.
ro: Listă de medii separate prin virgule care ar trebui să fie luate ca verbatim.

note: type: textblock
en: Use these options to override the default behavior of the defined commands.
ro: Utilizați aceste opțiuni pentru a trece peste comportamentul implicit al comenzilor definite.

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:
ro: Modulul TeX poate fi personalizat cu linii care încep cu B<% po4a:>.  Aceste linii sunt interpretate ca fiind comenzi pentru analizator. Sunt recunoscute următoarele comenzi:

note: type: =item
en: B<% po4a: command> I<command1> B<alias> I<command2>
ro: B<% po4a: command> I<comanda1> B<alias> I<comanda2>

note: type: textblock
en: Indicates that the arguments of the I<command1> command should be treated as the arguments of the I<command2> command.
ro: Indică faptul că argumentele comenzii I<comanda1> trebuie să fie tratate ca argumente ale comenzii I<comanda2>.

note: type: =item
en: B<% po4a: command> I<command1> I<parameters>
ro: B<% po4a: command> I<comanda1> I<parametrii>

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.
ro: Aceasta descrie în detaliu parametrii comenzii I<comanda1>.  Aceste informații vor fi utilizate pentru a verifica numărul de argumente și tipurile acestora.

note: type: textblock
en: You can precede the I<command1> command by
ro: Puteți preceda comanda I<comanda1> cu

note: type: =item
en: an asterisk (B<*>)
ro: un asterisc (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.
ro: po4a va extrage această comandă din paragrafe (dacă este situată la începutul sau la sfârșitul unui paragraf).  Traducătorii vor trebui apoi să traducă parametrii care sunt marcați ca traductibili.

note: type: =item
en: a plus (B<+>)
ro: un 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).
ro: În ceea ce privește asteriscul, comanda va fi extrasă dacă apare la o extremitate a unui bloc, dar parametrii nu vor fi traduși separat. Traducătorul va trebui să traducă comanda concatenată cu toți parametrii săi. Acest lucru păstrează mai mult context și este util pentru comenzile cu cuvinte mici în parametri, care pot avea mai multe sensuri (și traduceri).

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.
ro: Notă: În acest caz, nu trebuie să specificați care parametri sunt traductibili, dar po4a trebuie să cunoască tipul și numărul parametrilor.

note: type: =item
en: a minus (B<->)
ro: un 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.
ro: În acest caz, comanda nu va fi extrasă din niciun bloc. Dar dacă apare singură într-un bloc, atunci numai parametrii marcați ca traductibili vor fi prezentați traducătorului.  Acest lucru este util pentru comenzile privind fonturile. În general, aceste comenzi nu ar trebui să fie separate de paragraful lor (pentru a păstra contextul), dar nu există niciun motiv pentru a enerva traducătorul cu ele dacă un întreg șir de caractere este inclus într-o astfel de comandă.

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 [_]{_}
ro: Argumentul I<parametrii> este un set de [] (pentru a indica un argument
    opțional) sau {} (pentru a indica un argument obligatoriu).
    Puteți plasa un semn de subliniere (_) între aceste paranteze pentru a
    indica faptul că parametrul trebuie să fie tradus. De exemplu:
     % 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 {}{_}
ro: Acest lucru indică faptul că comanda „chapter” are doi parametri: unul opțional
    (titlu scurt) și unul obligatoriu, care trebuie să fie traduși amândoi.
    Dacă doriți să specificați că comanda „href” are doi parametri obligatorii,
    că nu doriți să traduceți adresa URL (primul parametru) și că nu doriți
    ca această comandă să fie separată de paragraful său (care permite
    traducătorului să mute legătura în frază), puteți utiliza:
     % 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.
ro: În acest caz, informațiile care indică ce argumente trebuie traduse sunt utilizate numai dacă un paragraf este compus numai din această comandă „href”.

note: type: =item
en: B<% po4a: environment> I<env> I<parameters>
ro: B<% po4a: environment> I<mediu> I<parametrii>

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
ro: Aceasta definește parametrii acceptați de mediul I<mediu> și îi specifică
    pe cei care trebuie traduși.
    Această informație este utilizată ulterior pentru a verifica numărul de
    argumente ale comenzii „\begin”.
    Sintaxa argumentului I<parametrii> este aceeași cu cea descrisă pentru
    celelalte comenzi.
    Primul parametru al comenzii „\begin” este numele mediului.
    Acest parametru nu trebuie să fie specificat în lista de parametri. Iată
    câteva exemple:
     % 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.
ro: În ceea ce privește comenzile, I<mediu> poate fi precedat de un plus (+) pentru a indica faptul că comanda „\begin” trebuie tradusă cu toate argumentele sale.

note: type: =item
en: B<% po4a: separator> I<env> B<">I<regex>B<">
ro: B<% po4a: separator> I<mediu> B<">I<expresie-regulată>B<">

note: type: textblock
en: Indicates that an environment should be split according to the given regular expression.
ro: Indică faptul că un mediu ar trebui să fie divizat în conformitate cu expresia regulată dată.

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.
ro: Expresia regulată este delimitată prin ghilimele.  Ea nu trebuie să creeze nicio referință înapoi.  Ar trebui să utilizați (?:) dacă aveți nevoie de un grup.  De asemenea, poate avea nevoie de unele eludări.

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 '&').
ro: De exemplu, modulul LaTeX utilizează expresia regulată „(?:&|\\\\)” pentru a traduce separat fiecare celulă a unui tabel (liniile sunt separate prin „\\”, iar celulele prin „&”).

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}.
ro: Noțiunea de mediu este extinsă la tipul afișat în fișierul PO.  Aceasta poate fi utilizată pentru a diviza pe „\\\\” în primul argument obligatoriu al comenzii title.  În acest caz, mediul este title{#1}.

note: type: =item
en: B<% po4a: verbatim environment> I<env>
ro: B<% po4a: verbatim environment> I<mediu>

note: type: textblock
en: Indicate that I<env> is a verbatim environment.  Comments and commands will be ignored in this environment.
ro: Indică faptul că I<mediu> este un mediu verbatim. Comentariile și comenzile vor fi ignorate în acest mediu.

note: type: =head1
en: WRITING DERIVATE MODULES
ro: SCRIEREA MODULELOR DERIVATE

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.
ro: Adaugă un șir de caractere ca un comentariu care să fie adăugat în jurul următorului element tradus. Acest lucru este util mai ales pentru modulul texinfo, deoarece comentariile sunt gestionate automat în TeX.

note: type: textblock
en: Wrapper around Transtractor's translate, with pre- and post-processing filters.
ro: Modul de învăluire în jurul traducerii Transtractor, cu filtre de pre și post-procesare.

note: type: textblock
en: Comments of a paragraph are inserted as a PO comment for the first translated string of this paragraph.
ro: Comentariile unui paragraf sunt inserate ca un comentariu PO pentru primul șir tradus din acest paragraf.

note: type: textblock
en: This function returns:
ro: Această funcție returnează:

note: type: =item
en: A command name
ro: Un nume de comandă

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.
ro: Dacă nu se găsește nicio comandă la începutul tamponului dat, acest șir va fi gol. Sunt luate în considerare numai comenzile care pot fi separate. Seria %separated_command conține lista acestor comenzi.

note: type: =item
en: A variant
ro: O variantă

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.
ro: Aceasta indică dacă se utilizează o variantă. De exemplu, un asterisc (*) poate fi adăugat la sfârșitul secțiunilor de comandă pentru a specifica faptul că acestea nu trebuie numerotate. În acest caz, acest câmp va conține „*”. Dacă nu există nicio variantă, câmpul este un șir gol.

note: type: =item
en: An array of tuples (type of argument, argument)
ro: O matrice de cupluri (tip de argument, argument)

note: type: textblock
en: The type of argument can be either '{' (for mandatory arguments) or '[' (for optional arguments).
ro: Tipul de argument poate fi „{” (pentru argumente obligatorii) sau „[” (pentru argumente opționale).

note: type: =item
en: The remaining buffer
ro: Tamponul rămas

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.
ro: Restul tamponului după eliminarea acestei comenzi principale și a argumentelor sale. Dacă nu se găsește nicio comandă, tamponul original nu este atins și este returnat în acest câmp.

note: type: textblock
en: The same as B<get_leading_command>, but for commands at the end of a buffer.
ro: La fel ca B<get_leading_command>, dar pentru comenzi la sfârșitul unui tampon.

note: type: textblock
en: Recursively translate a buffer by separating leading and trailing commands (those which should be translated separately) from the buffer.
ro: Traduce recursiv un tampon prin separarea comenzilor anterioare și ulterioare (cele care trebuie traduse separat) din tampon.

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().
ro: Dacă o funcție este definită în %translate_buffer_env pentru mediul curent, această funcție va fi utilizată pentru a traduce tamponul în loc de translate_buffer().

note: type: textblock
en: Overloads Transtractor's read().
ro: Supraîncarcă funcția read() a Transtractor.

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.
ro: Citește recursiv un fișier, adăugând fișierele incluse care nu sunt listate în matricea @exclude_include. Fișierele incluse sunt căutate folosind comanda B<kpsewhich> din biblioteca Kpathsea.

note: type: textblock
en: Except from the file inclusion part, it is a cut and paste from Transtractor's read.
ro: Cu excepția părții de includere a fișierului, este o simplă tăiere și lipire (o copie) din citirea lui Transtractor.

note: type: textblock
en: Subroutine for parsing a file with po4a directives (definitions for new commands).
ro: Subrutină pentru analizarea unui fișier cu directive po4a (definiții pentru comenzi noi).

note: type: textblock
en: Parse a definition line of the form "% po4a: ".
ro: Analizează o linie de definiție de forma „% po4a: ”.

note: type: textblock
en: See the B<INLINE CUSTOMIZATION> section for more details.
ro: Pentru mai multe detalii, consultați secțiunea B<PERSONALIZARE INLINE>.

note: type: =head1
en: INTERNAL FUNCTIONS used to write derivative parsers
ro: FUNCȚII INTERNE utilizate pentru scrierea analizatorilor derivativi

note: type: textblock
en: Command and environment functions take the following arguments (in addition to the $self object):
ro: Funcțiile de comandă și de mediu primesc următoarele argumente (în plus față de obiectul $self):

note: type: =item
en: An array of (type, argument) tuples
ro: O matrice de cupluri (tip, argument)

note: type: =item
en: The current environment
ro: Mediul actual

note: type: textblock
en: The first 3 arguments are extracted by get_leading_command or get_trailing_command.
ro: Primele 3 argumente sunt extrase de get_leading_command sau get_trailing_command.

note: type: textblock
en: Command and environment functions return the translation of the command with its arguments and a new environment.
ro: Funcțiile de comandă și mediu returnează traducerea comenzii cu argumentele sale și un nou mediu.

note: type: textblock
en: Environment functions are called when a \begin command is found. They are called with the \begin command and its arguments.
ro: Funcțiile de mediu sunt apelate atunci când este găsită o comandă „\begin”. Acestea sunt apelate cu comanda „\begin” și argumentele sale.

note: type: textblock
en: The TeX module only proposes one command function and one environment function: generic_command and generic_environment.
ro: Modulul TeX propune doar o funcție de comandă și o funcție de mediu: generic_command și 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>
ro: generic_command utilizează informațiile specificate de către
    register_generic_command sau prin adăugarea definiției la fișierul TeX:
     % po4a: command I<comanda1> I<parametri>

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>
ro: generic_environment utilizează informațiile specificate de către
    register_generic_environment sau prin adăugarea definiției la fișierul TeX:
     % po4a: environment I<mediu> I<parametri>

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]).
ro: Ambele funcții vor traduce numai parametrii care au fost specificați ca fiind traductibili (cu un „_”). generic_environment va adăuga numele mediului la stiva de medii, iar generic_command va adăuga numele comenzii urmat de un identificator al parametrului (cum ar fi {#7} sau [#2]).

note: type: textblock
en: This module needs more tests.
ro: Acest modul necesită mai multe teste.

note: type: textblock
en: It was tested on a book and with the Python documentation.
ro: Acesta a fost testat pe o carte și cu documentația Python.

note: type: =head1
en: TODO LIST
ro: LISTA CU LUCRURI DE FĂCUT

note: type: =item
en: Automatic detection of new commands
ro: Detectarea automată a comenzilor noi

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.
ro: Modulul TeX ar putea analiza argumentele noii comenzi și ar putea încerca să ghicească numărul de argumente, tipul acestora și dacă ar trebui sau nu să fie traduse.

note: type: =item
en: Translation of the environment separator
ro: Traducerea separatorului de mediu

note: type: textblock
en: When \item is used as an environment separator, the item argument is attached to the following string.
ro: Atunci când \item este utilizat ca separator de mediu, argumentul „item” este atașat la următorul șir de caractere.

note: type: =item
en: Some commands should be added to the environment stack
ro: Unele comenzi ar trebui adăugate la stiva de mediu

note: type: textblock
en: These commands should be specified by couples.  This can be used to specify commands beginning or ending a verbatim environment.
ro: Aceste comenzi trebuie să fie specificate prin cupluri.  Aceasta poate fi utilizată pentru a specifica comenzile care încep sau încheie un mediu verbatim.

note: type: =item
en: Others
ro: Altele

note: type: textblock
en: Various other points are tagged TODO in the source.
ro: Diverse alte puncte sunt etichetate TODO în codul-sursă.

note: type: =head1
en: KNOWN BUGS
ro: ERORI CUNOSCUTE

note: type: textblock
en: Various points are tagged FIXME in the source.
ro: Diverse puncte sunt etichetate FIXME în codul-sursă.

note: type: textblock
en: Locale::Po4a::Texinfo - convert Texinfo documents and derivates from/to PO files
ro: Locale::Po4a::Texinfo - convertește documentele Texinfo și derivatele din/în fișiere PO

note: type: textblock
en: Locale::Po4a::Texinfo is a module to help the translation of Texinfo documents into other [human] languages.
ro: Locale::Po4a::Texinfo este un modul care ajută la traducerea documentelor Texinfo în alte limbi [umane].

note: type: textblock
en: This module contains the definitions of common Texinfo commands and environments.
ro: Acest modul conține definițiile comenzilor și mediilor Texinfo comune.

note: type: textblock
en: Only the comments starting with 'TRANSLATORS' are added to the PO files to guide the translators.
ro: Doar comentariile care încep cu „TRANSLATORS” sunt adăugate la fișierele PO pentru a ghida traducătorii.

note: type: textblock
en: This module is still beta and not ready for production use.  Please send patches to contribute, not bug reports as we don't know how to deal with them.
ro: Acest modul este încă beta și nu este pregătit pentru utilizarea în producție. Vă rugăm să trimiteți plasturi (corecții și/sau modificări) pentru a contribui, nu rapoarte de erori, deoarece nu știm cum să ne ocupăm de acestea.

note: type: textblock
en: Do not warn about the current state of this module.
ro: Nu avertizează cu privire la starea actuală a acestui modul.

note: type: textblock
en: Copyright © 2004-2007 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
ro: Drepturi de autor © 2004-2007 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.

note: type: textblock
en: Locale::Po4a::Text - convert text documents from/to PO files
ro: Locale::Po4a::Text - convertește documente text din/în fișiere PO

note: type: textblock
en: Locale::Po4a::Text is a module to help the translation of text documents into other [human] languages.
ro: Locale::Po4a::Text este un modul care ajută la traducerea documentelor text în alte limbi [umane].

note: type: textblock
en: Paragraphs are split on empty lines (or lines containing only spaces or tabulations).
ro: Paragrafele sunt împărțite pe linii goale (sau linii care conțin doar spații sau tabulații).

note: type: textblock
en: If a paragraph contains a line starting by a space (or tabulation), this paragraph won't be rewrapped.
ro: Dacă un paragraf conține o linie care începe cu un spațiu (sau tabulație), acest paragraf nu va fi reîncadrat.

note: type: textblock
en: Treat paragraphs that look like a colon-separated key-value pair as verbatim (with the C<no-wrap> flag in the PO file). A key-value pair string is a string like C<key: value>, 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.
ro: Tratează paragrafele care seamănă cu o pereche cheie-valoare separată prin două puncte ca verbatim (cu indicatorul C<no-wrap> în fișierul PO). Un șir de perechi cheie-valoare este un șir de tipul C<cheie: valoare>, care conține unul sau mai multe caractere fără două puncte (:) și fără spațiu, urmate de două puncte urmate de cel puțin un caracter fără spațiu înainte de sfârșitul liniei.

note: type: textblock
en: Deactivate the detection of bullets.
ro: Dezactivează detectarea bulinelor (marcajelor).

note: type: textblock
en: By default, when a bullet is detected, the bullet paragraph is not considered as a verbatim paragraph (with the C<no-wrap> flag in the PO file). Instead, the corresponding paragraph is rewrapped in the translation.
ro: În mod implicit, atunci când este detectată o bulină (marcaj), paragraful bulină (marcat) nu este considerat un paragraf verbatim (cu indicatorul C<no-wrap> în fișierul PO). În schimb, paragraful corespunzător este reîncadrat în traducere.

note: type: =item
en: B<tabs=>I<mode>
ro: B<tabs=>I<mod>

note: type: textblock
en: Specify how tabulations shall be handled. The I<mode> can be any of:
ro: Specifică modul în care vor fi tratate tabulațiile. I<mod> poate fi oricare dintre:

note: type: textblock
en: Lines with tabulations introduce breaks in the current paragraph.
ro: Liniile cu tabulații introduc întreruperi de linie în paragraful curent.

note: type: textblock
en: Paragraph containing tabulations will not be re-wrapped.
ro: Paragraful care conține tabulații nu va fi reîncadrat (redimensionat).

note: type: textblock
en: By default, tabulations are considered as spaces.
ro: În mod implicit, tabulațiile sunt considerate spații.

note: type: =item
en: B<breaks=>I<regex>
ro: B<breaks=>I<exp-reg>

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.
ro: O expresie regulată care se potrivește liniilor care introduc întreruperi de linie. Expresia regulată va fi ancorată astfel încât întreaga linie să corespundă.

note: type: textblock
en: Handle the header and footer of released versions, which only contain non translatable information.
ro: Gestionează antetul și subsolul versiunilor lansate, care conțin doar informații care nu pot fi traduse.

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.
ro: Gestionează formatul „fortunes”, care separă „fortunes” cu o linie formată din „%” sau „%%”, și utilizează „%%” ca început al unui comentariu.

note: type: textblock
en: Handle some special markup in Markdown-formatted texts.
ro: Gestionează unele marcaje speciale în textele formatate Markdown.

note: type: =item
en: B<yfm_keys> (markdown-only)
ro: B<yfm_keys> (doar-markdown)

note: type: =item
en: B<yfm_lenient> (markdown only)
ro: B<yfm_lenient> (doar-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.
ro: Permite analizatorului „YAML Front Matter” să eșueze în cazul antetelor incorecte (formatate greșit). Acest lucru este deosebit de util atunci când fișierul dvs. începe cu o riglă orizontală în loc de un „YAML Front Matter”, dar insistați să utilizați doar trei liniuțe pentru riglă.

note: type: =item
en: B<yfm_paths> (markdown only)
ro: B<yfm_paths> (doar-markdown)

note: type: =item
en: B<yfm_skip_array> (markdown-only)
ro: B<yfm_skip_array> (doar-markdown)

note: type: =item
en: B<control>[B<=>I<field_list>]
ro: B<control>[B<=>I<listă-câmpurit>]

note: type: textblock
en: Handle Debian's control files.  A comma-separated list of fields to be translated can be provided.
ro: Gestionează fișierele de control Debian. Poate fi furnizată o listă de câmpuri separate prin virgule pentru a fi traduse.

note: type: textblock
en: Prevent po4a from wrapping any lines. This means that every content is handled verbatim, even simple paragraphs.
ro: Împiedică po4a să încadreze orice linie. Acest lucru înseamnă că fiecare conținut este tratat verbatim, chiar și paragrafele simple.

note: type: textblock
en: Tested successfully on simple text files and NEWS.Debian files.
ro: Testat cu succes pe fișiere text simple și fișiere NEWS.Debian.

note: type: verbatim
en:  Copyright © 2005-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.
ro:  Drepturi de autor © 2005-2008 Nicolas FRANÇOIS <nicolas.francois@centraliens.net>.

note: type: verbatim
en:  Copyright © 2008-2009, 2018 Jonas Smedegaard <dr@jones.dk>.
     Copyright © 2020 Martin Quinson <mquinson#debian.org>.
ro:  Drepturi de autor © 2008-2009, 2018 Jonas Smedegaard <dr@jones.dk>.
     Drepturi de autor © 2020 Martin Quinson <mquinson#debian.org>.

note: type: textblock
en: Locale::Po4a::TransTractor - generic trans(lator ex)tractor.
ro: Locale::Po4a::TransTractor - trans(lator -- ex)tractor generic.

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.
ro: Această clasă este strămoșul fiecărui analizator po4a utilizat pentru a analiza un document, pentru a căuta șiruri traductibile, pentru a le extrage într-un fișier PO și pentru a le înlocui cu traducerea lor în documentul de ieșire.

note: type: textblock
en: More formally, it takes the following arguments as input:
ro: Mai formal, acesta primește următoarele argumente ca intrare:

note: type: textblock
en: a document to translate;
ro: un document de tradus;

note: type: textblock
en: a PO file containing the translations to use.
ro: un fișier PO care conține traducerile care urmează să fie utilizate.

note: type: textblock
en: As output, it produces:
ro: Ca ieșire, produce:

note: type: textblock
en: another PO file, resulting of the extraction of translatable strings from the input document;
ro: un alt fișier PO, care rezultă din extragerea șirurilor traductibile din documentul de intrare;

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.
ro: un document tradus, cu aceeași structură ca cel de la intrare, dar cu toate șirurile traductibile înlocuite cu traducerile găsite în fișierul PO furnizat la intrare.

note: type: textblock
en: Here is a graphical representation of this:
ro: Iată o reprezentare grafică a acestui lucru:

note: type: verbatim
en:    Input document --\                             /---> Output document
                         \                           /       (translated)
                          +-> parse() function -----+
                         /                           \
       Input PO --------/                             \---> Output PO
                                                             (extracted)
ro:    document intrare --\                             /---> Document ieșire
                           \                           /         (tradus)
                            +--> funcția parse() -----+
                           /                           \
       PO intrare --------/                             \---> PO ieșire
                                                              (extras)

note: type: =head1
en: FUNCTIONS YOUR PARSER SHOULD OVERRIDE
ro: FUNCȚII PE CARE ANALIZATORUL TREBUIE SĂ LE SUPRASCRIE

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.
ro: Aici are loc toată munca: analizarea documentelor de intrare, generarea rezultatelor și extragerea șirurilor traductibile. Acest lucru este destul de simplu folosind funcțiile furnizate prezentate în secțiunea B<FUNCȚII INTERNE> de mai jos. Consultați și secțiunea B<SINOPSIS>, care prezintă un exemplu.

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.
ro: Această funcție este apelată de funcția process() de mai jos, dar dacă alegeți să utilizați funcția new() și să adăugați manual conținut documentului, va trebui să apelați această funcție.

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.
ro: Această funcție returnează antetul pe care ar trebui să îl adăugăm documentului produs, citat corespunzător pentru a fi un comentariu în limba țintă. Consultați secțiunea B<Educarea dezvoltatorilor cu privire la traduceri>, din L<po4a(7)|po4a.7>, pentru a afla la ce este bună această funcție.

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.
ro: Următorul exemplu analizează o listă de paragrafe care încep cu „<p>”. De dragul simplității, presupunem că documentul este bine formatat, adică că etichetele „<p>” sunt singurele etichete prezente și că această etichetă se află chiar la începutul fiecărui paragraf.

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);
ro:    PARAGRAPH: while (1) {
           my ($paragraph,$pararef)=("","");
           my $first=1;
           my ($line,$lref)=$self->shiftline();
           while (defined($line)) {
               if ($line =~ m/<p>/ && !$first--; ) {
                   # Nu este prima dată când vedem<p>.
                   # Repune linia curentă în intrare,
                   # și pune paragraful construit la ieșire.
                   $self->unshiftline($line,$lref);

note: type: verbatim
en:                # Now that the document is formed, translate it:
                   #   - Remove the leading tag
                   $paragraph =~ s/^<p>//s;
ro:                # Acum că documentul este format, traduceți-l:
                   #   - Eliminați eticheta inițială
                   $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)
                                   );
ro:                #   - Trimiteți la ieșire eticheta inițială (netradusă) și
                   #     restul paragrafului (tradus)
                   $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));
               }
ro:                next PARAGRAPH;
               } else {
                   # Adăugați la paragraf
                   $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;
       }
     }
ro:            # Reinițializați bucla
               ($line,$lref)=$self->shiftline();
           }
           # Nu ați obținut o linie definită? Sfârșitul fișierului de intrare.
           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.
ro: Odată ce ați implementat funcția de analizare, puteți utiliza clasa dvs. de documente, folosind interfața publică prezentată în secțiunea următoare.

note: type: =head1
en: PUBLIC INTERFACE for scripts using your parser
ro: Odată ce ați implementat funcția de analizare, puteți utiliza clasa dvs. de documente, folosind interfața publică prezentată în secțiunea următoare.
    INTERFAȚA PUBLICĂ pentru scripturile care utilizează analizatorul dvs.

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:
ro: Această funcție poate face tot ce aveți nevoie să faceți cu un document po4a într-o singură invocare. Argumentele sale trebuie să fie împachetate ca o serie de elemente asociative. ACȚIUNI:

note: type: textblock
en: Reads all the PO files specified in po_in_name
ro: Citește toate fișierele PO specificate în po_in_name

note: type: textblock
en: Reads all original documents specified in file_in_name
ro: Citește toate documentele originale specificate în file_in_name

note: type: textblock
en: Parses the document
ro: Analizează documentul

note: type: textblock
en: Reads and applies all the addenda specified
ro: Citește și aplică toate actele adiționale (addendele) specificate

note: type: textblock
en: Writes the translated document to file_out_name (if given)
ro: Scrie documentul tradus la file_out_name (dacă este dat)

note: type: textblock
en: Writes the extracted PO file to po_out_name (if given)
ro: Scrie fișierul PO extras la po_out_name (dacă este dat)

note: type: textblock
en: ARGUMENTS, beside the ones accepted by new() (with expected type):
ro: ARGUMENTE, în afară de cele acceptate de new() (cu tipul așteptat):

note: type: textblock
en: List of filenames where we should read the input document.
ro: Lista de nume de fișiere din care trebuie să citim documentul de intrare.

note: type: textblock
en: Charset used in the input document (if it isn't specified, use UTF-8).
ro: Setul de caractere utilizat în documentul de intrare (dacă nu este specificat, se utilizează UTF-8).

note: type: textblock
en: Filename where we should write the output document.
ro: Numele fișierului în care trebuie să scriem documentul de ieșire.

note: type: textblock
en: Charset used in the output document (if it isn't specified, use UTF-8).
ro: Setul de caractere utilizat în documentul de ieșire (dacă nu este specificat, se utilizează UTF-8).

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.
ro: Lista de nume de fișiere din care trebuie citite fișierele PO de intrare, care conțin traducerea ce va fi utilizată pentru a traduce documentul.

note: type: textblock
en: Filename where we should write the output PO file, containing the strings extracted from the input document.
ro: Numele fișierului în care trebuie să scriem fișierul PO de ieșire, care conține șirurile extrase din documentul de intrare.

note: type: textblock
en: List of filenames where we should read the addenda from.
ro: Lista de nume de fișiere din care trebuie să citim addenda.

note: type: textblock
en: Charset for the addenda.
ro: Setul de caractere pentru addendă.

note: type: textblock
en: Create a new po4a document. Accepted options (in the hash passed as a parameter):
ro: Creează un nou document po4a. Opțiuni acceptate (în seria de elemente asociative trecută ca parametru):

note: type: textblock
en: Sets the verbosity.
ro: Stabilește nivelul de detaliere al informațiilor.

note: type: textblock
en: Sets the debugging.
ro: Definește depanarea.

note: type: textblock
en: The column at which we should wrap text in output document (default: 76).
ro: Coloana la care ar trebui să încadrăm textul în documentul de ieșire (implicit: 76).

note: type: textblock
en: The negative value means not to wrap lines at all.
ro: Valoarea negativă înseamnă să nu se încadreze liniile deloc (fără întreruperi de linie).

note: type: textblock
en: Also it accepts next options for underlying Po-files: B<porefs>, B<copyright-holder>, B<msgid-bugs-address>, B<package-name>, B<package-version>, B<wrap-po>.
ro: De asemenea, acceptă următoarele opțiuni pentru fișierele Po subiacente: B<porefs>, B<copyright-holder>, B<msgid-bugs-address>, B<package-name>, B<package-version>, B<wrap-po>.

note: type: =head2
en: Manipulating document files
ro: Manipularea fișierelor de documente

note: type: textblock
en: Add another input document data at the end of the existing array C<< @{$self->{TT}{doc_in}} >>.
ro: Adaugă un alt document de intrare de date la sfârșitul matricei existente C<< @{$self->{TT}{doc_in}} >>.

note: type: verbatim
en: This function takes two mandatory arguments and an optional one.
     * The filename to read on disk;
     * The name to use as filename when building the reference in the PO file;
     * The charset to use to read that file (UTF-8 by default)
ro: Această funcție are două argumente obligatorii și unul opțional.
     * Numele fișierului care urmează să fie citit pe disc;
     * Numele care trebuie utilizat ca nume de fișier la construirea referinței în fișierul PO;
     * Setul de caractere care trebuie utilizat pentru a citi fișierul respectiv (UTF-8 în mod implicit)

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).
ro: Această matrice C<< @{$self->{TT}{doc_in}} >> conține datele acestui document de intrare
     ca o matrice de șiruri de caractere cu semnificații alternante.
     * Șirul C<$textline >> conține fiecare linie a datelor text de intrare.
     * Șirul C<< $filename:$linenum >> conține locația acestuia și se numește
       „referință” (C<linenum> începe cu 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.
ro: Vă rugăm să rețineți că aceasta nu analizează nimic. Ar trebui să utilizați funcția parse() atunci când ați terminat cu împachetarea fișierelor de intrare în document.

note: type: textblock
en: Write the translated document to the given filename.
ro: Scrie documentul tradus în fișierul specificat.

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.
ro: Aceste date de document traduse sunt furnizate de:
     * C<< $self->docheader() >> care conține textul antetului pentru modul și
     * C<< @{$self->{TT}{doc_out}} >> care conține fiecare linie a textului principal tradus în matrice.

note: type: =head2
en: Manipulating PO files
ro: Manipularea fișierelor PO

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.
ro: Adaugă conținutul unui fișier (al cărui nume este trecut ca argument) la PO de intrare existent. Conținutul vechi nu este eliminat.

note: type: textblock
en: Write the extracted PO file to the given filename.
ro: Scrie fișierul PO extras la numele de fișier dat.

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:
ro: Returnează câteva statistici despre traducerea efectuată până în prezent. Vă rugăm să rețineți că nu sunt aceleași statistici ca cele afișate de «msgfmt --statistic». Aici, este vorba de statistici despre utilizarea recentă a fișierului PO, în timp ce «msgfmt» raportează starea fișierului. Este o funcție de învăluire pentru funcția Locale::Po4a::Po::stats_get aplicată la fișierul PO de intrare. Exemplu de utilizare:

note: type: verbatim
en:     [normal use of the po4a document...]
ro:     [utilizarea normală a documentului po4a...]

note: type: verbatim
en:     ($percent,$hit,$queries) = $document->stats();
        print "We found translations for $percent\%  ($hit from $queries) of strings.\n";
ro:     ($percent,$hit,$queries) = $document->stats();
        print "Am găsit traduceri pentru $percent\% ($hit din $queries) de șiruri.\n";

note: type: =head2
en: Manipulating addenda
ro: Manipularea addendelor

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 ;)
ro: Vă rugăm să consultați L<po4a(7)|po4a.7> pentru mai multe informații despre ce sunt addendele și cum ar trebui să le scrie traducătorii. Pentru a aplica un addendum documentului tradus, pur și simplu treceți numele său de fișier la această funcție și ați terminat ;)

note: type: textblock
en: This function returns a non-null integer on error.
ro: Această funcție returnează un număr întreg nenul în caz de eroare.

note: type: =head2
en: Getting input, providing output
ro: Obținerea intrărilor, furnizarea ieșirilor

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.
ro: Sunt furnizate patru funcții pentru a obține intrare și a returna ieșire. Acestea sunt foarte asemănătoare cu shift/unshift și push/pop din Perl.

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.
ro:  * Perl shift returnează primul element din matrice și îl elimină din matrice.
     * Perl unshift antepune un element în matrice ca primul element din matrice.
     * Perl pop returnează ultimul element al matricei și îl elimină din matrice.
     * Perl push adaugă un element în matrice ca ultim element al matricei.

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.
ro: Prima pereche este despre intrare, în timp ce a doua este despre ieșire. Mnemonic: la intrare, sunteți interesat de prima linie, ceea ce oferă shift(), iar la ieșire doriți să adăugați rezultatul la sfârșit, așa cum face push().

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 >>.
ro: Această funcție returnează prima linie care urmează să fie analizată și referința corespunzătoare (împachetată ca o matrice) din matricea C<< @{$self->{TT}{doc_in}} >> și elimină aceste prime două elemente ale matricei.  Aici, referința este furnizată de un șir C<< $filename:$linenum >>.

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}} >>.
ro: Deplasează ultima linie deplasată a documentului de intrare și referința corespunzătoare înapoi la începutul C<< {$self->{TT}{doc_in}} >>.

note: type: textblock
en: Push a new line to the end of C<< {$self->{TT}{doc_out}} >>.
ro: Introduce o linie nouă la sfârșitul C<< {$self->{TT}{doc_out}} >>.

note: type: textblock
en: Pop the last pushed line from the end of C<< {$self->{TT}{doc_out}} >>.
ro: Extrage ultima linie introdusă de la sfârșitul C<< {$self->{TT}{doc_out}} >>.

note: type: =head2
en: Marking strings as translatable
ro: Marcarea șirurilor de caractere ca traductibile

note: type: textblock
en: One function is provided to handle the text which should be translated.
ro: O funcție este furnizată pentru a gestiona textul care trebuie tradus.

note: type: textblock
en: Mandatory arguments:
ro: Argumente obligatorii:

note: type: textblock
en: A string to translate
ro: Un șir de caractere de tradus

note: type: textblock
en: The reference of this string (i.e. position in inputfile)
ro: Referința acestui șir de caractere (de exemplu, poziția în fișierul de intrare)

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?>)
ro: Tipul acestui șir (adică descrierea textuală a rolului său structural; utilizat în Locale::Po4a::Po::gettextization(); vezi și L<po4a(7)|po4a.7>, secțiunea B<Gettextizarea: cum funcționează?>)

note: type: textblock
en: This function can also take some extra arguments. They must be organized as a hash. For example:
ro: Această funcție poate primi și câteva argumente suplimentare. Acestea trebuie să fie organizate ca p serie de elemente asociative. De exemplu:

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.
ro: argument boolean care indică dacă putem considera că spațiile albe din șir nu sunt importante. Dacă da, funcția canonizează șirul de caractere înainte de a căuta o traducere sau de a-l extrage și include traducerea.

note: type: textblock
en: the column at which we should wrap (default: the value of B<wrapcol> specified during creation of the TransTractor or 76).
ro: coloana la care trebuie să se încadreze (implicit: valoarea lui B<wrapcol> specificată la crearea TransTractor sau 76).

note: type: textblock
en: The negative value will be substracted from the default.
ro: Valoarea negativă va fi sustrasă din valoarea implicită.

note: type: textblock
en: an extra comment to add to the entry.
ro: un comentariu suplimentar pentru a adăuga la intrare.

note: type: textblock
en: Actions:
ro: Acțiuni:

note: type: textblock
en: Pushes the string, reference and type to po_out.
ro: Trimite șirul, referința și tipul în 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.
ro: Returnează traducerea șirului de caractere (așa cum se găsește în po_in) astfel încât analizatorul să poată construi doc_out.

note: type: textblock
en: Handles the charsets to recode the strings before sending them to po_out and before returning the translations.
ro: Gestionează seturile de caractere pentru a recodifica șirurile înainte de a le trimite la po_out și înainte de a returna traducerile.

note: type: =head2
en: Misc functions
ro: Diverse funcții

note: type: textblock
en: Returns if the verbose option was passed during the creation of the TransTractor.
ro: Returnează dacă opțiunea „verbose” (de detaliere a informațiilor) a fost trecută în timpul creării TransTractor.

note: type: textblock
en: Returns if the debug option was passed during the creation of the TransTractor.
ro: Returnează dacă opțiunea „debug” (de depanare) a fost trecută în timpul creării TransTractor.

note: type: textblock
en: This function return the charset that was provided as master charset
ro: Această funcție returnează setul de caractere care a fost furnizat ca set de caractere principal

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).
ro: Această funcție va returna setul de caractere care trebuie utilizat în documentul de ieșire (de obicei util pentru a înlocui setul de caractere detectat în documentul de intrare, în cazul în care acesta a fost găsit).

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.
ro: Aceasta va utiliza setul de caractere de ieșire specificat în linia de comandă. Dacă nu a fost specificat, va utiliza setul de caractere al PO de intrare, iar dacă PO de intrare are valoarea implicită „CHARSET”, va returna setul de caractere al documentului de intrare, astfel încât să nu fie efectuată nicio codificare.

note: type: =head1
en: FUTURE DIRECTIONS
ro: PERSPECTIVE

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.
ro: Un neajuns al TransTractor-ului actual este că nu poate gestiona documente traduse care conțin toate limbile, cum ar fi șabloanele „debconf” sau fișierele „.desktop”.

note: type: textblock
en: To address this problem, the only interface changes needed are:
ro: Pentru a aborda această problemă, singurele modificări de interfață necesare sunt:

note: type: textblock
en: take a hash as po_in_name (a list per language)
ro: luarea unui tabel de elemente asociate ca po_in_name (o listă pentru fiecare limbă)

note: type: textblock
en: add an argument to translate to indicate the target language
ro: adăugarea unui argument la traducere pentru a indica limba țintă

note: type: textblock
en: make a pushline_all function, which would make pushline of its content for all languages, using a map-like syntax:
ro: crearea unei funcții pushline_all*(, care ar face „pushline” din conținutul său pentru toate limbile, folosind o sintaxă de tip hartă:

note: type: textblock
en: Will see if it's enough ;)
ro: Vom vedea dacă este suficient ;)

note: type: textblock
en: Locale::Po4a::Wml - convert WML (web markup language) documents from/to PO files
ro: Locale::Po4a::Wml - convertește documente WML (web markup language) din/în fișiere PO

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.
ro: Locale::Po4a::Wml este un modul care ajută la traducerea documentelor WML în alte limbi [umane]. Nu confundați WML-ul despre care vorbim aici (web markup language) și porcăria de WAP utilizată pe telefoanele mobile.

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.
ro: Vă rugăm să rețineți că acest modul se bazează pe modulul Locale::Po4a::Xhtml, care se bazează de asemenea pe modulul Locale::Po4a::Xml. Aceasta înseamnă că se presupune că toate etichetele pentru expresiile paginilor web sunt scrise în sintaxa XHTML.

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.
ro: Acest modul funcționează pentru unele documente simple, dar este încă tânăr. În prezent, cea mai mare problemă a modulului este probabil faptul că nu poate gestiona documente care conțin etichete inline non-XML, cum ar fi <email „foo@example.org”>, care sunt adesea definite în WML. Îmbunătățiri vor fi adăugate în versiunile viitoare.

note: type: verbatim
en:  Copyright © 2005 SPI, Inc.
ro:  Drepturi de autor © 2005 SPI, Inc.

note: type: textblock
en: Locale::Po4a::Xhtml - convert XHTML documents from/to PO files
ro: Locale::Po4a::Xhtml - convertește documente XHTML din/în fișiere PO

note: type: textblock
en: Locale::Po4a::Xhtml is a module to help the translation of XHTML documents into other [human] languages.
ro: Locale::Po4a::Xhtml este un modul care ajută la traducerea documentelor XHTML în alte limbi [umane].

note: type: =item
en: B<includessi>[B<=>I<rootpath>]
ro: B<includessi>[B<=>I<ruta-rădăcină>]

note: type: textblock
en: Include files specified by an include SSI (Server Side Includes) element (e.g. <!--#include virtual="/foo/bar.html" -->).
ro: Include fișierele specificate de un element include SSI (Server Side Includes) (de exemplu, <!--#include virtual=„/foo/bar.html” -->).

note: type: textblock
en: B<Note:> You should use it only for static files.
ro: B<Notă:> Ar trebui să-l utilizați numai pentru fișiere statice.

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.
ro: Se poate specifica un parametru suplimentar I<ruta-rădăcină>. Acesta specifică ruta rădăcină pentru a găsi fișierele incluse de un atribut B<virtual>.

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.
ro: „Funcționează pentru mine”, ceea ce înseamnă că îl folosesc cu succes pe situl meu personal.  Cu toate acestea, acest rezultat poate varia în funcție de scenariu:: vă rog să-mi spuneți dacă ceva nu funcționează pentru dvs.

note: type: verbatim
en:  Copyright © 2004 Yves Rütschlé <po4a@rutschle.net>
     Copyright © 2007-2008 Nicolas François <nicolas.francois@centraliens.net>
ro:  Drepturi de autor © 2004 Yves Rütschlé <po4a@rutschle.net>
     Drepturi de autor © 2007-2008 Nicolas François <nicolas.francois@centraliens.net>

note: type: textblock
en: Locale::Po4a::Xml - convert XML documents and derivates from/to PO files
ro: Locale::Po4a::Xml - convertește documente XML și derivate din/în fișiere PO

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.
ro: Locale::Po4a::Xml este un modul care ajută la traducerea documentelor XML în alte limbi [umane]. De asemenea, poate fi folosit ca bază pentru a construi module pentru documente bazate pe XML.

note: type: =head1
en: TRANSLATING WITH PO4A::XML
ro: TRADUCEREA CU 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.
ro: Acest modul poate fi utilizat direct pentru a gestiona documente XML generice.  Acesta va extrage tot conținutul etichetei, fără atribute, deoarece acesta este locul în care este scris textul în majoritatea documentelor bazate pe XML.

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.
ro: Există câteva opțiuni (descrise în secțiunea următoare) care pot personaliza acest comportament. În cazul în care acest lucru nu se potrivește cu formatul documentului dvs., sunteți încurajat să scrieți propriul dvs. modul derivat din acesta, pentru a descrie detaliile formatului dvs. Pentru descrierea procesului, consultați secțiunea B<SCRIEREA MODULELOR DERIVATE> de mai jos.

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.
ro: Opțiunea globală de depanare face ca acest modul să afișeze șirurile excluse, pentru a vedea dacă sare peste ceva important.

note: type: textblock
en: Prevents it to strip the spaces around the extracted strings.
ro: Îl împiedică să elimine spațiile din jurul șirurilor extrase.

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.
ro: Canonizează șirul de caractere de tradus, considerând că spațiile albe nu sunt importante, și încadrează documentul tradus. Această opțiune poate fi anulată prin opțiuni de etichetă personalizate. A se vedea opțiunea B<translated> de mai jos.

note: type: textblock
en: Attributes are wrapped by default. This option disables wrapping.
ro: Atributele sunt învăluite în mod implicit. Această opțiune dezactivează învăluirea.

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.
ro: Aceasta face ca etichetele și atributele de căutare să funcționeze în mod insensibil la majuscule. Dacă este definită, va trata E<lt>BooKE<gt>laNG și E<lt>BOOKE<gt>Lang ca E<lt>bookE<gt>lang.

note: type: textblock
en: Escape quotes in output strings.  Necessary, for example, for creating string resources for use by Android build tools.
ro: Eludează ghilimelele din șirurile de ieșire. Necesar, de exemplu, pentru crearea resurselor de șiruri de caractere pentru a fi utilizate de instrumentele de compilare Android.

note: type: textblock
en: See also: https://developer.android.com/guide/topics/resources/string-resource.html
ro: A se vedea și: 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.
ro: Dacă este definită, entitățile externe sunt incluse în documentul generat (tradus) și pentru extragerea șirurilor de caractere. Dacă nu este definită, va trebui să traduceți entitățile externe separat, ca documente independente.

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:
ro: Această opțiune definește comportamentul modulului atunci când întâlnește o sintaxă XML nevalidă (o etichetă de închidere care nu se potrivește cu ultima etichetă de deschidere). Aceasta poate lua următoarele valori:

note: type: textblock
en: This is the default value.  The module will exit with an error.
ro: Aceasta este valoarea implicită. Modulul va ieși cu o eroare.

note: type: textblock
en: The module will continue, and will issue a warning.
ro: Modulul va continua și va emite un avertisment.

note: type: textblock
en: The module will continue without any warnings.
ro: Modulul va continua fără afișarea niciunui avertisment.

note: type: textblock
en: Be careful when using this option.  It is generally recommended to fix the input file.
ro: Fiți atenți atunci când utilizați această opțiune. În general, este recomandat să corectați fișierul de intrare.

note: type: textblock
en: Note: This option is deprecated.
ro: Notă: Această opțiune este depreciată.

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.
ro: Extrage numai etichetele specificate în opțiunea B<tags>. În caz contrar, va extrage toate etichetele, cu excepția celor specificate.

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.
ro: Șir de caractere care va încerca să se potrivească cu prima linie a  documentului doctype (dacă este definit). În caz contrar, un avertisment va indica faptul că documentul ar putea fi de un tip greșit.

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.
ro: Șir ce indică ruta (de exemplu, E<lt>bbbE<gt>E<lt>aaaE<gt>) unei etichete la care se adaugă un atribut lang=„...”. Limba va fi definită ca numele de bază al fișierului PO fără nicio extensie .po.

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>.
ro: Argument boolean care indică dacă etichetele de închidere sunt opționale (ca în HTML). În mod implicit, lipsa etichetelor de închidere generează o eroare tratată în conformitate cu B<ontagerror>.

note: type: textblock
en: Note: This option is deprecated.  You should use the B<translated> and B<untranslated> options instead.
ro: Notă: Această opțiune este depreciată. Ar trebui să utilizați în schimb opțiunile B<translated> și B<untranslated>.

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.
ro: Listă separată prin spații a etichetelor pe care doriți să le traduceți sau să le omiteți. În mod implicit, etichetele specificate vor fi excluse, dar dacă utilizați opțiunea „tagsonly”, etichetele specificate vor fi singurele incluse. Etichetele trebuie să fie de forma E<lt>aaaE<gt>, dar puteți alătura unele (E<lt>bbbE<gt>E<lt>aaaE<gt>) pentru a spune că conținutul etichetei E<lt>aaaE<gt> va fi tradus numai atunci când este într-o etichetă E<lt>bbbE<gt>.

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.
ro: De asemenea, puteți specifica unele opțiuni de etichetă prin introducerea unor caractere în fața ierarhiei etichetei. De exemplu, puteți pune I<w> (wrap) sau I<W> (don't wrap) pentru a trece peste comportamentul implicit specificat de opțiunea globală B<wrap>.

note: type: textblock
en: Example: WE<lt>chapterE<gt>E<lt>titleE<gt>
ro: Exemplu: WE<lt>capitolrE<gt>E<lt>titluE<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.
ro: Listă separată prin spații a atributelor etichetei pe care doriți să le traduceți.  Puteți specifica atributele după numele lor (de exemplu, „lang”), dar le puteți prefixa cu o ierarhie a etichetei, pentru a specifica faptul că acest atribut va fi tradus numai atunci când se află în eticheta specificată. De exemplu: E<lt>bbbE<gt>E<lt>aaaE<gt>lang specifică faptul că atributul lang va fi tradus numai dacă se află într-o etichetă E<lt>aaaE<gt>, și acesta se află într-o etichetă E<lt>bbbE<gt>.

note: type: textblock
en: Do not translate attributes in inline tags.  Instead, replace all attributes of a tag by po4a-id=<id>.
ro: Nu traduce atributele din etichetele inline. În schimb, înlocuiește toate atributele unui etichete cu po4a-id=<id>.

note: type: textblock
en: This is useful when attributes shall not be translated, as this simplifies the strings for translators, and avoids typos.
ro: Acest lucru este util atunci când atributele nu trebuie traduse, deoarece simplifică șirurile pentru traducători și evită greșelile de scriere.

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.
ro: Listă de etichete separate prin spații care nu ar trebui tratate ca etichete. Aceste etichete sunt tratate ca inline și nu trebuie să fie închise.

note: type: textblock
en: Space-separated list of tags which should break the sequence.  By default, all tags break the sequence.
ro: Lista de etichete separate prin spații care ar trebui să întrerupă secvența. În mod implicit, toate etichetele întrerup secvența.

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>).
ro: Etichetele trebuie să fie sub forma <aaa>, dar puteți alătura unele (<bbb><aaa>), dacă o etichetă (<aaa>) ar trebui să fie luată în considerare numai atunci când este în interiorul unei alte etichete (<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.
ro: Vă rugăm să rețineți că o etichetă trebuie să fie listată într-un singur șir de definiții B<break>, B<inline> B<placeholder>, sau B<customtag>.

note: type: textblock
en: Space-separated list of tags which should be treated as inline.  By default, all tags break the sequence.
ro: Listă de etichete separate prin spațiu care ar trebui tratate ca fiind inline.  În mod implicit, toate etichetele întrerup secvența.

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.
ro: Listă de etichete, separate prin spații, care ar trebui să fie tratate ca marcatori de poziție.  Marcatorii de poziție nu întrerup secvența, dar conținutul acestora este tradus separat.

note: type: textblock
en: The location of the placeholder in its block will be marked with a string similar to:
ro: Locația marcatorului de poziție în blocul său va fi marcată cu un șir similar cu:

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.
ro: În mod implicit, instrucțiunile de procesare (de exemplu, etichetele C<E<lt>? ... ?E<gt>>) sunt tratate ca etichete inline. Treceți această opțiune dacă doriți ca PI să fie tratată ca o etichetă de întrerupere. Rețineți că etichetele PHP neprocesate sunt tratate ca Instrucțiuni de procesare de către analizatorul analitic.

note: type: textblock
en: Space separated list of tags that the module should not try to set by default in any category.
ro: Listă de etichete separate prin spații pe care modulul nu ar trebui să încerce să le definească implicit în nicio categorie.

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.
ro: Dacă aveți o etichetă a cărei definiție implicită este stabilită de subclasa acestui modul, dar doriți să stabiliți o definiție alternativă, trebuie să listați eticheta respectivă ca parte a șirului de definiții B<nodefault>.

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).
ro: Acceptă directivele preprocesorului C. Atunci când această opțiune este activată, po4a va considera directivele preprocesorului ca separatoare de paragraf.  Acest lucru este important dacă fișierul XML trebuie preprocesat, deoarece în caz contrar directivele pot fi inserate în mijlocul liniilor dacă po4a consideră că aparțin paragrafului curent, iar acestea nu vor fi recunoscute de preprocesor. Notă: directivele preprocesorului trebuie să apară numai între etichete (ele nu trebuie să rupă o etichetă).

note: type: textblock
en: Space-separated list of tags you want to translate.
ro: Listă de etichete separate prin spații pe care doriți să le traduceți.

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.
ro: De asemenea, puteți specifica unele opțiuni de etichetă prin introducerea unor caractere în fața ierarhiei etichetei. Aceasta înlocuiește comportamentul implicit specificat de opțiunea globală B<wrap> și B<defaulttranslateoption>.

note: type: textblock
en: Tags should be translated and content can be re-wrapped.
ro: Etichetele trebuie să fie traduse, iar conținutul poate fi reîncadrat (redimensionat).

note: type: textblock
en: Tags should be translated and content should not be re-wrapped.
ro: Etichetele trebuie să fie traduse, iar conținutul nu trebuie să fie reîncadrat (redimensionat).

note: type: textblock
en: Tags should be translated inline.
ro: Etichetele trebuie traduse inline.

note: type: textblock
en: Tags should be translated as placeholders.
ro: Etichetele trebuie traduse ca marcatori de poziție.

note: type: textblock
en: Internally, the XML parser only cares about these four options: I<w> I<W> I<i> I<p>.
ro: Intern, analizorului XML îi pasă doar de aceste patru opțiuni: 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.
ro: * Etichetele enumerate în B<break> sunt stabilite la I<w> sau I<W> în funcție de opțiunea B<wrap>.

note: type: textblock
en: * Tags listed in B<inline> are set to I<i>.
ro: * Etichetele enumerate în B<inline> sunt stabilite la I<i>.

note: type: textblock
en: * Tags listed in B<placeholder> are set to I<p>.
ro: Etichetele enumerate în B<placeholder> sunt stabilite la I<p>.

note: type: textblock
en: * Tags listed in B<untranslated> are without any of these options set.
ro: * Etichetele enumerate în B<untranslated> sunt fără niciuna dintre aceste opțiuni definite.

note: type: textblock
en: You can verify actual internal parameter behavior by invoking B<po4a> with B<--debug> option.
ro: Puteți verifica comportamentul parametrului intern real invocând B<po4a> cu opțiunea B<--debug>.

note: type: textblock
en: Please note a tag should be listed in either B<translated> or B<untranslated> setting string.
ro: Vă rugăm să rețineți că o etichetă trebuie listată în șirul de definiții B<translated> sau B<untranslated>.

note: type: textblock
en: Space-separated list of tags you do not want to translate.
ro: Listă de etichete separate prin spații pe care nu doriți să le traduceți.

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.
ro: Vă rugăm să rețineți că o etichetă inline traductibilă într-o etichetă netradusă este tratată ca o etichetă de întrerupere traductibilă, opțiunea I<i> este eliminată și I<w> sau I<W> este stabilită în funcție de opțiunea B<wrap>.

note: type: textblock
en: The default categories for tags that are not in any of the translated, untranslated, break, inline, or placeholder.
ro: Categoriile implicite pentru etichetele care nu sunt în niciuna dintre categoriile „translated”, „untranslated”, „break”, „inline” sau „placeholder”.

note: type: textblock
en: This is a set of letters as defined in B<translated> and this setting is only valid for translatable tags.
ro: Acesta este un set de litere definit în B<translated> și această opțiune este valabilă numai pentru etichetele traductibile.

note: type: =head1
en: WRITING DERIVATIVE MODULES
ro: SCRIEREA MODULELOR DERIVATE

note: type: =head2
en: DEFINE WHAT TAGS AND ATTRIBUTES TO TRANSLATE
ro: DEFINIȚI ETICHETELE ȘI ATRIBUTELE CARE URMEAZĂ SĂ FIE TRADUSE

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:
ro: Cea mai simplă personalizare este să definiți etichetele și atributele pe care doriți ca analizatorul să le traducă. Acest lucru ar trebui făcut în funcția initialize(). Mai întâi ar trebui să apelați funcția principală initialize(), pentru a obține opțiunile din linia de comandă, iar apoi să adăugați definițiile dvs. personalizate la tabelul opțiunilor. Dacă doriți să tratați unele opțiuni noi din linia de comandă, trebuie să le definiți înainte de a apela funcția principală initialize():

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.
ro: Trebuie să utilizați opțiunile B<_default_inline>, B<_default_break>, B<_default_placeholder>, B<_default_translated>, B<_default_untranslated> și B<_default_attributes> în modulele derivate. Acest lucru permite utilizatorilor să înlocuiască comportamentul implicit definit în modulul dvs. cu opțiuni de linie de comandă.

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.
ro: Dacă nu vă place comportamentul implicit al modulului xml și al modulelor sale derivate, puteți furniza opțiuni de linie de comandă pentru a le modifica comportamentul.

note: type: textblock
en: See L<Locale::Po4a::Docbook(3pm)|Locale::Po4a::Docbook>,
ro: Vedeți L<Locale::Po4a::Docbook(3pm)|Locale::Po4a::Docbook>,

note: type: =head2
en: OVERRIDING THE found_string FUNCTION
ro: SUPRASCRIEREA FUNCȚIEI found_string()

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.
ro: Un alt pas simplu este să suprascrieți funcția „found_string”, care primește șirurile extrase de analizator, pentru a le traduce. Aici puteți controla șirurile de caractere pe care doriți să le traduceți și puteți efectua transformări ale acestora înainte sau după traducerea propriu-zisă.

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.
ro: Acesta primește textul extras, referința la locul de unde a fost extras și un tabel de elemente asociate care conține informații suplimentare pentru a controla ce șiruri de caractere să traducă, cum să le traducă și să genereze comentariul.

note: type: textblock
en: The content of these options depends on the kind of string it is (specified in an entry of this hash):
ro: Conținutul acestor opțiuni depinde de tipul de șir de caractere (specificat într-o intrare a acestui tabel):

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.
ro: Șirul găsit este conținutul unei etichete traductibile. Intrarea „tag_options” conține caracterele de opțiune din fața ierarhiei etichetelor în opțiunea „tags” a modulului.

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.
ro: Înseamnă că șirul găsit este valoarea unui atribut traductibil. Intrarea „attribute” are numele atributului.

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:
ro: Aceasta trebuie să returneze textul care va înlocui originalul în documentul tradus. Iată un exemplu de bază al acestei funcții:

note: type: textblock
en: There's another simple example in the new Dia module, which only filters some strings.
ro: Există un alt exemplu simplu în noul modul Dia, care filtrează doar câteva șiruri de caractere.

note: type: =head2
en: MODIFYING TAG TYPES (TODO)
ro: MODIFICAREA TIPURILOR DE ETICHETE (DE FĂCUT)

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:
ro: Acesta este unul mai complex, dar permite o personalizare (aproape) totală. Se bazează pe o listă de tabele de elemente asociate, fiecare definind comportamentul unui tip de etichetă. Lista ar trebui să fie ordonată astfel încât cele mai generale etichete să fie după cele mai concrete (ordonate mai întâi după cheile de început și apoi după cele de sfârșit). Pentru a defini un tip de etichetă, va trebui să creați un tabel cu următoarele chei:

note: type: textblock
en: Specifies the beginning of the tag, after the "E<lt>".
ro: Specifică începutul etichetei, după „E<lt>”.

note: type: textblock
en: Specifies the end of the tag, before the "E<gt>".
ro: Specifică sfârșitul etichetei, înainte de „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.
ro: Spune dacă aceasta este o clasă de etichetă de întrerupere.  O etichetă de neîntrerupere (inline) este una care poate fi luată ca parte a conținutului unei alte etichete. Aceasta poate lua valorile fals (0), adevărat (1) sau nedefinită. Dacă o lăsați nedefinită, va trebui să definiți funcția f_breaking care va spune dacă o etichetă concretă din această clasă este o etichetă de întrerupere sau nu.

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.
ro: Este o funcție care va spune dacă următoarea etichetă este una de întrerupere sau nu. Ar trebui să fie definită dacă opțiunea B<breaking> nu este.

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.
ro: Dacă lăsați această cheie nedefinită, funcția de extragere generică va trebui să extragă eticheta în sine. Este util pentru etichetele care pot conține alte etichete sau structuri speciale, astfel încât analizatorul principal să nu înnebunească. Această funcție primește un argument boolean care spune dacă eticheta trebuie sau nu să fie eliminată din fluxul de intrare.

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.
ro: Această funcție primește eticheta (în formatul get_string_until()) și returnează eticheta tradusă (atributele traduse sau toate transformările necesare) ca un singur șir.

note: type: =head2
en: WORKING WITH TAGS
ro: LUCRÂND CU ETICHETE

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>.
ro: Această funcție returnează ruta către eticheta curentă din rădăcina documentului, sub forma E<lt>htmlE<gt>E<lt>bodyE<gt>E<lt>pE<gt>.

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.
ro: O matrice suplimentară de etichete (fără paranteze) poate fi trecută ca argument. Aceste elemente de rută sunt adăugate la sfârșitul rutei curente.

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.
ro: Această funcție returnează indexul din lista tag_types care se potrivește cu următoarea etichetă din fluxul de intrare sau -1 dacă este la sfârșitul fișierului de intrare.

note: type: textblock
en: Here, the tag has structure started by E<lt> and end by E<gt> and it can contain multiple lines.
ro: Aici, eticheta are o structură care începe cu E<lt> și se termină cu E<gt> și poate conține mai multe linii.

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($$) >>.
ro: Aceasta funcționează pe matricea C<< @{$self->{TT}{doc_in}} >> care conține datele documentului de intrare și referință indirectă prin C<< $self->shiftline() >> și C<< $self->unshiftline($$) >>.

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.
ro: Această funcție returnează următoarea etichetă din fluxul de intrare fără început și sfârșit, sub forma unei matrice, pentru a menține referințele din fișierul de intrare. Funcția are doi parametri: tipul etichetei (returnat de tag_type) și un parametru boolean, care indică dacă aceasta ar trebui eliminată din fluxul de intrare.

note: type: textblock
en: This function returns the name of the tag passed as an argument, in the array form returned by extract_tag.
ro: Această funcție returnează numele etichetei transmise ca argument, în forma de matrice returnată de extract_tag.

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.
ro: Această funcție returnează un argument boolean care spune dacă următoarea etichetă din fluxul de intrare este o etichetă de întrerupere sau nu (etichetă inline).  Aceasta lasă fluxul de intrare intact.

note: type: textblock
en: This function translates the next tag from the input stream.  Using each tag type's custom translation functions.
ro: Această funcție traduce următoarea etichetă din fluxul de intrare. Folosind funcțiile de traducere personalizate ale fiecărui tip de etichetă.

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).
ro: Această funcție returnează o valoare șir de caractere care spune dacă primul argument (o ierarhie de etichete) se potrivește cu oricare dintre etichetele din al doilea argument (o listă de etichete sau ierarhii de etichete). Dacă nu se potrivește, returnează 0. În caz contrar, returnează opțiunile etichetei potrivite (caracterele din fața etichetei) sau 1 (dacă eticheta respectivă nu are opțiuni).

note: type: =head2
en: WORKING WITH ATTRIBUTES
ro: LUCRÂND CU ATRIBUTE

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.
ro: Această funcție se ocupă de traducerea atributelor etichetelor. Primește eticheta fără semnele de început / sfârșit, apoi găsește atributele și le traduce pe cele traductibile (specificate de opțiunea modulului B<attributes>). Aceasta returnează un șir simplu cu eticheta tradusă.

note: type: =head2
en: WORKING WITH TAGGED CONTENTS
ro: LUCRÂND CU CONȚINUT ETICHETAT

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.
ro: Această funcție obține textul până la următoarea etichetă de întrerupere (nu în linie) din fluxul de intrare. Îl traduce utilizând funcțiile de traducere personalizate ale fiecărui tip de etichetă.

note: type: =head2
en: WORKING WITH THE MODULE OPTIONS
ro: LUCRÂND CU OPȚIUNILE MODULULUI

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).
ro: Această funcție completează structurile interne care conțin etichetele, atributele și datele inline cu opțiunile modulului (specificate în linia de comandă sau în funcția de inițializare).

note: type: =head2
en: GETTING TEXT FROM THE INPUT DOCUMENT
ro: OBȚINEREA TEXTULUI DIN DOCUMENTUL DE INTRARE

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.
ro: Această funcție returnează o matrice cu liniile (și referințele) din documentul de intrare până când găsește primul argument. Al doilea argument este un șir de valori numerice pentru opțiuni. Valoarea 0 înseamnă dezactivat (implicit) și 1, activat.

note: type: textblock
en: The valid options are:
ro: Opțiunile valide sunt:

note: type: textblock
en: This makes the returned array to contain the searched text
ro: Aceasta face ca matricea returnată să conțină textul căutat

note: type: textblock
en: This removes the returned stream from the input
ro: Aceasta elimină fluxul returnat de la intrare

note: type: textblock
en: This ensures that the searched text is outside any quotes
ro: Aceasta asigură că textul căutat se află în afara oricăror ghilimele

note: type: textblock
en: This denotes that the first argument is a regular expression rather than an plain string
ro: Aceasta indică faptul că primul argument este o expresie regulată în loc de un șir simplu

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.
ro: Această funcție primește ca argument referința la un paragraf (în formatul returnat de get_string_until), ignoră spațiile de titlu ale acestuia și le returnează sub forma unui șir simplu.

note: type: textblock
en: This function returns a simple string with the text from the argument array (discarding the references).
ro: Această funcție returnează un șir de caractere simplu cu textul din matricea de argumente (eliminând referințele).

note: type: textblock
en: This module can translate tags and attributes.
ro: Acest modul poate traduce etichete și atribute.

note: type: textblock
en: DOCTYPE (ENTITIES)
ro: DOCTYPE (ENTITĂȚI)

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.
ro: Există un suport minim pentru traducerea entităților. Acestea sunt traduse ca un întreg, iar etichetele nu sunt luate în considerare. Entitățile multilinie nu sunt acceptate, iar entitățile sunt întotdeauna reîncadrate (redimensionate) în timpul traducerii.

note: type: textblock
en: MODIFY TAG TYPES FROM INHERITED MODULES (move the tag_types structure inside the $self hash?)
ro: MODIFICAREA TIPURILOR DE ETICHETE DIN MODULELE EREDATE (mutarea structurii tag_types în interiorul tabelului de elemente asociate $self?)

note: type: verbatim
en:  Copyright © 2004 Jordi Vilalta  <jvprat@gmail.com>
     Copyright © 2008-2009 Nicolas François <nicolas.francois@centraliens.net>
ro:  Drepturi de autor © 2004 Jordi Vilalta <jvprat@gmail.com>
     Drepturi de autor © 2008-2009 Nicolas François <nicolas.francois@centraliens.net>

note: type: textblock
en: Locale::Po4a::Yaml - convert YAML files from/to PO files
ro: Locale::Po4a::Yaml - convertește fișiere YAML din/în fișiere PO

note: type: textblock
en: Locale::Po4a::Yaml is a module to help the translation of Yaml files into other [human] languages.
ro: Locale::Po4a::Yaml este un modul care ajută la traducerea fișierelor Yaml în alte limbi [umane].

note: type: textblock
en: The module extracts the value of YAML hashes and arrays. Hash keys are not extracted.
ro: Modulul extrage valoarea hașurilor și a matricelor YAML. Cheile hash nu sunt extrase.

note: type: textblock
en: NOTE: This module parses the YAML file with YAML::Tiny.
ro: NOTĂ: Acest modul analizează fișierul YAML cu YAML::Tiny.

note: type: textblock
en: Space-separated list of hash keys to process for extraction, all other keys are skipped.  Keys are matched with a case-sensitive match.  If B<paths> and B<keys> are used together, values are included if they are matched by at least one of the options.  Arrays values are always returned unless the B<skip_array> option is provided.
ro: Listă de chei hash separate prin spații care urmează să fie procesate pentru extragere; toate celelalte chei sunt ignorate. Cheile sunt comparate cu o potrivire sensibilă la majuscule. Dacă B<paths> și B<keys> sunt utilizate împreună, valorile sunt incluse dacă se potrivesc cu cel puțin una dintre opțiuni. Valorile matricelor sunt întotdeauna returnate, cu excepția cazului în care este furnizată opțiunea B<skip_array>.

note: type: textblock
en: Comma-separated list of hash paths to process for extraction, all other paths are skipped. Paths are matched with a case-sensitive match.  If B<paths> and B<keys> are used together, values are included if they are matched by at least one of the options.  Arrays values are always returned unless the B<skip_array> option is provided.
ro: Listă separată prin virgule de rute hash care urmează să fie procesate pentru extragere; toate celelalte rute sunt ignorate. Rutele sunt comparate cu o potrivire sensibilă la majuscule. Dacă B<paths> și B<keys> sunt utilizate împreună, valorile sunt incluse dacă se potrivesc cu cel puțin una dintre opțiuni. Valorile matricelor sunt întotdeauna returnate, cu excepția cazului în care este furnizată opțiunea B<skip_array>.

note: type: textblock
en: Do not translate array values.
ro: Nu traduce valorile matricei.

note: type: verbatim
en:  Copyright © 2017 Brian Exelbierd.
     Copyright © 2022 Martin Quinson <mquinson#debian.org>.
ro:  Drepturi de autor © 2017 Brian Exelbierd.
     Drepturi de autor © 2022 Martin Quinson <mquinson#debian.org>.
