
        *****************************************************
        *           GENERATED FILE, DO NOT EDIT             *
        * THIS IS NO SOURCE FILE, BUT RESULT OF COMPILATION *
        *****************************************************

This file was generated by po4a(7). Do not store it (in VCS, for example),
but store the PO file used as source file by po4a-translate.

In fact, consider this as a binary, and the PO file as a regular .c file:
If the PO get lost, keeping this translation up-to-date will be harder.

=encoding UTF-8

=head1 NOME

po4a - framework para traduzir documentação e outros materiais

=head1 Introdução

po4a (PO for anything) facilita a manutenção da tradução de documentação
usando as ferramentas gettext clássicas. A principal característica do po4a
é que ele dissocia a tradução do conteúdo de sua estrutura documental.

Este documento serve como uma introdução ao projeto po4a, com foco nos
usuários em potencial, considerando a possibilidade de usar essa ferramenta
e no desejo curioso de entender por que as coisas são do jeito que são.

=head1 Por que o po4a?

A filosofia do software livre é tornar a tecnologia verdadeiramente
disponível para todos. Mas o licenciamento não é a única consideração: o
software livre não traduzido é inútil para quem não fala inglês. Portanto,
ainda temos algum trabalho a fazer para disponibilizar o software para
todos.

Essa situação é bem compreendida pela maioria dos projetos e agora todos
estão convencidos da necessidade de traduzir tudo. No entanto, as traduções
reais representam um enorme esforço de muitas pessoas, prejudicadas por
pequenas dificuldades técnicas.

Felizmente, o software de código aberto é realmente muito bem traduzido
usando o conjunto de ferramentas gettext. Essas ferramentas são usadas para
extrair as strings a serem traduzidas de um programa e apresentar as strings
em um formato padronizado (chamado de arquivos PO ou catálogos de
tradução). Um ecossistema inteiro de ferramentas surgiu para ajudar os
tradutores a traduzir esses arquivos PO. O resultado é usado pelo gettext no
tempo de execução para exibir mensagens traduzidas para os usuários finais.

Em relação à documentação, no entanto, a situação ainda é um pouco
decepcionante. No início, traduzir a documentação pode parecer mais fácil do
que traduzir um programa, pois parece que você apenas precisa copiar o
arquivo-fonte da documentação e começar a traduzir o conteúdo. No entanto,
quando a documentação original é modificada, acompanhar as modificações
rapidamente se transforma em um pesadelo para os tradutores. Se realizada
manualmente, esta tarefa é desagradável e propensa a erros.

Traduções desatualizadas geralmente são piores do que nenhuma tradução. Os
usuários finais podem ser enganados pela documentação que descreve um
comportamento antigo do programa. Além disso, eles não podem interagir
diretamente com os mantenedores, pois não falam inglês. Além disso, o
mantenedor não pode resolver o problema, pois não conhece todos os idiomas
em que sua documentação está traduzida. Essas dificuldades, muitas vezes
causadas por ferramentas precárias, podem minar a motivação de tradutores
voluntários, agravando ainda mais o problema.

B<O objetivo do projeto po4a é facilitar o trabalho dos tradutores de
documentação>. Em particular, ele torna possível I<manter> traduções de
documentações.

A ideia é reutilizar e adaptar a abordagem gettext a esse campo. Assim como
o gettext, os textos são extraídos de seus locais originais e apresentados
aos tradutores como catálogos de tradução de pedidos. Os tradutores podem
aproveitar as ferramentas gettext clássicas para monitorar o trabalho a
realizar, colaborar e organizar em equipe. O po4a injeta as traduções
diretamente na estrutura da documentação para produzir arquivos de origem
traduzidos que podem ser processados e distribuídos da mesma forma que os
arquivos em inglês. Qualquer parágrafo que não seja traduzido é deixado em
inglês no documento resultante, garantindo que os usuários finais nunca
vejam uma tradução desatualizada na documentação.

Isso automatiza a maior parte do trabalho pesado da manutenção da
tradução. A descoberta dos parágrafos que precisam de atualização se torna
muito fácil e o processo é completamente automatizado quando os elementos
são reordenados sem modificações adicionais. A verificação específica também
pode ser usada para reduzir a chance de erros de formatação que resultariam
em um documento quebrado.

