Free locale files for south africa software for linux

Locale files for South Africa project are scripts to aid in localization of software. Deals with conversion between different translation formats (such as gettext-based .po formats, OpenOffice.org formats, and Mozilla formats). Also tools to help process localizations etc.
Translate.org.za is a non-profit organisation producing Free and Open Source software that enables and empowers South Africans.
The Translate Project started in 2001 with the vision of providing Free Software translated into the 11 official languages of South Africa. Free Software in your language is true empowerment.
Enhancements:
- The international dialing code has been changed from 09 to 00.

Edit Config Files is an extension that allows you to edit config files.

Edit configuration files with your favorite editor from Toolbar or Tools menu.

Remove the menu icon

Add the following to userChrome.css:

#editconfigfiles-menu
{
list-style-image:none !important;
}

International Components for Unicode provides a Unicode implementation, with functions for formatting numbers, dates, times, and currencies (according to locale conventions, transliteration, and parsing text in those formats).
It provides flexible patterns for formatting messages, where the pattern determines the order of the variable parts of the messages, and the format for each of those variables. These patterns can be stored in resource files for translation to different languages. Included are more than 100 codepage converters for interaction with non-unicode systems.
Main features:
- Text: Unicode text handling, full character properties and character set conversions (500+ code pages)
- Analysis: Unicode regular expressions; full Unicode sets; character, word and line boundaries
- Comparison: language sensitive collation and searching
- Transformations: normalization, upper/lowercase, script transliterations (50+ pairs)
- Locales: comprehensive data (230+) & resource bundle architecture
- Complex Text Layout: Arabic, Hebrew, Indic and Thai
- Formatting and Parsing: multi-calendar and time zone,dates, times, numbers, currencies, messages
Enhancements:
- This is a major release, with new features, new APIs, and many bugfixes in data and code.
- ICU uses and supports Unicode 5.0, which is the latest major release of Unicode.
- CU uses and supports data from Common Locale Data Repository (CLDR) 1.4, which includes many improvements in quality and quantity of data.
- A charset detection framework was added, which provides heuristics for detecting the charset for unlabeled sequences of bytes.
- Other performance and feature enhancements were added.

X-Files KDM Theme is a login screen for KDE desktop manager with a nice X-Files background.

Locale::Messages is a Perl module with Gettext Like Message Retrieval.

SYNOPSIS

use Locale::Messages (:locale_h :libintl_h);

gettext $msgid;
dgettext $textdomain, $msgid;
dcgettext $textdomain, $msgid, LC_MESSAGES;
ngettext $msgid, $msgid_plural, $count;
dngettext $textdomain, $msgid, $msgid_plural, $count;
dcngettext $textdomain, $msgid, $msgid_plural, $count, LC_MESSAGES;
textdomain $textdomain;
bindtextdomain $textdomain, $directory;
bind_textdomain_codeset $textdomain, $encoding;
bind_textdomain_filter $textdomain, &filter, $data;
turn_utf_8_on ($variable);
turn_utf_8_off ($variable);
nl_putenv (OUTPUT_CHARSET=koi8-r);
my $category = LC_CTYPE;
my $category = LC_NUMERIC;
my $category = LC_TIME;
my $category = LC_COLLATE;
my $category = LC_MONETARY;
my $category = LC_MESSAGES;
my $category = LC_ALL;

The module Locale::Messages is a wrapper around the interface to message translation according to the Uniforum approach that is for example used in GNU gettext and Suns Solaris. It is intended to allow Locale::Messages(3) to switch between different implementations of the lower level libraries but this is not yet implemented.

Normally you should not use this module directly, but the high level interface Locale::TextDomain(3) that provides a much simpler interface. This description is therefore deliberately kept brief. Please refer to the GNU gettext documentation available at http://www.gnu.org/manual/gettext/ for in-depth and background information on the topic.
The lower level module Locale::gettext_pp(3) provides the Perl implementation of gettext() and related functions.

