gramps/src/NameDisplay.py

#
# Gramps - a GTK+/GNOME based genealogy program
#
# Copyright (C) 2004-2006  Donald N. Allingham
#
# 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
import Config

#-------------------------------------------------------------------------
#
# Constants
#
#-------------------------------------------------------------------------
_FIRSTNAME = 4
_SURNAME   = 5
_SUFFIX    = 6
_TITLE     = 7
_TYPE      = 8
_PREFIX    = 9
_PATRONYM  = 10
_SNAME     = 11
_GROUP     = 12
_SORT      = 13
_DISPLAY   = 14
_CALL      = 15

#-------------------------------------------------------------------------
#
# formats registration
#
#-------------------------------------------------------------------------
CUSTOM_FORMATS = []

def register_custom_formats(formats):
    CUSTOM_FORMATS = formats[:]

#-------------------------------------------------------------------------
#
# NameDisplay class
#
#-------------------------------------------------------------------------
class NameDisplay:
    """
    Base class for displaying of Name instances.
    """

    # FIXME: Is this used anywhere? I cannot see that it is.
    sort_field = (Name.get_surname, Name.get_surname,
                  Name.get_first_name, Name.get_patronymic,
                  Name.get_first_name)

    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.gramps_format = Config.get(Config.NAME_FORMAT)
        if self.gramps_format == 0:
            self.gramps_format = Name.LNFN
       
        self.force_upper = use_upper
        
        self.fn_array = {
            Name.LNFN: self._lnfn,
            Name.FNLN: self._fnln,
            Name.PTFN: self._ptfn,
            Name.FN:   self._fn,
        }
        
        self.raw_fn_array = {
            Name.LNFN: self._lnfn_raw,
            Name.FNLN: self._fnln_raw,
            Name.PTFN: self._ptfn_raw,
            Name.FN:   self._fn_raw,
        }
        
        self.extend_formats()

    def extend_formats(self):
        # Add custom formats to the mappings
        for number,name,fmt_str in CUSTOM_FORMATS:
            self.fn_array[number] = lambda x: self._format_str(x,fmt_str)
            self.raw_fn_array[number] = lambda x: \
                                            self._format_str_raw(x,fmt_str)
        # Add mappings for the gramps-prefs format
        self.fn_array[0] = self.fn_array[self.gramps_format]
        self.raw_fn_array[0] = self.raw_fn_array[self.gramps_format]

    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

    def sort_string(self,name):
        return u"%-25s%-30s%s" % (name.surname,name.first_name,name.suffix)

    def _fn(self,name):
        return self._fn_base(name.first_name)

    def _fn_raw(self,raw_data):
        first = raw_data[_FIRSTNAME]
        return self._fn_base(first)

    def _fn_base(self,first):
        return first

    def _ptfn(self,name):
        """
        Prints the Western style first name, last name style.
        Typically this is::

           SurnamePrefix Patronymic SurnameSuffix, FirstName
        """

        return self._ptfn_base(name.first_name,name.suffix,
                               name.prefix,name.patronymic)

    def _ptfn_raw(self,raw_data):
        """
        Prints the Western style first name, last name style.
        Typically this is::

           SurnamePrefix Patronymic SurnameSuffix, FirstName
        """

        first = raw_data[_FIRSTNAME]
        suffix = raw_data[_SUFFIX]
        prefix = raw_data[_PREFIX]
        patronymic = raw_data[_PATRONYM]

        return self._ptfn_base(first,suffix,prefix,patronymic)

    def _ptfn_base(self,first,suffix,prefix,patronymic):
        if self.force_upper:
            last = patronymic.upper()
        else:
            last = patronymic
            
        if suffix:
            if prefix:
                return "%s %s %s, %s" % (prefix, last, suffix, first)
            else:
                return "%s %s, %s" % (last, suffix, first)
        else:
            if prefix:
                return "%s %s, %s" % (prefix, last, first)
            else:
                return "%s, %s" % (last, first)
        
    def _fnln(self,name):
        """
        Prints the Western style first name, last name style.
        Typically this is::

           FirstName Patronymic SurnamePrefix Surname SurnameSuffix
        """
        return self._fnln_base(name.first_name,name.surname,name.suffix,
                          name.prefix,name.patronymic)

    def _fnln_raw(self,raw_data):
        """
        Prints the Western style first name, last name style.
        Typically this is::

           FirstName Patronymic SurnamePrefix Surname SurnameSuffix
        """
        first = raw_data[_FIRSTNAME]
        surname = raw_data[_SURNAME]
        suffix = raw_data[_SUFFIX]
        prefix = raw_data[_PREFIX]
        patronymic = raw_data[_PATRONYM]
        return self._fnln_base(first,surname,suffix,prefix,patronymic)

    def _fnln_base(self,first,surname,suffix,prefix,patronymic):
        if patronymic:
            first = "%s %s" % (first, patronymic)

        if self.force_upper:
            last = surname.upper()
        else:
            last = surname
            
        if suffix:
            if prefix:
                return "%s %s %s, %s" % (first, prefix, last, suffix)
            else:
                return "%s %s, %s" % (first, last, suffix)
        else:
            if prefix:
                return "%s %s %s" % (first, prefix, last)
            else:
                return "%s %s" % (first, last)

    def _lnfn(self,name):
        """
        Prints the Western style last name, first name style.
        Typically this is::

            SurnamePrefix Surname, FirstName Patronymic SurnameSuffix
        """
        return self._lnfn_base(name.first_name,name.surname,name.prefix,
                               name.suffix,name.patronymic)

    def _lnfn_raw(self,raw_data):
        """
        Prints the Western style last name, first name style.
        Typically this is::

            SurnamePrefix Surname, FirstName Patronymic SurnameSuffix
        """

        surname = raw_data[_SURNAME]
        prefix = raw_data[_PREFIX]
        first = raw_data[_FIRSTNAME]
        patronymic = raw_data[_PATRONYM]
        suffix = raw_data[_SUFFIX]

        return self._lnfn_base(first,surname,prefix,suffix,patronymic)

    def _lnfn_base(self,first,surname,prefix,suffix,patronymic):
        if self.force_upper:
            last = surname.upper()
        else:
            last = surname

        if last:
            last += ","

        return " ".join([prefix, last, first, patronymic, suffix])
    
    def _format_str(self,name,format_str):
        return self._format_str_base(name.first_name,name.surname,name.prefix,
                                     name.suffix,name.patronymic,name.title,
                                     name.call,format_str)

    def _format_str_raw(self,raw_data,format_str):
        surname = raw_data[_SURNAME]
        prefix = raw_data[_PREFIX]
        first = raw_data[_FIRSTNAME]
        patronymic = raw_data[_PATRONYM]
        suffix = raw_data[_SUFFIX]
        title = raw_data[_TITLE]
        call = raw_data[_CALL]
        return self._format_str_base(first,surname,prefix,suffix,patronymic,
                                     title,call,format_str)
        
    def _format_str_base(self,first,surname,prefix,suffix,patronymic,
                         title,call,format_str):
        """
        Generates name from a format string, e.g. '%T. %p %F %L (%p)' .
        """

        output = format_str
        
        output = output.replace("%t",title)
        output = output.replace("%f",first)
        output = output.replace("%p",prefix)
        output = output.replace("%l",surname)
        output = output.replace("%s",suffix)
        output = output.replace("%y",patronymic)
        output = output.replace("%c",call)
        output = output.replace("%T",title.upper())
        output = output.replace("%F",first.upper())
        output = output.replace("%P",prefix.upper())
        output = output.replace("%L",surname.upper())
        output = output.replace("%S",suffix.upper())
        output = output.replace("%Y",patronymic.upper())
        output = output.replace("%C",call.upper())
        output = output.replace("%%",'%')

        return output

    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
        name.

        @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()
        return self.sorted_name(name)

    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[name.sort_as](name)

    def raw_sorted_name(self,raw_data):
        """
        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.raw_fn_array[raw_data[_SORT]](raw_data)

    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()
        return self.display_name(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
        """
        # FIXME: At this time, this is just duplicating display() method
        name = person.get_primary_name()
        return self.display_name(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 ""
        return self.fn_array[name.display_as](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 name_grouping(self,db,person):
        return self.name_grouping_name(db,person.primary_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)

displayer = NameDisplay()