Por favor, veja também o B<FAQ> abaixo neste documento para uma lista mais
completa de vantagens e desvantagens desta abordagem.

=head2 Formatos suportados

Atualmente, essa abordagem tem sido implementada com sucesso em vários
formatos de formatação de texto:

=over 

=item man (analisador maduro)

O bom e velho formato de páginas de manual, usado por muitos programas por
aí. Suporte do po4a é muito bem-vindo, considerando que esse formato é de
certa forma difícil de usar e não exatamente amigável para novatos.

O módulo L<Locale::Po4a::Man(3pm)|Man> também possui suporte ao formato mdoc
usado pelas páginas man do BSD (elas também são bastante comuns no Linux).

=item AsciiDoc (analisador maduro)

Esse formato é um formato de marcação leve, destinado a facilitar a criação
da documentação. Por exemplo, é usado para documentar o sistema git. Essas
páginas man são traduzidas usando po4a.

=item pod (analisador maduro)

Esse é o formato da documentação online de Perl, ou Perl Online
Documentation. A própria linguagem e extensões são documentadas usando este
formato além da maioria dos scripts Perl existentes. Isso facilita a manter
a documentação ferto do real código embutindo-os no mesmo arquivo. Isso
torna a vida dos programadores mais fácil, mas infelizmente, não a do
tradutor, até você usar o po4a.

=item sgml (analisador maduro)

Mesmo que substituído pelo XML hoje em dia, esse formato ainda é usado para
documentos que têm mais de algumas telas. Pode até ser usado para livros
completos.  Documentos deste comprimento podem ser muito desafiadores para
atualizar. B<diff> muitas vezes revela inútil quando o texto original era
recuado novamente após a atualização.  Felizmente, po4a pode lhe ajudar
depois desse processo.

Atualmente, há suporte apenas ao DebianDoc e o DocBook DTD, mas a adição de
suporte a um novo é realmente fácil. É possível até mesmo usar po4a em um
SGML DTD desconhecido sem alterar o código, desde que sejam fornecidas as
informações necessárias na linha de comando. Veja L<Locale::Po4a::Sgml(3pm)>
para mais detalhes.

=item TeX / LaTeX (analisador maduro)

O formato LaTeX é um formato de documentação mais usado no mundo de software
livre e para publicações.

O módulo L<Locale::Po4a::LaTeX(3pm)|LaTeX> foi testado com a documentação do
Python, um livro e algumas apresentações.

=item text (analisador maduro)

O formato Text é of formato base para muitos formatos que incluem longos
blocos de texto, incluindo Markdown, debian/changelong e debian/control.

Este possui suporte ao formato comum usado em geradores de sites estáticos,
READMEs e outros sistemas de documentação. Consulte
L<Locale::Po4a::Text(3pm)|Text> para detalhes.

=item xml e XHMTL (analisador provavelmente maduro)

O formato XML é um formato base para muitos formatos de documentação.

Atualmente, o DocBook DTD (veja L<Locale::Po4a::Docbook(3pm)> para mais
detalhes) e XHTML são suportados pelo po4a.

=item texinfo (analisador altamente experimental)

Toda a documentação do GNU é escrita neste formato (esse é até mesmo um dos
requisitos para se tornar um projeto GNU oficial). O suporte a
L<Locale::Po4a::Texinfo(3pm)|Texinfo> no po4a ainda está nas fases
iniciais. Por favor relate eventuais erros e requisição por recursos.

=item Outros formatos com suporte

Po4a também pode manipular alguns formatos mais raros ou especializados,
como a documentação de opções de compilação dos kernels Linux 2.4+ ou
diagramas produzidos pela ferramenta Dia. A adição de um novo formato é
normalmente muito fácil e a tarefa principal é fazer um analisador para seu
formato alvo. Veja L<Locale::Po4a::TransTractor(3pm)> para mais informações
sobre isso.

=item Formatos sem suporte

Infelizmente, po4a ainda carece de suporte para vários formatos de
documentação. Muitos deles seriam fáceis de dar suporte no po4a. Isso inclui
formatos não apenas usados para documentação, como, descrições de pacotes
(deb e rpm), perguntas sobre scripts de instalação de pacotes, changelogs de
pacotes e todos os formatos de arquivo especializados usados por programas
como cenários de jogos ou arquivos de recursos de vinho.