Locale::TextDomain is a Perl Interface to Uniforum Message Translation.

SYNOPSIS

use Locale::TextDomain (my-package, @locale_dirs);

use Locale::TextDomain qw (my-package);

my $translated = __"Hello World!n";

my $alt = $__{"Hello World!n"};

my $alt2 = $__->{"Hello World!n"};

my @list = (N__"Hello", N__"World");

my @plurals = (N__ ("One world", "{num} worlds"),
N__ ("1 file", "%d files"));

my $question = __x ("Error reading file {file}: {err}",
file => $file, err => $!);

printf (__n ("one file read",
"%d files read",
$num_files),
$num_files);

print __nx ("one file read", "{num} files read", $num_files,
num => $num_files);

The module Locale::TextDomain(3pm) provides a high-level interface to Perl message translation.

Textdomains

When your request a translation for a given string, the system used in libintl-perl follows a standard strategy to find a suitable message catalog containing the translation: Unless you explicitely define a name for the message catalog, libintl-perl will assume that your catalog is called messages (unless you have changed the default value to something else via Locale::Messages(3pm), method textdomain()).
You might think that his default strategy leaves room for optimization and you are right. It would be a lot smarter if multiple software packages, all with their individual message catalogs, could be installed on one system, and it should also be possible that third-party components of your software (like Perl modules) can load their message catalogs, too, without interfering with yours.

The solution is clear, you have to assign a unique name to your message database, and you have to specify that name at run-time. That unique name is the so-called textdomain of your software package. The name is actually arbitrary but you should follow these best-practice guidelines to ensure maximum interoperability:

File System Safety

In practice, textdomains get mapped into file names, and you should therefore make sure that the textdomain you choose is a valid filename on every system that will run your software.

Case-sensitivity

Textdomains are always case-sensitive (i. e. Package and PACKAGE are not the same). However, since the message catalogs will be stored on file systems, that may or may not distinguish case when looking up file names, you should avoid potential conflicts here.

Textdomain Should Match CPAN Name

If your software is listed as a module on CPAN, you should simply choose the name on CPANS as your textdomain. The textdomain for libintl-perl is hence libintl-perl. But please replace all periods (.) in your package name with an underscore because ...

Internet Domain Names as a Fallback

... if your software is not a module listed on CPAN, as a last resort you should use the Java(tm) package scheme, i. e. choose an internet domain that you are owner of (or ask the owner of an internet domain) and concatenate your preferred textdomain with the reversed internet domain. Example: Your company runs the web-site www.foobar.org and is the owner of the domain foobar.org. The textdomain for your companys software barfoos should hence be org.foobar.barfoos.

If your software is likely to be installed in different versions on the same system, it is probably a good idea to append some version information to your textdomain.
Other systems are less strict with the naming scheme for textdomains but the phenomena known as Perl is actually a plethora of small, specialized modules and it is probably wisest to postulate some namespace model in order to avoid chaos.

Binding textdomains to directories

Once the system knows the textdomain of the message that you want to get translated into the users language, it still has to find the correct message catalog. By default, libintl-perl will look up the string in the translation database found in the directories /usr/share/locale and /usr/local/share/locale (in that order).

It is neither guaranteed that these directories exist on the target machine, nor can you be sure that the installation routine has write access to these locations. You can therefore instruct libintl-perl to search other directories prior to the default directories. Specifying a differnt search directory is called binding a textdomain to a directory.

Locale::TextDomain extends the default strategy by a Perl specific approach. Unless told otherwise, it will look for a directory LocaleData in every component found in the standard include path @INC and check for a database containing the message for your textdomain there. Example: If the path /usr/lib/perl/5.8.0/site_perl is in your @INC, you can install your translation files in /usr/lib/perl/5.8.0/site_perl/LocaleData, and they will be found at run-time.

Locale::KeyedText is a Perl module that refers to user messages in programs by keys.

