You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
281 lines
9.6 KiB
281 lines
9.6 KiB
#
|
|
# language.py: install data component that stores information about both
|
|
# installer runtime language choice and installed system
|
|
# language support.
|
|
#
|
|
# Copyright (C) 2001, 2002, 2003, 2004, 2005, 2009 Red Hat, Inc.
|
|
# All rights reserved.
|
|
#
|
|
# 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 2 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 os
|
|
import string
|
|
import locale
|
|
|
|
import gettext
|
|
from simpleconfig import SimpleConfigFile
|
|
import system_config_keyboard.keyboard as keyboard
|
|
|
|
import logging
|
|
log = logging.getLogger("anaconda")
|
|
|
|
# Converts a single language into a "language search path". For example,
|
|
# fr_FR.utf8@euro would become "fr_FR.utf8@eueo fr_FR.utf8 fr_FR fr"
|
|
def expandLangs(astring):
|
|
langs = [astring]
|
|
charset = None
|
|
base = None
|
|
|
|
# remove charset ...
|
|
if '.' in astring:
|
|
langs.append(string.split(astring, '.')[0])
|
|
|
|
if '@' in astring:
|
|
charset = string.split(astring, '@')[1]
|
|
|
|
if '_' in astring:
|
|
base = string.split(astring, '_')[0]
|
|
|
|
if charset:
|
|
langs.append("%s@%s" % (base, charset))
|
|
|
|
langs.append(base)
|
|
else:
|
|
langs.append(astring[:2])
|
|
|
|
return langs
|
|
|
|
class Language(object):
|
|
def _setInstLang(self, value):
|
|
# Always store in its full form so we know what we're comparing with.
|
|
try:
|
|
self._instLang = self._canonLang(value)
|
|
except ValueError:
|
|
# If the language isn't listed in lang-table, we won't know what
|
|
# keyboard/font/etc. to use. However, we can still set the $LANG
|
|
# to that and make sure it works in the installed system.
|
|
self._instLang = value
|
|
|
|
# If we're running in text mode, value may not be a supported language
|
|
# to display. We need to default to en_US.UTF-8 for now.
|
|
if self.displayMode == 't':
|
|
for (lang, info) in self.localeInfo.iteritems():
|
|
# If there's no font, it's not a supported language.
|
|
if lang == self._instLang and info[2] == "none":
|
|
self._instLang = self._default
|
|
break
|
|
|
|
# Now set some things to make sure the language setting takes effect
|
|
# right now.
|
|
os.environ["LANG"] = self._instLang
|
|
os.environ["LC_NUMERIC"] = "C"
|
|
|
|
try:
|
|
locale.setlocale(locale.LC_ALL, "")
|
|
except locale.Error:
|
|
pass
|
|
|
|
# XXX: oh ick. this is the sort of thing which you should never do...
|
|
# but we switch languages at runtime and thus need to invalidate
|
|
# the set of languages/mofiles which gettext knows about
|
|
gettext._translations = {}
|
|
|
|
def _getInstLang(self):
|
|
# If we were given a language that's not in lang-table, lie and say
|
|
# we're using the default. This prevents us from having to check all
|
|
# over the place. Unfortunately, it also means anaconda will be
|
|
# running with the wrong font and keyboard in these cases.
|
|
if self._instLang in self.localeInfo.keys():
|
|
return self._instLang
|
|
else:
|
|
return self._default
|
|
|
|
# The language being displayed while anaconda is running.
|
|
instLang = property(lambda s: s._getInstLang(), lambda s, v: s._setInstLang(v))
|
|
|
|
def _setSystemLang(self, value):
|
|
# Always store in its full form so we know what we're comparing with.
|
|
try:
|
|
self._systemLang = self._canonLang(value)
|
|
except ValueError:
|
|
# If the language isn't listed in lang-table, we won't know what
|
|
# keyboard/font/etc. to use. However, we can still set the $LANG
|
|
# to that and make sure it works in the installed system.
|
|
self._systemLang = value
|
|
|
|
# Now set a bunch of other things that'll get written to
|
|
# /etc/sysconfig/i18n on the installed system.
|
|
self.info["LANG"] = self._systemLang
|
|
|
|
if not self.localeInfo.has_key(self._systemLang):
|
|
return
|
|
|
|
if self.localeInfo[self._systemLang][2] == "none":
|
|
self.info["SYSFONT"] = None
|
|
else:
|
|
self.info["SYSFONT"] = self.localeInfo[self._systemLang][2]
|
|
|
|
# XXX hack - because of exceptional cases on the var - zh_CN.GB2312
|
|
if self._systemLang == "zh_CN.GB18030":
|
|
self.info["LANGUAGE"] = "zh_CN.GB18030:zh_CN.GB2312:zh_CN"
|
|
|
|
# The language to use on the installed system. This can differ from the
|
|
# language being used during anaconda. For instance, text installs cannot
|
|
# display all languages (CJK, Indic, etc.).
|
|
systemLang = property(lambda s: s._systemLang, lambda s, v: s._setSystemLang(v))
|
|
|
|
def __init__ (self, display_mode = 'g'):
|
|
self._default = "en_US.UTF-8"
|
|
self.displayMode = display_mode
|
|
self.info = {}
|
|
self.localeInfo = {}
|
|
self.nativeLangNames = {}
|
|
|
|
# English name -> native name mapping
|
|
search = ('lang-names', '/usr/lib/anaconda/lang-names')
|
|
for path in search:
|
|
if os.access(path, os.R_OK):
|
|
f = open(path, 'r')
|
|
for line in f.readlines():
|
|
lang, native = string.split(line, '\t')
|
|
native = native.strip()
|
|
self.nativeLangNames[lang] = native
|
|
|
|
f.close()
|
|
break
|
|
|
|
# nick -> (name, short name, font, keyboard, timezone) mapping
|
|
search = ('lang-table', '/tmp/updates/lang-table', '/etc/lang-table',
|
|
'/usr/lib/anaconda/lang-table')
|
|
for path in search:
|
|
if os.access(path, os.R_OK):
|
|
f = open(path, "r")
|
|
for line in f.readlines():
|
|
string.strip(line)
|
|
l = string.split(line, '\t')
|
|
|
|
# throw out invalid lines
|
|
if len(l) < 6:
|
|
continue
|
|
|
|
self.localeInfo[l[3]] = (l[0], l[1], l[2], l[4], string.strip(l[5]))
|
|
|
|
f.close()
|
|
break
|
|
|
|
# Hard code this to prevent errors in the build environment.
|
|
self.localeInfo['C'] = self.localeInfo[self._default]
|
|
|
|
# instLang must be set after localeInfo is populated, in case the
|
|
# current setting is unsupported by anaconda..
|
|
self.instLang = os.environ.get("LANG", self._default)
|
|
self.systemLang = os.environ.get("LANG", self._default)
|
|
|
|
def _canonLang(self, lang):
|
|
"""Convert the shortened form of a language name into the full
|
|
version. If it's not found, raise ValueError.
|
|
|
|
Example: fr -> fr_FR.UTF-8
|
|
fr_FR -> fr_FR.UTF-8
|
|
fr_CA -> ValueError
|
|
"""
|
|
for key in self.localeInfo.keys():
|
|
if lang in expandLangs(key):
|
|
return key
|
|
|
|
raise ValueError
|
|
|
|
def available(self):
|
|
return self.nativeLangNames.keys()
|
|
|
|
def dracutSetupString(self):
|
|
args=""
|
|
|
|
for (key, val) in self.info.iteritems():
|
|
if val != None:
|
|
args += " %s=%s" % (key, val)
|
|
|
|
return args
|
|
|
|
def getCurrentLangSearchList(self):
|
|
return expandLangs(self.systemLang) + ['C']
|
|
|
|
def getDefaultKeyboard(self, instPath):
|
|
try:
|
|
return self.localeInfo[self.systemLang][3]
|
|
except KeyError:
|
|
try:
|
|
kbd = keyboard.Keyboard()
|
|
kbd.read(instPath)
|
|
return kbd.get()
|
|
except:
|
|
return self.localeInfo[self._default][3]
|
|
|
|
def getDefaultTimeZone(self, instPath):
|
|
try:
|
|
return self.localeInfo[self.systemLang][4]
|
|
except KeyError:
|
|
# If doing an upgrade and the system language is something not
|
|
# recognized by anaconda, we should try to see if we can figure
|
|
# it out from the running system.
|
|
if os.path.exists(instPath + "/etc/sysconfig/clock"):
|
|
cfg = SimpleConfigFile()
|
|
cfg.read(instPath + "/etc/sysconfig/clock")
|
|
|
|
try:
|
|
return cfg.get("ZONE")
|
|
except:
|
|
return self.localeInfo[self._default][4]
|
|
else:
|
|
return self.localeInfo[self._default][4]
|
|
|
|
def getFontFile(self, lang):
|
|
# Note: in /etc/fonts.cgz fonts are named by the map
|
|
# name as that's unique, font names are not
|
|
try:
|
|
l = self._canonLang(lang)
|
|
except ValueError:
|
|
l = self._default
|
|
|
|
return self.localeInfo[l][2]
|
|
|
|
def getLangName(self, lang):
|
|
try:
|
|
l = self._canonLang(lang)
|
|
except ValueError:
|
|
l = self._default
|
|
|
|
return self.localeInfo[l][0]
|
|
|
|
def getLangByName(self, name):
|
|
for (key, val) in self.localeInfo.iteritems():
|
|
if val[0] == name:
|
|
return key
|
|
|
|
def getNativeLangName(self, lang):
|
|
return self.nativeLangNames[lang]
|
|
|
|
def write(self, instPath):
|
|
f = open(instPath + "/etc/sysconfig/i18n", "w")
|
|
|
|
for (key, val) in self.info.iteritems():
|
|
if val != None:
|
|
f.write("%s=\"%s\"\n" % (key, val))
|
|
|
|
f.close()
|
|
|
|
def writeKS(self, f):
|
|
f.write("lang %s\n" % self.info['LANG'])
|