=back

=head1 Usando po4a

Historicamente, o po4a foi construído em torno de quatro scripts, cada um
cumprindo uma tarefa específica. L<po4a-gettextize(1)> ajuda na
inicialização de traduções e, opcionalmente, na conversão de projetos de
tradução existentes em po4a. L<po4a-updatepo(1)> reflete as alterações na
documentação original nos arquivos po correspondentes. L<po4a-translate(1)>
constrói o arquivo de origem traduzido a partir do arquivo original e do
arquivo PO correspondente. Além disso, L<po4a-normalize(1)> é principalmente
útil para depurar os analisadores de po4a, pois produz um documento não
traduzido do original. Torna mais fácil identificar as falhas introduzidas
pelo processo de análise.

A maioria dos projetos requer apenas os recursos de L<po4a-updatepo(1)> e
L<po4a-translate(1)>, mas esses scripts provaram ser pesados e propensos a
erros. Se a documentação a ser traduzida estiver dividida em vários arquivos
fonte, é difícil manter os arquivos PO atualizados e criar os arquivos de
documentação corretamente. Como resposta, foi fornecida uma ferramenta
multifuncional: L<po4a(1)>. Essa ferramenta utiliza um arquivo de
configuração que descreve a estrutura do projeto de tradução: o local dos
arquivos PO, a lista de arquivos a serem traduzidos e as opções a serem
usadas, além de automatizar completamente o processo. Quando você invoca
L<po4a(1)>, ele atualiza os arquivos PO e regenera os arquivos de tradução
necessários. Se tudo já estiver atualizado, L<po4a(1)> não altera nenhum
arquivo.

O restante desta seção fornece uma visão geral de como usar a interface de
scripts do po4a. A maioria dos usuários provavelmente preferirá usar a
ferramenta multifuncional, descrita na documentação de L<po4a(1)>.

=head2 Visão geral gráfica dos scripts do po4a

O esquema a seguir fornece uma visão geral de como cada script po4a pode ser
usado. Aqui, F<master.doc> é um nome de exemplo para a documentação a ser
traduzida; F<XX.doc> é o mesmo documento traduzido no idioma XX, enquanto
F<doc.XX.po> é o catálogo de traduções desse documento no idioma XX. Os
autores da documentação se preocuparão principalmente com F<master.doc> (que
pode ser uma página man, um documento XML, um arquivo asciidoc ou
semelhante); os tradutores se preocuparão principalmente com o arquivo PO,
enquanto os usuários finais verão apenas o arquivo F<XX.doc>.

                                   mestre.doc
                                       |
                                       V
     +<-----<----+<-----<-----<--------+------->-------->-------+
     :           |                     |                        :
 {tradução}      |       { atualização de mestre.doc }          :
     :           |                     |                        :
   XX.doc        |                     V                        V
 (opcional)      |                 mestre.doc ->-------->------>+
     :           |                  (novo)                      |
     V           V                     |                        |
  [po4a-gettextize]  doc.XX.po---->+   |                        |
          |           (velho)      |   |                        |
          |              ^         V   V                        |
          |              |     [po4a-updatepo]                  |
          V              |           |                          V
     tradução.pot        ^           V                          |
          |              |       doc.XX.po                      |
          |              |       (incerto)                      |
     { tradução }        |           |                          |
          |              ^           V                          V
          |              |    {edição manual}                   |
          |              |           |                          |
          V              |           V                          V
      doc.XX.po --->---->+<---<-- doc.XX.po    adendo      mestre.doc
      (inicial)                 (atualizado)  (opcional)  (atualizado)
          :                          |            |             |
          :                          V            |             |
          +----->----->----->------> +            |             |
                                     |            |             |
                                     V            V             V
                                     +------>-----+------<------+
                                                  |
                                                  V
                                           [po4a-translate]
                                                  |
                                                  V
                                                XX.doc
                                            (atualizado)

Esse esquema é complicado, mas na prática apenas a parte correta (envolvendo
L<po4a-updatepo(1)> e L<po4a-translate(1)>) é usada depois que o projeto é
instalado e configurado.