It also describes the same-number versions of Locale::KeyedText::Message ("Message") and Locale::KeyedText::Translator ("Translator").

Note that the "Locale::KeyedText" package serves only as the name-sake representative for this whole file, which can be referenced as a unit by documentation or use statements or Perl archive indexes. Aside from use statements, you should never refer directly to "Locale::KeyedText" in your code; instead refer to other above-named packages in this file.

SYNOPSIS

use Locale::KeyedText;

main();

sub main {
# Create a translator.
my $translator = Locale::KeyedText::Translator->new({
set_names => [MyLib::Lang::, MyApp::Lang::],
# set package prefixes for localized app components
member_names => [Eng, Fr, De, Esp],
# set list of available languages in order of preference
});

# This will print Enter 2 Numbers in the first of the four
# languages that has a matching template available.
print $translator->translate_message(
Locale::KeyedText::Message->new({
msg_key => MYAPP_PROMPT }) );

# Read two numbers from the user.
my ($first, $second) = ;

# Print a statement giving the operands and their sum.
MyLib->add_two( $first, $second, $translator );
}

package MyLib; # module

sub add_two {
my (undef, $first, $second, $translator) = @_;
my $sum = $first + $second;

# This will print plus equals in
# the first possible language. For example, if the user
# inputs 3 and 4, it the output will be 3 plus 4 equals 7.
print $translator->translate_message(
Locale::KeyedText::Message->new({ msg_key => MYLIB_RESULT,
msg_vars => { FIRST => $first, SECOND => $second,
RESULT => $sum } }) );
}

Many times during a programs operation, the program (or a package it uses) will need to display a message to the user, or generate a message to be shown to the user. Sometimes this is an error message of some kind, but it could also be a prompt or response message for interactive systems.

If the program or any of its components are intended for widespread use then it needs to account for a variance of needs between its different users, such as their preferred language of communication, or their privileges regarding access to information details, or their technical skills. For example, a native French or Chinese speaker often prefers to communicate in those languages. Or, when viewing an error message, the applications developer should see more details than joe public would.

Alternately, sometimes a program will raise a condition or error that, while resembling a message that would be shown to a user, is in fact meant to be interpreted by the machine itself and not any human user. In some situations, a shared program component may raise such a condition, and one application may handle it internally, while another one displays it to the user instead.

Locale::KeyedText provides a simple but effective mechanism for applications and packages that empowers single binaries to support N locales or user types simultaneously, and that allows any end users to add support for new languages easily and without a recompile (such as by simply copying files), often even while the program is executing.

Locale::KeyedText gives your application the maximum amount of control as to what the user sees; it never outputs anything by itself to the user, but rather returns its results for calling code to output as it sees fit. It also does not make direct use of environment variables, which can aid in portability.

Practically speaking, Locale::KeyedText doesnt actually do a lot internally; it exists mainly to document a certain localization methodology in an easily accessable manner, such that would not be possible if its functionality was subsumed into a larger package that would otherwise use it. Hereafter, if any other package or application says that it uses Locale::KeyedText, that is a terse way of saying that it subscribes to the localization methodology that is described here, and hence provides these benefits to developers and users alike.

For some practical examples of Locale::KeyedText in use, see the /examples directory of this distribution. Or, see my dependent CPAN packages whose problem domain is databases and/or SQL.

Locale::Maketext::Lexicon::Msgcat is a Msgcat catalog parser Maketext.

SYNOPSIS

package Hello::I18N;
use base Locale::Maketext;
use Locale::Maketext::Lexicon {
en => [Msgcat, en_US/hello.pl.m],
};

package main;
my $lh = Hello::I18N->get_handle(en);
print $lh->maketext(1,2); # set 1, msg 2
print $lh->maketext("1,2"); # same thing

This module parses one or more Msgcat catalogs in plain text format, and returns a Lexicon hash, which may be looked up either with a two-argument form ($set_id, $msg_id) or as a single string ("$set_id,$msg_id").