po4a

Autres langues

Langue: pl

Autres versions - même langue

Version: 2008-11-05 (ubuntu - 08/07/09)

Autres sections - même nom

Section: 7 (Divers)

Sommaire

NAZWA

po4a - narzA.Xdzia do tA°XumaczeA°X dokumentacji i innych materiaA°XA~Xw

WstA.Xp

Celem projektu po4a (``po for anything'') jest uA°Xatwienie tA°XumaczeA°X (oraz, co ciekawsze, zarzA.Xdzania tA°Xumaczeniami) przy uA°Xyciu narzA.Xdzi gettext w tych obszarach, gdzie nie byA°Xy uA°Xywane, jak na przykA°Xad w obszarze dokumentacji.

Spis treA°Xci

Dokument jest zorganizowany nastA.XpujA.Xco:
1. Dlaczego powinno siA.X uA°XywaA.X po4a? Jakie sA.X jego zalety?
Ten rozdziaA°X wprowadzenia wyjaA°Xnia motywy i filozofiA.X projektu. JeA°Xeli rozwaA°Xasz uA°Xycie po4a do Twoich tA°XumaczeA°X, powinieneA°X najpierw przeczytaA.X ten rozdziaA°X.
2. Jak uA°XywaA.X po4a?
RozdziaA°X ten jest rodzajem podrA.Xcznika i prA~Xbuje odpowiedzieA.X na pytania uA°XytkownikA~Xw, pozwalajA.Xc lepiej zrozumieA.X caA°Xy proces. Odpowiada, jak wykonaA.X rA~XA°Xne rzeczy w po4a, i sA°XuA°Xy jako wprowadzenie do dokumentacji konkretnych narzA.Xdzi.
JAK zaczA.XA.X nowe tA°Xumaczenie?
JAK zamieniA.X tA°Xumaczenie z powrotem do pliku dokumentacji?
JAK zaktualizowaA.X tA°Xumaczenie programem po4a?
JAK skonwertowaA.X istniejA.Xce tA°Xumaczenia do po4a?
JAK dodaA.X dodatkowy tekst do tA°XumaczeA°X (np. nazwisko tA°Xumacza)?
JAK to wszystko zrobiA.X, wywoA°XujA.Xc tylko jeden program?
3. Jak to dziaA°Xa?
Ten rozdziaA°X zawiera krA~Xtki opis wewnA.Xtrznych mechanizmA~Xw po4a, tak A°Xe bA.Xdziesz miaA°X wiA.Xcej odwagi, aby pomA~Xc nam w jego tworzeniu i udoskonalaniu. MoA°Xe takA°Xe Ci pomA~Xc w zrozumieniu, dlaczego nie dziaA°Xa tak, jak byA°X tego oczekiwaA°X, oraz jak rozwiA.XzaA.X napotkane problemy.
4. FAQ
Ten rozdziaA°X zawiera odpowiedzi na czA.Xsto zadawane pytania. Tak naprawdA.X, wiA.XkszoA°XA.X tych pytaA°X moA°Xe byA.X sformuA°Xowanych jako ``Dlaczego po4a zostaA°Xo zaprojektowane tak, a nie inaczej?''. JeA°Xli wydaje Ci siA.X, A°Xe po4a nie jest wA°XaA°Xciwym narzA.Xdziem do tA°Xumaczenia dokumentacji, powinieneA°X rozwaA°XyA.X przeczytanie tego rozdziaA°Xu. JeA°Xli nie znajdziesz w nim odpowiedzi na swoje pytanie, prosimy siA.X z nami skontaktowaA.X poprzez listA.X dyskusyjnA.X <po4a-devel@lists.alioth.debian.org>. Uwielbiamy znaA.X opinie uA°XytkownikA~Xw.
5. Specyficzne uwagi o moduA°Xach
Ten rozdziaA°X opisuje rzeczy specyficzne dla kaA°Xdego moduA°Xu, z punktu widzenia zarA~Xwno tA°Xumacza, jak i autora oryginalnego dokumentu. CzytajA.Xc ten rozdziaA°X, dowiesz siA.X, kiedy dany moduA°X wykonuje tA°Xumaczenia oraz jakich zasad powinieneA°X przestrzegaA.X, piszA.Xc oryginalny dokument, aby uproA°XciA.X A°Xycie tA°Xumaczom.

W zasadzie, ta sekcja nie jest czA.XA°XciA.X tego dokumentu. Zamiast tego jest umieszczana w dokumentacji kaA°Xdego moduA°Xu. Pomaga to w zapewnieniu aktualnoA°Xci tych informacji, trzymajA.Xc kod i dokumentacjA.X razem.