A parte esquerda mostra como L<po4a-gettextize(1)> pode ser usado para
converter um projeto de tradução existente para a infraestrutura do
po4a. Este script pega um documento original e seu equivalente traduzido, e
tenta construir o arquivo PO correspondente. Tal conversão manual é um pouco
trabalhosa (veja a documentação L<po4a-gettextize(1)> para mais detalhes),
mas só é necessária uma vez para converter suas traduções existentes. Se
você não tem nenhuma tradução para converter, você pode esquecer isso e
focar na parte certa do esquema.

Na parte superior direita, a ação do autor original está descrita,
atualização da documentação. A parte do meio, à direita, representa as ações
automáticas do L<po4a-updatepo(1)>. Os novos materiais são extraídos e
comparados com a tradução existente. A tradução anterior é usado para as
partes que não foram alteradas, enquanto partes parcialmente modificadas
também são conectadas à tradução anterior com uma marcação "fuzzy" indicando
que a tradução deve ser atualizada. Material novo ou muito modificado é
deixado sem tradução.

Então, a I<edição manual> relatada representa a ação dos tradutores, que
modificam os arquivo PO para fornecer traduções para toda string e parágrafo
originais. Isso pode ser feito usando um editor específico, como o B<Editor
de Tradução do GNOME>, o B<Lokalize> do KDE ou B<poedit>, ou usando uma
plataforma de localização online como o B<weblate> ou B<pootle>. O resultado
da tradução é um conjunto de arquivos PO, um por idioma. Consulte a
documentação gettext para mais detalhes.

A parte inferior da figura mostra como L<po4a-translate(1)> cria um
documento fonte traduzido do documento original F<master.doc> e do catálogo
de traduções F<doc.XX.po> que foram atualizados pelos tradutores . A
estrutura do documento é reutilizada, enquanto o conteúdo original é
substituído por sua contraparte traduzida. Opcionalmente, um adendo pode ser
usado para adicionar um texto extra à tradução. Isso geralmente é usado para
adicionar o nome do tradutor ao documento final. Veja abaixo os detalhes.

Como observado anteriormente, o programa L<po4a(1)> combina os efeitos dos
scripts separados, atualizando os arquivos PO e o documento traduzido em uma
chamada. A lógica subjacente permanece a mesma.

=head2 Iniciando uma nova tradução

Se você usar L<po4a(1)>, não há etapa específica para iniciar uma
tradução. Você apenas precisa listar os idiomas no arquivo de configuração,
e os arquivos PO ausentes são criados automaticamente. Naturalmente, o
tradutor deve fornecer traduções para todos os conteúdos usados em seus
documentos. L<po4a(1)> também cria um arquivo POT, que é um arquivo de
modelo de PO. Tradutores em potencial podem traduzir seu projeto para um
novo idioma renomeando esse arquivo e fornecendo as traduções no idioma
deles.

Se você preferir usar os scripts individuais separadamente, use
L<po4a-gettextize(1)> da seguinte maneira para criar o arquivo POT. Este
arquivo pode ser copiado em F<XX.po> para iniciar uma nova tradução.

  $ po4a-gettextize --format <formato> --master <mestre.doc> --po <tradução.pot>

O documento mestre é usado na entrada, enquanto o arquivo PO é a saída deste
processo.

=head2 Integrando alterações ao documento original

O script a ser usado para isso é L<po4a-updatepo(1)> (consulte a
documentação para obter detalhes):

  $ po4a-updatepo --format <formato> --master <novo_mestre.doc> --po <doc_antigo.XX.po>

O documento mestre é usado na entrada, enquanto o arquivo PO é atualizado:
ele é usado tanto na entrada quanto na saída.

=head2 Gerando um documento traduzido

Assim que você finalizar com a tradução, você quer pegar a documentação
traduzida e distribuí-la para os usuários junto com o original. Para isso,
use o programa L<po4a-translate(1)> da seguinte forma:

  $ po4a-translate --format <formato> --master <mestre.doc> --po <doc.XX.po> --localized <XX.doc>

Os arquivos mestre e PO são usados na entrada, enquanto o arquivo localizado
é a saída desse processo.

