Skip to content

erp5
erp5
Commit 52146f5e authored by Leonardo Rochael Almeida's avatar Leonardo Rochael Almeida
Browse files
Options

Fork Localizer and itools 

Fork from master branch of Localizer and 0.50 branch of itools into ERP5

Remove almost everything from itools except bare essentials needed by a stripped Localizer for ERP5
parent 498500ed
Hide whitespace changes
Inline Side-by-side
Showing with 37269 additions and 0 deletions
product/Localizer/.gitignore 0 → 100644
View file @ 52146f5e
*.pyc
*.swp
locale/*.mo
locale/*~
product/Localizer/GettextTag.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2002 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
Localizer
Adds a new DTML tag:
<dtml-gettext [lang=<language>|lang_expr=<expression>] [verbatim] [catalog=<id>] [data=<expression>]>
...
</dtml-gettext>
"""
# Import from Zope
from DocumentTemplate.DT_Util import Eval, ParseError, parse_params, \
InstanceDict, namespace, render_blocks
# Auxiliar functions
def name_or_expr(mapping, name_attr, expr_attr, default):
name = mapping.get(name_attr, None)
expr = mapping.get(expr_attr, None)
if name is None:
if expr is None:
return default
return Eval(expr)
if expr is None:
return name
raise ParseError, ('%s and %s given' % (name_attr, expr_attr), 'calendar')
class GettextTag:
""" """
name = 'gettext'
blockContinuations = ()
def __init__(self, blocks):
tname, args, section = blocks[0]
self.section = section.blocks
args = parse_params(args, lang=None, lang_expr=None, verbatim=1,
catalog=None, data=None)
self.lang = name_or_expr(args, 'lang', 'lang_expr', None)
self.verbatim = args.get('', None) == 'verbatim' \
or args.get('verbatim', None)
self.catalog = args.get('catalog', None)
self.data = args.get('data', None)
if self.data is not None:
self.data = Eval(self.data)
def __call__(self, md):
# In which language, if any?
lang = self.lang
if lang is not None and type(lang) is not str:
lang = lang.eval(md)
# Get the message!!
ns = namespace(md)[0]
md._push(InstanceDict(ns, md))
message = render_blocks(self.section, md)
md._pop(1)
# Interpret the message as verbatim or not
if not self.verbatim:
message = ' '.join([ x.strip() for x in message.split() ])
# Search in a specific catalog
if self.catalog is None:
gettext = md.getitem('gettext', 0)
else:
gettext = md.getitem(self.catalog, 0).gettext
translation = gettext(message, lang)
# Variable substitution
if self.data is not None:
data = self.data.eval(md)
translation = translation % data
return translation
product/Localizer/LICENSE.txt 0 → 100644
View file @ 52146f5e
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program 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 3 of the License, or
(at your option) any later version.
This program 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.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
product/Localizer/LanguageManager.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2004 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from the Standard Library
from urlparse import urlparse
# Import from itools
from itools.i18n import get_language_name, get_languages
# Import from Zope
from App.class_init import InitializeClass
from App.Management import Tabs
from AccessControl import ClassSecurityInfo
# Import from Localizer
from LocalFiles import LocalDTMLFile
from utils import lang_negotiator, _
class LanguageManager(Tabs):
""" """
security = ClassSecurityInfo()
# TODO For backwards compatibility with Python 2.1 the variable
# _languages is a tuple. Change it to a frozenset.
_languages = ()
_default_language = None
########################################################################
# API
########################################################################
def get_languages(self):
"""Returns all the object languages.
"""
return self._languages
def set_languages(self, languages):
"""Sets the object languages.
"""
self._languages = tuple(languages)
def add_language(self, language):
"""Adds a new language.
"""
if language not in self._languages:
self._languages = tuple(self._languages) + (language,)
def del_language(self, language):
"""Removes a language.
"""
if language in self._languages:
languages = [ x for x in self._languages if x != language ]
self._languages = tuple(languages)
def get_languages_mapping(self):
"""Returns a list of dictionary, one for each objects language. The
dictionary contains the language code, its name and a boolean value
that tells wether the language is the default one or not.
"""
return [ {'code': x,
'name': get_language_name(x),
'default': x == self._default_language}
for x in self._languages ]
def get_available_languages(self, **kw):
"""Returns the langauges available. For example, a language could be
considered as available only if there is some data associated to it.
This method is used by the language negotiation code (see
'get_selected_language'), sometimes you will want to redefine it in
your classes.
"""
return self._languages
def get_default_language(self):
"""Returns the default language.
This method is used by the language negotiation code (see
'get_selected_language'), sometimes you will want to redefine it in
your classes.
For example, maybe you will want to define it to return always a
default language, even when internally it is None.
"""
return self._default_language
########################################################################
# Web API
########################################################################
# Security settings
security.declarePublic('get_languages')
security.declareProtected('Manage languages', 'set_languages')
security.declareProtected('Manage languages', 'add_language')
security.declareProtected('Manage languages', 'del_language')
security.declarePublic('get_languages_mapping')
security.declarePublic('get_language_name')
def get_language_name(self, id=None):
"""
Returns the name of the given language code.
XXX Kept here for backwards compatibility only
"""
if id is None:
id = self.get_default_language()
return get_language_name(id)
security.declarePublic('get_available_languages')
security.declarePublic('get_default_language')
# XXX Kept here temporarily, further refactoring needed
security.declarePublic('get_selected_language')
def get_selected_language(self, **kw):
"""
Returns the selected language. Here the language negotiation takes
place.
Accepts keyword arguments which will be passed to
'get_available_languages'.
"""
available_languages = apply(self.get_available_languages, (), kw)
return lang_negotiator(available_languages) \
or self.get_default_language()
########################################################################
# ZMI
########################################################################
manage_options = (
{'action': 'manage_languages', 'label': u'Languages',
'help': ('Localizer', 'LM_languages.stx')},)
def filtered_manage_options(self, REQUEST=None):
options = Tabs.filtered_manage_options(self, REQUEST=REQUEST)
# Insert the upgrade form if needed
if self._needs_upgrade():
options.insert(0,
{'action': 'manage_upgradeForm',
'label': u'Upgrade',
'help': ('Localizer', 'LM_upgrade.stx')})
# Translate the labels
r = []
for option in options:
option = option.copy()
option['label'] = _(option['label'])
r.append(option)
# Ok
return r
security.declareProtected('View management screens', 'manage_languages')
manage_languages = LocalDTMLFile('ui/LM_languages', globals())
security.declarePublic('get_all_languages')
def get_all_languages(self):
"""
Returns all ISO languages, used by 'manage_languages'.
"""
return get_languages()
security.declareProtected('Manage languages', 'manage_addLanguage')
def manage_addLanguage(self, language, REQUEST=None, RESPONSE=None):
""" """
self.add_language(language)
if RESPONSE is not None:
RESPONSE.redirect("%s/manage_languages" % REQUEST['URL1'])
security.declareProtected('Manage languages', 'manage_delLanguages')
def manage_delLanguages(self, languages, REQUEST, RESPONSE):
""" """
for language in languages:
self.del_language(language)
RESPONSE.redirect("%s/manage_languages" % REQUEST['URL1'])
security.declareProtected('Manage languages', 'manage_changeDefaultLang')
def manage_changeDefaultLang(self, language, REQUEST=None, RESPONSE=None):
""" """
self._default_language = language
if REQUEST is not None:
RESPONSE.redirect("%s/manage_languages" % REQUEST['URL1'])
# Unicode support, custom ZMI
manage_page_header = LocalDTMLFile('ui/manage_page_header', globals())
########################################################################
# Upgrade
def _needs_upgrade(self):
return False
def _upgrade(self):
pass
security.declarePublic('need_upgrade')
def need_upgrade(self):
""" """
return self._needs_upgrade()
security.declareProtected(
'Manage Access Rules', 'manage_upgradeForm', 'manage_upgrade')
manage_upgradeForm = LocalDTMLFile('ui/LM_upgrade', globals())
def manage_upgrade(self, REQUEST, RESPONSE):
""" """
self._upgrade()
RESPONSE.redirect('manage_main')
InitializeClass(LanguageManager)
product/Localizer/LocalAttributes.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2002 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from Zope
from ExtensionClass import Base
class LocalAttribute(Base):
"""
Provides a way to override class variables, useful for example
for title (defined in SimpleItem).
"""
def __init__(self, id):
self.id = id
def __of__(self, parent):
return parent.getLocalAttribute(self.id)
class LocalAttributesBase:
def getLocalAttribute(self, name, lang=None):
""" """
raise NotImplemented
class LocalAttributes(LocalAttributesBase):
"""
Example of a 'LocalAttributesBase' derived class, this also a base class
for 'LocalFolder.LocalFolder' and 'Locale.Locale', it can be considered
the default implementation.
Returns attributes of the form <name>_<lang>. When <lang> has more than
one level, for example es-CO, the dashes are transformed to underscores,
as dashes aren't valid charecters for identifiers in Python. For example,
the call 'getLocalAttribute("long_date", "es-CO")' would return
'self.long_date_es_CO'.
"""
def getLocalAttribute(self, name, lang=None):
if lang is None:
lang = self.get_selected_language()
lang = lang.replace('-', '_')
name = '%s_%s' % (name, lang)
return getattr(self, name)
product/Localizer/LocalContent.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2005 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from the Standard Library
from hashlib import md5
# Import from itools
from itools.datatypes import LanguageTag
from itools.tmx import TMXFile, Sentence, TMXUnit
from itools.xliff import XLFFile
# Import from Zope
from Acquisition import aq_base, aq_parent
from App.class_init import InitializeClass
from App.Dialogs import MessageDialog
from OFS.SimpleItem import SimpleItem
from OFS.PropertyManager import PropertyManager
from Products.ZCatalog.CatalogPathAwareness import CatalogAware
from AccessControl import ClassSecurityInfo
# Import from Localizer
from LocalAttributes import LocalAttribute
from LocalFiles import LocalDTMLFile
from LocalPropertyManager import LocalPropertyManager
from utils import _
def md5text(str):
"""Create an MD5 sum (or hash) of a text. It is guaranteed to be 32 bytes
long.
"""
return md5(str.encode('utf-8')).hexdigest()
manage_addLocalContentForm = LocalDTMLFile('ui/LocalContent_add', globals())
def manage_addLocalContent(self, id, sourcelang, languages, REQUEST=None):
""" """
languages.append(sourcelang) # Make sure source is one of the target langs
self._setObject(id, LocalContent(id, sourcelang, tuple(languages)))
if REQUEST is not None:
return self.manage_main(self, REQUEST)
class LocalContent(CatalogAware, LocalPropertyManager, PropertyManager,
SimpleItem):
""" """
meta_type = 'LocalContent'
security = ClassSecurityInfo()
# Properties metadata
_local_properties_metadata = ({'id': 'title', 'type': 'string'},
{'id': 'body', 'type': 'text'})
_properties = ()
title = LocalAttribute('title') # Override title from SimpleItem
body = LocalAttribute('body')
manage_options = \
LocalPropertyManager.manage_options \
+ PropertyManager.manage_options[:1] \
+ ({'action': 'manage_import', 'label': u'Import',
'help': ('Localizer', 'MC_importExport.stx')},
{'action': 'manage_export', 'label': u'Export',
'help': ('Localizer', 'MC_importExport.stx')}) \
+ PropertyManager.manage_options[1:] \
+ SimpleItem.manage_options
def __init__(self, id, sourcelang, languages):
self.id = id
self._default_language = sourcelang
self._languages = languages
index_html = None # Prevent accidental acquisition
def __call__(self, client=None, REQUEST=None, RESPONSE=None, **kw):
if REQUEST is None:
REQUEST = self.REQUEST
# Get the template to use
template_id = 'default_template'
if hasattr(aq_base(self), 'default_template'):
template_id = self.default_template
# Render the object
template = getattr(aq_parent(self), template_id)
template = template.__of__(self)
return apply(template, ((client, self), REQUEST), kw)
# Override some methods to be sure that LocalContent objects are
# reindexed when changed.
def set_localpropvalue(self, id, lang, value):
LocalContent.inheritedAttribute('set_localpropvalue')(self, id, lang,
value)
self.reindex_object()
def del_localproperty(self, id):
LocalContent.inheritedAttribute('del_localproperty')(self, id)
self.reindex_object()
security.declareProtected('View management screens', 'manage_import')
manage_import = LocalDTMLFile('ui/LC_import_form', globals())
#######################################################################
# TMX support
security.declareProtected('View management screens', 'manage_export')
manage_export = LocalDTMLFile('ui/LC_export_form', globals())
security.declareProtected('Manage messages', 'tmx_export')
def tmx_export(self, REQUEST, RESPONSE):
"""Exports the content of the message catalog to a TMX file.
"""
src_lang = self._default_language
# Init the TMX handler
tmx = TMXFile()
tmx.header['creationtool'] = u'Localizer'
tmx.header['creationtoolversion'] = u'1.x'
tmx.header['datatype'] = u'plaintext'
tmx.header['segtype'] = u'paragraph'
tmx.header['adminlang'] = src_lang
tmx.header['srclang'] = src_lang
tmx.header['o-encoding'] = u'utf-8'
# Add the translation units
for key in self._local_properties.keys():
unit = TMXUnit({})
for lang in self._languages:
sentence = Sentence({'lang': lang})
trans, fuzzy = self.get_localproperty(key, lang)
sentence.text = trans
unit.msgstr[lang] = sentence
tmx.messages[self.get_localproperty(key, src_lang)[0]] = unit
# Serialize
data = tmx.to_str()
# Set response headers
RESPONSE.setHeader('Content-type','application/data')
RESPONSE.setHeader('Content-Disposition',
'attachment; filename="%s.tmx"' % self.id)
# Ok
return data
security.declareProtected('Manage messages', 'tmx_import')
def tmx_import(self, file, REQUEST=None, RESPONSE=None):
"""Imports a TMX level 1 file.
"""
try:
data = file.read()
tmx = TMXFile(string=data)
except:
return MessageDialog(title = 'Parse error',
message = _('impossible to parse the file') ,
action = 'manage_import',)
for id, msg in tmx.messages.items():
for prop, d in self._local_properties.items():
if d[self._default_language][0] == id:
msg.msgstr.pop(self._default_language)
for lang in msg.msgstr.keys():
# normalize the languageTag and extract the core
(core, local) = LanguageTag.decode(lang)
lang = LanguageTag.encode((core, local))
if lang not in self._languages:
self._languages += (lang,)
texte = msg.msgstr[lang].text
if texte:
self.set_localpropvalue(prop, lang, texte)
if core != lang and core != self._default_language:
if core not in self._languages:
self._languages += (core,)
if not msg.msgstr.has_key(core):
self.set_localpropvalue(prop, lang, texte)
if REQUEST is not None:
RESPONSE.redirect('manage_localPropertiesForm')
security.declareProtected('Manage messages', 'xliff_export')
def xliff_export(self, dst_lang, export_all=1, REQUEST=None,
RESPONSE=None):
""" Exports the content of the message catalog to an XLIFF file
"""
from DateTime import DateTime
src_lang = self._default_language
export_all = int(export_all)
# Init the XLIFF handler
xliff = XLFFile()
# Add the translation units
original = '/%s' % self.absolute_url(1)
for prop in self._local_properties.keys():
target, fuzzy = self.get_localproperty(prop, dst_lang)
msgkey, fuzzy = self.get_localproperty(prop, src_lang)
# If 'export_all' is true export all messages, otherwise export
# only untranslated messages
if export_all or not target:
unit = xliff.add_unit(original, msgkey, None)
unit.attributes['id'] = md5text(msgkey)
if target:
unit.target = target
# Set the file attributes
file = xliff.files[original]
attributes = file.attributes
attributes['original'] = original
attributes['product-name'] = u'Localizer'
attributes['product-version'] = u'1.1.x'
attributes['data-type'] = u'plaintext'
attributes['source-language'] = src_lang
attributes['target-language'] = dst_lang
attributes['date'] = DateTime().HTML4()
# Serialize
xliff = xliff.to_str()
# Set response headers
RESPONSE.setHeader('Content-Type', 'text/xml; charset=UTF-8')
filename = '%s_%s_%s.xlf' % (self.id, src_lang, dst_lang)
RESPONSE.setHeader('Content-Disposition',
'attachment; filename="%s"' % filename)
# Ok
return xliff
security.declareProtected('Manage messages', 'xliff_import')
def xliff_import(self, file, REQUEST=None):
""" XLIFF is the XML Localization Interchange File Format
designed by a group of software providers.
It is specified by www.oasis-open.org
"""
try:
data = file.read()
xliff = XLFFile(string=data)
except:
return MessageDialog(title = 'Parse error',
message = _('impossible to parse the file') ,
action = 'manage_import',)
num_trans = 0
(file_ids, sources, targets) = xliff.get_languages()
# update languages
if len(sources) > 1 or sources[0] != self._default_language:
return MessageDialog(title = 'Language error',
message = _('incompatible language sources') ,
action = 'manage_import',)
for lang in targets:
if lang != self._default_language and lang not in self._languages:
self._languages += (lang,)
# get messages
for file in xliff.files:
cur_target = file.attributes.get('target-language', '')
for msg in file.body.keys():
for (prop, val) in self._local_properties.items():
if val[self._default_language][0] == msg:
if cur_target and file.body[msg].target:
texte = file.body[msg].target
self.set_localpropvalue(prop, cur_target, texte)
num_trans += 1
if REQUEST is not None:
return MessageDialog(
title = _(u'Messages imported'),
message = (_(u'Imported %d messages to %s') %
(num_trans, ' '.join(targets))),
action = 'manage_localPropertiesForm')
InitializeClass(LocalContent)
product/Localizer/LocalFiles.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2005 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
Localizer
This module provides several localized classes, that is, classes with the
locale attribute. Currently it only defines the classes LocalDTMLFile and
LocalPageTemplateFile, which should be used instead of DTMLFile and
PageTemplateFile.
"""
# Import from the Standard Library
import os
# Import Zope modules
from App.special_dtml import DTMLFile
# Import from Localizer
from utils import DomainAware
class LocalDTMLFile(DomainAware, DTMLFile):
""" """
def __init__(self, name, _prefix=None, **kw):
DTMLFile.__init__(self, name, _prefix, **kw)
DomainAware.__init__(self, _prefix)
def _exec(self, bound_data, args, kw):
# Add our gettext first
bound_data['gettext'] = self.gettext
return apply(LocalDTMLFile.inheritedAttribute('_exec'),
(self, bound_data, args, kw))
# Zope Page Templates (ZPT)
# XXX Deprecated, use the i18n namespace instead.
try:
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
except ImportError:
# If ZPT is not installed
class LocalPageTemplateFile:
pass
else:
class LocalPageTemplateFile(DomainAware, PageTemplateFile):
""" """
def __init__(self, name, _prefix=None, **kw):
PageTemplateFile.__init__(self, name, _prefix, **kw)
DomainAware.__init__(self, _prefix)
def _exec(self, bound_data, args, kw):
# Add our gettext first
bound_data['gettext'] = self.gettext
return apply(LocalPageTemplateFile.inheritedAttribute('_exec'),
(self, bound_data, args, kw))
product/Localizer/LocalFolder.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2004 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from Zope
from App.Common import package_home
from OFS.Folder import Folder
# Import from Localizer
from LanguageManager import LanguageManager
from LocalFiles import LocalDTMLFile
from LocalAttributes import LocalAttribute, LocalAttributes
from utils import _
manage_addLocalFolderForm = LocalDTMLFile('ui/LocalFolder_add', globals())
def manage_addLocalFolder(self, id, title, languages, REQUEST=None):
""" """
id = id.strip()
self._setObject(id, LocalFolder(id, title, languages))
if REQUEST is not None:
return self.manage_main(self, REQUEST)
class LocalFolder(LanguageManager, LocalAttributes, Folder):
""" """
meta_type = 'LocalFolder'
_properties = ({'id': 'title', 'type': 'string'},)
def __init__(self, id, title, languages):
self.id = id
self.title = title
# Language Manager data
self._languages = tuple(languages)
self._default_language = languages[0]
# Local attributes
self._local_attributes = ()
manage_options = \
Folder.manage_options[:1] \
+ ({'action': 'manage_attributes', 'label': u'Attributes'},) \
+ LanguageManager.manage_options \
+ Folder.manage_options[1:]
# Manage attributes
manage_attributes = LocalDTMLFile('ui/LocalFolder_attributes', globals())
def get_local_attributes(self):
return self._local_attributes
def manage_delAttributes(self, attributes, REQUEST=None, RESPONSE=None):
""" """
local_attributes = list(self._local_attributes)
for attr in attributes:
local_attributes.remove(attr)
delattr(self, attr)
self._local_attributes = tuple(local_attributes)
if RESPONSE is not None:
RESPONSE.redirect("%s/manage_attributes" % REQUEST['URL1'])
def manage_addAttribute(self, id, REQUEST=None, RESPONSE=None):
""" """
id = id.strip()
setattr(self, id, LocalAttribute(id))
self._local_attributes = self._local_attributes + (id,)
if RESPONSE is not None:
RESPONSE.redirect("%s/manage_attributes" % REQUEST['URL1'])
product/Localizer/LocalPropertyManager.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2004 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from the Standard Library
from urllib import quote
from time import time
# Import from Zope
from AccessControl import ClassSecurityInfo
from Acquisition import aq_base
from App.class_init import InitializeClass
# Import from Localizer
from LanguageManager import LanguageManager
from LocalAttributes import LocalAttribute, LocalAttributesBase
from LocalFiles import LocalDTMLFile
# FIXME
# For backwards compatibility (<= 0.8.0): other classes import 'LocalProperty'
# Since this may be stored as a persistent value, we cannot remove it, first
# we must provide an upgrade facility
LocalProperty = LocalAttribute
class LocalPropertyManager(LanguageManager, LocalAttributesBase):
"""
Mixin class that allows to manage localized properties.
Somewhat similar to OFS.PropertyManager.
"""
security = ClassSecurityInfo()
# Metadata for local properties
# Example: ({'id': 'title', 'type': 'string'},)
_local_properties_metadata = ()
# Local properties are stored here
# Example: {'title': {'en': ('Title', timestamp), 'es': ('Títul', timestamp)}}
_local_properties = {}
# Useful to find or index all LPM instances
isLocalPropertyManager = 1
def getLocalPropertyManager(self):
"""
Returns the instance, useful to get the object through acquisition.
"""
return self
manage_options = (
{'action': 'manage_localPropertiesForm',
'label': u'Local properties',
'help': ('Localizer', 'LPM_properties.stx')},
{'action': 'manage_transPropertiesForm',
'label': u'Translate properties',
'help': ('Localizer', 'LPM_translate.stx')}) \
+ LanguageManager.manage_options
security.declarePublic('hasLocalProperty')
def hasLocalProperty(self, id):
"""Return true if object has a property 'id'"""
for property in self._local_properties_metadata:
if property['id'] == id:
return 1
return 0
security.declareProtected('View management screens',
'manage_localPropertiesForm')
manage_localPropertiesForm = LocalDTMLFile('ui/LPM_properties', globals())
security.declareProtected('View management screens',
'manage_transPropertiesForm')
manage_transPropertiesForm = LocalDTMLFile('ui/LPM_translations', globals())
security.declareProtected('Manage properties', 'set_localpropvalue')
def set_localpropvalue(self, id, lang, value):
# Get previous value
old_value, timestamp = self.get_localproperty(id, lang)
if old_value is None:
old_value = ''
# Update value only if it is different
if value != old_value:
properties = self._local_properties.copy()
if not properties.has_key(id):
properties[id] = {}
properties[id][lang] = (value, time())
self._local_properties = properties
def get_localproperty(self, name, language):
if name not in self._local_properties:
return None, None
property = self._local_properties[name]
if language not in property:
return None, None
value = property[language]
if isinstance(value, tuple):
return value
return value, None
security.declareProtected('Manage properties', 'set_localproperty')
def set_localproperty(self, id, type, lang=None, value=None):
"""Adds a new local property"""
if not self.hasLocalProperty(id):
self._local_properties_metadata += ({'id': id, 'type': type},)
setattr(self, id, LocalAttribute(id))
if lang is not None:
self.set_localpropvalue(id, lang, value)
security.declareProtected('Manage properties', 'del_localproperty')
def del_localproperty(self, id):
"""Deletes a property"""
# Update properties metadata
p = [ x for x in self._local_properties_metadata if x['id'] != id ]
self._local_properties_metadata = tuple(p)
# delete attribute
try:
del self._local_properties[id]
except KeyError:
pass
try:
delattr(self, id)
except KeyError:
pass
security.declareProtected('Manage properties', 'manage_addLocalProperty')
def manage_addLocalProperty(self, id, type, REQUEST=None, RESPONSE=None):
"""Adds a new local property"""
self.set_localproperty(id, type)
if RESPONSE is not None:
url = "%s/manage_localPropertiesForm?manage_tabs_message=Saved changes." % REQUEST['URL1']
RESPONSE.redirect(url)
security.declareProtected('Manage properties', 'manage_editLocalProperty')
def manage_editLocalProperty(self, REQUEST, RESPONSE=None):
"""Edit a property"""
def_lang = self.get_default_language()
form = REQUEST.form
for prop in self.getLocalProperties():
name = prop['id']
if form.has_key(name):
value = form[name].strip()
self.set_localpropvalue(name, def_lang, value)
if REQUEST is not None:
url = "%s/%s?manage_tabs_message=Saved changes." \
% (REQUEST['URL1'], REQUEST['destination'])
REQUEST.RESPONSE.redirect(url)
security.declareProtected('Manage properties', 'manage_delLocalProperty')
def manage_delLocalProperty(self, ids=[], REQUEST=None, RESPONSE=None):
"""Deletes a property"""
for id in ids:
self.del_localproperty(id)
if RESPONSE is not None:
url = "%s/manage_localPropertiesForm?manage_tabs_message=Saved changes." % REQUEST['URL1']
RESPONSE.redirect(url)
security.declareProtected('Manage properties', 'manage_transLocalProperty')
def manage_transLocalProperty(self, id, code, value, REQUEST,
RESPONSE=None):
"""Translate a property."""
self.set_localpropvalue(id, code, value.strip())
if RESPONSE is not None:
url = "%s/%s?lang=%s&prop=%s&manage_tabs_message=Saved changes." \
% (REQUEST['URL1'], REQUEST['destination'], code, id)
RESPONSE.redirect(url)
security.declareProtected('Manage properties', 'is_obsolete')
def is_obsolete(self, prop, lang):
default_language = self.get_default_language()
value, t0 = self.get_localproperty(prop, default_language)
value, t1 = self.get_localproperty(prop, lang)
if t0 is None:
return False
if t1 is None:
return True
return t1 < t0
security.declarePublic('getTargetLanguages')
def get_targetLanguages(self):
"""Get all languages except the default one."""
def_lang = self.get_default_language()
all_langs = self.get_languages_mapping()
for record in all_langs:
if def_lang == record['code']:
all_langs.remove(record)
return all_langs
security.declarePublic('getLocalProperties')
def getLocalProperties(self):
"""Returns a copy of the properties metadata."""
return tuple([ x.copy() for x in self._local_properties_metadata ])
security.declarePublic('getLocalAttribute')
def getLocalAttribute(self, id, lang=None):
"""Returns a local property"""
# No language, look for the first non-empty available version
if lang is None:
lang = self.get_selected_language(property=id)
value, timestamp = self.get_localproperty(id, lang)
if value is None:
return ''
return value
# Languages logic
security.declarePublic('get_available_languages')
def get_available_languages(self, **kw):
""" """
languages = self.get_languages()
id = kw.get('property', None)
if id is None:
# Is this thing right??
return languages
else:
if id in self._local_properties:
property = self._local_properties[id]
return [ x for x in languages if property.get(x, None) ]
else:
return []
security.declarePublic('get_default_language')
def get_default_language(self):
""" """
if self._default_language:
return self._default_language
languages = self.get_languages()
if languages:
return languages[0]
return None
# Upgrading..
def _needs_upgrade(self):
return hasattr(aq_base(self), 'original_language')
def _upgrade(self):
# In version 0.7 the language management logic moved to the
# mixin class LanguageManager, as a consequence the attribute
# "original_language" changes its name to "_default_language".
if hasattr(aq_base(self), 'original_languge'):
self._default_language = self.original_language
del self.original_language
# XXX With version 1.1.0b5 (as of patch 14) the '_local_properties'
# data structure keeps a timestamp to mark obsolete translations.
# The upgrade code below must be activated once the new upgrade
# framework is deployed, something that should happen for the 1.2
# release.
## for k, v in self._local_properties.items():
## for i, j in v.items():
## if type(j) is not tuple:
## # XXX add the timestamp for every property
## self._local_properties[k][i] = (j, time())
## self._p_changed = 1
# Define <id>_<lang> attributes, useful for example to catalog
def __getattr__(self, name):
try:
index = name.rfind('_')
id, lang = name[:index], name[index+1:]
property = self._local_properties[id]
except:
raise AttributeError, "%s instance has no attribute '%s'" \
% (self.__class__.__name__, name)
return self.getLocalAttribute(id, lang)
InitializeClass(LocalPropertyManager)
product/Localizer/Locale.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2002 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from Localizer
from LocalAttributes import LocalAttributes, LocalAttribute
class Locale(LocalAttributes):
# Time, hours and minutes
time = LocalAttribute('time')
def time_en(self, datetime):
return datetime.strftime('%H:%M')
def time_es(self, datetime):
return datetime.strftime('%H.%M')
product/Localizer/Localizer.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2004 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from the Standard Library
from urllib import unquote
# Import from itools
from itools.i18n import get_language_name
# Import from Zope
from AccessControl import ClassSecurityInfo
from Acquisition import aq_parent
from App.class_init import InitializeClass
from OFS.Folder import Folder
from zLOG import LOG, ERROR, INFO, PROBLEM
from zope.interface import implements
from ZPublisher.BeforeTraverse import registerBeforeTraverse, \
unregisterBeforeTraverse, queryBeforeTraverse, NameCaller
# Import Localizer modules
from interfaces import ILocalizer
from LocalFiles import LocalDTMLFile
from MessageCatalog import MessageCatalog
from utils import lang_negotiator
from LanguageManager import LanguageManager
# Constructors
manage_addLocalizerForm = LocalDTMLFile('ui/Localizer_add', globals())
def manage_addLocalizer(self, title, languages, REQUEST=None, RESPONSE=None):
"""
Add a new Localizer instance.
"""
self._setObject('Localizer', Localizer(title, languages))
if REQUEST is not None:
RESPONSE.redirect('manage_main')
class Localizer(LanguageManager, Folder):
"""
The Localizer meta type lets you customize the language negotiation
policy.
"""
meta_type = 'Localizer'
implements(ILocalizer)
id = 'Localizer'
_properties = ({'id': 'title', 'type': 'string'},
{'id': 'accept_methods', 'type': 'tokens'})
accept_methods = ('accept_path', 'accept_cookie', 'accept_url')
security = ClassSecurityInfo()
manage_options = \
(Folder.manage_options[0],) \
+ LanguageManager.manage_options \
+ Folder.manage_options[1:]
def __init__(self, title, languages):
self.title = title
self._languages = languages
self._default_language = languages[0]
#######################################################################
# API / Private
#######################################################################
def _getCopy(self, container):
return Localizer.inheritedAttribute('_getCopy')(self, container)
def _needs_upgrade(self):
return not self.hooked()
def _upgrade(self):
# Upgrade to 0.9
if not self.hooked():
self.manage_hook(1)
#######################################################################
# API / Public
#######################################################################
# Get some data
security.declarePublic('get_supported_languages')
def get_supported_languages(self):
"""
Get the supported languages, that is the languages that the
are being working so the site is or will provide to the public.
"""
return self._languages
security.declarePublic('get_selected_language')
def get_selected_language(self):
""" """
return lang_negotiator(self._languages) \
or self._default_language
# Hooking the traversal machinery
# Fix this! a new permission needed?
## security.declareProtected('View management screens', 'manage_hookForm')
## manage_hookForm = LocalDTMLFile('ui/Localizer_hook', globals())
## security.declareProtected('Manage properties', 'manage_hook')
security.declarePrivate('manage_hook')
def manage_hook(self, hook=0):
""" """
if hook != self.hooked():
if hook:
hook = NameCaller(self.id)
registerBeforeTraverse(aq_parent(self), hook, self.meta_type)
else:
unregisterBeforeTraverse(aq_parent(self), self.meta_type)
security.declarePublic('hooked')
def hooked(self):
""" """
if queryBeforeTraverse(aq_parent(self), self.meta_type):
return 1
return 0
# New code to control the language policy
def accept_cookie(self, accept_language):
"""Add the language from a cookie."""
lang = self.REQUEST.cookies.get('LOCALIZER_LANGUAGE', None)
if lang is not None:
accept_language.set(lang, 2.0)
def accept_path(self, accept_language):
"""Add the language from the path."""
stack = self.REQUEST['TraversalRequestNameStack']
if stack and (stack[-1] in self._languages):
lang = stack.pop()
accept_language.set(lang, 3.0)
def accept_url(self, accept_language):
"""Add the language from the URL."""
lang = self.REQUEST.form.get('LOCALIZER_LANGUAGE')
if lang is not None:
accept_language.set(lang, 2.0)
def __call__(self, container, REQUEST):
"""Hooks the traversal path."""
try:
accept_language = REQUEST['AcceptLanguage']
except KeyError:
return
for id in self.accept_methods:
try:
method = getattr(self, id)
method(accept_language)
except:
LOG(self.meta_type, PROBLEM,
'method "%s" raised an exception.' % id)
# Changing the language, useful snippets
security.declarePublic('get_languages_map')
def get_languages_map(self):
"""
Return a list of dictionaries, each dictionary has the language
id, its title and a boolean value to indicate wether it's the
user preferred language, for example:
[{'id': 'en', 'title': 'English', 'selected': 1}]
Used in changeLanguageForm.
"""
# For now only LPM instances are considered to be containers of
# multilingual data.
try:
ob = self.getLocalPropertyManager()
except AttributeError:
ob = self
ob_language = ob.get_selected_language()
ob_languages = ob.get_available_languages()
langs = []
for x in ob_languages:
langs.append({'id': x, 'title': get_language_name(x),
'selected': x == ob_language})
return langs
security.declarePublic('changeLanguage')
changeLanguageForm = LocalDTMLFile('ui/changeLanguageForm', globals())
def changeLanguage(self, lang, goto=None, expires=None):
""" """
request = self.REQUEST
response = request.RESPONSE
# Changes the cookie (it could be something different)
parent = aq_parent(self)
path = parent.absolute_url()[len(request['SERVER_URL']):] or '/'
if expires is None:
response.setCookie('LOCALIZER_LANGUAGE', lang, path=path)
else:
response.setCookie('LOCALIZER_LANGUAGE', lang, path=path,
expires=unquote(expires))
# Comes back
if goto is None:
goto = request['HTTP_REFERER']
response.redirect(goto)
InitializeClass(Localizer)
# Hook/unhook the traversal machinery
# Support for copy, cut and paste operations
def Localizer_moved(object, event):
container = event.oldParent
if container is not None:
unregisterBeforeTraverse(container, object.meta_type)
container = event.newParent
if container is not None:
id = object.id
container = container.this()
hook = NameCaller(id)
registerBeforeTraverse(container, hook, object.meta_type)
product/Localizer/LocalizerSupport.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2002-2004 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
This module makes more easy to implement multilingual Zope products based
on Localizer that also work when Localizer is not installed (they are
monolingual in this situation).
It provides dummy versions of some Localizer features. To internationalize
your code copy and paste this module to your product directory and, in the
modules you need it, just type:
from LocalizerSupport import _
from LocalizerSupport import LocalDTMLFile as DTMLFile
from LocalizerSupport import LocalPageTemplateFile as PageTemplateFile
Another option is not to rename the classes, then you will have to
change from 'DTMLFile' to 'LocalDTMLFile' and from 'PageTemplateFile'
to 'LocalPageTemplateFile' wherever you need it.
Note that Localizer requieres Python 2.4 or above, so the multilingual
version of your product will also requiere Python 2.4 or above.
Of course, you don't need to import the features you don't need.
"""
# The version information refers to the Localizer product version.
# If you change this module, please update the version number to
# show it.
__version__ = '1.2.0'
try:
from Products.Localizer import LocalDTMLFile, LocalPageTemplateFile
from Products.Localizer import _
except ImportError:
# For Python code
def _(message, language=None):
"""
Used to markup a string for translation but without translating it,
this is known as deferred translations.
"""
return message
# For DTML and Page Templates
def gettext(self, message, language=None):
""" """
return message
# Document Template Markup Langyage (DTML)
from Globals import DTMLFile
class LocalDTMLFile(DTMLFile):
def _exec(self, bound_data, args, kw):
# Add our gettext first
bound_data['gettext'] = self.gettext
return apply(LocalDTMLFile.inheritedAttribute('_exec'),
(self, bound_data, args, kw))
gettext = gettext
# Zope Page Templates (ZPT)
try:
from Products.PageTemplates.PageTemplateFile import PageTemplateFile
except ImportError:
# If ZPT is not installed
class LocalPageTemplateFile:
pass
else:
class LocalPageTemplateFile(PageTemplateFile):
def _exec(self, bound_data, args, kw):
# Add our gettext first
bound_data['gettext'] = self.gettext
return apply(LocalPageTemplateFile.inheritedAttribute('_exec'),
(self, bound_data, args, kw))
gettext = gettext
# Dummy dtml-gettext tag
from DocumentTemplate.DT_Util import InstanceDict, namespace, render_blocks
class GettextTag:
""" """
name = 'gettext'
blockContinuations = ()
def __init__(self, blocks):
tname, args, section = blocks[0]
self.section = section.blocks
def __call__(self, md):
ns = namespace(md)[0]
md._push(InstanceDict(ns, md))
message = render_blocks(self.section, md)
md._pop(1)
return message
# Register the dtml-gettext tag
from DocumentTemplate.DT_String import String
if not String.commands.has_key('gettext'):
String.commands['gettext'] = GettextTag
product/Localizer/Makefile 0 → 100644
View file @ 52146f5e
PYTHON=python
po:
${PYTHON} zgettext.py *.py ui/*.dtml -l ca de es eu fr hu it ja pt ru
mo:
${PYTHON} zgettext.py -m
clean:
rm -f *~ *.pyc
rm -f locale/*~ locale/locale.pot.bak locale/*.mo
rm -f help/*~
rm -f tests/*~ tests/*.pyc
rm -f ui/*~
test:
${PYTHON} tests/test_zgettext.py
binary: clean mo
rm -f refresh.txt
product/Localizer/MessageCatalog.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2007 Juan David Ibáñez Palomar <jdavid@itaapy.com>
# Copyright (C) 2003 Roberto Quero, Eduardo Corrales
# Copyright (C) 2004 Søren Roug
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
This module provides the MessageCatalog base class, which
provides message catalogs for the web.
"""
# Import from the Standard Library
from base64 import encodestring, decodestring
from hashlib import md5
from re import compile
from time import gmtime, strftime, time
from urllib import quote
# Import from itools
from itools.datatypes import LanguageTag
import itools.gettext
from itools.tmx import TMXFile, Sentence, TMXUnit, TMXNote
from itools.xliff import XLFFile, XLFNote
# Import from Zope
from AccessControl import ClassSecurityInfo
from Acquisition import aq_base
from App.class_init import InitializeClass
from App.Dialogs import MessageDialog
from OFS.ObjectManager import ObjectManager
from OFS.SimpleItem import SimpleItem
from Persistence import PersistentMapping
from ZPublisher import HTTPRequest
from zope.component import getSiteManager
from zope.i18n import interpolate
from zope.i18n.interfaces import ITranslationDomain
from zope.interface import implements
# Import from Localizer
from interfaces import IMessageCatalog
from LanguageManager import LanguageManager
from LocalFiles import LocalDTMLFile
from utils import charsets, lang_negotiator, _
###########################################################################
# Utility functions and constants
###########################################################################
def md5text(str):
"""Create an MD5 sum (or hash) of a text. It is guaranteed to be 32 bytes
long.
"""
return md5(str.encode('utf-8')).hexdigest()
def to_unicode(x):
"""In Zope the ISO-8859-1 encoding has an special status, normal strings
are considered to be in this encoding by default.
"""
if isinstance(x, unicode):
return x
encoding = HTTPRequest.default_encoding
return unicode(x, encoding)
def message_encode(message):
"""Encodes a message to an ASCII string.
To be used in the user interface, to avoid problems with the
encodings, HTML entities, etc..
"""
if isinstance(message, unicode):
encoding = HTTPRequest.default_encoding
message = message.encode(encoding)
return encodestring(message)
def message_decode(message):
"""Decodes a message from an ASCII string.
To be used in the user interface, to avoid problems with the
encodings, HTML entities, etc..
"""
message = decodestring(message)
encoding = HTTPRequest.default_encoding
return unicode(message, encoding)
def filter_sort(x, y):
return cmp(to_unicode(x), to_unicode(y))
def get_url(url, batch_start, batch_size, regex, lang, empty, **kw):
params = []
for key, value in kw.items():
if value is None:
continue
if isinstance(value, unicode):
value = value.encode('utf-8')
params.append('%s=%s' % (key, quote(value)))
params.extend(['batch_start:int=%d' % batch_start,
'batch_size:int=%d' % batch_size,
'regex=%s' % quote(regex),
'empty=%s' % (empty and 'on' or '')])
if lang:
params.append('lang=%s' % lang)
return url + '?' + '&amp;'.join(params)
# Empty header information for PO files (UTF-8 is the default encoding)
empty_po_header = {'last_translator_name': '',
'last_translator_email': '',
'language_team': '',
'charset': 'UTF-8'}
###########################################################################
# The Message Catalog class, and ZMI constructor
###########################################################################
manage_addMessageCatalogForm = LocalDTMLFile('ui/MC_add', globals())
def manage_addMessageCatalog(self, id, title, languages, sourcelang=None,
REQUEST=None):
""" """
if sourcelang is None:
sourcelang = languages[0]
self._setObject(id, MessageCatalog(id, title, sourcelang, languages))
if REQUEST is not None:
return self.manage_main(self, REQUEST)
class MessageCatalog(LanguageManager, ObjectManager, SimpleItem):
"""Stores messages and their translations...
"""
meta_type = 'MessageCatalog'
implements(IMessageCatalog)
security = ClassSecurityInfo()
def __init__(self, id, title, sourcelang, languages):
self.id = id
self.title = title
# Language Manager data
self._languages = tuple(languages)
self._default_language = sourcelang
# Here the message translations are stored
self._messages = PersistentMapping()
# Data for the PO files headers
self._po_headers = PersistentMapping()
for lang in self._languages:
self._po_headers[lang] = empty_po_header
#######################################################################
# ITranslationDomain interface
# zope.i18n.interfaces.ITranslationDomain
#######################################################################
@property
def domain(self):
""" """
return unicode(self.id)
def translate(self, msgid, mapping=None, context=None,
target_language=None, default=None):
""" """
msgstr = self.gettext(msgid, lang=target_language, default=default)
return interpolate(msgstr, mapping)
#######################################################################
# Private API
#######################################################################
def get_message_key(self, message):
if message in self._messages:
return message
# A message may be stored as unicode or byte string
encoding = HTTPRequest.default_encoding
if isinstance(message, unicode):
message = message.encode(encoding)
else:
message = unicode(message, encoding)
if message in self._messages:
return message
def get_translations(self, message):
message = self.get_message_key(message)
return self._messages[message]
def get_tabs_message(self, REQUEST):
message = REQUEST.get('manage_tabs_message')
if message is None:
return None
return unicode(message, 'utf-8')
#######################################################################
# Public API
#######################################################################
security.declarePublic('message_exists')
def message_exists(self, message):
""" """
return self._messages.has_key(message)
security.declareProtected('Manage messages', 'message_edit')
def message_edit(self, message, language, translation, note):
""" """
self._messages[message][language] = translation
self._messages[message]['note'] = note
security.declareProtected('Manage messages', 'message_del')
def message_del(self, message):
""" """
del self._messages[message]
security.declarePublic('gettext')
def gettext(self, message, lang=None, add=1, default=None):
"""Returns the message translation from the database if available.
If add=1, add any unknown message to the database.
If a default is provided, use it instead of the message id
as a translation for unknown messages.
"""
if not isinstance(message, (str, unicode)):
raise TypeError, 'only strings can be translated.'
message = message.strip()
if default is None:
default = message
# Add it if it's not in the dictionary
if add and not self._messages.has_key(message) and message:
self._messages[message] = PersistentMapping()
# Get the string
if self._messages.has_key(message):
m = self._messages[message]
if lang is None:
# Builds the list of available languages
# should the empty translations be filtered?
available_languages = list(self._languages)
# Imagine that the default language is 'en'. There is no
# translation from 'en' to 'en' in the message catalog
# The user has the preferences 'en' and 'nl' in that order
# The next two lines make certain 'en' is shown, not 'nl'
if not self._default_language in available_languages:
available_languages.append(self._default_language)
# Get the language!
lang = lang_negotiator(available_languages)
# Is it None? use the default
if lang is None:
lang = self._default_language
if lang is not None:
return m.get(lang) or default
return default
__call__ = gettext
#######################################################################
# Management screens
#######################################################################
manage_options = (
{'label': u'Messages', 'action': 'manage_messages',
'help': ('Localizer', 'MC_messages.stx')},
{'label': u'Properties', 'action': 'manage_propertiesForm'},
{'label': u'Import', 'action': 'manage_Import_form',
'help': ('Localizer', 'MC_importExport.stx')},
{'label': u'Export', 'action': 'manage_Export_form',
'help': ('Localizer', 'MC_importExport.stx')}) \
+ LanguageManager.manage_options \
+ SimpleItem.manage_options
#######################################################################
# Management screens -- Messages
#######################################################################
security.declareProtected('Manage messages', 'manage_messages')
manage_messages = LocalDTMLFile('ui/MC_messages', globals())
security.declarePublic('get_namespace')
def get_namespace(self, REQUEST):
"""For the management interface, allows to filter the messages to
show.
"""
# Check whether there are languages or not
languages = self.get_languages_mapping()
if not languages:
return {}
# Input
batch_start = REQUEST.get('batch_start', 0)
batch_size = REQUEST.get('batch_size', 15)
empty = REQUEST.get('empty', 0)
regex = REQUEST.get('regex', '')
message = REQUEST.get('msg', None)
# Build the namespace
namespace = {}
namespace['batch_size'] = batch_size
namespace['empty'] = empty
namespace['regex'] = regex
# The language
lang = REQUEST.get('lang', None) or languages[0]['code']
namespace['language'] = lang
# Filter the messages
query = regex.strip()
try:
query = compile(query)
except:
query = compile('')
messages = []
for m, t in self._messages.items():
if query.search(m) and (not empty or not t.get(lang, '').strip()):
messages.append(m)
messages.sort(filter_sort)
# How many messages
n = len(messages)
namespace['n_messages'] = n
# Calculate the start
while batch_start >= n:
batch_start = batch_start - batch_size
if batch_start < 0:
batch_start = 0
namespace['batch_start'] = batch_start
# Select the batch to show
batch_end = batch_start + batch_size
messages = messages[batch_start:batch_end]
# Batch links
namespace['previous'] = get_url(REQUEST.URL, batch_start - batch_size,
batch_size, regex, lang, empty)
namespace['next'] = get_url(REQUEST.URL, batch_start + batch_size,
batch_size, regex, lang, empty)
# Get the message
message_encoded = None
translations = {}
if message is None:
if messages:
message = messages[0]
translations = self.get_translations(message)
message = to_unicode(message)
message_encoded = message_encode(message)
else:
message_encoded = message
message = message_decode(message_encoded)
translations = self.get_translations(message)
message = to_unicode(message)
namespace['message'] = message
namespace['message_encoded'] = message_encoded
namespace['translations'] = translations
namespace['translation'] = translations.get(lang, '')
namespace['note'] = translations.get('note', '')
# Calculate the current message
namespace['messages'] = []
for x in messages:
x = to_unicode(x)
x_encoded = message_encode(x)
url = get_url(
REQUEST.URL, batch_start, batch_size, regex, lang, empty,
msg=x_encoded)
namespace['messages'].append({
'message': x,
'message_encoded': x_encoded,
'current': x == message,
'url': url})
# The languages
for language in languages:
code = language['code']
language['name'] = _(language['name'], language=code)
language['url'] = get_url(REQUEST.URL, batch_start, batch_size,
regex, code, empty, msg=message_encoded)
namespace['languages'] = languages
return namespace
security.declareProtected('Manage messages', 'manage_editMessage')
def manage_editMessage(self, message, language, translation, note,
REQUEST, RESPONSE):
"""Modifies a message.
"""
message_encoded = message
message = message_decode(message_encoded)
message_key = self.get_message_key(message)
self.message_edit(message_key, language, translation, note)
url = get_url(REQUEST.URL1 + '/manage_messages',
REQUEST['batch_start'], REQUEST['batch_size'],
REQUEST['regex'], REQUEST.get('lang', ''),
REQUEST.get('empty', 0),
msg=message_encoded,
manage_tabs_message=_(u'Saved changes.'))
RESPONSE.redirect(url)
security.declareProtected('Manage messages', 'manage_delMessage')
def manage_delMessage(self, message, REQUEST, RESPONSE):
""" """
message = message_decode(message)
message_key = self.get_message_key(message)
self.message_del(message_key)
url = get_url(REQUEST.URL1 + '/manage_messages',
REQUEST['batch_start'], REQUEST['batch_size'],
REQUEST['regex'], REQUEST.get('lang', ''),
REQUEST.get('empty', 0),
manage_tabs_message=_(u'Saved changes.'))
RESPONSE.redirect(url)
#######################################################################
# Management screens -- Properties
# Management screens -- Import/Export
# FTP access
#######################################################################
security.declareProtected('View management screens',
'manage_propertiesForm')
manage_propertiesForm = LocalDTMLFile('ui/MC_properties', globals())
security.declareProtected('View management screens', 'manage_properties')
def manage_properties(self, title, REQUEST=None, RESPONSE=None):
"""Change the Message Catalog properties.
"""
self.title = title
if RESPONSE is not None:
RESPONSE.redirect('manage_propertiesForm')
# Properties management screen
security.declareProtected('View management screens', 'get_po_header')
def get_po_header(self, lang):
""" """
# For backwards compatibility
if not hasattr(aq_base(self), '_po_headers'):
self._po_headers = PersistentMapping()
return self._po_headers.get(lang, empty_po_header)
security.declareProtected('View management screens', 'update_po_header')
def update_po_header(self, lang,
last_translator_name=None,
last_translator_email=None,
language_team=None,
charset=None,
REQUEST=None, RESPONSE=None):
""" """
header = self.get_po_header(lang)
if last_translator_name is None:
last_translator_name = header['last_translator_name']
if last_translator_email is None:
last_translator_email = header['last_translator_email']
if language_team is None:
language_team = header['language_team']
if charset is None:
charset = header['charset']
header = {'last_translator_name': last_translator_name,
'last_translator_email': last_translator_email,
'language_team': language_team,
'charset': charset}
self._po_headers[lang] = header
if RESPONSE is not None:
RESPONSE.redirect('manage_propertiesForm')
security.declareProtected('View management screens', 'manage_Import_form')
manage_Import_form = LocalDTMLFile('ui/MC_Import_form', globals())
security.declarePublic('get_charsets')
def get_charsets(self):
""" """
return charsets[:]
security.declarePublic('manage_export')
def manage_export(self, x, REQUEST=None, RESPONSE=None):
"""Exports the content of the message catalog either to a template
file (locale.pot) or to an language specific PO file (<x>.po).
"""
# Get the PO header info
header = self.get_po_header(x)
last_translator_name = header['last_translator_name']
last_translator_email = header['last_translator_email']
language_team = header['language_team']
charset = header['charset']
# PO file header, empty message.
po_revision_date = strftime('%Y-%m-%d %H:%m+%Z', gmtime(time()))
pot_creation_date = po_revision_date
last_translator = '%s <%s>' % (last_translator_name,
last_translator_email)
if x == 'locale.pot':
language_team = 'LANGUAGE <LL@li.org>'
else:
language_team = '%s <%s>' % (x, language_team)
r = ['msgid ""',
'msgstr "Project-Id-Version: %s\\n"' % self.title,
'"POT-Creation-Date: %s\\n"' % pot_creation_date,
'"PO-Revision-Date: %s\\n"' % po_revision_date,
'"Last-Translator: %s\\n"' % last_translator,
'"Language-Team: %s\\n"' % language_team,
'"MIME-Version: 1.0\\n"',
'"Content-Type: text/plain; charset=%s\\n"' % charset,
'"Content-Transfer-Encoding: 8bit\\n"',
'', '']
# Get the messages, and perhaps its translations.
d = {}
if x == 'locale.pot':
filename = x
for k in self._messages.keys():
d[k] = ""
else:
filename = '%s.po' % x
for k, v in self._messages.items():
try:
d[k] = v[x]
except KeyError:
d[k] = ""
# Generate the file
def backslashescape(x):
quote_esc = compile(r'"')
x = quote_esc.sub('\\"', x)
trans = [('\n', '\\n'), ('\r', '\\r'), ('\t', '\\t')]
for a, b in trans:
x = x.replace(a, b)
return x
# Generate sorted msgids to simplify diffs
dkeys = d.keys()
dkeys.sort()
for k in dkeys:
r.append('msgid "%s"' % backslashescape(k))
v = d[k]
r.append('msgstr "%s"' % backslashescape(v))
r.append('')
if RESPONSE is not None:
RESPONSE.setHeader('Content-type','application/data')
RESPONSE.setHeader('Content-Disposition',
'inline;filename=%s' % filename)
r2 = []
for x in r:
if isinstance(x, unicode):
r2.append(x.encode(charset))
else:
r2.append(x)
return '\n'.join(r2)
security.declareProtected('Manage messages', 'po_import')
def po_import(self, lang, data):
""" """
messages = self._messages
# Load the data
po = itools.gettext.POFile(string=data)
for msgid in po.get_msgids():
# TODO Keep the context if any
_context, msgid = msgid
if msgid:
msgstr = po.get_msgstr(msgid) or ''
if not messages.has_key(msgid):
messages[msgid] = PersistentMapping()
messages[msgid][lang] = msgstr
# Set the encoding (the full header should be loaded XXX)
self.update_po_header(lang, charset=po.get_encoding())
security.declareProtected('Manage messages', 'manage_import')
def manage_import(self, lang, file, REQUEST=None, RESPONSE=None):
""" """
# XXX For backwards compatibility only, use "po_import" instead.
if isinstance(file, str):
content = file
else:
content = file.read()
self.po_import(lang, content)
if RESPONSE is not None:
RESPONSE.redirect('manage_messages')
def objectItems(self, spec=None):
""" """
for lang in self._languages:
if not hasattr(aq_base(self), lang):
self._setObject(lang, POFile(lang))
r = MessageCatalog.inheritedAttribute('objectItems')(self, spec)
return r
#######################################################################
# TMX support
security.declareProtected('View management screens', 'manage_Export_form')
manage_Export_form = LocalDTMLFile('ui/MC_Export_form', globals())
security.declareProtected('Manage messages', 'tmx_export')
def tmx_export(self, REQUEST, RESPONSE=None):
"""Exports the content of the message catalog to a TMX file
"""
src_lang = self._default_language
# Get the header info
header = self.get_po_header(src_lang)
charset = header['charset']
# Init the TMX handler
tmx = TMXFile()
tmx.header['creationtool'] = u'Localizer'
tmx.header['creationtoolversion'] = u'1.x'
tmx.header['datatype'] = u'plaintext'
tmx.header['segtype'] = u'paragraph'
tmx.header['adminlang'] = src_lang
tmx.header['srclang'] = src_lang
tmx.header['o-encoding'] = u'%s' % charset.lower()
# handle messages
for msgkey, transunit in self._messages.items():
unit = TMXUnit({})
for lang in transunit.keys():
if lang != 'note':
sentence = Sentence({'lang': lang})
sentence.text = transunit[lang]
unit.msgstr[lang] = sentence
if src_lang not in transunit.keys():
sentence = Sentence({'lang': src_lang})
sentence.text = msgkey
unit.msgstr[src_lang] = sentence
if transunit.has_key('note'):
note = TMXNote(transunit.get('note'))
unit.notes.append(note)
tmx.messages[msgkey] = unit
if RESPONSE is not None:
RESPONSE.setHeader('Content-type','application/data')
RESPONSE.setHeader('Content-Disposition',
'attachment; filename="%s.tmx"' % self.id)
return tmx.to_str()
security.declareProtected('Manage messages', 'tmx_import')
def tmx_import(self, howmuch, file, REQUEST=None, RESPONSE=None):
"""Imports a TMX level 1 file.
"""
try:
data = file.read()
tmx = TMXFile(string=data)
except:
return MessageDialog(title = 'Parse error',
message = _('impossible to parse the file') ,
action = 'manage_Import_form',)
num_notes = 0
num_trans = 0
if howmuch == 'clear':
# Clear the message catalogue prior to import
self._messages = {}
self._languages = ()
self._default_language = tmx.get_srclang()
for id, msg in tmx.messages.items():
if not self._messages.has_key(id) and howmuch == 'existing':
continue
msg.msgstr.pop(self._default_language)
if not self._messages.has_key(id):
self._messages[id] = {}
for lang in msg.msgstr.keys():
# normalize the languageTag and extract the core
(core, local) = LanguageTag.decode(lang)
lang = LanguageTag.encode((core, local))
if lang not in self._languages:
self._languages += (lang,)
if msg.msgstr[lang].text:
self._messages[id][lang] = msg.msgstr[lang].text
if core != lang and core != self._default_language:
if core not in self._languages:
self._languages += (core,)
if not msg.msgstr.has_key(core):
self._messages[id][core] = msg.msgstr[lang].text
if msg.notes:
ns = [m.text for m in msg.notes]
self._messages[id]['note'] = u' '.join(ns)
num_notes += 1
num_trans += 1
if REQUEST is not None:
message = _(u'Imported %d messages and %d notes')
return MessageDialog(
title = _(u'Messages imported'),
message = message % (num_trans, num_notes),
action = 'manage_messages')
#######################################################################
# Backwards compatibility (XXX)
#######################################################################
hasmsg = message_exists
hasLS = message_exists # CMFLocalizer uses it
security.declareProtected('Manage messages', 'xliff_export')
def xliff_export(self, dst_lang, export_all=1, REQUEST=None,
RESPONSE=None):
"""Exports the content of the message catalog to an XLIFF file
"""
from DateTime import DateTime
src_lang = self._default_language
export_all = int(export_all)
# Init the XLIFF handler
xliff = XLFFile()
# Add the translation units
original = '/%s' % self.absolute_url(1)
for msgkey, transunit in self._messages.items():
target = transunit.get(dst_lang, '')
# If 'export_all' is true export all messages, otherwise export
# only untranslated messages
if export_all or not target:
unit = xliff.add_unit(original, msgkey, None)
unit.attributes['id'] = md5text(msgkey)
if target:
unit.target = target
# Add note
note = transunit.get('note')
if note:
unit.notes.append(XLFNote(note))
# build the data-stucture for the File tag
file = xliff.files[original]
attributes = file.attributes
attributes['original'] = original
attributes['product-name'] = u'Localizer'
attributes['product-version'] = u'1.1.x'
attributes['data-type'] = u'plaintext'
attributes['source-language'] = src_lang
attributes['target-language'] = dst_lang
attributes['date'] = DateTime().HTML4()
# Serialize
xliff = xliff.to_str()
# Set response headers
RESPONSE.setHeader('Content-Type', 'text/xml; charset=UTF-8')
filename = '%s_%s_%s.xlf' % (self.id, src_lang, dst_lang)
RESPONSE.setHeader('Content-Disposition',
'attachment; filename="%s"' % filename)
# Ok
return xliff
security.declareProtected('Manage messages', 'xliff_import')
def xliff_import(self, howmuch, file, REQUEST=None):
"""XLIFF is the XML Localization Interchange File Format designed by a
group of software providers. It is specified by www.oasis-open.org
"""
try:
data = file.read()
xliff = XLFFile(string=data)
except:
return MessageDialog(title = 'Parse error',
message = _('impossible to parse the file') ,
action = 'manage_Import_form',)
num_notes = 0
num_trans = 0
(file_ids, sources, targets) = xliff.get_languages()
if howmuch == 'clear':
# Clear the message catalogue prior to import
self._messages = {}
self._languages = ()
self._default_language = sources[0]
# update languages
if len(sources) > 1 or sources[0] != self._default_language:
return MessageDialog(title = 'Language error',
message = _('incompatible language sources') ,
action = 'manage_Import_form',)
for lang in targets:
if lang != self._default_language and lang not in self._languages:
self._languages += (lang,)
# get messages
for file in xliff.files:
cur_target = file.attributes.get('target-language', '')
for msg in file.body.keys():
if not self._messages.has_key(msg) and howmuch == 'existing':
pass
else:
if not self._messages.has_key(msg):
self._messages[msg] = {}
if cur_target and file.body[msg].target:
self._messages[msg][cur_target] = file.body[msg].target
num_trans += 1
if file.body[msg].notes:
ns = [n.text for n in file.body[msg].notes]
comment = ' '.join(ns)
self._messages[msg]['note'] = comment
num_notes += 1
if REQUEST is not None:
return MessageDialog(
title = _(u'Messages imported'),
message = (_(u'Imported %d messages and %d notes to %s') % \
(num_trans, num_notes, ' '.join(targets))),
action = 'manage_messages')
class POFile(SimpleItem):
""" """
security = ClassSecurityInfo()
def __init__(self, id):
self.id = id
security.declareProtected('FTP access', 'manage_FTPget')
def manage_FTPget(self):
""" """
return self.manage_export(self.id)
security.declareProtected('Manage messages', 'PUT')
def PUT(self, REQUEST, RESPONSE):
""" """
body = REQUEST['BODY']
self.po_import(self.id, body)
RESPONSE.setStatus(204)
return RESPONSE
InitializeClass(MessageCatalog)
InitializeClass(POFile)
def MessageCatalog_moved(object, event):
# FIXME This does not work if what we move is the folder that contains
# the message catalog
container = event.oldParent
if container is not None:
sm = getSiteManager(container)
sm.unregisterUtility(object, ITranslationDomain, event.oldName)
container = event.newParent
if container is not None:
sm = getSiteManager(container)
sm.registerUtility(object, ITranslationDomain, event.newName)
product/Localizer/README.txt 0 → 100644
View file @ 52146f5e
Localizer is the de-facto standard to build multilingual applications with
Zope. It helps to internationalize and localize Zope products and to build
multilingual web sites through the Management Interface. It deals with
both user interfaces and content.
Requirements
- Python 2.5.2 or later
- Zope 2.12.2 or later
- itools 0.50.6 or later (download from
"http://www.hforge.org/itools":http://www.hforge.org/itools)
Installation
Download Localizer. Unpack the tarball and install it in the "Products"
directory::
$ tar xzf Localizer-1.3.0.tar.gz
$ cp -r Localizer-1.3.0 <Zope instance>/Products/Localizer
Another option, case you are running Unix, is to use symbolic links::
$ ln -s Localizer-1.3.0 <Zope instance>/Products/Localizer
Resources
- "Home site":http://www.localizer.org/
- "Mailing list subscription":http://www.hforge.org/community
- "Mailing list archives":http://archives.hforge.org/index.cgi?list=localizer
- "Bug Tracker":http://bugs.hforge.org/
Examples of sites powered by Localizer
- "European Environment Agency":http://www.eea.eu.int/
- "Bank Winter":http://www.bankwinter.com/
- "Castagnari":http://www.castagnari.com/
- "Hiru":http://www.hiru.com/
- "Hotsak":http://www.hotsak.com/
- "Ego Ibarra":http://www.egoibarra.com/
- "Udaleuskaltegiak":http://www.udaleuskaltegiak.net/
Author and License
Copyright 2001-2010 J. David Ibez (jdavid@itaapy.com)
2001 Universitat Jaume I
This program 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 3 of the License, or
(at your option) any later version.
This program 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.
You should have received a copy of the GNU General Public License
along with this program. If not, see
"http://www.gnu.org/licenses/":http://www.gnu.org/licenses/
product/Localizer/RELEASE-1.3.0 0 → 100644
View file @ 52146f5e
Localizer 1.3.0 (2009/XX/XX)
============================
Localizer is a Zope product for developers and web masters. Localizer
solves the problem of building multilingual products and web sites,
ranging from internationalization and localization of the user
interface to management of multilingual content.
What is new?
------------
Upgraded to Zope 2.12, Python 2.5 and itools 0.50 (previous versions are
not supported).
Some API obsolete since at least 2004 has been removed:
- The 'ugettext' function has been removed from DTML and ZPT templates,
use instead 'gettext'.
- Four methods from the 'LocalPropertyManger' class have been removed:
_setLocalPropValue => set_localpropvalue
_setLocalProperty => set_localproperty
_delLocalProperty => del_localproperty
getLocalProperty => getLocalAttribute
Resources
---------
Download
http://download.hforge.org/localizer/Localizer-1.3.0.tar.gz
http://download.hforge.org/itools/0.50/itools-0.50.7.tar.gz
Home
http://www.localizer.org/
Mailing list
http://www.hforge.org/community
http://archives.hforge.org/index.cgi?list=localizer
Bug Tracker
http://bugs.hforge.org/
product/Localizer/TODO.txt 0 → 100644
View file @ 52146f5e
See http://in-girum.net/cgi-bin/bugzilla/index.cgi
Things should be removed from here and added to the bug tracker.
Bugs
----
- Bo M. Maryniuck:
"I can't reproduce the error anymore though I can't send you traceback,
but I just found, that Localizer crashes Medusa threads if someone else
object uses "register before traverse". In my case there is an product,
which is always modifies the request. So if I put there also Localizer,
you'll never enter the site.
Quality Assurance
-----------------
- Audit the code, update the idioms (e.g. use "get_context" to access the
request and response objects).
API
---
- When importing modules from Localizer, either the sort or the long
way should always be used. Update the documentation to reflect it
(Rainer Thaden).
Where the sort form is:
from Products.Localizer import LocalPropertyManager
and the long form is:
from Products.Localizer.LocalPropertyManager import LocalPropertyManager
See if this can be addressed without compromising backwards compatibility,
if not document exactly which is the current situation.
- Develop an API to get messages and translations from the message catalog,
see email from Pierre-Yves Delens.
- Implement the whole mapping interface in the "AcceptLanguage" and
"AcceptCharset" classes (itools.i18n.accept). Sugested by Bjorn.
Documentation
-------------
- Update (rewrite) the documentation. Most likely to be in latex, and
distributed with the source.
- Add a section "Localizer application anatomy" to the tutorial:
"One thing you may want to consider is an overview of how a site
using all the products should be laid out. The examples and guide
you are providing are very very good and explain all the techcinal
components of the variouse packages quite well. What seems to be
missing is a higher level view that ties it all together in terms
of layout for a demo site.
An example of a 2-3 language basic site that uses the variouse
components would be very attractive for new programs and users
(moi) and help the adoption of this most excellent product."
- Comment about "management_page_charset" to switch the ZMI to utf-8,
or maybe patch Zope so they're in utf-8 by default.
Localizer.org
-------------
- Kill "http://www.j-david.net/software/localizer", everything should be
in "http://www.ikaaro.org/localizer".
User Interface (ZMI)
--------------------
- Complete the help screens.
- Be sure the framed messages appear in all the management screens every
time an action is performed, i.e. "Content changed (2002-02-08 15:26)".
- Add PrincipiaSearchSource
Standards Support
-----------------
- Support fuzzy in "itools.handlers.PO".
- Use the library libgettextpo introduced in gettext 0.12 to parse the
PO files?? See the docs: "Writing your own programs that process PO
files"
Message Extraction
------------------
- Kill "zgettext", use "igettext" from "itools.i18n" instead.
- Add support for ZPT to "igettext". This means to implement part of
the "i18n" namespace in "itools.xml.ZPT". See [1] for a sample code.
[1] http://savannah.nongnu.org/cgi-bin/viewcvs/opental/opental/OpenPTi18n/i18n_xgettext.py?rev=1.8&content-type=text/vnd.viewcvs-markup
Not yet classified
------------------
- (Zope bug) See if something feasible can be done to remove the hardcoded
use of Latin-1 encoding from Zope and Localizer.
If not, explain which the problems are and what the developer can
do (add this as a task for the documentation).
- When importing a message catalog, should be done something with
the header? When managing the message catalog through FTP, should
the header also be editable?
- François Meehan:
"Also found that using the import/export function in Localizer/zope
can bring corruption to the po file, a problem with the accents it
seems."
- Document the path where Localizer.changeLanguage sets the cookie,
which is the path from where it is called, not its physical path.
See the mails exchanged with Claus Rosenberger. Maybe a FAQ?
- Work on locale information: dates, money, etc..
- Integrate the File System Message Catalog from CMFLocalizer.
- Add the ability to manage localized versions of standard files
in a product: the on-line help system, README.txt, etc..
- Let to implement ZClasses that inherite from 'MessageCatalog'
- Set the 'Vary' header.
The problem is: which value should it have?
This could allow to remove the patch to Zope for images, if UA
take care of the 'Vary' header.
- Rework 'changeLanguageForm' to support browsers without javascript.
- Build user management interfaces similar to the ZMI
(standard_html_header/footer instead of manage_page_header/footer
and manage_tabs).
product/Localizer/UPGRADE.txt 0 → 100644
View file @ 52146f5e
***************************************************************************
Localizer 0.8.1
***************************************************************************
* The request variable USER_PREF_LANGUAGES isn't a list anymore,
now it's an object that represents a tree. Any code that directly
reads or modifies USER_PREF_LANGUAGES will be broken. Tell me
if you did it.
* The Localizer class provides a feature known as "locale folders"
that lets to manage any kind of multilingual content. Now this
feature is deprecated. A new class named "LocalFolder" provides
a better solution for this, please move to it as soon as posible,
in the next release the deprecated feature will be removed!!
The quickest way to move from "Localizer" to "LocalFolder" is:
0. Do a backup of the database;
1. Create in the root of your web site a "LocalFolder" instance called,
for example, "locale";
2. Go to the management screens of "locale" and create an attribute
named, for example, "folder";
3. Add as many languages as needed in the tab "Languages";
4. Create a folder for every language in the "Contents" tab, for
example, "folder_en", "folder_es", etc..;
5. For each language copy all the stuff from the Localizer instance
to "locale". For example, copy everything in "Localizer/es" to
"locale/folder_es";
6. Now the most time expensive step, go to all the templates and scripts
that refer to any object in the "Localizer" instance and change to
use "locale" instead.
For example, if you had an image named "logo" and you called it with:
<dtml-var logo>
change it to:
<dtml-with locale><dtml-var logo></dtml-with>
or to:
<dtml-var "locale.logo()">
Hopefully you will have to modify few methods;
7. And finally, remove the "Localizer" instance!!
* The previous way to internationalize Python code from Python
products has been deprecated. Read the documentation to know
how it should be done from now on. However, the deprecated
way will be preserved for a while, probably a long while.
***************************************************************************
Localizer 0.8.0
***************************************************************************
* The 0.7 version saw a big redesign of message catalogs, and
also of the way they're used. Before they were implicitly called,
through a globaly available "gettext" method, this feature
was implemented in the "Localizer" class.
In the 0.7 version message catalogs became an independent class,
its instances are explicitly called. The old way to use message
catalogs was preserved for backwards compatibility.
Now, in version 0.8, the old way to use message catalogs (through
the global "gettext" method) has been removed. To upgrade to this
version follow the steps:
0. If you upgrade from a version previous to 0.7 upgrade first
to 0.7.x
1. Move all your 'MessageCatalog' instances with the id
'Messages' that are inside of a 'Localizer' instance
to the same level in the hierarchy where is the
'Localizer' object, but with the name 'gettext'.
For example if you have "/a/b/c/Localizer/Messages" you
should move the 'Messages' object to "/a/b/c/gettext".
[!] This will work in most situations, you only could get
wrong behaviour if you're using Localizer instances
inside other Localizer instances. For example if you
have the objects "/a/b/c/Localizer/Messages" and
"/a/b/c/d/Localizer/Messages".
I guess very few people, if any, will have a configuration
like this one, so I don't provide any upgrade path. If
you've something like this send me an email before doing
anything.
2. Don't do anything for a few days, just to be sure that
everything works.
3. Upgrade to the 0.8 version.
Don't hesitate to contact me if you have any problem or doubt.
***************************************************************************
Localizer 0.7.0
***************************************************************************
* There're several changes that require all Localizer instances
to be upgraded, to do so go to the management interfaces of
each Localizer instance and click the "upgrade" button that
will appear.
Be careful, the upgrading must be done with access rules
deactivated, for example: "www.foo.com/bar/Z/manage"
* LocalContent instances and other instances of classes that
inherit from LocalPropertyManager also need to be upgraded.
To do it just run the same script used to upgrade to the
0.6 version, it is:
obs = context.ZopeFind(context, None, None, None,
'isLocalPropertyManager == 1',
None, None, None, None, 1)
for path, ob in obs:
ob.manage_upgrade()
return '%d objects upgraded' % len(obs)
* There're several changes in the API that could break your
code if you have used directly the Localizer API, if in
doubt send me an email.
***************************************************************************
Localizer 0.6.1
***************************************************************************
Before 0.6.0 changeLanguageForm was a LocalDTMLFile, in 0.6.0
I changed it to a DTML Method. Now it's again a LocalDTMLFile.
To upgrade go to each Localizer instance and remove the
changeLanguageForm method. If you don't do it nothing will
break, but anyway it's encouraged.
If you're curious about this change, it's because I've finally
discovered which is the difference between DTMLFile and HTMLFile:
bindings can be used from a DTMLFile.
***************************************************************************
Localizer 0.6
***************************************************************************
* LocalContent and LocalPropertyManager
All LocalContent objects and instances of classes that inherit
from LocalPropertyManager need to be upgraded.
Create and run a Python script in the root with the code:
obs = context.ZopeFind(context, None, None, None,
'isLocalPropertyManager == 1',
None, None, None, None, 1)
for path, ob in obs:
ob.manage_upgrade()
return '%d objects upgraded' % len(obs)
* All Localizer instances also need to be upgraded, but it's done
automatically. To verify it:
- test that the 'hook_traversal' property has been removed.
- test that the Localizer has a DTML Method called changeLanguageForm.
Some future release, probably 0.7, will be incompatible with
versions < 0.6. So it won't be possible, for example, to upgrade
from 0.5.1 to 0.7 directly; it must be from 0.5.1 to 0.6.x to 0.7.
In short: upgrade to 0.6 as soon as posible!!
* Other minor changes:
- Now get_available_languages returns a list of tuples of two
elements: [(id, title), ..]
For example, [('en', 'English'), ('es', 'Spanish'), ...]
- Now the title of local folders is not used in changeLanguageForm.
Perhaps there're other minor changes that could break something.
***************************************************************************
Localizer 0.3
***************************************************************************
In Localizer versions < 0.3 the way to localize DTML files was:
from Products.Localizer.LocalizedDTMLFile import LocalizedDTMLFile
xxx = LocalizedDTMLFile('xxx', globals())
Since version 0.3 the right way to do it is:
from Products.Localizer import LocalDTMLFile
xxx = LocalDTMLFile('xxx', globals())
In 0.3 version the old way was still supported, but deprecated. Since
version 0.4 the old way is no longer available, so products using it
will break.
product/Localizer/__init__.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2005 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Check whether itools is installed
msg = ('itools 0.50 or later is needed, download from '
'http://download.hforge.org/itools/0.50')
try:
import itools
except ImportError:
raise ImportError, msg
# Check itools is version 0.50 or later
if itools.__version__ < '0.50':
raise ImportError, msg
# Import from the Standard Library
import os.path
# Import from Zope
from App.ImageFile import ImageFile
from DocumentTemplate.DT_String import String
# Import from Localizer
from patches import get_request
import Localizer, LocalContent, MessageCatalog, LocalFolder
from LocalAttributes import LocalAttribute
from LocalFiles import LocalDTMLFile, LocalPageTemplateFile
from LocalPropertyManager import LocalPropertyManager, LocalProperty
from GettextTag import GettextTag
misc_ = {'arrow_left': ImageFile('img/arrow_left.gif', globals()),
'arrow_right': ImageFile('img/arrow_right.gif', globals()),
'eye_opened': ImageFile('img/eye_opened.gif', globals()),
'eye_closed': ImageFile('img/eye_closed.gif', globals()),
'obsolete': ImageFile('img/obsolete.gif', globals())}
def initialize(context):
# Check Localizer is not installed with a name different than Localizer
# (this is a common mistake).
filename = os.path.split(os.path.split(__file__)[0])[1]
if filename != 'Localizer':
message = (
"The Localizer product must be installed within the 'Products'"
" folder with the name 'Localizer' (not '%s').") % filename
raise RuntimeError, message
# XXX This code has been written by Cornel Nitu, it may be a solution to
# upgrade instances.
## root = context._ProductContext__app
## for item in root.PrincipiaFind(root, obj_metatypes=['LocalContent'],
## search_sub=1):
## item[1].manage_upgrade()
# Register the Localizer
context.registerClass(Localizer.Localizer,
constructors = (Localizer.manage_addLocalizerForm,
Localizer.manage_addLocalizer),
icon = 'img/localizer.gif')
# Register LocalContent
context.registerClass(
LocalContent.LocalContent,
constructors = (LocalContent.manage_addLocalContentForm,
LocalContent.manage_addLocalContent),
icon='img/local_content.gif')
# Register MessageCatalog
context.registerClass(
MessageCatalog.MessageCatalog,
constructors = (MessageCatalog.manage_addMessageCatalogForm,
MessageCatalog.manage_addMessageCatalog),
icon='img/message_catalog.gif')
# Register LocalFolder
context.registerClass(
LocalFolder.LocalFolder,
constructors = (LocalFolder.manage_addLocalFolderForm,
LocalFolder.manage_addLocalFolder),
icon='img/local_folder.gif')
context.registerHelp()
# Register the dtml-gettext tag
String.commands['gettext'] = GettextTag
product/Localizer/archive/CHANGES.txt 0 → 100644
View file @ 52146f5e
***************************************************************************
See the "RELEASE.txt" file
***************************************************************************
1.1.2 (2005/10/21)
Upgrade to itools 0.9
1.1.1 (2005/05/26)
User Interface
- Improved message catalog user interface, suggested by Christopher
Lozinski.
Fixes
- Fix "LPM.get_available_languages" when property is empty.
- Backwards compatility improvements by Yoshinori Okuji.
- Fix Localizer with Zope 2.8, problem found by Lennart Regebro.
- Fixed english of the release notes, by Chris H.
1.1.0 (2005/04/10)
Nothing new, just some information files have been updated.
1.1.0rc1 (2005/03/21)
User Interface
- The text area to edit local properties is bigger now.
Packaging
- Check itools and iHotfix are installed.
1.1.0b5 (2005/01/28)
ZPT
- More robust support for the "i18n" namespace, check the domain object is
a message catalog.
User Interface
- New LocalPropertyManager/LocalContent interface, by Cornel Nitu.
Translations
- Updated the portuguese translation, by Rodrigo Senra.
Plone
- Remove conflict with PlacelessTranslationService, Plone and Localizer
work again together.
1.1.0b4 (2005/01/09)
ZPT
- Add support for i18n:domain
1.1.0b3 (2004/12/17)
Translations
- Added the italian version, by Marco Bizzarri
***************************************************************************
See "RELEASE.txt" for the changes between 0.8.1 and 1.1.0b3
***************************************************************************
0.8.1 (2002/02/25)
Now the language selection algorithm is compliant with the
RFC 2068 (HTTP 1.1).
New meta type LocalFolder. Now the "locale folders" feature of
the Localizer meta type are is deprecated, the new meta type
LocalFolder should be used instead.
Change internationalization of Python code from Python products.
Little cleanups: LocalObjects moved to LocalFiles;..
0.8.0 (2002/01/31)
Fixed bug in the ZMI reported by Magnus Heino.
Fixed use of file system message catalogs from ZPT.
Some improvements in the LanguageManager API.
Updated the few tests available to use PyUnit.
Fixed export of message catalogs, now the empty message is included.
Now LocalContent is CatalogAware, still remains to update the catalog
each time it's edited.
Now LocalPropertyManager implements __getattr__ to define attributes
of the form <name>_<lang>.
Moved the changeLanguageForm and changeLanguage helper methods to
the LanguageManager class.
Added the ugettext method in LocalObjects, beginning to work with
unicode.
Disabled the global gettext method that was added with a dynamnic patch
to to the Application class.
Improvements in the LocalPropertyManager web interface.
Now it's possible to change the default template for a LocalContent object.
0.7.1 (2001/10/26)
Improved zgettext.py script
First unit tests.
More online help screens.
Several security fixes.
Several bugs fixed.
Some minor improvements in the user interfaces.
Completed internationalization.
Updated several translations: french, hungarian and spanish.
0.7.0 (2001/10/10)
Several fixes in zgettext.py
New meta type MessageCatalog, it's possible to create message catalogs
with any id. Now the Localizer class no longer stores messages, but it
can contain MessageCatalog instances; specifically, if it contains a
MC named "Messages" gettext will behave in a similar way than before.
New mixin class LanguageManager that allows to manage list of available
languages and a default language. Used in LocalPropertyManager,
MessageCatalog and Localizer classes.
Added a dtml-gettext tag, useful for long messages.
Added the hungarian translation, thanks to Gabor Suveg.
Updated documentation.
More online help screens, improved some web interfaces.
0.6.2 (2001/10/01)
Completed the list of languages, ISO 639 compliance.
Now the language negotation algortithm is implemented in
a helper function (before this code was replicated in several
places).
Improvements in the message catalog user interface. Added a
help screen.
Minor changes in standard files (VERSION.txt and LICENSE.txt)
to comply ZDG guidelines.
0.6.1 (2001/09/28)
Added "original language" to LocalPropertyManager.
Minor improvements in the LocalPropertyManager user interface.
Now Localizer can be refreshed, except if Zope version >= 2.4.1b1.
Added the basque translation.
changeLanguageForm is a LocalDTMLFile again. Read UPGRADE.txt if
you're upgrading from 0.6.0
Some internal changes in the way message translations are searched.
Sometimes the translations were looked for in the wrong place, this
bug is fixed.
Now the localizer tutorial works with Zope < 2.4
0.6.0 (2001/09/25)
LocalPropertyManager
LocalProperty must be used always.
Improved user interface: posibility to add/delete languages;
show only few properties at a time.
Added a isLocalPropertyManager class attribute.
LocalPropertyManager can be used as base class for ZClasses.
LocalContent
Inherit also from PropertyManeger.
Localizer
Export and import message catalogs to and from .pot/.po files.
Changed the way to hook/unhook the traversal machinery.
Now changeLanguageForm is a DTML Method.
Now get_available_languages returns a list of tuples: [(id, title),..]
New method get_languages_map, used from changeLanguageForm.
Securtiy
Use "Declarative Assertions".
Several bugs fixed, mainly related with local folders. Also fixes
in zgettext.py, and probably others I don't remember now.
0.5.1 (2001/07/19)
Several fixes for LocalPropertyManager and LocalContent.
Added a tutorial (localizer_tutorial.zexp).
Now __version__ module attributes show the CVS revision number.
0.5.0 (2001/07/17)
Reorganization of the directory structure.
Added the LocalPropertyManager and LocalContent classes.
Patch OFS.Image to prevent browsers to cache images in localized folders.
0.4.0 (2001/07/10)
The gettext and locale modules have been removed, Python 2.x required.
License changed to GPL.
Management interface tabs internationalized, spanish and catalan
translations updated.
Fixed a bug in changeLanguage when the Localizer was used with other
SiteAccess, virtual hosting for example.
The script zgettext now keeps the locale.pot changes and uses msgmerge
to build the .po files.
Added new files BUGS.txt, TODO.txt and UPGRADE.txt
Old LocalizedDTMLFile removed.
0.3.0 (2001/06/..)
Fixed a bug that prevented proper copy&paste of Localized objects.
Changed the usage of localized dtml files, old usage preserved for
backwards compatibility.
Added support for page template files. Added documentation about
how to localize zpt.
0.2.1 (2001/05/23)
Ops, 0.2.0 bug fixed, I should test the code before releasing it,
apologies.
0.2.0 (2001/05/22)
Localized strings are looked for in all the Localizer instances in the path.
Now it's possible to override the user prefered language with the path.
Added the german version.
Some bugs fixed.
0.1.1 (2001/??/??)
Bug fixing release.
0.1.0 (2001/??/??)
Initial version.
product/Localizer/archive/RELEASE-0.9.0 0 → 100644
View file @ 52146f5e
Localizer 0.9.0
===============
General arquitecture
In the version 0.9 there're four meta types (Localizer, MessageCatalog,
LocalContent and LocalFolder), each one specialized in one task, finishing
this way with the confusion present in previous versions, where the
different features weren't clearly separated.
Previous versions mixed two features in the Localizer meta type, language
negotiation and generic support of multilingual objects.
Now the Localizer meta type is specialized in language negotiation. And a
new meta type, named LocalFolder, provides the generic support for language
negotiation following a different approach.
The old "locale folders" feature that was present in the Localizer meta
type has been definitely removed.
Language negotiation
This is one of the areas that has seen mayor improvements since version
0.8, now there's a simple default criteria to choose the language, based
only in the browser configuration. But the developer has much more power
to customize the language negotiation policy through the Localizer meta
type.
Also, the algorithm that chooses the language is finally standards compliant.
Unicode
The Unicode support is another of the big new features in this version.
To implement it now Localizer depends on the Unicode patches from Toby
Dickenson (http://www.zope.org/Members/htrd/wstring), which are part of
Zope since the version 2.6.
Now the policy is to use Python Unicode strings for everything:
- translations in the message catalog are stored as unicode strings;
- multilingual properties of LocalContent objects are stored as unicode
strings;
- the gettext method, when used from the file system, always returns
unicode strings (as the "ugettext" method of the "gettext" python
module).
The problem could raise when unicode and normal strings are mixed. By
default Python converts the normal strings to unicode as if they were
in ASCII. However, in Zope the default is considered to be iso-8859-1,
which is hardcoded in several places. Just be careful if you mix normal
and unicode strings, specially if they're in an encoding different than
iso-8859-1.
But maybe the main problem is the lack of proper unicode support in ZPT,
this will cause problems to anybody that wants to use ZPT and Unicode.
So it's likely that both Zope and Localizer will need a bit of work before
the Unicode support becomes stable.
Message Catalog
The message catalog interface has been completely redone. Now it correctly
supports multiline messages, including correct import and export from and
to PO files (thanks to Jean-Paul Smets).
There're other minor changes, like some improvements in the management
screens. The relevant links are:
- Home page
http://www.j-david.net/localizer
- Download
http://sourceforge.net/projects/lleu
- Mailing list
http://mail.freesoftware.fsf.org/mailman/listinfo/nuxeo-localizer
product/Localizer/archive/RELEASE-0.9.1 0 → 100644
View file @ 52146f5e
Localizer 0.9.1
===============
Localizer is a Zope [1] product that provides a set of facilities
to develop multilingual web applications. It offers solutions to
internationalize the user interfaces and to manage multilingual
content.
Localizer becomes beta
----------------------
Finally I've decided to officially declare Localizer as beta. This
means that no new features will be added for the 1.0 release, the
focus will be stability and documentation.
What's new
----------
Added unicode support to ZPT. Final version by Florent Guillaume.
New icons for all the meta types. Now Localizer has a logo (see logo.gif).
This is a contribution of Maite Rementeria, from Code&Syntax [2].
Spanish translation updated. New japanese version!, by Kazuya Fukamachi.
Some minor bugs fixed.
Resources
---------
Home page
http://www.j-david.net/software/localizer
Download
http://sourceforge.net/projects/lleu
Mailing list
http://mail.freesoftware.fsf.org/mailman/listinfo/nuxeo-localizer
Footnotes
---------
[1] http://www.zope.org
[2] http://www.codesyntax.com
product/Localizer/archive/RELEASE-0.9.2 0 → 100644
View file @ 52146f5e
Localizer 0.9.2
===============
Localizer is a Zope product that provides a set of facilities
to develop multilingual web applications. It offers solutions to
internationalize the user interfaces and to manage multilingual
content.
This is a bug fix release, the changes are:
- The "zgettext.py" script correctly parses Python files, to do
it the xgettext program from the GNU Gettext utilities is used.
- Now "zgettext.py" don't preserves the old messages in the
locale.pot file.
- Updated the Unicode patch, by Florent Guillaume.
- In some rare conditions the request object dissapears from the
global dictionary, this produces a key error when it's tried to be
removed. Fixed catching the exception (I couldn't reproduce the
error).
And a new "feature":
- Added the new module "LocalizerSupport.py", it helps to develop
Localizer based products that become monolingual when Localizer
is not installed (instead of becoming broken). It provides dummy
versions for some of the features of Localizer, not all.
Resources
---------
Home page
http://www.j-david.net/software/localizer
Download
http://sourceforge.net/projects/lleu
Mailing list
http://mail.freesoftware.fsf.org/mailman/listinfo/nuxeo-localizer
product/Localizer/archive/RELEASE-0.9.3 0 → 100644
View file @ 52146f5e
Localizer 0.9.3
===============
Localizer is a Zope product that provides a set of facilities
to develop multilingual web applications. It offers solutions to
internationalize the user interfaces and to manage multilingual
content.
This is a bug fix release, the changes are:
- Open MO files as binary files, this caused problems on Windows.
Thanks to Johan Carlsson
- Correctly copy and paste Localizer instances.
- Correctly detect Netscape 4.x, before Internet Explorer was thought
to be NS, this caused problems with the language negotiation. Thanks
to Olivier Nibart.
- Add the languages from a Localizer instance (if it exists) to the
languages input box of the LocalFolder add screen (as it already
was done with LocalContent).
- Quote messages in the Message Catalog interface, thanks to Geir Bækholt.
Resources
---------
Home page
http://www.localizer.org
Download
http://sourceforge.net/projects/lleu
Mailing list
http://mail.freesoftware.fsf.org/mailman/listinfo/nuxeo-localizer
product/Localizer/archive/RELEASE-1.0.0 0 → 100644
View file @ 52146f5e
Localizer 1.0.0
===============
Localizer is a Zope product that provides a set of facilities
to develop multilingual web applications. It offers solutions to
internationalize the user interfaces and to manage multilingual
content.
This is a bug fix release, the changes are:
- The dynamic global request patch is not installed if the static
version (by Tim McLaughlin) is already applied.
Resources
---------
Home page
http://www.localizer.org
Download
http://sourceforge.net/projects/lleu
Mailing list
http://mail.freesoftware.fsf.org/mailman/listinfo/nuxeo-localizer
product/Localizer/archive/RELEASE-1.0.1 0 → 100644
View file @ 52146f5e
Localizer 1.0.1
===============
Localizer is a Zope product that provides a set of facilities
to develop multilingual web applications. It offers solutions to
internationalize the user interfaces and to manage multilingual
content.
The changes of this release are:
- Added missing docstring to the Localizer class, thanks to
Christian Scholz.
- Strip the quality when parsing an accept header, this lets the
browser w3m and mobile phones to work, thanks to Helge Tesdal.
- Don't trigger Localizer instances when traversing if the request
variable AcceptLanguage does not exist. Thanks to Florent Guillaume.
- Now LocalPropertyManager.get_default_language returns None if
there isn't _default_language and get_languages returns an
empty list. Thanks to Greg Ward.
- Renamed the VERSION.txt file to version.txt, this lets to see the
version string from the control panel in the Zope management screens.
Thanks to Gilles Lenfant.
- Fixed bug in MessageCatalog.manage_export, thanks to Joachim Werner.
Resources
---------
Home page
http://www.localizer.org
Download
http://sourceforge.net/projects/lleu
Mailing list
http://mail.freesoftware.fsf.org/mailman/listinfo/nuxeo-localizer
product/Localizer/archive/RELEASE-1.1.0 0 → 100644
View file @ 52146f5e
Localizer 1.1
=============
April 11, 2005 - Two years after release of Localizer 1.0, I am
pleased to announce the availability of the next major version,
Localizer 1.1.
Localizer is a Zope [1] product for developers and web masters.
Localizer solves the problem of building multilingual products
and web sites, ranging from internationalization and localization
of the user interface to management of multilingual content.
jdavid at itaapy.com [2]
What's new in 1.1
-----------------
This release brings several new features. Specifically Localizer
now supports industry standards such as TMX [3] and XLIFF [4],
which enhance the interoperability of Localizer based applications
within mainstream environments.
Native support for 'i18n' namespaces for ZPT (Zope Page Templates)
is included avoiding the need to install other products.
The user interfaces have been vastly improved, specially for
'LocalContent' objects.
Four new translations are available: Danish, Italian, Portuguese
and Russian.
Localizer 1.1 has been re-packaged and now depends on itools Python
package and iHotfix Zope product. While these changes make installation
a bit more complex, the added benefit is simplified source management.
Furthermore this subtle change makes Localizer Services available to
the wider audience of Python [5] developers.
Last but not least, Localizer's stability has been dramatically
improved by resolution of many bugs resulting in a mature and even
more reliable product.
Credits
-------
This is the first release where the majority of work has been
contributed by community users and the original author. Credit
where credit is due.
To Eduardo Corrales and Roberto Quero from the Deusto University [6],
for the original implementation of the TMX standard.
To Søren Roug and Cornel Nitu from the European Environment Agency [7],
for their work on the TMX code, the implementation of the XLIFF standard,
the overhaul of the LocalContent interfaces, and the Danish translation.
To Alexey Lubimov for the Russian translation.
To Mario Olimpio de Menezes for the original Portuguese translation.
To Rodrigo Senra for updating the Portuguese translation, and for improving
the Localizer API.
To Marco Bizzarri for the Italian translation, and for improving the
stability.
Download and Install
--------------------
1. Download the Localizer meta-package from http://www.localizer.org
2. Unpack the tarball
3. Follow the instructions within the README file
Resources
---------
Home
http://www.localizer.org
Mailing list
http://in-girum.net/mailman/listinfo/localizer
Bug Tracker
http://in-girum.net/cgi-bin/bugzilla/index.cgi
References
----------
[1] http://www.zope.org
[2] http://www.itaapy.com
[3] http://www.lisa.org/tmx/
[4] http://www.oasis-open.org/committees/tc_home.php?wg_abbrev=xliff
[5] http://www.python.org
[6] http://www.deusto.es/
[7] http://www.eea.eu.int/
product/Localizer/archive/RELEASE-1.1.3 0 → 100644
View file @ 52146f5e
Localizer 1.1.3 (2006/12/13)
============================
Localizer is a Zope product for developers and web masters. Localizer
solves the problem of building multilingual products and web sites,
ranging from internationalization and localization of the user interface
to management of multilingual content.
The 1.1.3 release brings some new features for ZPT. Most important is
the support of interpolation. And now message catalogs are searched for
within the "Localizer" objects, if it exists.
There are also a couple of bugs fixed:
- The method "LocalPropertyManager.__getattr__" works again.
- The function "Utils.lang_negotiator" works now when the context
is not available.
Credits:
- Mikel Larreategi fixed "LocalPropertyManager.__getattr__".
- Josef Meile worked on ZPT.
- Yoshinori Okuji fixed "Utils.lang_negotiator".
Resources
---------
Download
http://download.ikaaro.org/localizer/Localizer-1.1.3.tar.gz
Home
http://www.localizer.org
Mailing list
http://mail.ikaaro.org/mailman/listinfo/localizer
Bug Tracker
http://bugs.ikaaro.org/
product/Localizer/charsets.txt 0 → 100644
View file @ 52146f5e
ASCII
ISO-8859-1
ISO-8859-2
ISO-8859-3
ISO-8859-4
ISO-8859-5
ISO-8859-6
ISO-8859-7
ISO-8859-8
ISO-8859-9
ISO-8859-13
ISO-8859-15
KOI8-R
KOI8-U
CP850
CP866
CP874
CP932
CP949
CP950
CP1250
CP1251
CP1252
CP1253
CP1254
CP1255
CP1256
CP1257
GB2312
EUC-JP
EUC-KR
EUC-TW
BIG5
BIG5-HKSCS
GBK
GB18030
SHIFT_JIS
JOHAB
TIS-620
VISCII
UTF-8
product/Localizer/configure.zcml 0 → 100644
View file @ 52146f5e
<configure xmlns="http://namespaces.zope.org/zope">
<subscriber
for="Products.Localizer.Localizer.Localizer
zope.lifecycleevent.interfaces.IObjectMovedEvent"
handler="Products.Localizer.Localizer.Localizer_moved" />
<subscriber
for="Products.Localizer.MessageCatalog.MessageCatalog
zope.lifecycleevent.interfaces.IObjectMovedEvent"
handler="Products.Localizer.MessageCatalog.MessageCatalog_moved" />
</configure>
product/Localizer/doc/RELEASE-1.2.0 0 → 100644
View file @ 52146f5e
Localizer 1.2.0 (2006/12/22)
============================
Localizer is a Zope product for developers and web masters. Localizer
solves the problem of building multilingual products and web sites,
ranging from internationalization and localization of the user interface
to management of multilingual content.
The release 1.2.0 is a version update: it requires Python 2.4 and
itools 0.13.10, and the product iHotfix is not required anymore (it
has been merged back into Localizer).
This grid show the possible software combinations:
Localizer Python Zope itools
1.2 2.4 2.9, 2.10 0.13
1.1 (+iHotfix) 2.3 2.7, 2.8 0.9
1.0 2.1 2.6 ---
Of course it is recommended to use Localizer 1.2 with Zope 2.9 or later.
Resources
---------
Download
http://download.ikaaro.org/localizer/Localizer-1.2.0.tar.gz
http://download.ikaaro.org/itools/itools-0.13.10.tar.gz
Home
http://www.localizer.org
Mailing list
http://mail.ikaaro.org/mailman/listinfo/localizer
Bug Tracker
http://bugs.ikaaro.org/
product/Localizer/doc/RELEASE-1.2.1 0 → 100644
View file @ 52146f5e
Localizer 1.2.1 (2007/02/12)
============================
Localizer is a Zope product for developers and web masters. Localizer
solves the problem of building multilingual products and web sites,
ranging from internationalization and localization of the user interface
to management of multilingual content.
Fixed a serious regression, with 1.2.0 the Localizer object (used to
customize the language negotiation policy) stopped working. Thanks to
Igor Leturia for pointing out the problem.
Resources
---------
Download
http://download.ikaaro.org/localizer/Localizer-1.2.1.tar.gz
http://download.ikaaro.org/itools/itools-0.13.10.tar.gz
Home
http://www.localizer.org
Mailing list
http://mail.ikaaro.org/mailman/listinfo/localizer
Bug Tracker
http://bugs.ikaaro.org/
product/Localizer/doc/RELEASE-1.2.2 0 → 100644
View file @ 52146f5e
Localizer 1.2.2 (2008/01/18)
============================
Localizer is a Zope product for developers and web masters. Localizer
solves the problem of building multilingual products and web sites,
ranging from internationalization and localization of the user interface
to management of multilingual content.
What is new?
- Upgraded itools version to 0.20
- Compatibility fixes for Zope 2.10
- Upgraded the license to GPL version 3
Resources
---------
Download
http://download.ikaaro.org/localizer/Localizer-1.2.2.tar.gz
http://download.ikaaro.org/itools/itools-0.20.2.tar.gz
Home
http://www.localizer.org
Mailing list
http://mail.ikaaro.org/mailman/listinfo/localizer
Bug Tracker
http://bugs.ikaaro.org/
product/Localizer/doc/RELEASE-1.2.3 0 → 100644
View file @ 52146f5e
Localizer 1.2.3 (2008/12/03)
============================
Localizer is a Zope product for developers and web masters. Localizer
solves the problem of building multilingual products and web sites,
ranging from internationalization and localization of the user
interface to management of multilingual content.
What is new?
- Compatibility fixes for Zope 2.10/2.11 (bug #381)
- Other minor fixes (including bug #304)
Resources
---------
Download
http://download.hforge.org/localizer/Localizer-1.2.3.tar.gz
http://download.hforge.org/itools/itools-0.20.6.tar.gz
Home
http://www.localizer.org/
Mailing list
http://www.hforge.org/community
http://archives.hforge.org/index.cgi?list=localizer
Bug Tracker
http://bugs.hforge.org/
product/Localizer/docs/.gitignore 0 → 100644
View file @ 52146f5e
_build
figures
autodoc/modules
product/Localizer/docs/conf.py 0 → 100644
View file @ 52146f5e
# -*- coding: utf-8 -*-
#
# Localizer documentation build configuration file, created by
# sphinx-quickstart on Fri Nov 19 19:55:33 2010.
#
# This file is execfile()d with the current directory set to its containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import sys, os
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
#sys.path.insert(0, os.path.abspath('.'))
# -- General configuration -----------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
#needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be extensions
# coming with Sphinx (named 'sphinx.ext.*') or your custom ones.
extensions = []
# Add any paths that contain templates here, relative to this directory.
templates_path = ['_templates']
# The suffix of source filenames.
source_suffix = '.rst'
# The encoding of source files.
#source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = 'index'
# General information about the project.
project = u'Localizer'
copyright = u'2010, J. David Ibáñez'
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = '1.2'
# The full version, including alpha/beta/rc tags.
release = '1.2.3'
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
#today = ''
# Else, today_fmt is used as the format for a strftime call.
#today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ['_build']
# The reST default role (used for this markup: `text`) to use for all documents.
#default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
#add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
#add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
#show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = 'sphinx'
# A list of ignored prefixes for module index sorting.
#modindex_common_prefix = []
# -- Options for HTML output ---------------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = 'default'
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
#html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
#html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
#html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
#html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
#html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
#html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
html_static_path = ['_static']
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
#html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
#html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
#html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
#html_additional_pages = {}
# If false, no module index is generated.
#html_domain_indices = True
# If false, no index is generated.
#html_use_index = True
# If true, the index is split into individual pages for each letter.
#html_split_index = False
# If true, links to the reST sources are added to the pages.
#html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
#html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
#html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
#html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
#html_file_suffix = None
# Output file base name for HTML help builder.
htmlhelp_basename = 'Localizerdoc'
# -- Options for LaTeX output --------------------------------------------------
# The paper size ('letter' or 'a4').
#latex_paper_size = 'letter'
# The font size ('10pt', '11pt' or '12pt').
#latex_font_size = '10pt'
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title, author, documentclass [howto/manual]).
latex_documents = [
('index', 'Localizer.tex', u'Localizer Documentation',
u'J. David Ibáñez', 'manual'),
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
#latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
#latex_use_parts = False
# If true, show page references after internal links.
#latex_show_pagerefs = False
# If true, show URL addresses after external links.
#latex_show_urls = False
# Additional stuff for the LaTeX preamble.
#latex_preamble = ''
# Documents to append as an appendix to all manuals.
#latex_appendices = []
# If false, no module index is generated.
#latex_domain_indices = True
# -- Options for manual page output --------------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [
('index', 'localizer', u'Localizer Documentation',
[u'J. David Ibáñez'], 1)
]
product/Localizer/docs/index.rst 0 → 100644
View file @ 52146f5e
.. Localizer documentation master file, created by
sphinx-quickstart on Fri Nov 19 19:55:33 2010.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
Welcome to Localizer's documentation!
=====================================
Localizer is a Zope product that allows to build multilingual web
applictaions.
.. note::
This documentation was written for Localizer 0.9, and has not been
updated since. Though most of it should apply to newer versions of
Localizer, because the API has not changed much.
Documentation, table of contents:
.. toctree::
:maxdepth: 2
quick-start
introduction/index
tutorial/index
python-programmers/index
Other documents of interest (external links):
* `List of tips <http://www.zope.org/Members/CodeSyntax/DTML_Localizer>`_, by
Luistxo from Code&Syntax.
* The `slides <http://>`_ and the `example <http://>`_ I used for the
talk about Localizer at the fifth Hispalinux congress held in Madrid
(Spain). The `article
<http://congreso.hispalinux.es/ponencias/index.en.html>`_ is available too.
Everything is in spanish only.
Products based on Localizer
===========================
* `CMFLocalizer <http://zope.org/Members/fafhrd/CMFLocalizer>`_, adds
filesystem based message catalogs to the CMF. By Kim Nikolay.
* `Base18
<http://www.nexedi.org/sections/software/base18_multilingual/view>`_,
explores new ways to
manage multilingual content (for the CMF). By Jean-Paul Smets.
* `Localizer + CMF <http://www.zope.org/Members/rthaden/HowToLocCMFProduct>`_
HowTo and product. Multilingual content for the CMF with Localizer. By
Rainer Thaden.
* `Translation Service
<http://www.zope.org/Members/efge/TranslationService>`_. Lets to use the
i18n ZPT namespace with Localizer. By Florent Guillaume.
Sites powered by Localizer
==========================
Here is a list of multilingual web sites that use Localizer. If you've used
Localizer to build a web site or to develop a multilingual Python product or
for something else, please tell me, send me a url if it's public and a short
explanation of how you used Localizer or your experience with it, and I'll
include it on the list.
* `LLEU <http://lleu2001.uji.es/>`_
I developed Localizer to build this web site, it included workflow for
multilingual documents and an automatic translation system to aid human
translators.
* `Code&Syntax <http://www.codesyntax.com/>`_
Code&Syntax is a Zope company specialized in internationalization and
localization. They're the Localizer users number 1, and have provided me
very valuable feedback. Other multilingual web sites based on Localizer of
this company are:
+ `Udal Euskaltegiak <http://www.udaleuskaltegiak.net/>`_
+ `Egoibarra <http://www.egoibarra.com/>`_
+ `Hotsak.com <http://www.hotsak.com/>`_
* `Castagnari <http://www.castagnari.com/>`_
Credits
=======
This list has not been updated for a while.
+----------------------+----------------------------------+
| Lead developer | **Juan David Ibáñez Palomar** |
+----------------------+----------------------------------+
| Developers | **Andrés Marzal Varó** |
| + +
| | **Bjorn Stabell** |
| + +
| | **Florent Guillaume** |
| + +
| | **Jean-Paul Smets** |
+----------------------+----------------------------------+
| Graphic designers | **Maite Rementeria** |
+----------------------+----------------------------------+
| Product translators | **Arnaud Lefèvre** (french) |
| + +
| | **Danny William Adair** (german) |
| + +
| | **Gabor Suveg** (hungarian) |
| + +
| | **Kazuya Fukamachi** (japanese) |
| + +
| | **Serge Stinckwich** (french) |
| + +
| | **Garikoitz Araolaza** (basque) |
| + +
| | **Luistxo Fernandez** (basque) |
+----------------------+----------------------------------+
product/Localizer/docs/introduction/i18n.rst 0 → 100644
View file @ 52146f5e
Internationalization and localization
=====================================
Software needs to be adapted to the local conditions. For example, a word
processor has labels, menus and buttons that need to be translated, the dates
must be shown in the rigth locale format, the help system and any other text
must be available in the user's language. The software industry has faced this
problem for years, I've tried to learn from other's experience to provide Zope
users a solution for their needs. The name of this solution is Localizer.
To be multilingual
------------------
Imagine that you've developed an application, it provides a user interface
with text for example in english. Then your application gets success and
starts to be used in non-english speaking regions. These new users will begin
to ask you about a version in their language. Then, how to do it?
There're several approaches to solve this problem, you could for example fork
the software and provide a version in english, another in spanish, etc.. This
is the quickest solution as you won't need any special infrastructure to
implement it, just fork. But, of course, fork is not an option, it would be
too much work to keep the different versions in sync.
The best you can do is to look at what other developers have already done for
their software. Then you'll discover that this problem is addressed in two
steps:
* Internationalization (i18n)
The operation by which a program is made aware of and able to support
multiple languages. This is done once and forever.
Of course, you could write internationalized software since the begining.
You'll probably do it this way if you've already developed multilingual
software before.
In written language the **i18n** abbreviation is usually used for the term
internationalization. The letter **i** is the first letter of the term, the
letter **n** is the last letter of the term, **18** is the number of letters
between the **i** and the **n**.
* Localization (l10n)
The operation by which, in a program already internationalized, one gives
the program all the needed information so that it can adapt itself to handle
its input and output in a fashion which is correct for some native language
and cultural habits. This is done once per language.
This information needs to be maintained to keep it updated in every version
of the software.
For the term localization the abbreviation **l10n** is used. I'm sure you
already know where the **l**, the **n** and the **10** come from.
To localize
-----------
But this is not only about being multilingual, this is about adapting your
software, your application, your web site to the local conditions of the
users.
For example, imagine you work for a company that sells computers in the U.S.A.
and in the United Kingdom. The language of the both countries is english, you
don't need to translate the text of the company's web site. But perhaps the
company offers different computer models in each country, the contact address
will probably be different too. This means that the web site will show
different content for each market, you'll need to adapt it to the users local
conditions.
Continue reading please
-----------------------
In this introduction I've tried to answer the question : what
internationalization and localization are about?. In the following sections
we'll see the details of every concrete problem, at least the ones that for
now Localizer address.
product/Localizer/docs/introduction/index.rst 0 → 100644
View file @ 52146f5e
Introduction
============
This chapter provides background information about the topic. And also links
if you want to learn more. The sections are:
.. toctree::
:maxdepth: 1
i18n
unicode
multilingual-software
multilingual-data
web
product/Localizer/docs/introduction/multilingual-data.rst 0 → 100644
View file @ 52146f5e
Multilingual data
=================
Internatiolizing software is the easy part, managing multilingual content is
the hard one.
In a multilingual information system there will be people that introduces
content and people that translates it. To keep the information synchronized
and to reduce the translation costs as much as possible are the goals.
The problem
-----------
Here are some elements to be considered:
* A translator aware workflow
When a new document is introduced into the system or when an existing
document changes, the translators must be notified. The same document could
be in different states depending on the language, for example the english
version could be ready to be published while the french version could be
unfinished yet.
Translators are specialized, they can't translate from any language to any
language. For example a translator could do translations from spanish to
french, while another one could translate from english to french and
spanish, or between spanish and french (in both directions).
* Identify the original content.
It's better to translate from the original content than from another
translation because, usually, through the translation process there's a
quality loss. This information is important to improve the translation
process and also for the end user, who always should know which is the
original version of the document, the one that contains the more accurate
data.
* Reduce the translation cost
Translations are expensive, you should use automatic translation systems to
reduce the cost. The output of these systems is not good enough to directly
publish it, but can help a lot to the human translators to do their work
quickly.
It's also important to provide translators the possibility to work off-line,
this is specially important when external translators are used, sometimes
freelancers.
Translation memories
--------------------
The standard solution to address these problems is known as translation
memories systems. Basically, the procedure used is:
1. First the text is splitted in sentences
2. Each sentence is automatically translated, usually using fuzzy matching
against a database. The result is proposed to the translator.
3. The translator corrects the translation and the good one is re-introduced
in the system to improve future translations.
Sophisticated tools for translators with easy to use interfaces, workflow and
versioning systems to manage the content and advanced automatic translation
engines are an important part of the solution.
.. seealso::
Related links
Institutions:
* the `Localisation Research Centre <http://www.localisation.ie/>`_
* the `Localisation Standards Industry Association
<http://www.lisa.org/>`_
Publications:
* `Localisation focus
<http://www.localisation.ie/resources/locfocus/index.htm>`_
Standards:
* the `Translation Memory eXchange <http://www.lisa.org/tmx>`_
standard;
Papers:
* `Evaluation of Natural Language Processing Systems
<http://www.issco.unige.ch/ewg95>`_, final report
product/Localizer/docs/introduction/multilingual-software.rst 0 → 100644
View file @ 52146f5e
Multilingual software
=====================
Software provides always a user interface, doesn't matters wether it's a text
based interface, a graphical application or a web site. The error messages,
the buttons, the labels, etc.. need to be translated.
This is a well known problem for which there're available mature solutions.
But first we'll introduce some basic terminology that will be needed to read
the rest of this guide:
Message
A piece of text that needs to be translated.
Message translation
The translation of a message.
Message catalog
A database that stores the message translations, and provides ways to get
them.
Gettext
-------
In the free software world the de facto standard solution to translate the
user interfaces are the `GNU gettext
<http://www.gnu.org/software/gettext/gettext.html>`_ utilities. Gettext is
used to translate the GNU software and also other projects like KDE.
Initially developed to translate C or C++ programs its usage has grown and now
it's also used with other languages. For example, Python 2.x includes a
gettext module that lets to use the GNU gettext tools, and the last versions
of the well know `Mailman <http://www.list.org/>`_ application use it to
provide a multilingual interface.
product/Localizer/docs/introduction/unicode.rst 0 → 100644
View file @ 52146f5e
Unicode
=======
Encoding systems
----------------
Computers deal with numbers, this means that letters and other characters are
internally represented as numbers. Basically, an encoding system associates
each character with a number. For example, for the encoding named ASCII the
number 97 represents the character "a". So a text is just a sequence of
characters, and for computers it's just a sequence of numbers.
There're many different encoding systems, each one is used to represent
characters from one or more languages. For example the ASCII encoding is used
for english; ISO-8859-1 can be used with spanish, french or german; EUC-JP
represents japanese characters; etc..
The problem is that different encodings can use the same number to represent
different charecters, then they're incompatible. This is a problem for example
if you want to mix different languages in the same text.
Unicode
-------
To solve this problem Unicode appeared. Unicode is an encoding system that is
able to represent all the characters in the world. Using Unicode it's possible
to mix different languages in the same text without problems.
Python
------
The Python programming language provides two types of strings, normal strings
and unicode strings. Internationalized software written in Python always
should use unicode strings for text.
Normal strings represent sequences of bytes while unicode strings represent
sequences of characters. Unicode strings provide a higher abstraction layer
for the programmer that lets to forget, most of the time, about the encoding
issues.
Encoding becomes an issue when an unicode string needs to be serialized, for
example when the server response is sent to the browser. Then an specific
encoding needs to be choosen. For fully multilingual applications this should
be UTF-8, which is a particular representation of the Unicode character set.
.. seealso::
Related links
General information about Unicode:
* `Official Unicode web site <http://www.unicode.org/>`_
* `UTF-8 and Unicode FAQ for Unix/Linux
<http://www.cl.cam.ac.uk/~mgk25/unicode.html>`_
* `Unicode and Multilingual Support in HTML, Fonts, Web Browsers and
Other Applications <http://www.alanwood.net/unicode/>`_
Python resources for Unicode:
* `Python Unicode Tutorial
<http://www.reportlab.com/i18n/python_unicode_tutorial.html>`_
* `Python Internationalization Special Interest Group
<http://www.python.org/sigs/i18n-sig/>`_
product/Localizer/docs/introduction/web.rst 0 → 100644
View file @ 52146f5e
The web
=======
A personal computer is configured with what is known as a locale, it specifies
the encoding system, the user language, the timezone and other parameters that
will be used by the applications to show their interfaces adapted to the user.
When an application starts, for example a word processor, it reads the locale
information, it only needs to be done once, at the begining. This process is
more complex in a networking environment like the web, where there are many
computers involved with different locale configurations.
In the web the client must send the locale information to the server each time
it requests a page. With this information the server can decide in which
language send the data.
Things become more complex when there is a cache between the server and the
client, then the needed dialog to choose the language involves more parties,
the server, the client and the cache.
.. seealso::
Related links
* `HTTP 1.1 language negotiation
<http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.4>`_
* `Apache content negotiation
<http://httpd.apache.org/docs-2.0/content-negotiation.html>`_
product/Localizer/docs/python-programmers/index.rst 0 → 100644
View file @ 52146f5e
For Python programmers
======================
This chapter explains what you can do with Localizer if you're a Python
programmer. Right now there's only one section, this chapter is far to be
complete.
.. toctree::
:maxdepth: 1
python-products
multilingual-content
product/Localizer/docs/python-programmers/multilingual-content.rst 0 → 100644
View file @ 52146f5e
Multilingual content
====================
LocalProperty and LocalPropertyManager
--------------------------------------
The multilingual features of the LocalContent class are actually provided by
the LocalPropertyManager mixin class. Now I'm going to explain how to develop
your own multilingual classes.
Let's imagine that you want to manage multilingual articles, each article has
three multilingual properties, the title, the abstract and the body. The
commented code would be::
# Import the needed classes from Localizer
from Products.Localizer import LocalAttribute, LocalPropertyManager
# The class must inherit from LocalPropertyManager
class Article(LocalPropertyManager, SimpleItem):
meta_type = 'Article'
# The multilingual properties are instances of
# LocalAttribute, they can be class variables.
# The constructor takes 1 argument, which must
# be the name of the attribute.
title = LocalAttribute('title')
abstract = LocalAttribute('abstract')
body = LocalAttribute('body')
# LocalPropertyManager needs some metadata,
# this is similar to the PropertyManager mixin class.
_local_properties_metadata = ({'id': 'title', 'type': 'string'},
{'id': 'abstract', 'type': 'text'},
{'id': 'body', 'type': 'text'})
product/Localizer/docs/python-programmers/python-products.rst 0 → 100644
View file @ 52146f5e
Python products
===============
The Localizer product also provides facilities to internationalize and
localize python products. These facilities are built around the GNU gettext
utilities, the standard in the free software community.
Internationalize
----------------
* DTML and ZPT
The LocalDTMLFile and LocalPageTemplateFile classes must be used instead
of the DTMLfile and PageTemplateFile classes::
from Products.Localizer import LocalDTMLFile, LocalPageTemplateFile
....
manage_addForm = LocalDTMLFile('addForm', globals())
Then the messages will be translated using the gettext method:
.. code-block:: xml
<dtml-var "gettext('Hello world!')">
<span tal:replace="python:gettext('Hello world!')">
Hello world!
</span>
* Python code
Import the needed stuff::
from Products.Localizer import utils
_ = utils.translation(globals())
The underscode (\_) is used to translate messages.
::
def x(self, ...):
return _(u'Hello world!')
Messages must be unicode strings (not byte strings), otherwise the
``zgettext.py`` script (see below) won't detect them.
Localize
--------
The messages and their translations are stored in ".po" and ".mo" files, in
the locale directory within the product.
To help with the localization task Localizer includes the script zgettext.py.
Use it from your product directory, for example:
.. code-block:: sh
../Localizer/zgettext.py *.dtml -l es fr
will create the locale directory and the locale.pot, es.po and fr.po files
inside. Then the human translators will translate the messages in the ".po"
files. Finally, type:
.. code-block:: sh
../Localizer/zgettext.py -m
to compile the ".po" files and generate the ".mo" files that will be used at
run time to get the translations.
product/Localizer/docs/quick-start.rst 0 → 100644
View file @ 52146f5e
Quick start (5 min)
===================
.. highlight:: xml
Output the "Hello world" message in multiple languages
------------------------------------------------------
#. Create a folder named, for example, TestLocalizer, and go inside it.
#. Create a MessageCatalog named, for example, gettext.
#. Go to the management interfaces of the message catalog, go to the tab
languages and add the languages you want.
#. Create a DTML method named test_gettext.
#. In the DTML method type::
<dtml-var "gettext('Hello world!')">
#. View the DTML method.
#. Go to the management screens of the message catalog, provide translations
to the message "Hello world!".
#. View again the DTML method, change the language configuration of your
browser and reload the page to see how the message changes.
Add a language selection box
----------------------------
1. Add a Localizer instance.
2. Edit the DTML method test_gettext and add::
<dtml-var "Localizer.changeLanguageForm()">
3. View again the DTML method and use the selection box to change the language
(you need to active cookies and javascript in your browser).
product/Localizer/docs/tutorial/LocalContent.rst 0 → 100644
View file @ 52146f5e
LocalContent
============
The **LocalContent** meta type is used to store and manage multilingual data.
A single object has different properties, multilingual and monolingual, for
the multilingual ones it's possible to have different language versions.
To explain how to use local content objects we'll go through an step by step
example:
1. Go to the management screens and create a new LocalContent object.
Just type an id, for example "index_html", and a list of languages (iso
codes) separated by spaces, for example "en es fr" for english, spanish,
and french (later you'll be able to add and remove languages through the
management screens).
2. Edit the object, put some text in the "title" and "body" properties for
each language.
3. Create a template to view the object, for example a Page Template named
view
.. code-block:: html
<html>
<head>
<title tal:content="here/title">Title</title>
</head>
<body>
<h1 tal:content="here/title">Title</h1>
<p tal:content="here/body">Body</p>
</body>
</html>
4. View the object with the url <path>/index_html/view. Try to change the
language configuration of your browser and reload the page to see how it
changes.
5. Try to look the url <path>/index_html, it doesn't works. Rename the
template view to default_template and try again.
When no template is specified a default one named default_template is used.
6. You can change the default template too, just go to the object index_html,
go to the Properties tab and add a new property named default_template of
type string, choose for example view as its value. Now rename
default_template to view, and visit the url <path>/index_html again.
This is useful because sometimes different "LocalContent" objects should
have different default templates.
Indexing and searching
----------------------
Local content objects are catalog aware, if you have a catalog named Catalog
in the acquisition path your local content objects will be automatically
cataloged when you create, modify or delete them.
Local content objects have computed attributes of the form <property>_<lang>,
for instance title_es returns the title of the object in spanish and body_en
returns the english version of the body. This feature lets you, for example,
search through all language versions of a local content object simply by using
these attributes as indexes in the catalog.
product/Localizer/docs/tutorial/LocalFolder.rst 0 → 100644
View file @ 52146f5e
LocalFolder
===========
The LocalFolder meta type provides a generic solution to internationalize any
Zope object. Use it to provide images in multiple languages, output dates in
locale formats, etc..
To explain how to use local folder objects we will go through an step by step
example:
1. Go to the management screens and create a new LocalFolder object.
Use "datetime" as the id and "en es" (for english and spanish) as the list
of languages (later you'll be able to add and remove languages through the
management screens).
2. Go to the management screens, to the Attributes tab, and add the ids of the
multilingual objects you want to have, for example, add short_date.
3. Go to the Contents tab and add an object for each language. For example,
add two Python scripts, short_date_en and short_date_es (put datetime in
their parameters list). The body of the english version could be::
return datetime.strftime('%Y/%m/%d')
The body of the spanish version could be::
return datetime.strftime('%d/%m/%Y')
4. Now leave the local folder object and create, for example, a DTML method,
call it today. Its body could be:
.. code-block:: xml
<dtml-var standard_html_header>
<dtml-var "datetime.short_date(_.DateTime())">
<dtml-var standard_html_footer>
5. View the today method and change the configuration of your browser between
english and spanish to see how it changes.
In short, what local folder objects do is to let to use different language
versions of any Zope object (Python scripts, images, folders, etc..), which
version is used with each request depends on the language negotiation
facilities. Each multilingual object must be specified in the Attributes tab,
each language version has the form <name>_<language>. For example, if the
multilingual attribute is logo the spanish version's id is logo_es.
product/Localizer/docs/tutorial/Localizer.rst 0 → 100644
View file @ 52146f5e
Localizer
=========
.. highlight:: xml
By default only the browser configuration (the **AcceptLanguage** header) is
used to choose the language. Localizer implements the HTTP standard, it
represents the user prefered languages as a tree where each node has a quality
between 0.0 and 1.0 (a higher quality means the language is more prefered by
the user). For more information see the HTTP protocol specification.
The **Localizer** meta type lets to use other criterias to choose the
language. Usually there's one instance in the root of the web site. Its id is
always Localizer and can't be changed.
A Localizer object has a property named **accept_methods** (of type tokens)
which contains a list of method ids. Each method specified in this list will
be called every time the folder where the Localizer object lives is traversed.
By default it includes two builtin methods that add two new criterias to
choose the language:
accept_cookie
Lets to specify the language with the cookie LOCALIZER_LANGUAGE, which
must contain a language code. This method assigns a quality of 2.0 to the
language specified in the cookie. This way it takes precedence over the
browser configuration.
accept_path
Lets to specify the language in the url. For example, if there's a
Localizer object at the root of the web site, the url
http://www.example.com/es/index.html will set the quality for spanish to
3.0, this way it will take precedence over the browser configuration and
the cookie.
Customize
---------
To change the language negotiation policy to fit your needs you have to modify
the property accept_methods. You can remove any of the builtin methods (if you
don't want to use cookies or to specify the language in the url) and add new
ones that usually will be implemeted as Python scripts.
The functions that appear in the accept_methods list receive a parameter that
represents the tree of the user prefered languages. This object offers a
complete API, but usually only the method set will be used.
For example, create a Python script within the Localizer instance named
accept_french, add accept_language to its parameter list. The body of the
script could be the line:
.. code-block:: python
accept_language.set("fr", 4.0)
This would set french as the user prefered language with a quality of 4.0,
taking precedence over the browser, the cookie and the laguage specified in
the url. Finally just add its id to the list accept_methods.
The change language form
------------------------
The Localizer object also provides the HTML form changeLanguageForm and its
action, changeLanguage. They provide a quick way to implement a language
selection box, the action modifies the LOCALIZER_LANGUAGE cookie.
For DTML type::
<dtml-var "Localizer.changeLanguageForm()">
For ZPT type::
<tal:block content="structure here/Localizer/changeLanguageForm" />
product/Localizer/docs/tutorial/MessageCatalog.rst 0 → 100644
View file @ 52146f5e
MessageCatalog
==============
.. highlight:: xml
The Localizer product provides the class MessageCatalog, it stores messages
and their translations and provides a web interface to manage them. They're
useful to translate the application interface: labels, buttons, etc..
The messages are stored in the ZODB, though they can be exported and imported
to and from "po" files. It's also possible to manage a message catalog through
FTP.
Getting translations
--------------------
To get the translations message catalogs provide the gettext method, for
example::
<dtml-var "messages.gettext('Hello world!')">
The message catalog is callable, this means it's possible to use a shorter
version::
<dtml-var "messages('Hello world!')">
The gettext method accepts two optional parameters, it's signature is:
.. code-block:: python
gettext(message, language=None, add=1)
The parameters are:
+----------+--------------------------------------+
| message | The message to be translated. |
+----------+--------------------------------------+
| language | The destination language, if None |
| | (default) the selection language |
| | algortihm will be used to choose |
| | the destination language. |
+----------+--------------------------------------+
| add | If true (default) the message will |
| | be automatically added to the |
| | catalog if it doesn't exists. |
+----------+--------------------------------------+
dtml-gettext
------------
For long messages the tag dtml-gettext can be more comfortable::
<dtml-gettext>
This could be a very long message.
</dtml-gettext>
It accepts several parameters, they're:
+------------------------------+--------------------------------+
| lang [#msg-catalog-rq]_ | The target language (string). |
+------------------------------+--------------------------------+
| lang_expr [#msg-catalog-rq]_ | The target language (string |
| | expression). |
+------------------------------+--------------------------------+
| verbatim | If set the message will be |
| | interpreted as it is, |
| | otherwise (default) any blank |
| | characters will be interpreted |
| | as just one space character. |
+------------------------------+--------------------------------+
| catalog | The id of the catalog from |
| | where the translations will be |
| | obtained. |
+------------------------------+--------------------------------+
| data | If present the message will be |
| | interpreted as a formatted |
| | string and data will contain |
| | the tuple or dictionary to be |
| | passed to the string. |
+------------------------------+--------------------------------+
.. [#msg-catalog-rq] Only one (or none) can be provided.
Zope Page Templates
-------------------
Message catalogs can also be used from ZPT, for example::
<span tal:replace="python:here.messages('Hello world!')">
Hello world!
</span>
product/Localizer/docs/tutorial/example.rst 0 → 100644
View file @ 52146f5e
Example of a Localizer web site
===============================
Nothing yet...
product/Localizer/docs/tutorial/index.rst 0 → 100644
View file @ 52146f5e
Tutorial
========
This chapter explains how to use and when to use the four meta types provided
by the Localizer product. They are:
.. toctree::
:maxdepth: 1
MessageCatalog
Localizer
LocalContent
LocalFolder
Finally, to know how to put all this together we're going to see with an
example the typical organization of a Localizer based multilingual web site:
.. toctree::
:maxdepth: 1
example
product/Localizer/help/LF_add.stx 0 → 100644
View file @ 52146f5e
Localizer - Add Locale Folder
Description
This view allows to create a new Locale Folder.
Controls
Id -- The id of the Locale Folder, must be a language code.
Title -- The optional title for the Locale Folder.
product/Localizer/help/LM_languages.stx 0 → 100644
View file @ 52146f5e
Localizer - Manage languages
Description
This view allows to manage the available languages (add and delete) and
to set the default language.
Controls
Add -- Adds a new language.
Delete -- Removes the selected languages.
Change -- Changes the default language.
product/Localizer/help/LM_upgrade.stx 0 → 100644
View file @ 52146f5e
Localizer - Upgrade LocalPropertyManager
Description
This view allows to upgrade an object when a new version of its class
has been installed that requires changes to the object.
This feature is specific to the Localizer product.
Controls
Upgrade -- Upgrades the object.
product/Localizer/help/LPM_properties.stx 0 → 100644
View file @ 52146f5e
Localizer - Manage local properties
Description
This view allows to manage the local properties.
Add properties
To add a new property enter its name and select its type, then click
the 'Add' button.
Property selector
Below the form to add new properties there's an interface that allows
to modify and delete them.
Only one local property is edited at a time, it's highlighted in the
property selection bar. To select a different one click on it's name.
If there're lots of properties the selection bar will have two buttons
to browse the properties at the right side of the bar.
Delete a property
To delete the property being edited click the 'Delete' button.
Edit properties
The body of the interface shows all the language versions for the
selected property. To modify them introduce the right text and click
the 'Save changes' button.
product/Localizer/help/LocalContent_add.stx 0 → 100644
View file @ 52146f5e
Localizer - Add Local Content
Description
This view allows to create a new Local Content object.
Controls
Id -- The id of the object.
Languages -- The list of available languages that the Local Content
will have.
\ No newline at end of file
product/Localizer/help/LocalFolder_add.stx 0 → 100644
View file @ 52146f5e
Localizer - Add Local Folder
Description
This view allows to create a new Local Folder.
Controls
Id -- The id of the Local Folder, must be a language code.
Title -- The optional title for the Local Folder.
Languages -- The list of available languages that the local folder will
have.
product/Localizer/help/Localizer_add.stx 0 → 100644
View file @ 52146f5e
Localizer - Add Localizer
Description
This view allows to create a new Localizer.
Controls
Id -- The id of the object is 'Localizer'.
Title -- The optional title for the Localizer.
Languages -- The list of available languages that the Localizer will have.
Add -- Adds the Localizer instance.
product/Localizer/help/MC_add.stx 0 → 100644
View file @ 52146f5e
Localizer - Add Message Catalog
Description
This view allows to create a new Message Catalog.
Controls
'Id' -- The id of the message catalog
Title -- The optional title for the message catalog.
Languages -- The list of available languages that the message catalog
will have.
\ No newline at end of file
product/Localizer/help/MC_importExport.stx 0 → 100644
View file @ 52146f5e
Localizer - Import/Export messages
Description
This views allows to import and export messages.
Controls
File / Language -- The file (and language) to be exported.
Export -- Exports the file.
File -- The file that you want to import.
Language -- The language of the translations contained in the file to
be imported.
Import -- Imports the file.
product/Localizer/help/MC_messages.stx 0 → 100644
View file @ 52146f5e
Message Catalog - Manage messages.
Description
This screen lets to manage the message catalog, it lets to remove
messages and to edit the translations.
The screen is divided in two parts, the working area at the left
and the navigation system at the right.
The working area
It is divided in two parts, at the top there is a non editable
text area that contains the message to be translated.
At the bottom there's an editable text area wich lets to change
the translation. Above this text area there is a menu which lets
to change the language that is being edited.
Finally, there are two buttons, one saves the translation and the
other removes the current message.
Navigation system
It lets to browse the messages and is divided in two parts.
At the top there is a search form that lets to show only a subset of
the messages, following two criterias. The first one is wether to show
all the messages or only those that have an empty translation. The
second criteria if used will only show the messages that match the
specified string.
Below the search form there is a list with all the found messages,
which can be used to change the message that is being edited.
product/Localizer/interfaces.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2010 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from Zope
from zope.interface import Interface
from zope.i18n.interfaces import ITranslationDomain
class ILocalizer(Interface):
pass
class IMessageCatalog(ITranslationDomain):
pass
product/Localizer/itools/.gitignore 0 → 100644
View file @ 52146f5e
*~
*.pyc
*.swp
build
dist
MANIFEST
version.txt
locale/*.mo
test/fables/catalog
test/pdf/*.pdf
product/Localizer/itools/LICENSE.txt 0 → 100644
View file @ 52146f5e
GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
<one line to give the program's name and a brief idea of what it does.>
Copyright (C) <year> <name of author>
This program 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 3 of the License, or
(at your option) any later version.
This program 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.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
<program> Copyright (C) <year> <name of author>
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
<http://www.gnu.org/licenses/>.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
<http://www.gnu.org/philosophy/why-not-lgpl.html>.
product/Localizer/itools/README.txt 0 → 100644
View file @ 52146f5e
This is a stub of the original itools library, containing only the
bare essentials needed for Localizer as used in ERP5. Namely:
* itools.utils
* itools.i18n
The intention is that even these few remaining functionalities should
be replaced by native Zope API calls.
The original itools distribution on which this stub is based is the
0.50 branch of the itools repository at:
https://github.com/hforge/itools/tree/0.50
The original CREDITS.txt file can be seen at:
https://github.com/hforge/itools/blob/0.50/CREDITS
The copyright notice of the original code is as follows:
Copyright
---------
Copyright (C) 2002-2008 Juan David Ibáñez Palomar <jdavid@itaapy.com>
Copyright (C) 2005-2008 Luis Arturo Belmar-Letelier <luis@itaapy.com>
Copyright (C) 2005-2008 Hervé Cauwelier <herve@itaapy.com>
Copyright (C) 2005-2008 Nicolas Deram <nicolas@itaapy.com>
And others. Check the CREDITS file for complete list.
License
-------
This program 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 3 of the License, or
(at your option) any later version.
This program 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.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
product/Localizer/itools/__init__.py 0 → 100644
View file @ 52146f5e
# -*- coding: utf-8 -*-
# Copyright (C) 2006, 2008 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
product/Localizer/itools/i18n/__init__.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2006-2008 Juan David Ibáñez Palomar <jdavid@itaapy.com>
# Copyright (C) 2008 Henry Obein <henry@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from itools
from accept import AcceptLanguageType, get_accept, select_language
from accept import init_language_selector
from base import has_language, get_languages, get_language_name
from fuzzy import get_distance, get_similarity, is_similar, get_most_similar
from locale_ import format_date, format_time, format_datetime
from oracle import guess_language, is_asian_character, is_punctuation
__all__ = [
# accept
'AcceptLanguageType',
'get_accept',
'select_language',
'init_language_selector',
# fuzzy
'get_distance',
'get_similarity',
'is_similar',
'get_most_similar',
# locale
'format_date',
'format_time',
'format_datetime',
# oracle
'guess_language',
'is_asian_character',
'is_punctuation',
# languages
'has_language',
'get_languages',
'get_language_name',
]
product/Localizer/itools/i18n/accept.py 0 → 100644
View file @ 52146f5e
# -*- coding: utf-8 -*-
# Copyright (C) 2002-2008 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
This module implements the Accept-Language request header of the HTTP
protocol.
"""
# Import from the Standard Library
import __builtin__
from decimal import Decimal
from locale import getdefaultlocale
zero = Decimal('0.0')
one = Decimal('1.0')
# FIXME This class belongs to the public API, but it is not exposed since
# we never create it directly (we use AcceptLanguageType).
class AcceptLanguage(dict):
"""Implements the Accept-Language tree.
"""
# Allow unrestricted access to AcceptLanguage and subobjects from Zope
__allow_access_to_unprotected_subobjects__ = 1
def set(self, key, quality):
if not isinstance(quality, Decimal):
if not isinstance(quality, str):
quality = str(quality)
quality = Decimal(quality)
if key == '*':
key = ''
self[key] = quality
def get_quality(self, language):
"""This method returns the quality of the given language. As defined
by the RFC 2616, if a langage is not defined it inherits the quality
from a "parent" language; for instance, if 'fr-FR' is not defined but
'fr' is, then 'fr-FR' inherits the quality from 'fr'.
To make the difference between an exact match and an inherited value,
this method returns a tuple: first value is the quality, and second
value is the number of steps it had to go back in the inheritance
chain (0 for an exact match).
"""
steps = 0
while language and language not in self:
language = '-'.join(language.split('-')[:-1])
steps += 1
return self.get(language, zero), steps
def select_language(self, languages):
"""This is the selection language algorithm, it returns the user
prefered language for the given list of available languages, if the
intersection is void returns None.
The criterias used to select a language are:
1. The quality
2. The distance to the exact match
3. The order in the 'languages' parameter
"""
language, quality, steps = None, zero, 100
for lang in languages:
q, s = self.get_quality(lang)
if q > quality or (q and q == quality and s < steps):
language, quality, steps = lang, q, s
return language
class AcceptLanguageType(object):
@staticmethod
def decode(data):
"""From a string formatted as specified in the RFC2616, it builds a
data structure which provides a high level interface to implement
language negotiation.
"""
data = data.strip()
if not data:
return AcceptLanguage({})
accept = {}
for language in data.lower().split(','):
language = language.strip()
if ';' in language:
language, quality = language.split(';')
# Get the number (remove "q=")
quality = Decimal(quality.strip()[2:])
else:
quality = one
if language == '*':
language = ''
accept[language] = quality
return AcceptLanguage(accept)
@staticmethod
def encode(accept):
# Sort
accept = [ (y, x) for x, y in accept.items() ]
accept.sort()
accept.reverse()
# Encode
data = []
for quality, language in accept:
if language == '':
if quality == zero:
continue
language = '*'
if quality == one:
data.append(language)
else:
data.append('%s;q=%s' % (language, quality))
return ', '.join(data)
def get_accept():
language = getdefaultlocale()[0]
if language is None:
language = ''
elif '_' in language:
language = language.replace('_', '-')
language = '%s, %s;q=0.5' % (language, language.split('-')[0])
return AcceptLanguageType.decode(language)
def select_language(languages=None):
return get_accept().select_language(languages)
def init_language_selector(language_selector=select_language):
__builtin__.__dict__['select_language'] = language_selector
# Set default language selector
init_language_selector(select_language)
product/Localizer/itools/i18n/base.py 0 → 100644
View file @ 52146f5e
# -*- coding: utf-8 -*-
# Copyright (C) 2002-2003, 2007-2008 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from itools
from ..utils import get_abspath
# Initializes a dictionary containing the iso 639 language codes/names
languages = {}
filename = get_abspath('languages.txt')
for line in open(filename).readlines():
line = line.strip()
if line and line[0] != '#':
code, name = line.split(' ', 1)
languages[code] = name
# Builds a sorted list with the languages code and name
language_codes = languages.keys()
language_codes.sort()
langs = [ {'code': x, 'name': languages[x]} for x in language_codes ]
def has_language(code):
return code in languages
def get_languages():
"""Returns a list of tuples with the code and the name of each language.
"""
return [ x.copy() for x in langs ]
def get_language_name(code):
"""Returns the name of a language.
"""
# FIXME The value returned should be a MSG object, but the MSG class comes
# from the itools.gettext module, which is higher level than itools.i18n
if code in languages:
return languages[code]
return u'???'
product/Localizer/itools/i18n/fuzzy.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2004 Thierry Fromon <from.t@free.fr>
# Copyright (C) 2006-2007 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
def get_distance(a, b):
"""
This function was giving by Magnus Lie Hetland. It calculates the gap
(mathematical distance) between two strings with the cost of word's
translation inside the string.
"""
# XXX Find URL to original code, check license
c = {}
n = len(a)
m = len(b)
for i in range(0, n+1):
c[i, 0] = i
for j in range(0, m+1):
c[0, j] = j
for i in range(1, n+1):
for j in range(1, m+1):
x = c[i-1, j] + 1
y = c[i, j-1] + 1
if a[i-1] == b[j-1]:
z = c[i-1, j-1]
else:
z = c[i-1, j-1] + 1
c[i, j] = min(x, y, z)
return c[n, m]
def get_similarity(a, b):
"""
Return a gap and a percent that takes account of abrevations.
"""
length = max(len(a), len(b))
distance = get_distance(a, b)
return 1 - (float(distance) / float(length))
def is_similar(a, b, limit=0.8):
"""
Returns True if both text strings are close enough, False otherwise.
The optional parameter 'limit' defines the degree of similarity required
to be considered 'close enough', it is a float value between '0'
(completely different) and '1' (the same string).
"""
return get_similarity(a, b) >= limit
def get_most_similar(a, *args):
"""
Returns the text string from 'args' that is closest to the given string.
"""
if not args:
return None
options = [ (get_similarity(a, x), x) for x in args ]
options.sort()
return options[-1][1]
##############################################################################
# XXX To enable this feature a deep work on abbreviations must be done
##dictionary = {u'Monsieur': (u'Mr', u'M', u'M.', u'Mr.'),
## u'Madame': (u'Md', u'Md.')}
##punctuations = [u'.', u',', u';', u'?', '!', u"'", u'"', u'¡', u'¿']
##def expand_abbreviations(text):
## """
## Return a text without abrevation.
## """
## t = ' ' + text + ' '
## for i in punctuations:
## t = t.replace(i, ' ' + i + ' ')
## for word, abrevations in dictionary.items():
## for abrevation in abrevations:
## t = t.replace(' ' + abrevation + ' ', ' ' + word + ' ')
## return t
##def get_distance(a, b):
## """
## Return a gap and a percent that takes account of abrevations.
## """
## a_expanded = expand_abbreviations(a)
## b_expanded = expand_abbreviations(b)
## length = max(len(a), len(b))
## length_expanded = 5 * max(len(a_expanded), len(b_expanded))
## gap = get_gap(a, b)
## gap_expanded = 5 * get_gap(a_expanded, b_expanded)
## percent = 100 - 100 * (gap_expanded + gap) / (length_expanded + length)
## return gap, percent
product/Localizer/itools/i18n/languages.txt 0 → 100644
View file @ 52146f5e
# ISO 639-2
# http://www.loc.gov/standards/iso639-2/php/code_list.php
#
# Format: "<alpha-2 code> <language name>"
aa Afar
ab Abkhazian
ae Avestan
af Afrikaans
ak Akan
am Amharic
an Aragonese
ar Arabic
as Assamese
av Avaric
ay Aymara
az Azerbaijani
ba Bashkir
be Belarusian
bg Bulgarian
bh Bihari
bi Bislama
bm Bambara
bn Bengali
bo Tibetan
br Breton
bs Bosnian
ca Catalan
ce Chechen
ch Chamorro
co Corsican
cr Cree
cs Czech
cu Church Slavic
cv Chuvash
cy Welsh
da Danish
de German
de-AU German/Austria
de-DE German/Germany
de-CH German/Switzerland
dv Divehi; Dhivehi; Maldivian
dz Dzongkha
ee Ewe
el Greek
en English
en-GB English/United Kingdom
en-US English/United States
eo Esperanto
es Spanish
es-AR Spanish/Argentina
es-CO Spanish/Colombia
es-MX Spanish/Mexico
es-ES Spanish/Spain
et Estonian
eu Basque
fa Persian
ff Fulah
fi Finnish
fj Fijian
fo Faroese
fr French
fr-BE French/Belgium
fr-CA French/Canada
fr-FR French/France
fr-CH French/Switzerland
fy Frisian
ga Irish
gd Gaelic
gl Galician
gn Guarani
gu Gujarati
gv Manx
ha Hausa
he Hebrew
hi Hindi
ho Hiri Motu
hr Croatian
ht Haitian
hu Hungarian
hy Armenian
hz Herero
ia Interlingua
id Indonesian
ie Interlingue; Occidental
ig Igbo
ii Sichuan Yi; Nuosu
ik Inupiak
io Ido
is Icelandic
it Italian
iu Inuktitut
ja Japanese
jv Javanese
ka Georgian
kg Kongo
ki Kikuyu; Gikuyu
kj Kuanyama; Kwanyama
kk Kazakh
kl Kalaallisut; Greenlandic
km Khmer
kn Kannada
ko Korean
kr Kanuri
ks Kashmiri
ku Kurdish
kv Komi
kw Cornish
ky Kirghiz; Kyrgyz
la Latin
lb Luxembourgish
lg Ganda
li Limburgan
ln Lingala
lo Lao
lt Lithuanian
lu Luba-Katanga
lv Latvian
mg Malagasy
mh Marshallese
mi Maori
mk Macedonian
ml Malayalam
mn Mongolian
mr Marathi
ms Malay
mt Maltese
my Burmese
na Nauru
nb Norwegian Bokmal
nd Ndebele, North
ne Nepali
ng Ndonga
nl Dutch
nl-BE Dutch/Belgium
nn Norwegian Nyrnosk
no Norwegian
nr Ndebele, South
nv Navajo; Navaho
ny Chichewa; Chewa; Nyanja
oc Occitan
oj Ojibwa
om Oromo
os Ossetian; Ossetic
or Oriya
pa Panjabi; Punjabi
pi Pali
pl Polish
ps Pushto; Pashto
pt Portuguese
pt-BR Portuguese/Brazil
qu Quechua
rm Romansh
rn Rundi
ro Romanian; Moldavian
ru Russian
rw Kinyarwanda
sa Sanskrit
sc Sardinian
sd Sindhi
se Sami
sg Sango
si Sinhala; Sinhalese
sk Slovak
sl Slovenian
sm Samoan
sn Shona
so Somali
sq Albanian
sr Serbian
ss Swati
st Sotho
su Sundanese
sv Swedish
sw Swahili
ta Tamil
te Telugu
tg Tajik
th Thai
ti Tigrinya
tk Turkmen
tl Tagalog
tn Tswana
to Tonga
tr Turkish
ts Tsonga
tt Tatar
tw Twi
ty Tahitian
ug Uighur; Uyghur
uk Ukrainian
ur Urdu
uz Uzbek
ve Venda
vi Vietnamese
vo Volapuk
wa Walloon
wo Wolof
xh Xhosa
yi Yiddish
yo Yoruba
za Zhuang; Chuang
zh Chinese
zh-CN Chinese/China
zh-TW Chinese/Taiwan
zu Zulu
# Add here the languages you need
product/Localizer/itools/i18n/locale_.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2007 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
Output dates and times in locale format.
"""
# Import from itools
from accept import get_accept
formats = {
# Date, Time, DateTime
'en': ('%d/%m/%Y', '%H:%M', '%d/%m/%Y %H:%M'),
'es': ('%d/%m/%Y', '%H.%M', '%d/%m/%Y %H.%M'),
'fr': ('%d/%m/%Y', '%Hh%M', '%d/%m/%Y %Hh%M'),
}
available_languages = formats.keys()
def get_format(accept):
# By default use the computer's locale
if accept is None:
accept = get_accept()
# Negotiate
language = accept.select_language(available_languages)
if language is None:
language = 'en'
# The format
return formats[language]
def format_date(x, accept=None):
format = get_format(accept)[0]
return x.strftime(format)
def format_time(x, accept=None):
format = get_format(accept)[1]
return x.strftime(format)
def format_datetime(x, accept=None):
format = get_format(accept)[2]
return x.strftime(format)
product/Localizer/itools/i18n/oracle.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2004 Thierry Fromon <from.t@free.fr>
# Copyright (C) 2004, 2006-2007 Juan David Ibáñez Palomar <jdavid@itaapy.com>
# Copyright (C) 2008 Henry Obein <henry@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
###########################################################################
# To add a new language, edit the dictionaries below:
#
# - positive_chars
#
# Defines special characters (like accentuated characters) that belong
# to the language.
#
# - negative_chars
#
# Defines special characters (like accentuated characters) that do not
# belong to the language.
#
# - positive_words
#
# Defines common words that belong to the language.
#
# - negative_words
#
# Defines some words that do not belong to the language.
###########################################################################
import unicodedata
positive_chars = {
u'¡': ['es'],
u'¿': ['es'],
u'ä': ['de'],
u'ß': ['de'],
u'ç': ['fr'],
u'ê': ['fr'],
u'í': ['es'],
u'ñ': ['es'],
u'ö': ['de'],
u'ó': ['es'],
u'ü': ['de'],
u'ú': ['es'],
# Asian languages
# Japanese : based on particles (hiragana)
u'の': ['ja'],
u'は': ['ja'],
u'で': ['ja'],
u'に': ['ja'],
u'が': ['ja'],
u'へ': ['ja'],
u'を': ['ja'],
u'や': ['ja'],
u'と': ['ja'],
# Japanese : punctuation
u'、': ['ja'],
u'。': ['ja'],
}
negative_chars = {}
positive_words = {
u'à': ['fr'],
u'al': ['es'],
u'an': ['en'],
u'and': ['en'],
u'are': ['en'],
u'as': ['en'],
u'aux': ['fr'],
u'but': ['en'],
u'como': ['es'],
u'con': ['es'],
u'de': ['es', 'fr'],
u'del': ['es'],
u'des': ['fr'],
u'donc': ['fr'],
u'du': ['fr'],
u'el': ['es'],
u'elle': ['fr'],
u'elles': ['fr'],
u'es': ['es'],
u'est': ['fr'],
u'está': ['es'],
u'et': ['fr'],
u'from': ['en'],
u'hay': ['es'],
u'he': ['en', 'es'],
u'i': ['en'],
u'il': ['fr'],
u'ils': ['fr'],
u'in': ['en'],
u'is': ['en'],
u'it': ['en'],
u'je': ['fr'],
u'las': ['es'],
u'le': ['es', 'fr'],
u'lo': ['es'],
u'les': ['es', 'fr'],
u'los': ['es'],
u'mais': ['fr'],
u'no': ['en', 'es'],
u'nous': ['fr'],
u'nueva': ['es'],
u'o': ['es'],
u'of': ['en'],
u'on': ['en'],
u'or': ['en'],
u'où': ['fr'],
u'para': ['es'],
u'pero': ['es'],
u'por': ['es'],
u'que': ['es', 'fr'],
u'qué': ['es'],
u'she': ['en'],
u'su': ['es'],
u'sur': ['fr'],
u'that': ['en'],
u'the': ['en'],
u'their': ['en'],
u'this': ['en'],
u'to': ['en'],
u'tu': ['es', 'fr'],
u'un': ['es', 'fr'],
u'una': ['es'],
u'une': ['fr'],
u'vous': ['fr'],
u'when': ['en'],
u'where': ['en'],
u'y': ['es'],
u'you': ['en'],
u'your': ['en'],
}
negative_words = {
u'du': ['es'],
}
# One thousand words should be enough
MAX_WORDS = 1000
def is_asian_character(c):
# get the decimal value of the character
code = int('%04x' % ord(c), 16)
# http://en.wikipedia.org/wiki/Template:Unicode_chart_CJK_Compatibility
# CJK Compatibility
# Range: 3300–33FF
if code >= 13056 and code <= 13311:
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_CJK_Compatibility_Forms
# CJK Compatibility Forms
# Range: FE30–FE4F
if code >= 65072 and code <= 65103:
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_CJK_Compatibility_Ideographs
# CJK Compatibility Ideographs
# Range: F900–FAFF
if code >= 63744 and code <= 64255:
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_CJK_Radicals_Supplement
# CJK Radicals Supplement
# Range: 2E80–2EFF
if code >= 11904 and code <= 12031:
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_CJK_Strokes
# CJK Strokes
# Range: 31C0–31EF
if code >= 12736 and code <= 12783:
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_CJK_Unified_Ideographs
# CJK Unified Ideographs
# Range: 4E00–9FBF
if code >= 19968 and code <= 40895:
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_CJK_Unified_Ideographs_Extension_A
# CJK Unified Ideographs Extension A
# Range: 3400–4DBF
if code >= 13312 and code <= 19903:
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_Halfwidth_and_Fullwidth_Forms
# Halfwidth and Fullwidth Forms
# Range: FF00–FFEF
if code >= 65280 and code <= 65519 :
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_Hangul_Compatibility_Jamo
# Hangul Compatibility Jamo
# Range: 3130–318F
#if code >= 12592 and code <= 12687:
# return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_Hangul_Jamo
# Hangul Jamo
# Range: 1100–11FF
#if code >= 4352 and code <= 4607:
# return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_Hangul_Syllables
# Hangul Syllables
# Range: AC00–D7AF
#if code >= 44032 and code <= 55215:
# return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_Hiragana
# Hiragana
# Range: 3040–309F
if code >= 12352 and code <= 12447:
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_Katakana
# Katakana
# Range: 30A0–30FF
if code >= 12448 and code <= 12543:
return True
# http://en.wikipedia.org/wiki/Template:Unicode_chart_Katakana_Phonetic_Extensions
# Katakana Phonetic Extensions
# Range: 31F0–31FF
if code >= 12784 and code <= 12799:
return True
return False
def is_punctuation(c):
"""Check if c is a punctuation symbol
http://en.wikipedia.org/wiki/Template:Unicode_chart_General_Punctuation
General Punctuation
Range: 2000–206F
http://en.wikipedia.org/wiki/Template:Unicode_chart_CJK_Symbols_and_Punctuation
CJK Symbols and Punctuation
Range: 3000–303F
"""
# call isalnum before check character code
if c.isalnum() is False:
return True
# get the decimal value of the character
code = int('%04x' % ord(c), 16)
if (code >= 8192 and code <= 8303) or (code >= 12288 and code <= 12351):
return True
return False
###########################################################################
# The Code
###########################################################################
def guess_language(text):
chars = {}
words = {}
# Number of chars and words analyzed
n_chars = 0
n_words = 0
# Look for special chars and words in the given text
word = u''
for c in text:
n_chars += 1
c = c.lower()
# Characters
for language in positive_chars.get(c, []):
chars.setdefault(language, 0)
chars[language] += 1
for language in negative_chars.get(c, []):
chars.setdefault(language, 0)
chars[language] -= 2
# Words
if c.isalpha():
word += c
elif word:
for language in positive_words.get(word, []):
words.setdefault(language, 0)
words[language] += 1
for language in negative_words.get(word, []):
words.setdefault(language, 0)
words[language] -= 2
word = u''
# Check limit
n_words += 1
if n_words >= MAX_WORDS:
break
# If we found nothing...
if not chars and not words:
return None
# Depending on the length of the text, the weight given to chars and
# words changes. The minimum distance between two languages too.
if n_chars < 75:
w_weight, c_weight, distance = 1.0, 1.0, 1.0
elif n_chars < 500:
w_weight, c_weight, distance = 1.2, 2.0, 2.0
else:
w_weight, c_weight, distance = 1.6, 4.0, 4.0
# Calculate the chances the text is written in any language.
languages = []
for lang in set(chars.keys()) | set(words.keys()):
p = w_weight*words.get(lang, 0) + c_weight*chars.get(lang, 0)
languages.append((p, lang))
languages.sort()
# Pick the most probable language, unless the distance to the second is
# too small.
n = len(languages)
if n == 0:
return None
if n == 1:
return languages[0][1]
if languages[-1][0] - languages[-2][0] >= distance:
return languages[-1][1]
return None
product/Localizer/itools/utils.py 0 → 100644
View file @ 52146f5e
# -*- coding: utf-8 -*-
# Copyright (C) 2006-2008 Juan David Ibáñez Palomar <jdavid@itaapy.com>
# Copyright (C) 2008 Gautier Hayoun <gautier.hayoun@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from the Standard Library
from distutils import core
from distutils.errors import DistutilsOptionError
from distutils.command.build_py import build_py
from distutils.command.register import register
from distutils.command.upload import upload
from getpass import getpass
from mimetypes import MimeTypes
from os import getcwd, open as os_open, devnull, dup2, O_RDWR
from os.path import exists, join as join_path, sep, splitdrive
from re import search
from sys import _getframe, platform, exit, stdin, stdout, stderr
from urllib2 import HTTPPasswordMgr
import sys
def get_abspath(local_path, mname=None):
"""Returns the absolute path to the required file.
"""
if mname is None:
mname = _getframe(1).f_globals.get('__name__')
if mname == '__main__' or mname == '__init__':
mpath = getcwd()
else:
module = sys.modules[mname]
if hasattr(module, '__path__'):
mpath = module.__path__[0]
elif '.' in mname:
mpath = sys.modules[mname[:mname.rfind('.')]].__path__[0]
else:
mpath = mname
drive, mpath = splitdrive(mpath)
mpath = drive + join_path(mpath, local_path)
# Make it working with Windows. Internally we use always the "/".
if sep == '\\':
mpath = mpath.replace(sep, '/')
return mpath
product/Localizer/locale/ca.po 0 → 100644
View file @ 52146f5e
msgid ""
msgstr ""
"Project-Id-Version: 0.2.1\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2001-06-03 18:06+CET\n"
"Last-Translator: jdavid\n"
"Language-Team: ??\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8-bit\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "Afegir"
#, fuzzy
msgid "Add Local Content"
msgstr "Contingut localitzat"
#, fuzzy
msgid "Add Local Folder"
msgstr "Nou Localizer"
#, fuzzy
msgid "Add Localizer"
msgstr "Nou Localizer"
msgid "Add Message Catalog"
msgstr ""
#, fuzzy
msgid "Add language"
msgstr "Nou llenguatge"
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
msgid "Assamese"
msgstr ""
#: LocalFolder.py:62
msgid "Attributes"
msgstr ""
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr ""
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
#, fuzzy
msgid "Browse the messages"
msgstr "Idiomes pendents"
#: utils.py:114
msgid "Bulgarian"
msgstr ""
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr "Català"
msgid "Change"
msgstr ""
msgid "Charset"
msgstr ""
#: utils.py:119
msgid "Chinese"
msgstr ""
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr "Contingut"
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
#, fuzzy
msgid "Croatian"
msgstr "Català"
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
msgid "Danish"
msgstr ""
msgid "Default language"
msgstr "Idioma per defecte"
msgid "Delete"
msgstr "Esborrar"
#, fuzzy
msgid "Delete languages"
msgstr "Idioma per defecte"
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr ""
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
#, fuzzy
msgid "File"
msgstr "Filtrar"
#, fuzzy
msgid "File / Language"
msgstr "Nou llenguatge"
msgid "Filter"
msgstr "Filtrar"
#: utils.py:94
msgid "Find"
msgstr "Cercar"
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr ""
#: utils.py:138
msgid "French/Belgium"
msgstr ""
#: utils.py:139
msgid "French/Canada"
msgstr ""
#: utils.py:140
msgid "French/France"
msgstr ""
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
msgid "Georgian"
msgstr ""
#: utils.py:145
msgid "German"
msgstr ""
#: utils.py:146
msgid "German/Austria"
msgstr ""
#: utils.py:147
msgid "German/Germany"
msgstr ""
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
msgid "Guarani"
msgstr ""
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
#, fuzzy
msgid "Hindi"
msgstr "Cercar"
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr ""
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr "Id"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr ""
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
#, fuzzy
msgid "Italian"
msgstr "Català"
#: utils.py:165
msgid "Japanese"
msgstr ""
#: utils.py:166
#, fuzzy
msgid "Javanese"
msgstr "Guardar canvis"
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
#, fuzzy
msgid "Language"
msgstr "Nou llenguatge"
#: LanguageManager.py:157
#, fuzzy
msgid "Languages"
msgstr "Nou llenguatge"
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
#, fuzzy
msgid "Local properties"
msgstr "Propietats"
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
#, fuzzy
msgid "Localizer"
msgstr "Nou Localizer"
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
msgid "Message to translate"
msgstr ""
#: MessageCatalog.py:303
msgid "Messages"
msgstr ""
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
msgid "Messages imported"
msgstr ""
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr ""
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr ""
#, fuzzy
msgid "Original language"
msgstr "Idioma per defecte"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr "Propietat"
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
msgid "Persian"
msgstr ""
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
#, fuzzy
msgid "Portuguese"
msgstr "Propietats"
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr "Propietats"
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr ""
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
msgid "Sangho"
msgstr ""
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr ""
msgid "Save changes"
msgstr "Guardar canvis"
#: MessageCatalog.py:439 MessageCatalog.py:454
#, fuzzy
msgid "Saved changes."
msgstr "Guardar canvis"
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr "Seguritat"
#: utils.py:211
msgid "Serbian"
msgstr ""
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
#, fuzzy
msgid "Sindhi"
msgstr "Cercar"
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr ""
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
msgid "Spanish/Colombia"
msgstr ""
#: utils.py:225
msgid "Spanish/Mexico"
msgstr ""
#: utils.py:226
msgid "Spanish/Spain"
msgstr ""
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
#, fuzzy
msgid "Tamil"
msgstr "Títol"
#, fuzzy
msgid "Target language"
msgstr "Idiomes pendents"
#, fuzzy
msgid "Target languages"
msgstr "Idiomes pendents"
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr ""
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
#, fuzzy
msgid "There are no attributes"
msgstr "Idiomes pendents"
#, fuzzy
msgid "There are no languages"
msgstr "Idiomes pendents"
#, fuzzy
msgid "There are no messages."
msgstr "Idiomes pendents"
msgid "This object is up-to-date."
msgstr ""
msgid "This object must be upgraded."
msgstr ""
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Títol"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr ""
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
#, fuzzy
msgid "Translate properties"
msgstr "Propietats"
#, fuzzy
msgid "Translations"
msgstr "Traduccions disponibles"
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Tipus"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr "Desfer"
#: LanguageManager.py:168
msgid "Upgrade"
msgstr ""
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr ""
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr "Veure"
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid "Your e-mail address"
msgstr ""
msgid "Your name"
msgstr ""
#: utils.py:254
msgid "Zhuang"
msgstr ""
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#, fuzzy
#~ msgid "Default"
#~ msgstr "Esborrar"
#, fuzzy
#~ msgid "Hide this language"
#~ msgstr "Nou llenguatge"
#, fuzzy
#~ msgid "Show this language"
#~ msgstr "Idiomes pendents"
#~ msgid "Next"
#~ msgstr "Següent"
#~ msgid "Previous"
#~ msgstr "Anterior"
#~ msgid "All"
#~ msgstr "Tots"
#~ msgid "Batch size"
#~ msgstr "Grandària del lot"
#~ msgid "Full"
#~ msgstr "Total"
#~ msgid "Localized Content"
#~ msgstr "Contingut localitzat"
#~ msgid "Localized Strings"
#~ msgstr "Cadenes localitzades"
#, fuzzy
#~ msgid "New Local Content"
#~ msgstr "Contingut localitzat"
#~ msgid "New Localizer"
#~ msgstr "Nou Localizer"
#~ msgid "Only valid"
#~ msgstr "Sols els vàlids"
#~ msgid "Partial"
#~ msgstr "Parcial"
#~ msgid "Pending languages"
#~ msgstr "Idiomes pendents"
#~ msgid "Regular expression"
#~ msgstr "Expressió regular"
#~ msgid "Results"
#~ msgstr "Resultats"
#~ msgid "Status"
#~ msgstr "Estat"
#~ msgid "Text"
#~ msgstr "Texte"
#~ msgid "of"
#~ msgstr "de"
product/Localizer/locale/da.po 0 → 100644
View file @ 52146f5e
msgid ""
msgstr "Project-Id-Version: Localizer for Zope\n"
"POT-Creation-Date: 2004-03-22 20:03+CET\n"
"PO-Revision-Date: 2004-03-22 20:03+CET\n"
"Last-Translator: <>\n"
"Language-Team: da <>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
msgid "(Afan) Oromo"
msgstr ""
msgid "<em>No languages available, please add them using the <a href='manage_languages'>Languages</a> tab</em>"
msgstr "<em>Ingen tilgængelige sprog, opret den venligst med <a href='manage_languages'>Sprog</a> fanebladet</em>"
msgid "A Local Content object provides a storage for multilingual (and non multilingual) properties. It also helps you keep your content separated from the logic and the presentation."
msgstr "Et Local Content objekt leverer plads for flersprogede (og enkeltsprogede) egenskaber.\r\nDet hjælper dig også med at adskille indhold fra logik og præsentation."
msgid "A Localizer object lets you customize the language negotiation policy. It lets you use cookies, the path or any other criteria to select the user prefered language."
msgstr "Et Localizer object lader du tilpasse sprogforhandlingspolitikken. Det lader dig bruge cookies, stien eller enhvert andet kriterium for at fange brugerens foretrukne sprog"
msgid "A local folder is a generic solution to manage any kind of multingual objects, files, images, scripts, etc.."
msgstr ""
msgid "A message catalog stores messages and its translations to different languages. It provides the <tt>gettext</tt> method to get the right translation for a given message. Message catalogs are useful to translate the application interfaces (labels, buttons, etc..)."
msgstr "Et message catalog indeholder tekster og deres oversættelser til\r\nforskellige sprog. Det leverer <tt>gettext</tt> metoden til at få\r\nden rigtige oversættelse for en given tekst. Message catalog'er er\r\nnyttige til at oversætte applikationssnitflader (etiketter, knapper, etc...)."
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "Tilføj"
msgid "Add Local Content"
msgstr "Opret Local Content"
msgid "Add Local Folder"
msgstr "Opret Local Folder"
msgid "Add Localizer"
msgstr "Opret Localizer"
msgid "Add Message Catalog"
msgstr "Opret Message Catalog"
msgid "Afar"
msgstr ""
msgid "Afrikaans"
msgstr ""
msgid "Albanian"
msgstr "Albansk"
msgid "Amharic"
msgstr "Amharisk"
msgid "Arabic"
msgstr "Arabisk"
msgid "Arabic (Egypt)"
msgstr "Arabisk (egyptisk)"
msgid "Arabic (Lebanon)"
msgstr "Arabisk (libanesisk)"
msgid "Armenian"
msgstr ""
msgid "Assamese"
msgstr ""
msgid "Attributes"
msgstr "Attributter"
msgid "Aymara"
msgstr ""
msgid "Azerbaijani"
msgstr "Aserbadjansk"
msgid "Bashkir"
msgstr ""
msgid "Basque"
msgstr "Baskisk"
msgid "Bengali"
msgstr ""
msgid "Bengali; Bangla"
msgstr ""
msgid "Besides the title the header of a PO file stores more information; the name and the email address of the last translator, the email address of the translation team and the charset. The forms below let you modify this information for each language."
msgstr "Udover titlen gemmer hovedet på PO filen på mere information;\r\nnavn og email adresse på den sidste oversætter, email adressen på\r\noversættelsesholdet og tegnsættet. Formularerne nedenfor lader\r\ndig ændre denne information for hvert sprog."
msgid "Bhutani"
msgstr ""
msgid "Bihari"
msgstr ""
msgid "Bislama"
msgstr ""
msgid "Bosnian"
msgstr "Bosnisk"
msgid "Breton"
msgstr ""
msgid "Bulgarian"
msgstr "Bulgarsk"
msgid "Burmese"
msgstr ""
msgid "Byelorussian"
msgstr ""
msgid "Cambodian"
msgstr ""
msgid "Catalan"
msgstr "Katalansk"
msgid "Change"
msgstr "Ændr"
msgid "Charset"
msgstr "Tegnsæt"
msgid "Chinese"
msgstr "Kinesisk"
msgid "Chinese (simplified)"
msgstr "Kinesisk (forenklet)"
msgid "Chinese (traditional)"
msgstr "Kinesisk (traditionel)"
msgid "Chinese/China"
msgstr "Kinesisk/kina"
msgid "Chinese/Taiwan"
msgstr "Kinesisk/Taiwan"
msgid "Clear catalog and import all messages"
msgstr "Slet kataloget og importer alle tekster"
msgid "Contents"
msgstr "Indhold"
msgid "Corsican"
msgstr ""
msgid "Croatian"
msgstr "Kroatisk"
msgid "Czech"
msgstr "Tjekkisk"
msgid "Danish"
msgstr "Dansk"
msgid "Delete"
msgstr "Slet"
msgid "Dutch"
msgstr "Hollandsk"
msgid "Dutch/Belgium"
msgstr ""
msgid "English"
msgstr "Engelsk"
msgid "English/United Kingdom"
msgstr ""
msgid "English/United States"
msgstr ""
msgid "Esperanto"
msgstr "Esperanto"
msgid "Estonian"
msgstr "Estisk"
msgid "Export"
msgstr "Eksportér"
msgid "Export messages to PO file"
msgstr "Eksporter tekster til PO fil"
msgid "Export messages to TMX file"
msgstr "Eksporter tekster til TMX fil"
msgid "Export messages to XLIFF file"
msgstr "Exporter tekster til XLIFF fil"
msgid "Faroese"
msgstr ""
msgid "Fiji"
msgstr ""
msgid "File"
msgstr "Fil"
msgid "File / Language"
msgstr "Fil / Sprog"
msgid "Filter"
msgstr "Filtrer"
msgid "Find"
msgstr "Find"
msgid "Finnish"
msgstr "Finsk"
msgid "French"
msgstr "Fransk"
msgid "French/Belgium"
msgstr ""
msgid "French/Canada"
msgstr "Fransk/Canada"
msgid "French/France"
msgstr "Fransk/Frankrig"
msgid "French/Switzerland"
msgstr ""
msgid "Frisian"
msgstr ""
msgid "Galician"
msgstr "Galisisk"
msgid "Georgian"
msgstr "Georgiansk"
msgid "German"
msgstr "Tysk"
msgid "German/Austria"
msgstr ""
msgid "German/Germany"
msgstr ""
msgid "German/Switzerland"
msgstr ""
msgid "Greek"
msgstr "Græsk"
msgid "Greenlandic"
msgstr ""
msgid "Guarani"
msgstr ""
msgid "Gujarati"
msgstr "Gujarati"
msgid "Hausa"
msgstr ""
msgid "Hebrew"
msgstr "Hebraisk"
msgid "Hide this language"
msgstr "Skjul dette sprog"
msgid "Hindi"
msgstr "Hindi"
msgid "How much"
msgstr "Hvor meget"
msgid "Hungarian"
msgstr "Ungarsk"
msgid "Icelandic"
msgstr "Islandsk"
msgid "Id"
msgstr "Id"
msgid "Import"
msgstr "Importér"
msgid "Import all messages"
msgstr "Importer all tekster"
msgid "Import only translations for messages that exist already"
msgstr "Importer kun oversættelser for tekster som allerede eksisterer"
msgid "Import translations from PO file"
msgstr "Importer oversættelser fra PO fil"
msgid "Import translations from TMX file"
msgstr "Importer oversættelser fra TMX fil"
msgid "Import translations from XLIFF file"
msgstr "Importer oversættelser fra XLIFF fil"
msgid "Import/Export"
msgstr "Import/Eksport"
msgid "Imported %d messages and %d notes"
msgstr "Importerede %d tekster og %d noter"
msgid "Indonesian"
msgstr "Indonesisk"
msgid "Interlingua"
msgstr "Interlingua"
msgid "Interlingue"
msgstr ""
msgid "Inuktitut"
msgstr ""
msgid "Inupiak"
msgstr ""
msgid "Irish"
msgstr "Irsk"
msgid "Italian"
msgstr "Italiensk"
msgid "Japanese"
msgstr "Japansk"
msgid "Javanese"
msgstr ""
msgid "Kannada"
msgstr "Kannada"
msgid "Kashmiri"
msgstr ""
msgid "Kazakh"
msgstr ""
msgid "Kinyarwanda"
msgstr ""
msgid "Kirghiz"
msgstr ""
msgid "Kirundi"
msgstr ""
msgid "Korean"
msgstr "Koreansk"
msgid "Kurdish"
msgstr ""
msgid "Language"
msgstr "Sprog"
msgid "Languages"
msgstr "Sprog"
msgid "Laothian"
msgstr ""
msgid "Latin"
msgstr ""
msgid "Latvian"
msgstr "Lettisk"
msgid "Latvian, Lettish"
msgstr ""
msgid "Lingala"
msgstr ""
msgid "Lithuanian"
msgstr "Litauisk"
msgid "Local properties"
msgstr "Lokale egenskaber"
msgid "Locale folders are useful to store special multilingual objects like images and specific logic. If used the <tt>Localizer</tt> object will transparently add the right locale folder to the url. If you want to use locale folders check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> button."
msgstr ""
msgid "Macedonian"
msgstr "Makedonsk"
msgid "Malagasy"
msgstr ""
msgid "Malay"
msgstr "Malayisk"
msgid "Malayalam"
msgstr "Malayam"
msgid "Maltese"
msgstr ""
msgid "Maori"
msgstr ""
msgid "Marathi"
msgstr "Marathi"
msgid "Messages"
msgstr "Tekster"
msgid "Messages imported"
msgstr "Tekster importeret"
msgid "Moldavian"
msgstr ""
msgid "Mongolian"
msgstr "Mongolsk"
msgid "Name"
msgstr "Navn"
msgid "Nauru"
msgstr ""
msgid "Nepali"
msgstr ""
msgid "Norwegian"
msgstr "Norsk"
msgid "Note"
msgstr "Note"
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr "Kun uoversatte tekster"
msgid "Original language"
msgstr "Oprindeligt sprog"
msgid "Oriya"
msgstr "Oriya"
msgid "Ownership"
msgstr "Ejerskab"
msgid "Pashto, Pushto"
msgstr ""
msgid "Persian"
msgstr "Persisk"
msgid "Polish"
msgstr "Polsk"
msgid "Portuguese"
msgstr "Portugisisk"
msgid "Portuguese/Brazil"
msgstr ""
msgid "Properties"
msgstr "Egenskaber"
msgid "Punjabi"
msgstr ""
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr "Resultater %d-%d of %d"
msgid "Rhaeto-Romance"
msgstr ""
msgid "Romanian"
msgstr "Romansk"
msgid "Russian"
msgstr "Russisk"
msgid "Samoan"
msgstr ""
msgid "Sangho"
msgstr ""
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr "Gem"
msgid "Save changes"
msgstr "Gem ændringer"
msgid "Saved changes."
msgstr "Ændringer er gemt."
msgid "Scots Gaelic"
msgstr ""
msgid "Security"
msgstr "Sikkerhed"
msgid "Serbian"
msgstr "Serbisk"
msgid "Serbo-Croatian"
msgstr ""
msgid "Sesotho"
msgstr ""
msgid "Setswana"
msgstr ""
msgid "Shona"
msgstr ""
msgid "Show this language"
msgstr "Vis dette sprog"
msgid "Sindhi"
msgstr ""
msgid "Sinhalese"
msgstr ""
msgid "Siswati"
msgstr ""
msgid "Slovak"
msgstr "Slovakisk"
msgid "Slovenian"
msgstr "Slovensk"
msgid "Somali"
msgstr ""
msgid "Spanish"
msgstr "Spansk"
msgid "Spanish/Argentina"
msgstr "Spansk/Argentina"
msgid "Spanish/Colombia"
msgstr "Spansk/Colombia"
msgid "Spanish/Mexico"
msgstr "Spansk/Mexico"
msgid "Spanish/Spain"
msgstr "Spansk/Spanien"
msgid "Sundanese"
msgstr ""
msgid "Swahili"
msgstr ""
msgid "Swedish"
msgstr "Svensk"
msgid "TMX"
msgstr "TMX"
msgid "TMX stands for Translation Memory eXchange. The purpose of a translation memory is to gather thousands of translations. Whenever you need a term such as <tt>Home</tt> for your website chances are it is already translated, and all you have to do is to load a TMX file to get the translations."
msgstr ""
msgid "Tagalog"
msgstr ""
msgid "Tajik"
msgstr ""
msgid "Tamil"
msgstr "Tamilsk"
msgid "Target language"
msgstr "Oversættelsessprog"
msgid "Target languages"
msgstr "Oversættelsessprog"
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr "Team e-mail adresse"
msgid "Telugu"
msgstr "Telugu"
msgid "Thai"
msgstr "Thailandsk"
msgid "The message catalog also supports importing TMX files. You can add new messages and translations importing a TMX file in TMX level 1. Enter the filename and click the <tt>Import</tt> button."
msgstr ""
msgid "There are no attributes"
msgstr "Der er ingen attributter"
msgid "There are no languages"
msgstr "Der er ingen sprog"
msgid "There are no messages."
msgstr "Der er ingen tekster"
msgid "There are no properties."
msgstr "Der er ingen egenskaber"
msgid "This <tt>%s</tt> object needs to be upgraded"
msgstr "Dette <tt>%s</tt> objekt skal opgraderes"
msgid "This <tt>Localizer</tt> object doesn't need to be upgraded."
msgstr "Dette <tt>Localizer</tt> objekt behøver ikke at bliver opgraderet"
msgid "This <tt>Localizer</tt> object needs to be upgraded."
msgstr "Dette <tt>Localizer</tt> objekt skal opgraderes"
msgid "This object doesn't need to be upgraded."
msgstr "Dette objekt har ikke behov for at blive opgraderet"
msgid "Tibetan"
msgstr ""
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Titel"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
msgid "To add a new property enter its name, select its type and click the <tt>Add</tt> button."
msgstr ""
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
msgid "To change the default language select it and click the <tt>Change</tt> button."
msgstr ""
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
msgid "Tonga"
msgstr ""
msgid "Tsonga"
msgstr ""
msgid "Turkish"
msgstr "Tyrkisk"
msgid "Turkmen"
msgstr ""
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Type"
msgid "Uighur"
msgstr ""
msgid "Ukrainian"
msgstr "Ukrainsk"
msgid "Undo"
msgstr "Fortryd"
msgid "Upgrade"
msgstr "Opgradere"
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr ""
msgid "Uzbek"
msgstr ""
msgid "Vietnamese"
msgstr "Vietnamesisk"
msgid "View"
msgstr "Vis"
msgid "Volapuk"
msgstr ""
msgid "Welsh"
msgstr "Wallisisk"
msgid "With this form you can change the title of the message catalog. The title also is used as the value of the <tt>Project-Id-Version</tt> field in the header of the PO files, which are generated when the message catalog is exported."
msgstr ""
msgid "Wolof"
msgstr ""
msgid "Xhosa"
msgstr ""
msgid "Yiddish"
msgstr "Jiddisch"
msgid "Yoruba"
msgstr ""
msgid "You can add new messages and translations importing a PO file. Enter the filename, select the language of the translations and click the <tt>Import</tt> button."
msgstr ""
msgid "You can export the messages and their translations to PO files. Check <tt>locale.pot</tt> to get only the messages, without their translations. Check any other option to get a PO file with the messages and their translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid "You can export the messages and their translations to TMX level 1 files. To do that just click the <tt>Export</tt> button."
msgstr ""
msgid "You can export the messages and their translations to XLIFF files. Check any option to get a XLIFF file with the messages and their translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid "Your e-mail address"
msgstr "Din email adresse"
msgid "Your name"
msgstr "Dit navn"
msgid "Zhuang"
msgstr ""
msgid "Zulu"
msgstr ""
msgid "label"
msgstr "etiket"
product/Localizer/locale/de.po 0 → 100644
View file @ 52146f5e
msgid ""
msgstr ""
"Project-Id-Version: PRODUCT VERSION\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2001-05-03 11:05+Neuseeland Normalzeit\n"
"Last-Translator: Danny\n"
"Language-Team: ??\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8-bit\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "Hinzufügen"
msgid "Add Local Content"
msgstr ""
msgid "Add Local Folder"
msgstr ""
msgid "Add Localizer"
msgstr ""
msgid "Add Message Catalog"
msgstr ""
#, fuzzy
msgid "Add language"
msgstr "Neue Sprache"
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
msgid "Assamese"
msgstr ""
#: LocalFolder.py:62
msgid "Attributes"
msgstr ""
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr ""
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
#, fuzzy
msgid "Browse the messages"
msgstr "Neue Sprache"
#: utils.py:114
msgid "Bulgarian"
msgstr ""
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr ""
msgid "Change"
msgstr ""
msgid "Charset"
msgstr ""
#: utils.py:119
msgid "Chinese"
msgstr ""
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr ""
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
msgid "Croatian"
msgstr ""
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
msgid "Danish"
msgstr ""
#, fuzzy
msgid "Default language"
msgstr "Neue Sprache"
msgid "Delete"
msgstr "Löschen"
#, fuzzy
msgid "Delete languages"
msgstr "Neue Sprache"
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr ""
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
#, fuzzy
msgid "File"
msgstr "Filtern"
#, fuzzy
msgid "File / Language"
msgstr "Neue Sprache"
msgid "Filter"
msgstr "Filtern"
#: utils.py:94
msgid "Find"
msgstr ""
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr ""
#: utils.py:138
msgid "French/Belgium"
msgstr ""
#: utils.py:139
msgid "French/Canada"
msgstr ""
#: utils.py:140
msgid "French/France"
msgstr ""
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
msgid "Georgian"
msgstr ""
#: utils.py:145
msgid "German"
msgstr ""
#: utils.py:146
msgid "German/Austria"
msgstr ""
#: utils.py:147
msgid "German/Germany"
msgstr ""
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
msgid "Guarani"
msgstr ""
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
msgid "Hindi"
msgstr ""
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr ""
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr "Id"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr ""
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
msgid "Italian"
msgstr ""
#: utils.py:165
msgid "Japanese"
msgstr ""
#: utils.py:166
#, fuzzy
msgid "Javanese"
msgstr "Änderungen speichern"
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
#, fuzzy
msgid "Language"
msgstr "Neue Sprache"
#: LanguageManager.py:157
#, fuzzy
msgid "Languages"
msgstr "Neue Sprache"
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
msgid "Local properties"
msgstr ""
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
msgid "Localizer"
msgstr ""
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
msgid "Message to translate"
msgstr ""
#: MessageCatalog.py:303
msgid "Messages"
msgstr ""
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
msgid "Messages imported"
msgstr ""
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr ""
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr ""
#, fuzzy
msgid "Original language"
msgstr "Neue Sprache"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr ""
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
msgid "Persian"
msgstr ""
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
msgid "Portuguese"
msgstr ""
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr ""
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr ""
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
msgid "Sangho"
msgstr ""
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr ""
msgid "Save changes"
msgstr "Änderungen speichern"
#: MessageCatalog.py:439 MessageCatalog.py:454
#, fuzzy
msgid "Saved changes."
msgstr "Änderungen speichern"
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr ""
#: utils.py:211
msgid "Serbian"
msgstr ""
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
msgid "Sindhi"
msgstr ""
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr ""
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
msgid "Spanish/Colombia"
msgstr ""
#: utils.py:225
msgid "Spanish/Mexico"
msgstr ""
#: utils.py:226
msgid "Spanish/Spain"
msgstr ""
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
#, fuzzy
msgid "Tamil"
msgstr "Titel"
#, fuzzy
msgid "Target language"
msgstr "Neue Sprache"
#, fuzzy
msgid "Target languages"
msgstr "Neue Sprache"
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr ""
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
#, fuzzy
msgid "There are no attributes"
msgstr "Neue Sprache"
#, fuzzy
msgid "There are no languages"
msgstr "Neue Sprache"
#, fuzzy
msgid "There are no messages."
msgstr "Neue Sprache"
msgid "This object is up-to-date."
msgstr ""
msgid "This object must be upgraded."
msgstr ""
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Titel"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr ""
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
msgid "Translate properties"
msgstr ""
#, fuzzy
msgid "Translations"
msgstr "Verfügbare Übersetzungen"
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Typ"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr ""
#: LanguageManager.py:168
msgid "Upgrade"
msgstr ""
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr ""
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr ""
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid "Your e-mail address"
msgstr ""
msgid "Your name"
msgstr ""
#: utils.py:254
msgid "Zhuang"
msgstr ""
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#, fuzzy
#~ msgid "Default"
#~ msgstr "Löschen"
#, fuzzy
#~ msgid "Show this language"
#~ msgstr "Neue Sprache"
#~ msgid "Next"
#~ msgstr "Nächste"
#~ msgid "Previous"
#~ msgstr "Vorherige"
#~ msgid "Full"
#~ msgstr "Vollständig"
#~ msgid "Partial"
#~ msgstr "Partiell"
#~ msgid "Regular expression"
#~ msgstr "Regulärer Ausdruck"
#~ msgid "Results"
#~ msgstr "Ergebnisse"
#~ msgid "Text"
#~ msgstr "Text"
#~ msgid "of"
#~ msgstr "von"
product/Localizer/locale/en.po 0 → 100644
View file @ 52146f5e
msgid ""
msgstr ""
"Project-Id-Version: 0.3.0\n"
"POT-Creation-Date: 2001-10-13 19:10+CET\n"
"PO-Revision-Date: 2001-07-08 17:07+CET\n"
"Last-Translator: jdavid\n"
"Language-Team: ??\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8-bit\n"
product/Localizer/locale/es.po 0 → 100644
View file @ 52146f5e
msgid ""
msgstr ""
"Project-Id-Version: 0.3.0\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2002-10-12 16:58GMT+1\n"
"Last-Translator: Juan David Ibáñez Palomar <jdavid@nuxeo.com>\n"
"Language-Team: Spanish <es@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 0.9.5\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
#, fuzzy
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
"Un objeto <em>Local Content</em> proporciona un medio para almacenar "
"propiedades multilingües (y monolingües). También ayuda a mantener el "
"contenido separado de la lógica y la presentación."
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
"Una carpeta local es una solución genérica para gestionar cualquier tipo de "
"objetos multilingües, ficheros, imágenes, guiones de código, etc.."
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
"Un catálogo de mensajes almacena mensajes y sus traducciones a diferentes "
"idiomas. Proporciona el método <tt>gettext</tt> para obtener la traducción "
"correcta en un idioma dado. Los catálogos de mensajes son útiles para "
"traducir las interfaces de la aplicación (etiquetas, botones, etc..)."
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "Añadir"
msgid "Add Local Content"
msgstr "Añadir contenido localizado"
msgid "Add Local Folder"
msgstr "Añadir carpeta local"
msgid "Add Localizer"
msgstr "Añadir <em>Localizer</em>"
msgid "Add Message Catalog"
msgstr "Añadir un catálogo de mensajes"
#, fuzzy
msgid "Add language"
msgstr "Idioma"
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
#, fuzzy
msgid "Assamese"
msgstr "Mensajes"
#: LocalFolder.py:62
msgid "Attributes"
msgstr "Atributos"
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr ""
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
#, fuzzy
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
"Además del título las cabeceras de los ficheros PO almacenan más "
"información, el nombre y la dirección de correo electrónico del último "
"traductor, la dirección de correo electrónico del equipo de traducción y el "
"conjunto de caracteres. Los formularios que hay abajo permiten modificar "
"esta información para cada idioma."
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
#, fuzzy
msgid "Browse the messages"
msgstr "No hay mensajes."
#: utils.py:114
msgid "Bulgarian"
msgstr ""
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr ""
msgid "Change"
msgstr "Cambiar"
msgid "Charset"
msgstr "Conjunto de caracteres"
#: utils.py:119
#, fuzzy
msgid "Chinese"
msgstr "Cambiar"
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr "Contenido"
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
msgid "Croatian"
msgstr ""
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
#, fuzzy
msgid "Danish"
msgstr "Español"
#, fuzzy
msgid "Default language"
msgstr "Ocultar este idioma"
msgid "Delete"
msgstr "Eliminar"
#, fuzzy
msgid "Delete languages"
msgstr "No hay idiomas."
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr "Exportar"
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
msgid "File"
msgstr "Fichero"
msgid "File / Language"
msgstr "Fichero / Idioma"
msgid "Filter"
msgstr "Filtrar"
#: utils.py:94
msgid "Find"
msgstr "Buscar"
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr ""
#: utils.py:138
msgid "French/Belgium"
msgstr ""
#: utils.py:139
msgid "French/Canada"
msgstr ""
#: utils.py:140
msgid "French/France"
msgstr ""
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
msgid "Georgian"
msgstr ""
#: utils.py:145
msgid "German"
msgstr ""
#: utils.py:146
msgid "German/Austria"
msgstr ""
#: utils.py:147
msgid "German/Germany"
msgstr ""
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
msgid "Guarani"
msgstr ""
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
#, fuzzy
msgid "Hindi"
msgstr "Buscar"
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr ""
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr "Id"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr "Importar"
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
msgid "Italian"
msgstr ""
#: utils.py:165
msgid "Japanese"
msgstr ""
#: utils.py:166
#, fuzzy
msgid "Javanese"
msgstr "Guardar cambios"
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
msgid "Language"
msgstr "Idioma"
#: LanguageManager.py:157
msgid "Languages"
msgstr "Idiomas"
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
msgid "Local properties"
msgstr "Propiedades locales"
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
"Las carpetas locales son útiles para almacenar objetos multilingües "
"especiales como imágenes y lógica específica. Si se usan el objeto "
"<tt>Localizer</tt> de forma transparente añadirá la carpeta local correcta a "
"la <em>url</em>. Si quieres usar las carpetas locales selecciona el cuadro "
"de selección, si no deseleccionalo, entonces pulsa en botón <tt>Cambiar</tt>."
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
#, fuzzy
msgid "Localizer"
msgstr "Añadir <em>Localizer</em>"
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
#, fuzzy
msgid "Message to translate"
msgstr "Mensajes"
#: MessageCatalog.py:303
msgid "Messages"
msgstr "Mensajes"
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
#, fuzzy
msgid "Messages imported"
msgstr "Mensajes"
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr "Nombre"
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr "Solamente mensajes sin traducción"
#, fuzzy
msgid "Original language"
msgstr "Ocultar este idioma"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr "Propiedad"
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
msgid "Persian"
msgstr ""
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
#, fuzzy
msgid "Portuguese"
msgstr "Propiedades"
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr "Propiedades"
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr "Resultados %d-%d de %d"
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
#, fuzzy
msgid "Sangho"
msgstr "Español"
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr "Guardar"
msgid "Save changes"
msgstr "Guardar cambios"
#: MessageCatalog.py:439 MessageCatalog.py:454
msgid "Saved changes."
msgstr "Cambios guardados."
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr "Seguridad"
#: utils.py:211
msgid "Serbian"
msgstr ""
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
#, fuzzy
msgid "Sindhi"
msgstr "Buscar"
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr "Español"
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
#, fuzzy
msgid "Spanish/Colombia"
msgstr "Español"
#: utils.py:225
#, fuzzy
msgid "Spanish/Mexico"
msgstr "Español"
#: utils.py:226
#, fuzzy
msgid "Spanish/Spain"
msgstr "Español"
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
#, fuzzy
msgid "Tamil"
msgstr "Título"
#, fuzzy
msgid "Target language"
msgstr "No hay idiomas."
#, fuzzy
msgid "Target languages"
msgstr "No hay idiomas."
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr "Dirección de <em>email</em> del equipo"
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
#, fuzzy
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
"Puedes añadir nuevos mensajes y traducciones importando ficheros PO. "
"Introduce el nombre del fichero, selecciona el idioma de las traducciones y "
"pulsa el botón <tt>Importar</tt>."
#, fuzzy
msgid "There are no attributes"
msgstr "No hay atributos."
#, fuzzy
msgid "There are no languages"
msgstr "No hay idiomas."
#, fuzzy
msgid "There are no messages."
msgstr "No hay mensajes."
msgid "This object is up-to-date."
msgstr ""
#, fuzzy
msgid "This object must be upgraded."
msgstr "Este objeto no necesita ser actualizado."
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Título"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr "Para añadir un idioma seleccionalo y pulsa el botón <tt>Añadir</tt>."
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
"Para añadir un atributo introduce su id y pulsa el botón <tt>Añadir</tt>."
#, fuzzy
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr "Para añadir un idioma seleccionalo y pulsa el botón <tt>Añadir</tt>."
#, fuzzy
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
"Para eliminar un atributo seleccionalo y pulsa el botón <tt>Eliminar</tt>."
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
"Para eliminar un atributo seleccionalo y pulsa el botón <tt>Eliminar</tt>."
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
#, fuzzy
msgid "Translate properties"
msgstr "No hay propiedades."
#, fuzzy
msgid "Translations"
msgstr "No hay propiedades."
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Tipo"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr "Deshacer"
#: LanguageManager.py:168
msgid "Upgrade"
msgstr "Actualizar"
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr "Usar carpetas locales"
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr "Ver"
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
"Con este formulario puedes cambiar el título del catálogo de mensajes. El "
"título también se utiliza como valor del campo <tt>Project-Id-Version</tt> "
"en la cabecera de los ficheros PO, los cuales se generan cuando se exporta "
"el catálogo de mensajes."
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
"Puedes añadir nuevos mensajes y traducciones importando ficheros PO. "
"Introduce el nombre del fichero, selecciona el idioma de las traducciones y "
"pulsa el botón <tt>Importar</tt>."
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Puedes exportar los mensajes y sus traducciones a ficheros PO. Selecciona "
"<tt>locale.pot</tt> para obtener tan solo los mensajes, sin sus "
"traducciones. Selecciona cualquier otra opción para obtener un fichero PO "
"con los mensajes y sus traducciones al idioma seleccionado. Entonces pulsa "
"el botón <tt>Exportar</tt>."
#, fuzzy
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
"Puedes añadir nuevos mensajes y traducciones importando ficheros PO. "
"Introduce el nombre del fichero, selecciona el idioma de las traducciones y "
"pulsa el botón <tt>Importar</tt>."
#, fuzzy
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Puedes exportar los mensajes y sus traducciones a ficheros PO. Selecciona "
"<tt>locale.pot</tt> para obtener tan solo los mensajes, sin sus "
"traducciones. Selecciona cualquier otra opción para obtener un fichero PO "
"con los mensajes y sus traducciones al idioma seleccionado. Entonces pulsa "
"el botón <tt>Exportar</tt>."
msgid "Your e-mail address"
msgstr "Tu dirección de <em>email</em>"
msgid "Your name"
msgstr "Tu nombre"
#: utils.py:254
#, fuzzy
msgid "Zhuang"
msgstr "Cambiar"
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#~ msgid "This <tt>%s</tt> object needs to be upgraded"
#~ msgstr "Este objeto <tt>%s</tt> necesita ser actualizado"
#~ msgid "This <tt>Localizer</tt> object needs to be upgraded."
#~ msgstr "Este objeto <tt>Localizer</tt> debe ser actualizado"
#, fuzzy
#~ msgid "This <tt>Localizer</tt> object doesn't need to be upgraded."
#~ msgstr "Este objeto <tt>Localizer</tt> no necesita actualizarse"
#~ msgid "Import/Export"
#~ msgstr "Importar/Exportar"
#~ msgid "Default"
#~ msgstr "Por defecto"
#~ msgid ""
#~ "To delete a language check it and click the <tt>Delete</tt> button. To "
#~ "change the default language select it and click the <tt>Change</tt> "
#~ "button."
#~ msgstr ""
#~ "Para eliminar un idioma selecciónalo y pulsa el botón <tt>Eliminar</tt>. "
#~ "Para cambiar el idioma por defecto selecciónalo y pulsa el botón "
#~ "<tt>Cambiar</tt>."
#~ msgid "Show this language"
#~ msgstr "Mostrar este idioma"
#~ msgid ""
#~ "To add a new property enter its name, select its type and click the "
#~ "<tt>Add</tt> button."
#~ msgstr ""
#~ "Para añadir una nueva propiedad introduce su nombre, selecciona su tipo y "
#~ "pulsa el botón <tt>Añadir</tt>."
#~ msgid ""
#~ "A Localizer object provides <em>locale folders</em>, each one associated "
#~ "with a language. It transparently adds a locale folder to the path so "
#~ "objects for that language will be used. It's useful to localize special "
#~ "objects like images, or specific logic (to format dates for example)."
#~ msgstr ""
#~ "Un objeto <em>Localizer</em> proporciona <em>carpetas locales</em>, cada "
#~ "una asociada a un idioma. De forma transparente añade una carpeta local a "
#~ "la ruta, de este modo se usarán los objetos del lenguaje asociado. Es "
#~ "útil para localizar objetos especiales como imágenes, o lógica específica "
#~ "(para dar formato a las fechas por ejemplo)."
product/Localizer/locale/eu.po 0 → 100644
View file @ 52146f5e
msgid ""
msgstr ""
"Project-Id-Version: 0.3.0\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2001-07-08 17:07+CET\n"
"Last-Translator: code&syntax\n"
"Language-Team: ??\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8-bit\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "Gehitu"
#, fuzzy
msgid "Add Local Content"
msgstr "Itzulitako edukia"
msgid "Add Local Folder"
msgstr "Localizer berria"
#, fuzzy
msgid "Add Localizer"
msgstr "Localizer berria"
msgid "Add Message Catalog"
msgstr ""
#, fuzzy
msgid "Add language"
msgstr "Hizkuntza berria"
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
msgid "Assamese"
msgstr ""
#: LocalFolder.py:62
msgid "Attributes"
msgstr ""
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr ""
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
#, fuzzy
msgid "Browse the messages"
msgstr "Ez dago sarrerarik"
#: utils.py:114
msgid "Bulgarian"
msgstr ""
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr ""
msgid "Change"
msgstr ""
msgid "Charset"
msgstr ""
#: utils.py:119
msgid "Chinese"
msgstr ""
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr "Edukia"
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
msgid "Croatian"
msgstr ""
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
#, fuzzy
msgid "Danish"
msgstr "Gaztelania"
msgid "Default language"
msgstr "Hobetsitako hizkuntza"
msgid "Delete"
msgstr "Ezabatu"
#, fuzzy
msgid "Delete languages"
msgstr "Hobetsitako hizkuntza"
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr "Esportatu"
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
#, fuzzy
msgid "File"
msgstr "Galbahetu"
#, fuzzy
msgid "File / Language"
msgstr "Hizkuntza berria"
msgid "Filter"
msgstr "Galbahetu"
#: utils.py:94
msgid "Find"
msgstr "Bilatu"
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr ""
#: utils.py:138
msgid "French/Belgium"
msgstr ""
#: utils.py:139
msgid "French/Canada"
msgstr ""
#: utils.py:140
msgid "French/France"
msgstr ""
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
msgid "Georgian"
msgstr ""
#: utils.py:145
msgid "German"
msgstr ""
#: utils.py:146
msgid "German/Austria"
msgstr ""
#: utils.py:147
msgid "German/Germany"
msgstr ""
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
msgid "Guarani"
msgstr ""
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
#, fuzzy
msgid "Hindi"
msgstr "Bilatu"
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr ""
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr "Id"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr "Inportatu"
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
msgid "Italian"
msgstr ""
#: utils.py:165
msgid "Japanese"
msgstr ""
#: utils.py:166
#, fuzzy
msgid "Javanese"
msgstr "Aldaketak gorde"
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
#, fuzzy
msgid "Language"
msgstr "Hizkuntza berria"
#: LanguageManager.py:157
#, fuzzy
msgid "Languages"
msgstr "Hizkuntza berria"
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
#, fuzzy
msgid "Local properties"
msgstr "Ezaugarriak"
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
#, fuzzy
msgid "Localizer"
msgstr "Localizer berria"
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
#, fuzzy
msgid "Message to translate"
msgstr "Itzuli beharreko testua:"
#: MessageCatalog.py:303
msgid "Messages"
msgstr ""
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
msgid "Messages imported"
msgstr ""
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr ""
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr ""
#, fuzzy
msgid "Original language"
msgstr "Hobetsitako hizkuntza"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr "Jabetza"
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
msgid "Persian"
msgstr ""
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
#, fuzzy
msgid "Portuguese"
msgstr "Ezaugarriak"
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr "Ezaugarriak"
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr ""
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
#, fuzzy
msgid "Sangho"
msgstr "Gaztelania"
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr ""
msgid "Save changes"
msgstr "Aldaketak gorde"
#: MessageCatalog.py:439 MessageCatalog.py:454
#, fuzzy
msgid "Saved changes."
msgstr "Aldaketak gorde"
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr "Segurtasuna"
#: utils.py:211
msgid "Serbian"
msgstr ""
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
#, fuzzy
msgid "Sindhi"
msgstr "Bilatu"
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr "Gaztelania"
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
#, fuzzy
msgid "Spanish/Colombia"
msgstr "Gaztelania"
#: utils.py:225
#, fuzzy
msgid "Spanish/Mexico"
msgstr "Gaztelania"
#: utils.py:226
#, fuzzy
msgid "Spanish/Spain"
msgstr "Gaztelania"
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
#, fuzzy
msgid "Tamil"
msgstr "Izenburua"
#, fuzzy
msgid "Target language"
msgstr "Ez dago sarrerarik"
#, fuzzy
msgid "Target languages"
msgstr "Ez dago sarrerarik"
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr ""
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
#, fuzzy
msgid "There are no attributes"
msgstr "Ez dago sarrerarik"
#, fuzzy
msgid "There are no languages"
msgstr "Ez dago sarrerarik"
#, fuzzy
msgid "There are no messages."
msgstr "Ez dago sarrerarik"
msgid "This object is up-to-date."
msgstr ""
msgid "This object must be upgraded."
msgstr ""
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Izenburua"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr ""
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
#, fuzzy
msgid "Translate properties"
msgstr "Ez dago ezaugarri-orririk"
#, fuzzy
msgid "Translations"
msgstr "Itzulitakoak"
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Mota"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr "Desegin"
#: LanguageManager.py:168
msgid "Upgrade"
msgstr ""
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr ""
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr "Ikusi"
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid "Your e-mail address"
msgstr ""
msgid "Your name"
msgstr ""
#: utils.py:254
msgid "Zhuang"
msgstr ""
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#, fuzzy
#~ msgid "Import/Export"
#~ msgstr "Inportatu"
#, fuzzy
#~ msgid "Default"
#~ msgstr "Ezabatu"
#, fuzzy
#~ msgid "Hide this language"
#~ msgstr "Hizkuntza berria"
#, fuzzy
#~ msgid "Show this language"
#~ msgstr "Ez dago sarrerarik"
#~ msgid "Next"
#~ msgstr "Hurrengoa"
#~ msgid "Previous"
#~ msgstr "Aurrekoa"
#~ msgid "All"
#~ msgstr "Denak"
#~ msgid "Batch size"
#~ msgstr "Zenbat erakutsi"
#~ msgid "Full"
#~ msgstr "Osoa"
#~ msgid "Localized Content"
#~ msgstr "Itzulitako edukia"
#~ msgid "Localized Strings"
#~ msgstr "Itzulitako mezuak"
#, fuzzy
#~ msgid "New Local Content"
#~ msgstr "Itzulitako edukia"
#~ msgid "New Localizer"
#~ msgstr "Localizer berria"
#~ msgid "Only valid"
#~ msgstr "Balekoak bakarrik"
#~ msgid "Partial"
#~ msgstr "Partziala"
#~ msgid "Pending languages"
#~ msgstr "Egiteke dauden hizkuntzak"
#~ msgid "Regular expression"
#~ msgstr "Espresio erregularra"
#~ msgid "Results"
#~ msgstr "Emaitzak"
#~ msgid "Status"
#~ msgstr "Egoera"
#~ msgid "Text"
#~ msgstr "Testua"
#~ msgid "There are no entries."
#~ msgstr "Ez dago sarrerarik"
#~ msgid "There are not property sheets."
#~ msgstr "Ez dago ezaugarri-orririk"
#~ msgid "This property sheet is empty."
#~ msgstr "Ezaugarri-orri hau hutsik dago"
#~ msgid "of"
#~ msgstr "Guztira:"
product/Localizer/locale/fr.po 0 → 100644
View file @ 52146f5e
msgid ""
msgstr ""
"Project-Id-Version: PRODUCT VERSION\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2002-01-30 18:06GMT\n"
"Last-Translator: lefevre arnaud <al@nuxeo.com>\n"
"Language-Team: french\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 0.8\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
#, fuzzy
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
"Un Objet de contenu local permet de sauvegarder des propriétées multilingues "
"(ou unique). Il permet également de séparer le contenu de la présentation et "
"de la logique de l'application."
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
"Un message catalog stocke les messages et leurs traductions. Il fournit la "
"méthode <tt>gettext</tt> afin d'obtenir la bonne traduction pour un message "
"donné. Les message catalogs sont utiles pour traduire les interfaces des "
"applications (titres, boutons, etc.)."
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "Ajouter"
msgid "Add Local Content"
msgstr "Ajouter du contenu local"
msgid "Add Local Folder"
msgstr "Ajouter un répertoire de langue"
msgid "Add Localizer"
msgstr "Ajouter une instance \"Localizer\""
msgid "Add Message Catalog"
msgstr "Ajouter un Message Catalog"
#, fuzzy
msgid "Add language"
msgstr "Langue"
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
#, fuzzy
msgid "Assamese"
msgstr "Messages"
#: LocalFolder.py:62
msgid "Attributes"
msgstr ""
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr ""
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
#, fuzzy
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
"En plus du titre, l'entête d'un fichier PO stocke d'autres informations : le "
"nom et l'adresse email du dernier traducteur, l'adresse email de l'équipe de "
"traduction et le type de caractères. Le formulaire situé en dessous permet "
"de modifier ces information pour chaque langue."
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
#, fuzzy
msgid "Browse the messages"
msgstr "Il n'y a pas de message"
#: utils.py:114
msgid "Bulgarian"
msgstr ""
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr ""
msgid "Change"
msgstr "Modifier"
msgid "Charset"
msgstr "Type de caractères"
#: utils.py:119
#, fuzzy
msgid "Chinese"
msgstr "Modifier"
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr "Contenu"
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
msgid "Croatian"
msgstr ""
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
msgid "Danish"
msgstr ""
#, fuzzy
msgid "Default language"
msgstr "Cacher cette langue"
msgid "Delete"
msgstr "Effacer"
#, fuzzy
msgid "Delete languages"
msgstr "Il n'y a pas de langue"
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr "Exporter"
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
msgid "File"
msgstr "Fichier"
msgid "File / Language"
msgstr "Fichier / Langue"
msgid "Filter"
msgstr "Filtrer"
#: utils.py:94
msgid "Find"
msgstr "Recherche"
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr "Français"
#: utils.py:138
#, fuzzy
msgid "French/Belgium"
msgstr "Français"
#: utils.py:139
#, fuzzy
msgid "French/Canada"
msgstr "Français"
#: utils.py:140
#, fuzzy
msgid "French/France"
msgstr "Français"
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
msgid "Georgian"
msgstr ""
#: utils.py:145
msgid "German"
msgstr ""
#: utils.py:146
msgid "German/Austria"
msgstr ""
#: utils.py:147
msgid "German/Germany"
msgstr ""
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
msgid "Guarani"
msgstr ""
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
#, fuzzy
msgid "Hindi"
msgstr "Recherche"
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr ""
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr "Id"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr "Importer"
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
msgid "Italian"
msgstr ""
#: utils.py:165
msgid "Japanese"
msgstr ""
#: utils.py:166
#, fuzzy
msgid "Javanese"
msgstr "Sauvegarder les modifications"
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
msgid "Language"
msgstr "Langue"
#: LanguageManager.py:157
msgid "Languages"
msgstr "Langues"
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
msgid "Local properties"
msgstr "Propriétées locales"
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
"Les répertoires de langue sont utiles pour sauvegarder des objets "
"multilingues speciaux commes des images et leur logique spécifique. "
"Lorsqu'il est utilisé, l'objet <tt>Localizer</tt> va automatiquement ajouter "
"le Répertoire de langue approprié à l'url. Si vous voulez utiliser un "
"répertoire de langue spécifique, le sélectioner puis activé les "
"modifications en cliquant sur le bouton <tt>Change</tt>."
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
#, fuzzy
msgid "Localizer"
msgstr "Ajouter une instance \"Localizer\""
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
#, fuzzy
msgid "Message to translate"
msgstr "Texte a traduire:"
#: MessageCatalog.py:303
msgid "Messages"
msgstr "Messages"
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
#, fuzzy
msgid "Messages imported"
msgstr "Messages"
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr "Nom"
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
#, fuzzy
msgid "Only untranslated messages"
msgstr "Retour vers la gestion des messages"
#, fuzzy
msgid "Original language"
msgstr "Cacher cette langue"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr "Propriétaire"
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
msgid "Persian"
msgstr ""
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
#, fuzzy
msgid "Portuguese"
msgstr "Propriétés"
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr "Propriétés"
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr "Résutats %d-%d de %d"
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
msgid "Sangho"
msgstr ""
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr ""
msgid "Save changes"
msgstr "Sauvegarder les modifications"
#: MessageCatalog.py:439 MessageCatalog.py:454
#, fuzzy
msgid "Saved changes."
msgstr "Sauvegarder les modifications"
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr "Sécurité"
#: utils.py:211
msgid "Serbian"
msgstr ""
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
#, fuzzy
msgid "Sindhi"
msgstr "Recherche"
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr ""
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
msgid "Spanish/Colombia"
msgstr ""
#: utils.py:225
msgid "Spanish/Mexico"
msgstr ""
#: utils.py:226
msgid "Spanish/Spain"
msgstr ""
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
#, fuzzy
msgid "Tamil"
msgstr "Titre"
#, fuzzy
msgid "Target language"
msgstr "Il n'y a pas de langue"
#, fuzzy
msgid "Target languages"
msgstr "Il n'y a pas de langue"
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr "Adresse email de l'équipe"
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
#, fuzzy
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
"Vous pouvez ajouter de nouveau messages et traductions en important un "
"fichier de type \"PO\". Saisissez le nom de fichier, sélectionnez la langue "
"de traduction et cliquez sur le bouton <tt>Import</tt> ."
#, fuzzy
msgid "There are no attributes"
msgstr "Il n'y a pas de langue"
#, fuzzy
msgid "There are no languages"
msgstr "Il n'y a pas de langue"
#, fuzzy
msgid "There are no messages."
msgstr "Il n'y a pas de message"
msgid "This object is up-to-date."
msgstr ""
#, fuzzy
msgid "This object must be upgraded."
msgstr "Cet objet n'a pas besoin de mise à niveau."
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Titre"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
"Pour ajouter une langue, sélectionnez la et cliquer sur le bouton <tt>Add</"
"tt> ."
#, fuzzy
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
"Pour ajouter un nouveau message, sélectionnez le et cliquer sur le bouton "
"<tt>Add</tt> ."
#, fuzzy
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr ""
"Pour ajouter une langue, sélectionnez la et cliquer sur le bouton <tt>Add</"
"tt> ."
#, fuzzy
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
"Pour ajouter une langue, sélectionnez la et cliquer sur le bouton <tt>Add</"
"tt> ."
#, fuzzy
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
"Pour ajouter une langue, sélectionnez la et cliquer sur le bouton <tt>Add</"
"tt> ."
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
#, fuzzy
msgid "Translate properties"
msgstr "Il n'y a pas de propriétés"
#, fuzzy
msgid "Translations"
msgstr "Il n'y a pas de propriétés"
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Type"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr "Annuler"
#: LanguageManager.py:168
msgid "Upgrade"
msgstr "Mise à niveau"
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr "Utiliser le répertoire local"
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr "Visualiser"
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
"À l'aide de ce formulaire vous pouvez modifier le titre du message catalog. "
"Le titre est également utilisé comme valeur du champ <tt>Project-Id-Version</"
"tt>dans l'entête des fichiers PO. Ces derniers sont créés quand le message "
"catalog est exporté."
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
"Vous pouvez ajouter de nouveau messages et traductions en important un "
"fichier de type \"PO\". Saisissez le nom de fichier, sélectionnez la langue "
"de traduction et cliquez sur le bouton <tt>Import</tt> ."
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Vous pouvez exporter des messages et leurs traductions dans des fichiers de "
"type \"PO\". Sélectionnez <tt>locale.pot</tt> pour exporter les messages "
"sans traductions. Sélectionnez tout autre options pour générer un fichier "
"\"PO\" avec ses messages et leurs traductions dans le langage sélectioné. "
"Ensuite cliquez sur le bouton <tt>Export</tt>."
#, fuzzy
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
"Vous pouvez ajouter de nouveau messages et traductions en important un "
"fichier de type \"PO\". Saisissez le nom de fichier, sélectionnez la langue "
"de traduction et cliquez sur le bouton <tt>Import</tt> ."
#, fuzzy
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Vous pouvez exporter des messages et leurs traductions dans des fichiers de "
"type \"PO\". Sélectionnez <tt>locale.pot</tt> pour exporter les messages "
"sans traductions. Sélectionnez tout autre options pour générer un fichier "
"\"PO\" avec ses messages et leurs traductions dans le langage sélectioné. "
"Ensuite cliquez sur le bouton <tt>Export</tt>."
msgid "Your e-mail address"
msgstr "Votre adresse email"
msgid "Your name"
msgstr "Votre nom"
#: utils.py:254
#, fuzzy
msgid "Zhuang"
msgstr "Modifier"
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#~ msgid "This <tt>%s</tt> object needs to be upgraded"
#~ msgstr "Cet objet <tt>%s</tt> requière une mise à niveau."
#~ msgid "This <tt>Localizer</tt> object needs to be upgraded."
#~ msgstr "Cet objet <tt>Localizer</tt> a besoin d'une mise à niveau."
#, fuzzy
#~ msgid "This <tt>Localizer</tt> object doesn't need to be upgraded."
#~ msgstr "Cet objet <tt>Localizer</tt> ne requière pas de mise à niveau."
#~ msgid "Import/Export"
#~ msgstr "Importer/Exporter"
#~ msgid "Default"
#~ msgstr "Défaut"
#~ msgid ""
#~ "To delete a language check it and click the <tt>Delete</tt> button. To "
#~ "change the default language select it and click the <tt>Change</tt> "
#~ "button."
#~ msgstr ""
#~ "Pour supprimer un langage, sélectionnez le et cliquer le bouton "
#~ "<tt>Delete</tt> . Pour modifier le language de défault, sélectionnez le "
#~ "et cliquez le bouton <tt>Change</tt> ."
#~ msgid "Show this language"
#~ msgstr "Afficher cette langue"
#~ msgid ""
#~ "To add a new property enter its name, select its type and click the "
#~ "<tt>Add</tt> button."
#~ msgstr ""
#~ "Pour ajouter une nouvelle propriété, saisissez son nom, choisissez son "
#~ "type et cliquez sur le bouton <tt>Add</tt>."
#~ msgid ""
#~ "A Localizer object provides <em>locale folders</em>, each one associated "
#~ "with a language. It transparently adds a locale folder to the path so "
#~ "objects for that language will be used. It's useful to localize special "
#~ "objects like images, or specific logic (to format dates for example)."
#~ msgstr ""
#~ "Un objet Localizer fournit des <em>répertoire de langue</em>, chaque "
#~ "locale foldercorrespond à une langue. Localizer ajoute d'une manière "
#~ "transparente un locale folderà la variable d'environnement path pour que "
#~ "la langue soit utilisée. Il est très pratique de localiser des objets "
#~ "spéciaux (comme des images) ou des logiques particulières (pour formater "
#~ "les dates par exemple)."
#~ msgid ""
#~ "A locale folder is just a normal folder with a <tt>SiteRoot</tt>. Its id "
#~ "must be a language code, the title is optional. Locale folders are used "
#~ "to store special objects like images and logic that needs to be localized."
#~ msgstr ""
#~ "Un locale folder est un folder normal avec une racine de site (<tt>Site "
#~ "Root</tt>). Son ID doit être le code d'une langue, le titre est "
#~ "optionnel. Les répertoires de langues sont utilisés pour stocker des "
#~ "objets spéciaux (comme les images) et les logiques qui doivent être "
#~ "localisées."
#~ msgid "Back to manage messages."
#~ msgstr "Retour vers la gestion des messages"
#~ msgid "Header"
#~ msgstr "Entête"
#~ msgid "Locale folders"
#~ msgstr "Répertoire de langues"
#~ msgid "Message"
#~ msgstr "Message"
#~ msgid "Message catalog"
#~ msgstr "Catalogue de Message"
#~ msgid "Next"
#~ msgstr "Suivant"
#~ msgid "No languages available."
#~ msgstr "Aucun language disponible"
#~ msgid "Previous"
#~ msgstr "Précédent"
#~ msgid "To add a new message enter it and click the <tt>Add</tt> button."
#~ msgstr ""
#~ "Pour ajouter un nouveau message, sélectionnez le et cliquer sur le bouton "
#~ "<tt>Add</tt> ."
#~ msgid ""
#~ "To add a new property enter its name and type and click the <tt>Add</tt> "
#~ "button."
#~ msgstr ""
#~ "Pour ajouter une propriété, saisissez son nom et son type puis cliquer su "
#~ "the bouton <tt>Add</tt> ."
#~ msgid ""
#~ "To show only few messages enter a regular expression and click the "
#~ "<tt>Filter</tt> button."
#~ msgstr ""
#~ "Pour afficher seulement quelques messages, entrez une expression "
#~ "régulière et cliquez sur le bouton <tt>Filter</tt>."
#~ msgid "default"
#~ msgstr "défaut"
product/Localizer/locale/hu.po 0 → 100644
View file @ 52146f5e
# Hungarian Translation of FSR.
# Copyright (C) 2001 Free Software Foundation, Inc.
# Gábor Süveg <gsuveg@sgsystem.com>, 2001.
# Reviewed by: Emese Kovács <emese@gnome.hu> on 2001-10-11
#
msgid ""
msgstr ""
"Project-Id-Version: ZOPE HEAD\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2001-10-11 10:38+0200\n"
"Last-Translator: Gabor Suveg <gsuveg@sgsystem.com>\n"
"Language-Team: Hungarian <magyar@linux.hu>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "Hozzáadás"
msgid "Add Local Content"
msgstr "Új nyelvi tartalom"
msgid "Add Local Folder"
msgstr "Nyelvi mappa hozzáadása"
msgid "Add Localizer"
msgstr "Új fordító"
msgid "Add Message Catalog"
msgstr "Üzenet katalógus hozzáadása"
#, fuzzy
msgid "Add language"
msgstr "Nyelv"
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
#, fuzzy
msgid "Assamese"
msgstr "Üzenetek"
#: LocalFolder.py:62
msgid "Attributes"
msgstr ""
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr ""
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
#, fuzzy
msgid "Browse the messages"
msgstr "Nincs bejegyzés."
#: utils.py:114
msgid "Bulgarian"
msgstr ""
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr ""
msgid "Change"
msgstr "Változtat"
#, fuzzy
msgid "Charset"
msgstr "Változtat"
#: utils.py:119
#, fuzzy
msgid "Chinese"
msgstr "Változtat"
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr "Tartalom"
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
msgid "Croatian"
msgstr ""
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
msgid "Danish"
msgstr ""
msgid "Default language"
msgstr "Alapértelmezett nyelv"
msgid "Delete"
msgstr "Törlés"
#, fuzzy
msgid "Delete languages"
msgstr "Alapértelmezett nyelv"
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr "Exportálás"
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
msgid "File"
msgstr "Fájl"
msgid "File / Language"
msgstr "Új nyelv"
msgid "Filter"
msgstr "Szűrő"
#: utils.py:94
msgid "Find"
msgstr "Keresés"
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr ""
#: utils.py:138
msgid "French/Belgium"
msgstr ""
#: utils.py:139
msgid "French/Canada"
msgstr ""
#: utils.py:140
msgid "French/France"
msgstr ""
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
msgid "Georgian"
msgstr ""
#: utils.py:145
msgid "German"
msgstr ""
#: utils.py:146
msgid "German/Austria"
msgstr ""
#: utils.py:147
msgid "German/Germany"
msgstr ""
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
msgid "Guarani"
msgstr ""
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
#, fuzzy
msgid "Hindi"
msgstr "Keresés"
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr ""
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr "Azonosító"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr "Importálás"
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
msgid "Italian"
msgstr ""
#: utils.py:165
msgid "Japanese"
msgstr ""
#: utils.py:166
#, fuzzy
msgid "Javanese"
msgstr "Változások mentése"
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
msgid "Language"
msgstr "Nyelv"
#: LanguageManager.py:157
msgid "Languages"
msgstr "Nyelvek"
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
msgid "Local properties"
msgstr "Tulajdonságok"
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
#, fuzzy
msgid "Localizer"
msgstr "Új fordító"
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
#, fuzzy
msgid "Message to translate"
msgstr "Fordítandó szöveg:"
#: MessageCatalog.py:303
msgid "Messages"
msgstr "Üzenetek"
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
#, fuzzy
msgid "Messages imported"
msgstr "Üzenetek"
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr "Név"
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
#, fuzzy
msgid "Only untranslated messages"
msgstr "Vissza az üzenetek szerkesztéséhez"
#, fuzzy
msgid "Original language"
msgstr "Alapértelmezett nyelv"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr "Tulajdonos"
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
msgid "Persian"
msgstr ""
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
#, fuzzy
msgid "Portuguese"
msgstr "Tulajdonságok"
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr "Tulajdonságok"
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr "Eredemények %d-%d / %d"
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
msgid "Sangho"
msgstr ""
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr ""
msgid "Save changes"
msgstr "Változások mentése"
#: MessageCatalog.py:439 MessageCatalog.py:454
#, fuzzy
msgid "Saved changes."
msgstr "Változások mentése"
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr "Biztonság"
#: utils.py:211
msgid "Serbian"
msgstr ""
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
#, fuzzy
msgid "Sindhi"
msgstr "Keresés"
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr ""
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
msgid "Spanish/Colombia"
msgstr ""
#: utils.py:225
msgid "Spanish/Mexico"
msgstr ""
#: utils.py:226
msgid "Spanish/Spain"
msgstr ""
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
#, fuzzy
msgid "Tamil"
msgstr "Cím"
#, fuzzy
msgid "Target language"
msgstr "Nincs bejegyzés."
#, fuzzy
msgid "Target languages"
msgstr "Nincs bejegyzés."
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr ""
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
#, fuzzy
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
"Új nyelvet és a forditás hozzáadásához inportáld be a PO fájlt. Írd be a \n"
"fájlnevet, válaszd ki a fordítás nyelvét, és kattints a <tt>Import</tt>\n"
"gombra."
#, fuzzy
msgid "There are no attributes"
msgstr "Nincs bejegyzés."
#, fuzzy
msgid "There are no languages"
msgstr "Nincs bejegyzés."
#, fuzzy
msgid "There are no messages."
msgstr "Nincs bejegyzés."
msgid "This object is up-to-date."
msgstr ""
#, fuzzy
msgid "This object must be upgraded."
msgstr "Ez az objektum nem igényel frissitést."
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Cím"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr "Nyelv hozzáadásához kattints a <tt>Hozzáadás</tt> gombra."
#, fuzzy
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
"Új üzenet hozzadásához ird be, majd kattintsd a <tt>Hozzáadás</tt> gombra."
#, fuzzy
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr "Nyelv hozzáadásához kattints a <tt>Hozzáadás</tt> gombra."
#, fuzzy
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr "Nyelv hozzáadásához kattints a <tt>Hozzáadás</tt> gombra."
#, fuzzy
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr "Nyelv hozzáadásához kattints a <tt>Hozzáadás</tt> gombra."
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
#, fuzzy
msgid "Translate properties"
msgstr "Nincs tulajdonságokat leíró lap."
#, fuzzy
msgid "Translations"
msgstr "Elérhető fordítások"
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Típus"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr "Visszavonás"
#: LanguageManager.py:168
msgid "Upgrade"
msgstr "Frissítés"
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr "Nyelvi mappák használata"
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr "Nézet"
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
"Új nyelvet és a forditás hozzáadásához inportáld be a PO fájlt. Írd be a \n"
"fájlnevet, válaszd ki a fordítás nyelvét, és kattints a <tt>Import</tt>\n"
"gombra."
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
#, fuzzy
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
"Új nyelvet és a forditás hozzáadásához inportáld be a PO fájlt. Írd be a \n"
"fájlnevet, válaszd ki a fordítás nyelvét, és kattints a <tt>Import</tt>\n"
"gombra."
#, fuzzy
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Új nyelvet és a forditás hozzáadásához inportáld be a PO fájlt. Írd be a \n"
"fájlnevet, válaszd ki a fordítás nyelvét, és kattints a <tt>Import</tt>\n"
"gombra."
msgid "Your e-mail address"
msgstr ""
msgid "Your name"
msgstr ""
#: utils.py:254
#, fuzzy
msgid "Zhuang"
msgstr "Változtat"
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#~ msgid "This <tt>%s</tt> object needs to be upgraded"
#~ msgstr "Ezt a <tt>%s</tt> objektumot frissítsd!"
#~ msgid "This <tt>Localizer</tt> object needs to be upgraded."
#~ msgstr "Ezt a <tt>Localizr</tt> objektumtumot frissítsd!"
#, fuzzy
#~ msgid "This <tt>Localizer</tt> object doesn't need to be upgraded."
#~ msgstr "Ez a <tt>Localizer</tt> objektum nem igényel frissitést."
#~ msgid "Import/Export"
#~ msgstr "Impotálás/Exportálás"
#~ msgid "Default"
#~ msgstr "Alapértelmezett"
#, fuzzy
#~ msgid "Hide this language"
#~ msgstr "Új nyelv"
#, fuzzy
#~ msgid "Show this language"
#~ msgstr "Nincs bejegyzés."
#~ msgid "Back to manage messages."
#~ msgstr "Vissza az üzenetek szerkesztéséhez"
#~ msgid "Locale folders"
#~ msgstr "Mappák"
#~ msgid "Message"
#~ msgstr "Üzenet"
#~ msgid "Message catalog"
#~ msgstr "Üzenetkatalógus"
#~ msgid "Next"
#~ msgstr "Következő"
#~ msgid "No languages available."
#~ msgstr "Nincs elérhető nyelv"
#~ msgid "Previous"
#~ msgstr "Előző"
#~ msgid "To add a new message enter it and click the <tt>Add</tt> button."
#~ msgstr ""
#~ "Új üzenet hozzadásához ird be, majd kattintsd a <tt>Hozzáadás</tt> gombra."
#~ msgid "default"
#~ msgstr "alapértelmezett"
#~ msgid "All"
#~ msgstr "Összes"
#~ msgid "Batch size"
#~ msgstr "Köteg mérete"
#~ msgid "Full"
#~ msgstr "Teljes"
#~ msgid "Localized Content"
#~ msgstr "Lokalizált tartalom"
#~ msgid "Localized Strings"
#~ msgstr "Lokalizált karakterláncok"
#~ msgid "Only valid"
#~ msgstr "Csak érvényes"
#~ msgid "Partial"
#~ msgstr "Részleges"
# nem biztos, hogy jó
#~ msgid "Pending languages"
#~ msgstr "Kapcsolódó nyelvek"
# Az állandó kifejezés nem túl jó.
#~ msgid "Regular expression"
#~ msgstr "Reguláris kifejezés"
#~ msgid "Results"
#~ msgstr "Eredmény"
#~ msgid "Status"
#~ msgstr "Állapot"
#~ msgid "Text"
#~ msgstr "Szöveg"
#~ msgid "This property sheet is empty."
#~ msgstr "Ez a tulajdonságokat leíró lap üres."
# ból/ből ragozástól függ. A szövegkörnyezet valószínűleg pl. 25 / 30
#~ msgid "of"
#~ msgstr "/"
product/Localizer/locale/it.po 0 → 100644
View file @ 52146f5e
# translation of it.po to Italiano
# translation of locale.po to italian
# Marco Bizzarri <m.bizzarri@icube.it>, 2004.
msgid ""
msgstr ""
"Project-Id-Version: it\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2004-11-12 17:09+0100\n"
"Last-Translator: Marco Bizzarri <m.bizzarri@icube.it>\n"
"Language-Team: Italiano <it@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Generator: KBabel 1.3.1\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
#, fuzzy
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
"Un oggetto Local Content permette la memorizzazione di proprietà multilingua "
"(e non multilingua). Ti aiuta anche a tenere separato il contenuto dalla "
"presentazione."
#, fuzzy
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
"Un oggetto Localizer ti permette di personalizzare la politica di "
"negoziazione della lingua. Ti permette di usare i cookie, il cammino o "
"qualsiasi altro criterio per scegliere la lingua preferita dall'utente."
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
"Un Local Folder è una soluzione generale per gestire qualsiasi tipo di "
"oggetti multilingua, come file, immagini, script, ecc..."
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
"Un catalogo di messaggi memorizza i messaggi e le sue traduzioni in lingue "
"diverse. Fornisce il metodo <tt>gettext</tt> per ottenere la traduzione "
"corretta per un certo messaggio. I cataloghi dei messaggi sono utili per "
"tradurre l'interfacce delle applicazioni (etichette, pulsanti, ecc...)."
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "Aggiungi"
msgid "Add Local Content"
msgstr "Aggiungi un Local Content"
msgid "Add Local Folder"
msgstr "Aggiungi un Local Folder"
msgid "Add Localizer"
msgstr "Aggiungi Localizer"
msgid "Add Message Catalog"
msgstr "Aggiungi un Message Catalog"
#, fuzzy
msgid "Add language"
msgstr "Importa"
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
#, fuzzy
msgid "Assamese"
msgstr "Messaggi"
#: LocalFolder.py:62
msgid "Attributes"
msgstr "Attributi"
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr "Basco"
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
#, fuzzy
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
"Oltre al titolo l'intestazione di un file PO memorizza altre informazioni, "
"il nome e l'indirizzo dell'ultimo traduttore, l'indirizzo di email del "
"gruppo di traduzione e il set di caratteri. Le maschere che seguono ti "
"permettono di modificare queste informazioni per ogni lingua."
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
#, fuzzy
msgid "Browse the messages"
msgstr "Non ci sono messaggi"
#: utils.py:114
#, fuzzy
msgid "Bulgarian"
msgstr "Ungherese"
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr "Catalano"
msgid "Change"
msgstr "Cambia"
msgid "Charset"
msgstr "Set di caratteri"
#: utils.py:119
#, fuzzy
msgid "Chinese"
msgstr "Cambia"
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr "Contenuti"
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
#, fuzzy
msgid "Croatian"
msgstr "Catalano"
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
#, fuzzy
msgid "Danish"
msgstr "Spagnolo"
#, fuzzy
msgid "Default language"
msgstr "Nascondi questa lingua"
msgid "Delete"
msgstr "Elimina"
#, fuzzy
msgid "Delete languages"
msgstr "Non ci sono lingue."
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr "Esporta"
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
msgid "File"
msgstr "File"
msgid "File / Language"
msgstr "File / Lingua"
msgid "Filter"
msgstr "Filtro"
#: utils.py:94
msgid "Find"
msgstr "Trova"
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr "Francese"
#: utils.py:138
#, fuzzy
msgid "French/Belgium"
msgstr "Francese"
#: utils.py:139
#, fuzzy
msgid "French/Canada"
msgstr "Francese"
#: utils.py:140
#, fuzzy
msgid "French/France"
msgstr "Francese"
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
#, fuzzy
msgid "Georgian"
msgstr "Tedesco"
#: utils.py:145
msgid "German"
msgstr "Tedesco"
#: utils.py:146
#, fuzzy
msgid "German/Austria"
msgstr "Tedesco"
#: utils.py:147
#, fuzzy
msgid "German/Germany"
msgstr "Tedesco"
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
#, fuzzy
msgid "Guarani"
msgstr "Ungherese"
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
#, fuzzy
msgid "Hindi"
msgstr "Trova"
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr "Ungherese"
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr "Id"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr "Importa"
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
#, fuzzy
msgid "Italian"
msgstr "Catalano"
#: utils.py:165
msgid "Japanese"
msgstr "Giapponese"
#: utils.py:166
#, fuzzy
msgid "Javanese"
msgstr "Giapponese"
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
msgid "Language"
msgstr "Importa"
#: LanguageManager.py:157
msgid "Languages"
msgstr "Lingue"
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
msgid "Local properties"
msgstr "Proprietà locali"
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
"I Locale Folders sono utili per memorizzare oggetti speciali multilingua "
"come immagini e logica specifica. Se si usa, l'oggetto Localizer aggiungerà "
"in modo trasparente il locale folder giusto all'url. Se vuoi usare i locale "
"folders seleziona la checkbox, altrimenti deselezionala, poi premi il "
"pulsante <tt>Cambia</tt>."
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
#, fuzzy
msgid "Localizer"
msgstr "Aggiungi Localizer"
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
#, fuzzy
msgid "Message to translate"
msgstr "Messaggi"
#: MessageCatalog.py:303
msgid "Messages"
msgstr "Messaggi"
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
#, fuzzy
msgid "Messages imported"
msgstr "Messaggi"
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr "Nome"
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr "Solo messaggi non tradotti"
#, fuzzy
msgid "Original language"
msgstr "Nascondi questa lingua"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr "Ownership"
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
#, fuzzy
msgid "Persian"
msgstr "Tedesco"
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
#, fuzzy
msgid "Portuguese"
msgstr "Proprietà"
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr "Proprietà"
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr "Risultato %d-%d di %d"
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
#, fuzzy
msgid "Sangho"
msgstr "Spagnolo"
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr "Salva"
msgid "Save changes"
msgstr "Salva i cambiamenti"
#: MessageCatalog.py:439 MessageCatalog.py:454
msgid "Saved changes."
msgstr "Cambiamenti salvati."
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr "Sicurezza"
#: utils.py:211
#, fuzzy
msgid "Serbian"
msgstr "Tedesco"
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
#, fuzzy
msgid "Sindhi"
msgstr "Trova"
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr "Spagnolo"
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
#, fuzzy
msgid "Spanish/Colombia"
msgstr "Spagnolo"
#: utils.py:225
#, fuzzy
msgid "Spanish/Mexico"
msgstr "Spagnolo"
#: utils.py:226
#, fuzzy
msgid "Spanish/Spain"
msgstr "Spagnolo"
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
#, fuzzy
msgid "Tamil"
msgstr "Titolo"
#, fuzzy
msgid "Target language"
msgstr "Non ci sono lingue."
#, fuzzy
msgid "Target languages"
msgstr "Non ci sono lingue."
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr "Indirizzo email del gruppo"
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
"Il catalogo dei messaggi permette anche di importare file TMX. Puoi "
"aggiungere nuovi messaggi e traduzioni importando un file TMX nel livello "
"TMX 1. Immetti il nome del file e premi il pulsante <tt>Importa</tt>."
#, fuzzy
msgid "There are no attributes"
msgstr "Non ci sono attributi."
#, fuzzy
msgid "There are no languages"
msgstr "Non ci sono lingue."
#, fuzzy
msgid "There are no messages."
msgstr "Non ci sono messaggi"
msgid "This object is up-to-date."
msgstr ""
#, fuzzy
msgid "This object must be upgraded."
msgstr "Questo oggetto non ha bisogno di essere aggiornato."
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Titolo"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
"Per aggiungere una lingua selezionala e premi il pulsante <tt>Aggiungi</tt>"
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
"Per aggiungere un attributo inserisci il suo id e premi il pulsante "
"<tt>Aggiungi</tt>."
#, fuzzy
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr ""
"Per aggiungere una lingua selezionala e premi il pulsante <tt>Aggiungi</tt>"
#, fuzzy
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
"Per eliminare un attributo selezionalo e premi il pulsante <tt>Elimina</tt>."
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
"Per eliminare un attributo selezionalo e premi il pulsante <tt>Elimina</tt>."
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
#, fuzzy
msgid "Translate properties"
msgstr "Non ci sono proprietà."
#, fuzzy
msgid "Translations"
msgstr "Non ci sono proprietà."
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Tipo"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr "Disfa"
#: LanguageManager.py:168
msgid "Upgrade"
msgstr "Aggiorna"
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr "Usa i Local Folder"
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr "View"
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
"Con questa maschera puoi modificare il titolo del catalogo dei messaggi. Il "
"titolo viene usato anche come valore del campo <tt>Project-Id-Version</tt> "
"nell'intestazione dei file PO, che sono generati quando si esporta il "
"catalogo."
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
"Puoi aggiungere nuovi messaggi e traduzioni importando un file PO. Immetti "
"il nome del file, scegli la lingua delle traduzioni e premi il pulsante "
"<tt>Importa</tt>."
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Puoi esportare il messaggi e le loro traduzioni in file PO. Scegli "
"<tt>locale.pot</tt> per ottenere solo i messaggi, senza le loro traduzioni. "
"Scegli qualsiai altra opzione per ottenere un file PO con i messaggi e le "
"loro traduzioni nella lingua scelta. Poi premi il pulsante <tt>Esporta</tt>"
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
"Puoi esportare i messaggi e le loro traduzioni come file TMX level 1. Per "
"farlo premi semplicemente il pulsante <tt>Esporta</tt>."
#, fuzzy
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Puoi esportare il messaggi e le loro traduzioni in file PO. Scegli "
"<tt>locale.pot</tt> per ottenere solo i messaggi, senza le loro traduzioni. "
"Scegli qualsiai altra opzione per ottenere un file PO con i messaggi e le "
"loro traduzioni nella lingua scelta. Poi premi il pulsante <tt>Esporta</tt>"
msgid "Your e-mail address"
msgstr "Il tuo indirizzo di email"
msgid "Your name"
msgstr "Il tuo nome"
#: utils.py:254
#, fuzzy
msgid "Zhuang"
msgstr "Cambia"
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#~ msgid "This <tt>%s</tt> object needs to be upgraded"
#~ msgstr "Questo oggetto <tt>%s</tt> ha bisogno di essere aggiornato."
#~ msgid "This <tt>Localizer</tt> object needs to be upgraded."
#~ msgstr "Questo oggetto <tt>Localizer</tt> ha bisogno di essere aggiornato."
#, fuzzy
#~ msgid "This <tt>Localizer</tt> object doesn't need to be upgraded."
#~ msgstr ""
#~ "Questo oggetto <tt>Localizer</tt> non ha bisogno di essere aggiornato."
#~ msgid "Import/Export"
#~ msgstr "Importa/Esporta"
#~ msgid "TMX"
#~ msgstr "TMX"
#~ msgid "label"
#~ msgstr "etichetta"
#~ msgid "Default"
#~ msgstr "Predefinito"
#~ msgid ""
#~ "To delete a language check it and click the <tt>Delete</tt> button. To "
#~ "change the default language select it and click the <tt>Change</tt> "
#~ "button."
#~ msgstr ""
#~ "Per eliminare una lingua selezionala e premi il pulsante <tt>Elimina</tt>."
#~ "Per cambiare la lingua predefinita selezionala e premi il pulsante "
#~ "<tt>Cambia</tt>."
#~ msgid "Show this language"
#~ msgstr "Mostra questa lingua"
#~ msgid ""
#~ "To add a new property enter its name, select its type and click the "
#~ "<tt>Add</tt> button."
#~ msgstr ""
#~ "Per aggiungere una nuova proprietà immetti il suo nome, scegli il suo "
#~ "tipo e premi il pulsante <tt>Aggiungi</tt>."
product/Localizer/locale/ja.po 0 → 100644
View file @ 52146f5e
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2002-09-10 07:36+0900\n"
"Last-Translator: kf@atransia.co.jp <kf@atransia.co.jp>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
#, fuzzy
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
"ロケールコンテンツ (Locale Content) オブジェクトには、多言語のオブジェクトが"
"格納されます (マルチリンガルではありません) 。そして、コンテンツをロジックと"
"プレゼンテーションに分離するのも役立ちます。"
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
"メッセージカタログ (Message Catalog) には、メッセージとそれに対する言語ごとの"
"翻訳が保存されます。指定されたメッセージに対する正しい翻訳を取り出すために"
"は、メッセージカタログの <tt>gettext</tt> メソッドを使用することができます。"
"メッセージカタログは、ラベルやボタンなどアプリケーションのユーザーインター"
"フェイスを翻訳するのに役立ちます。"
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "追加"
msgid "Add Local Content"
msgstr "ローカルコンテンツの追加"
#, fuzzy
msgid "Add Local Folder"
msgstr "ロケールフォルダの追加"
msgid "Add Localizer"
msgstr "Localizer の追加"
msgid "Add Message Catalog"
msgstr "メッセージカタログの追加"
#, fuzzy
msgid "Add language"
msgstr "言語"
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
#, fuzzy
msgid "Assamese"
msgstr "メッセージ"
#: LocalFolder.py:62
msgid "Attributes"
msgstr "属性"
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr ""
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
#, fuzzy
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
"PO ファイルのヘッダには、タイトルだけでなく、名前、電子メールアドレス、最終翻"
"訳者、翻訳チームの電子メールアドレス、文字セットなど、その他の情報が格納され"
"ます。下のフォームは、この情報を言語ごとに指定できるようにするものです。"
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
#, fuzzy
msgid "Browse the messages"
msgstr "言語がありません。"
#: utils.py:114
msgid "Bulgarian"
msgstr ""
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr ""
msgid "Change"
msgstr "変更"
msgid "Charset"
msgstr "文字セット"
#: utils.py:119
#, fuzzy
msgid "Chinese"
msgstr "変更"
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr "コンテンツ"
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
msgid "Croatian"
msgstr ""
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
msgid "Danish"
msgstr ""
#, fuzzy
msgid "Default language"
msgstr "この言語を隠す"
msgid "Delete"
msgstr "削除"
#, fuzzy
msgid "Delete languages"
msgstr "言語がありません"
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr "エクスポート"
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
msgid "File"
msgstr "ファイル"
msgid "File / Language"
msgstr "ファイル/言語"
msgid "Filter"
msgstr "フィルタ"
#: utils.py:94
msgid "Find"
msgstr "検索"
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr ""
#: utils.py:138
msgid "French/Belgium"
msgstr ""
#: utils.py:139
msgid "French/Canada"
msgstr ""
#: utils.py:140
msgid "French/France"
msgstr ""
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
msgid "Georgian"
msgstr ""
#: utils.py:145
msgid "German"
msgstr ""
#: utils.py:146
msgid "German/Austria"
msgstr ""
#: utils.py:147
msgid "German/Germany"
msgstr ""
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
msgid "Guarani"
msgstr ""
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
#, fuzzy
msgid "Hindi"
msgstr "検索"
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr ""
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr "Id"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr "インポート"
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
msgid "Italian"
msgstr ""
#: utils.py:165
msgid "Japanese"
msgstr ""
#: utils.py:166
#, fuzzy
msgid "Javanese"
msgstr "変更を保存"
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
msgid "Language"
msgstr "言語"
#: LanguageManager.py:157
msgid "Languages"
msgstr "言語"
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
msgid "Local properties"
msgstr "ローカルプロパティ"
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
"ロケールフォルダ (Locale Folder) は、画像や特殊なロジックなどマルチリンガルオ"
"ブジェクトを格納するのに有用です。これを使用すると、<tt>Localizer</tt> オブ"
"ジェクトが適切なロケールフォルダを URL に透過的に追加してくれます。ロケール"
"フォルダを使用するには、チェックボックスをオンにします。"
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
#, fuzzy
msgid "Localizer"
msgstr "Localizer の追加"
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
#, fuzzy
msgid "Message to translate"
msgstr "翻訳するテキスト:"
#: MessageCatalog.py:303
msgid "Messages"
msgstr "メッセージ"
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
#, fuzzy
msgid "Messages imported"
msgstr "メッセージ"
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr "名前"
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr "未翻訳メッセージのみ"
#, fuzzy
msgid "Original language"
msgstr "この言語を隠す"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr "所有者"
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
msgid "Persian"
msgstr ""
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
#, fuzzy
msgid "Portuguese"
msgstr "プロパティ"
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr "プロパティ"
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr "結果: %d-%d (%d中)"
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
msgid "Sangho"
msgstr ""
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr "保存"
msgid "Save changes"
msgstr "変更を保存"
#: MessageCatalog.py:439 MessageCatalog.py:454
#, fuzzy
msgid "Saved changes."
msgstr "変更を保存"
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr "セキュリティ"
#: utils.py:211
msgid "Serbian"
msgstr ""
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
#, fuzzy
msgid "Sindhi"
msgstr "検索"
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr ""
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
msgid "Spanish/Colombia"
msgstr ""
#: utils.py:225
msgid "Spanish/Mexico"
msgstr ""
#: utils.py:226
msgid "Spanish/Spain"
msgstr ""
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
#, fuzzy
msgid "Tamil"
msgstr "タイトル"
#, fuzzy
msgid "Target language"
msgstr "言語がありません"
#, fuzzy
msgid "Target languages"
msgstr "言語がありません"
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr "翻訳チームの電子メールアドレス"
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
#, fuzzy
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
"新しいメッセージと翻訳を PO ファイルからインポートすることによって追加できま"
"す。ファイル名を入力し、翻訳の言語を選択し、<b>インポート</b> ボタンをクリッ"
"クします。"
#, fuzzy
msgid "There are no attributes"
msgstr "言語がありません"
#, fuzzy
msgid "There are no languages"
msgstr "言語がありません"
#, fuzzy
msgid "There are no messages."
msgstr "言語がありません。"
msgid "This object is up-to-date."
msgstr ""
#, fuzzy
msgid "This object must be upgraded."
msgstr "このオブジェクトは、更新の必要がありません。"
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "タイトル"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
"言語を追加するには、追加する言語を選択して、<tt>追加</tt>ボタンをクリックしま"
"す。"
#, fuzzy
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr "新しいメッセージを追加するには、<b>追加</b> ボタンをクリックします。"
#, fuzzy
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr ""
"言語を追加するには、追加する言語を選択して、<tt>追加</tt>ボタンをクリックしま"
"す。"
#, fuzzy
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
"言語を追加するには、追加する言語を選択して、<tt>追加</tt>ボタンをクリックしま"
"す。"
#, fuzzy
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
"言語を追加するには、追加する言語を選択して、<tt>追加</tt>ボタンをクリックしま"
"す。"
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
#, fuzzy
msgid "Translate properties"
msgstr "プロパティがありません。"
#, fuzzy
msgid "Translations"
msgstr "プロパティがありません。"
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "種類"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr "やり直し"
#: LanguageManager.py:168
msgid "Upgrade"
msgstr "更新"
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr "ロケールフォルダを使う"
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr "表示"
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
"このフォームでは、メッセージカタログ (Message Catalog) のタイトルを変更できま"
"す。このタイトルは、メッセージカタログをエクスポートすると生成される PO ファ"
"イルのヘッダ内にある、<tt>Project-Id-Version</tt> フィールドの値としても使わ"
"れます。"
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
"新しいメッセージと翻訳を PO ファイルからインポートすることによって追加できま"
"す。ファイル名を入力し、翻訳の言語を選択し、<b>インポート</b> ボタンをクリッ"
"クします。"
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
"メッセージと翻訳は、PO ファイルにエクスポートできます。翻訳を省いてメッセージ"
"だけを得るには <tt>locale.pot</tt> のチェックします。選択した言語に対するメッ"
"セージと翻訳を得るには、そのほかのオプションをチェックします。そして、<b>エク"
"スポート</b>ボタンをクリックします。"
#, fuzzy
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
"新しいメッセージと翻訳を PO ファイルからインポートすることによって追加できま"
"す。ファイル名を入力し、翻訳の言語を選択し、<b>インポート</b> ボタンをクリッ"
"クします。"
#, fuzzy
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
"メッセージと翻訳は、PO ファイルにエクスポートできます。翻訳を省いてメッセージ"
"だけを得るには <tt>locale.pot</tt> のチェックします。選択した言語に対するメッ"
"セージと翻訳を得るには、そのほかのオプションをチェックします。そして、<b>エク"
"スポート</b>ボタンをクリックします。"
msgid "Your e-mail address"
msgstr "あなたの電子メールアドレス"
msgid "Your name"
msgstr "あなたの名前"
#: utils.py:254
#, fuzzy
msgid "Zhuang"
msgstr "変更"
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#~ msgid "This <tt>%s</tt> object needs to be upgraded"
#~ msgstr "この <tt>%s</tt> オブジェクトは更新する必要があります。"
#~ msgid "This <tt>Localizer</tt> object needs to be upgraded."
#~ msgstr "このオブジェクトは、更新する必要があります。"
#, fuzzy
#~ msgid "This <tt>Localizer</tt> object doesn't need to be upgraded."
#~ msgstr "この <tt>Localizer</tt> オブジェクトは、更新の必要がありません。"
#~ msgid "Import/Export"
#~ msgstr "インポート/エクスポート"
#~ msgid "Default"
#~ msgstr "標準"
#~ msgid ""
#~ "To delete a language check it and click the <tt>Delete</tt> button. To "
#~ "change the default language select it and click the <tt>Change</tt> "
#~ "button."
#~ msgstr ""
#~ "言語を削除するには、その言語のチェックボックスをオンにし、<b>削除</b>ボタ"
#~ "ンをクリックします。標準の言語を変更するには、標準にしたい言語を選択し、"
#~ "<tt>変更</tt>ボタンをクリックします。"
#~ msgid "Show this language"
#~ msgstr "この言語を表示する"
#~ msgid ""
#~ "To add a new property enter its name, select its type and click the "
#~ "<tt>Add</tt> button."
#~ msgstr ""
#~ "新しいプロパティを追加するには、名前を入力し、種類を選択します。そして、"
#~ "<b>追加</b>ボタンをクリックします。"
#~ msgid ""
#~ "A Localizer object provides <em>locale folders</em>, each one associated "
#~ "with a language. It transparently adds a locale folder to the path so "
#~ "objects for that language will be used. It's useful to localize special "
#~ "objects like images, or specific logic (to format dates for example)."
#~ msgstr ""
#~ "Localizer オブジェクトは、<em>Locale フォルダ</em> を持ちます。各ロケール "
#~ "(locale) は言語に関連づけられます。そして、Locale フォルダには使用される言"
#~ "語に対応したパスが透過的に追加されます。これは画像や、日付の書式などの特殊"
#~ "なロジックといった特別にローカライズされたオブジェクトに対し使用されます。"
#~ msgid ""
#~ "A locale folder is just a normal folder with a <tt>SiteRoot</tt>. Its id "
#~ "must be a language code, the title is optional. Locale folders are used "
#~ "to store special objects like images and logic that needs to be localized."
#~ msgstr ""
#~ "ロケール (Locale) フォルダは、標準的なフォルダに<b>SiteRoot</b> の機能をつ"
#~ "けたものです。Id には言語コードを使用する必要があります。タイトルはオプ"
#~ "ションです。ロケールフォルダには、ローカライズの必要がある画像やロジックな"
#~ "どの特別なオブジェクトを保存します。"
#~ msgid "Back to manage messages."
#~ msgstr "メッセージ管理に戻る"
#~ msgid "Header"
#~ msgstr "ヘッダ"
#~ msgid "Locale folders"
#~ msgstr "ロケールフォルダ"
#~ msgid "Message"
#~ msgstr "メッセージ"
#~ msgid "Message catalog"
#~ msgstr "メッセージカタログ"
#~ msgid "Next"
#~ msgstr "次へ"
#~ msgid "No languages available."
#~ msgstr "使用可能な言語がありません。"
#~ msgid "Previous"
#~ msgstr "前へ"
#~ msgid ""
#~ "To add a new property enter its name and type and click the <tt>Add</tt> "
#~ "button."
#~ msgstr ""
#~ "新しいプロパティを追加するには、名前と種類を入力し、<b>追加</b>ボタンをク"
#~ "リックします。"
#~ msgid ""
#~ "To show only few messages enter a regular expression and click the "
#~ "<tt>Filter</tt> button."
#~ msgstr ""
#~ "表示されるメッセージの数を減らすには、正規表現を入力し、<b>フィルタ</b>ボ"
#~ "タンをクリックします。"
#~ msgid "default"
#~ msgstr "標準"
product/Localizer/locale/locale.pot 0 → 100644
View file @ 52146f5e
msgid ""
msgstr ""
"Project-Id-Version: PACKAGE VERSION\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: FULL NAME <EMAIL@ADDRESS>\n"
"Language-Team: LANGUAGE <LL@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: ENCODING\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr ""
msgid "Add Local Content"
msgstr ""
msgid "Add Local Folder"
msgstr ""
msgid "Add Localizer"
msgstr ""
msgid "Add Message Catalog"
msgstr ""
msgid "Add language"
msgstr ""
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
msgid "Assamese"
msgstr ""
#: LocalFolder.py:62
msgid "Attributes"
msgstr ""
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr ""
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
msgid "Browse the messages"
msgstr ""
#: utils.py:114
msgid "Bulgarian"
msgstr ""
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr ""
msgid "Change"
msgstr ""
msgid "Charset"
msgstr ""
#: utils.py:119
msgid "Chinese"
msgstr ""
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr ""
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
msgid "Croatian"
msgstr ""
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
msgid "Danish"
msgstr ""
msgid "Default language"
msgstr ""
msgid "Delete"
msgstr ""
msgid "Delete languages"
msgstr ""
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr ""
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
msgid "File"
msgstr ""
msgid "File / Language"
msgstr ""
msgid "Filter"
msgstr ""
#: utils.py:94
msgid "Find"
msgstr ""
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr ""
#: utils.py:138
msgid "French/Belgium"
msgstr ""
#: utils.py:139
msgid "French/Canada"
msgstr ""
#: utils.py:140
msgid "French/France"
msgstr ""
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
msgid "Georgian"
msgstr ""
#: utils.py:145
msgid "German"
msgstr ""
#: utils.py:146
msgid "German/Austria"
msgstr ""
#: utils.py:147
msgid "German/Germany"
msgstr ""
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
msgid "Guarani"
msgstr ""
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
msgid "Hindi"
msgstr ""
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr ""
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr ""
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr ""
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
msgid "Italian"
msgstr ""
#: utils.py:165
msgid "Japanese"
msgstr ""
#: utils.py:166
msgid "Javanese"
msgstr ""
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
msgid "Language"
msgstr ""
#: LanguageManager.py:157
msgid "Languages"
msgstr ""
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
msgid "Local properties"
msgstr ""
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
msgid "Localizer"
msgstr ""
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
msgid "Message to translate"
msgstr ""
#: MessageCatalog.py:303
msgid "Messages"
msgstr ""
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
msgid "Messages imported"
msgstr ""
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr ""
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr ""
msgid "Original language"
msgstr ""
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr ""
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
msgid "Persian"
msgstr ""
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
msgid "Portuguese"
msgstr ""
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr ""
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr ""
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
msgid "Sangho"
msgstr ""
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr ""
msgid "Save changes"
msgstr ""
#: MessageCatalog.py:439 MessageCatalog.py:454
msgid "Saved changes."
msgstr ""
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr ""
#: utils.py:211
msgid "Serbian"
msgstr ""
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
msgid "Sindhi"
msgstr ""
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr ""
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
msgid "Spanish/Colombia"
msgstr ""
#: utils.py:225
msgid "Spanish/Mexico"
msgstr ""
#: utils.py:226
msgid "Spanish/Spain"
msgstr ""
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
msgid "Tamil"
msgstr ""
msgid "Target language"
msgstr ""
msgid "Target languages"
msgstr ""
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr ""
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
msgid "There are no attributes"
msgstr ""
msgid "There are no languages"
msgstr ""
msgid "There are no messages."
msgstr ""
msgid "This object is up-to-date."
msgstr ""
msgid "This object must be upgraded."
msgstr ""
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr ""
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr ""
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
msgid "Translate properties"
msgstr ""
msgid "Translations"
msgstr ""
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr ""
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr ""
#: LanguageManager.py:168
msgid "Upgrade"
msgstr ""
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr ""
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr ""
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
msgid "Your e-mail address"
msgstr ""
msgid "Your name"
msgstr ""
#: utils.py:254
msgid "Zhuang"
msgstr ""
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
product/Localizer/locale/localizermsgs.tmx 0 → 100644
View file @ 52146f5e
This source diff could not be displayed because it is too large. You can view the blob instead.
product/Localizer/locale/pt.po 0 → 100644
View file @ 52146f5e
msgid ""
msgstr ""
"Project-Id-Version: 0.3.0\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2005-01-24 09:00 BRST\n"
"Last-Translator: Rodrigo Dias Arruda Senra <rsenra@acm.org>\n"
"Language-Team: ??\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
"Um objeto Local Content provê armazenamento para propriedades multi-"
"linguísticas (ou não multi-linguísticas). Também facilita na separação entre "
"lógica e apresentação de conteúdo."
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
"Um objeto Localizer permite a customização da política de negociação de "
"língua. Ele permite o uso de cookies, do path ou qualquer outro critério "
"para selecionar a língua preferida do usuário."
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
"Um Local Folder é uma solução genérica para gerenciar qualquer tipo de "
"objeto multi-linguístico, arquivos, imagens, scripts, etc."
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
"Um Catálogo de Mensagens armazena mensagens e suas traduções em diferentes "
"línguas. Ele provê o método <tt>gettext</tt> para obter a tradução correta "
"da respectiva mensagem. Catálogos de Mensagens são úteis para traduzir "
"componentes da interface como rótulos, botões, etc."
#: utils.py:96
msgid "Abkhazian"
msgstr "Afegão"
msgid "Add"
msgstr "Adicionar"
msgid "Add Local Content"
msgstr "Adicionar Local Content"
msgid "Add Local Folder"
msgstr "Adiciona Local Folder"
msgid "Add Localizer"
msgstr "Adiciona Localizer"
msgid "Add Message Catalog"
msgstr "Adicionar Catálogo de Mensagens"
msgid "Add language"
msgstr "Adicionar Língua"
#: utils.py:97
msgid "Afar"
msgstr "Afar"
#: utils.py:98
msgid "Afrikaans"
msgstr "Afrikaans"
#: utils.py:99
msgid "Albanian"
msgstr "Albanês"
#: utils.py:100
msgid "Amharic"
msgstr "Aramaico"
#: utils.py:101
msgid "Arabic"
msgstr "Árabe"
#: utils.py:102
msgid "Armenian"
msgstr "Armeno"
#: utils.py:103
msgid "Assamese"
msgstr "Assamês"
#: LocalFolder.py:62
msgid "Attributes"
msgstr "Atributos"
#: utils.py:104
msgid "Aymara"
msgstr "Aymarês"
#: utils.py:105
msgid "Azerbaijani"
msgstr "Azerbaijanês"
#: utils.py:106
msgid "Bashkir"
msgstr "Bashkir"
#: utils.py:107
msgid "Basque"
msgstr "Basco"
#: utils.py:116
msgid "Belarusian"
msgstr "Bilorusso"
#: utils.py:108
msgid "Bengali"
msgstr "Bengalês"
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
"Além do título, o cabeçalho de uma arquivo PO armazena mais informação, o "
"nome, o endereço de e-mail do útlimo tradutor, o endereço de e-mail do grupo "
"de tradução e a codificação (charset). O formulário abaixo permite modificar "
"tasi informações para cada uma das línguas."
#: utils.py:109
msgid "Bhutani"
msgstr "Bhutanês"
#: utils.py:110
msgid "Bihari"
msgstr "Bihari"
#: utils.py:111
msgid "Bislama"
msgstr "Bislama"
#: utils.py:112
msgid "Bosnian"
msgstr "Bosniano"
#: utils.py:113
msgid "Breton"
msgstr "Bretão"
#, fuzzy
msgid "Browse the messages"
msgstr "Não existem mensagens"
#: utils.py:114
msgid "Bulgarian"
msgstr "Búlgaro"
#: utils.py:115
msgid "Burmese"
msgstr "Brumanês"
#: utils.py:117
msgid "Cambodian"
msgstr "Cambojano"
#: utils.py:118
msgid "Catalan"
msgstr "Catalão"
msgid "Change"
msgstr "Alterar"
msgid "Charset"
msgstr "Charset"
#: utils.py:119
msgid "Chinese"
msgstr "Chinês"
#: utils.py:120
msgid "Chinese/China"
msgstr "Chinês/China"
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr "Chinês/Taiwan"
msgid "Clear catalog and import all messages"
msgstr "Limpar este catálogo e re-importar todas as mensagens."
#: utils.py:88
msgid "Contents"
msgstr "Conteúdo"
#: utils.py:122
msgid "Cornish"
msgstr "Cornês"
#: utils.py:123
msgid "Corsican"
msgstr "Corso"
#: utils.py:124
msgid "Croatian"
msgstr "Croata"
#: utils.py:125
msgid "Czech"
msgstr "Tcheco"
#: utils.py:126
msgid "Danish"
msgstr "Noroeguês"
msgid "Default language"
msgstr "Língua default"
msgid "Delete"
msgstr "Apagar"
msgid "Delete languages"
msgstr "Apagar línguas"
#: utils.py:127
msgid "Dutch"
msgstr "Holandês"
#: utils.py:128
msgid "Dutch/Belgium"
msgstr "Holandês/Bélgica"
#: utils.py:129
msgid "English"
msgstr "Inglês"
#: utils.py:130
msgid "English/United Kingdom"
msgstr "Inglês/Reino Unido"
#: utils.py:131
msgid "English/United States"
msgstr "Inglês/Estados Unidos"
#: utils.py:132
msgid "Esperanto"
msgstr "Esperanto"
#: utils.py:133
msgid "Estonian"
msgstr "Estonês"
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr "Exportar"
msgid "Export messages to PO file"
msgstr "Exportar mensagens para arquivos no formato PO"
msgid "Export messages to TMX file"
msgstr "Exportar mensagens para arquivo no formato TMX"
msgid "Export messages to XLIFF file"
msgstr "Exportar mensagens para arquivo no formato XLIFF"
#: utils.py:134
msgid "Faroese"
msgstr "Faroês"
#: utils.py:135
msgid "Fiji"
msgstr "Fiji"
msgid "File"
msgstr "Arquivo"
msgid "File / Language"
msgstr "Arquivo / Língua"
msgid "Filter"
msgstr "Filtro"
#: utils.py:94
msgid "Find"
msgstr "Buscar"
#: utils.py:136
msgid "Finnish"
msgstr "Finlandês"
#: utils.py:137
msgid "French"
msgstr "Francês"
#: utils.py:138
msgid "French/Belgium"
msgstr "Francês/Bélgica"
#: utils.py:139
msgid "French/Canada"
msgstr "Francês/Canadá"
#: utils.py:140
msgid "French/France"
msgstr "Francês/França"
#: utils.py:141
msgid "French/Switzerland"
msgstr "Francês/Suiça"
#: utils.py:142
msgid "Frisian"
msgstr "Frisian"
#: utils.py:143
msgid "Galician"
msgstr "Espanhol/Galícia"
#: utils.py:144
msgid "Georgian"
msgstr "Georgia"
#: utils.py:145
msgid "German"
msgstr "Alemão"
#: utils.py:146
msgid "German/Austria"
msgstr "Alemão/Aústria"
#: utils.py:147
msgid "German/Germany"
msgstr "Alemão/Alemanha"
#: utils.py:148
msgid "German/Switzerland"
msgstr "Alemão/Suiça"
#: utils.py:149
msgid "Greek"
msgstr "Grego"
#: utils.py:150
msgid "Greenlandic"
msgstr "Groelandês"
#: utils.py:151
msgid "Guarani"
msgstr "Guarani"
#: utils.py:152
msgid "Gujarati"
msgstr "Gujarati"
#: utils.py:153
msgid "Hausa"
msgstr "Hausa"
#: utils.py:154
msgid "Hebrew"
msgstr "hebreu"
#: utils.py:155
msgid "Hindi"
msgstr "Hindu"
msgid "How much"
msgstr "Quanto"
#: utils.py:156
msgid "Hungarian"
msgstr "Húngaro"
#: utils.py:157
msgid "Icelandic"
msgstr "Islândia"
msgid "Id"
msgstr "Id"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr "Importar"
msgid "Import all messages"
msgstr "Importar todas as mensagens"
msgid "Import only translations for messages that exist already"
msgstr "Importar apenas traduções para mensagens pré-existentes"
msgid "Import translations from PO file"
msgstr "Importar traduções de arquivo no formato PO"
msgid "Import translations from TMX file"
msgstr "Importar traduções a partir de arquivo no formato TMX"
msgid "Import translations from XLIFF file"
msgstr "Importar traduções de arquivo no formato XLIFF"
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr "Importadas %d mensagens e %d observações"
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr "Importadas %d mensagens e %d observações para %s"
#: LocalContent.py:294
#, fuzzy
msgid "Imported %d messages to %s"
msgstr "Importadas %d mensagens e %d observações"
#: utils.py:158
msgid "Indonesian"
msgstr "Indonésia"
#: utils.py:159
msgid "Interlingua"
msgstr "Intrerlíngua"
#: utils.py:160
msgid "Interlingue"
msgstr "Interlíngua"
#: utils.py:161
msgid "Inuktitut"
msgstr "Inuktitut"
#: utils.py:162
msgid "Inupiak"
msgstr "Inupiak"
#: utils.py:163
msgid "Irish"
msgstr "Irlandês"
#: utils.py:164
msgid "Italian"
msgstr "Italiano"
#: utils.py:165
msgid "Japanese"
msgstr "Japonês"
#: utils.py:166
msgid "Javanese"
msgstr "Javanês"
#: utils.py:167
msgid "Kannada"
msgstr "Kannada"
#: utils.py:168
msgid "Kashmiri"
msgstr "Kashmiri"
#: utils.py:169
msgid "Kazakh"
msgstr "Kazakh"
#: utils.py:170
msgid "Kinyarwanda"
msgstr "Kinyarwandanês"
#: utils.py:171
msgid "Kirghiz"
msgstr "Kirghiz"
#: utils.py:172
msgid "Kirundi"
msgstr "Kirundi"
#: utils.py:173
msgid "Korean"
msgstr "Coreano"
#: utils.py:174
msgid "Kurdish"
msgstr "Curdo"
msgid "Language"
msgstr "Língua"
#: LanguageManager.py:157
msgid "Languages"
msgstr "Línguas"
#: utils.py:175
msgid "Laothian"
msgstr "Laoanês"
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr "Latvério"
#: utils.py:178
msgid "Lingala"
msgstr "Lingala"
#: utils.py:179
msgid "Lithuanian"
msgstr "Lituano"
#: LocalPropertyManager.py:67
msgid "Local properties"
msgstr "Propriedades locais"
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
"Pastas Locale são úteis para armazenar objetos multi-linguísticos como "
"imagens e lógica específica. Se usado, um objeto <tt>Localizer</tt> irá "
"adicionar a pasta locale correta à url transparentemente. Se você desejar "
"utilzar pastas locale selecione a caixa-de-seleção e clique no botão "
"<tt>Alterar</tt>."
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
#, fuzzy
msgid "Localizer"
msgstr "Adiciona Localizer"
#: utils.py:180
msgid "Luxembourgish"
msgstr "Luxemburguês"
#: utils.py:181
msgid "Macedonian"
msgstr "Macedônico"
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr "Maltês"
#: utils.py:186
msgid "Maori"
msgstr "Maori"
#: utils.py:187
msgid "Marathi"
msgstr ""
#, fuzzy
msgid "Message to translate"
msgstr "Mensagens importadas"
#: MessageCatalog.py:303
msgid "Messages"
msgstr "Mensagens"
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
msgid "Messages imported"
msgstr "Mensagens importadas"
#: utils.py:188
msgid "Moldavian"
msgstr "Moldávio"
#: utils.py:189
msgid "Mongolian"
msgstr "Mongol"
msgid "Name"
msgstr "Nome"
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr "Nepalês"
#, fuzzy
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
"<em>Não há linguas disponíveis, favor adicioná-las através da aba <a "
"href='manage_languages'>Línguas</a> </em>"
#: utils.py:192
msgid "Northern Saami"
msgstr "Saami do Norte"
#: utils.py:193
msgid "Norwegian"
msgstr "Noroeguês"
msgid "Note"
msgstr "Observação"
#: utils.py:194
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr "Apenas mensagens não-traduzidas"
msgid "Original language"
msgstr "Língua Original"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr "Propriedade"
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
msgid "Persian"
msgstr "Persa"
#: utils.py:199
msgid "Polish"
msgstr "Polonês"
#: utils.py:200
msgid "Portuguese"
msgstr "Português"
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr "Português/Brazil"
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr "Propriedades"
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr "Resultados %d-%d em %d"
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr "Romaniano"
#: utils.py:206
msgid "Russian"
msgstr "Russo"
#: utils.py:207
msgid "Samoan"
msgstr "Samoano"
#: utils.py:208
msgid "Sangho"
msgstr ""
#: utils.py:209
msgid "Sanskrit"
msgstr "Sânscrito"
msgid "Save"
msgstr "Salvar"
msgid "Save changes"
msgstr "Salvar alterações"
#: MessageCatalog.py:439 MessageCatalog.py:454
msgid "Saved changes."
msgstr "Mudanças salvas."
#: utils.py:210
msgid "Scots Gaelic"
msgstr "Galês Escocês"
#: utils.py:91
msgid "Security"
msgstr "Segurança"
#: utils.py:211
msgid "Serbian"
msgstr "Sérvio"
#: utils.py:212
msgid "Serbo-Croatian"
msgstr "Servo-Croata"
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
msgid "Sindhi"
msgstr ""
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr "Eslovaco"
#: utils.py:220
msgid "Slovenian"
msgstr "Esloveno"
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr "Espanhol"
#: utils.py:223
msgid "Spanish/Argentina"
msgstr "Espanhol/Argentina"
#: utils.py:224
msgid "Spanish/Colombia"
msgstr "Espanhol/Colômbia"
#: utils.py:225
msgid "Spanish/Mexico"
msgstr "Espanhol/México"
#: utils.py:226
msgid "Spanish/Spain"
msgstr "Espanhol/Espanha"
#: utils.py:227
msgid "Sundanese"
msgstr "Sudanês"
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr "Sueco"
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
msgid "Tamil"
msgstr ""
msgid "Target language"
msgstr "Língua alvo"
msgid "Target languages"
msgstr "Línguas Alvo"
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr "Endereço de e-mail do Grupo"
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
"O Catálogo de Mensagens também suporta importar arquivos TMX. Você pode "
"adicionar mensagens e traduções importando um arquivo TMX em um TMX nível 1. "
"Entre com o nome do arquivo e clique no botão <tt>Importar</tt>."
msgid "There are no attributes"
msgstr "Não existem atributos definidos"
msgid "There are no languages"
msgstr "Não existem línguas definidas"
msgid "There are no messages."
msgstr "Não existem mensagens"
msgid "This object is up-to-date."
msgstr ""
#, fuzzy
msgid "This object must be upgraded."
msgstr "Este objeto não precisa de atualização."
#: utils.py:236
msgid "Tibetan"
msgstr "Tibetano"
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Título"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
"Para acrescentar uma língua selecione a mesma e clique no botão "
"<tt>Adicionar</tt>"
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
"Para adicionar um atributo introduza o id e clique no botão <tt> Adicionar</"
"tt>."
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr ""
"Para alterar a língua default selecione a mesma e clique no botão "
"<tt>Adicionar</tt>"
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
"Para remover uma língua selecione a mesma e clique no botão <tt>Remover</tt>."
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
"Para remover um atributo selecione o mesmo e clique no botão <tt>Remover</"
"tt>."
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
msgid "Translate properties"
msgstr "Traduzir propriedades"
#, fuzzy
msgid "Translations"
msgstr "Traduzir propriedades"
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr "Turco"
#: utils.py:241
msgid "Turkmen"
msgstr "Turcomeno"
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Tipo"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr "Ucraniano"
#: utils.py:92
msgid "Undo"
msgstr "Desfazer"
#: LanguageManager.py:168
msgid "Upgrade"
msgstr "Atualizar"
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr "Use pastas locale"
#: utils.py:246
msgid "Uzbek"
msgstr "Uzbeco"
msgid "Value"
msgstr "Valor"
#: utils.py:247
msgid "Vietnamese"
msgstr "Vietnamita"
#: utils.py:89
msgid "View"
msgstr "Visualizar"
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr "Escocês"
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
"Com este formulário você pode alterar o título do Catálogo de Mensagens. O "
"título também é usado como valor do campo <tt>Project-Id-version</tt> no "
"cabeçalho dos arquivos PO, os quais são gerados quando o catálogo é "
"exportado."
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
"Você pode adicionar novas mensagens e traduções importando um arquivo PO. "
"Forneça o nome do arquivo, selecione a língua a traduzir e clique no botão "
"<tt>Importar</tt>."
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Você pode exportar as mensagens e suas traduções para arquivos PO. Selecione "
"<tt>locale.pot</tt> para exportar apenas mensagens, sem as respectivas "
"traduções. Selecione qualquer outra opção para obter um arquivo PO com "
"mensagens e traduções na língua selecionada. Finalmente clique no botão "
"<tt>Exportar</tt>."
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
"Você pode exportar as mensagens e suas traduções para arquivos TMX nível 1. "
"Para fazê-lo basta clicar no botão <tt>Exportar</tt>."
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Você pode exportar as mensagens e suas traduções para arquivos PO. Selecione "
"<tt>locale.pot</tt> para exportar apenas mensagens, sem as respectivas "
"traduções. Selecione qualquer outra opção para obter um arquivo PO com "
"mensagens e traduções na língua selecionada. Finalmente clique no botão "
"<tt>Exportar</tt>."
msgid "Your e-mail address"
msgstr "Seu endereço de e-mail"
msgid "Your name"
msgstr "Seu nome"
#: utils.py:254
msgid "Zhuang"
msgstr ""
#: utils.py:255
msgid "Zulu"
msgstr "Zulu"
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#~ msgid "This <tt>%s</tt> object needs to be upgraded"
#~ msgstr "Este <tt>%s</tt> objeto precisa de atualização"
#~ msgid "This <tt>Localizer</tt> object needs to be upgraded."
#~ msgstr "Este objeto <tt>Localizer</tt> precisa ser atualizado."
#~ msgid "This <tt>Localizer</tt> object doesn't need to be upgraded."
#~ msgstr "Este objeto <tt>Localizer</tt> não precisa ser atualizado."
#~ msgid "Import/Export"
#~ msgstr "Importar/Exportar"
#~ msgid "TMX"
#~ msgstr "TMX"
#~ msgid "label"
#~ msgstr "rótulo"
#~ msgid "Default"
#~ msgstr "Default"
#~ msgid ""
#~ "To delete a language check it and click the <tt>Delete</tt> button. To "
#~ "change the default language select it and click the <tt>Change</tt> "
#~ "button."
#~ msgstr ""
#~ "Para remover uma língua selecione a mesma e clique no botão <tt>Remover</"
#~ "tt>. Para alterar a língua default selecione a mesma e clique no botão "
#~ "<tt>Alterar</tt>."
#~ msgid "Show this language"
#~ msgstr "Mostrar esta língua"
#~ msgid ""
#~ "To add a new property enter its name, select its type and click the "
#~ "<tt>Add</tt> button."
#~ msgstr ""
#~ "Para adicionar uma nova propriedade preencha o respectivo nome, selecione "
#~ "seu tipo e clique no botão <tt>Adicionar</tt>"
product/Localizer/locale/ru.po 0 → 100644
View file @ 52146f5e
# russian po file for Localizer.
# Copyright (C) 2003 Free Software Foundation, Inc.
# Alexey Lubimov <avl@altlinux.ru>, 2003.
msgid ""
msgstr ""
"Project-Id-Version: User messages\n"
"POT-Creation-Date: 2010-01-29 14:01+CET\n"
"PO-Revision-Date: 2003-07-31 09:07+MSK\n"
"Last-Translator: Lubimov Alexey <avl@altlinux.ru>\n"
"Language-Team: ru <RU@li.org>\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
#: MessageCatalog.py:684
msgid "%s"
msgstr ""
#: MessageCatalog.py:809 LocalContent.py:237
msgid "1.1.x"
msgstr ""
#: MessageCatalog.py:679 LocalContent.py:143
msgid "1.x"
msgstr ""
#, fuzzy
msgid ""
"A Local Content object provides a storage for multilingual (and non "
"multilingual) properties. It also helps you keep your content separated from "
"the logic and the presentation."
msgstr ""
"Local Content объект предоставляет хранилище для многоязычных (и не "
"многоязычных) свойств. Он также помогает хранить данные (content) отдельно "
"от логики (logic) и представления (presentation)."
#, fuzzy
msgid ""
"A Localizer object lets you customize the language negotiation policy. It "
"lets you use cookies, the path or any other criteria to select the user "
"preferred language."
msgstr ""
"Объект Localizer позволяет адаптировать политику выбора языка. Он позволяет "
"использовать куки (cookies), путь и любые другие критерии для выбора "
"предпочитаемого пользователем языка."
msgid ""
"A local folder is a generic solution to manage any kind of multingual "
"objects, files, images, scripts, etc.."
msgstr ""
"Локальная папка, это универсальный способ управления любыми аспектами "
"мультиязыковых объектов, файлов, изображений, скриптов и т.д...\r\n"
" "
msgid ""
"A message catalog stores messages and its translations to different "
"languages. It provides the <tt>gettext</tt> method to get the right "
"translation for a given message. Message catalogs are useful to translate "
"the application interfaces (labels, buttons, etc..)."
msgstr ""
"Каталог сообщений хранит сообщения и их переводы на разные языки Он "
"предоставляет <tt>gettext</tt> метод для доступа к правильному переводу "
"требуемого сообщения. Каталог сообщений используется для перевода интерфейса "
"приложений (метки, кнопки, итд..)."
#: utils.py:96
msgid "Abkhazian"
msgstr ""
msgid "Add"
msgstr "Добавить"
msgid "Add Local Content"
msgstr "Добавить локальное содержимое"
msgid "Add Local Folder"
msgstr "Добавить локальную папку"
msgid "Add Localizer"
msgstr "Добавить Localizer"
msgid "Add Message Catalog"
msgstr "Добавить каталог сообщений"
#, fuzzy
msgid "Add language"
msgstr "Язык"
#: utils.py:97
msgid "Afar"
msgstr ""
#: utils.py:98
msgid "Afrikaans"
msgstr ""
#: utils.py:99
msgid "Albanian"
msgstr ""
#: utils.py:100
msgid "Amharic"
msgstr ""
#: utils.py:101
msgid "Arabic"
msgstr ""
#: utils.py:102
msgid "Armenian"
msgstr ""
#: utils.py:103
#, fuzzy
msgid "Assamese"
msgstr "Сообщения"
#: LocalFolder.py:62
msgid "Attributes"
msgstr "Атрибуты"
#: utils.py:104
msgid "Aymara"
msgstr ""
#: utils.py:105
msgid "Azerbaijani"
msgstr ""
#: utils.py:106
msgid "Bashkir"
msgstr ""
#: utils.py:107
msgid "Basque"
msgstr "Язык басков"
#: utils.py:116
msgid "Belarusian"
msgstr ""
#: utils.py:108
msgid "Bengali"
msgstr ""
#, fuzzy
msgid ""
"Besides the title the header of a PO file stores more information; the name "
"and the email address of the last translator, the email address of the "
"translation team and the charset. The forms below let you modify this "
"information for each language."
msgstr ""
"Кроме заглавия, заголовок PO файла содержит дополнительную информацию, имя и "
"e-mail последнего переводчика, e-mail команды переводчиков и кодировку. "
"Форму внизу позволяет изменить эту информацию для каждого языка."
#: utils.py:109
msgid "Bhutani"
msgstr ""
#: utils.py:110
msgid "Bihari"
msgstr ""
#: utils.py:111
msgid "Bislama"
msgstr ""
#: utils.py:112
msgid "Bosnian"
msgstr ""
#: utils.py:113
msgid "Breton"
msgstr ""
#, fuzzy
msgid "Browse the messages"
msgstr "Сообщений нет"
#: utils.py:114
#, fuzzy
msgid "Bulgarian"
msgstr "Венгерский"
#: utils.py:115
msgid "Burmese"
msgstr ""
#: utils.py:117
msgid "Cambodian"
msgstr ""
#: utils.py:118
msgid "Catalan"
msgstr "Каталонское наречие"
msgid "Change"
msgstr "Изменить"
msgid "Charset"
msgstr "Кодировка"
#: utils.py:119
#, fuzzy
msgid "Chinese"
msgstr "Изменить"
#: utils.py:120
msgid "Chinese/China"
msgstr ""
#: utils.py:121
msgid "Chinese/Taiwan"
msgstr ""
msgid "Clear catalog and import all messages"
msgstr ""
#: utils.py:88
msgid "Contents"
msgstr "Содержимое"
#: utils.py:122
msgid "Cornish"
msgstr ""
#: utils.py:123
msgid "Corsican"
msgstr ""
#: utils.py:124
#, fuzzy
msgid "Croatian"
msgstr "Каталонское наречие"
#: utils.py:125
msgid "Czech"
msgstr ""
#: utils.py:126
#, fuzzy
msgid "Danish"
msgstr "Испанский"
#, fuzzy
msgid "Default language"
msgstr "Скрыть этот язык"
msgid "Delete"
msgstr "Удалить"
#, fuzzy
msgid "Delete languages"
msgstr "Языки не доступны"
#: utils.py:127
msgid "Dutch"
msgstr ""
#: utils.py:128
msgid "Dutch/Belgium"
msgstr ""
#: utils.py:129
msgid "English"
msgstr ""
#: utils.py:130
msgid "English/United Kingdom"
msgstr ""
#: utils.py:131
msgid "English/United States"
msgstr ""
#: utils.py:132
msgid "Esperanto"
msgstr ""
#: utils.py:133
msgid "Estonian"
msgstr ""
#: MessageCatalog.py:308 LocalContent.py:81
msgid "Export"
msgstr "Экспорт"
msgid "Export messages to PO file"
msgstr ""
msgid "Export messages to TMX file"
msgstr ""
msgid "Export messages to XLIFF file"
msgstr ""
#: utils.py:134
msgid "Faroese"
msgstr ""
#: utils.py:135
msgid "Fiji"
msgstr ""
msgid "File"
msgstr "Файл"
msgid "File / Language"
msgstr "Файл / язык"
msgid "Filter"
msgstr "Фильтр"
#: utils.py:94
msgid "Find"
msgstr "Поиск"
#: utils.py:136
msgid "Finnish"
msgstr ""
#: utils.py:137
msgid "French"
msgstr "Французский"
#: utils.py:138
#, fuzzy
msgid "French/Belgium"
msgstr "Французский"
#: utils.py:139
#, fuzzy
msgid "French/Canada"
msgstr "Французский"
#: utils.py:140
#, fuzzy
msgid "French/France"
msgstr "Французский"
#: utils.py:141
msgid "French/Switzerland"
msgstr ""
#: utils.py:142
msgid "Frisian"
msgstr ""
#: utils.py:143
msgid "Galician"
msgstr ""
#: utils.py:144
#, fuzzy
msgid "Georgian"
msgstr "Немецкий"
#: utils.py:145
msgid "German"
msgstr "Немецкий"
#: utils.py:146
#, fuzzy
msgid "German/Austria"
msgstr "Немецкий"
#: utils.py:147
#, fuzzy
msgid "German/Germany"
msgstr "Немецкий"
#: utils.py:148
msgid "German/Switzerland"
msgstr ""
#: utils.py:149
msgid "Greek"
msgstr ""
#: utils.py:150
msgid "Greenlandic"
msgstr ""
#: utils.py:151
#, fuzzy
msgid "Guarani"
msgstr "Венгерский"
#: utils.py:152
msgid "Gujarati"
msgstr ""
#: utils.py:153
msgid "Hausa"
msgstr ""
#: utils.py:154
msgid "Hebrew"
msgstr ""
#: utils.py:155
#, fuzzy
msgid "Hindi"
msgstr "Поиск"
msgid "How much"
msgstr ""
#: utils.py:156
msgid "Hungarian"
msgstr "Венгерский"
#: utils.py:157
msgid "Icelandic"
msgstr ""
msgid "Id"
msgstr "Id"
#: MessageCatalog.py:306 LocalContent.py:79
msgid "Import"
msgstr "Импорт"
msgid "Import all messages"
msgstr ""
msgid "Import only translations for messages that exist already"
msgstr ""
msgid "Import translations from PO file"
msgstr ""
msgid "Import translations from TMX file"
msgstr ""
msgid "Import translations from XLIFF file"
msgstr ""
#: MessageCatalog.py:761
msgid "Imported %d messages and %d notes"
msgstr ""
#: MessageCatalog.py:880
msgid "Imported %d messages and %d notes to %s"
msgstr ""
#: LocalContent.py:294
msgid "Imported %d messages to %s"
msgstr ""
#: utils.py:158
msgid "Indonesian"
msgstr ""
#: utils.py:159
msgid "Interlingua"
msgstr ""
#: utils.py:160
msgid "Interlingue"
msgstr ""
#: utils.py:161
msgid "Inuktitut"
msgstr ""
#: utils.py:162
msgid "Inupiak"
msgstr ""
#: utils.py:163
msgid "Irish"
msgstr ""
#: utils.py:164
#, fuzzy
msgid "Italian"
msgstr "Каталонское наречие"
#: utils.py:165
msgid "Japanese"
msgstr "Японский"
#: utils.py:166
#, fuzzy
msgid "Javanese"
msgstr "Японский"
#: utils.py:167
msgid "Kannada"
msgstr ""
#: utils.py:168
msgid "Kashmiri"
msgstr ""
#: utils.py:169
msgid "Kazakh"
msgstr ""
#: utils.py:170
msgid "Kinyarwanda"
msgstr ""
#: utils.py:171
msgid "Kirghiz"
msgstr ""
#: utils.py:172
msgid "Kirundi"
msgstr ""
#: utils.py:173
msgid "Korean"
msgstr ""
#: utils.py:174
msgid "Kurdish"
msgstr ""
msgid "Language"
msgstr "Язык"
#: LanguageManager.py:157
msgid "Languages"
msgstr "Языки"
#: utils.py:175
msgid "Laothian"
msgstr ""
#: utils.py:176
msgid "Latin"
msgstr ""
#: utils.py:177
msgid "Latvian"
msgstr ""
#: utils.py:178
msgid "Lingala"
msgstr ""
#: utils.py:179
msgid "Lithuanian"
msgstr ""
#: LocalPropertyManager.py:67
msgid "Local properties"
msgstr "Локальные свойства"
msgid ""
"Locale folders are useful to store special multilingual objects like images "
"and specific logic. If used the <tt>Localizer</tt> object will transparently "
"add the right locale folder to the url. If you want to use locale folders "
"check the checkbox, otherwise uncheck it, then click the <tt>Change</tt> "
"button."
msgstr ""
"Папки локалей используются для хранения многоязычных объектов, таких как "
"изображения и специфичной логики. При использовании объект- <tt>Localizer</"
"tt> прозрачно добавит папку локалей в url. При желании использовать папки "
"локалей, необходимо отметить чекбокс или в ином случае снять с него отметку "
"и щелкнуть кнопку <tt>Изменить</tt>."
#: MessageCatalog.py:678 MessageCatalog.py:808 LocalContent.py:142
#: LocalContent.py:236
#, fuzzy
msgid "Localizer"
msgstr "Добавить Localizer"
#: utils.py:180
msgid "Luxembourgish"
msgstr ""
#: utils.py:181
msgid "Macedonian"
msgstr ""
#: utils.py:182
msgid "Malagasy"
msgstr ""
#: utils.py:183
msgid "Malay"
msgstr ""
#: utils.py:184
msgid "Malayalam"
msgstr ""
#: utils.py:185
msgid "Maltese"
msgstr ""
#: utils.py:186
msgid "Maori"
msgstr ""
#: utils.py:187
msgid "Marathi"
msgstr ""
#, fuzzy
msgid "Message to translate"
msgstr "Сообщения"
#: MessageCatalog.py:303
msgid "Messages"
msgstr "Сообщения"
#: MessageCatalog.py:763 MessageCatalog.py:879 LocalContent.py:293
#, fuzzy
msgid "Messages imported"
msgstr "Сообщения"
#: utils.py:188
msgid "Moldavian"
msgstr ""
#: utils.py:189
msgid "Mongolian"
msgstr ""
msgid "Name"
msgstr "Имя"
#: utils.py:190
msgid "Nauru"
msgstr ""
#: utils.py:191
msgid "Nepali"
msgstr ""
msgid ""
"No languages available, please add them using the <a "
"href='manage_languages'>Languages</a> tab"
msgstr ""
#: utils.py:192
msgid "Northern Saami"
msgstr ""
#: utils.py:193
msgid "Norwegian"
msgstr ""
msgid "Note"
msgstr ""
#: utils.py:194
msgid "Occitan"
msgstr ""
msgid "Only untranslated messages"
msgstr "Только непереведнные сообщения"
#, fuzzy
msgid "Original language"
msgstr "Скрыть этот язык"
#: utils.py:195
msgid "Oriya"
msgstr ""
#: utils.py:196
msgid "Oromo"
msgstr ""
#: utils.py:93
msgid "Ownership"
msgstr "Владелец"
#: utils.py:197
msgid "Pashto"
msgstr ""
#: utils.py:198
#, fuzzy
msgid "Persian"
msgstr "Немецкий"
#: utils.py:199
msgid "Polish"
msgstr ""
#: utils.py:200
#, fuzzy
msgid "Portuguese"
msgstr "Свойства"
#: utils.py:201
msgid "Portuguese/Brazil"
msgstr ""
#: utils.py:90 MessageCatalog.py:305
msgid "Properties"
msgstr "Свойства"
#: utils.py:202
msgid "Punjabi"
msgstr ""
#: utils.py:203
msgid "Quechua"
msgstr ""
msgid "Results %d-%d of %d"
msgstr "Результаты %d-%d из %d"
#: utils.py:204
msgid "Rhaeto-Romance"
msgstr ""
#: utils.py:205
msgid "Romanian"
msgstr ""
#: utils.py:206
msgid "Russian"
msgstr ""
#: utils.py:207
msgid "Samoan"
msgstr ""
#: utils.py:208
#, fuzzy
msgid "Sangho"
msgstr "Испанский"
#: utils.py:209
msgid "Sanskrit"
msgstr ""
msgid "Save"
msgstr "Сохранить"
msgid "Save changes"
msgstr "Сохранить изменения"
#: MessageCatalog.py:439 MessageCatalog.py:454
msgid "Saved changes."
msgstr "Изменения сохранены."
#: utils.py:210
msgid "Scots Gaelic"
msgstr ""
#: utils.py:91
msgid "Security"
msgstr "Безопасность"
#: utils.py:211
#, fuzzy
msgid "Serbian"
msgstr "Немецкий"
#: utils.py:212
msgid "Serbo-Croatian"
msgstr ""
#: utils.py:213
msgid "Sesotho"
msgstr ""
#: utils.py:214
msgid "Setswana"
msgstr ""
#: utils.py:215
msgid "Shona"
msgstr ""
#: utils.py:216
#, fuzzy
msgid "Sindhi"
msgstr "Поиск"
#: utils.py:217
msgid "Sinhalese"
msgstr ""
#: utils.py:218
msgid "Siswati"
msgstr ""
#: utils.py:219
msgid "Slovak"
msgstr ""
#: utils.py:220
msgid "Slovenian"
msgstr ""
#: utils.py:221
msgid "Somali"
msgstr ""
#: utils.py:222
msgid "Spanish"
msgstr "Испанский"
#: utils.py:223
msgid "Spanish/Argentina"
msgstr ""
#: utils.py:224
#, fuzzy
msgid "Spanish/Colombia"
msgstr "Испанский"
#: utils.py:225
#, fuzzy
msgid "Spanish/Mexico"
msgstr "Испанский"
#: utils.py:226
#, fuzzy
msgid "Spanish/Spain"
msgstr "Испанский"
#: utils.py:227
msgid "Sundanese"
msgstr ""
#: utils.py:228
msgid "Swahili"
msgstr ""
#: utils.py:229
msgid "Swedish"
msgstr ""
#: utils.py:230
msgid "Tagalog"
msgstr ""
#: utils.py:231
msgid "Tajik"
msgstr ""
#: utils.py:232
#, fuzzy
msgid "Tamil"
msgstr "Заголовок"
#, fuzzy
msgid "Target language"
msgstr "Языки не доступны"
#, fuzzy
msgid "Target languages"
msgstr "Языки не доступны"
#: utils.py:233
msgid "Tatar"
msgstr ""
msgid "Team e-mail address"
msgstr "Групповой e-mail адрес"
#: utils.py:234
msgid "Telugu"
msgstr ""
#: utils.py:235
msgid "Thai"
msgstr ""
msgid ""
"The message catalog also supports importing TMX files. You can add new "
"messages and translations importing a TMX file in TMX level 1. Enter the "
"filename and click the <tt>Import</tt> button."
msgstr ""
"Каталог сообщений также поддерживает импорт TMX файлов. Вы можете добавить "
"новый сообщения и переводы, импортируя TMX файл в TMX уровень 1. Введите имя "
"файла и щелкните по кнопке <tt>Импорт</tt> "
#, fuzzy
msgid "There are no attributes"
msgstr "Атрибутов нет"
#, fuzzy
msgid "There are no languages"
msgstr "Языки не доступны"
#, fuzzy
msgid "There are no messages."
msgstr "Сообщений нет"
msgid "This object is up-to-date."
msgstr ""
#, fuzzy
msgid "This object must be upgraded."
msgstr "Этот объект не требует обновления"
#: utils.py:236
msgid "Tibetan"
msgstr ""
#: utils.py:237
msgid "Tigrinya"
msgstr ""
msgid "Title"
msgstr "Заголовок"
msgid "To add a language select it and click the <tt>Add</tt> button."
msgstr ""
"Чтобы добавить язык, его надо выбрать и щелкнуть по кнопке <tt>Добавить</tt>"
msgid "To add an attribute introduce its id and click the <tt>Add</tt> button."
msgstr ""
"Чтобы добавить атрибуты, надо ввести их id и щелкнуть по кнопке "
"<tt>Добавить</tt>"
#, fuzzy
msgid ""
"To change the default language select it and click the <tt>Change</tt> "
"button."
msgstr ""
"Чтобы добавить язык, его надо выбрать и щелкнуть по кнопке <tt>Добавить</tt>"
#, fuzzy
msgid "To delete a language check it and click the <tt>Delete</tt> button."
msgstr ""
"Чтобы удалить атрибут, надо отметить его и щелкнуть кнопку <tt>Удалить</tt>"
msgid "To delete an attribute check it and click the <tt>Delete</tt> button."
msgstr ""
"Чтобы удалить атрибут, надо отметить его и щелкнуть кнопку <tt>Удалить</tt>"
#: utils.py:238
msgid "Tonga"
msgstr ""
#: LocalPropertyManager.py:70
#, fuzzy
msgid "Translate properties"
msgstr "Свойств нет"
#, fuzzy
msgid "Translations"
msgstr "Свойств нет"
#: utils.py:239
msgid "Tsonga"
msgstr ""
#: utils.py:240
msgid "Turkish"
msgstr ""
#: utils.py:241
msgid "Turkmen"
msgstr ""
#: utils.py:242
msgid "Twi"
msgstr ""
msgid "Type"
msgstr "Тип"
#: utils.py:243
msgid "Uighur"
msgstr ""
#: utils.py:244
msgid "Ukrainian"
msgstr ""
#: utils.py:92
msgid "Undo"
msgstr "Отмена"
#: LanguageManager.py:168
msgid "Upgrade"
msgstr "Обновление"
#: utils.py:245
msgid "Urdu"
msgstr ""
msgid "Use locale folders"
msgstr "Использовать локальные папки"
#: utils.py:246
msgid "Uzbek"
msgstr ""
msgid "Value"
msgstr ""
#: utils.py:247
msgid "Vietnamese"
msgstr ""
#: utils.py:89
msgid "View"
msgstr "Вид"
#: utils.py:248
msgid "Volapuk"
msgstr ""
#: utils.py:249
msgid "Welsh"
msgstr ""
msgid ""
"With this form you can change the title of the message catalog. The title "
"also is used as the value of the <tt>Project-Id-Version</tt> field in the "
"header of the PO files, which are generated when the message catalog is "
"exported."
msgstr ""
"В этой форме можно изменить заголовок каталога сообщений. Заголовок также "
"используется, как значение <tt>Project-Id-Version</tt> в шапке PO файлов, "
"которые генерируются при экспорте этого каталога сообщений."
#: utils.py:250
msgid "Wolof"
msgstr ""
#: utils.py:251
msgid "Xhosa"
msgstr ""
#: utils.py:252
msgid "Yiddish"
msgstr ""
#: utils.py:253
msgid "Yoruba"
msgstr ""
msgid ""
"You can add new messages and translations importing a PO file. Enter the "
"filename, select the language of the translations and click the <tt>Import</"
"tt> button."
msgstr ""
"Можно добавить новые сообщения и переводы импортируя PO файл. Для этого "
"введите имя файла, выберите язык переводов и щелкните по кнопке <tt>Импорт</"
"tt>"
msgid ""
"You can export the messages and their translations to PO files. Check "
"<tt>locale.pot</tt> to get only the messages, without their translations. "
"Check any other option to get a PO file with the messages and their "
"translations to the selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Можно экспортировать сообщения и их переводы в PO файлы. Опция <tt>locale."
"pot</tt> позволяет получить только сообщения, без их перевода. Для "
"получения PO файла с сообщениями и их переводами, необходимо ототметить "
"нужные опции и атем щелкнуть по кнопке <tt>Экспорт</tt>"
msgid ""
"You can export the messages and their translations to TMX level 1 files. To "
"do that just click the <tt>Export</tt> button."
msgstr ""
"Можно экспортировать сообщения и их перевод в TMX уровень 1 файлы. Для этого "
"просто щелкните по кнопке <tt>Экспорт</tt>"
#, fuzzy
msgid ""
"You can export the messages and their translations to XLIFF files. Check any "
"option to get a XLIFF file with the messages and their translations to the "
"selected language. Then click the <tt>Export</tt> button."
msgstr ""
"Можно экспортировать сообщения и их переводы в PO файлы. Опция <tt>locale."
"pot</tt> позволяет получить только сообщения, без их перевода. Для "
"получения PO файла с сообщениями и их переводами, необходимо ототметить "
"нужные опции и атем щелкнуть по кнопке <tt>Экспорт</tt>"
msgid "Your e-mail address"
msgstr "Ваш e-mail адрес"
msgid "Your name"
msgstr "Ваше имя"
#: utils.py:254
#, fuzzy
msgid "Zhuang"
msgstr "Изменить"
#: utils.py:255
msgid "Zulu"
msgstr ""
#: MessageCatalog.py:681 LocalContent.py:145
msgid "paragraph"
msgstr ""
#: MessageCatalog.py:680 MessageCatalog.py:810 LocalContent.py:144
#: LocalContent.py:238
msgid "plaintext"
msgstr ""
#: LocalContent.py:148
msgid "utf-8"
msgstr ""
#~ msgid "This <tt>%s</tt> object needs to be upgraded"
#~ msgstr "Этот <tt>%s</tt> объект требует обновления"
#~ msgid "This <tt>Localizer</tt> object needs to be upgraded."
#~ msgstr "Этот объект <tt>Localizer</tt> требует обновления"
#, fuzzy
#~ msgid "This <tt>Localizer</tt> object doesn't need to be upgraded."
#~ msgstr "Этот объект <tt>Localizer</tt> не требует обновления"
#~ msgid "Import/Export"
#~ msgstr "Импорт/Экспорт"
#~ msgid "TMX"
#~ msgstr "TMX"
#~ msgid "label"
#~ msgstr "Метка"
#~ msgid "Default"
#~ msgstr "По умолчанию"
#~ msgid "Show this language"
#~ msgstr "Показать этот язык"
#~ msgid ""
#~ "To add a new property enter its name, select its type and click the "
#~ "<tt>Add</tt> button."
#~ msgstr ""
#~ "Для добавки нового свойства, надо ввести его имя и щелкнуть по кнопке "
#~ "<tt>Добавить</tt>."
#~ msgid ""
#~ "To delete a language check it and click the <tt>Delete</tt> button. To "
#~ "change the default language select it and click the <tt>Change</tt> "
#~ "button."
#~ msgstr ""
#~ "Для удаления языка, его надо отметить и щелкнуть <tt>Удалить</tt>. Для "
#~ "установки языка по умолчанию, его надо выбрать и щелкнуть кнопку "
#~ "<tt>Изменить</tt>"
product/Localizer/patches.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2006 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
This is a hotfix, it dynamically applies several patches to Zope.
"""
# Import from the Standard Library
import logging
import os
from thread import allocate_lock, get_ident
# Import from itools
from itools.i18n import AcceptLanguageType
# Import from Zope
import Globals
from ZPublisher import Publish
from ZPublisher.HTTPRequest import HTTPRequest
# Flag
patch = False
Z_DEBUG_MODE = os.environ.get('Z_DEBUG_MODE') == '1'
logger = logging.getLogger('Localizer')
# PATCH 1: Global Request
#
# The original purpose was to get the request object from places where the
# acquisition was disabled (within the __of__ method for example). It was
# inspired by the Tim McLaughlin's GlobalGetRequest proposal, see
# http://dev.zope.org/Wikis/DevSite/Proposals/GlobalGetRequest
#
# Currently it keeps a Context instance, which wraps the request object,
# but also other things, like the user's session, as it is required by
# the ikaaro CMS.
#
# The request objects are stored in a dictionary in the Publish module,
# whose keys are the thread id.
#
# Also, we keep the get_request method in the Globals module for backwards
# compatibility (with TranslationService for example).
_requests = {}
_requests_lock = allocate_lock()
def get_request():
"""Get a request object"""
return _requests.get(get_ident(), None)
def new_publish(request, module_name, after_list, debug=0,
zope_publish=Publish.publish):
# Get the process id
ident = get_ident()
# Add the request object to the global dictionnary
_requests_lock.acquire()
try:
_requests[ident] = request
finally:
_requests_lock.release()
# Call the old publish
try:
# Publish
x = zope_publish(request, module_name, after_list, debug)
finally:
# Remove the request object.
# When conflicts occur the "publish" method is called again,
# recursively. In this situation the "_requests dictionary would
# be cleaned in the innermost call, hence outer calls find the
# request does not exist anymore. For this reason we check first
# wether the request is there or not.
if ident in _requests:
_requests_lock.acquire()
try:
del _requests[ident]
finally:
_requests_lock.release()
return x
if patch is False:
logger.info('Install "Globals.get_request".')
# Apply the patch
Publish.publish = new_publish
# First import (it's not a refresh operation).
# We need to apply the patches.
patch = True
# Add to Globals for backwards compatibility
Globals.get_request = get_request
# PATCH 2: Accept
#
# Adds the variable AcceptLanguage to the REQUEST. It provides a higher
# level interface than HTTP_ACCEPT_LANGUAGE.
# Apply the patch
def new_processInputs(self):
HTTPRequest.old_processInputs(self)
request = self
# Set the AcceptLanguage variable
# Initialize with the browser configuration
accept_language = request['HTTP_ACCEPT_LANGUAGE']
# Patches for user agents that don't support correctly the protocol
user_agent = request['HTTP_USER_AGENT']
if user_agent.startswith('Mozilla/4') and user_agent.find('MSIE') == -1:
# Netscape 4.x
q = 1.0
langs = []
for lang in [ x.strip() for x in accept_language.split(',') ]:
langs.append('%s;q=%f' % (lang, q))
q = q/2
accept_language = ','.join(langs)
accept_language = AcceptLanguageType.decode(accept_language)
self.other['AcceptLanguage'] = accept_language
if patch:
HTTPRequest.old_processInputs = HTTPRequest.processInputs
HTTPRequest.processInputs = new_processInputs
product/Localizer/tests/test_zgettext.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2001, 2002 J. David Ibáñez <j-david@noos.fr>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
Test suite for the zgettext.py script.
"""
# Import from the Standard Library
import os
import sys
import unittest
from unittest import TestCase, TestSuite, TextTestRunner
# Import from Localizer
sys.path.append(os.path.join(sys.path[0], '../'))
import zgettext
class GettextTagTestCase(TestCase):
def test_caseSimple(self):
"""Test the 'dtml-gettext' tag without any option."""
text = "<dtml-gettext>\n" \
" message\n" \
"</dtml-gettext>"
assert zgettext.parse_dtml(text) == ['message']
def test_caseVerbatim(self):
"""Test the 'dtml-gettext' tag when using the 'verbatim' option."""
text = "<dtml-gettext verbatim>\n" \
" message\n" \
"</dtml-gettext>"
assert zgettext.parse_dtml(text) == ['\n message\n']
if __name__ == '__main__':
unittest.main()
product/Localizer/ui/LC_export_form.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<fieldset><legend><dtml-var "gettext('Export messages to TMX file')"></legend>
<p class="form-help">
<dtml-gettext>
You can export the messages and their translations to TMX level 1 files.
To do that just click the <tt>Export</tt> button.
</dtml-gettext>
</p>
<form action="tmx_export" method="post">
<table>
<tr>
<td><br></td>
<tr>
<td><input type="submit" value=" <dtml-var "gettext('Export')"> "></td>
<td></td>
</tr>
</table>
</form>
</fieldset>
<fieldset><legend><dtml-var "gettext('Export messages to XLIFF file')"></legend>
<p class="form-help">
<dtml-gettext>
You can export the messages and their translations to XLIFF files.
Check any option to get a XLIFF file with the messages and their
translations to the selected language. Then click the <tt>Export</tt>
button.
</dtml-gettext>
</p>
<form action="xliff_export" method="post">
<table border=0 cellpadding="2" cellspacing="2">
<tr>
<td><input type="radio" name="export_all" value="1" checked>Export all messages<br>
<input type="radio" name="export_all" value="0">Export only untranslated messages
for the language you select
</td>
</tr>
<tr>
<th align="left">
<dtml-var "gettext('Target language')">
</th>
</tr>
<tr>
<td valign="top">
<select name="targetlang">
<dtml-in get_languages_mapping mapping>
<option value="<dtml-var code>"><dtml-var code> / <dtml-var "gettext(name)"></option>
</dtml-in>
</select>
</td>
</tr>
<tr>
<td><input type="submit" value=" <dtml-var "gettext('Export')"> "></td>
<td></td>
</tr>
</table>
</form>
</fieldset>
<dtml-var manage_page_footer>
product/Localizer/ui/LC_import_form.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<fieldset><legend><dtml-var "gettext('Import translations from TMX file')"></legend>
<p class="form-help">
<dtml-gettext>
The message catalog also supports importing TMX files. You can add new
messages and translations importing a TMX file in TMX level 1. Enter the
filename and click the
<tt>Import</tt> button.
</dtml-gettext>
</p>
<form action="tmx_import" method="post" enctype="multipart/form-data">
<table>
<tr>
<th align="right"><dtml-var "gettext('File')"></th>
<td><input type="file" name="file"></td>
</tr>
<tr>
<th></th>
<td><input type="submit" value=" <dtml-var "gettext('Import')"> "></td>
</tr>
</table>
</form>
</fieldset>
<fieldset><legend><dtml-var "gettext('Import translations from XLIFF file')"></legend>
<form action="xliff_import" method="post" enctype="multipart/form-data">
<table>
<tr>
<th align="right"><dtml-var "gettext('File')"></th>
<td><input type="file" name="file"></td>
</tr>
<tr>
<th></th>
<td><input type="submit" value=" <dtml-var "gettext('Import')"> "></td>
</tr>
</table>
</form>
</fieldset>
<dtml-var manage_page_footer>
product/Localizer/ui/LM_languages.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<fieldset><legend><dtml-var "gettext('Add language')"></legend>
<p class="form-help">
<dtml-gettext>
To add a language select it and click the <tt>Add</tt> button.
</dtml-gettext>
</p>
<dtml-let languages=get_languages>
<form action="manage_addLanguage" method="post">
<table>
<tr>
<td>
<select name="language">
<dtml-in get_all_languages mapping sort=name>
<dtml-unless "code in languages">
<option value="<dtml-var code>">
<dtml-var "gettext(name)"> [&dtml-code;]</option>
</dtml-unless>
</dtml-in>
</select>
<input type="submit" value=" <dtml-var "gettext('Add')"> ">
</td>
</tr>
</table>
</form>
</dtml-let>
</fieldset>
<fieldset><legend><dtml-var "gettext('Delete languages')"></legend>
<dtml-let languages=get_languages_mapping>
<dtml-if languages>
<p class="form-help">
<dtml-gettext>
To delete a language check it and click the <tt>Delete</tt> button.
</dtml-gettext>
</p>
<form action="<dtml-var URL1>" method="post">
<table>
<tr>
<th></th>
<th align="left"></th>
</tr>
<dtml-in languages mapping sort=name>
<tr>
<td><input type="checkbox" name="languages:tuple"
value="<dtml-var code>"></td>
<td><dtml-var "gettext(name)"> [<dtml-var code>]</td>
</tr>
</dtml-in>
<tr>
<td></td>
<td>
<input type="submit" name="manage_delLanguages:method"
value=" <dtml-var "gettext('Delete')"> ">
</td>
</tr>
</table>
</form>
<dtml-else>
<em><dtml-gettext>There are no languages</dtml-gettext></em>
</dtml-if>
</dtml-let>
</fieldset>
<fieldset><legend><dtml-var "gettext('Default language')"></legend>
<form action="<dtml-var URL1>" method="post">
<table>
<tr>
<td>
<dtml-gettext>
To change the default language select it and click the
<tt>Change</tt> button.
</dtml-gettext>
</td>
</tr>
<tr>
<td>
<input type="text" name="language" value="<dtml-var get_default_language>">
<input type="submit" name="manage_changeDefaultLang:method"
value=" <dtml-var "gettext('Change')"> ">
</td>
</tr>
</table>
</form>
</fieldset>
<dtml-var manage_page_footer>
product/Localizer/ui/LM_upgrade.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<dtml-if need_upgrade>
<p class="form-help">
<dtml-gettext>
This object must be upgraded.
</dtml-gettext>
</p>
<blockquote>
<form action="manage_upgrade" action="post">
<input type="submit" value=" <dtml-var "gettext('Upgrade')"> ">
</form>
</blockquote>
<dtml-else>
<p class="form-help">
<dtml-gettext>
This object is up-to-date.
</dtml-gettext>
</p>
</dtml-if>
<dtml-var manage_page_footer>
product/Localizer/ui/LPM_properties.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<p class="form-help">
This page allows you to define, edit and delete properties of LocalContent.
To change property values, edit the values and click "Save Changes".
If you want to remove a property select it and click "Delete".
</p>
<dtml-let properties="getLocalProperties()">
<dtml-if properties>
<dtml-let curr_prop="REQUEST.get('prop', properties[0]['id'])"
default_lang="get_default_language()"
curr_value="getLocalAttribute(curr_prop, default_lang)">
<form action="<dtml-var URL1>" method="post" name="frmProperties">
<table cellspacing="0" cellpadding="2" border="0">
<tr class="list-header">
<td align="left" valign="top" width="16">&nbsp;</td>
<td align="left" valign="top">
<div class="form-label"><dtml-var "gettext('Name')"></div>
</td>
<td align="left" valign="top">
<div class="form-label"><dtml-var "gettext('Value')"></div>
</td>
<td align="left" valign="top">
<div class="form-label"><dtml-var "gettext('Type')"></div>
</td>
</tr>
<dtml-in properties mapping>
<tr>
<td align="left" valign="top" width="16">
<input type="checkbox" name="ids:list"
value="<dtml-var id>" id="cb-title">
</td>
<td align="left" valign="top">
<div class="form-label"><label for="cb-title"><dtml-var id></label></div>
</td>
<td align="left" valign="top">
<dtml-if "type == 'string'">
<input type="text" name="<dtml-var id>:utf8:ustring" size="65" value="<dtml-var "getLocalAttribute(id, default_lang)">" />
<dtml-elif "type == 'text'">
<textarea name="<dtml-var id>:utf8:ustring" rows="10" cols="65"><dtml-var "getLocalAttribute(id, default_lang)"></textarea>
</dtml-if>
</td>
<td align="left" valign="top">
<div class="list-item"><dtml-var type></div>
</td>
</tr>
</dtml-in>
<tr>
<td colspan="2"></td>
<td align="left" valign="top">
<div class="form-element">
<input type="hidden" name="code" value="<dtml-var default_lang>" />
<input type="hidden" name="destination" value="manage_localPropertiesForm" />
<input name="manage_editLocalProperty:method" type="submit" class="form-element" value=" <dtml-var "gettext('Save changes')"> " />
<input name="manage_delLocalProperty:method" type="submit" class="form-element" value=" <dtml-var "gettext('Delete')"> " />
</div>
</td>
<td></td>
</tr>
</table>
</form>
</dtml-let>
</dtml-if>
<form action="manage_addLocalProperty" method="post">
<p class="form-help">
To add a new property, enter a name, type and value for the new
property and click the &quot;Add&quot; button.
</p>
<table>
<tr>
<td align="left" valign="top">
<div class="form-label"><dtml-var "gettext('Name')"></div>
</td>
<td align="left" valign="top">
<input type="text" name="id:utf8:ustring" size="30" value=""/>
</td>
<td align="left" valign="top" class="form-label">
<dtml-var "gettext('Type')">
</td>
<td align="left" valign="top">
<div class="form-element">
<select name="type">
<option>string</option>
<option>text</option>
</select>
</div>
</td>
</tr>
<tr>
<td align="left" valign="top">
<div class="form-label"><dtml-var "gettext('Value')"></div>
</td>
<td colspan=2 align="left" valign="top">
<input type="text" name="value:utf8:ustring" size="30" />
</td>
<td align="right" valign="top">
<div class="form-element">
<input class="form-element" type="submit" name="submit" value=" <dtml-var "gettext('Add')"> " />
</div>
</td>
</tr>
</table>
</form>
</dtml-let>
<dtml-var manage_page_footer>
product/Localizer/ui/LPM_translations.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<dtml-comment>
Set here the default values for the REQUEST varibiles used
for the navigation of the web interface
</dtml-comment>
<p class="form-help">
This page allows you to see the properties of LocalContent and translate them.
Select a property and the property value will appear in the default language.
You can navigate throw the property translations by clicking on one of the available
languages. After changing the translation click Save Changes.
</p>
<p class="form-help">
When the property value in the default language changes all the translations become
obsolete and they are marked with <img src="misc_/Localizer/obsolete" border="0" alt="Obsolete translation flag" />.
</p>
<dtml-let languages="get_targetLanguages()"
properties="getLocalProperties()">
<dtml-if languages>
<dtml-if properties>
<dtml-let curr_lang="REQUEST.get('lang', None) or languages[0]['code']"
default_lang="get_default_language()"
curr_prop="REQUEST.get('prop', properties[0]['id'])"
curr_value="getLocalAttribute(curr_prop, curr_lang)">
<table border="0" cellspacing="3" cellpadding="3" width="90%">
<tr>
<td rowspan="2" width="30%">
<textarea cols="65" rows="10" wrap="virtual"
readonly="readonly"><dtml-var "getLocalAttribute(curr_prop, default_lang)" html_quote></textarea>
<br />
<dtml-in languages mapping sort=name>
<dtml-let name="gettext(name)">
<dtml-if "code != get_default_language()">
<a href="?lang=<dtml-var code url_quote>&prop=<dtml-var curr_prop url_quote>">
<dtml-if "code==curr_lang">
<dtml-if "is_obsolete(curr_prop, code)">
<span style="font-weight:bold"><dtml-var name></span>
<img src="misc_/Localizer/obsolete" border="0" alt="Obsolete translation flag" />
<dtml-else>
<span style="font-weight:bold"><dtml-var name></span>
</dtml-if>
<dtml-else>
<dtml-if "is_obsolete(curr_prop, code)">
<dtml-var name><img src="misc_/Localizer/obsolete" border="0" alt="Obsolete translation flag" />
<dtml-else>
<dtml-var name>
</dtml-if>
</dtml-if>
</a>
</dtml-if>
</dtml-let>
</dtml-in>
<form action="<dtml-var URL1>" method="post" name="frmProperties">
<textarea name="value:utf8:ustring" cols="65" rows="10"
wrap="virtual"><dtml-var curr_value html_quote></textarea>
<input type="hidden" name="id" value="<dtml-var curr_prop>" />
<input type="hidden" name="destination" value="manage_transPropertiesForm" />
<input type="hidden" name="code" value="<dtml-var curr_lang>" />
<dtml-if languages>
<input type="submit" name="manage_transLocalProperty:method" value=" <dtml-var "gettext('Save changes')"> " />
</dtml-if>
</form>
</td>
<td valign="top">
<div class="list-header" style="font-weight:bold"> Properties </div>
<dtml-in properties mapping>
<div <dtml-if sequence-even> style="background-color:white"<dtml-elif sequence-odd> style="background-color:#F0F0F0"</dtml-if>>
<a href="?lang=<dtml-var curr_lang url_quote>&prop=<dtml-var id url_quote>">
<dtml-if "id == curr_prop">
<span style="font-weight:bold"><em><dtml-var id></em></span>
<dtml-else>
<dtml-var id>
</dtml-if></a></div>
</dtml-in>
</td>
</tr>
</table>
</dtml-let>
<dtml-else>
There are no properties.
</dtml-if>
<dtml-else>
<p>No languages available, please add them using the
<a href='manage_languages'>Languages</a> tab</p>
</dtml-if>
</dtml-let>
<dtml-var manage_page_footer>
product/Localizer/ui/LocalContent_add.dtml 0 → 100644
View file @ 52146f5e
<dtml-unless management_page_charset>
<dtml-call "REQUEST.set('management_page_charset', 'UTF-8')">
</dtml-unless>
<dtml-var manage_page_header>
<dtml-var "manage_form_title(this(), _,
form_title=gettext('Add Local Content'),
help_product='Localizer',
help_topic='LocalContent_add.stx')">
<p class="form-help">
<dtml-gettext>
A Local Content object provides a storage for multilingual (and
non multilingual) properties. It also helps you keep your content
separated from the logic and the presentation.
</dtml-gettext>
</p>
<form action="manage_addLocalContent" method="post">
<table cellspacing="2">
<tr>
<th align="right"><dtml-var "gettext('Id')"></th>
<td><input type="text" name="id" size="50"></td>
</tr>
<tr>
<th align="right"><dtml-var "gettext('Original language')"></th>
<td><input type="text" size="10" name="sourcelang" value="en"></td>
</tr>
<tr>
<th align="right"><dtml-var "gettext('Target languages')"></th>
<td><input type="text" name="languages:tokens" size="50"
value="<dtml-try><dtml-in "Localizer.get_languages()"><dtml-var sequence-item> </dtml-in><dtml-except></dtml-try>"></td>
</tr>
<tr>
<td></td>
<td><br><input type="submit" value=" <dtml-var "gettext('Add')"> "></td>
</tr>
</table>
</form>
<dtml-var manage_page_footer>
product/Localizer/ui/LocalFolder_add.dtml 0 → 100644
View file @ 52146f5e
<dtml-unless management_page_charset>
<dtml-call "REQUEST.set('management_page_charset', 'UTF-8')">
</dtml-unless>
<dtml-var manage_page_header>
<dtml-var "manage_form_title(this(), _,
form_title=gettext('Add Local Folder'),
help_product='Localizer',
help_topic='LocalFolder_add.stx')">
<p class="form-help">
<dtml-gettext>
A local folder is a generic solution to manage any kind of multingual
objects, files, images, scripts, etc..
</dtml-gettext>
</p>
<form action="manage_addLocalFolder" method="post">
<table>
<tr>
<th align="right"><dtml-var "gettext('Id')"></th>
<td><input type="text" name="id"></td>
</tr>
<tr>
<th align="right"><em><dtml-var "gettext('Title')"></em></th>
<td><input type="text" name="title"></td>
</tr>
<tr>
<th align="right"><dtml-var "gettext('Languages')"></th>
<td><input type="text" name="languages:tokens"
value="<dtml-try><dtml-in "Localizer.get_languages()"><dtml-var sequence-item> </dtml-in><dtml-except>en </dtml-try>"></td>
</tr>
<tr>
<td></td>
<td><input type="submit" value=" <dtml-var "gettext('Add')"> "></td>
</tr>
</table>
</form>
<dtml-var manage_page_footer>
product/Localizer/ui/LocalFolder_attributes.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<dtml-let local_attributes="get_local_attributes()">
<dtml-if local_attributes>
<p class="form-help">
<dtml-gettext>
To delete an attribute check it and click the <tt>Delete</tt> button.
</dtml-gettext>
</p>
<blockquote>
<form action="manage_delAttributes" method="post">
<table>
<dtml-in get_local_attributes>
<tr>
<td>
<input type="checkbox" name="attributes:tuple"
value="<dtml-var sequence-item>">
</td>
<td>
<dtml-var sequence-item>
</td>
</tr>
</dtml-in>
<tr>
<td></td>
<td>
<input type="submit" value=" <dtml-var "gettext('Delete')"> ">
</td>
</tr>
</table>
</form>
</blockquote>
<dtml-else>
<p class="form-help">
<dtml-gettext>There are no attributes</dtml-gettext>
</p>
</dtml-if>
</dtml-let>
<p class="form-help">
<dtml-gettext>
To add an attribute introduce its id and click the <tt>Add</tt> button.
</dtml-gettext>
</p>
<blockquote>
<form action="manage_addAttribute" method="post">
<input type="text" name="id">
<input type="submit" value=" <dtml-var "gettext('Add')"> ">
</form>
</blockquote>
<dtml-var manage_page_footer>
product/Localizer/ui/Localizer_add.dtml 0 → 100644
View file @ 52146f5e
<dtml-unless management_page_charset>
<dtml-call "REQUEST.set('management_page_charset', 'UTF-8')">
</dtml-unless>
<dtml-var manage_page_header>
<dtml-var "manage_form_title(this(), _, form_title=gettext('Add Localizer'),
help_product='Localizer',
help_topic='Localizer_add.stx')">
<p class="form-help">
<dtml-gettext>
A Localizer object lets you customize the language negotiation policy.
It lets you use cookies, the path or any other criteria to select the
user preferred language.
</dtml-gettext>
</p>
<form action="manage_addLocalizer" method="post">
<table>
<tr>
<th align="right"><dtml-var "gettext('Id')"></th>
<td>Localizer</td>
</tr>
<tr>
<th align="right"><em><dtml-var "gettext('Title')"></em></th>
<td><input type="text" name="title"></td>
</tr>
<tr>
<th align="right"><dtml-var "gettext('Languages')"></th>
<td><input type="text" name="languages:tokens" value="en"></td>
</tr>
<tr>
<td></td>
<td><input type="submit" value=" <dtml-var "gettext('Add')"> "></td>
</tr>
</table>
</form>
<dtml-var manage_page_footer>
product/Localizer/ui/Localizer_hook.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<p class="form-help">
<dtml-gettext>
Locale folders are useful to store special multilingual objects like
images and specific logic. If used the <tt>Localizer</tt> object will
transparently add the right locale folder to the url. If you want to
use locale folders check the checkbox, otherwise uncheck it, then click
the <tt>Change</tt> button.
</dtml-gettext>
</p>
<blockquote>
<form action="manage_hook" method="post">
<table>
<tr>
<td>
<input type="checkbox" name="hook"<dtml-if hooked> checked</dtml-if>>
</td>
<td>
<dtml-var "gettext('Use locale folders')">
</td>
</tr>
<tr>
<td></td>
<td><input type="submit" value=" <dtml-var "gettext('Change')"> "></td>
</tr>
</table>
</form>
</blockquote>
<dtml-var manage_page_footer>
\ No newline at end of file
product/Localizer/ui/MC_Export_form.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<fieldset><legend><dtml-var "gettext('Export messages to PO file')"></legend>
<p class="form-help">
<dtml-gettext>
You can export the messages and their translations to PO files. Check
<tt>locale.pot</tt> to get only the messages, without their translations.
Check any other option to get a PO file with the messages and their
translations to the selected language. Then click the <tt>Export</tt>
button.
</dtml-gettext>
</p>
<form action="manage_export" method="post">
<table>
<tr>
<th align="left">
<dtml-var "gettext('File / Language')">
</th>
</tr>
<tr>
<td valign="top">
<select name="x">
<option value="locale.pot" selected>locale.pot</option>
<dtml-in get_languages_mapping mapping sort=name>
<option value="<dtml-var code>"><dtml-var code>.po / <dtml-var "gettext(name)"></option>
</dtml-in>
</select>
</td>
</tr>
<tr>
<td><input type="submit" value=" <dtml-var "gettext('Export')"> "></td>
<td></td>
</tr>
</table>
</form>
</fieldset>
<fieldset><legend><dtml-var "gettext('Export messages to TMX file')"></legend>
<p class="form-help">
<dtml-gettext>
You can export the messages and their translations to TMX level 1 files.
To do that just click the <tt>Export</tt> button.
</dtml-gettext>
</p>
<form action="tmx_export" method="post">
<table>
<tr>
<td><br></td>
<tr>
<td><input type="submit" value=" <dtml-var "gettext('Export')"> "></td>
<td></td>
</tr>
</table>
</form>
</fieldset>
<fieldset><legend><dtml-var "gettext('Export messages to XLIFF file')"></legend>
<p class="form-help">
<dtml-gettext>
You can export the messages and their translations to XLIFF files.
Check any option to get a XLIFF file with the messages and their
translations to the selected language. Then click the <tt>Export</tt>
button.
</dtml-gettext>
</p>
<form action="xliff_export" method="post">
<table border=0 cellpadding="2" cellspacing="2">
<tr>
<td><input type="radio" name="export_all" value="1" checked>Export all messages<br>
<input type="radio" name="export_all" value="0">Export only untranslated messages
for the language you select
</td>
</tr>
<tr>
<th align="left">
<dtml-var "gettext('Target language')">
</th>
</tr>
<tr>
<td valign="top">
<select name="x">
<dtml-in get_languages_mapping mapping sort=name>
<option value="<dtml-var code>"><dtml-var code> / <dtml-var "gettext(name)"></option>
</dtml-in>
</select>
</td>
</tr>
<tr>
<td><input type="submit" value=" <dtml-var "gettext('Export')"> "></td>
<td></td>
</tr>
</table>
</form>
</fieldset>
<dtml-var manage_page_footer>
product/Localizer/ui/MC_Import_form.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<fieldset><legend><dtml-var "gettext('Import translations from PO file')"></legend>
<p class="form-help">
<dtml-gettext>
You can add new messages and translations importing a PO file. Enter the
filename, select the language of the translations and click the
<tt>Import</tt> button.
</dtml-gettext>
</p>
<form action="manage_import" method="post" enctype="multipart/form-data">
<table>
<tr>
<th align="right"><dtml-var "gettext('File')"></th>
<td><input type="file" name="file"></td>
</tr>
<tr>
<th align="right" valign="top"><dtml-var "gettext('Language')"></th>
<td>
<select name="lang">
<dtml-in get_languages_mapping mapping sort=name>
<option value="<dtml-var code>" <dtml-if sequence-start>selected</dtml-if>><dtml-var "gettext(name)"> [&dtml-code;]</option>
</dtml-in>
</select>
</td>
</tr>
<tr>
<th></th>
<td><input type="submit" value=" <dtml-var "gettext('Import')"> "></td>
</tr>
</table>
</form>
</fieldset>
<fieldset><legend><dtml-var "gettext('Import translations from TMX file')"></legend>
<p class="form-help">
<dtml-gettext>
The message catalog also supports importing TMX files. You can add new
messages and translations importing a TMX file in TMX level 1. Enter the
filename and click the
<tt>Import</tt> button.
</dtml-gettext>
</p>
<form action="tmx_import" method="post" enctype="multipart/form-data">
<table>
<tr>
<th align="right"><dtml-var "gettext('How much')"></th>
<td>
<input type="radio" name="howmuch" value="existing" checked>
<dtml-gettext>Import only translations for messages that
exist already</dtml-gettext><br>
<input type="radio" name="howmuch" value="all">
<dtml-gettext>Import all messages</dtml-gettext><br>
<input type="radio" name="howmuch" value="clear">
<dtml-gettext>Clear catalog and import all messages</dtml-gettext>
</td>
</tr>
<tr>
<th align="right"><dtml-var "gettext('File')"></th>
<td><input type="file" name="file"></td>
</tr>
<tr>
<th></th>
<td><input type="submit" value=" <dtml-var "gettext('Import')"> "></td>
</tr>
</table>
</form>
</fieldset>
<fieldset><legend><dtml-var "gettext('Import translations from XLIFF file')"></legend>
<form action="xliff_import" method="post" enctype="multipart/form-data">
<table>
<tr>
<th align="right"><dtml-var "gettext('How much')"></th>
<td>
<input type="radio" name="howmuch" value="existing" checked>
<dtml-gettext>Import only translations for messages that
exist already</dtml-gettext><br>
<input type="radio" name="howmuch" value="all">
<dtml-gettext>Import all messages</dtml-gettext><br>
<input type="radio" name="howmuch" value="clear">
<dtml-gettext>Clear catalog and import all messages</dtml-gettext>
</td>
</tr>
<tr>
<th align="right"><dtml-var "gettext('File')"></th>
<td><input type="file" name="file"></td>
</tr>
<tr>
<th></th>
<td><input type="submit" value=" <dtml-var "gettext('Import')"> "></td>
</tr>
</table>
</form>
</fieldset>
<dtml-var manage_page_footer>
product/Localizer/ui/MC_add.dtml 0 → 100644
View file @ 52146f5e
<dtml-unless management_page_charset>
<dtml-call "REQUEST.set('management_page_charset', 'UTF-8')">
</dtml-unless>
<dtml-var manage_page_header>
<dtml-var "manage_form_title(this(), _,
form_title=gettext('Add Message Catalog'),
help_product='Localizer',
help_topic='MC_add.stx')">
<p class="form-help">
<dtml-gettext>
A message catalog stores messages and its translations to different
languages. It provides the <tt>gettext</tt> method to get the right
translation for a given message. Message catalogs are useful to
translate the application interfaces (labels, buttons, etc..).
</dtml-gettext>
</p>
<form action="manage_addMessageCatalog" method="post">
<table>
<tr>
<th align="right"><dtml-var "gettext('Id')"></th>
<td><input type="text" name="id"></td>
</tr>
<tr>
<th align="right"><em><dtml-var "gettext('Title')"></em></th>
<td><input type="text" name="title"></td>
</tr>
<tr>
<th align="right"><dtml-var "gettext('Original language')"></th>
<td><input type="text" size="10" name="sourcelang" value="en"></td>
</tr>
<tr>
<th align="right"><dtml-var "gettext('Target languages')"></th>
<td><input type="text" name="languages:tokens" value=""></td>
</tr>
<tr>
<th></th>
<td><input type="submit" value=" <dtml-var "gettext('Add')"> "></td>
</tr>
</table>
</form>
<dtml-var manage_page_footer>
product/Localizer/ui/MC_messages.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-let manage_tabs_message="get_tabs_message(REQUEST)">
<dtml-var manage_tabs>
</dtml-let>
<dtml-with "get_namespace(REQUEST)" mapping>
<dtml-if languages>
<!-- OK -->
<table width="100%">
<tr>
<td valign="top">
<dtml-if n_messages>
<form action="<dtml-var URL1>" method="post">
<input type="hidden" name="batch_start:int"
value="<dtml-var batch_start>">
<input type="hidden" name="batch_size:int"
value="<dtml-var batch_size>">
<input type="hidden" name="regex" value="<dtml-var regex>">
<input type="hidden" name="lang" value="<dtml-var language>">
<input type="hidden" name="empty" value="<dtml-var empty>">
<input type="hidden" name="message"
value="<dtml-var message_encoded html_quote>">
<fieldset>
<legend><dtml-var "gettext('Message to translate')"></legend>
<div style="font-family: monospace"><dtml-var message html_quote
></div>
</fieldset>
<fieldset>
<legend><dtml-var "gettext('Note')"></legend>
<input name="note:utf8:ustring" type="text" value="&dtml-note;"
size="55">
</fieldset>
<fieldset>
<legend><dtml-var "gettext('Translations')"></legend>
<dtml-in languages mapping sort=name>
<a href="<dtml-var url>"><dtml-if "code == language"><span style="font-weight: bold"><dtml-var name></span><dtml-else><dtml-var name></dtml-if></a>
&nbsp;
</dtml-in>
<input type="hidden" name="language" value="<dtml-var language>">
<br>
<textarea name="translation:utf8:ustring" cols="65" rows="10"
wrap="off"><dtml-var translation html_quote></textarea>
</fieldset>
<br>
<input type="submit" name="manage_editMessage:method"
value=" <dtml-var "gettext('Save')"> ">
<input type="submit" name="manage_delMessage:method"
value=" <dtml-var "gettext('Delete')"> ">
</form>
<dtml-else>
<dtml-gettext>There are no messages.</dtml-gettext>
<br>
<dtml-in languages mapping>
<a href="<dtml-var url>"><dtml-if "code == language"><span style="font-weight: bold"><dtml-var name></span><dtml-else><dtml-var name></dtml-if></a>
</dtml-in>
</dtml-if>
</td>
<td valign="top" width="300">
<fieldset>
<legend><dtml-var "gettext('Browse the messages')"></legend>
<form action="manage_messages" action="get">
<input type="hidden" name="batch_start:int"
value="<dtml-var batch_start>">
<input type="hidden" name="batch_size:int"
value="<dtml-var batch_size>">
<input type="hidden" name="lang" value="<dtml-var language>">
<input type="hidden" name="empty" value="">
<input type="checkbox" name="empty" <dtml-if empty>checked</dtml-if>>
<dtml-var "gettext('Only untranslated messages')">
<br>
<input type="text" name="regex" value="<dtml-var regex>">
<input type="submit" value=" <dtml-var "gettext('Filter')"> ">
</form>
<dtml-if n_messages>
<br>
<dtml-var "gettext('Results %d-%d of %d') % (batch_start+1, (batch_start+batch_size < n_messages and batch_start+batch_size) or n_messages, n_messages)">
<dtml-if "batch_start > 0">
<a href="<dtml-var previous>"><<</a>
</dtml-if>
<dtml-if "batch_start + batch_size < n_messages">
<a href="<dtml-var next>">>></a>
</dtml-if>
<br>
<table width="100%" cellspacing="0">
<dtml-in messages mapping>
<tr>
<td<dtml-if current> bgcolor="yellow"<dtml-elif sequence-odd> bgcolor="#DDDDDD"</dtml-if>>
<small>
<a href="<dtml-var url>"><dtml-var message size="40" html_quote></a>
</small>
</td>
</tr>
</dtml-in>
</table>
<dtml-else>
<dtml-gettext>There are no messages.</dtml-gettext>
</dtml-if>
</fieldset>
</td>
</tr>
</table>
<!-- EMPTY -->
<dtml-else>
<p>
<dtml-gettext>No languages available, please add them using the
<a href='manage_languages'>Languages</a> tab</dtml-gettext>
</p>
</dtml-if>
</dtml-with>
<dtml-var manage_page_footer>
product/Localizer/ui/MC_properties.dtml 0 → 100644
View file @ 52146f5e
<dtml-var manage_page_header>
<dtml-var manage_tabs>
<p class="form-help">
<dtml-gettext>
With this form you can change the title of the message catalog. The
title also is used as the value of the <tt>Project-Id-Version</tt>
field in the header of the PO files, which are generated when the
message catalog is exported.
</dtml-gettext>
</p>
<blockquote>
<form action="manage_properties" method="post">
<table>
<tr>
<th align="right">
<dtml-var "gettext('Title')">
</th>
<td>
<input type="text" name="title" value="<dtml-var title>">
</td>
</tr>
<tr>
<th></th>
<td>
<input type="submit" value=" <dtml-var "gettext('Save changes')"> ">
</td>
</tr>
</table>
</form>
</blockquote>
<p class="form-help">
<dtml-gettext>
Besides the title the header of a PO file stores more information;
the name and the email address of the last translator, the email
address of the translation team and the charset. The forms below
let you modify this information for each language.
</dtml-gettext>
</p>
<blockquote>
<dtml-in get_languages_mapping mapping>
<h4>
<dtml-var "gettext(name)"> [<dtml-var code>]
</h4>
<blockquote>
<form action="update_po_header" method="post">
<input type="hidden" name="lang" value="<dtml-var code>">
<dtml-with "get_po_header(code)" mapping>
<table>
<tr>
<td align="right"><dtml-var "gettext('Your name')"></td>
<td>
<input type="text" name="last_translator_name" size="30"
value="<dtml-var last_translator_name>">
</td>
</tr>
<tr>
<td align="right"><dtml-var "gettext('Your e-mail address')"></td>
<td>
<input type="text" name="last_translator_email" size="30"
value="<dtml-var last_translator_email>">
</td>
</tr>
<tr>
<td align="right"><dtml-var "gettext('Team e-mail address')"></td>
<td>
<input type="text" name="language_team" size="30"
value="<dtml-var language_team>">
</td>
</tr>
<tr>
<td align="right"><dtml-var "gettext('Charset')"></td>
<td>
<select name="charset">
<dtml-in get_charsets prefix=sequence>
<option value="<dtml-var sequence-item>"
<dtml-if "charset == sequence_item">selected</dtml-if>>
<dtml-var sequence-item>
</option>
</dtml-in>
</select>
</td>
</tr>
<tr>
<td></td>
<td>
<input type="submit"
value=" <dtml-var "gettext('Save changes')"> ">
</td>
</tr>
</table>
</dtml-with>
</form>
</blockquote>
</dtml-in>
</blockquote>
<dtml-var manage_page_footer>
product/Localizer/ui/changeLanguageForm.dtml 0 → 100644
View file @ 52146f5e
<form id="change_language" action="<dtml-var absolute_url>/changeLanguage"
method="post">
<div>
<select name="lang" onchange="javascript:document.getElementById('change_language').submit()">
<dtml-in "context.get_languages_map()" mapping>
<option value="<dtml-var id>"<dtml-if selected> selected="selected"</dtml-if>><dtml-var "gettext(title, id)"></option>
</dtml-in>
</select>
<dtml-comment>
<input type="submit" value="<dtml-var "gettext('Change')">">
</dtml-comment>
</div>
</form>
\ No newline at end of file
product/Localizer/ui/manage_page_header.dtml 0 → 100644
View file @ 52146f5e
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<dtml-call "RESPONSE.setHeader('Content-Type','text/html; charset=UTF-8')">
<title><dtml-var title_or_id></title>
<dtml-let ag="REQUEST.get('HTTP_USER_AGENT', '')"
is_nav4="ag[:9] == 'Mozilla/4' and _.string.find(ag, 'MSIE') < 0"
use_css="REQUEST.get('zmi_use_css', '1')"
zmi_embedded_css="1">
<dtml-if use_css>
<dtml-if is_nav4>
<style type="text/css">
<!--
<dtml-var manage_page_style.css>
-->
</style>
<dtml-else>
<link rel="stylesheet" type="text/css"
href="<dtml-var BASEPATH1>/manage_page_style.css">
</dtml-if>
</dtml-if>
</dtml-let>
</head>
<body bgcolor="#ffffff" link="#000099" alink="#000099" vlink="#000099">
product/Localizer/utils.py 0 → 100644
View file @ 52146f5e
# -*- coding: UTF-8 -*-
# Copyright (C) 2000-2003 Juan David Ibáñez Palomar <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
# Import from itools
from itools import get_abspath
from itools.i18n import AcceptLanguageType, init_language_selector
from itools.gettext import get_domain, register_domain
# Import from Zope
from App.Common import package_home
# Import from Localizer
from patches import get_request
# Package home
ph = package_home(globals())
# Initializes a list with the charsets
charsets = [ x.strip() for x in open(ph + '/charsets.txt').readlines() ]
###########################################################################
# Language negotiation
###########################################################################
def lang_negotiator(available_languages):
"""Receives two ordered lists, the list of user preferred languages and
the list of available languages. Returns the first user pref. language
that is available, if none is available returns None.
"""
request = get_request()
if request is None:
return None
try:
accept = request['AcceptLanguage']
except KeyError:
return None
return accept.select_language(available_languages)
init_language_selector(lang_negotiator)
###########################################################################
# Provide an API to access translations stored as MO files in the 'locale'
# directory.
###########################################################################
class DomainAware(object):
def __init__(self, namespace):
mname = namespace['__name__']
domain = get_abspath('locale', mname=mname)
self.class_domain = domain
register_domain(domain, domain)
def gettext(self, message, language=None):
domain = get_domain(self.class_domain)
if language is None:
languages = domain.get_languages()
language = select_language(languages)
return domain.gettext(message, language)
_ = DomainAware(globals()).gettext
###########################################################################
# Defines strings that must be internationalized
###########################################################################
# Tabs of the management screens
u'Contents'
u'View'
u'Properties'
u'Security'
u'Undo'
u'Ownership'
u'Find'
# Languages (FIXME This will be removed once we upgrade to itools 0.60)
u'Abkhazian'
u'Afar'
u'Afrikaans'
u'Albanian'
u'Amharic'
u'Arabic'
u'Armenian'
u'Assamese'
u'Aymara'
u'Azerbaijani'
u'Bashkir'
u'Basque'
u'Bengali'
u'Bhutani'
u'Bihari'
u'Bislama'
u'Bosnian'
u'Breton'
u'Bulgarian'
u'Burmese'
u'Belarusian'
u'Cambodian'
u'Catalan'
u'Chinese'
u'Chinese/China'
u'Chinese/Taiwan'
u'Cornish'
u'Corsican'
u'Croatian'
u'Czech'
u'Danish'
u'Dutch'
u'Dutch/Belgium'
u'English'
u'English/United Kingdom'
u'English/United States'
u'Esperanto'
u'Estonian'
u'Faroese'
u'Fiji'
u'Finnish'
u'French'
u'French/Belgium'
u'French/Canada'
u'French/France'
u'French/Switzerland'
u'Frisian'
u'Galician'
u'Georgian'
u'German'
u'German/Austria'
u'German/Germany'
u'German/Switzerland'
u'Greek'
u'Greenlandic'
u'Guarani'
u'Gujarati'
u'Hausa'
u'Hebrew'
u'Hindi'
u'Hungarian'
u'Icelandic'
u'Indonesian'
u'Interlingua'
u'Interlingue'
u'Inuktitut'
u'Inupiak'
u'Irish'
u'Italian'
u'Japanese'
u'Javanese'
u'Kannada'
u'Kashmiri'
u'Kazakh'
u'Kinyarwanda'
u'Kirghiz'
u'Kirundi'
u'Korean'
u'Kurdish'
u'Laothian'
u'Latin'
u'Latvian'
u'Lingala'
u'Lithuanian'
u'Luxembourgish'
u'Macedonian'
u'Malagasy'
u'Malay'
u'Malayalam'
u'Maltese'
u'Maori'
u'Marathi'
u'Moldavian'
u'Mongolian'
u'Nauru'
u'Nepali'
u'Northern Saami'
u'Norwegian'
u'Occitan'
u'Oriya'
u'Oromo'
u'Pashto'
u'Persian'
u'Polish'
u'Portuguese'
u'Portuguese/Brazil'
u'Punjabi'
u'Quechua'
u'Rhaeto-Romance'
u'Romanian'
u'Russian'
u'Samoan'
u'Sangho'
u'Sanskrit'
u'Scots Gaelic'
u'Serbian'
u'Serbo-Croatian'
u'Sesotho'
u'Setswana'
u'Shona'
u'Sindhi'
u'Sinhalese'
u'Siswati'
u'Slovak'
u'Slovenian'
u'Somali'
u'Spanish'
u'Spanish/Argentina'
u'Spanish/Colombia'
u'Spanish/Mexico'
u'Spanish/Spain'
u'Sundanese'
u'Swahili'
u'Swedish'
u'Tagalog'
u'Tajik'
u'Tamil'
u'Tatar'
u'Telugu'
u'Thai'
u'Tibetan'
u'Tigrinya'
u'Tonga'
u'Tsonga'
u'Turkish'
u'Turkmen'
u'Twi'
u'Uighur'
u'Ukrainian'
u'Urdu'
u'Uzbek'
u'Vietnamese'
u'Volapuk'
u'Welsh'
u'Wolof'
u'Xhosa'
u'Yiddish'
u'Yoruba'
u'Zhuang'
u'Zulu'
product/Localizer/zgettext.py 0 → 100755
View file @ 52146f5e
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
# Copyright (C) 2001 Andrés Marzal Varo
# Copyright (C) 2001-2002 J. David Ibáñez <jdavid@itaapy.com>
#
# This program 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 3 of the License, or
# (at your option) any later version.
#
# This program 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.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
"""
zgettext.py is a script that parses DTML files and generates .pot and .po
files, and then generates .mo files from the .po files.
Future (XXX):
zgettext should provide a similar interface to xgettext, it just should
detect dtml and zpt files, parse them, and call xgettext for the rest.
another script should do the wrap up to easily create multilingual products,
or maybe we could avoid this and just use make
Anyway, the trend is to levereage the gettext tools as much as posible.
"""
# Import from the Standard Library
from os import listdir, mkdir, remove, system
from os.path import exists, isdir
from re import compile, DOTALL, findall
import sys
from tempfile import mktemp
from time import gmtime, strftime, time
# Import from itools
from itools.handlers import get_handler
from itools.gettext import POFile
# Exceptions
class UnknownStatus(Exception):
pass
def create_mo_files():
for filename in [ x for x in listdir('locale') if x.endswith('.po') ]:
language = filename[:-3]
system('msgfmt locale/%s.po -o locale/%s.mo' % (language, language))
def parse_generic(text, commands=('gettext',)):
"""Search for patterns like: gettext('message').
XXX
Originally it was used to parse Python code, but it fails to parse
some of the Python strings, now xgettext is used instead. So currently
this function is only used to parse DTML and ZPT; probably the regular
expression could be simplified as in DTML and ZPT there're (maybe)
less options for Python strings due to the syntax constrains of these
languages.
"""
r = []
for command in commands:
pattern = command + '\s*\(\s*(\'.*?[^\\\\]\'|\".*?[^\\\\]\")\s*\)'
regex = compile(pattern, DOTALL)
r.extend([ x[1:-1] for x in findall(regex, text) ])
return r
def parse_dtml(text):
"""Extract the messages from a DTML template.
"""
messages = parse_generic(text)
# Search the "<dtml-gettext>message</dtml-gettext>" pattern
regex = compile('<dtml-gettext(.*?)>(.*?)</dtml-gettext>', DOTALL)
for parameters, message in findall(regex, text):
if parameters.find('verbatim') == -1:
message = ' '.join([ x.strip() for x in message.split() ])
messages.append(message)
return messages
def parse_zpt(text):
"""Extract the messages from a ZPT template.
XXX It should be improved to parse the i18n namespace.
"""
return parse_generic(text)
def do_all(filenames, languages):
# Create the locale directory
if not isdir('./locale'):
try:
mkdir('./locale')
except OSError, msg:
sys.stderr.write('Error: Cannot create directory "locale".\n%s\n'
% msg)
sys.exit(1)
# Create the pot file
if not exists('locale/locale.pot'):
f = open('locale/locale.pot', 'w')
f.write("# SOME DESCRIPTIVE TITLE.\n")
f.write("# Copyright (C) YEAR THE PACKAGE'S COPYRIGHT HOLDER\n")
f.write("# This file is distributed under the same license as the PACKAGE package.\n")
f.write("# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.\n")
f.write("#\n")
f.write("#, fuzzy\n")
f.write('msgid ""\n')
f.write('msgstr ""\n')
f.write('"Project-Id-Version: PACKAGE VERSION\\n"\n')
f.write('"POT-Creation-Date: %s\\n"\n' % strftime('%Y-%m-%d %H:%m+%Z',
gmtime(time())))
f.write('"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"\n')
f.write('"Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"\n')
f.write('"Language-Team: LANGUAGE <LL@li.org>\\n"\n')
f.write('"MIME-Version: 1.0\\n"\n')
f.write('"Content-Type: text/plain; charset=CHARSET\\n"\n')
f.write('"Content-Transfer-Encoding: 8bit\\n"\n')
f.close()
# Filter and parse the DTML and ZPT files, the rest will be parsed
# with xgettext.
filenames2 = []
messages = []
for filename in filenames:
filetype = filename.split('.')[-1]
if filetype == 'dtml':
text = open(filename).read()
messages.extend(parse_dtml(text))
elif filetype == 'zpt':
text = open(filename).read()
messages.extend(parse_zpt(text))
else:
filenames2.append(filename)
filenames = []
# Write a PO file with the messages from DTML and ZPT
if messages:
filename = mktemp('.po')
filenames.append(filename)
f = open(filename, 'w')
aux = []
for message in messages:
if message not in aux:
f.write('msgid "%s"\n' % message)
f.write('msgstr ""\n')
f.write('\n')
aux.append(message)
f.close()
# Parse the rest of the files
if filenames2:
po = POFile()
for filename in filenames2:
handler = get_handler(filename)
for source, context, line in handler.get_units():
po.add_unit(filename, source, context, line)
filename = mktemp('.po')
filenames.append(filename)
open(filename, 'w').write(po.to_str())
# Create the POT file
if filenames:
filename = mktemp('.po')
cmd = 'msgcat -s --output-file=%s %s' % (filename, ' '.join(filenames))
system(cmd)
system('msgmerge -U locale/locale.pot %s' % filename)
# Remove temporal files
remove(filename)
for filename in filenames:
remove(filename)
# Generate the PO files
for language in languages:
if exists('./locale/%s.po' % language):
# a .po file already exist, merge it with locale.pot
system('msgmerge -U locale/%s.po locale/locale.pot' % language)
else:
# po doesn't exist, just copy locale.pot
text = open('./locale/locale.pot').read()
open('./locale/%s.po' % language, 'w').write(text)
if __name__ == '__main__':
# Parse the command line
status = 0
files = []
langs = []
for arg in sys.argv[1:]:
if status == 0:
if arg == '-h':
status = 1
elif arg == '-m':
status = 2
elif arg == '-l':
status = 3
else:
files.append(arg)
status = 4
elif status == 1:
status = 'Error'
break
elif status == 2:
status = 'Error'
break
elif status == 3:
langs.append(arg)
status = 5
elif status == 4:
if arg == '-l':
status = 3
else:
files.append(arg)
elif status == 5:
langs.append(arg)
else:
raise UnknownStatus, str(status)
# Action
if status in (0, 1, 3, 'Error'):
# Provide help if the line format is wrong or if the -h modifier
# is provided
print 'Usage:'
print ' zgettext.py -h'
print ' Shows this help message.'
print ' zgettext.py [file file ... file] [-l languages]'
print ' Parses all the specified files, creates the locale'
print ' directory, creates the locale.pot file and the .po'
print ' files of the languages specified.'
print ' zgettxt.py -m'
print ' Compiles all the .po files in the locale directory'
print ' and creates the .mo files.'
print
print 'Examples:'
print ' zgettext.py *.dtml -l ca es en'
print ' zgettext.py -m'
elif status == 2:
create_mo_files()
elif status in (4, 5):
do_all(files, langs)
else:
raise UnknownStatus, str(status)
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7