6. Znane bA°XA.Xdy i A°XA.Xdania nowych funkcjonalnoA°Xci
JuA°X kilka :(

Dlaczego uA°XywaA.X po4a? Do czego jest on przydatny?

Podoba mi siA.X idea wolnego oprogramowania, pozwalajA.Xcego kaA°Xdemu na dostA.Xp do programA~Xw i ich kodA~Xw A°XrA~XdA°Xowych. BA.XdA.Xc jednak Francuzem, jestem A°Xwiadomy tego, A°Xe licencja programu nie jest jedynym ograniczeniem otwartoA°Xci oprogramowania: nieprzetA°Xumaczone oprogramowanie jest bezuA°Xyteczne dla ludzi nieznajA.Xcych angielskiego, wiA.Xc ciA.Xgle czeka na nas duA°Xo pracy, A°Xeby udostA.XpniA.X je kaA°Xdej takiej osobie.

A°XwiadomoA°XA.X tego problemu wA°XrA~Xd osA~Xb zwiA.Xzanych z oprogramowaniem open-source ostatnio znacznie wzrosA°Xa. WygraliA°Xmy, jako tA°Xumacze, pierwszA.X bitwA.X i przekonaliA°Xmy wszystkich o znaczeniu tA°XumaczeA°X. Niestety, to byA°Xa ta A°Xatwiejsza czA.XA°XA.X. Teraz musimy wykonaA.X naszA.X pracA.X i przetA°XumaczyA.X wszystkie te rzeczy.

WA°XaA°Xciwie oprogramowanie typu open-source ma doA°XA.X przyzwoity poziom tA°XumaczeA°X, dziA.Xki wspaniaA°Xemu pakietowi gettext, ktA~Xry ma moA°XliwoA°Xci wyodrA.Xbniania z programu komunikatA~Xw do przetA°Xumaczenia, przekazywania tA°Xumaczom plikA~Xw w jednolitym formacie i uA°Xywania wynikA~Xw ich pracy do pokazywania uA°Xytkownikowi przetA°Xumaczonych komunikatA~Xw w czasie dziaA°Xania programu.

W przypadku dokumentacji sytuacja jest trochA.X inna. Zbyt czA.Xsto siA.X zdarza, A°Xe tA°Xumaczony dokument nie jest dostatecznie widoczny (nie jest dystrybuowany jako czA.XA°XA.X programu), jest tylko czA.XA°Xciowy lub nie jest aktualny. Ostatnia sytuacja jest najgorszA.X z moA°Xliwych. PrzestarzaA°Xe tA°Xumaczenie, opisujA.Xce stare, juA°X nieistniejA.Xce zachowanie programu, moA°Xe byA.X o wiele gorsze dla uA°Xytkownika niA°X brak tA°Xumaczenia w ogA~Xle.

Problem do rozwiA.Xzania

TA°Xumaczenie dokumentacji samo w sobie nie jest zbyt trudne. Teksty sA.X duA°Xo dA°XuA°Xsze niA°X komunikaty wyA°Xwietlane przez program, wiA.Xc ich tA°Xumaczenie zajmuje trochA.X wiA.Xcej czasu, nie wymaga przy tym jednak A°Xadnych umiejA.XtnoA°Xci technicznych. TrudniejszA.X czA.XA°XciA.X pracy jest zarzA.Xdzanie tA°Xumaczeniem. Wykrywanie czA.XA°Xci, ktA~Xre siA.X zmieniA°Xy i powinny byA.X zaktualizowane, jest bardzo trudne, podatne na bA°XA.Xdy i wysoce nieprzyjemne. Najprawdopodobniej wyjaA°Xnia to, dlaczego tak wiele przetA°Xumaczonej dokumentacji nie jest aktualne.

Odpowiedzi po4a

Tak wiA.Xc, celem po4a jest uczynienie tA°XumaczeA°X dokumentacji A°Xatwymi do zarzA.Xdzania. IdeA.X jest wykorzystanie metodologii gettexta na tym nowym polu. Tak jak w programie gettext, teksty sA.X wyodrA.Xbniane z ich oryginalnych miejsc, aby mogA°Xy w jednolitym formacie zostaA.X zaprezentowane tA°Xumaczowi. Klasyczne narzA.Xdzia gettexta pomogA.X im uaktualniA.X ich pracA.X, kiedy pojawi siA.X nowa wersja oryginalnego dokumentu. W przeciwieA°Xstwie zaA°X do klasycznego modelu gettext, tA°Xumaczenia sA.X wstawiane do struktury oryginalnego dokumentu, tak A°Xeby mogA°Xy byA.X przetwarzane i dystrybuowane w dokA°Xadnie taki sam sposA~Xb, co wersja angielska.

DziA.Xki temu staA°Xo siA.X A°Xatwiejsze znalezienie do przetA°Xumaczenia zmienionych czA.XA°Xci dokumentu. Innym plusem jest to, A°Xe w wypadku zasadniczej reorganizacji struktury dokumentu, gdy rozdziaA°Xy sA.X przesuwane, A°XA.Xczone lub dzielone, narzA.Xdzia wykonajA.X prawie caA°XA.X brudnA.X robotA.X. WyodrA.Xbnianie ze struktury dokumentu tekstA~Xw do przetA°Xumaczenia pozwala tA°Xumaczom nie przejmowaA.X siA.X zA°XoA°XonoA°XciA.X struktury dokumentu i zmniejsza szanse otrzymania dokumentu o niepoprawnej strukturze (choA.X zawsze jest to moA°Xliwe).

W sekcji FAQ poniA°Xej opisano kompletnA.X listA.X plusA~Xw i minusA~Xw tego rozwiA.Xzania.

ObsA°Xugiwane formaty

Obecnie rozwiA.Xzanie to zaimplementowano z sukcesem dla kilku formatA~Xw tekstu:

nroff

Format starych, dobrych stron podrA.Xcznika ekranowego, uA°Xywanego przez wiele programA~Xw. ObsA°Xuga tego formatu w po4a jest mile widziana, poniewaA°X ten format jest raczej trudny w uA°Xyciu i niezbyt przyjazny dla nowych uA°XytkownikA~Xw. ModuA°X Locale::Po4a::Man(3pm) obsA°Xuguje rA~XwnieA°X format mdoc,uA°Xywany przez strony podrA.Xcznika systemu BSD (caA°Xkiem czA.Xsto wystA.XpujA.Xcych rA~XwnieA°X pod Linuksem).

pod

Jest to format dokumentacji Perla. W ten sposA~Xb jest udokumentowany sam jA.Xzyk i jego rozszerzenia, a takA°Xe wiA.XkszoA°XA.X istniejA.Xcych skryptA~Xw Perla. A°XA.Xczenie dokumentacji i kodu w jednym pliku, pomaga utrzymywaA.X aktualnoA°XA.X dokumentacji. Upraszcza to A°Xycie programisty, ale niestety, nie tA°Xumacza.

sgml

Nawet jeA°Xli jest obecnie wypierany przez XML, ten format jest wciA.XA°X raczej czA.Xsto uA°Xywany w dokumentach o dA°XugoA°Xci wiA.Xkszej niA°X kilka ekranA~Xw. Pozwala tworzyA.X kompletne ksiA.XA°Xki. Aktualizowane tA°XumaczeA°X tak dA°Xugich dokumentA~Xw moA°Xe byA.X prawdziwym koszmarem. Program diff bardzo czA.Xsto okazuje siA.X bezuA°Xyteczny, jeA°Xli zmieni siA.X struktura oryginalnego tekstu. Na szczA.XA°Xcie, z pomocA.X moA°Xe przyjA°XA.X po4a.

Obecnie obsA°Xugiwane sA.X tylko DTD debiandoc i docbook, ale dodanie obsA°Xugi nowego typu jest bardzo proste. Jest nawet moA°Xliwe uA°Xycie po4a z nieznanym DTD SGML bez zmiany kodu - przez podanie wymaganych informacji w parametrach linii poleceA°X. SzczegA~XA°Xy moA°Xna znaleA°XA.X w Locale::Po4a::Sgml(3pm).

TeX / LaTeX

Format LaTeX jest gA°XA~Xwnym formatem dokumentacji uA°Xywanym w publikacjach pisanych przez ludzi zwiA.Xzanych ze A°Xwiatem wolnego oprogramowania. ModuA°X Locale::Po4a::LaTeX(3pm) byA°X testowany na dokumentacji Pythona, ksiA.XA°Xce i kilku prezentacjach.

texinfo

CaA°Xa dokumentacja GNU jest pisana w tym formacie (i jest to nawet jedno z wymagaA°X stawianych projektom , ktA~Xre chcA.X staA.X siA.X oficjalnymi projektami GNU). Wsparcie dla Locale::Po4a::Texinfo(3pm) jest wciA.XA°X w fazie poczA.Xtkowej. Prosimy o zgA°Xaszanie bA°XA.XdA~Xw i przesyA°Xanie uwag dotyczA.Xcych brakujA.Xcych funkcjonalnoA°Xci.

xml

XML jest formatem bazowym wielu innych formatA~Xw dokumentacji.

Obecnie po4a obsA°Xuguje docbook DTD. SzczegA~XA°Xy moA°Xna znaleA°XA.X w Locale::Po4a::Docbook(3pm).

inne

Po4a moA°Xe takA°Xe obsA°XugiwaA.X kilka rzadszych lub bardziej specjalizowanych formatA~Xw, takich jak dokumentacja opcji kompilacji jA.Xder 2.4 lub diagramA~Xw wyprodukowanych przez narzA.Xdzie dia. Dodanie nowego formatu jest czA.Xsto bardzo proste, a gA°XA~Xwnym zadaniem jest napisanie parsera tego formatu. WiA.Xcej informacji o tym moA°Xna znaleA°XA.X w Locale::Po4a::TransTractor(3pm).

Formaty niewspierane

Niestety, po4a ciA.Xgle nie obsA°Xuguje kilku formatA~Xw dokumentacji.

Istnieje caA°Xa masa innych formatA~Xw, ktA~Xre byA°Xmy chcieli obsA°XugiwaA.X w po4a, i nie sA.X to tylko formaty dokumentacji. W zasadzie, naszym celem jest wypeA°Xnienie wszystkich dziur pozostawionych przez klasyczne narzA.Xdzia gettext. Obejmuje to opisy pakietA~Xw (deb i rpm), pytania skryptA~Xw instalacyjnych pakietA~Xw, logi zmian pakietA~Xw i wszystkie specjalizowane formaty uA°Xywane przez programy, jak na przykA°Xad scenariusze gier lub pliki zasobA~Xw wine.

Jak uA°XywaA.X po4a?

RozdziaA°X ten jest rodzajem podrA.Xcznika i prA~Xbuje odpowiedzieA.X na pytania uA°XytkownikA~Xw, pozwalajA.Xc lepiej zrozumieA.X caA°Xy proces. Odpowiada, jak wykonaA.X rA~XA°Xne rzeczy w po4a, i sA°XuA°Xy jako wprowadzenie do dokumentacji konkretnych narzA.Xdzi.

Graficzne podsumowanie

NastA.XpujA.Xcy schemat pokazuje poglA.Xdowo proces tA°Xumaczenia dokumentacji z uA°Xyciem po4a. Nie powinno siA.X przejmowaA.X jego pozornA.X zA°XoA°XonoA°XciA.X, ktA~Xra wziA.XA°Xa siA.X stA.Xd, A°Xe pokazaliA°Xmy tutaj caA°Xy proces. Po skonwertowaniu projektu do po4a, istotna bA.Xdzie tylko prawa czA.XA°XA.X schematu. ProszA.X zauwaA°XyA.X, A°Xe sgml wystA.Xpuje tu jako przykA°Xad i caA°Xy schemat jest dokA°Xadnie taki sam dla wszystkich moduA°XA~Xw. KaA°XdA.X czA.XA°XA.X rysunku omA~Xwimy szczegA~XA°Xowo w nastA.Xpnych sekcjach. 
   fr.sgml  oryginalny.sgml ---->------+------>----------->-------+
      |         |                      |                          |
      V         V           { aktualizacja oryginaA°Xu }            |
      |         |                      |                          |
      +--<---<--+                      V                          |
      |         |              oryginalny.nowy.sgml ---->---->----+
      V         V                      |                          |
   [po4a-gettextize]      +--->---->---+                          |
      |         |         |            V                          |
      |         |         |     [po4a-updatepo]                   |
      |         V         ^            |                          V
      V    oryginalny.pot |            V                          |
      |         |         |          fr.po                        |
      |         |         |      (niepewny - fuzzy)               |
      |  { tA°Xumaczenie }  |            |                          |
      |         |         ^            V                          V
      |         |         |     {rA.Xczna edycja}                   |
      V         V         |            |                          |
      |         |         |            V                          V
      |         |         +--<---    fr.po     zaA°XA.Xcznik   oryginalny.sgml
      +---->----+---->------->---> (aktualny) (opcjonalny)    (aktualny)
                                       |            |             |
                                       v            v             v
                                       +------>-----+------<------+
                                                    |
                                                    v
                                            [po4a-translate]
                                                    |
                                                    V
                                                 fr.sgml
                                               (aktualny)

Lewa czA.XA°XA.X pokazuje konwersjA.X tA°Xumaczenia nie uA°XywajA.Xcego jeszcze po4a do tego systemu. GA~Xra prawej czA.XA°Xci pokazuje akcje autora oryginaA°Xu (aktualizowanie dokumentacji). A°Xrodek prawej czA.XA°Xci obrazuje automatyczne akcje po4a. Nowy materiaA°X jest wyodrA.Xbniany i porA~Xwnywany z istniejA.Xcymi tA°Xumaczeniami. Znajdowane sA.X czA.XA°Xci, ktA~Xre siA.X nie zmieniA°Xy, i dla nich uA°Xywane jest poprzednie tA°Xumaczenie. CzA.XA°Xci zmodyfikowane tylko w nieznacznym stopniu sA.X takA°Xe A°XA.Xczone z poprzednimi tA°Xumaczeniami, ale dodawany jest specjalny znacznik, mA~XwiA.Xcy, A°Xe tA°Xumaczenie musi byA.X uaktualnione. DA~XA°X rysunku pokazuje sposA~Xb, w jaki jest budowany sformatowany dokument.

WA°XaA°Xciwie, jedynA.X rA.XcznA.X operacjA.X, ktA~XrA.X musi wykonaA.X tA°Xumacz jest czA.XA°XA.X oznaczona {rA.Xczna edycja}. Przykro nam, po4a tylko pomaga tA°XumaczyA.X, ale niestety niczego za Ciebie nie przetA°Xumaczy...

JAK zaczA.XA.X nowe tA°Xumaczenie?

Ta sekcja opisuje kroki niezbA.Xdne do rozpoczA.Xcia nowego tA°Xumaczenia z uA°Xyciem po4a. Konwertowanie istniejA.Xcego projektu do tego systemu opisano w szczegA~XA°Xach w odpowiedniej sekcji.

Aby zaczA.XA.X nowe tA°Xumaczenie, uA°XywajA.Xc po4a, naleA°Xy wykonaA.X nastA.XpujA.Xce kroki:

-
WyciA.XgnA.XA.X tekst do przetA°Xumaczenia z oryginalnego dokumentu do nowego pliku pot (format programu gettext). Aby to zrobiA.X, naleA°Xy wywoA°XaA.X program po4a-gettextize w nastA.XpujA.Xcy sposA~Xb: 
   $ po4a-gettextize -f <format> -m <master.doc> -p <tA°Xumaczenie.pot>

<format> jest oczywiA°Xcie formatem uA°Xywanym w dokumencie <master.doc>. Jak moA°Xna oczekiwaA.X, plikiem wyjA°Xciowym jest <tA°Xumaczenie.pot>. WiA.Xcej szczegA~XA°XA~Xw o dostA.Xpnych opcjach moA°Xna znaleA°XA.X w po4a-gettextize(1).

-
PrzetA°XumaczyA.X to, co jest do przetA°Xumaczenia. W tym celu naleA°Xy zmieniA.X nazwA.X pliku pot na przykA°Xad na doc.XX.po (gdzie XX jest kodem ISO639 jA.Xzyka, na ktA~Xry siA.X tA°Xumaczy, np. ``fr'' dla jA.Xzyka francuskiego) i edytowaA.X powstaA°Xy plik. Zazwyczaj dobrym pomysA°Xem jest nienazywanie tego pliku XX.po, aby uniknA.XA.X pomylenia z tA°Xumaczeniem komunikatA~Xw programu, ale wybA~Xr naleA°Xy do Ciebie. ProszA.X nie zapominaA.X o uaktualnieniu nagA°XA~XwkA~Xw pliku po; sA.X one bardzo waA°Xne.

Do tA°Xumaczenia moA°Xna wykorzystaA.X tryb po Emacsa, program kbabel (oparty na KDE) lub gtranslator (oparty na GNOME) lub jakikolwiek inny program, w zaleA°XnoA°Xci od upodobaA°X tA°Xumacza. MoA°Xna nawet uA°XyA.X dobrego starego edytora vi, mimo A°Xe nie ma on specjalnego trybu uA°XatwiajA.Xcego tA°Xumaczenia.

Aby dowiedzieA.X siA.X czegoA°X wiA.Xcej, stanowczo powinno siA.X przeczytaA.X dokumentacjA.X programu gettext, dostA.XpnA.X w pakiecie gettext-doc.

JAK zamieniA.X tA°Xumaczenie z powrotem do pliku dokumentacji?

Po zakoA°Xczeniu tA°Xumaczenia zapewne naleA°XaA°Xoby wygenerowaA.X przetA°Xumaczone dokumenty i rozdystrybuowaA.X je wA°XrA~Xd uA°XytkownikA~Xw, razem z oryginalnymi dokumentami. Aby to zrobiA.X, naleA°Xy uA°XyA.X programu po4a-translate(1) w ten sposA~Xb (XX jest kodem jA.Xzyka): 
   $ po4a-translate -f <format> -m <master.doc> -p <doc.XX.po> -l <XX.doc>

Jak wczeA°Xniej, <format> jest formatem dokumentu <master.doc>. Jednak tym razem plik po, przekazany w opcji -p, jest czA.XA°XciA.X wejA°Xcia - jest to Twoje tA°Xumaczenie. WyjA°Xcie jest zapisywane w <XX.doc>.

WiA.Xcej szczegA~XA°XA~Xw moA°Xna znaleA°XA.X w <po4a-translate(1)>.

JAK zaktualizowaA.X tA°Xumaczenie programem po4a?

Aby zaktualizowaA.X tA°Xumaczenie, gdy zmieni siA.X oryginalny plik, naleA°Xy uA°XyA.X po4a-updatepo(1) w nastA.XpujA.Xcy sposA~Xb: 
   $ po4a-updatepo -f <format> -m <nowy_oryginalny.doc> -p <istniejA.Xcy.XX.po>

(WiA.Xcej szczegA~XA°XA~Xw moA°Xna znaleA°XA.X w <po4a-updatepo(1)>).

OczywiA°Xcie ta operacja nie spowoduje automagicznego przetA°Xumaczenia nowych akapitA~Xw oryginalnego dokumentu. NaleA°Xy rA.Xcznie uaktualniA.X plik "po". Podobnie naleA°Xy zaktualizowaA.X tA°Xumaczenie akapitA~Xw, ktA~Xre siA.X choA.X trochA.X zmieniA°Xy. Aby mieA.X pewnoA°XA.X, A°Xe A°Xadnego z nich nie ominiesz, zostaA°Xy one zaznaczone jako ``fuzzy'' (niepewne) i zanim po4a-translate bA.Xdzie mA~XgA°X ich uA°XyA.X, to zaznaczenie musi zostaA.X usuniA.Xte. Tak jak w przypadku pierwszego tA°Xumaczenia najlepiej jest uA°XyA.X ulubionego edytora.

Kiedy plik "po" bA.Xdzie znowu aktualny, bez A°Xadnych wpisA~Xw nieprzetA°Xumaczonych lub niepewnych (``fuzzy''), moA°Xna wygenerowaA.X przetA°Xumaczony plik dokumentacji, tak jak to opisano w poprzedniej sekcji.

JAK skonwertowaA.X istniejA.Xce tA°Xumaczenia do po4a?

CzA.Xsto siA.X zdarzaA°Xo, A°Xe tA°XumaczyA°XeA°X dokument rA.Xcznie dopA~Xty, dopA~Xki nie nastA.XpiA°Xa wiA.Xksza reorganizacja oryginalnego dokumentu. W tej sytuacji, po kilku nieprzyjemnych prA~Xbach z diffem lub podobnymi narzA.Xdziami, moA°Xesz zechcieA.X skonwertowaA.X dokument do po4a. OczywiA°Xcie naleA°Xy go skonwertowaA.X tak, aby nie utraciA.X istniejA.Xcych tA°XumaczeA°X. Nie naleA°Xy siA.X obawiaA.X, ten przypadek takA°Xe jest obsA°Xugiwany przez po4a i jest nazywany procesem przechodzenia do formatu gettext.

KluczowA.X kwestiA.X jest to, aby struktura tA°Xumaczonego dokumentu byA°Xa taka sama jak oryginaA°Xu, tak A°Xeby narzA.Xdzia mogA°Xy odpowiednio dopasowaA.X zawartoA°XA.X.

JeA°Xli masz szczA.XA°Xcie (tj. struktura obu dokumentA~Xw dokA°Xadnie do siebie pasuje), wszystko zadziaA°Xa bez A°Xadnego problemu i bA.Xdzie gotowe w ciA.Xgu paru sekund. W przeciwnym razie moA°Xesz zrozumieA.X dlaczego ten proces ma takA.X brzydkA.X nazwA.X i przygotuj siA.X na doA°XA.X nieprzyjemnA.X pracA.X. W kaA°Xdym razie, pamiA.Xtaj, A°Xe jest to cena za komfort, ktA~Xry pA~XA°Xniej dostarczy po4a. Dobre w tym wszystkim jest to, A°Xe trzeba to zrobiA.X tylko raz.

Nie bA.XdA.X siA.X dA°Xugo nad tym rozwodziA°X. Aby uA°XatwiA.X proces, waA°Xne jest znalezienie dokA°Xadnie tej wersji oryginaA°Xu, ktA~Xra byA°Xa przetA°Xumaczona. Najlepiej, jeA°Xli zanotowaA°XeA°X sobie wersjA.X z CVS-u dokumentu uA°Xytego do tA°Xumaczenia i jej nie modyfikowaA°XeA°X w procesie tA°Xumaczenia, tak A°Xe moA°Xesz jej teraz uA°XyA.X.

Nie zadziaA°Xa to dobrze, jeA°Xli uA°Xyje siA.X uaktualnionego tekstu oryginaA°Xu ze starym tA°Xumaczeniem. Pozostaje to moA°Xliwe, ale jest to trudniejsze i naprawdA.X powinno siA.X tego unikaA.X, gdy tylko jest to moA°Xliwe. JeA°Xeli nie udaA°Xo Ci siA.X znaleA°XA.X ponownie starego oryginaA°Xu, to najlepszym rozwiA.Xzaniem jest znalezienie kogoA°X, kto przeprowadzi za Ciebie proces przechodzenia na format gettext (ale, proszA.X, niech nie bA.XdA.X to ja ;).

ByA.X moA°Xe zbytnio w tym momencie dramatyzujA.X. Jednak nawet, gdy proces siA.X nie udaje, pozostaje mimo wszystko szybszA.X drogA.X niA°X tA°Xumaczenie wszystkiego od nowa. UdaA°Xo mi siA.X przepuA°XciA.X przez ten proces francuskie tA°Xumaczenie dokumentacji Perla w ciA.Xgu jednego dnia, nawet wtedy, gdy wszystko szA°Xo A°Xle. ByA°Xo to ponad dwa megabajty tekstu, ktA~Xrego tA°Xumaczenie od nowa trwaA°Xoby miesiA.Xcami lub dA°XuA°Xej.

ProszA.X najpierw pozwoliA.X mi wyjaA°XniA.X podstawy tej procedury, a potem powrA~XcA.X do wskazA~Xwek, co zrobiA.X, gdy proces siA.X nie udaje. Dla lepszego zrozumienia, weA°Xmy jako przykA°Xad ponownie moduA°X sgml, jednak tak naprawdA.X uA°Xyty format nie ma A°Xadnego znaczenia.

Kiedy juA°X zdobA.Xdziesz stary oryginaA°X dokumentu, proces przechodzenia na gettext moA°Xe byA.X tak A°Xatwy, jak:

  $ po4a-gettextize -f <format> -m <stary.oryginaA°X> -l <stare.tA°Xumaczenie> -p <doc.XX.po>

JeA°Xli masz szczA.XA°Xcie, to to wszystko. Stare tA°Xumaczenia zostaA°Xy skonwertowane do po4a i moA°Xna od razu zaczA.XA.X ich aktualizowanie. NaleA°Xy tylko trzymajA.Xc siA.X procedury opisanej kilka sekcji wczeA°Xniej, zsynchronizowaA.X plik po z najnowszym oryginalnym dokumentem i odpowiednio zaktualizowaA.X tA°Xumaczenia.

ProszA.X zauwaA°XyA.X, A°Xe nawet jeA°Xli wydaje siA.X, A°Xe wszystko zadziaA°XaA°Xo poprawnie, moA°Xe siA.X okazaA.X, A°Xe jednak wystA.XpiA°Xy bA°XA.Xdy podczas tego procesu. Po4a nie rozumie przetwarzanych tekstA~Xw, wiA.Xc nie moA°Xe byA.X byA.X pewne, A°Xe tA°Xumaczenia sA.X poprawnie przypisane do oryginaA°XA~Xw. Dlatego wszystkie komunikaty sA.X oznaczone jako ``fuzzy'' (niepewne). Przed usuniA.Xciem tych znacznikA~Xw, proszA.X uwaA°Xnie sprawdziA.X kaA°Xde tA°Xumaczenie.

Bardzo czA.Xsto struktury dokumentA~Xw nie pasujA.X dokA°Xadnie do siebie, przez co po4a-gettextize nie moA°Xe poprawnie wykonaA.X swojego zadania. W tym punkcie gra toczy siA.X o to, aby tak pozmieniaA.X pliki, aby ich cholerne struktury sobie odpowiadaA°Xy.

Pomocne moA°Xe byA.X przeczytanie poniA°Xej sekcji ``Proces przeksztaA°Xcania do formatu gettext: jak to dziaA°Xa?''. Zrozumienie wewnA.Xtrznych procesA~Xw pomoA°Xe wykonaA.X zadanie. Plusem jest to, A°Xe w razie niepowodzenia, po4a-gettextize gA°XoA°Xno powie, co poszA°Xo A°Xle, umoA°XliwiajA.Xc poznanie komunikatA~Xw, ktA~Xre do siebie nie pasowaA°Xy, ich pozycjA.X w tekA°Xcie i typ kaA°Xdego z nich. Co wiA.Xcej, plik po wygenerowany do tej pory, bA.Xdzie zachowany jako gettextization.failed.po.

-
NaleA°Xy usunA.XA.X wszystkie dodatkowe czA.XA°Xci tA°Xumaczenia, takie jak sekcja, w ktA~Xrej podano nazwisko tA°Xumacza i podziA.Xkowania dla wszystkich ludzi, ktA~Xrzy pomagali przy tA°Xumaczeniu. PA~XA°Xniej takie czA.XA°Xci bA.Xdzie moA°Xna z powrotem dodaA.X, uA°XywajA.Xc zaA°XA.XcznikA~Xw, opisanych w nastA.Xpnym rozdziale.
-
Nie wahaj siA.X edytowaA.X zarA~Xwno pliku oryginalnego, jak i jego tA°Xumaczenia. NajwaA°XniejszA.X rzeczA.X jest otrzymanie pliku po. Potem bA.Xdzie moA°Xna go zaktualizowaA.X. Edytowanie tA°XumaczeA°X powinno byA.X jednak preferowane, poniewaA°X uproA°Xci to pewne rzeczy po zakoA°Xczeniu siA.X procesu przeksztaA°Xcania na format gettext.
-
JeA°Xli jest taka potrzeba, naleA°Xy usunA.XA.X kilka czA.XA°Xci oryginalnego dokumentu, ktA~Xre nie sA.X przetA°Xumaczone. PA~XA°Xniej podczas synchronizowania po z dokumentem czA.XA°Xci te siA.X pojawiA.X same.
-
JeA°Xli w niewielkim stopniu zmieniA°XeA°X strukturA.X dokumentu (poA°XA.Xczenie dwA~Xch akapitA~Xw, albo podzielenie innego akapitu), wycofaj te zmiany. JeA°Xli te zmiany miaA°Xy zwiA.Xzek z problemami wystA.XpujA.Xcym w oryginalnym dokumencie, powinieneA°X poinformowaA.X o nich jego autora. KorzyA°Xci z poprawienie ich tylko w Twoim tA°Xumaczeniu bA.Xdzie miaA°Xa tyko czA.XA°XA.X spoA°XecznoA°Xci. Co wiA.Xcej, takie poprawki nie sA.X moA°Xliwe, gdy siA.X uA°Xywa po4a.
-
Czasami zawartoA°Xci akapitA~Xw siA.X zgadzajA.X, ale ich typy nie. Poprawienie tego zaleA°Xy od formatu. W formatach pod i nroff, czA.Xsto bierze siA.X to z tego, A°Xe jeden z tych dwA~Xch akapitA~Xw zawiera liniA.X zaczynajA.XcA.X siA.X od biaA°Xego znaku, a drugi - nie. W tych formatach tekst takich akapitA~Xw nie moA°Xe byA.X zawijany i dlatego wystA.Xpuje niezgodnoA°XA.X typA~Xw. RozwiA.Xzaniem jest usuniA.Xcie spacji. MoA°Xe to byA.X takA°Xe literA~Xwka w nazwie elementu.

Podobnie, dwa akapity mogA.X zostaA.X scalone razem w formacie pod, jeA°Xeli rozdzielajA.Xca linia zawiera spacje lub kiedy brakuje pustej linii przed liniA.X ==item i zawartoA°XciA.X tego elementu.

-
Czasami wystA.Xpuje rozsynchronizowanie miA.Xdzy plikami i tA°Xumaczenie jest przypisane do zA°Xego akapitu oryginaA°Xu. Jest to oznaka, A°Xe w rzeczywistoA°Xci problem leA°Xy w plikach. ProszA.X znaleA°XA.X w gettextization.failed.po miejsce, gdzie zaczyna siA.X rozsynchronizowanie, a nastA.Xpnie poprawiA.X w tym miejscu pliki wejA°Xciowe.
-
Czasami moA°Xe siA.X wydawaA.X, A°Xe po4a zjadA°Xo jakA.XA°X czA.XA°XA.X tekstu albo z oryginaA°Xu, albo z tA°Xumaczenia. gettextization.failed.po wskazuje, A°Xe oba pliki dokA°Xadnie do siebie pasowaA°Xy, a przetwarzanie koA°Xczy siA.X bA°XA.Xdem poniewaA°X nastA.XpiA°Xa prA~Xba dopasowania jakiegoA°X akapitu do akapitu po (lub przed) tym wA°XaA°Xciwym, tak jakby ten wA°XaA°Xciwy siA.X ulotniA°X. MoA°Xna tylko klA.XA.X na po4a, tak jak ja klA.XA°Xem, gdy mi siA.X to zdarzyA°Xo po raz pierwszy. Serio.

Ta nieszczA.XA°Xliwa sytuacja zdarza siA.X, kiedy ten sam akapit jest powtA~Xrzony w dokumencie. W tym przypadku nie jest tworzony nowy wpis w pliku po, ale dodawane jest tylko nowe odwoA°Xanie do juA°X istniejA.Xcego wpisu.

Tak wiA.Xc, kiedy ten sam akapit pojawia siA.X dwa razy w oryginalnym dokumencie, ale nie jest przetA°Xumaczony w dokA°Xadnie ten sam sposA~Xb, moA°Xna mieA.X wraA°Xenie, A°Xe ten akapit oryginaA°Xu zniknA.XA°X. Wystarczy usunA.XA.X nowe tA°Xumaczenie. JeA°Xli preferowaA°XbyA°X usuniA.Xcie pierwszego z tych tA°XumaczeA°X, bo drugie jest lepsze, po prostu przenieA°X drugie tA°Xumaczenie w miejsce pierwszego.

Odwrotnie, jeA°Xli dwa podobne, ale jednak rA~XA°Xne, akapity byA°Xy przetA°Xumaczone dokA°Xadnie tak samo, to jeden akapit tA°Xumaczenia zniknie. RozwiA.Xzaniem jest dodanie gA°Xupiego tekstu do oryginalnego akapitu (takiego jak ``rA~XA°XniA.X siA.X''). Nie trzeba siA.X tego baA.X, takie rzeczy zniknA.X podczas synchronizacji, a kiedy taki tekst jest wystarczajA.Xco krA~Xtki, gettext dopasuje Twoje tA°Xumaczenie do istniejA.Xcego tekstu (oznaczajA.Xc je jako niepewne [``fuzzy''], czym nie powinno siA.X przejmowaA.X, gdyA°X wszystkie komunikaty sA.X tak oznaczone zaraz po procesie przeksztaA°Xcania na format gettext).

Mamy nadziejA.X, A°Xe te porady pomogA.X w procesie przeksztaA°Xcania do formatu gettext i w otrzymaniu pliku po. MoA°Xna teraz ten plik zsynchronizowaA.X i zaczA.XA.X go tA°XumaczyA.X. ProszA.X zauwaA°XyA.X, A°Xe w wypadku dA°Xugich plikA~Xw, pierwsza synchronizacja moA°Xe zajA.XA.X duA°Xo czasu.

Na przykA°Xad, pierwsze wykonanie po4a-updatepo na francuskim tA°Xumaczeniu dokumentacji Perla (plik po o rozmiarze 5.5 Mb) zajA.XA°Xo okoA°Xo dwA~Xch dni na komputerze 1Ghz G5. Tak, 48 godzin. Ale kolejne zajmujA.X tylko kilkanaA°Xcie sekund na moim starym laptopie. Dzieje siA.X tak, poniewaA°X na samym poczA.Xtku wiA.XkszoA°XA.X msgid pliku po nie pasuje do A°Xadnego msgid w pliku pot. Wymusza to na programie gettext wyszukiwanie najbardziej zbliA°Xonego msgid, uA°XywajA.Xc kosztownego algorytmu bliskoA°Xci A°XaA°XcuchA~Xw znakA~Xw.

JAK dodaA.X dodatkowy tekst do tA°XumaczeA°X (np. nazwisko tA°Xumacza)?

Z powodu rozwiA.XzaA°X stosowanych przez gettext, zrobienie tego moA°Xe byA.X trudniejsze w po4a niA°X byA°Xo wczeA°Xniej, kiedy to plik byA°X po prostu rA.Xcznie edytowany. Jednak pozostaje to moA°Xliwe, dziA.Xki tak zwanym zaA°XA.Xcznikom.

Dla lepszego zrozumienia moA°Xna przyjA.XA.X, A°Xe zaA°XA.Xczniki sA.X rodzajem A°Xat (patch) aplikowanych do przetA°Xumaczonego dokumentu po zakoA°Xczeniu przetwarzania. RA~XA°XniA.X siA.X one od zwykA°Xych A°Xat (majA.X tylko jednA.X liniA.X kontekstu, ktA~Xra moA°Xe zawieraA.X wyraA°Xenie regularne Perla, i mogA.X tylko dodawaA.X nowy tekst bez usuwania czegokolwiek), ale funkcjonalnoA°XA.X jest taka sama.

Celem jest danie tA°Xumaczowi moA°XliwoA°Xci doA°XA.Xczenie do dokumentu dodatkowej zawartoA°Xci, ktA~Xra nie jest tA°Xumaczeniem oryginalnego dokumentu. NajczA.XA°Xciej uA°Xywany jest do dodawania sekcji dotyczA.Xcej samego tA°Xumaczenia, wypisania wspA~XA°XpracownikA~Xw lub podania sposobu zgA°Xaszania bA°XA.XdA~Xw znalezionych w tA°Xumaczeniu.

ZaA°XA.Xcznik musi byA.X podany jako osobny plik, ktA~Xrego pierwsza linia zawiera nagA°XA~Xwek okreA°XlajA.Xcy, gdzie naleA°Xy umieA°XciA.X tekst zaA°XA.Xcznika. Reszta pliku zaA°XA.Xcznika bA.Xdzie umieszczona bez zmian w okreA°Xlonej pozycji wynikowego dokumentu.

SkA°Xadnia nagA°XA~Xwka jest caA°Xkiem sztywna: musi zaczynaA.X siA.X od tekstu ``PO4A-HEADER:'' poprzedzajA.Xcego rozdzielonA.X A°Xrednikami (;) listA.X pA~Xl ``klucz=wartoA°XA.X''. Spacje SA.X istotne. ProszA.X zauwaA°XyA.X, A°Xe nie moA°Xna uA°XyA.X A°XrednikA~Xw (;) w wartoA°Xci, a ich cytowanie za pomocA.X odwrotnego ukoA°Xnika nie pomaga.

Tak, brzmi to strasznie, ale poniA°Xsze przykA°Xady powinny pomA~Xc w napisaniu odpowiedniej linii nagA°XA~Xwka. Aby zilustrowaA.X dyskusjA.X, zaA°XA~XA°Xmy, A°Xe chcemy dodaA.X sekcjA.X ``O tA°Xumaczeniu'' zaraz po sekcji ``O dokumencie''.

Kilka moA°Xliwych kluczy nagA°XA~Xwka:

position (obowiA.Xzkowe)
wyraA°Xenie regularne. ZaA°XA.Xcznik bA.Xdzie umieszczony w pobliA°Xu linii pasujA.Xcej do wyraA°Xenia regularnego. ProszA.X zauwaA°XyA.X, A°Xe mA~Xwimy tutaj o dokumencie przetA°Xumaczonym, a nie o oryginale. JeA°Xli wiA.Xcej niA°X jedna linia pasuje do tego wyraA°Xenia, dodawanie zaA°XA.Xcznika siA.X nie powiedzie. Istotnie, lepiej jest zgA°XosiA.X bA°XA.Xd niA°X wstawiA.X zaA°XA.Xcznik w nieodpowiednie miejsc.

TA.X liniA.X bA.Xdziemy dalej nazywaA.X punktem pozycji. Punkt, w ktA~Xrym zaA°XA.Xcznik jest dodawany nazwiemy punktem wstawienia. Te dwa punkty sA.X blisko siebie, ale nie sA.X sobie rA~Xwne. Na przykA°Xad, aby dodaA.X nowA.X sekcjA.X A°Xatwiej zaczepiA.X punkt pozycji na tytule poprzedniej sekcji i wytA°XumaczyA.X programowi po4a, gdzie ta sekcja siA.X koA°Xczy (naleA°Xy pamiA.XtaA.X, A°Xe punkt pozycji jest podany przez wyraA°Xenie regularne, ktA~Xre powinno dopasowywaA.X siA.X do pojedynczej linii).

ZaleA°XnoA°XA.X miejsca punktu wstawienia w stosunku do punkty pozycji jest okreA°Xlana przez pola "mode", "beginboundary" i "endboundary", opisane poniA°Xej.

W naszym przypadku byA°Xoby to:

      position=<title>O dokumencie</title>
mode (obowiA.Xzkowe)
MoA°Xe byA.X to jeden z nastA.XpujA.Xcych A°XaA°XcuchA~Xw znakA~Xw: ``before'' (= przed) lub ``after'' (= po), okreA°XlajA.Xcych pozycjA.X dodatku w stosunku do punktu pozycji.

PoniewaA°X chcemy nowA.X sekcjA.X umieA°XciA.X pod tA.X, ktA~XrA.X wyszukaliA°Xmy, mamy:

      mode=after
beginboundary (uA°Xywany, gdy mode=after i obowiA.Xzkowy w tym wypadku)
endboundary (jak wyA°Xej)
wyraA°Xenie regularne pasujA.Xce do koA°Xca sekcji, po ktA~Xrej jest dodawany zaA°XA.Xcznik.

W trybie ``after'' punkt wstawienia jest za punktem pozycji, ale nie bezpoA°Xrednio za! Jest on umieszczony na koA°Xcu sekcji zaczynajA.Xcej siA.X w punkcie pozycji, czyli za albo przed liniA.X pasujA.XcA.X do argumentu "???boundary" w zaleA°XnoA°Xci od tego, czy byA°Xo uA°Xyte "beginboundary", czy "endboundary".

W rozpatrywanym przypadku moA°Xemy wybraA.X wskazanie koA°Xca dopasowywanej sekcji, dodajA.Xc:

    endboundary=</section>

albo moA°Xemy wskazaA.X poczA.Xtek kolejnej sekcji w nastA.XpujA.Xcy sposA~Xb:

    beginboundary=<section>

W obu wypadkach zaA°XA.Xcznik bA.Xdzie umieszczony po </section>, a przed <section>. Ten pierwszy sposA~Xb dziaA°Xa lepiej, poniewaA°X zadziaA°Xa nawet wtedy, gdy dokument zostanie zreorganizowany.

Obie formy istniejA.X poniewaA°X formaty dokumentacji sA.X rA~XA°Xne. NiektA~Xre z nich zawierajA.X znacznik koA°Xca sekcji (tak jak "</section>", ktA~Xrej wA°XaA°Xnie uA°XyliA°Xmy), a inne (np. nroff) tego koA°Xca nie oznaczajA.X w A°Xaden szczegA~Xlny sposA~Xb. W pierwszym przypadku boundary powinno odpowiadaA.X koA°Xcowi sekcji, tak A°Xe punkt wstawienia nastA.Xpuje po niej. W drugim przypadku boundary powinno pasowaA.X do poczA.Xtku nastA.Xpnej sekcji, a punkt wstawienia powinien byA.X umieszczony zaraz przed niA.X.

MoA°Xe siA.X to wydawaA.X niejasne, nastA.Xpne przykA°Xady powinny co nieco wyklarowaA.X.

PodsumowujA.Xc przykA°Xady podane do tej pory: aby dodaA.X sekcjA.X "O tA°Xumaczeniu" po sekcji "O dokumencie" w dokumencie sgml, naleA°Xy uA°XyA.X jednej z poniA°Xszych linii nagA°XA~Xwka:
  PO4A-HEADER: mode=after; position=O dokumencie; endboundary=</section>
  PO4A-HEADER: mode=after; position=O dokumencie; beginboundary=<section>
Aby dodaA.X coA°X po nastA.XpujA.Xcej sekcji nroff:
   .SH "AUTORZY"

powinno siA.X ustawiA.X "positon" pasujA.Xce do tej linii oraz "beginboundary" pasujA.Xce do poczA.Xtku nastA.Xpnej sekcji (tj. "^\.SH"). ZaA°XA.Xcznik zostanie dodany po punkcie pozycji i zaraz przed pierwszA.X liniA.X pasujA.XcA.X do "beginboundary". Czyli:

  PO4A-HEADER:mode=after;position=AUTORZY;beginboundary=\.SH
Aby zamiast dodawaA.X caA°XA.X sekcjA.X, dodaA.X coA°X do jakiejA°X sekcji (np. po "Copyright Big Dude"), trzeba podaA.X "position" pasujA.Xce do tej linii i "beginboundary" pasujA.Xce do jakiejkolwiek linii.
  PO4A-HEADER:mode=after;position=Copyright Big Dude, 2004;beginboundary=^
Aby dodaA.X coA°X na koA°Xcu dokumentu, naleA°Xy podaA.X "position" pasujA.Xce do jakiejkolwiek linii pliku (ale tylko jednej linii. Po4a nie przetworzy tego, jeA°Xli linia nie bA.Xdzie unikatowa) i podaA.X "endboundary" nie pasujA.Xce do niczego. Nie naleA°Xy uA°XywaA.X tutaj prostych tekstA~Xw jak ""EOF"", tylko takich, ktA~Xre majA.X maA°Xe szanse pojawienia siA.X w dokumencie.
  PO4A-HEADER:mode=after;position=<title>O dokumencie</title>;beginboundary=NieistniejA.XaLiniaPo4a

W kaA°Xdym wypadku naleA°Xy pamiA.XtaA.X, A°Xe sA.X to wyraA°Xenia regularne. Na przykA°Xad, aby dopasowaA.X koniec sekcji nroff, koA°XczA.Xcej siA.X liniA.X

   .fi

nie naleA°Xy uA°XywaA.X ".fi" jako endboundary, poniewaA°X bA.Xdzie on pasowaA°X do ``the[ fi]le'' co raczej nie jest tym, czego moA°Xna by oczekiwaA.X. Poprawnym endboundary w tym przypadku jest "^\.fi$".

JeA°Xli zaA°XA.Xcznik nie trafiA°X tam, gdzie powinien, sprA~Xbuj przekazaA.X narzA.Xdziom po4a argument -vv, ktA~Xry powinien pomA~Xc wyjaA°XniA.X co siA.X dzieje podczas dodawania zaA°XA.Xcznika.

Bardziej szczegA~XA°Xowy przykA°Xad

Oryginalny dokument (w formacie pod):

  |=head1 NAZWA
  |
  |dummy - fikcyjny program
  |
  |=head1 AUTOR
  |
  |ja

Wtedy nastA.XpujA.Xcy dodatek spowoduje dodanie sekcji (w jA.Xzyku francuskim) na koniec tego pliku (w jA.Xz. francuskim ``TRADUCTEUR'' oznacza ``TA°XUMACZ'', a ``moi'' znaczy ``ja'')

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

Aby umieA°XciA.X dodatek przed sekcjA.X AUTOR, naleA°Xy uA°XyA.X nastA.XpujA.Xcego nagA°XA~Xwka:

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

To dziaA°Xa, poniewaA°X nastA.XpnA.X liniA.X pasujA.XcA.X do beginboundary /^=head1/ po sekcji ``NAZWA'' (przetA°Xumaczonej na francuskie ``NOM'') jest linia opisujA.Xca autorA~Xw. Tak wiA.Xc zaA°XA.Xcznik zostanie umieszczony pomiA.Xdzy obiema sekcjami.

JAK to wszystko zrobiA.X, wywoA°XujA.Xc tylko jeden program?

UA°Xytkownicy udowodnili, A°Xe takie uA°Xycie po4a jest naraA°Xone na bA°XA.Xdy, poniewaA°X naleA°Xy we wA°XaA°Xciwym porzA.Xdku wywoA°XaA.X dwa rA~XA°Xne programy (po4a-updatepo, a nastA.Xpnie po4a-translate), z ktA~Xrych kaA°Xdy wymaga podania wiA.Xcej niA°X 3 argumentA~Xw. Co wiA.Xcej, w tym systemie byA°Xo trudno uA°XyA.X tylko jednego pliku po dla wszystkich dokumentA~Xw, kiedy uA°Xyto wiA.Xcej niA°X jednego formatu.

Program po4a(1) zaprojektowano, aby rozwiA.XzaA.X te trudnoA°Xci. Kiedy tylko projekt zostanie skonwertowany do tego systemu, moA°Xna napisaA.X prosty plik konfiguracyjny opisujA.Xcy miejsce poA°XoA°Xenia plikA~Xw tA°XumaczeA°X (po i pot) i oryginalnych dokumentA~Xw, ich formaty oraz miejsce, gdzie powinny trafiaA.X przetA°Xumaczone dokumenty.

Uruchomienie po4a(1) na tym pliku spowoduje zsynchronizowanie wszystkich plikA~Xw po z oryginalnym dokumentem, tak A°Xeby przetA°Xumaczony dokument zostaA°X poprawnie wygenerowany. OczywiA°Xcie naleA°Xy ten program wywoA°XaA.X dwa razy: raz przed edytowaniem pliku po, A°Xeby go zaktualizowaA.X, i raz po jego edycji, aby otrzymaA.X caA°Xkowicie aktualny przetA°Xumaczony dokument . Tylko A°Xe potrzebujesz zapamiA.XtaA.X tylko jednA.X komendA.X linii poleceA°X.

Jak to dziaA°Xa?

Ten rozdziaA°X zawiera krA~Xtki opis wewnA.Xtrznych mechanizmA~Xw po4a, tak A°Xe bA.Xdziesz miaA°X wiA.Xcej odwagi, aby pomA~Xc nam w jego tworzeniu i udoskonalaniu. MoA°Xe takA°Xe Ci pomA~Xc w zrozumieniu, dlaczego nie dziaA°Xa tak, jak byA°X tego oczekiwaA°X, oraz jak rozwiA.XzaA.X napotkane problemy.

Jaki jest tu duA°Xy obrazek?

Architektura po4a jest zorientowana obiektowo (w Perlu, czy to nie eleganckie?). WspA~Xlny przodek wszystkich klas parserA~Xw zwie siA.X TransTractor. Ta dziwna nazwa wziA.XA°Xa siA.X stA.Xd, A°Xe jest on odpowiedzialny za tA°Xumaczenie dokumentu i wydobywanie komunikatA~Xw.

Bardziej formalnie mA~XwiA.Xc, pobiera dokument do przetA°Xumaczenia oraz plik po zawierajA.Xcy tA°Xumaczenia uA°Xywany jako wejA°Xcie podczas tworzenia dwA~Xch oddzielnych plikA~Xw wyjA°Xciowych: innego pliku po (wyniku wyodrA.Xbniania komunikatA~Xw z dokumentu wejA°Xciowego) oraz przetA°Xumaczonego dokumentu (majA.Xcego takA.X samA.X strukturA.X jak plik wejA°Xciowy, ale ze wszystkimi komunikatami zamienionymi na zawartoA°XA.X wejA°Xciowego pliku po). PoniA°Xej jest graficzne przedstawienie tego procesu:

    Dokument wejA°Xciowy -\                          /-> Dokument wyjA°Xciowy
                         \      TransTractor::    /    (przetA°Xumaczony)
                          +-->--   parse()  --- -+
                         /                        \
    WejA°Xciowy po -------/                          \---> WyjA°Xciowy po
                                                         (wyodrA.Xbniony)

Ta maA°Xa koA°XA.X jest podstawA.X caA°Xej architektury po4a. JeA°Xli pominiesz wejA°Xciowy plik po i dokument wyjA°Xciowy, otrzymasz po4a-gettextize. JeA°Xli podasz oba pliki wejA°Xciowe i zlekcewaA°Xysz wyjA°Xciowy plik po, otrzymasz po4a-translate.

TransTractor::parse() jest wirtualnA.X funkcjA.X zaimplementowanA.X w kaA°Xdym module. Tutaj podano prosty przykA°Xad, A°Xeby zobrazowaA.X jej dziaA°Xanie. Przetwarza listA.X akapitA~Xw, z ktA~Xrych kaA°Xdy zaczyna siA.X od <p>.

   1 sub parse {
   2   PARAGRAPH: while (1) {
   3     $my ($paragraph,$pararef,$line,$lref)=("","","","");
   4     $my $first=1;
   5     while (($line,$lref)=$document->shiftline() && defined($line)) {
   6       if ($line =~ m/<p>/ && !$first--; ) {
   7         $document->unshiftline($line,$lref);
   8
   9         $paragraph =~ s/^<p>//s;
  10         $document->pushline("<p>".$document->translate($paragraph,$pararef));
  11
  12         next PARAGRAPH;
  13       } else {
  14         $paragraph .= $line;
  15         $pararef = $lref unless(length($pararef));
  16       }
  17     }
  18     return; # Nie otrzymano linii? Koniec pliku wejA°Xciowego.
  19   }
  20 }

W linii 6. po raz drugi napotkaliA°Xmy <p>. Oznacza to kolejny akapit. PowinniA°Xmy dlatego zwrA~XciA.X otrzymanA.X liniA.X do oryginalnego dokumentu (linia 7.), a na wyjA°Xcie doA°XoA°XyA.X akapit zbudowany do tej pory. Po usuniA.Xciu z niego poczA.Xtkowego <p> w linii 9., dokA°Xadamy ten element poA°XA.Xczony z tA°Xumaczeniem reszty akapitu.

Funkcja translate() jest bardzo fajna (cool ;)). Dodaje swoje argumenty na koniec wynikowego pliku po (ekstrakcja) i zwraca ich tA°Xumaczenie, znalezione w wejA°Xciowym pliku po (tA°Xumaczenie). PoniewaA°X jest uA°Xywana jako czA.XA°XA.X argumentu pushline(), tA°Xumaczenie lA.Xduje w wynikowym dokumencie.