=head2 Usando adendos para adicionar texto extra às traduções

Adicionar novo texto à tradução é provavelmente a única coisa mais fácil a
longo prazo quando você traduz arquivos manualmente :). Isso acontece quando
você deseja adicionar uma seção extra ao documento traduzido, que não
corresponde a nenhum conteúdo no documento original. O caso de uso clássico
é dar créditos à equipe de tradução e indicar como relatar problemas
específicos da tradução.

Com o po4a, é necessário especificar os arquivos B<addendum>, que podem ser
vistos conceitualmente como patches aplicados ao documento localizado após o
processamento. Cada adendo deve ser fornecido como um arquivo separado, cujo
formato é, no entanto, muito diferente dos patches clássicos. A primeira
linha é uma I<linha de cabeçalho>, definindo o ponto de inserção do adendo
(com uma sintaxe infelizmente enigmática -- veja abaixo) enquanto o restante
do arquivo é adicionado literalmente na posição determinada.

A linha do cabeçalho deve começar com a string B<PO4A-HEADER:>, seguida por
uma lista separada por ponto e vírgula dos campos I<chave>B<=>I<valor>.

Por exemplo, o cabeçalho a seguir declara um adendo que deve ser colocado
bem no final da tradução.

 PO4A-HEADER: mode=eof

As coisas ficam mais complexas quando você deseja adicionar seu conteúdo
extra no meio do documento. O cabeçalho a seguir declara um adendo que deve
ser colocado após a seção XML que contém a string C<Sobre este documento> na
tradução.

=pod

 PO4A-HEADER: position=Sobre este documento; mode=after; endboundary=</section>

Na prática, ao tentar aplicar um adendo, o po4a pesquisa a primeira linha
correspondente ao argumento C<position> (isso pode ser um regexp). Não
esqueça que o po4a considera o documento B<translated> aqui. Esta
documentação está em inglês, mas sua linha provavelmente deve ser a
seguinte, se você pretende que seu adendo se aplique à tradução em francês
do documento.

 PO4A-HEADER: position=À propos de ce document; mode=after; endboundary=</section>

Depois que a C<position> é encontrada no documento de destino, o po4a
procura a próxima linha após a C<position> que corresponde ao C<endboundary>
fornecido. O adendo é adicionado à direita B<after> essa linha (porque
fornecemos um I<endboundary>, ou seja, um limite que termina a seção atual).

O exato mesmo efeito pode ser obtido com o seguinte cabeçalho, que é
equivalente:

 PO4A-HEADER: position=About this document; mode=after; beginboundary=<section>

Aqui, o po4a pesquisa a primeira linha correspondente a C<<section>> após a
linha correspondente a C<About this document> na tradução e adicione o
adendo B<before> dessa linha, pois fornecemos um I<beginboundary>, ou seja,
um limite que marca o início da próxima seção. Portanto, essa linha de
cabeçalho exige a inserção do adendo após a seção que contém C<About this
document> e instrui o po4a que uma seção começa com uma linha que contém a
tag C<<section>>. Isso é equivalente ao exemplo anterior, porque o que você
realmente deseja é adicionar este adendo após C</section>> ou antes de
C<<section>>.

Você também pode definir a inserção I<modo> como o valor C<before>, com uma
semântica semelhante: a combinação de C<mode=before> com um C<endboundary>
colocará o adendo apenas B<after> o limite correspondente, que a última
linha limite potencial antes da C<position>. Combinar C<mode=before> com um
C<beginboundary> colocará o adendo apenas B<before> do limite
correspondente, que é a última linha limite potencial antes da C<position>.

  Modo   | Tipo de limite |       Limite usado         | Ponto de inserção am comparação ao limite
 ========|================|============================|==========================================
 'before'| 'endboundary'  | último antes de 'position' | Logo após o limite selecionado
 'before'|'beginboundary' | último antes de 'position' | Logo antes do limite selecionado
 'after' | 'endboundary'  |  primeiro após 'position'  | Logo após o limite selecionado
 'after' |'beginboundary' |  primeiro após 'position'  | Logo antes do limite selecionado
 'eof'   |   (none)       |  n/d                       | Fim do arquivo

