1068 lines
40 KiB
Python
1068 lines
40 KiB
Python
#
|
|
# Gramps - a GTK+/GNOME based genealogy program
|
|
#
|
|
# Copyright (C) 2000-2006 Donald N. Allingham
|
|
# Copyright (C) 2009 Brian G. Matherly
|
|
#
|
|
# 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, write to the Free Software
|
|
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
#
|
|
|
|
# $Id$
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
# python modules
|
|
#
|
|
#------------------------------------------------------------------------
|
|
from __future__ import print_function
|
|
import gettext
|
|
import sys
|
|
import os
|
|
import codecs
|
|
import locale
|
|
import logging
|
|
LOG = logging.getLogger("grampslocale")
|
|
HAVE_ICU = False
|
|
_hdlr = None
|
|
# GrampsLocale initialization comes before command-line argument
|
|
# passing, so one must set the log level directly. The default is
|
|
# logging.WARN. Uncomment the following to change it to logging.DEBUG:
|
|
# LOG.setLevel(logging.DEBUG)
|
|
try:
|
|
from icu import Locale, Collator
|
|
HAVE_ICU = True
|
|
except ImportError:
|
|
try:
|
|
from PyICU import Locale, Collator
|
|
HAVE_ICU = True
|
|
except ImportError as err:
|
|
LOG.warning("ICU not loaded because %s. Localization will be impaired. "
|
|
"Use your package manager to install PyICU", str(err))
|
|
ICU_LOCALES = None
|
|
if HAVE_ICU:
|
|
ICU_LOCALES = Locale.getAvailableLocales()
|
|
|
|
#Map our translated language codes to Microsoft Locale Names
|
|
#Important: Maintain this list with new translations or they
|
|
#won't work under MS Windows!
|
|
mslocales = {
|
|
'ar': ('Arabic_Saudi Arabia', '1256'),
|
|
'bg': ('Bulgrian_Bulgaria', '1251'),
|
|
'br': None, #Windows has no translation for Breton
|
|
'ca': ('Catalang_Spain', '1252'),
|
|
'cs': ('Czech_Czech Republic', '1250'),
|
|
'da': ('Danish_Denmark', '1252'),
|
|
'de': ('German_Germany', '1252'),
|
|
'en_GB': ('English_United Kingdom', '1252'),
|
|
'eo': None, #Windows has no translation for Esperanto
|
|
'es': ('Spanish_Spain', '1252'),
|
|
'fi': ('Finnish_Finland', '1252'),
|
|
'fr': ('French_France', '1252'),
|
|
'ga': None, #Windows has no translation for Gaelic
|
|
'he': ('Hebrew_Israel', '1255'),
|
|
'hr': ('Croatian_Croatia', '1250'),
|
|
'hu': ('Hungarian_Hungary', '1250'),
|
|
'it': ('Italian_Italy', '1252'),
|
|
'ja': ('Japanese_Japan', '932'),
|
|
'lt': ('Lithuanian_Lithuania', '1252'),
|
|
'mk': None, #Windows has no translation for Macedonian
|
|
'nb': ('Norwegian_Norway', '1252'),
|
|
'nl': ('Dutch_Netherlands', '1252'),
|
|
'nn': ('Norwegian-Nynorsk_Norway', '1252'),
|
|
'pl': ('Polish_Poland', '1250'),
|
|
'pt_BR': ('Portuguese_Brazil', '1252'),
|
|
'pt_PT': ('Portuguese_Portugal', '1252'),
|
|
'ro': ('Romanian_Romania', '1250'),
|
|
'ru': ('Russian_Russia', '1251'),
|
|
'sk': ('Slovak_Slovakia', '1250'),
|
|
'sl': ('Slovenian_Slovenia', '1250'),
|
|
'sq': ('Albanian_Albania', '1250'),
|
|
'sr': ('Serbian(Cyrillic)_Serbia and Montenegro', '1251'),
|
|
'sv': ('Swedish_Sweden', '1252'),
|
|
'tr': ('Turkish_Turkey', '1254'),
|
|
'uk': ('Ukrainian_Ukraine', '1251'),
|
|
'vi': ('Vietnamese_Viet Nam', '1258'),
|
|
'zh_CN': ('Chinese_China', '936'),
|
|
}
|
|
|
|
def _check_mswin_locale(locale):
|
|
msloc = None
|
|
try:
|
|
msloc = mslocales[locale[:5]]
|
|
locale = locale[:5]
|
|
except KeyError:
|
|
try:
|
|
msloc = mslocales[locale[:2]]
|
|
locale = locale[:2]
|
|
except KeyError:
|
|
return (None, None)
|
|
return (locale, msloc)
|
|
|
|
def _check_mswin_locale_reverse(locale):
|
|
for (loc, msloc) in mslocales.items():
|
|
if msloc and locale == msloc[0]:
|
|
return (loc, msloc[1])
|
|
|
|
return (None, None)
|
|
|
|
#------------------------------------------------------------------------
|
|
#
|
|
# GrampsLocale Class
|
|
#
|
|
#------------------------------------------------------------------------
|
|
class GrampsLocale(object):
|
|
"""
|
|
Encapsulate a locale. This class is a sort-of-singleton: The
|
|
first instance created will query the environment and OSX defaults
|
|
for missing parameters (precedence is parameters passed to the
|
|
constructor, environment variables LANG, LC_COLLATE, LC_TIME,
|
|
etc., and LANGUAGE, OSX defaults settings when that's the
|
|
platform). Subsequent calls to the constructor with no or
|
|
identical parameters will return the same Grampslocale
|
|
object. Construction with different parameters will result in a
|
|
new GrampsLocale instance with the specified parameters, but any
|
|
parameters left out will be filled in from the first instance.
|
|
|
|
@localedir: The full path to the top level directory containing
|
|
the translation files. Defaults to sys.prefix/share/locale.
|
|
|
|
@lang: A single locale value which is used for unset locale.LC_FOO
|
|
settings.
|
|
|
|
@domain: The name of the applicable translation file. The default is
|
|
"gramps", indicating files in LC_MESSAGES named gramps.mo.
|
|
|
|
@languages: A list of two or five character codes corresponding to
|
|
subidrectries in the localedir, e.g. "fr" or "zh_CN".
|
|
"""
|
|
DEFAULT_TRANSLATION_STR = "default"
|
|
__first_instance = None
|
|
encoding = None
|
|
_lang_map = None
|
|
_country_map = None
|
|
|
|
def __new__(cls, localedir=None, lang=None, domain=None, languages=None):
|
|
if not GrampsLocale.__first_instance:
|
|
cls.__first_instance = super(GrampsLocale, cls).__new__(cls)
|
|
cls.__first_instance.initialized = False
|
|
return cls.__first_instance
|
|
|
|
if not cls.__first_instance.initialized:
|
|
raise RuntimeError("Second GrampsLocale created before first one was initialized")
|
|
if ((lang is None or lang == cls.__first_instance.lang)
|
|
and (localedir is None or localedir == cls.__first_instance.localedir)
|
|
and (domain is None or domain == cls.__first_instance.localedomain)
|
|
and (languages is None or len(languages) == 0 or
|
|
languages == cls.__first_instance.languages)):
|
|
return cls.__first_instance
|
|
|
|
return super(GrampsLocale, cls).__new__(cls)
|
|
|
|
def _win_init_environment(self):
|
|
"""
|
|
The Windows implementation of Python ignores environment
|
|
variables when setting the locale; it only pays attention to
|
|
the control panel language settings -- which for practical
|
|
purposes limits one to the language for which one purchased
|
|
Windows. This function enables using alternative
|
|
localizations.
|
|
"""
|
|
|
|
if not (hasattr(self, 'lang') and self.lang):
|
|
self.lang = None
|
|
if 'LANG' in os.environ:
|
|
(lang, loc) = _check_mswin_locale(os.environ['LANG'])
|
|
if loc:
|
|
locale.setlocale(locale.LC_ALL, '.'.join(loc))
|
|
self.lang = lang
|
|
self.language = [self.lang]
|
|
self.encoding = loc[1]
|
|
|
|
if not self.lang:
|
|
locale.setlocale(locale.LC_ALL, '')
|
|
(lang, encoding) = locale.getlocale()
|
|
loc = _check_mswin_locale_reverse(lang)
|
|
if loc:
|
|
self.lang = loc[0]
|
|
self.languages = [loc[0]]
|
|
self.encoding = loc[1]
|
|
else:
|
|
(lang, loc) = _check_mswin_locale(lang)
|
|
if lang:
|
|
self.lang = lang
|
|
self.language = [self.lang]
|
|
self.encoding = loc[1]
|
|
|
|
if not self.lang:
|
|
self.lang = 'C'
|
|
self.language = ['en']
|
|
self.encoding = 'cp1252'
|
|
|
|
if not (hasattr(self, 'language') and self.language):
|
|
if 'LC_MESSAGES' in os.environ:
|
|
lang = self.check_available_translations(os.environ['LC_MESSAGES'])
|
|
if lang:
|
|
self.language = [lang]
|
|
if 'LANGUAGE' in os.environ:
|
|
language = [x for x in [self.check_available_translations(l)
|
|
for l in os.environ["LANGUAGE"].split(":")]
|
|
if x]
|
|
|
|
self.language = language
|
|
if not (hasattr(self, 'language') and self.language):
|
|
self.language = [self.lang]
|
|
|
|
if 'LC_COLLATE' in os.environ:
|
|
coll = os.environ['LC_COLLATE']
|
|
if HAVE_ICU:
|
|
if coll[:5] in ICU_LOCALES:
|
|
self.collation = coll
|
|
else:
|
|
self.collation = self.lang
|
|
else:
|
|
(coll, loc) = _check_mswin_locale(coll)
|
|
if not loc:
|
|
(coll, loc) = _check_mswin_locale(self.lang)
|
|
self.collation = '.'.join(loc)
|
|
locale.setlocale(locale.LC_COLLATE, self.collation )
|
|
else:
|
|
if HAVE_ICU:
|
|
self.collation = self.lang
|
|
else:
|
|
(coll, loc) = _check_mswin_locale(self.lang)
|
|
if loc:
|
|
self.collation = '.'.join(loc)
|
|
else:
|
|
self.collation = 'C'
|
|
locale.setlocale(locale.LC_COLLATE, self.collation )
|
|
|
|
# We can't import datahandler stuff or we'll get a circular
|
|
# dependency, so we rely on the available translations list
|
|
if 'LC_TIME' in os.environ:
|
|
self.calendar = self.check_available_translations(os.environ['LC_TIME']) or self.lang
|
|
else:
|
|
self.calendar = self.lang
|
|
|
|
if 'LC_NUMERIC' in os.environ:
|
|
self.numeric = os.environ['LC_NUMERIC']
|
|
else:
|
|
self.numeric = self.lang
|
|
|
|
if 'LC_MONETARY' in os.environ:
|
|
self.currency = os.environ['LC_MONETARY']
|
|
else:
|
|
self.currency = self.lang
|
|
|
|
def _init_from_environment(self):
|
|
|
|
def _check_locale(locale):
|
|
if not locale[0]:
|
|
return False
|
|
lang = self.check_available_translations(locale[0])
|
|
if not lang:
|
|
return False
|
|
self.lang = locale[0]
|
|
self.encoding = locale[1]
|
|
self.language = [lang]
|
|
return True
|
|
|
|
_failure = False
|
|
try:
|
|
locale.setlocale(locale.LC_ALL, '')
|
|
if not _check_locale(locale.getlocale(locale.LC_MESSAGES)):
|
|
if not _check_locale(locale.getlocale()):
|
|
if not _check_locale(locale.getdefaultlocale()):
|
|
LOG.debug("Usable locale not found, localization settings ignored.");
|
|
self.lang = 'C'
|
|
self.encoding = 'ascii'
|
|
self.language = ['en']
|
|
_failure = True
|
|
|
|
except locale.Error as err:
|
|
LOG.debug("Locale error %s, localization settings ignored.",
|
|
err);
|
|
self.lang = 'C'
|
|
self.encoding = 'ascii'
|
|
self.language = ['en']
|
|
_failure = True
|
|
|
|
# $LANGUAGE overrides $LANG, $LC_MESSAGES
|
|
if "LANGUAGE" in os.environ:
|
|
language = [x for x in [self.check_available_translations(l)
|
|
for l in os.environ["LANGUAGE"].split(":")]
|
|
if x]
|
|
if language:
|
|
self.language = language
|
|
if not self.lang.startswith(self.language[0]):
|
|
LOG.debug("Overiding locale setting %s with LANGUAGE setting %s", self.lang, self.language[0])
|
|
self.lang = locale.normalize(self.language[0])
|
|
self.encoding = self.lang.split('.')[1]
|
|
elif _failure:
|
|
LOG.warning("No valid locale settings found, using US English")
|
|
|
|
if HAVE_ICU:
|
|
self.calendar = locale.getlocale(locale.LC_TIME)[0] or self.lang[:5]
|
|
self.collation = locale.getlocale(locale.LC_COLLATE)[0] or self.lang[:5]
|
|
else:
|
|
loc = locale.getlocale(locale.LC_TIME)
|
|
if loc and loc[0]:
|
|
self.calendar = '.'.join(loc)
|
|
else:
|
|
self.calendar = self.lang
|
|
|
|
loc = locale.getlocale(locale.LC_COLLATE)
|
|
if loc and loc[0]:
|
|
self.collation = '.'.join(loc)
|
|
else:
|
|
self.collation = self.lang
|
|
|
|
loc = locale.getlocale(locale.LC_NUMERIC)
|
|
if loc and loc[0]:
|
|
self.numeric = '.'.join(loc)
|
|
else:
|
|
self.numeric = self.lang
|
|
|
|
loc = locale.getlocale(locale.LC_MONETARY)
|
|
if loc and loc[0]:
|
|
self.currency = '.'.join(loc)
|
|
else:
|
|
self.currency = self.lang
|
|
|
|
def _win_bindtextdomain(self, localedomain, localedir):
|
|
"""
|
|
Help routine for loading and setting up libintl attributes
|
|
Returns libintl
|
|
"""
|
|
from ctypes import cdll
|
|
try:
|
|
libintl = cdll.LoadLibrary('libintl-8')
|
|
libintl.bindtextdomain(localedomain,
|
|
localedir.encode(sys.getfilesystemencoding()))
|
|
libintl.textdomain(localedomain)
|
|
libintl.bind_textdomain_codeset(localedomain, "UTF-8")
|
|
|
|
except WindowsError:
|
|
LOG.warning("Localization library libintl not on %PATH%, localization will be incomplete")
|
|
|
|
def __init_first_instance(self):
|
|
"""
|
|
Initialize the primary locale from whatever might be
|
|
available. We only do this once, and the resulting
|
|
GrampsLocale is returned by default.
|
|
"""
|
|
global _hdlr
|
|
_hdlr = logging.StreamHandler()
|
|
_hdlr.setFormatter(logging.Formatter(fmt="%(name)s.%(levelname)s: %(message)s"))
|
|
LOG.addHandler(_hdlr)
|
|
|
|
# Even the first instance can be overridden by passing lang
|
|
# and languages to the constructor. If it isn't (which is the
|
|
# expected behavior), do platform-specific setup:
|
|
if not (self.lang and self.language):
|
|
if sys.platform == 'darwin':
|
|
from . import maclocale
|
|
maclocale.mac_setup_localization(self)
|
|
elif sys.platform == 'win32':
|
|
self._win_init_environment()
|
|
else:
|
|
self._init_from_environment()
|
|
else:
|
|
self.numeric = self.currency = self.calendar = self.collation = self.lang
|
|
|
|
if not self.lang:
|
|
self.lang = 'en_US.UTF-8'
|
|
if not self.language:
|
|
self.language.append('en')
|
|
if not self.localedir and not self.lang.startswith('en'):
|
|
LOG.warning("No translations for %s were found, setting localization to U.S. English", self.localedomain)
|
|
self.lang = 'en_US.UTF-8'
|
|
self.language = ['en']
|
|
|
|
#Next, we need to know what is the encoding from the native
|
|
#environment. This is used by python standard library funcions which
|
|
#localize their output, e.g. time.strftime(). NB: encoding is a class variable.
|
|
if not self.encoding:
|
|
self.encoding = (locale.getpreferredencoding()
|
|
or sys.getdefaultencoding())
|
|
LOG.debug("Setting encoding to %s", self.encoding)
|
|
#Ensure that output is encoded correctly to stdout and stderr. This is
|
|
#much less cumbersome and error-prone than encoding individual outputs
|
|
#and better handles the differences between Python 2 and Python 3:
|
|
_encoding = sys.stdout.encoding or sys.getdefaultencoding()
|
|
if sys.version_info[0] < 3:
|
|
sys.stdout = codecs.getwriter(_encoding)(sys.stdout,
|
|
'backslashreplace')
|
|
sys.stderr = codecs.getwriter(_encoding)(sys.stderr,
|
|
'backslashreplace')
|
|
else:
|
|
sys.stdout = codecs.getwriter(_encoding)(sys.stdout.detach(),
|
|
'backslashreplace')
|
|
sys.stderr = codecs.getwriter(_encoding)(sys.stderr.detach(),
|
|
'backslashreplace')
|
|
|
|
|
|
# Make sure that self.lang and self.language are reflected
|
|
# back into the environment for Gtk to use when its
|
|
# initialized. If self.lang isn't 'C', make sure that it has a
|
|
# 'UTF-8' suffix, because that's all that GtkBuilder can
|
|
# digest.
|
|
|
|
# Linux note: You'll get unsupported locale errors from Gtk
|
|
# and untranslated strings if the requisite UTF-8 locale isn't
|
|
# installed. This is particularly a problem on Debian and
|
|
# Debian-derived distributions which by default don't install
|
|
# a lot of locales.
|
|
lang = locale.normalize(self.language[0] if self.language[0] else 'C')
|
|
check_lang = lang.split('.')
|
|
if not check_lang[0] in ('C', 'en', 'en_US'):
|
|
if len(check_lang) < 2 or check_lang[1] not in ("utf-8", "UTF-8"):
|
|
lang = '.'.join((check_lang[0], 'UTF-8'))
|
|
|
|
os.environ["LANG"] = self.lang
|
|
os.environ["LANGUAGE"] = ':'.join(['C' if l in ('en', 'en_US') else l
|
|
for l in self.language])
|
|
|
|
# GtkBuilder uses GLib's g_dgettext wrapper, which oddly is bound
|
|
# with locale instead of gettext. Win32 doesn't support bindtextdomain.
|
|
if self.localedir:
|
|
if not sys.platform == 'win32':
|
|
locale.bindtextdomain(self.localedomain, self.localedir)
|
|
else:
|
|
self._win_bindtextdomain(self.localedomain, self.localedir)
|
|
|
|
def _init_secondary_locale(self):
|
|
"""
|
|
Init a secondary locale. Secondary locales are used to provide
|
|
an alternate localization to the one used for the UI; for
|
|
example, some reports offer the option to use a different
|
|
language.
|
|
"""
|
|
if not self.localedir:
|
|
LOG.warning("No Localedir provided, unable to find translations")
|
|
|
|
if not self.localedomain:
|
|
if _firstlocaledomain:
|
|
self.localedomain = _first.localedomain
|
|
else:
|
|
self.localedomain = "gramps"
|
|
|
|
_first = self._GrampsLocale__first_instance
|
|
if not self.lang and _first.lang:
|
|
self.lang = _first.lang
|
|
|
|
if not self.language:
|
|
if self.lang:
|
|
trans = self.check_available_translations(self.lang)
|
|
if trans:
|
|
self.language = [trans]
|
|
|
|
if not self.language and _first.language:
|
|
self.language = _first.language
|
|
|
|
self.calendar = self.collation = self.lang
|
|
|
|
def __init__(self, localedir=None, lang=None, domain=None, languages=None):
|
|
"""
|
|
Init a GrampsLocale. Run __init_first_instance() to set up the
|
|
environment if this is the first run. Return __first_instance
|
|
otherwise if called without arguments.
|
|
"""
|
|
global _hdlr
|
|
#initialized is special, used only for the "first instance",
|
|
#and created by __new__(). It's used to prevent re-__init__ing
|
|
#__first_instance when __new__() returns its pointer.
|
|
if hasattr(self, 'initialized') and self.initialized:
|
|
return
|
|
_first = self._GrampsLocale__first_instance
|
|
|
|
# Everything breaks without localedir, so get that set up
|
|
# first. Warnings are logged in _init_first_instance or
|
|
# _init_secondary_locale if this comes up empty.
|
|
if localedir and os.path.exists(os.path.abspath(localedir)):
|
|
self.localedir = localedir
|
|
elif _first and _first.localedir:
|
|
self.localedir = _first.localedir
|
|
else:
|
|
self.localedir = None
|
|
|
|
self.lang = lang
|
|
self.localedomain = domain or 'gramps'
|
|
if languages:
|
|
self.language = [x for x in [self.check_available_translations(l)
|
|
for l in languages.split(":")]
|
|
if x]
|
|
else:
|
|
self.language = None
|
|
|
|
#For alternate collation sequences. Works only with ICU, and
|
|
#set only on Macs.
|
|
self.coll_qualifier = None
|
|
_first = self._GrampsLocale__first_instance
|
|
if self == _first:
|
|
self._GrampsLocale__init_first_instance()
|
|
else:
|
|
self._init_secondary_locale()
|
|
|
|
self.icu_locales = {}
|
|
self.collator = None
|
|
if HAVE_ICU:
|
|
self.icu_locales["default"] = Locale.createFromName(self.lang)
|
|
if self.collation and self.collation != self.lang:
|
|
self.icu_locales["collation"] = Locale.createFromName(self.collation)
|
|
else:
|
|
self.icu_locales["collation"] = self.icu_locales["default"]
|
|
try:
|
|
self.collator = Collator.createInstance(self.icu_locales["collation"])
|
|
except ICUError as err:
|
|
LOG.warning("Unable to create collator: %s", str(err))
|
|
self.collator = None
|
|
|
|
self.translation = self._get_translation(self.localedomain,
|
|
self.localedir, self.language)
|
|
# This is a no-op for secondaries but needs the translation
|
|
# set, so it needs to be here.
|
|
self._set_dictionaries()
|
|
|
|
if _hdlr:
|
|
LOG.removeHandler(_hdlr)
|
|
|
|
self._dd = self._dp = None
|
|
#Guards against running twice on the first instance.
|
|
self.initialized = True
|
|
|
|
def _get_translation(self, domain = None,
|
|
localedir = None,
|
|
languages=None):
|
|
"""
|
|
Get a translation of one of our classes. Doesn't return the
|
|
singleton so that it can be used by get_addon_translation()
|
|
"""
|
|
if not domain:
|
|
domain = self.localedomain
|
|
if not languages:
|
|
languages = self.language
|
|
if not localedir:
|
|
localedir = self.localedir
|
|
|
|
for lang in languages:
|
|
if gettext.find(domain, localedir, [lang]):
|
|
translator = gettext.translation(domain, localedir,
|
|
[lang],
|
|
class_ = GrampsTranslations)
|
|
translator._language = lang
|
|
return translator
|
|
|
|
elif lang.startswith("en") or lang.startswith("C"):
|
|
translator = GrampsNullTranslations()
|
|
translator._language = "en"
|
|
return translator
|
|
|
|
if not languages or len(languages) == 0:
|
|
LOG.warning("No language provided, using US English")
|
|
else:
|
|
LOG.warning("No usable languages found in %s for %s, using US English", ':'.join(languages), os.path.abspath(localedir))
|
|
translator = GrampsNullTranslations()
|
|
translator._language = "en"
|
|
return translator
|
|
|
|
def _set_dictionaries(self):
|
|
"""
|
|
Create a dictionary of language names localized to the
|
|
GrampsLocale's primary language, keyed by language and country
|
|
code. Note that _lang_map and _country_map are class
|
|
variables, so this function is no-op in secondary locales.
|
|
"""
|
|
_ = self.translation.gettext
|
|
if not self._lang_map:
|
|
self._lang_map = {
|
|
"bg" : _("Bulgarian"),
|
|
"ca" : _("Catalan"),
|
|
"cs" : _("Czech"),
|
|
"da" : _("Danish"),
|
|
"de" : _("German"),
|
|
"el" : _("Greek"),
|
|
"en" : _("English"),
|
|
"eo" : _("Esperanto"),
|
|
"es" : _("Spanish"),
|
|
"fi" : _("Finnish"),
|
|
"fr" : _("French"),
|
|
"he" : _("Hebrew"),
|
|
"hr" : _("Croatian"),
|
|
"hu" : _("Hungarian"),
|
|
"it" : _("Italian"),
|
|
"ja" : _("Japanese"),
|
|
"lt" : _("Lithuanian"),
|
|
"mk" : _("Macedonian"),
|
|
"nb" : _("Norwegian Bokmal"),
|
|
"nl" : _("Dutch"),
|
|
"nn" : _("Norwegian Nynorsk"),
|
|
"pl" : _("Polish"),
|
|
"pt" : _("Portuguese"),
|
|
"ro" : _("Romanian"),
|
|
"ru" : _("Russian"),
|
|
"sk" : _("Slovak"),
|
|
"sl" : _("Slovenian"),
|
|
"sq" : _("Albanian"),
|
|
"sv" : _("Swedish"),
|
|
"tr" : _("Turkish"),
|
|
"uk" : _("Ukrainian"),
|
|
"vi" : _("Vietnamese"),
|
|
"zh" : _("Chinese")
|
|
}
|
|
|
|
if not self._country_map:
|
|
self._country_map = {
|
|
"BR" : _("Brazil"),
|
|
"CN" : _("China"),
|
|
"PT" : _("Portugal")
|
|
}
|
|
|
|
def _get_language_string(self, lang_code):
|
|
"""
|
|
Given a language code of the form "lang_region", return a text string
|
|
representing that language.
|
|
"""
|
|
code_parts = lang_code.rsplit("_")
|
|
|
|
lang = code_parts[0]
|
|
|
|
if lang in self._lang_map:
|
|
lang = self._lang_map[lang]
|
|
|
|
country = None
|
|
if len(code_parts) > 1:
|
|
country = code_parts[1]
|
|
if country in self._country_map:
|
|
country = self._country_map[country]
|
|
lang = "%(language)s (%(country)s)" % \
|
|
{ 'language' : lang, 'country' : country }
|
|
|
|
return lang
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Properties
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
@property
|
|
def date_displayer(self):
|
|
"""
|
|
Return the locale's date displayer; if it hasn't already been
|
|
cached, set it from datehandler.LANG_TO_DISPLAY. If one isn't
|
|
available for the selected locale, attempt to fall back on the
|
|
first_instance's locale before settling on the 'C' displayer.
|
|
NB: This is the getter for the date_displayer property
|
|
"""
|
|
if self._dd:
|
|
return self._dd
|
|
|
|
from gramps.gen.config import config
|
|
try:
|
|
val = config.get('preferences.date-format')
|
|
except AttributeError:
|
|
val = 0;
|
|
|
|
from gramps.gen.datehandler import LANG_TO_DISPLAY as displayers
|
|
_first = self._GrampsLocale__first_instance
|
|
if self.calendar in displayers:
|
|
self._dd = displayers[self.calendar](val)
|
|
elif self.calendar[:2] in displayers:
|
|
self._dd = displayers[self.calendar[:2]](val)
|
|
elif self != _first and _first.calendar in displayers:
|
|
self._dd = displayers[_first.calendar](val)
|
|
elif self != _first and _first.calendar[:2] in displayers:
|
|
self._dd = displayers[_first.calendar[:2]](val)
|
|
else:
|
|
self._dd = displayers['C'](val)
|
|
|
|
return self._dd
|
|
|
|
@property
|
|
def date_parser(self):
|
|
"""
|
|
Return the locale's date parser; if it hasn't already been
|
|
cached, set it from datehandler.LANG_TO_PARSER. If one isn't
|
|
available for the selected locale, attempt to fall back on the
|
|
first_instance's locale before settling on the 'C' parser.
|
|
NB: This is the getter for the date_parser property
|
|
"""
|
|
if self._dp:
|
|
return self._dp
|
|
|
|
from gramps.gen.datehandler import LANG_TO_PARSER as parsers
|
|
_first = self._GrampsLocale__first_instance
|
|
if self.calendar in parsers:
|
|
self._dp = parsers[self.calendar]()
|
|
elif self.calendar[:2] in parsers:
|
|
self._dp = parsers[self.calendar]()
|
|
elif self != _first and _first.calendar in parsers:
|
|
self._dp = parsers[_first.calendar]()
|
|
elif self != _first and _first.calendar[:2] in parsers:
|
|
self._dp = parsers[_first.calendar[:2]]()
|
|
else:
|
|
self._dp = parsers['C']()
|
|
|
|
return self._dp
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Public Functions
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
|
|
def get_localedomain(self):
|
|
"""
|
|
Get the LOCALEDOMAIN used for the Gramps application.
|
|
Required by gui/glade.py to pass to Gtk.Builder
|
|
"""
|
|
return self.localedomain
|
|
|
|
def get_language_list(self):
|
|
"""
|
|
Return the list of configured languages. Used by
|
|
ViewManager.check_for_updates to select the language for the
|
|
addons descriptions.
|
|
"""
|
|
return self.language
|
|
|
|
|
|
def get_addon_translator(self, filename, domain="addon",
|
|
languages=None):
|
|
"""
|
|
Get a translator for an addon.
|
|
|
|
filename - filename of a file in directory with full path, or
|
|
None to get from self.
|
|
domain - the name of the .mo file under the LANG/LC_MESSAGES dir
|
|
languages - a list of languages to force
|
|
returns - a gettext.translation object
|
|
|
|
Example:
|
|
_ = glocale.get_addon_translator(languages=["fr_BE.utf8"]).gettext
|
|
|
|
See the python gettext documentation.
|
|
Assumes path/filename
|
|
path/locale/LANG/LC_MESSAGES/addon.mo.
|
|
"""
|
|
gramps_translator = self._get_translation()
|
|
|
|
path = self.localedir
|
|
if filename:
|
|
path = os.path.join(os.path.dirname(os.path.abspath(filename)), "locale")
|
|
if languages:
|
|
addon_translator = self._get_translation(domain,
|
|
path,
|
|
languages=languages)
|
|
else:
|
|
addon_translator = self._get_translation(domain, path)
|
|
gramps_translator.add_fallback(addon_translator)
|
|
return gramps_translator # with a language fallback
|
|
|
|
def get_available_translations(self, localedir = None, localedomain = None):
|
|
"""
|
|
Get a list of available translations.
|
|
|
|
:returns: A list of translation languages.
|
|
:rtype: unicode[]
|
|
|
|
"""
|
|
languages = ["en"]
|
|
|
|
if not localedir and self.localedir:
|
|
localedir = self.localedir
|
|
else:
|
|
return languages
|
|
|
|
if not localedomain and self.localedomain:
|
|
localedomain = self.localedomain
|
|
else:
|
|
localedomain = 'gramps'
|
|
|
|
for langdir in os.listdir(self.localedir):
|
|
mofilename = os.path.join(localedir, langdir,
|
|
"LC_MESSAGES",
|
|
"%s.mo" % localedomain )
|
|
if os.path.exists(mofilename):
|
|
languages.append(langdir)
|
|
|
|
languages.sort()
|
|
|
|
return languages
|
|
|
|
def check_available_translations(self, locale):
|
|
"""
|
|
Test a locale for having a translation available
|
|
locale -- string with standard language code, locale code, or name
|
|
"""
|
|
if not self.localedir:
|
|
return None
|
|
if not hasattr(self, 'languages'):
|
|
self.languages = self.get_available_translations()
|
|
|
|
if not locale:
|
|
return None
|
|
|
|
if locale[:2] in self.languages:
|
|
return locale[:2]
|
|
if locale[:5] in self.languages:
|
|
return locale[:5]
|
|
|
|
return None
|
|
|
|
def get_language_dict(self):
|
|
'''
|
|
return a dictionary of language names : codes for use by language
|
|
pickers.
|
|
'''
|
|
langs = {}
|
|
for code in self.get_available_translations():
|
|
langs[self._get_language_string(code)] = code
|
|
|
|
return langs
|
|
|
|
|
|
def trans_objclass(self, objclass_str):
|
|
"""
|
|
Translates objclass_str into "... %s", where objclass_str
|
|
is 'Person', 'person', 'Family', 'family', etc.
|
|
"""
|
|
_ = self.translation.gettext
|
|
objclass = objclass_str.lower()
|
|
if objclass == "person":
|
|
return _("the person")
|
|
elif objclass == "family":
|
|
return _("the family")
|
|
elif objclass == "place":
|
|
return _("the place")
|
|
elif objclass == "event":
|
|
return _("the event")
|
|
elif objclass == "repository":
|
|
return _("the repository")
|
|
elif objclass == "note":
|
|
return _("the note")
|
|
elif objclass in ["media", "mediaobject"]:
|
|
return _("the media")
|
|
elif objclass == "source":
|
|
return _("the source")
|
|
elif objclass == "filter":
|
|
return _("the filter")
|
|
else:
|
|
return _("See details")
|
|
|
|
def getfilesystemencoding(self):
|
|
"""
|
|
If the locale isn't configured correctly, this will return
|
|
'ascii' or 'ANSI_X3.4-1968' or some other unfortunate
|
|
result. Current unix systems all encode filenames in utf-8,
|
|
and Microsoft Windows uses utf-16 (which they call mbcs). Make
|
|
sure we return the right value.
|
|
"""
|
|
encoding = sys.getfilesystemencoding()
|
|
|
|
if encoding in ("utf-8", "UTF-8", "utf8", "UTF8", "mbcs", "MBCS"):
|
|
return encoding
|
|
|
|
return "utf-8"
|
|
|
|
def sort_key(self, string):
|
|
"""
|
|
Return a value suitable to pass to the "key" parameter of sorted()
|
|
"""
|
|
|
|
if HAVE_ICU and self.collator:
|
|
#ICU can digest strings and unicode
|
|
return self.collator.getCollationKey(string).getByteArray()
|
|
else:
|
|
try:
|
|
if sys.version_info[0] < 3 and isinstance(string, unicode):
|
|
key = locale.strxfrm(string.encode("utf-8", "replace"))
|
|
else:
|
|
key = locale.strxfrm(string)
|
|
|
|
except Exception as err:
|
|
LOG.warn("Failed to obtain key for %s because %s",
|
|
self.collation, str(err))
|
|
return string
|
|
return key
|
|
|
|
def strcoll(self, string1, string2):
|
|
"""
|
|
Given two localized strings, compare them and return -1 if
|
|
string1 would sort first, 1 if string2 would, and 0 if
|
|
they are the same.
|
|
"""
|
|
key1 = self.sort_key(string1)
|
|
key2 = self.sort_key(string2)
|
|
return (-1 if key1 < key2 else (1 if key1 > key2 else 0))
|
|
|
|
|
|
def get_date(self, date):
|
|
"""
|
|
Return a string representing the date appropriate for the language being
|
|
translated.
|
|
|
|
:param date: The date to be represented.
|
|
:type date: :class:`~gen.lib.date.Date`
|
|
:returns: The date as text in the proper language.
|
|
:rtype: unicode
|
|
"""
|
|
return self.date_displayer.display(date)
|
|
|
|
def get_type(self, name):
|
|
"""
|
|
Return a string representing the name appropriate for the language being
|
|
translated.
|
|
|
|
:param name: The name type to be represented.
|
|
:returns: The name as text in the proper language.
|
|
:rtype: unicode
|
|
"""
|
|
return GrampsType.xml_str(name)
|
|
|
|
def format(self, format, val, grouping=False, monetary=False):
|
|
"""
|
|
Format a number in the current numeric locale. See python's
|
|
locale.format for details. ICU's formatting codes are
|
|
incompatible with locale's, so just use locale.format for now.
|
|
"""
|
|
return locale.format(format, val, grouping, monetary)
|
|
|
|
def format_string(self, format, val, grouping=False):
|
|
"""
|
|
Format a string in the current numeric locale. See python's
|
|
locale.format_string for details. ICU's message formatting codes are
|
|
incompatible with locale's, so just use locale.format_string
|
|
for now.
|
|
"""
|
|
return locale.format_string(format, val, grouping)
|
|
|
|
def float(self, val):
|
|
"""
|
|
Parse a string to a floating point number. Uses locale.atof(),
|
|
in future with ICU present will use icu.NumberFormat.parse().
|
|
"""
|
|
try:
|
|
return locale.atof(val)
|
|
except ValueError:
|
|
point = locale.localeconv()['decimal_point']
|
|
sep = locale.localeconv()['thousands_sep']
|
|
try:
|
|
if point == ',':
|
|
return locale.atof(val.replace(' ', sep).replace('.', sep))
|
|
elif point == '.':
|
|
return locale.atof(val.replace(' ', sep).replace(',', sep))
|
|
else:
|
|
return None
|
|
except ValueError:
|
|
return None
|
|
|
|
#-------------------------------------------------------------------------
|
|
#
|
|
# Translations Classes
|
|
#
|
|
#-------------------------------------------------------------------------
|
|
class GrampsTranslations(gettext.GNUTranslations):
|
|
"""
|
|
Overrides and extends gettext.GNUTranslations. See the Python gettext
|
|
"Class API" documentation for how to use this.
|
|
"""
|
|
def language(self):
|
|
"""
|
|
Return the target languge of this translations object.
|
|
"""
|
|
return self._language
|
|
|
|
def gettext(self, msgid):
|
|
"""
|
|
Obtain translation of gettext, return a unicode object
|
|
:param msgid: The string to translated.
|
|
:type msgid: unicode
|
|
:returns: Translation or the original.
|
|
:rtype: unicode
|
|
"""
|
|
# If msgid =="" then gettext will return po file header
|
|
# and that's not what we want.
|
|
if len(msgid.strip()) == 0:
|
|
return msgid
|
|
if sys.version_info[0] < 3:
|
|
return gettext.GNUTranslations.ugettext(self, msgid)
|
|
else:
|
|
return gettext.GNUTranslations.gettext(self, msgid)
|
|
|
|
def ngettext(self, singular, plural, num):
|
|
"""
|
|
The translation of singular/plural is returned unless the translation is
|
|
not available and the singular contains the separator. In that case,
|
|
the returned value is the singular.
|
|
|
|
:param singular: The singular form of the string to be translated.
|
|
may contain a context seperator
|
|
:type singular: unicode
|
|
:param plural: The plural form of the string to be translated.
|
|
:type plural: unicode
|
|
:param num: the amount for which to decide the translation
|
|
:type num: int
|
|
:returns: Translation or the original.
|
|
:rtype: unicode
|
|
"""
|
|
if sys.version_info[0] < 3:
|
|
return gettext.GNUTranslations.ungettext(self, singular,
|
|
plural, num)
|
|
else:
|
|
return gettext.GNUTranslations.ngettext(self, singular,
|
|
plural, num)
|
|
|
|
def sgettext(self, msgid, sep='|'):
|
|
"""
|
|
Strip the context used for resolving translation ambiguities.
|
|
|
|
The translation of msgid is returned unless the translation is
|
|
not available and the msgid contains the separator. In that case,
|
|
the returned value is the portion of msgid following the last
|
|
separator. Default separator is '|'.
|
|
|
|
:param msgid: The string to translated.
|
|
:type msgid: unicode
|
|
:param sep: The separator marking the context.
|
|
:type sep: unicode
|
|
:returns: Translation or the original with context stripped.
|
|
:rtype: unicode
|
|
"""
|
|
msgval = self.gettext(msgid)
|
|
if msgval == msgid:
|
|
sep_idx = msgid.rfind(sep)
|
|
msgval = msgid[sep_idx+1:]
|
|
return msgval
|
|
|
|
class GrampsNullTranslations(gettext.NullTranslations):
|
|
"""
|
|
Extends gettext.NullTranslations to provide the sgettext method.
|
|
|
|
Note that it's necessary for msgid to be unicode. If it's not,
|
|
neither will be the returned string.
|
|
"""
|
|
def sgettext(self, msgid, sep='|'):
|
|
msgval = self.gettext(msgid)
|
|
if msgval == msgid:
|
|
sep_idx = msgid.rfind(sep)
|
|
msgval = msgid[sep_idx+1:]
|
|
return msgval
|
|
|
|
def language(self):
|
|
"""
|
|
The null translation returns the raw msgids, which are in English
|
|
"""
|
|
return "en"
|