Czy to nie jest fajne? Jest moA°Xliwe zbudowanie kompletnego moduA°Xu po4a w mniej niA°X 20 liniach, jeA°Xeli tylko format jest wystarczajA.Xco prosty...

WiA.Xcej informacji o tym moA°Xna znaleA°XA.X w Locale::Po4a::TransTractor(3pm).

Proces przeksztaA°Xcania do formatu gettext: jak to dziaA°Xa?

Idea jest nastA.XpujA.Xca: pobranie oryginalnego dokumentu i jego tA°Xumaczenia i powiedzenie, A°Xe n-ty komunikat wyodrA.Xbniony z tA°Xumaczenia jest tA°Xumaczeniem n-tego komunikatu wyodrA.Xbnionego z oryginaA°Xu. Aby to zadziaA°XaA°Xo, oba pliki muszA.X mieA.X dokA°Xadnie takA.X samA.X strukturA.X. Na przykA°Xad, jeA°Xeli pliki majA.X poniA°XszA.X strukturA.X, to jest raczej niemoA°Xliwe, by 4. komunikat tA°Xumaczenia (typu ``rozdziaA°X'') byA°X tA°Xumaczeniem 4. komunikatu oryginaA°Xu (typu ``akapit''). 
    OryginaA°X         TA°Xumaczenie
 
    rozdziaA°X          rozdziaA°X
       akapit            akapit
       akapit            akapit
       akapit         rozdziaA°X
    rozdziaA°X             akapit
       akapit            akapit