=head3 Dicas e truques sobre adendos

=over 

=item 

Lembre-se de que estes são regexp. Por exemplo, se você deseja combinar o
final de uma seção nroff que termina com a linha C<.fi>, não use C<.fi> como
B<endboundary> porque ele vai corresponder a C<the[ fi]le>, o que obviamente
não é o que está esperando. O B<endboundary> correto neste caso é:
C<^\.fi$>.

=item 

Espaços em branco SÃO importantes no conteúdo da C<position> e
limites. Portanto, as duas linhas seguintes B<são diferentes>. O segundo só
será encontrado se houver espaços à direita suficientes no documento
traduzido.

 PO4A-HEADER: position=Sobre este documento; mode=after; beginboundary=<section>
 PO4A-HEADER: position=Sobre este documento; mode=after; beginboundary=<section>

=item 

Embora essa pesquisa de contexto possa ser considerada como operando
aproximadamente em cada linha do documento B<traduzido>, ela realmente opera
na cadeia de dados interna do documento traduzido. Essa cadeia de dados
interna pode ser um texto abrangendo um parágrafo contendo várias linhas ou
pode ser uma tag XML sozinha. O exato I<ponto de inserção> do adendo deve
ser anterior ou posterior à sequência de dados interna e não pode estar
dentro da cadeia de dados interna.

=item 

Passe o argumento B<-vv> para po4a para entender como os adendos são
adicionados à tradução. Também pode ajudar a executar po4a no modo de
depuração para ver a string de dados interna real quando o seu adendo não se
aplica.

=back

=head3 Exemplos de adendos

=over 

=item 

Se você quiser adicionar alguma coisa após a seção nroff a seguir:

  .SH "AUTHORS"

Você deve selecionar uma abordagem em duas etapas configurando
B<mode=after>. Em seguida, você deve restringir a pesquisa à linha após
B<AUTHORS> com a regex de argumento B<position>. Então, você deve combinar o
início da próxima seção (isto é, B<^ \. SH>) com a regex de argumento
B<beginboundary>. Isso é para dizer:

 PO4A-HEADER:mode=after;position=AUTHORS;beginboundary=\.SH

=item 

Se você quiser adicionar alguma coisa após a linha dada (ex,. após a linha
"Copyright Grande Cara") use um B<position> correspondendo a esta linha,
B<mode=after> e forneça um B<beginboundary> correspondendo a qualquer linha.

 PO4A-HEADER:mode=after;position=Copyright Grande Cara, 2004;beginboundary=^

=item 

Se você quiser adicionar alguma coisa ao final do documento, forneça um
B<position> correspondendo a qualquer linha do seu documento (mas apenas uma
linha. Po4a não vai proceder se ela não for única), e forneça um
B<endboundary> correspondendo a nada. Não use strings simples aqui como
B<"EOF">, e sim prefira aquelas que possuem menos chance de estar no seu
documento.

 PO4A-HEADER:mode=after;position=Sobre este documento;beginboundary=FakePo4aBoundary

=back



=head3 Exemplo mais detalhado

Documento original (formatado em POD):

 |=head1 NAME
 |
 |dummy - a dummy program
 |
 |=head1 AUTHOR
 |
 |me

Então, o adendo a seguir vai assegurar que a seção (em Francês) sobre o
tradutor seja adicionado ao final do arquivo (em Francês, "TRADUCTEUR"
significa "TRADUTOR", e "moi" significa "eu").

 |PO4A-HEADER:mode=after;position=AUTEUR;beginboundary=^=head
 |
 |=head1 TRADUCTEUR
 |
 |moi
 |

Para colocar seu adendo antes do AUTHOR, use o seguinte cabeçalho:

 PO4A-HEADER:mode=after;position=NOM;beginboundary=^=head1

Isso funciona porque a próxima linha correspondendo ao B<beginboundary>
/^=head1/ após a seção "NAME" (traduzido para "NOM" em Francês) é aquela
declarando os autores. Então, o adendo será colocado entre as duas
seções. Note que se outra seção for adicionada entre as seções NAME e AUTHOR
posteriormente, po4a colocará o adendo equivocadamente antes da nova seção.

