gramps/gramps2/src/NameDisplay.py

280 lines
8.6 KiB
Python
Raw Normal View History

2005-01-01 20:46:44 +05:30
#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2004-2005 Donald N. Allingham
2005-01-01 20:46:44 +05:30
#
# 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$
"""
Class handling language-specific displaying of names.
"""
#-------------------------------------------------------------------------
#
# GRAMPS modules
#
#-------------------------------------------------------------------------
from RelLib import Name
2005-01-01 20:46:44 +05:30
#-------------------------------------------------------------------------
#
# NameDisplay class
#
#-------------------------------------------------------------------------
2005-01-01 20:46:44 +05:30
class NameDisplay:
"""
Base class for displaying of Name instances.
"""
def __init__(self,use_upper=False):
"""
Creates a new NameDisplay class.
@param use_upper: True indicates that the surname should be
displayed in upper case.
@type use_upper: bool
"""
self.force_upper = use_upper
2005-01-01 20:46:44 +05:30
def use_upper(self,upper):
"""
Changes the NameDisplay class to enable or display the displaying
of surnames in upper case.
@param upper: True indicates that the surname should be
displayed in upper case.
@type upper: bool
"""
self.force_upper = upper
2005-01-01 20:46:44 +05:30
def sorted(self,person):
"""
Returns a text string representing the L{RelLib.Person} instance's
L{Name} in a manner that should be used for displaying a sorted
2005-01-01 20:46:44 +05:30
name.
@param person: L{RelLib.Person} instance that contains the
L{Name} that is to be displayed. The primary name is used for
2005-01-01 20:46:44 +05:30
the display.
@type person: L{RelLib.Person}
@returns: Returns the L{RelLib.Person} instance's name
@rtype: str
"""
name = person.get_primary_name()
if name.sort_as == Name.FNLN:
2005-01-01 20:46:44 +05:30
return self._fnln(name)
elif name.sort_as == Name.PTFN:
return self._ptfn(name)
elif name.sort_as == Name.FN:
return name.first_name
else:
return self._lnfn(name)
2005-01-01 20:46:44 +05:30
def _empty(self,name):
return name.first_name
2005-01-01 20:46:44 +05:30
def _ptfn(self,name):
"""
Prints the Western style first name, last name style.
Typically this is::
SurnamePrefix Patronymic SurnameSuffix, FirstName
"""
first = name.first_name
if self.force_upper:
last = name.patronymic.upper()
else:
last = name.patronymic
if name.suffix == "":
if name.prefix:
return "%s %s, %s" % (name.prefix, last, first)
else:
return "%s, %s" % (last, first)
else:
if name.prefix:
return "%s %s %s, %s" % (name.prefix, last, name.suffix, first)
else:
return "%s %s, %s" % (last, name.suffix, first)
2005-12-06 12:08:09 +05:30
def _fnln(self,name,nickname=""):
2005-01-01 20:46:44 +05:30
"""
Prints the Western style first name, last name style.
Typically this is::
FirstName Patronymic SurnamePrefix Surname SurnameSuffix
"""
2005-12-06 12:08:09 +05:30
first = name.first_name
if nickname:
first = '%s "%s"' % (first,nickname)
2005-01-01 20:46:44 +05:30
if name.patronymic:
2005-12-06 12:08:09 +05:30
first = "%s %s" % (first, name.patronymic)
2005-01-01 20:46:44 +05:30
if self.force_upper:
2005-01-01 20:46:44 +05:30
last = name.surname.upper()
else:
last = name.surname
if name.suffix == "":
if name.prefix:
return "%s %s %s" % (first, name.prefix, last)
else:
return "%s %s" % (first, last)
else:
if name.prefix:
return "%s %s %s, %s" % (first, name.prefix, last, name.suffix)
else:
return "%s %s, %s" % (first, last, name.suffix)
2005-12-06 12:08:09 +05:30
def _lnfn(self,name,nickname=u""):
2005-01-01 20:46:44 +05:30
"""
Prints the Western style last name, first name style.
Typically this is::
SurnamePrefix Surname, FirstName Patronymic SurnameSuffix
"""
2005-12-06 12:08:09 +05:30
first = name.first_name
2005-01-01 20:46:44 +05:30
if name.patronymic:
2005-12-06 12:08:09 +05:30
first = "%s %s" % (first, name.patronymic)
2005-01-01 20:46:44 +05:30
if self.force_upper:
2005-01-01 20:46:44 +05:30
last = name.surname.upper()
else:
last = name.surname
2005-12-06 12:08:09 +05:30
if last:
last += ","
2005-01-01 20:46:44 +05:30
if name.suffix:
if name.prefix:
2005-12-06 12:08:09 +05:30
return "%s %s %s %s" % (name.prefix, last, first, name.suffix)
2005-01-01 20:46:44 +05:30
else:
2005-12-06 12:08:09 +05:30
return "%s %s %s" % (last, first, name.suffix)
2005-01-01 20:46:44 +05:30
else:
if name.prefix:
2005-12-06 12:08:09 +05:30
return "%s %s %s" % (name.prefix, last, first)
2005-01-01 20:46:44 +05:30
else:
2005-12-06 12:08:09 +05:30
return "%s %s" % (last, first)
2005-01-01 20:46:44 +05:30
fn_array = { Name.FNLN : _fnln,
Name.PTFN : _ptfn,
Name.FN : _empty,
}
def sorted_name(self,name):
"""
Returns a text string representing the L{Name} instance
in a manner that should be used for displaying a sorted
name.
@param name: L{Name} instance that is to be displayed.
@type name: L{Name}
@returns: Returns the L{Name} string representation
@rtype: str
"""
return self.fn_array.get(name.sort_as,self._lnfn)(name)
def display_given(self,person):
name = person.get_primary_name()
if name.patronymic:
return "%s %s" % (name.first_name, name.patronymic)
else:
return name.first_name
def display(self,person):
"""
Returns a text string representing the L{RelLib.Person} instance's
L{Name} in a manner that should be used for normal displaying.
@param person: L{RelLib.Person} instance that contains the
L{Name} that is to be displayed. The primary name is used for
the display.
@type person: L{RelLib.Person}
@returns: Returns the L{RelLib.Person} instance's name
@rtype: str
"""
name = person.get_primary_name()
if name.display_as == Name.LNFN:
return self._lnfn(name,"")
else:
return self._fnln(name,"")
def display_formal(self,person):
"""
Returns a text string representing the L{RelLib.Person} instance's
L{Name} in a manner that should be used for normal displaying.
@param person: L{RelLib.Person} instance that contains the
L{Name} that is to be displayed. The primary name is used for
the display.
@type person: L{RelLib.Person}
@returns: Returns the L{RelLib.Person} instance's name
@rtype: str
"""
name = person.get_primary_name()
if name.display_as == Name.LNFN:
return self._lnfn(name,'')
else:
return self._fnln(name,'')
def display_name(self,name):
"""
Returns a text string representing the L{Name} instance
in a manner that should be used for normal displaying.
@param name: L{Name} instance that is to be displayed.
@type name: L{Name}
@returns: Returns the L{Name} string representation
@rtype: str
"""
if name == None:
return ""
elif name.display_as == Name.LNFN:
return self._lnfn(name)
elif name.display_as == Name.PTFN:
return self._ptfn(name)
else:
return self._fnln(name)
def name_grouping(self,db,person):
return self.name_grouping_name(db,person.primary_name)
sort_field = (Name.get_surname, Name.get_surname,
Name.get_first_name, Name.get_patronymic,
Name.get_first_name)
def name_grouping_name(self,db,pn):
if pn.group_as:
return pn.group_as
sv = pn.sort_as
if sv <= Name.LNFN:
return db.get_name_group_mapping(pn.surname)
elif sv == Name.PTFN:
return db.get_name_group_mapping(pn.patronymic)
else:
return db.get_name_group_mapping(pn.first_name)
2005-01-01 20:46:44 +05:30
displayer = NameDisplay()