Aby to osiA.XgnA.XA.X, parsery po4a sA.X uA°Xywane zarA~Xwno na pliku oryginaA°Xu, jak i tA°Xumaczenia, A°Xeby utworzyA.X pliki po, a nastA.Xpnie jest budowany z nich trzeci plik po zawierajA.Xcy komunikaty z drugiego pliku jako tA°Xumaczenia komunikatA~Xw z pierwszego. Aby sprawdziA.X, A°Xe komunikaty, ktA~Xre ze sobA.X A°XA.Xczymy, sA.X rzeczywiA°Xcie odpowiadajA.Xcymi sobie tA°Xumaczeniami, parsesy dokumentA~Xw w po4a powinny umieszczaA.X informacje o typach skA°Xadniowych komunikatA~Xw wyodrA.Xbnionych z dokumentu (wszystkie istniejA.Xce to robiA.X, TwA~Xj teA°X powinien). NastA.Xpnie te informacje sA.X uA°Xywane do sprawdzenia, A°Xe oba dokumenty majA.X tA.X samA.X skA°XadniA.X. W poprzednim przykA°Xadzie pozwoliA°Xo nam to wykryA.X, A°Xe 4. komunikat jest w jednym przypadku akapitem, a w drugim - tytuA°Xem rozdziaA°Xu i zgA°XosiA.X problem.