Para evitar isto, você pode realizar o mesmo usando B<mode>=I<before>:

 PO4A-HEADER:mode=before;position=^=head1 AUTEUR

=head1 Como ele funciona?

Este capítulo dá a você uma visão geral da parte interna do po4a, de forma
que você pode se sentir mais confiante para nos ajudar a manter e
melhorá-lo. ele também pode ajudá-lo a entender o porquê de ele não
funcionar da forma que você esperava, e como resolver seus problemas.

A arquitetura do po4a é orientada a objeto. A classe
L<Locale::Po4a::TransTractor(3pm)|TransTractor> é um antepassado comum para
todos analisadores do po4a. Esse nome estranho vem do fato que ele é ao
mesmo tempo o encarregado por tradução de documento e extração de strings.

Mais formalmente, ele pega um documento para traduzir mais um arquivo PO
contendo as traduções para usar como entrada, enquanto produz duas saídas
separadas: outro arquivo PO (resultante da extração das strings traduzíveis
do documento de entrada) e um documento traduzido (com a mesma estrutura
daquele de entrada, mas com todas as strings traduzíveis substituídas com o
conteúdo do PO de entrada). Aqui está uma representação gráfica disso:

   Doc. de entrada --\                             /---> Doc. de saída
                      \      TransTractor::       /       (traduzido)
                       +-->--   parse()  --------+
                      /                           \
   PO de entrada ----/                             \---> PO de saída
                                                           (extraído)



Esse pequeno osso é o núcleo de toda arquitetura do po4a. Se você omitir o
PO de entrada e o documento de saída, você obtém B<po4a-gettextize>. Se você
fornecer ambos arquivos de entrada e desconsiderar o PO de saída, você obtém
B<po4a-translate>. O B<po4a> chama o TransTractor duas vezes e chama
B<msgmerge -U> entre essas chamadas do TransTractor para fornecer uma
solução completa com um único arquivo de configuração. Por favor, veja
L<Locale::Po4a::TransTractor(3pm)> para mais detalhes.

=head1 Projetos de código aberto que usam o po4a

Aqui está uma lista bem parcial de projetos que usam po4a na produção para
sua documentação. Se você quiser adicionar seu projeto à lista, basta nos
enviar um e-mail (ou uma merge request).

=over 

=item 

adduser (man): ferramenta de gerenciamento de usuários e grupos.

=item 

apt (man, docbook): Gerenciador de pacotes do Debian.

=item 

aptitude (docbook, svg): Gerenciador de pacotes em interface de texto para
Debian

=item 

L<Site do F-Droid|https://gitlab.com/fdroid/fdroid-website> (markdown):
catálogo instalável de aplicativos FOSS (abreviação de software livre e de
código aberto) para a plataforma Android.

=item 

L<git|https://github.com/jnavila/git-manpages-l10n> (asciidoc): sistema de
controle de versão distribuído para alterações de rastreamento em
código-fonte.

=item 

L<Páginas man do
Linux|https://salsa.debian.org/manpages-l10n-team/manpages-l10n> (man)

Este projeto fornece uma infraestrutura para traduzir muitas páginas man
para diferentes idiomas, prontas para integração em várias grandes
distribuições (Arch Linux, Debian e derivados, Fedora).

=item 

L<Stellarium|https://github.com/Stellarium/stellarium> (HTML): um planetário
de código aberto e livre para o seu computador. po4a é usado para traduzir
as descrições da cultura do céu.

=back



=head1 FAQ

=head2 Como você pronuncia po4a?

Eu pessoalmente vocalizo-o como
L<pouah|https://en.wiktionary.org/wiki/pouah>, que é um onomatopoético
francês que usamos no lugar de "eca" :) eu posso ter um senso de humor
estranho :)

=head2 E as outras ferramentas de tradução para documentação usando gettext?

Até onde eu sei, há somente duas:

=over 

=item B<poxml>

Essa é a ferramenta desenvolvida pelo pessoal do KDE para manipular DocBook
XML. Até onde eu sei, esse foi o primeiro programa a extrair strings para
traduzir de documentação para arquivos PO, e a injetá-las de volta após a
tradução.

