| -rw-c5601" => [ undef, undef, undef, "euc-kr", "949" ],
#- I have no console font for Thai...
"tis620" => [ undef, undef, "trivial.trans", "tis-620", "874" ],
# UTF-8 encodings here; they differ in the console font mainly.
"utf_am" => [ "Agafari-16", undef, undef, "utf8", undef ],
"utf_ar" => [ "iso06.f16", undef, undef, "utf8", undef ],
"utf_az" => [ "tiso09e", undef, undef, "utf8", undef ],
"utf_cyr1" => [ "UniCyr_8x16", undef, undef, "utf8", undef ],
"utf_cyr2" => [ "koi8-k", undef, undef, "utf8", undef ],
"utf_he" => [ "iso08.f16", undef, undef, "utf8", undef ],
"utf_hy" => [ "arm8", undef, undef, "utf8", undef ],
"utf_ka" => [ "t_geors", undef, undef, "utf8", undef ],
"utf_lo" => [ undef, undef, undef, "utf8", undef ],
"utf_ta" => [ "tamil", undef, undef, "utf8", undef ],
"utf_vi" => [ "tcvn8x16", undef, undef, "utf8", undef ],
"utf_lat8" => [ "iso14.f16", undef, undef, "utf8", undef ],
# default for utf-8 encodings
"unicode" => [ "LatArCyrHeb-16", undef, undef, "utf8", undef ],
);
#- for special cases not handled magically
my %charset2kde_charset = (
gb2312 => 'gb2312.1980-0',
jisx0208 => 'jisx0208.1983-0',
ksc5601 => 'ksc5601.1987-0',
Big5 => 'big5-0',
cp1251 => 'microsoft-cp1251',
utf8 => 'iso10646-1',
tis620 => 'tis620-0',
#- Tamil KDE translations still use TSCII, and KDE know it as iso-8859-1
utf_ta => 'iso8859-1',
);
my @during_install__lang_having_their_LC_CTYPE = qw(ja ko ta);
#- -------------------
sub list {
my (%options) = @_;
my @l = list_langs();
if ($options{exclude_non_installed_langs}) {
@l = grep { -e "/usr/share/locale/$_/LC_CTYPE" } @l;
}
@l;
}
sub l2console_font {
my ($locale) = @_;
my $c = $charsets{l2charset($locale->{lang}) || return} or return;
my ($name, $sfm, $acm) = @$c;
undef $acm if $locale->{utf8};
($name, $sfm, $acm);
}
sub get_kde_lang {
my ($locale, $default) = @_;
#- get it using
#- echo C $(rpm -qp --qf "%{name}\n" /RPMS/kde-i18n-* | sed 's/kde-i18n-//')
my @valid_kde_langs = qw(C af ar az bg ca cs da de el en_GB eo es et fi fr he hu is it ja ko lt lv mt nb nl nn pl pt pt_BR ro ru sk sl sr sv ta th tr uk xh zh_CN.GB2312 zh_TW.Big5);
my %valid_kde_langs; @valid_kde_langs{@valid_kde_langs} = ();
my $valid_lang = sub {
my ($lang) = @_;
#- fast & dirty solution to ensure bad entries do not happen
my %fixlangs = (en => 'C', en_US => 'C', no => 'nb', sp => 'sr',
zh_CN => 'zh_CN.GB2312', zh_SG => 'zh_CN.GB2312', zh_TW => 'zh_TW.Big5', zh_HK => 'zh_TW.Big5');
exists $fixlangs{$lang} ? $fixlangs{$lang} :
exists $valid_kde_langs{$lang} ? $lang :
exists $valid_kde_langs{substr($lang, 0, 2)} ? substr($lang, 0, 2) : '';
};
my $r;
$r ||= $valid_lang->($locale->{lang});
$r ||= find { $valid_lang->($_) } split(':', getlocale_for_lang($locale->{lang}, $locale->{country}));
$r || $default || 'C';
}
sub charset2kde_charset {
my ($charset, $default) = @_;
my $iocharset = ($charsets{$charset} || [])->[3];
my @valid_kde_charsets = qw(big5-0 gb2312.1980-0 iso10646-1 iso8859-1 iso8859-4 iso8859-6 iso8859-8 iso8859-13 iso8859-14 iso8859-15 iso8859-2 iso8859-3 iso8859-5 iso8859-7 iso8859-9 koi8-r koi8-u ksc5601.1987-0 jisx0208.1983-0 microsoft-cp1251 tis620-0);
my %valid_kde_charsets; @valid_kde_charsets{@valid_kde_charsets} = ();
my $valid_charset = sub {
my ($charset) = @_;
#- fast & dirty solution to ensure bad entries do not happen
exists $valid_kde_charsets{$charset} && $charset;
};
my $r;
$r ||= $valid_charset->($charset2kde_charset{$charset});
$r ||= $valid_charset->($charset2kde_charset{$iocharset});
$r ||= $valid_charset->($iocharset);
$r || $default || 'iso10646-1';
}
#- font+size for different charsets; the field [0] is the default,
#- others are overrridens for fixed(1), toolbar(2), menu(3) and taskbar(4)
my %charset2kde_font = (
'C' => [ "Sans,10", "Monospace,10" ],
'iso-8859-1' => [ "Sans,10", "Monospace,10" ],
'iso-8859-2' => [ "Sans,10", "Monospace,10" ],
'iso-8859-7' => [ "Helvetica,12", "courier,10", "Helvetica,11" ],
'iso-8859-9' => [ "Sans,10", "Monospace,10" ],
'iso-8859-15' => [ "Sans,10", "Monospace,10" ],
'iso-8859-13' => [ "Sans,10", "Monospace,10" ],
'jisx0208' => [ "Kochi Mincho,13", "Kochi Gothic,13" ],
'ksc5601' => [ "Baekmuk Gulim,16" ],
'gb2312' => [ "Ar Pl Sungtil Gb,13" ],
'Big5' => [ "Ar Pl Mingti2l Big5,13" ],
'tis620' => [ "Norasi,16", "Norasi,15" ],
'utf_ar' => [ "Kacs_qr,13", "Courier New,13", "Kacs_qr,12" ],
'utf_az' => [ "Nimbus Sans,12", "Nimbus Mono,10", "Nimbus Sans,11" ],
'utf_hy' => [ "Artsounk,12", "Monospace,10", "Artsounk,11" ],
'utf_ta' => [ "Tscu_paranar,14", "Tsc_avarangalfxd,10", "Tscu_paranar,12", ],
#- the following should be changed to better defaults when better fonts
#- get available
'utf_vi' => [ "misc-fixed,13", "misc-fixed,13", "misc-fixed,10", ],
'utf_am' => [ "clearlyu,15" ],
'utf_he' => [ "clearlyu,15" ],
'utf_ka' => [ "clearlyu,15" ],
'utf_lo' => [ "clearlyu,15" ],
'default' => [ "Nimbus Sans,12", "Nimbus Mono,10", "Nimbus Sans,11" ],
);
sub charset2kde_font {
my ($charset, $type) = @_;
my $font = $charset2kde_font{$charset} || $charset2kde_font{default};
my $r = $font->[$type] || $font->[0];
#- the format is "font-name,size,-1,5,0,0,0,0,0,0" I have no idea of the
#- meaning of that "5"...
"$r,-1,5,0,0,0,0,0,0";
}
# this define pango name fonts (like "NimbusSans L") depending
# on the "charset" defined by language array. This allows to selecting
# an appropriate font for each language.
my %charset2pango_font = (
'tis620' => "Norasi 17",
'utf_ar' => "KacstBook 14",
'utf_cyr2' => "URW Bookman L 14",
'utf_he' => "ClearlyU 12",
'utf_hy' => "Artsounk 14",
'utf_ka' => "ClearlyU 14",
'utf_lo' => "ClearlyU 14",
'utf_ta' => "TSCu_Paranar 14",
'utf_vi' => "ClearlyU 14",
'iso-8859-7' => "Kerkis 14",
'jisx0208' => "Sans 18",
#- Nimbus Sans L is missing some chars used by some cyrillic languages,
#- but tose haven't yet DrakX translations; it also misses vietnamese
#- latin chars; all other latin and cyrillic are covered.
'default' => "Nimbus Sans L 12"
);
sub charset2pango_font {
my ($charset) = @_;
$charset2pango_font{exists $charset2pango_font{$charset} ? $charset : 'default'};
}
sub l2pango_font {
my ($lang) = @_;
my $charset = l2charset($lang) or log::l("no charset found for lang $lang!"), return;
my $font = charset2pango_font($charset);
log::l("lang:$lang charset:$charset font:$font sfm:$charsets{$charset}[0]");
if (common::usingRamdisk()) {
if ($charsets{$charset}[0] !~ /lat|koi|UniCyr/) {
install_any::remove_bigseldom_used();
unlink glob_('/usr/share/langs/*'); #- remove langs images
my @generic_fontfiles = qw(/usr/X11R6/lib/X11/fonts/12x13mdk.pcf.gz /usr/X11R6/lib/X11/fonts/18x18mdk.pcf.gz);
#- need to unlink first because the files actually exist (and are void); they must exist
#- because if not, when gtk starts, pango will recompute its cache file and exclude them
unlink($_), install_any::getAndSaveFile($_) foreach @generic_fontfiles;
}
my %pango_modules = (arabic => 'ar|fa|ur', hangul => 'ko', hebrew => 'he|yi', indic => 'hi|bn|ta|te|mr', thai => 'th');
foreach my $module (keys %pango_modules) {
next if $lang !~ /$pango_modules{$module}/;
install_any::remove_bigseldom_used();
my ($pango_modules_dir) = glob('/usr/lib/pango/*/modules');
install_any::getAndSaveFile("$pango_modules_dir/pango-$module-xft.so");
}
}
return $font;
}
sub set {
my ($lang, $translate_for_console) = @_;
#- disable Arabic in install as no (free) fonts are available.
$lang eq 'ar' and $lang='en_US';
exists $langs{$lang} or log::l("lang::set: trying to set to $lang but I don't know it!"), return;
my $dir = "$ENV{SHARE_PATH}/locale";
if (!-e "$dir/$lang" && common::usingRamdisk()) {
@ENV{qw(LANG LC_ALL LANGUAGE LINGUAS)} = ();
my @LCs = qw(LC_ADDRESS LC_COLLATE LC_IDENTIFICATION LC_MEASUREMENT LC_MONETARY LC_NAME LC_NUMERIC LC_PAPER LC_TELEPHONE LC_TIME);
my $charset = during_install__l2charset($lang) || $lang;
#- there are 3 main charsets containing everything for all locales, except LC_CTYPE
#- by default, there is UTF-8.
#- when asked for GB2312 or BIG5, removing the other main charsets
my $main_charset = member($charset, 'GB2312', 'BIG5') ? $charset : 'UTF-8';
#- removing everything
#- except in main charset: only removing LC_CTYPE if it is there
eval { rm_rf($_ eq $main_charset ? "$dir/$_/LC_CTYPE" : "$dir/$_") } foreach all($dir);
if (!-e "$dir/$main_charset") {
#- getting the main charset
mkdir "$dir/$main_charset";
mkdir "$dir/$main_charset/LC_MESSAGES";
install_any::getAndSaveFile("$dir/$main_charset/$_") foreach @LCs, 'LC_MESSAGES/SYS_LC_MESSAGES';
}
mkdir "$dir/$lang";
#- linking to the main charset
symlink "../$main_charset/$_", "$dir/$lang/$_" foreach @LCs, 'LC_MESSAGES';
#- getting LC_CTYPE (putting it directly in $lang)
install_any::getAndSaveFile("Mandrake/mdkinst$dir/$charset/LC_CTYPE", "$dir/$lang/LC_CTYPE");
}
#- set all LC_* variables to a unique locale ("C"), and only redefine
#- LC_CTYPE (for X11 choosing the fontset) and LANGUAGE (for the po files)
$ENV{$_} = 'C' foreach qw(LC_NUMERIC LC_TIME LC_COLLATE LC_MONETARY LC_PAPER LC_NAME LC_ADDRESS LC_TELEPHONE LC_MEASUREMENT LC_IDENTIFICATION);
$ENV{LC_CTYPE} = $lang;
$ENV{LC_MESSAGES} = $lang;
$ENV{LANG} = $lang;
if ($translate_for_console && $lang =~ /^(ko|ja|zh|th)/) {
log::l("not translating in console");
$ENV{LANGUAGE} = 'C';
} else {
$ENV{LANGUAGE} = getLANGUAGE($lang);
}
load_mo();
$lang;
}
sub langs {
my ($l) = @_;
$l->{all} ? list_langs() : grep { $l->{$_} } keys %$l;
}
sub langsLANGUAGE {
my ($l, $c) = @_;
uniq(map { split ':', getLANGUAGE($_, $c) } langs($l));
}
sub langs_selected {
my ($locale) = @_;
#- adding the UTF-8 flag (if not forced) depends on the selected languages
$locale->{utf8} ||= l2charset($locale->{lang}) =~ /utf|unicode/
|| (uniq map { l2charset($_) } langs($locale->{langs})) > 1;
}
sub pack_langs {
my ($l) = @_;
my $s = $l->{all} ? 'all' : join ':', uniq(map { getLANGUAGE($_) } langs($l));
$ENV{RPM_INSTALL_LANG} = $s;
$s;
}
sub system_locales_to_ourlocale {
my ($locale_lang, $locale_country) = @_;
my $locale;
if (member($locale_lang, list_langs())) {
#- special lang's such as en_US pt_BR
$locale->{lang} = $locale_lang;
} else {
($locale->{lang}) = $locale_lang =~ /^(..)/;
}
($locale->{country}) = $locale_country =~ /^.._(..)/;
$locale->{utf8} = $locale_lang =~ /UTF-8/;
#- safe fallbacks
$locale->{lang} ||= 'en_US';
$locale->{country} ||= 'US';
$locale;
}
sub read {
my ($prefix, $user_only) = @_;
my ($f1, $f2) = ("$prefix$ENV{HOME}/.i18n", "$prefix/etc/sysconfig/i18n");
my %h = getVarsFromSh($user_only && -e $f1 ? $f1 : $f2);
system_locales_to_ourlocale($h{LC_MESSAGES} || 'en_US', $h{LC_MONETARY} || 'en_US');
}
sub write_langs {
my ($prefix, $langs) = @_;
my $s = pack_langs($langs);
symlink "$prefix/etc/rpm", "/etc/rpm" if $prefix;
substInFile { s/%_install_langs.*//; $_ .= "%_install_langs $s\n" if eof && $s } "$prefix/etc/rpm/macros";
}
sub write {
my ($prefix, $locale, $user_only, $dont_touch_kde_files) = @_;
$locale && $locale->{lang} or return;
my $locale_lang = getlocale_for_lang($locale->{lang}, $locale->{country}, $locale->{utf8});
my $locale_country = getlocale_for_country($locale->{lang}, $locale->{country}, $locale->{utf8});
my $h = {
XKB_IN_USE => '',
(map { $_ => $locale_lang } qw(LANG LC_COLLATE LC_CTYPE LC_MESSAGES LC_TIME)),
LANGUAGE => getLANGUAGE($locale->{lang}, $locale->{country}, $locale->{utf8}),
(map { $_ => $locale_country } qw(LC_NUMERIC LC_MONETARY LC_ADDRESS LC_MEASUREMENT LC_NAME LC_PAPER LC_IDENTIFICATION LC_TELEPHONE))
};
log::l("lang::write: lang:$locale->{lang} country:$locale->{country} locale|lang:$locale_lang locale|country:$locale_country language:$h->{LANGUAGE}");
my ($name, $sfm, $acm) = l2console_font($locale);
if ($name && !$user_only) {
my $p = "$prefix/usr/lib/kbd";
if ($name) {
eval {
cp_af("$p/consolefonts/$name.psf.gz", "$prefix/etc/sysconfig/console/consolefonts");
add2hash $h, { SYSFONT => $name };
};
$@ and log::l("missing console font $name");
}
if ($sfm) {
eval {
cp_af(glob_("$p/consoletrans/$sfm*"), "$prefix/etc/sysconfig/console/consoletrans");
add2hash $h, { UNIMAP => $sfm };
};
$@ and log::l("missing console unimap file $sfm");
}
if ($acm) {
eval {
cp_af(glob_("$p/consoletrans/$acm*"), "$prefix/etc/sysconfig/console/consoletrans");
add2hash $h, { SYSFONTACM => $acm };
};
$@ and log::l("missing console acm file $acm");
}
}
add2hash $h, $xim{$locale_lang};
#- deactivate translations on console for RTL languages
if ($locale_lang =~ /ar|fa|he|ur|yi/) {
add2hash $h, { CONSOLE_NOT_LOCALIZED => 'yes' }
}
setVarsInSh($prefix . ($user_only ? "$ENV{HOME}/.i18n" : '/etc/sysconfig/i18n'), $h);
eval {
my $charset = l2charset($locale->{lang});
my $confdir = $prefix . ($user_only ? "$ENV{HOME}/.kde" : '/usr') . '/share/config';
my ($prev_kde_charset) = cat_("$confdir/kdeglobals") =~ /^Charset=(.*)/mi;
mkdir_p($confdir);
update_gnomekderc("$confdir/kdeglobals", Locale => (
Charset => charset2kde_charset($charset),
Country => lc($locale->{country}),
Language => get_kde_lang($locale),
));
my %qt_xim = (zh => 'Over The Spot', ko => 'On The Spot', ja => 'Over The Spot');
if ($user_only && (my $qt_xim = $qt_xim{substr($locale->{lang}, 0, 2)})) {
update_gnomekderc("$ENV{HOME}/.qt/qtrc", General => (XIMInputStyle => $qt_xim));
}
if ($prev_kde_charset ne charset2kde_charset($charset)) {
update_gnomekderc("$confdir/kdeglobals", WM => (
activeFont => charset2kde_font($charset,0),
));
update_gnomekderc("$confdir/kdeglobals", General => (
fixed => charset2kde_font($charset, 1),
font => charset2kde_font($charset, 0),
menuFont => charset2kde_font($charset, 3),
taskbarFont => charset2kde_font($charset, 4),
toolBarFont => charset2kde_font($charset, 2),
));
update_gnomekderc("$confdir/konquerorrc", FMSettings => (
StandardFont => charset2kde_font($charset, 0),
));
update_gnomekderc("$confdir/kdesktoprc", FMSettings => (
StandardFont => charset2kde_font($charset, 0),
));
}
} if !$dont_touch_kde_files;
}
sub bindtextdomain() {
my $localedir = "$ENV{SHARE_PATH}/locale";
$localedir .= "_special" if $::isInstall;
c::setlocale();
c::bind_textdomain_codeset('libDrakX', 'UTF-8');
$::need_utf8_i18n = 1;
c::bindtextdomain('libDrakX', $localedir);
$localedir;
}
sub load_mo {
my ($lang) = @_;
my $localedir = bindtextdomain();
my $suffix = 'LC_MESSAGES/libDrakX.mo';
$lang ||= $ENV{LANGUAGE} || $ENV{LC_ALL} || $ENV{LC_MESSAGES} || $ENV{LANG};
foreach (split ':', $lang) {
my $f = "$localedir/$_/$suffix";
-s $f and return $_;
if ($::isInstall && common::usingRamdisk()) {
#- cleanup
eval { rm_rf($localedir) };
eval { mkdir_p(dirname("$localedir/$_/$suffix")) };
install_any::getAndSaveFile("$localedir/$_/$suffix");
-s $f and return $_;
}
}
'';
}
#- used in Makefile during "make get_needed_files"
sub console_font_files {
map { -e $_ ? $_ : "$_.gz" }
(map { "/usr/lib/kbd/consolefonts/$_.psf" } uniq grep { $_ } map { $_->[0] } values %charsets),
(map { -e $_ ? $_ : "$_.sfm" } map { "/usr/lib/kbd/consoletrans/$_" } uniq grep { $_ } map { $_->[1] } values %charsets),
(map { -e $_ ? $_ : "$_.acm" } map { "/usr/lib/kbd/consoletrans/$_" } uniq grep { $_ } map { $_->[2] } values %charsets),
}
sub load_console_font {
my ($locale) = @_;
my ($name, $sfm, $acm) = l2console_font($locale);
require run_program;
run_program::run(if_($ENV{LD_LOADER}, $ENV{LD_LOADER}),
'consolechars', '-v', '-f', $name || 'lat0-sun16',
if_($sfm, '-u', $sfm), if_($acm, '-m', $acm));
#- in console mode install, ensure we'll get translations in the right codeset
#- (charset of locales reported by the glibc are UTF-8 during install)
if ($acm) {
c::bind_textdomain_codeset('libDrakX', l2charset($locale->{lang}));
$::need_utf8_i18n = 0;
}
}
sub fs_options {
my ($locale) = @_;
if ($locale->{utf8}) {
('utf8', undef);
} else {
my $c = $charsets{l2charset($locale->{lang}) || return} or return;
my ($iocharset, $codepage) = @$c[3..4];
$iocharset, $codepage;
}
}
sub during_install__l2charset {
my ($lang) = @_;
return if member($lang, @during_install__lang_having_their_LC_CTYPE);
my ($c) = l2charset($lang) or die "bad lang $lang\n";
$c = 'UTF-8' if member($c, 'tis620', 'C');
$c = 'UTF-8' if $c =~ /koi8-/;
$c = 'UTF-8' if $c =~ /iso-8859/;
$c = 'UTF-8' if $c =~ /cp125/;
$c = 'UTF-8' if $c =~ /utf_/;
uc($c);
}
sub get_unneeded_png_lang_files {
print join(' ', map { m|(langs/lang-(.*)\.png)|; if_(!member($2, list_langs()), $1) } glob("pixmaps/langs/lang-*.png"));
}
sub check {
$^W = 0;
my $ok = 1;
my $warn = sub {
print STDERR "$_[0]\n";
};
my $err = sub {
&$warn;
$ok = 0;
};
my @wanted_charsets = uniq map { l2charset($_) } list_langs();
print "\tWarnings:\n";
$warn->("unused charset $_ (given in \%charsets, but not used in \%langs)") foreach difference2([ keys %charsets ], \@wanted_charsets);
$warn->("unused entry $_ in \%xim") foreach grep { !/UTF-8/ } difference2([ keys %xim ], [ map { l2locale($_) } list_langs() ]);
#- consolefonts are checked during build via console_font_files()
if (my @l = difference2([ 'default', keys %charsets ], [ keys %charset2kde_font ])) {
$warn->("no kde font for charset " . join(" ", @l));
}
if (my @l = grep { get_kde_lang({ lang => $_, country => 'US' }, 'err') eq 'err' } list_langs()) {
$warn->("no KDE lang for langs " . join(" ", @l));
}
if (my @l = grep { charset2kde_charset($_, 'err') eq 'err' } keys %charsets) {
$warn->("no KDE charset for charsets " . join(" ", @l));
}
$warn->("no country corresponding to default locale $_->[1] of lang $_->[0]")
foreach grep { $_->[1] =~ /^.._(..)/ && !exists $countries{$1} } map { [ $_, l2locale($_) ] } list_langs();
print "\tErrors:\n";
$err->("invalid charset $_ ($_ does not exist in \%charsets)") foreach difference2(\@wanted_charsets, [ keys %charsets ]);
$err->("invalid charset $_ in \%charset2kde_font ($_ does not exist in \%charsets)") foreach difference2([ keys %charset2kde_font ], [ 'default', keys %charsets ]);
$err->("default locale $_->[1] of lang $_->[0] isn't listed in \@locales")
foreach grep { !member($_->[1], @locales) } map { [ $_, l2locale($_) ] } list_langs();
$err->("lang image for lang $_->[0] is missing (file $_->[1])")
foreach grep { !(-e $_->[1]) } map { [ $_, "pixmaps/langs/lang-$_.png" ] } list_langs();
$err->("default locale $_->[1] of country $_->[0] isn't listed in \@locales")
foreach grep { !member($_->[1], @locales) } map { [ $_, c2locale($_) ] } list_countries();
exit($ok ? 0 : 1);
}
1;
|