Teoretycznie byA°Xoby moA°Xliwe zsynchronizowanie plikA~Xw po wykryciu problemu (tak, jak to robi diff). Niestety, nie jest jasne, co zrobiA.X z komunikatami, ktA~Xre nie wystA.XpujA.Xc w jednym z plikA~Xw, byA°Xy przyczynA.X rozsynchronizowania. Dlatego obecna implementacja nie stara siA.X synchronizowaA.X plikA~Xw i zgA°Xasza bA°XA.Xd, kiedy coA°X poszA°Xo A°Xle, wymagajA.Xc od uA°Xytkownika rA.Xcznego zmodyfikowania plikA~Xw w celu rozwiA.Xzania problemu.

Nawet z tymi zabezpieczeniami, rzeczy mogA.X A°Xle siA.X potoczyA.X. WA°XaA°Xnie dlatego wszystkie tA°Xumaczenia odgadniA.Xte w ten sposA~Xb sA.X zaznaczane jako niepewne (``fuzzy''), aby tA°Xumacz je przejrzaA°X i sprawdziA°X.

ZaA°XA.Xcznik: Jak to dziaA°Xa?

Hmm, to caA°Xkiem proste. TA°Xumaczony dokument nie jest bezpoA°Xrednio zapisywany na dysk, ale trzymany w pamiA.Xci, dopA~Xki wszystkie zaA°XA.Xczniki nie zostanA.X dodane. Wykorzystane algorytmy sA.X raczej proste. Szukamy linii pasujA.Xcej do wyraA°Xenia regularnego okreA°XlajA.Xcego pozycjA.X i dodajemy zaA°XA.Xcznik przed tA.X linA.X, jeA°Xli tryb = before. JeA°Xli nie jesteA°Xmy w tym trybie, to szukamy nastA.Xpnej linii pasujA.Xcej do ograniczenia i wstawiamy zaA°XA.Xcznik po tej linii, jeA°Xli jest to "endboundary", lub przed niA.X, jeA°Xli jest to "beginboundary".