Ela só consegue manipular XML e apenas um DTD em particular. Eu fico,
particularmente, não gosto das listas de manipulação, que acabam com um
grande msgid. Quando a lista fica grande, o fragmento se torna mais difícil
de engolir.

=item B<po-debiandoc>

Esse problema desenvolvido por Denis Barbier é uma espécie de precursor do
módulo de SGML do po4a, o qual meio que torna-o (po-debiandoc)
obsoleto. Como o nome já diz, ele linda apenas o DebianDoc DTD, o qual é
meio que um DTD obsoleto.

=back

As principais vantagens do po4a sobre eles é a facilidade de adição de
conteúdo extra (o que é bem pior lá) e a habilidade de alcançar
gettextização.

=head2 RESUMO das vantagens da abordagem baseada em gettext

=over 2

=item 

As traduções não são armazenadas junto do original, o que possibilita
detectar se as traduções estão desatualizadas.

=item 

As traduções são armazenadas em arquivos separados um dos outros, o que
previne tradutores de idiomas diferentes interferir tanto quando da
submissão do patch quanto a nível de codificação do arquivo.

=item 

Ele é internamente baseado no B<gettext> (mas B<po4a> oferece uma interface
bem simples, de forma que você não precisa entender as especificidades para
usá-lo). Dessa forma, nós não temos que reinventar a roda e, por causa do
seu amplo uso, nós podemos pensar que essas ferramentas meio que não tem
erros.

=item 

Nada mudou para o usuário final (além do fato de traduções estarem melhor
mantidas, espero). o arquivo de documentação resultante distribuído é
exatamente o mesmo.

=item 

Não há necessidade de tradutores aprenderem um novo arquivo de sintaxe e seu
editor de arquivos PO (como o modo PO do Emacs, Lokalize ou Gtranslator) vão
funcionar muito bem.

=item 

gettext oferece uma forma simples de obter estatísticas sobre o que está
feito, o que deveria ser revisto e atualizado e o que ainda deve ser
feito. Alguns exemplos podem ser encontrados nesses endereços:

 - https://docs.kde.org/stable5/pt_BR/kdesdk/lokalize/project-view.html
 - http://www.debian.org/intl/l10n/

=back

Mas tudo tem seu lado negativo, e essa abordagem tem algumas desvantagens
com as quais nós temos que lidar.

=over 2

=item 

Adendos são… estranhos à primeira vista.

=item 

Você não pode adaptar o texto traduzido às suas preferências, com divisão de
um parágrafo aqui e juntar outros dois ali. Mas de certa forma, se há um
problema com o original, isso deveria ser relatado como um erro.

=item 

Até mesmo com uma interface fácil, ainda é uma nova ferramenta que as
pessoas precisam aprender.

Um dos meus sonhos seria integrar de alguma forma po4a ao Gtranslator ou
Lokalize. Quando um arquivo de documento fosse aberto, as strings seriam
automaticamente extraídas e um arquivo traduzido + arquivo po poderia ser
gravado no disco. Se nós conseguirmos fazer um módulo para MS Word (TM) (ou
pelo menos RTF), tradutores profissionais podem até mesmo usá-lo.

=back

=head1 VEJA TAMBÉM

=over 

=item 

A documentação da ferramenta multifuncional que você deve usar: L<po4a(1)>.

=item 

A documentação dos scripts individuais do po4a: L<po4a-gettextize(1)>,
L<po4a-updatepo(1)>, L<po4a-translate(1)>, L<po4a-normalize(1)>.

=item 

Os scripts de ajuda adicionais: L<msguntypot(1)>, L<po4a-display-man(1)>,
L<po4a-display-pod(1)>.

=item 

Os analisadores de cada formato, em particular para ver as opções aceitas
por cada um deles: 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)>.

=item 

A implementação da infraestrutura principal:
L<Locale::Po4a::TransTractor(3pm)> (particularmente importante para entender
a organização do código), L<Locale::Po4a::Chooser(3pm)>,
L<Locale::Po4a::Po(3pm)>, L<Locale::Po4a::Common(3pm)>. Por favor, verifique
também o arquivo F<CONTRIBUTING.md> na árvore de fonts.

=back

=head1 AUTORES

 Denis Barbier <barbier,linuxfr.org>
 Martin Quinson (mquinson#debian.org)