FAQ

Ten rozdziaA°X zawiera odpowiedzi na czA.Xsto zadawane pytania. Tak naprawdA.X, wiA.XkszoA°XA.X tych pytaA°X moA°Xe byA.X sformuA°Xowanych jako ``Dlaczego po4a zostaA°Xo zaprojektowane tak, a nie inaczej?''. JeA°Xli wydaje Ci siA.X, A°Xe po4a nie jest wA°XaA°Xciwym narzA.Xdziem do tA°Xumaczenia dokumentacji, powinieneA°X rozwaA°XyA.X przeczytanie tego rozdziaA°Xu. JeA°Xli nie znajdziesz w nim odpowiedzi na swoje pytanie, prosimy siA.X z nami skontaktowaA.X poprzez listA.X dyskusyjnA.X <po4a-devel@lists.alioth.debian.org>. Uwielbiamy znaA.X opinie uA°XytkownikA~Xw.

Dlaczego trzeba tA°XumaczyA.X kaA°Xdy akapit osobno?

Tak, w po4a, kaA°Xdy akapit jest tA°Xumaczony osobno (w zasadzie, to kaA°Xdy moduA°X o tym decyduje, ale wszystkie istniejA.Xce moduA°Xy tak robiA.X i TwA~Xj takA°Xe powinien). SA.X dwie gA°XA~Xwne przyczyny takiego rozwiA.Xzania:
•
Kiedy techniczne czA.XA°Xci dokumentu sA.X ukryte, tA°Xumacz nie moA°Xe w nich zrobiA.X baA°Xaganu. Im mniej znacznikA~Xw pokazujemy tA°Xumaczowi, tym mniej bA°XA.XdA~Xw moA°Xe popeA°XniA.X.
•
Przycinanie dokumentu pomaga odizolowaA.X zmiany w oryginalnym dokumencie. Kiedy oryginaA°X zostanie zmieniony, ten proces uproA°Xci wyszukanie czA.XA°Xci tA°XumaczeA°X potrzebujA.Xcych aktualizacji.

Nawet biorA.Xc pod uwagA.X te plusy, niektA~Xrym ludziom nie podoba siA.X osobne tA°Xumaczenie kaA°Xdego akapitu. Postaram siA.X odpowiedzieA.X na ich obawy:

•
Takie podejA°Xcie sprawdziA°Xo siA.X w projekcie KDE, pozwalajA.Xc temu zespoA°Xowi na wyprodukowanie znacznej iloA°Xci przetA°Xumaczonej i aktualnej dokumentacji.
•
TA°Xumacze mogA.X wciA.XA°X uA°XywaA.X kontekstu tA°Xumaczenia, poniewaA°X wszystkie komunikaty w pliku po sA.X w takiej samej kolejnoA°Xci jak w oryginalnym dokumencie. TA°Xumaczenie sekwencyjne jest podobne, niezaleA°Xnie, czy uA°Xywa siA.X po4a czy nie. I w kaA°Xdym wypadku najlepszym sposobem otrzymania kontekstu pozostaje skonwertowanie dokumentu do formatu dokumentu drukowanego, poniewaA°X formaty A°XrA~XdA°Xowe tekstu mogA.X nie byA.X zbyt czytelne.
•
Takie podejA°Xcie jest uA°Xywany przez profesjonalnych tA°Xumaczy. Zgadzam siA.X, majA.X oni trochA.X inne cele niA°X tA°Xumacze oprogramowania open-source. Na przykA°Xad moA°XliwoA°XA.X A°Xatwego zarzA.Xdzania tA°Xumaczeniem jest czA.Xsto dla nich mniej istotna, poniewaA°X zawartoA°XA.X rzadko siA.X zmienia.

Dlaczego nie podzieliA.X na zdania (lub mniejsze czA.XA°Xci)?

Profesjonalne narzA.Xdzie tA°Xumaczy czasami dzielA.X dokument na poszczegA~Xlne zdania, aby zmaksymalizowaA.X wykorzystanie wczeA°Xniejszych tA°XumaczeA°X i zwiA.XkszyA.X szybkoA°XA.X tA°Xumaczenia. Problemem jest jednak to, A°Xe w zaleA°XnoA°Xci od kontekstu to samo zdanie moA°Xe mieA.X kilka tA°XumaczeA°X.

Akapity sA.X z definicji dA°XuA°Xsze niA°X zdania. JeA°Xeli w dwA~Xch dokumentach ten sam akapit wystA.Xpuje, to moA°Xemy zaA°XoA°XyA.X, A°Xe jego znaczenie (i tA°Xumaczenie) jest takie samo, niezaleA°Xnie od kontekstu.

Dzielenie na czA.XA°Xci mniejsze niA°X zdania byA°Xoby czymA°X bardzo niedobrym. Za duA°Xo miejsca by zajA.XA°Xo napisanie tu wyjaA°Xnienie dlaczego, ale zainteresowany czytelnik moA°Xe na przykA°Xad przeczytaA.X stronA.X podrA.Xcznika Locale::Maketext::TPJ13(3pm) (pochodzA.XcA.X z dokumentacji Perla). W skrA~Xcie, kaA°Xdy jA.Xzyk ma okreA°Xlone zasady skA°Xadniowe i nie istnieje taki sposA~Xb budowania zdaA°X przez A°XA.Xczenie ich czA.XA°Xci, ktA~Xry by dziaA°XaA°X dla wszystkich istniejA.Xcych jA.XzykA~Xw (lub nawet dla tylko 5 czy 10 najpopularniejszych).

Dlaczego nie umieA°XciA.X oryginaA°Xu jako komentarza do tA°Xumaczenia (lub w inny sposA~Xb)?

Na pierwszy rzut oka gettext nie wydaje siA.X byA.X przeznaczony do wszystkich rodzajA~Xw tA°XumaczeA°X. Na przykA°Xad nie wydawaA°X siA.X on byA.X przystosowany do debconfa, interfejsu wszystkich pakietA~Xw Debiana uA°Xywanego do interakcji z uA°Xytkownikiem podczas instalacji. W tym przypadku teksty do tA°Xumaczenia byA°Xy caA°Xkiem krA~Xtkie (tuzin linii dla kaA°Xdego pakietu) i byA°Xo trudno umieA°XciA.X tA°Xumaczenie w specjalnym pliku poniewaA°X musiaA°Xo byA.X dostA.Xpne jeszcze przed zainstalowaniem pakietu.

To dlatego opiekun debconfa zdecydowaA°X zaimplementowaA.X inne rozwiA.Xzanie, w ktA~Xrym tA°Xumaczenia sA.X umieszczane w tym samym pliku, co oryginaA°X. Jest to pociA.XgajA.Xce. KtoA°X mA~XgA°Xby nawet chcieA.X coA°X takiego zrobiA.X dla XML-a na przykA°Xad. MA~XgA°Xby on wyglA.XdaA.X tak:

  <section>
   <title lang="en">My title</title>
   <title lang="fr">Mon titre</title>
 
   <para>
    <text lang="en">My text.</text>
    <text lang="fr">Mon texte.</text>
   </para>
  </section>

Jednak byA°Xo to na tyle problematyczne, A°Xe obecnie jest uA°Xywane rozwiA.Xzanie oparte na plikach po. Tylko oryginalny tekst moA°Xe byA.X edytowany w pliku, a tA°Xumaczenia muszA.X siA.X pojawiA.X w plikach po, wyciA.XgniA.Xtych z gA°XA~Xwnego szablonu (A°XA.Xczonych z powrotem w czasie kompilacji pakietu). Ten stary system jest potA.Xpiany z kilku powodA~Xw:

•
problemy w zarzA.Xdzaniu

JeA°Xeli kilku tA°Xumaczy dostarczy A°XatA.X w tym samym czasie, bA.Xdzie trudno poA°XA.XczyA.X te A°Xaty wszystkie razem.

Jak wykryA.X te zmiany w oryginale, ktA~Xre muszA.X byA.X zastosowane w tA°Xumaczeniach? Aby uA°XyA.X programu diff, trzeba byA°Xo zanotowaA.X wersjA.X oryginaA°Xu, ktA~Xra zostaA°Xa przetA°Xumaczone. Tj. potrzebujesz pliku po w Twoim pliku.

•
problemy z kodowaniem znakA~Xw

RozwiA.Xzanie to jest dobre tylko dla europejskich jA.XzykA~Xw, jednak wprowadzenie koreaA°Xskiego, rosyjskiego lub arabskiego bardzo wszystko komplikuje. RozwiA.Xzaniem mA~XgA°Xby byA.X UTF, jednak wciA.XA°X jest z nim kilka problemA~Xw.

Co wiA.Xcej takie problemy sA.X trudne do wychwycenia (tj. tylko KoreaA°Xczycy zauwaA°XA.X A°Xe kodowanie znakA~Xw w koreaA°Xskim tekA°Xcie jest zepsute [bo tA°Xumacz byA°X Rosjaninem]).

gettext rozwiA.Xzuje wszystkie te problemy razem.

Ale gettext nie zostaA°X zaprojektowany do takiego uA°Xycia!

To prawda, ale do tej pory nikt nie znalazA°X lepszego rozwiA.Xzania. JedynA.X znanA.X alternatywA.X jest rA.Xczne tA°Xumaczenie ze wszystkimi problemami w jego zarzA.Xdzaniu.

Co z innymi narzA.Xdziami do tA°XumaczeA°X dokumentacji wykorzystujA.Xcymi gettext?

O ile mi wiadomo, sA.X tylko dwa takie:
poxml
Jest to narzA.Xdzie rozwijane przez ludzi z KDE obsA°XugujA.Xce format DocBook XML. O ile mi wiadomo, byA°X to pierwszy program wyciA.XgajA.Xcy A°XaA°Xcuchy znakA~Xw do przetA°Xumaczenia z dokumentacji do plikA~Xw po i wstawiajA.Xcy je z powrotem po przetA°Xumaczeniu.

MoA°Xe on obsA°XugiwaA.X tylko XML i czA.XA°Xciowo DTD. Jestem bardzo niezadowolony z obsA°Xugi list, ktA~Xre zostajA.X umieszczone w jednym wielkim msgid. Kiedy lista staje siA.X dA°Xuga, sprawa siA.X komplikuje.

po-debiandoc
Program utworzony przez Denisa Barbiera jest poprzednikiem moduA°Xu sgml po4a, ktA~Xry w mniejszym bA.XdA°X wiA.Xkszym stopniu go zastA.Xpuje, czyniA.Xc przestarzaA°Xym. Zgodnie ze swA.X nazwA.X obsA°Xuguje tylko debiandoc DTD, ktA~Xry jest DTD mniej lub bardziej przestarzaA°Xym.

NajwiA.XkszA.X zaletA.X po4a nad nimi jest A°XatwoA°XA.X umieszczania dodatkowej zawartoA°Xci (co jest nawet gorsze tutaj) i przejA°Xcia na format gettext.

Przekazywanie deweloperom wiedzy o tA°Xumaczeniu

PrA~XbujA.Xc tA°XumaczyA.X dokumentacjA.X lub programy moA°Xna napotkaA.X trzy rodzaje problemA~Xw: lingwistyczne (nie kaA°Xdy mA~Xwi dwoma jA.Xzykami), techniczne (to dlatego istnieje po4a) i ludzkie. Nie wszyscy deweloperzy rozumiejA.X potrzebA.X tA°XumaczeA°X. Nawet majA.Xc dobre chA.Xci, mogA.X ignorowaA.X potrzebA.X upraszczania pracy tA°Xumaczy. Aby w tym pomA~Xc, po4a dostarcza wiele dokumentacji, do ktA~Xrej moA°Xna siA.X odnosiA.X.

Innym waA°Xnym punktem jest to, A°Xe kaA°Xdy plik z tA°Xumaczeniem zaczyna siA.X od krA~Xtkiego komentarza okreA°XlajA.Xcego, czym jest ten plik i jak go uA°XyA.X. Powinno to pomA~Xc deweloperom, zalanym tonami plikA~Xw w rA~XA°Xnych jA.Xzykach, ktA~Xrych nie znajA.X, pomA~Xc w poprawnym obsA°XuA°Xeniu tego.

W projekcie po4a przetA°Xumaczone dokumenty nie sA.X plikami A°XrA~XdA°Xowymi. PoniewaA°X jesteA°Xmy przyzwyczajeni do tego, A°Xe pliki sgml sA.X plikami A°XrA~XdA°Xowymi, A°Xatwo jest o pomyA°XkA.X. Dlatego wszystkie pliki zawierajA.X taki nagA°XA~Xwek:

  |       ****************************************************
  |       *         PLIK WYGENEROWANY, NIE EDYTOWAA.X          *
  |       * TO NIE JEST PLIK A°XRA~XDA°XOWY, ALE WYNIK KOMPILACJI  *
  |       ****************************************************
  |
  | Ten plik zostaA°X wygenerowany przez po4a-translate(1). Nie przechowuj go
  | (na przykA°Xad w CVS-ie), ale przechowuj plik po, uA°Xyty jako plik A°XrA~XdA°Xowy
  | przez polecenie po4a-translate.
  |
  | Tak naprawdA.X, potraktuj ten plik jako plik binarny, a plik po jako zwykA°Xy
  | plik A°XrA~XdA°Xowy: jeA°Xli plik po zaginie, to bA.Xdzie trudniej zachowaA.X aktualnoA°XA.X
  | tego tA°Xumaczenia ;)

Podobnie, to co naleA°Xy zrobiA.X ze zwykA°Xymi plikami po programu gettext, to skopiowaA.X je do katalogu po/. Ale w przypadku plikA~Xw zarzA.Xdzanych przez po4a to nie dziaA°Xa. NajwiA.Xkszym ryzykiem tutaj jest to, A°Xe deweloper usunie istniejA.Xce tA°Xumaczenia jego programu wraz z tA°Xumaczeniami dokumentacji. (Oba nie mogA.X byA.X przechowywane w jednym pliku po, poniewaA°X program wymaga instalacji pliku tA°XumaczeA°X jako pliku mo, podczas gdy dokumentacja uA°Xywa tA°XumaczeA°X w czasie kompilacji). Dlatego pliki po tworzone przez moduA°X po-debiandoc zawierajA.X poniA°Xszy nagA°XA~Xwek:

  #
  #  RADY DLA DEWELOPERA~XW:
  #    - nie trzeba rA.Xcznie edytowaA.X plikA~Xw POT i PO.
  #    - ten plik zawiera tA°Xumaczenie Twoich szablonA~Xw confiteor.
  #      Nie zastA.Xpuj tA°XumaczeA°X Twojego programu tym plikiem !!
  #        (albo tA°Xumacze bA.XdA.X na Ciebie wA°Xciekli)
  #
  #  RADY DLA TA°XUMACZY:
  #    JeA°Xli nie jesteA°X zaznajomiony z formatem PO, warto przeczytaA.X
  #    dokumentacjA.X pakietu gettext, zwA°Xaszcza sekcje poA°XwiA.Xcone
  #    temu formatowi. Na przykA°Xad uruchom:
  #         info -n "(gettext)PO Files"
  #         info -n "(gettext)Heder Centry"
  #
  #    Informacje specyficzne po-debconf sA.X dostA.Xpne w
  #            /usr/share/doc/po-debconf/README-trans
  #        lub http://www.debian.org/intl/l10n/po-debconf/README-trans
  #

PODSUMOWANIE plusA~Xw i minusA~Xw rozwiA.Xzania opartego na gettext

•
TA°Xumaczenia nie sA.X trzymane wraz z oryginaA°Xem, co pozwala w prosty sposA~Xb wykryA.X, czy tA°Xumaczenia nie sA.X przestarzaA°Xe.
•
TA°Xumaczenia sA.X przechowywane w oddzielnych plikach, dziA.Xki czemu tA°Xumacze rA~XA°Xnych jA.XzykA~Xw sobie nie przeszkadzajA.X, zarA~Xwno kiedy podsyA°XajA.X swoje tA°Xumaczenia, jak i kiedy zmieniajA.X kodowanie znakA~Xw pliku.
•
WewnA.Xtrznie jest oparty na pakiecie "gettext" (ale "po4a" oferuje bardzo prosty interfejs, tak A°Xe nie ma potrzeby poznawania wewnA.Xtrznych mechanizmA~Xw, aby go uA°XyA.X). W ten sposA~Xb, nie musimy ponownie wymyA°XlaA.X koA°Xa, a poniewaA°X gettext jest szeroko uA°Xywany, mamy nadziejA.X, A°Xe w wiA.Xkszym lub mniejszym stopniu jest wolny od bA°XA.XdA~Xw.
•
Z punktu widzenia koA°Xcowego uA°Xytkownika nic siA.X nie zmieniA°Xo (poza tym, A°Xe tA°Xumaczenia sA.X lepiej zarzA.Xdzane). Wynikowe pliki z dokumentacjA.X sA.X tak samo dystrybuowane.
•
TA°Xumacze nie muszA.X uczyA.X siA.X skA°Xadni nowego pliku i mogA.X po prostu uA°XyA.X swojego ulubionego edytora plikA~Xw po (jak tryb po emasca, kbabel lub gtranslator).
•
Gettext udostA.Xpnia prosty sposA~Xb otrzymania statystyk o tym, co zostaA°Xo zrobione, co powinno byA.X przejrzane i zaktualizowane, a co jeszcze jest do zrobienia. PrzykA°Xady moA°Xna znaleA°XA.X pod tymi adresami: 
  - http://kbabel.kde.org/img/previewKonq.png
  - http://www.debian.org/intl/l10n/

Nie wszystko zA°Xoto, co siA.X A°Xwieci - to podejA°Xcie ma takA°Xe kilka minusA~Xw, z ktA~Xrymi musimy sobie poradziA.X.

•
Na pierwszy rzut oka zaA°XA.Xczniki sA.X... dziwne.
•
Nie moA°Xna dostosowywaA.X tA°Xumaczonego tekstu do wA°Xasnych upodobaA°X, na przykA°Xad przez podzielenie w danym miejscu na akapity, poA°XA.Xczenie dwA~Xch innych akapitA~Xw w jeden. Jednak w pewnym sensie, jeA°Xeli jest jakiA°X problem z oryginaA°Xem, powinno to zostaA.X zgA°Xoszone jako bA°XA.Xd.
•
Nawet majA.Xc A°Xatwy interfejs, wciA.XA°X pozostaje nowym narzA.Xdziem, ktA~Xrego trzeba siA.X uczyA.X.

Jednym z moich marzeA°X jest zintegrowanie w jakiA°X sposA~Xb po4a z programami gtranslator lub kbabel. Kiedy plik sgml jest otwierany, komunikaty zostajA.X automatycznie wyciA.Xgane. Kiedy jest zamykany, przetA°Xumaczony plik jest zapisywany na dysk. JeA°Xli uda nam siA.X zrobiA.X moduA°X MS Word (TM) (a przynajmniej RFT), to bA.XdA.X mogli go nawet uA°XywaA.X profesjonalni tA°Xumacze.

Znane bA°XA.Xdy i i A°XA.Xdania nowych funkcjonalnoA°Xci

NajwaA°XniejszA.X sprawA.X (oprA~Xcz brakujA.Xcych moduA°XA~Xw) jest obsA°Xuga kodowania znakA~Xw. RozwiA.Xzaniem mogA°Xoby byA.X dodanie pragmy Perla UTF-8 i rekodowanie komunikatA~Xw na wyjA°Xciu, ale nie jest to jeszcze zrobione.

ChcielibyA°Xmy wydzieliA.X czA.XA°XA.X kodu (dotyczA.Xcego wstawiania plikA~Xw) moduA°Xu sgml z powrotem do TransTractora, tak A°Xeby pozostaA°Xe moduA°Xy mogA°Xy z niego korzystaA.X, ale to nie bA.Xdzie zmiana widoczna dla uA°Xytkownika.

AUTORZY

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

TA°XUMACZENIE

  Robert Luberda <robert@debian.org>