def __init__(self, database, options, user):
"""
Create the FamilyGroup object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the families of the database.
The option class carries its number, and the function
returning the list of filters.
incattrs - Whether to include attributes
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self._user = user
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
self._ = self._locale.translation.sgettext # needed for English
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.db = self.database
self.filter = menu.get_option_by_name('filter').get_filter()
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.gramps_ids = get_value('inc_id')
self.recursive = get_value('recursive')
self.missing_info = get_value('missinginfo')
self.generations = get_value('generations')
self.inc_fam_notes = get_value('incFamNotes')
self.inc_par_events = get_value('incParEvents')
self.inc_par_addr = get_value('incParAddr')
self.inc_par_notes = get_value('incParNotes')
self.inc_par_names = get_value('incParNames')
self.inc_par_mar = get_value('incParMar')
self.inc_rel_dates = get_value('incRelDates')
self.inc_chi_mar = get_value('incChiMar')
self.include_attrs = get_value('incattrs')
stdoptions.run_name_format_option(self, menu)
self.place_format = menu.get_option_by_name("place_format").get_value()
def __init__(self, database, options, user):
"""
Create the FanChart object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User instance
This report needs the following parameters (class variables)
that come in the options class.
maxgen - Maximum number of generations to include.
circle - Draw a full circle, half circle, or quarter circle.
background - Background color is generation dependent or white.
radial - Print radial texts roundabout or as upright as possible.
draw_empty - draw background when there is no information
same_style - use the same style for all generation
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = options.menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
self.max_generations = menu.get_option_by_name('maxgen').get_value()
self.circle = menu.get_option_by_name('circle').get_value()
self.background = menu.get_option_by_name('background').get_value()
self.radial = menu.get_option_by_name('radial').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.draw_empty = menu.get_option_by_name('draw_empty').get_value()
self.same_style = menu.get_option_by_name('same_style').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.graphic_style = []
self.text_style = []
for i in range(0, self.max_generations):
self.graphic_style.append('FC-Graphic' + '%02d' % i)
self.text_style.append('FC-Text' + '%02d' % i)
self.calendar = 0
self.height = 0
self.map = [None] * 2**self.max_generations
self.text = {}
def __init__(self, database, options, user):
"""
Create the Timeline object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - instance of gen.user.User()
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the people of the database.
The option class carries its number, and the function
returning the list of filters.
sortby - Sorting method to be used.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self._user = user
menu = options.menu
self.set_locale(options.menu.get_option_by_name('trans').get_value())
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(
self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.filter = menu.get_option_by_name('filter').get_filter()
self.fil_name = "(%s)" % self.filter.get_name(self._locale)
living_value = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == living_value:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)") % {
'option_name': living_desc
}
stdoptions.run_name_format_option(self, menu)
sort_func_num = menu.get_option_by_name('sortby').get_value()
sort_functions = _get_sort_functions(Sort(self.database))
self.sort_name = self._(sort_functions[sort_func_num][0])
self.sort_func = sort_functions[sort_func_num][1]
self.calendar = config.get('preferences.calendar-format-report')
self.plist = []
self.header = 2.6
def __init__(self, database, options, user):
"""
Create the KinshipReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
maxdescend - Maximum generations of descendants to include.
maxascend - Maximum generations of ancestors to include.
incspouses - Whether to include spouses.
inccousins - Whether to include cousins.
incaunts - Whether to include aunts/uncles/nephews/nieces.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.__db = self.database
self.max_descend = menu.get_option_by_name('maxdescend').get_value()
self.max_ascend = menu.get_option_by_name('maxascend').get_value()
self.inc_spouses = menu.get_option_by_name('incspouses').get_value()
self.inc_cousins = menu.get_option_by_name('inccousins').get_value()
self.inc_aunts = menu.get_option_by_name('incaunts').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.person = self.database.get_person_from_gramps_id(pid)
if self.person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self.rel_calc = get_relationship_calculator(reinit=True,
clocale=self._locale)
self.kinship_map = {}
self.spouse_map = {}
def __init__(self, database, options, user):
"""
Create the EndOfLineReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
# eol_map is a map whose:
# keys are the generations of the people
# values are a map whose:
# keys are person handles
# values are an array whose:
# elements are an array of ancestor person handles that link
# the eol person handle to the person or interest
# eol_map[generation][person_handle][pedigree_idx][ancestor_handle_idx]
#
# There is an array of pedigrees because one person could show up twice
# in one generation (descendants marrying). Most people only have one
# pedigree.
#
# eol_map is populated by get_eol() which calls itself recursively.
self.eol_map = {}
self.get_eol(self.center_person, 1, [])
def __init__(self, database, options, user):
"""
Create the AncestorReport object that produces the Ahnentafel report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
pagebbg - Whether to include page breaks between generations.
name_format - Preferred format to display names
incl_private - Whether to include private data
namebrk - Whether a line break should follow the name
inc_id - Whether to include Gramps IDs
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self.map = {}
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.max_generations = menu.get_option_by_name('maxgen').get_value()
self.pgbrk = menu.get_option_by_name('pagebbg').get_value()
self.opt_namebrk = menu.get_option_by_name('namebrk').get_value()
self.want_ids = menu.get_option_by_name('inc_id').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self.__narrator = Narrator(self.database,
use_fulldate=True,
nlocale=self._locale)
def __init__(self, database, options, user):
"""
Create the TagReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
tag - The tag each object must match to be included.
name_format - Preferred format to display names of people
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(
self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._lv = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == self._lv:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)") % {
'option_name': living_desc
}
self.tag = menu.get_option_by_name('tag').get_value()
if not self.tag:
raise ReportError(
_('Tag Report'),
_('You must first create a tag before running this report.'))
stdoptions.run_name_format_option(self, menu)
self.place_format = menu.get_option_by_name("place_format").get_value()
def __init__(self, database, options, user):
"""
Create HourGlass object that produces the report.
name_format - Preferred format to display names
incl_private - Whether to include private data
inc_id - Whether to include IDs.
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.__db = self.database
self.__used_people = []
self.__family_father = [] # links allocated from family to father
self.__family_mother = [] # links allocated from family to mother
self.__node_label = {} # labels of node for merge sosa number
self.max_descend = menu.get_option_by_name('maxdescend').get_value()
self.max_ascend = menu.get_option_by_name('maxascend').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.__db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.colorize = menu.get_option_by_name('color').get_value()
self.colors = {'male': menu.get_option_by_name('colormales').get_value(),
'female': menu.get_option_by_name('colorfemales').get_value(),
'unknown': menu.get_option_by_name('colorunknown').get_value(),
'family': menu.get_option_by_name('colorfamilies').get_value()
}
self.roundcorners = menu.get_option_by_name('roundcorners').get_value()
self.ahnentafel = menu.get_option_by_name('ahnentafel').get_value()
self.ahnentafelnum = menu.get_option_by_name('ahnentafelnum').get_value()
self.includeid = menu.get_option_by_name('inc_id').get_value()
arrow_str = menu.get_option_by_name('arrow').get_value()
if 'o' in arrow_str:
self.arrowheadstyle = 'normal'
else:
self.arrowheadstyle = 'none'
if 'c' in arrow_str:
self.arrowtailstyle = 'normal'
else:
self.arrowtailstyle = 'none'
stdoptions.run_name_format_option(self, menu)
def __init__(self, database, options, user):
"""
Create HourGlass object that produces the report.
name_format - Preferred format to display names
incl_private - Whether to include private data
incid - Whether to include IDs.
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
locale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, locale)
self.database = CacheProxyDb(self.database)
self.__db = self.database
self.__used_people = []
self.__family_father = [] # links allocated from family to father
self.__family_mother = [] # links allocated from family to mother
self.max_descend = menu.get_option_by_name('maxdescend').get_value()
self.max_ascend = menu.get_option_by_name('maxascend').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.__db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
# Would be nice to get rid of these 2 hard-coded arrays of colours
# and instead allow the user to pick-and-choose whatever colour they
# want. When/if this is done, take a look at the colour-selection
# widget and code used in the FamilyLines graph. FIXME
colored = {
'male': 'dodgerblue4',
'female': 'deeppink',
'unknown': 'black',
'family': 'darkgreen'
}
filled = {
'male': 'lightblue',
'female': 'lightpink',
'unknown': 'lightgray',
'family': 'lightyellow'
}
self.colorize = menu.get_option_by_name('color').get_value()
if self.colorize == 'colored':
self.colors = colored
elif self.colorize == 'filled':
self.colors = filled
self.roundcorners = menu.get_option_by_name('roundcorners').get_value()
self.includeid = menu.get_option_by_name('incid').get_value()
stdoptions.run_name_format_option(self, menu)
def __init__(self, database, options, user):
"""
Create the DescendantReport object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
name_format - Preferred format to display names
dups - Whether to include duplicate descendant trees
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
self._locale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.max_generations = menu.get_option_by_name('gen').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
#Initialize the Printinfo class
self._showdups = menu.get_option_by_name('dups').get_value()
numbering = menu.get_option_by_name('numbering').get_value()
if numbering == "Simple":
obj = PrintSimple(self._showdups)
elif numbering == "de Villiers/Pama":
obj = PrintVilliers()
elif numbering == "Meurgey de Tupigny":
obj = PrintMeurgey()
else:
raise AttributeError("no such numbering: '%s'" % numbering)
marrs = menu.get_option_by_name('marrs').get_value()
divs = menu.get_option_by_name('divs').get_value()
stdoptions.run_name_format_option(self, menu)
self.obj_print = Printinfo(self.doc, self.database, obj, marrs, divs,
self._name_display, self._locale)
def __init__(self, database, options, user):
"""
Create the FanChart object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User instance
This report needs the following parameters (class variables)
that come in the options class.
maxgen - Maximum number of generations to include.
circle - Draw a full circle, half circle, or quarter circle.
background - Background color is generation dependent or white.
radial - Print radial texts roundabout or as upright as possible.
draw_empty - draw background when there is no information
same_style - use the same style for all generation
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = options.menu.get_option_by_name("trans").get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
self.max_generations = menu.get_option_by_name("maxgen").get_value()
self.circle = menu.get_option_by_name("circle").get_value()
self.background = menu.get_option_by_name("background").get_value()
self.radial = menu.get_option_by_name("radial").get_value()
pid = menu.get_option_by_name("pid").get_value()
self.draw_empty = menu.get_option_by_name("draw_empty").get_value()
self.same_style = menu.get_option_by_name("same_style").get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.graphic_style = []
self.text_style = []
for i in range(0, self.max_generations):
self.graphic_style.append("FC-Graphic" + "%02d" % i)
self.text_style.append("FC-Text" + "%02d" % i)
self.calendar = 0
self.height = 0
self.map = [None] * 2 ** self.max_generations
self.text = {}
def __init__(self, database, options, user):
"""
Create the FamilyGroup object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the families of the database.
The option class carries its number, and the function
returning the list of filters.
incattrs - Whether to include attributes
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self._user = user
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
self._ = self._locale.translation.sgettext # needed for English
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.db = self.database
self.filter = menu.get_option_by_name('filter').get_filter()
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.gramps_ids = get_value('inc_id')
self.recursive = get_value('recursive')
self.missing_info = get_value('missinginfo')
self.generations = get_value('generations')
self.inc_fam_notes = get_value('incFamNotes')
self.inc_par_events = get_value('incParEvents')
self.inc_par_addr = get_value('incParAddr')
self.inc_par_notes = get_value('incParNotes')
self.inc_par_names = get_value('incParNames')
self.inc_par_mar = get_value('incParMar')
self.inc_rel_dates = get_value('incRelDates')
self.inc_chi_mar = get_value('incChiMar')
self.include_attrs = get_value('incattrs')
stdoptions.run_name_format_option(self, menu)
self.place_format = menu.get_option_by_name("place_format").get_value()
def __init__(self, database, options, user):
"""
This report needs the following parameters (class variables)
that come in the options class.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = options.menu.get_option_by_name('trans').get_value()
self._locale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(
self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._lv = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == self._lv:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)") % {
'option_name': living_desc
}
filter_option = menu.get_option_by_name('filter')
self.filter = filter_option.get_filter()
self.top_size = menu.get_option_by_name('top_size').get_value()
self.callname = menu.get_option_by_name('callname').get_value()
self.footer = menu.get_option_by_name('footer').get_value()
self.include = {}
for (text, varname, default) in RECORDS:
self.include[varname] = menu.get_option_by_name(
varname).get_value()
self._nf = stdoptions.run_name_format_option(self, menu)
def __init__(self, database, options, user):
"""
Create the KinshipReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
maxdescend - Maximum generations of descendants to include.
maxascend - Maximum generations of ancestors to include.
incspouses - Whether to include spouses.
inccousins - Whether to include cousins.
incaunts - Whether to include aunts/uncles/nephews/nieces.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.__db = self.database
self.max_descend = menu.get_option_by_name('maxdescend').get_value()
self.max_ascend = menu.get_option_by_name('maxascend').get_value()
self.inc_spouses = menu.get_option_by_name('incspouses').get_value()
self.inc_cousins = menu.get_option_by_name('inccousins').get_value()
self.inc_aunts = menu.get_option_by_name('incaunts').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.person = self.database.get_person_from_gramps_id(pid)
if self.person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self.rel_calc = get_relationship_calculator(reinit=True,
clocale=self._locale)
self.kinship_map = {}
self.spouse_map = {}
def __init__(self, database, options, user):
"""
Create the Timeline object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - instance of gen.user.User()
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the people of the database.
The option class carries its number, and the function
returning the list of filters.
sortby - Sorting method to be used.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self._user = user
menu = options.menu
lang = options.menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
self.filter = menu.get_option_by_name('filter').get_filter()
self.fil_name = "(%s)" % self.filter.get_name(rlocale)
living_value = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == living_value:
living_desc = self._(description)
break
self.living_desc = self._(
"(Living people: %(option_name)s)") % {'option_name': living_desc}
stdoptions.run_name_format_option(self, menu)
sort_func_num = menu.get_option_by_name('sortby').get_value()
sort_functions = _get_sort_functions(Sort(self.database))
self.sort_name = self._(sort_functions[sort_func_num][0])
self.sort_func = sort_functions[sort_func_num][1]
self.calendar = config.get('preferences.calendar-format-report')
self.plist = []
self.header = 2.6
def __init__(self, database, options, user):
"""
Create the EndOfLineReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
# eol_map is a map whose:
# keys are the generations of the people
# values are a map whose:
# keys are person handles
# values are an array whose:
# elements are an array of ancestor person handles that link
# the eol person handle to the person or interest
# eol_map[generation][person_handle][pedigree_idx][ancestor_handle_idx]
#
# There is an array of pedigrees because one person could show up twice
# in one generation (descendants marrying). Most people only have one
# pedigree.
#
# eol_map is populated by get_eol() which calls itself recursively.
self.eol_map = {}
self.get_eol(self.center_person, 1, [])
def __init__(self, database, options, user):
"""
Create AncestorTree object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
"""
Report.__init__(self, database, options, user)
self.options = options
self._user = user
lang = options.menu.get_option_by_name('trans').get_value()
self._locale = self.set_locale(lang)
stdoptions.run_private_data_option(self, options.menu)
stdoptions.run_living_people_option(self, options.menu, self._locale)
self.database = CacheProxyDb(self.database)
stdoptions.run_name_format_option(self, options.menu)
self._nd = self._name_display
def __init__(self, database, options, user):
"""
Create the AncestorReport object that produces the Ahnentafel report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
pagebbg - Whether to include page breaks between generations.
name_format - Preferred format to display names
incl_private - Whether to include private data
namebrk - Whether a line break should follow the name
inc_id - Whether to include Gramps IDs
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self.map = {}
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.max_generations = menu.get_option_by_name('maxgen').get_value()
self.pgbrk = menu.get_option_by_name('pagebbg').get_value()
self.opt_namebrk = menu.get_option_by_name('namebrk').get_value()
self.want_ids = menu.get_option_by_name('inc_id').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self.__narrator = Narrator(self.database, use_fulldate=True,
nlocale=self._locale)
def __init__(self, database, options, user):
"""
Create the TagReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
tag - The tag each object must match to be included.
name_format - Preferred format to display names of people
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu,
self._locale)
self.database = CacheProxyDb(self.database)
self._lv = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == self._lv:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)"
) % {'option_name' : living_desc}
self.tag = menu.get_option_by_name('tag').get_value()
if not self.tag:
raise ReportError(
_('Tag Report'),
_('You must first create a tag before running this report.'))
stdoptions.run_name_format_option(self, menu)
self.place_format = menu.get_option_by_name("place_format").get_value()
def __init__(self, database, options, user):
"""
This report needs the following parameters (class variables)
that come in the options class.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = options.menu.get_option_by_name('trans').get_value()
self._locale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu,
self._locale)
self.database = CacheProxyDb(self.database)
self._lv = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == self._lv:
living_desc = self._(description)
break
self.living_desc = self._(
"(Living people: %(option_name)s)") % {'option_name': living_desc}
filter_option = menu.get_option_by_name('filter')
self.filter = filter_option.get_filter()
self.top_size = menu.get_option_by_name('top_size').get_value()
self.callname = menu.get_option_by_name('callname').get_value()
self.footer = menu.get_option_by_name('footer').get_value()
self.include = {}
for (text, varname, default) in RECORDS:
self.include[varname] = menu.get_option_by_name(varname).get_value()
self._nf = stdoptions.run_name_format_option(self, menu)
def __init__(self, database, options, user):
"""
Create the SummaryReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
incl_private - Whether to count private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self.set_locale(options.menu.get_option_by_name('trans').get_value())
stdoptions.run_private_data_option(self, options.menu)
stdoptions.run_living_people_option(self, options.menu, self._locale)
self.database = CacheProxyDb(self.database)
self.__db = self.database
def __init__(self, database, options, user):
"""
Create AncestorTree object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
"""
Report.__init__(self, database, options, user)
self.options = options
self._user = user
self.set_locale(options.menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, options.menu)
stdoptions.run_private_data_option(self, options.menu)
stdoptions.run_living_people_option(self, options.menu, self._locale)
self.database = CacheProxyDb(self.database)
stdoptions.run_name_format_option(self, options.menu)
self._nd = self._name_display
def __init__(self, database, options, user):
"""
Create the DetAncestorReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
inc_id - Whether to include Gramps IDs
pagebgg - Whether to include page breaks between generations.
pageben - Whether to include page break before End Notes.
firstName - Whether to use first names instead of pronouns.
fulldate - Whether to use full dates instead of just year.
listchildren - Whether to list children.
list_children_spouses - Whether to list the spouses of the children
includenotes - Whether to include notes.
incattrs - Whether to include attributes
blankplace - Whether to replace missing Places with ___________.
blankDate - Whether to replace missing Dates with ___________.
calcageflag - Whether to compute age.
dupperson - Whether to omit duplicate ancestors
(e.g. when distant cousins marry).
verbose - Whether to use complete sentences
childref - Whether to add descendant references in child list.
addimages - Whether to include images.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
other_events - Whether to include other events.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self.map = {}
self._user = user
menu = options.menu
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.max_generations = get_value('gen')
self.pgbrk = get_value('pagebbg')
self.pgbrkenotes = get_value('pageben')
self.fulldate = get_value('fulldates')
use_fulldate = self.fulldate
self.listchildren = get_value('listc')
self.list_children_spouses = get_value('listc_spouses')
self.includenotes = get_value('incnotes')
use_call = get_value('usecall')
blankplace = get_value('repplace')
blankdate = get_value('repdate')
self.calcageflag = get_value('computeage')
self.dupperson = get_value('omitda')
self.verbose = get_value('verbose')
self.childref = get_value('desref')
self.addimages = get_value('incphotos')
self.inc_names = get_value('incnames')
self.inc_events = get_value('incevents')
self.inc_addr = get_value('incaddresses')
self.inc_sources = get_value('incsources')
self.inc_srcnotes = get_value('incsrcnotes')
self.inc_attrs = get_value('incattrs')
self.initial_sosa = get_value('initial_sosa')
self.want_ids = get_value('inc_id')
pid = get_value('pid')
self.other_events = get_value('incotherevents')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self._nd = self._name_display
self.place_format = menu.get_option_by_name("place_format").get_value()
self.gen_handles = {}
self.prev_gen_handles = {}
if blankdate:
empty_date = EMPTY_ENTRY
else:
empty_date = ""
if blankplace:
empty_place = EMPTY_ENTRY
else:
empty_place = ""
self.__narrator = Narrator(self._db,
self.verbose,
use_call,
use_fulldate,
empty_date,
empty_place,
nlocale=self._locale,
place_format=self.place_format,
get_endnote_numbers=self.endnotes)
self.bibli = Bibliography(Bibliography.MODE_DATE
| Bibliography.MODE_PAGE)
def __init__(self, database, options, user):
"""
Create RelGraphReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the people of the database.
The option class carries its number, and the function
returning the list of filters.
arrow - Arrow styles for heads and tails.
showfamily - Whether to show family nodes.
inc_id - Whether to include IDs.
url - Whether to include URLs.
inclimg - Include images or not
imgpos - Image position, above/beside name
color - Whether to use outline, colored outline or filled color
in graph
color_males - Colour to apply to males
color_females - Colour to apply to females
color_unknown - Colour to apply to unknown genders
color_families - Colour to apply to families
dashed - Whether to use dashed lines for non-birth relationships
use_roundedcorners - Whether to use rounded corners for females
name_format - Preferred format to display names
incl_private - Whether to include private data
event_choice - Whether to include dates and/or places
occupation - Whether to include occupations
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
get_option_by_name = options.menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.includeid = get_value('inc_id')
self.includeurl = get_value('url')
self.includeimg = get_value('includeImages')
self.imgpos = get_value('imageOnTheSide')
self.use_roundedcorners = get_value('useroundedcorners')
self.adoptionsdashed = get_value('dashed')
self.show_families = get_value('showfamily')
self.use_subgraphs = get_value('usesubgraphs')
self.event_choice = get_value('event_choice')
self.occupation = get_value('occupation')
self.use_html_output = False
self.colorize = get_value('color')
color_males = get_value('colormales')
color_females = get_value('colorfemales')
color_unknown = get_value('colorunknown')
color_families = get_value('colorfamilies')
self.colors = {
'male': color_males,
'female': color_females,
'unknown': color_unknown,
'family': color_families
}
arrow_str = get_value('arrow')
if 'd' in arrow_str:
self.arrowheadstyle = 'normal'
else:
self.arrowheadstyle = 'none'
if 'a' in arrow_str:
self.arrowtailstyle = 'normal'
else:
self.arrowtailstyle = 'none'
filter_option = get_option_by_name('filter')
self._filter = filter_option.get_filter()
stdoptions.run_name_format_option(self, menu)
pid = get_value('pid')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.increlname = get_value('increlname')
if self.increlname:
self.rel_calc = get_relationship_calculator(reinit=True,
clocale=self._locale)
if __debug__:
self.advrelinfo = get_value('advrelinfo')
else:
self.advrelinfo = False
class DetAncestorReport(Report):
""" the Detailed Ancestor Report """
def __init__(self, database, options, user):
"""
Create the DetAncestorReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
inc_id - Whether to include Gramps IDs
pagebgg - Whether to include page breaks between generations.
pageben - Whether to include page break before End Notes.
firstName - Whether to use first names instead of pronouns.
fulldate - Whether to use full dates instead of just year.
listchildren - Whether to list children.
list_children_spouses - Whether to list the spouses of the children
includenotes - Whether to include notes.
incattrs - Whether to include attributes
blankplace - Whether to replace missing Places with ___________.
blankDate - Whether to replace missing Dates with ___________.
calcageflag - Whether to compute age.
dupperson - Whether to omit duplicate ancestors
(e.g. when distant cousins marry).
verbose - Whether to use complete sentences
childref - Whether to add descendant references in child list.
addimages - Whether to include images.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
other_events - Whether to include other events.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self.map = {}
self._user = user
menu = options.menu
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.max_generations = get_value('gen')
self.pgbrk = get_value('pagebbg')
self.pgbrkenotes = get_value('pageben')
self.fulldate = get_value('fulldates')
use_fulldate = self.fulldate
self.listchildren = get_value('listc')
self.list_children_spouses = get_value('listc_spouses')
self.includenotes = get_value('incnotes')
use_call = get_value('usecall')
blankplace = get_value('repplace')
blankdate = get_value('repdate')
self.calcageflag = get_value('computeage')
self.dupperson = get_value('omitda')
self.verbose = get_value('verbose')
self.childref = get_value('desref')
self.addimages = get_value('incphotos')
self.inc_names = get_value('incnames')
self.inc_events = get_value('incevents')
self.inc_addr = get_value('incaddresses')
self.inc_sources = get_value('incsources')
self.inc_srcnotes = get_value('incsrcnotes')
self.inc_attrs = get_value('incattrs')
self.initial_sosa = get_value('initial_sosa')
self.want_ids = get_value('inc_id')
pid = get_value('pid')
self.other_events = get_value('incotherevents')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self._nd = self._name_display
self.place_format = menu.get_option_by_name("place_format").get_value()
self.gen_handles = {}
self.prev_gen_handles = {}
if blankdate:
empty_date = EMPTY_ENTRY
else:
empty_date = ""
if blankplace:
empty_place = EMPTY_ENTRY
else:
empty_place = ""
self.__narrator = Narrator(self._db,
self.verbose,
use_call,
use_fulldate,
empty_date,
empty_place,
nlocale=self._locale,
place_format=self.place_format,
get_endnote_numbers=self.endnotes)
self.bibli = Bibliography(Bibliography.MODE_DATE
| Bibliography.MODE_PAGE)
def apply_filter(self, person_handle, index):
""" recurse up through the generations """
if (not person_handle) or (index >= 2**self.max_generations):
return
self.map[index] = person_handle
person = self._db.get_person_from_handle(person_handle)
family_handle = person.get_main_parents_family_handle()
if family_handle:
family = self._db.get_family_from_handle(family_handle)
self.apply_filter(family.get_father_handle(), index * 2)
self.apply_filter(family.get_mother_handle(), (index * 2) + 1)
def write_report(self):
self.apply_filter(self.center_person.get_handle(), 1)
name = self._nd.display_name(self.center_person.get_primary_name())
if not name:
name = self._("Unknown")
self.doc.start_paragraph("DAR-Title")
# feature request 2356: avoid genitive form
title = self._("Ancestral Report for %s") % name
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
generation = 0
for key in sorted(self.map):
if generation == 0 or key >= 2**generation:
if self.pgbrk and generation > 0:
self.doc.page_break()
self.doc.start_paragraph("DAR-Generation")
text = self._("Generation %d") % (generation + 1)
mark = IndexMark(text, INDEX_TYPE_TOC, 2)
self.doc.write_text(text, mark)
self.doc.end_paragraph()
generation += 1
if self.childref:
self.prev_gen_handles = self.gen_handles.copy()
self.gen_handles.clear()
person_handle = self.map[key]
person = self._db.get_person_from_handle(person_handle)
self.gen_handles[person_handle] = key
dupperson = self.write_person(key)
if dupperson == 0: # Is this a duplicate ind record
if self.listchildren or self.inc_events:
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
mother_handle = family.get_mother_handle()
if (mother_handle is None
or mother_handle not in iter(self.map.values())
or person.get_gender() == Person.FEMALE):
# The second test above also covers the 1. person's
# mate, which is not an ancestor and as such is not
# included in the self.map dictionary
if self.listchildren:
self.write_children(family)
if self.inc_events:
self.write_family_events(family)
if self.inc_sources:
if self.pgbrkenotes:
self.doc.page_break()
# it ignores language set for Note type (use locale)
endnotes.write_endnotes(self.bibli,
self._db,
self.doc,
printnotes=self.inc_srcnotes,
elocale=self._locale)
def _get_s_s(self, key):
"""returns Sosa-Stradonitz (a.k.a. Kekule or Ahnentafel) number"""
generation = int(math.floor(math.log(key, 2))) # 0
gen_start = pow(2, generation) # 1
new_gen_start = self.initial_sosa * gen_start # 3
return new_gen_start + (key - gen_start) # 3+0
def write_person(self, key):
""" Output birth, death, parentage, marriage and notes information """
def write_more_header(first, name):
""" convenience function """
if first:
self.doc.start_paragraph('DAR-MoreHeader')
self.doc.write_text(
self._('More about %(person_name)s:') %
{'person_name': name})
self.doc.end_paragraph()
return False
person_handle = self.map[key]
person = self._db.get_person_from_handle(person_handle)
plist = person.get_media_list()
self.__narrator.set_subject(person)
if self.addimages and len(plist) > 0:
photo = plist[0]
utils.insert_image(self._db, self.doc, photo, self._user)
self.doc.start_paragraph("DAR-First-Entry", "%d." % self._get_s_s(key))
name = self._nd.display(person)
if not name:
name = self._("Unknown")
mark = utils.get_person_mark(self._db, person)
self.doc.start_bold()
self.doc.write_text(name, mark)
if name[-1:] == '.':
self.doc.write_text_citation("%s " % self.endnotes(person))
elif name:
self.doc.write_text_citation("%s. " % self.endnotes(person))
self.doc.end_bold()
if self.want_ids:
self.doc.write_text('(%s) ' % person.get_gramps_id())
if self.dupperson:
# Check for duplicate record (result of distant cousins marrying)
for dkey in sorted(self.map):
if dkey >= key:
break
if self.map[key] == self.map[dkey]:
self.doc.write_text(
self._("%(name)s is the same person as [%(id_str)s].")
% {
'name': '',
'id_str': str(dkey)
})
self.doc.end_paragraph()
return 1 # Duplicate person
if not self.verbose:
self.write_parents(person)
text = self.__narrator.get_born_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_baptised_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_christened_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_died_string(self.calcageflag)
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_buried_string()
if text:
self.doc.write_text_citation(text)
if self.verbose:
self.write_parents(person)
if not key % 2 or key == 1:
self.write_marriage(person)
self.doc.end_paragraph()
if key == 1:
self.write_mate(person)
notelist = person.get_note_list()
if len(notelist) > 0 and self.includenotes:
self.doc.start_paragraph("DAR-NoteHeader")
# feature request 2356: avoid genitive form
self.doc.write_text(self._("Notes for %s") % name)
self.doc.end_paragraph()
for notehandle in notelist:
note = self._db.get_note_from_handle(notehandle)
self.doc.write_styled_note(
note.get_styledtext(),
note.get_format(),
"DAR-Entry",
contains_html=(note.get_type() == NoteType.HTML_CODE))
first = True
if self.inc_names:
for alt_name in person.get_alternate_names():
first = write_more_header(first, name)
self.doc.start_paragraph('DAR-MoreDetails')
atype = self._get_type(alt_name.get_type())
self.doc.write_text_citation(
self._('%(type)s: %(value)s%(endnotes)s') % {
'type': self._(atype),
'value': alt_name.get_regular_name(),
'endnotes': self.endnotes(alt_name)
})
self.doc.end_paragraph()
if self.inc_events:
birth_ref = person.get_birth_ref()
death_ref = person.get_death_ref()
for event_ref in person.get_primary_event_ref_list():
if event_ref == birth_ref or event_ref == death_ref:
continue
first = write_more_header(first, name)
self.write_event(event_ref)
if self.other_events:
for event_ref in person.get_event_ref_list():
role = event_ref.get_role()
if role in (EventRoleType.PRIMARY, EventRoleType.FAMILY):
continue
first = write_more_header(first, name)
self.write_event(event_ref)
if self.inc_addr:
for addr in person.get_address_list():
first = write_more_header(first, name)
self.doc.start_paragraph('DAR-MoreDetails')
text = utils.get_address_str(addr)
self.doc.write_text(self._('Address: '))
if self.fulldate:
date = self._get_date(addr.get_date_object())
else:
date = addr.get_date_object().get_year()
if date:
# translators: needed for Arabic, ignore otherwise
self.doc.write_text(self._('%s, ') % date)
self.doc.write_text(text)
self.doc.write_text_citation(self.endnotes(addr))
self.doc.end_paragraph()
if self.inc_attrs:
attrs = person.get_attribute_list()
if attrs:
first = write_more_header(first, name)
for attr in attrs:
self.doc.start_paragraph('DAR-MoreDetails')
attr_name = attr.get_type().type2base()
# translators: needed for French, ignore otherwise
text = self._("%(type)s: %(value)s%(endnotes)s") % {
'type': self._(attr_name),
'value': attr.get_value(),
'endnotes': self.endnotes(attr)
}
self.doc.write_text_citation(text)
self.doc.end_paragraph()
return 0 # Not duplicate person
def write_event(self, event_ref):
""" write out the event """
text = ""
event = self._db.get_event_from_handle(event_ref.ref)
if self.fulldate:
date = self._get_date(event.get_date_object())
else:
date = event.get_date_object().get_year()
place = _pd.display_event(self._db, event, self.place_format)
self.doc.start_paragraph('DAR-MoreDetails')
if date and place:
# translators: needed for Arabic, ignore otherwise
text += self._('%(str1)s, %(str2)s') % {
'str1': date,
'str2': place
}
elif date:
text += '%s' % date
elif place:
text += '%s' % self._(place)
if event.get_description():
if text:
text += ". "
text += event.get_description()
text += self.endnotes(event)
if text:
text += ". "
event_name = self._(self._get_type(event.get_type()))
role = event_ref.get_role()
if role in (EventRoleType.PRIMARY, EventRoleType.FAMILY):
# translators: needed for French, ignore otherwise
text = self._('%(str1)s: %(str2)s') % {
'str1': event_name,
'str2': text
}
else:
primaries = get_participant_from_event(self._db, event_ref.ref)
text = self._('%(event_role)s at %(event_name)s '
'of %(primary_person)s: %(event_text)s') % {
'event_role': self._(role.xml_str()),
'event_name': event_name,
'primary_person': primaries,
'event_text': text
}
self.doc.write_text_citation(text)
if self.inc_attrs:
text = ""
attr_list = event.get_attribute_list()
attr_list.extend(event_ref.get_attribute_list())
for attr in attr_list:
if text:
# translators: needed for Arabic, ignore otherwise
text += self._("; ")
attr_name = attr.get_type().type2base()
# translators: needed for French, ignore otherwise
text += self._("%(type)s: %(value)s%(endnotes)s") % {
'type': self._(attr_name),
'value': attr.get_value(),
'endnotes': self.endnotes(attr)
}
text = " " + text
self.doc.write_text_citation(text)
self.doc.end_paragraph()
if self.includenotes:
# if the event or event reference has a note attached to it,
# get the text and format it correctly
notelist = event.get_note_list()
notelist.extend(event_ref.get_note_list())
for notehandle in notelist:
note = self._db.get_note_from_handle(notehandle)
self.doc.write_styled_note(
note.get_styledtext(),
note.get_format(),
"DAR-MoreDetails",
contains_html=(note.get_type() == NoteType.HTML_CODE))
def write_parents(self, person):
""" write the parents """
family_handle = person.get_main_parents_family_handle()
if family_handle:
family = self._db.get_family_from_handle(family_handle)
mother_handle = family.get_mother_handle()
father_handle = family.get_father_handle()
if mother_handle:
mother = self._db.get_person_from_handle(mother_handle)
mother_name = self._nd.display_name(mother.get_primary_name())
mother_mark = utils.get_person_mark(self._db, mother)
else:
mother_name = ""
mother_mark = ""
if father_handle:
father = self._db.get_person_from_handle(father_handle)
father_name = self._nd.display_name(father.get_primary_name())
father_mark = utils.get_person_mark(self._db, father)
else:
father_name = ""
father_mark = ""
text = self.__narrator.get_child_string(father_name, mother_name)
if text:
self.doc.write_text(text)
if father_mark:
self.doc.write_text("", father_mark)
if mother_mark:
self.doc.write_text("", mother_mark)
def write_marriage(self, person):
"""
Output marriage sentence.
"""
is_first = True
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
spouse_handle = utils.find_spouse(person, family)
if spouse_handle:
spouse = self._db.get_person_from_handle(spouse_handle)
spouse_mark = utils.get_person_mark(self._db, spouse)
else:
spouse_mark = None
text = self.__narrator.get_married_string(family, is_first,
self._nd)
if text:
self.doc.write_text_citation(text, spouse_mark)
if self.want_ids:
self.doc.write_text(' (%s)' % family.get_gramps_id())
is_first = False
def write_children(self, family):
"""
List children.
:param family: Family
:return:
"""
if not family.get_child_ref_list():
return
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self._db.get_person_from_handle(mother_handle)
mother_name = self._nd.display(mother)
if not mother_name:
mother_name = self._("Unknown")
else:
mother_name = self._("Unknown")
father_handle = family.get_father_handle()
if father_handle:
father = self._db.get_person_from_handle(father_handle)
father_name = self._nd.display(father)
if not father_name:
father_name = self._("Unknown")
else:
father_name = self._("Unknown")
self.doc.start_paragraph("DAR-ChildTitle")
self.doc.write_text(
self._("Children of %(mother_name)s and %(father_name)s") % {
'father_name': father_name,
'mother_name': mother_name
})
self.doc.end_paragraph()
cnt = 1
for child_ref in family.get_child_ref_list():
child_handle = child_ref.ref
child = self._db.get_person_from_handle(child_handle)
child_name = self._nd.display(child)
if not child_name:
child_name = self._("Unknown")
child_mark = utils.get_person_mark(self._db, child)
if self.childref and self.prev_gen_handles.get(child_handle):
value = int(self.prev_gen_handles.get(child_handle))
child_name += " [%d]" % self._get_s_s(value)
self.doc.start_paragraph("DAR-ChildList",
utils.roman(cnt).lower() + ".")
cnt += 1
self.__narrator.set_subject(child)
if child_name:
self.doc.write_text("%s. " % child_name, child_mark)
if self.want_ids:
self.doc.write_text('(%s) ' % child.get_gramps_id())
self.doc.write_text_citation(
self.__narrator.get_born_string()
or self.__narrator.get_christened_string()
or self.__narrator.get_baptised_string())
self.doc.write_text_citation(
self.__narrator.get_died_string()
or self.__narrator.get_buried_string())
# if the list_children_spouses option is selected:
if self.list_children_spouses:
# get the family of the child that contains the spouse
# of the child. There may be more than one spouse for each
# child
family_handle_list = child.get_family_handle_list()
# for the first spouse, this is true.
# For subsequent spouses, make it false
is_first_family = True
for family_handle in family_handle_list:
child_family = self.database.get_family_from_handle(
family_handle)
self.doc.write_text_citation(
self.__narrator.get_married_string(
child_family, is_first_family, self._name_display))
is_first_family = False
self.doc.end_paragraph()
def write_family_events(self, family):
""" write the family events """
if not family.get_event_ref_list():
return
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self._db.get_person_from_handle(mother_handle)
mother_name = self._nd.display(mother)
if not mother_name:
mother_name = self._("Unknown")
else:
mother_name = self._("Unknown")
father_handle = family.get_father_handle()
if father_handle:
father = self._db.get_person_from_handle(father_handle)
father_name = self._nd.display(father)
if not father_name:
father_name = self._("Unknown")
else:
father_name = self._("Unknown")
first = True
for event_ref in family.get_event_ref_list():
if first:
self.doc.start_paragraph('DAR-MoreHeader')
self.doc.write_text(
self._('More about %(mother_name)s and %(father_name)s:') %
{
'mother_name': mother_name,
'father_name': father_name
})
self.doc.end_paragraph()
first = False
self.write_event(event_ref)
def write_mate(self, person):
"""Output birth, death, parentage, marriage and notes information """
ind = None
has_info = False
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
ind_handle = None
if person.get_gender() == Person.MALE:
ind_handle = family.get_mother_handle()
else:
ind_handle = family.get_father_handle()
if ind_handle:
ind = self._db.get_person_from_handle(ind_handle)
for event_ref in ind.get_primary_event_ref_list():
event = self._db.get_event_from_handle(event_ref.ref)
if event:
etype = event.get_type()
if (etype == EventType.BAPTISM
or etype == EventType.BURIAL
or etype == EventType.BIRTH
or etype == EventType.DEATH):
has_info = True
break
if not has_info:
family_handle = ind.get_main_parents_family_handle()
if family_handle:
fam = self._db.get_family_from_handle(family_handle)
if fam.get_mother_handle() or fam.get_father_handle():
has_info = True
break
if has_info:
self.doc.start_paragraph("DAR-MoreHeader")
plist = ind.get_media_list()
if self.addimages and len(plist) > 0:
photo = plist[0]
utils.insert_image(self._db, self.doc, photo, self._user)
name = self._nd.display(ind)
if not name:
name = self._("Unknown")
mark = utils.get_person_mark(self._db, ind)
if family.get_relationship() == FamilyRelType.MARRIED:
self.doc.write_text(self._("Spouse: %s") % name, mark)
else:
self.doc.write_text(
self._("Relationship with: %s") % name, mark)
if name[-1:] != '.':
self.doc.write_text(".")
if self.want_ids:
self.doc.write_text(' (%s)' % ind.get_gramps_id())
self.doc.write_text_citation(self.endnotes(ind))
self.doc.end_paragraph()
self.doc.start_paragraph("DAR-Entry")
self.__narrator.set_subject(ind)
text = self.__narrator.get_born_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_baptised_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_christened_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_died_string(self.calcageflag)
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_buried_string()
if text:
self.doc.write_text_citation(text)
self.write_parents(ind)
self.doc.end_paragraph()
def endnotes(self, obj):
""" cite the endnotes for the object """
if not obj or not self.inc_sources:
return ""
txt = endnotes.cite_source(self.bibli, self._db, obj, self._locale)
if txt:
txt = '<super>' + txt + '</super>'
return txt
class TagReport(Report):
""" Tag Report """
def __init__(self, database, options, user):
"""
Create the TagReport object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
tag - The tag each object must match to be included.
name_format - Preferred format to display names of people
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
self._lv = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == self._lv:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)"
) % {'option_name' : living_desc}
self.tag = menu.get_option_by_name('tag').get_value()
if not self.tag:
raise ReportError(
_('Tag Report'),
_('You must first create a tag before running this report.'))
stdoptions.run_name_format_option(self, menu)
def write_report(self):
self.doc.start_paragraph("TR-Title")
# feature request 2356: avoid genitive form
title = self._("Tag Report for %s Items") % self.tag
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
if self._lv != LivingProxyDb.MODE_INCLUDE_ALL:
self.doc.start_paragraph("TR-ReportSubtitle")
self.doc.write_text(self.living_desc)
self.doc.end_paragraph()
self.write_people()
self.write_families()
self.write_events()
self.write_places()
self.write_notes()
self.write_media()
self.write_repositories()
self.write_sources()
self.write_citations()
def write_people(self):
""" write the people associated with the tag """
plist = self.database.iter_person_handles()
filter_class = GenericFilterFactory('Person')
a_filter = filter_class()
a_filter.add_rule(rules.person.HasTag([self.tag]))
ind_list = a_filter.apply(self.database, plist)
if not ind_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("People")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('PeopleTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Name"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Birth"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Death"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for person_handle in ind_list:
person = self.database.get_person_from_handle(person_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(person.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
name = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(name, mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
birth_ref = person.get_birth_ref()
if birth_ref:
event = self.database.get_event_from_handle(birth_ref.ref)
self.doc.write_text(self._get_date(event.get_date_object()))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
death_ref = person.get_death_ref()
if death_ref:
event = self.database.get_event_from_handle(death_ref.ref)
self.doc.write_text(self._get_date(event.get_date_object()))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_families(self):
""" write the families associated with the tag """
flist = self.database.iter_family_handles()
filter_class = GenericFilterFactory('Family')
a_filter = filter_class()
a_filter.add_rule(rules.family.HasTag([self.tag]))
fam_list = a_filter.apply(self.database, flist)
if not fam_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Families")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('FamilyTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Father"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Mother"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Relationship"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for family_handle in fam_list:
family = self.database.get_family_from_handle(family_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(family.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
father_handle = family.get_father_handle()
if father_handle:
father = self.database.get_person_from_handle(father_handle)
mark = utils.get_person_mark(self.database, father)
self.doc.write_text(self._name_display.display(father), mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self.database.get_person_from_handle(mother_handle)
mark = utils.get_person_mark(self.database, mother)
self.doc.write_text(self._name_display.display(mother), mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
relation = family.get_relationship()
self.doc.write_text(str(relation))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_events(self):
""" write the events associated with the tag """
elist = self.database.get_event_handles()
filter_class = GenericFilterFactory('Event')
a_filter = filter_class()
a_filter.add_rule(rules.event.HasTag([self.tag]))
event_list = a_filter.apply(self.database, elist)
if not event_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Events")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('EventTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Participants"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Date"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for event_handle in event_list:
event = self.database.get_event_from_handle(event_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(event.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(self._(self._get_type(event.get_type())))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(get_participant_from_event(self.database,
event_handle))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
date = self._get_date(event.get_date_object())
if date:
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_places(self):
""" write the places associated with the tag """
plist = self.database.get_place_handles()
filter_class = GenericFilterFactory('Place')
a_filter = filter_class()
a_filter.add_rule(rules.place.HasTag([self.tag]))
place_list = a_filter.apply(self.database, plist)
if not place_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Places")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('PlaceTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Title"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Name"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for place_handle in place_list:
place = self.database.get_place_from_handle(place_handle)
place_title = _pd.display(self.database, place)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(place.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(place_title)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(place.get_name().get_value())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(str(place.get_type()))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_notes(self):
""" write the notes associated with the tag """
nlist = self.database.get_note_handles()
filter_class = GenericFilterFactory('Note')
a_filter = filter_class()
a_filter.add_rule(rules.note.HasTag([self.tag]))
note_list = a_filter.apply(self.database, nlist)
if not note_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Notes")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('NoteTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell', 2)
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Text"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for note_handle in note_list:
note = self.database.get_note_from_handle(note_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(note.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
note_type = note.get_type()
self.doc.write_text(str(note_type))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell', 2)
self.doc.write_styled_note(
note.get_styledtext(), note.get_format(), 'TR-Note',
contains_html=((note.get_type() == NoteType.HTML_CODE)))
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_media(self):
""" write the media associated with the tag """
mlist = self.database.get_media_handles(sort_handles=True)
filter_class = GenericFilterFactory('Media')
a_filter = filter_class()
a_filter.add_rule(rules.media.HasTag([self.tag]))
media_list = a_filter.apply(self.database, mlist)
if not media_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Media")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('MediaTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Title"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Date"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for media_handle in media_list:
media = self.database.get_media_from_handle(media_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(media.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
title = media.get_description()
self.doc.write_text(str(title))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
mime_type = media.get_mime_type()
self.doc.write_text(str(mime_type))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
date = self._get_date(media.get_date_object())
if date:
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_repositories(self):
""" write the repositories associated with the tag """
rlist = self.database.get_repository_handles()
filter_class = GenericFilterFactory('Repository')
a_filter = filter_class()
a_filter.add_rule(rules.repository.HasTag([self.tag]))
repo_list = a_filter.apply(self.database, rlist)
if not repo_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Repositories")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('ReopTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Name"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Email Address"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for repo_handle in repo_list:
repo = self.database.get_repository_from_handle(repo_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(repo.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(repo.get_name())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(str(repo.get_type()))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
home_page = ''
for url in repo.get_url_list():
if url.get_type() == UrlType.EMAIL:
home_page = url.get_path()
break
self.doc.write_text(home_page)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_sources(self):
""" write the sources associated with the tag """
slist = self.database.get_source_handles(sort_handles=True)
filter_class = GenericFilterFactory('Source')
a_filter = filter_class()
a_filter.add_rule(rules.source.HasTag([self.tag]))
source_list = a_filter.apply(self.database, slist)
if not source_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Source")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('SourceTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Title"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Author"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Publication Information"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for source_handle in source_list:
source = self.database.get_source_from_handle(source_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(source.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(source.get_title())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(source.get_author())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(source.get_publication_info())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_citations(self):
""" write the citations associated with the tag """
clist = self.database.get_citation_handles(sort_handles=True)
filter_class = GenericFilterFactory('Citation')
a_filter = filter_class()
a_filter.add_rule(rules.citation.HasTag([self.tag]))
citation_list = a_filter.apply(self.database, clist)
if not citation_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Citations")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('CitationTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Volume/Page"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Date"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Source"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for citation_handle in citation_list:
citation = self.database.get_citation_from_handle(citation_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(citation.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(citation.get_page())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
date = self._get_date(citation.get_date_object())
if date:
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
source_handle = citation.get_reference_handle()
source = self.database.get_source_from_handle(source_handle)
self.doc.write_text(source.get_title())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
class RelGraphReport(Report):
def __init__(self, database, options, user):
"""
Create RelGraphReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the people of the database.
The option class carries its number, and the function
returning the list of filters.
arrow - Arrow styles for heads and tails.
showfamily - Whether to show family nodes.
inc_id - Whether to include IDs.
url - Whether to include URLs.
inclimg - Include images or not
imgpos - Image position, above/beside name
color - Whether to use outline, colored outline or filled color
in graph
color_males - Colour to apply to males
color_females - Colour to apply to females
color_unknown - Colour to apply to unknown genders
color_families - Colour to apply to families
dashed - Whether to use dashed lines for non-birth relationships
use_roundedcorners - Whether to use rounded corners for females
name_format - Preferred format to display names
incl_private - Whether to include private data
event_choice - Whether to include dates and/or places
occupation - Whether to include occupations
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
get_option_by_name = options.menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.includeid = get_value('inc_id')
self.includeurl = get_value('url')
self.includeimg = get_value('includeImages')
self.imgpos = get_value('imageOnTheSide')
self.use_roundedcorners = get_value('useroundedcorners')
self.adoptionsdashed = get_value('dashed')
self.show_families = get_value('showfamily')
self.use_subgraphs = get_value('usesubgraphs')
self.event_choice = get_value('event_choice')
self.occupation = get_value('occupation')
self.use_html_output = False
self.colorize = get_value('color')
color_males = get_value('colormales')
color_females = get_value('colorfemales')
color_unknown = get_value('colorunknown')
color_families = get_value('colorfamilies')
self.colors = {
'male': color_males,
'female': color_females,
'unknown': color_unknown,
'family': color_families
}
arrow_str = get_value('arrow')
if 'd' in arrow_str:
self.arrowheadstyle = 'normal'
else:
self.arrowheadstyle = 'none'
if 'a' in arrow_str:
self.arrowtailstyle = 'normal'
else:
self.arrowtailstyle = 'none'
filter_option = get_option_by_name('filter')
self._filter = filter_option.get_filter()
stdoptions.run_name_format_option(self, menu)
pid = get_value('pid')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.increlname = get_value('increlname')
if self.increlname:
self.rel_calc = get_relationship_calculator(reinit=True,
clocale=self._locale)
if __debug__:
self.advrelinfo = get_value('advrelinfo')
else:
self.advrelinfo = False
def write_report(self):
person_handles = self._filter.apply(self._db,
self._db.iter_person_handles(),
user=self._user)
# Hash people in a dictionary for faster inclusion checking
self.persons = set(person_handles)
person_handles = self.sort_persons(person_handles)
if len(person_handles) > 1:
if self._user:
self._user.begin_progress(_("Relationship Graph"),
_("Generating report"),
len(person_handles) * 2)
self.add_persons_and_families(person_handles)
self.add_child_links_to_families(person_handles)
if self._user:
self._user.end_progress()
def sort_persons(self, person_handle_list):
"sort persons by close relations"
# first make a list of all persons who don't have any parents
root_nodes = list()
for person_handle in person_handle_list:
person = self.database.get_person_from_handle(person_handle)
has_parent = False
for parent_handle in find_parents(self.database, person):
if parent_handle not in self.persons:
continue
has_parent = True
if not has_parent:
root_nodes.append(person_handle)
# now start from all root nodes we found and traverse their trees
outlist = list()
p_done = set()
for person_handle in root_nodes:
todolist = list()
todolist.append(person_handle)
while len(todolist) > 0:
# take the first person from todolist and do sanity check
cur = todolist.pop(0)
if cur in p_done:
continue
if cur not in self.persons:
p_done.add(cur)
continue
person = self.database.get_person_from_handle(cur)
# first check whether both parents are added
missing_parents = False
for parent_handle in find_parents(self.database, person):
if not parent_handle or parent_handle in p_done:
continue
if parent_handle not in self.persons:
continue
todolist.insert(0, parent_handle)
missing_parents = True
# if one of the parents is still missing, wait for them
if missing_parents:
continue
# add person to the sorted output
outlist.append(cur)
p_done.add(cur)
# add all spouses and children to the todo list
family_list = person.get_family_handle_list()
for fam_handle in family_list:
family = self.database.get_family_from_handle(fam_handle)
if family is None:
continue
if (family.get_father_handle() and
family.get_father_handle() != cur):
todolist.insert(0, family.get_father_handle())
if (family.get_mother_handle() and
family.get_mother_handle() != cur):
todolist.insert(0, family.get_mother_handle())
for child_ref in family.get_child_ref_list():
todolist.append(child_ref.ref)
# finally store the result
assert len(person_handle_list) == len(outlist)
return outlist
def add_child_links_to_families(self, person_handles):
"""
returns string of Graphviz edges linking parents to families or
children
"""
for person_handle in person_handles:
if self._user:
self._user.step_progress()
person = self._db.get_person_from_handle(person_handle)
p_id = person.get_gramps_id()
for fam_handle in person.get_parent_family_handle_list():
family = self._db.get_family_from_handle(fam_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
sibling = False
for child_ref in family.get_child_ref_list():
if child_ref.ref == person_handle:
frel = child_ref.frel
mrel = child_ref.mrel
elif child_ref.ref in self.persons:
sibling = True
if (self.show_families and
((father_handle and father_handle in self.persons) or
(mother_handle and mother_handle in self.persons) or
sibling)):
# Link to the family node if either parent is in graph
self.add_family_link(p_id, family, frel, mrel)
else:
# Link to the parents' nodes directly, if they are in graph
if father_handle and father_handle in self.persons:
self.add_parent_link(p_id, father_handle, frel)
if mother_handle and mother_handle in self.persons:
self.add_parent_link(p_id, mother_handle, mrel)
def add_family_link(self, p_id, family, frel, mrel):
"Links the child to a family"
style = 'solid'
adopted = ((int(frel) != ChildRefType.BIRTH) or
(int(mrel) != ChildRefType.BIRTH))
# If birth relation to father is NONE, meaning there is no father and
# if birth relation to mother is BIRTH then solid line
if (int(frel) == ChildRefType.NONE and
int(mrel) == ChildRefType.BIRTH):
adopted = False
if adopted and self.adoptionsdashed:
style = 'dotted'
self.doc.add_link(family.get_gramps_id(), p_id, style,
self.arrowheadstyle, self.arrowtailstyle)
def add_parent_link(self, p_id, parent_handle, rel):
"Links the child to a parent"
style = 'solid'
if (int(rel) != ChildRefType.BIRTH) and self.adoptionsdashed:
style = 'dotted'
parent = self._db.get_person_from_handle(parent_handle)
self.doc.add_link(parent.get_gramps_id(), p_id, style,
self.arrowheadstyle, self.arrowtailstyle)
def add_persons_and_families(self, person_handles):
"adds nodes for persons and their families"
# variable to communicate with get_person_label
self.use_html_output = False
# The list of families for which we have output the node,
# so we don't do it twice
families_done = set()
for person_handle in person_handles:
if self._user:
self._user.step_progress()
# determine per person if we use HTML style label
if self.includeimg:
self.use_html_output = True
person = self._db.get_person_from_handle(person_handle)
if person is None:
continue
p_id = person.get_gramps_id()
# Output the person's node
label = self.get_person_label(person)
(shape, style, color, fill) = self.get_gender_style(person)
url = ""
if self.includeurl:
phan = person_handle
dirpath = "ppl/%s/%s" % (phan[-1], phan[-2])
dirpath = dirpath.lower()
url = "%s/%s.html" % (dirpath, phan)
self.doc.add_node(p_id, label, shape, color, style, fill, url)
# Output families where person is a parent
if self.show_families:
family_list = person.get_family_handle_list()
for fam_handle in family_list:
family = self._db.get_family_from_handle(fam_handle)
if family is None:
continue
if fam_handle not in families_done:
families_done.add(fam_handle)
self.__add_family(fam_handle)
# If subgraphs are not chosen then each parent is linked
# separately to the family. This gives Graphviz greater
# control over the layout of the whole graph but
# may leave spouses not positioned together.
if not self.use_subgraphs:
self.doc.add_link(p_id, family.get_gramps_id(), "",
self.arrowheadstyle,
self.arrowtailstyle)
# Output families where person is a sibling if another sibling
# is present
family_list = person.get_parent_family_handle_list()
for fam_handle in family_list:
if fam_handle in families_done:
continue
family = self.database.get_family_from_handle(fam_handle)
if family is None:
continue
for child_ref in family.get_child_ref_list():
if (child_ref.ref != person_handle and
child_ref.ref in self.persons):
families_done.add(fam_handle)
self.__add_family(fam_handle)
def __add_family(self, fam_handle):
"""Add a node for a family and optionally link the spouses to it"""
fam = self._db.get_family_from_handle(fam_handle)
if fam is None:
return
fam_id = fam.get_gramps_id()
m_type = m_date = m_place = ""
d_type = d_date = d_place = ""
for event_ref in fam.get_event_ref_list():
event = self._db.get_event_from_handle(event_ref.ref)
if event is None:
continue
if (event.type == EventType.MARRIAGE and
(event_ref.get_role() == EventRoleType.FAMILY or
event_ref.get_role() == EventRoleType.PRIMARY)):
m_type = event.type
m_date = self.get_date_string(event)
if not (self.event_choice == 3 and m_date):
m_place = self.get_place_string(event)
break
if (event.type == EventType.DIVORCE and
(event_ref.get_role() == EventRoleType.FAMILY or
event_ref.get_role() == EventRoleType.PRIMARY)):
d_type = event.type
d_date = self.get_date_string(event)
if not (self.event_choice == 3 and d_date):
d_place = self.get_place_string(event)
break
labellines = list()
if self.includeid == 2:
# id on separate line
labellines.append("(%s)" % fam_id)
if self.event_choice == 7:
if m_type:
line = m_type.get_abbreviation()
if m_date:
line += ' %s' % m_date
if m_date and m_place:
labellines.append(line)
line = ''
if m_place:
line += ' %s' % m_place
labellines.append(line)
if d_type:
line = d_type.get_abbreviation()
if d_date:
line += ' %s' % d_date
if d_date and d_place:
labellines.append(line)
line = ''
if d_place:
line += ' %s' % d_place
labellines.append(line)
else:
if m_date:
labellines.append("(%s)" % m_date)
if m_place:
labellines.append("(%s)" % m_place)
label = "\\n".join(labellines)
labellines = list()
if self.includeid == 1:
# id on same line
labellines.append("(%s)" % fam_id)
if len(label):
labellines.append(label)
label = ' '.join(labellines)
color = ""
fill = ""
style = "solid"
if self.colorize == 'colored':
color = self.colors['family']
elif self.colorize == 'filled':
fill = self.colors['family']
style = "filled"
self.doc.add_node(fam_id, label, "ellipse", color, style, fill)
# If subgraphs are used then we add both spouses here and Graphviz
# will attempt to position both spouses closely together.
# TODO: A person who is a parent in more than one family may only be
# positioned next to one of their spouses. The code currently
# does not take into account multiple spouses.
if self.use_subgraphs:
self.doc.start_subgraph(fam_id)
f_handle = fam.get_father_handle()
m_handle = fam.get_mother_handle()
if f_handle:
father = self._db.get_person_from_handle(f_handle)
self.doc.add_link(father.get_gramps_id(),
fam_id, "",
self.arrowheadstyle,
self.arrowtailstyle)
if m_handle:
mother = self._db.get_person_from_handle(m_handle)
self.doc.add_link(mother.get_gramps_id(),
fam_id, "",
self.arrowheadstyle,
self.arrowtailstyle)
self.doc.end_subgraph()
def get_gender_style(self, person):
"return gender specific person style"
gender = person.get_gender()
shape = "box"
style = "solid"
color = ""
fill = ""
if gender == person.FEMALE and self.use_roundedcorners:
style = "rounded"
elif gender == person.UNKNOWN:
shape = "hexagon"
if person == self.center_person and self.increlname:
shape = "octagon"
if self.colorize == 'colored':
if gender == person.MALE:
color = self.colors['male']
elif gender == person.FEMALE:
color = self.colors['female']
else:
color = self.colors['unknown']
elif self.colorize == 'filled':
style += ",filled"
if gender == person.MALE:
fill = self.colors['male']
elif gender == person.FEMALE:
fill = self.colors['female']
else:
fill = self.colors['unknown']
return(shape, style, color, fill)
def get_person_label(self, person):
"return person label string"
# see if we have an image to use for this person
image_path = None
if self.use_html_output:
media_list = person.get_media_list()
if len(media_list) > 0:
media_handle = media_list[0].get_reference_handle()
media = self._db.get_media_from_handle(media_handle)
media_mime_type = media.get_mime_type()
if media_mime_type[0:5] == "image":
image_path = get_thumbnail_path(
media_path_full(self._db, media.get_path()),
rectangle=media_list[0].get_rectangle())
# test if thumbnail actually exists in thumbs
# (import of data means media files might not be present
image_path = find_file(image_path)
label = ""
line_delimiter = '\\n'
# If we have an image, then start an HTML table; remember to close
# the table afterwards!
#
# This isn't a free-form HTML format here...just a few keywords that
# happen to be
# similar to keywords commonly seen in HTML. For additional
# information on what
# is allowed, see:
#
# http://www.graphviz.org/info/shapes.html#html
#
if self.use_html_output and image_path:
line_delimiter = '<BR/>'
label += '<TABLE BORDER="0" CELLSPACING="2" CELLPADDING="0" '
label += 'CELLBORDER="0"><TR><TD></TD><TD>'
label += '<IMG SRC="%s"/></TD><TD></TD>' % image_path
if self.imgpos == 0:
#trick it into not stretching the image
label += '</TR><TR><TD COLSPAN="3">'
else:
label += '<TD>'
else:
#no need for html label with this person
self.use_html_output = False
# at the very least, the label must have the person's name
p_name = self._name_display.display(person)
p_name = p_name.replace('"', '"')
label += p_name.replace('<', '<').replace('>', '>')
p_id = person.get_gramps_id()
if self.includeid == 1: # same line
label += " (%s)" % p_id
elif self.includeid == 2: # own line
label += "%s(%s)" % (line_delimiter, p_id)
if self.event_choice != 0:
b_date, d_date, b_place, d_place, b_type, d_type = \
self.get_event_strings(person)
if self.event_choice in [1, 2, 3, 4, 5] and (b_date or d_date):
label += '%s(' % line_delimiter
if b_date:
label += '%s' % b_date
label += ' – '
if d_date:
label += '%s' % d_date
label += ')'
if (self.event_choice in [2, 3, 5, 6] and
(b_place or d_place) and
not (self.event_choice == 3 and (b_date or d_date))
):
label += '%s(' % line_delimiter
if b_place:
label += '%s' % b_place
label += ' – '
if d_place:
label += '%s' % d_place
label += ')'
if self.event_choice == 7:
if b_type:
label += '%s%s' % (line_delimiter, b_type.get_abbreviation())
if b_date:
label += ' %s' % b_date
if b_place:
label += ' %s' % b_place
if d_type:
label += '%s%s' % (line_delimiter, d_type.get_abbreviation())
if d_date:
label += ' %s' % d_date
if d_place:
label += ' %s' % d_place
if self.increlname and self.center_person != person:
# display relationship info
if self.advrelinfo:
(relationship, _ga, _gb) = self.rel_calc.get_one_relationship(
self._db, self.center_person, person,
extra_info=True, olocale=self._locale)
if relationship:
label += "%s(%s Ga=%d Gb=%d)" % (line_delimiter,
relationship, _ga, _gb)
else:
relationship = self.rel_calc.get_one_relationship(
self._db, self.center_person, person,
olocale=self._locale)
if relationship:
label += "%s(%s)" % (line_delimiter, relationship)
if self.occupation > 0:
event_refs = person.get_primary_event_ref_list()
events = [event for event in
[self._db.get_event_from_handle(ref.ref)
for ref in event_refs]
if event.get_type() == EventType(EventType.OCCUPATION)]
if len(events) > 0:
events.sort(key=lambda x: x.get_date_object())
if self.occupation == 1:
occupation = events[-1].get_description()
if occupation:
label += "%s(%s)" % (line_delimiter, occupation)
elif self.occupation == 2:
for evt in events:
date = self.get_date_string(evt)
place = self.get_place_string(evt)
desc = evt.get_description()
if not date and not desc and not place:
continue
label += '%s(' % line_delimiter
if date:
label += '%s' % date
if desc:
label += ' '
if desc:
label += '%s' % desc
if place:
if date or desc:
label += self._(', ') # Arabic OK
label += '%s' % place
label += ')'
# see if we have a table that needs to be terminated
if self.use_html_output:
label += '</TD></TR></TABLE>'
return label
else:
# non html label is enclosed by "" so escape other "
return label.replace('"', '\\\"')
def get_event_strings(self, person):
"returns tuple of birth/christening and death/burying date strings"
birth_date = birth_place = death_date = death_place = ""
birth_type = death_type = ""
birth_event = get_birth_or_fallback(self._db, person)
if birth_event:
birth_type = birth_event.type
birth_date = self.get_date_string(birth_event)
birth_place = self.get_place_string(birth_event)
death_event = get_death_or_fallback(self._db, person)
if death_event:
death_type = death_event.type
death_date = self.get_date_string(death_event)
death_place = self.get_place_string(death_event)
return (birth_date, death_date, birth_place,
death_place, birth_type, death_type)
def get_date_string(self, event):
"""
return date string for an event label.
Based on the data availability and preferences, we select one
of the following for a given event:
year only
complete date
empty string
"""
if event and event.get_date_object() is not None:
event_date = event.get_date_object()
if event_date.get_year_valid():
if self.event_choice in [4, 5]:
return '%i' % event_date.get_year()
elif self.event_choice in [1, 2, 3, 7]:
return self._get_date(event_date)
return ''
def get_place_string(self, event):
"""
return place string for an event label.
Based on the data availability and preferences, we select one
of the following for a given event:
place name
empty string
"""
if event and self.event_choice in [2, 3, 5, 6, 7]:
place = _pd.display_event(self._db, event)
return place.replace('<', '<').replace('>', '>')
return ''
class AncestorReport(Report):
"""
Ancestor Report class
"""
def __init__(self, database, options, user):
"""
Create the AncestorReport object that produces the Ahnentafel report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
pagebbg - Whether to include page breaks between generations.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self.map = {}
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
self.max_generations = menu.get_option_by_name('maxgen').get_value()
self.pgbrk = menu.get_option_by_name('pagebbg').get_value()
self.opt_namebrk = menu.get_option_by_name('namebrk').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if (self.center_person == None) :
raise ReportError(_("Person %s is not in the Database") % pid )
stdoptions.run_name_format_option(self, menu)
self.__narrator = Narrator(self.database, use_fulldate=True,
nlocale=rlocale)
def apply_filter(self, person_handle, index, generation=1):
"""
Recursive function to walk back all parents of the current person.
When max_generations are hit, we stop the traversal.
"""
# check for end of the current recursion level. This happens
# if the person handle is None, or if the max_generations is hit
if not person_handle or generation > self.max_generations:
return
# store the person in the map based off their index number
# which is passed to the routine.
self.map[index] = person_handle
# retrieve the Person instance from the database from the
# passed person_handle and find the parents from the list.
# Since this report is for natural parents (birth parents),
# we have to handle that parents may not
person = self.database.get_person_from_handle(person_handle)
if person is None:
return
father_handle = None
mother_handle = None
for family_handle in person.get_parent_family_handle_list():
family = self.database.get_family_from_handle(family_handle)
# filter the child_ref_list to find the reference that matches
# the passed person. There should be exactly one, but there is
# nothing that prevents the same child in the list multiple times.
ref = [ c for c in family.get_child_ref_list()
if c.get_reference_handle() == person_handle]
if ref:
# If the father_handle is not defined and the relationship is
# BIRTH, then we have found the birth father. Same applies to
# the birth mother. If for some reason, the we have multiple
# people defined as the birth parents, we will select based on
# priority in the list
if not father_handle and \
ref[0].get_father_relation() == ChildRefType.BIRTH:
father_handle = family.get_father_handle()
if not mother_handle and \
ref[0].get_mother_relation() == ChildRefType.BIRTH:
mother_handle = family.get_mother_handle()
# Recursively call the function. It is okay if the handle is None,
# since routine handles a handle of None
self.apply_filter(father_handle, index*2, generation+1)
self.apply_filter(mother_handle, (index*2)+1, generation+1)
def write_report(self):
"""
The routine the actually creates the report. At this point, the document
is opened and ready for writing.
"""
# Call apply_filter to build the self.map array of people in the
# database that match the ancestry.
self.apply_filter(self.center_person.get_handle(), 1)
# Write the title line. Set in INDEX marker so that this section will be
# identified as a major category if this is included in a Book report.
name = self._name_display.display_formal(self.center_person)
# feature request 2356: avoid genitive form
title = self._("Ahnentafel Report for %s") % name
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.start_paragraph("AHN-Title")
self.doc.write_text(title, mark)
self.doc.end_paragraph()
# get the entries out of the map, and sort them.
generation = 0
for key in sorted(self.map):
# check the index number to see if we need to start a new generation
if generation == log2(key):
# generate a page break if requested
if self.pgbrk and generation > 0:
self.doc.page_break()
generation += 1
# Create the Generation title, set an index marker
gen_text = self._("Generation %d") % generation
mark = None # don't need any with no page breaks
if self.pgbrk:
mark = IndexMark(gen_text, INDEX_TYPE_TOC, 2)
self.doc.start_paragraph("AHN-Generation")
self.doc.write_text(gen_text, mark)
self.doc.end_paragraph()
# Build the entry
self.doc.start_paragraph("AHN-Entry","%d." % key)
person = self.database.get_person_from_handle(self.map[key])
if person is None:
continue
name = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
# write the name in bold
self.doc.start_bold()
self.doc.write_text(name.strip(), mark)
self.doc.end_bold()
# terminate with a period if it is not already terminated.
# This can happen if the person's name ends with something 'Jr.'
if name[-1:] == '.':
self.doc.write_text(" ")
else:
self.doc.write_text(". ")
# Add a line break if requested (not implemented yet)
if self.opt_namebrk:
self.doc.write_text('\n')
self.__narrator.set_subject(person)
self.doc.write_text(self.__narrator.get_born_string())
self.doc.write_text(self.__narrator.get_baptised_string())
self.doc.write_text(self.__narrator.get_christened_string())
self.doc.write_text(self.__narrator.get_died_string())
self.doc.write_text(self.__narrator.get_buried_string())
self.doc.end_paragraph()
def __init__(self, database, options, user):
"""
Create the DetDescendantReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
inc_id - Whether to include Gramps IDs
pagebgg - Whether to include page breaks between generations.
pageben - Whether to include page break before End Notes.
fulldates - Whether to use full dates instead of just year.
listc - Whether to list children.
list_children_spouses - Whether to list the spouses of the children
incnotes - Whether to include notes.
usecall - Whether to use the call name as the first name.
repplace - Whether to replace missing Places with ___________.
repdate - Whether to replace missing Dates with ___________.
computeage - Whether to compute age.
verbose - Whether to use complete sentences.
numbering - The descendancy numbering system to be utilized.
desref - Whether to add descendant references in child list.
incphotos - Whether to include images.
incnames - Whether to include other names.
incevents - Whether to include events.
incaddresses - Whether to include addresses.
incsrcnotes - Whether to include source notes in the Endnotes
section. Only works if Include sources is selected.
incmates - Whether to include information about spouses
incattrs - Whether to include attributes
incpaths - Whether to include the path of descendancy
from the start-person to each descendant.
incssign - Whether to include a sign ('+') before the
descendant number in the child-list
to indicate a child has succession.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
incmateref - Whether to print mate information or reference
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
structure - How to structure the report
"""
Report.__init__(self, database, options, user)
self.map = {}
self._user = user
menu = options.menu
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(get_value('trans'))
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.max_generations = get_value('gen')
self.pgbrk = get_value('pagebbg')
self.pgbrkenotes = get_value('pageben')
self.fulldate = get_value('fulldates')
use_fulldate = self.fulldate
self.listchildren = get_value('listc')
self.list_children_spouses = get_value('listc_spouses')
self.inc_notes = get_value('incnotes')
use_call = get_value('usecall')
blankplace = get_value('repplace')
blankdate = get_value('repdate')
self.calcageflag = get_value('computeage')
self.verbose = get_value('verbose')
self.numbering = get_value('numbering')
self.childref = get_value('desref')
self.addimages = get_value('incphotos')
self.structure = get_value('structure')
self.inc_names = get_value('incnames')
self.inc_events = get_value('incevents')
self.inc_addr = get_value('incaddresses')
self.inc_sources = get_value('incsources')
self.inc_srcnotes = get_value('incsrcnotes')
self.inc_mates = get_value('incmates')
self.inc_attrs = get_value('incattrs')
self.inc_paths = get_value('incpaths')
self.inc_ssign = get_value('incssign')
self.inc_materef = get_value('incmateref')
self.want_ids = get_value('inc_id')
pid = get_value('pid')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.gen_handles = {}
self.prev_gen_handles = {}
self.gen_keys = []
self.dnumber = {}
self.dmates = {}
self.numbers_printed = list()
if blankdate:
empty_date = EMPTY_ENTRY
else:
empty_date = ""
if blankplace:
empty_place = EMPTY_ENTRY
else:
empty_place = ""
stdoptions.run_name_format_option(self, menu)
self.__narrator = Narrator(self._db, self.verbose,
use_call, use_fulldate,
empty_date, empty_place,
nlocale=self._locale,
get_endnote_numbers=self.endnotes)
self.bibli = Bibliography(Bibliography.MODE_DATE|Bibliography.MODE_PAGE)
class TagReport(Report):
""" Tag Report """
def __init__(self, database, options, user):
"""
Create the TagReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
tag - The tag each object must match to be included.
name_format - Preferred format to display names of people
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu,
self._locale)
self.database = CacheProxyDb(self.database)
self._lv = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == self._lv:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)"
) % {'option_name' : living_desc}
self.tag = menu.get_option_by_name('tag').get_value()
if not self.tag:
raise ReportError(
_('Tag Report'),
_('You must first create a tag before running this report.'))
stdoptions.run_name_format_option(self, menu)
def write_report(self):
self.doc.start_paragraph("TR-Title")
# feature request 2356: avoid genitive form
title = self._("Tag Report for %s Items") % self.tag
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
if self._lv != LivingProxyDb.MODE_INCLUDE_ALL:
self.doc.start_paragraph("TR-ReportSubtitle")
self.doc.write_text(self.living_desc)
self.doc.end_paragraph()
self.write_people()
self.write_families()
self.write_events()
self.write_places()
self.write_notes()
self.write_media()
self.write_repositories()
self.write_sources()
self.write_citations()
def write_people(self):
""" write the people associated with the tag """
plist = self.database.iter_person_handles()
filter_class = GenericFilterFactory('Person')
a_filter = filter_class()
a_filter.add_rule(rules.person.HasTag([self.tag]))
ind_list = a_filter.apply(self.database, plist)
if not ind_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("People")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('PeopleTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Name"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Birth"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Death"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for person_handle in ind_list:
person = self.database.get_person_from_handle(person_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(person.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
name = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(name, mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
birth_ref = person.get_birth_ref()
if birth_ref:
event = self.database.get_event_from_handle(birth_ref.ref)
self.doc.write_text(self._get_date(event.get_date_object()))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
death_ref = person.get_death_ref()
if death_ref:
event = self.database.get_event_from_handle(death_ref.ref)
self.doc.write_text(self._get_date(event.get_date_object()))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_families(self):
""" write the families associated with the tag """
flist = self.database.iter_family_handles()
filter_class = GenericFilterFactory('Family')
a_filter = filter_class()
a_filter.add_rule(rules.family.HasTag([self.tag]))
fam_list = a_filter.apply(self.database, flist)
if not fam_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Families")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('FamilyTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Father"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Mother"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Relationship"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for family_handle in fam_list:
family = self.database.get_family_from_handle(family_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(family.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
father_handle = family.get_father_handle()
if father_handle:
father = self.database.get_person_from_handle(father_handle)
mark = utils.get_person_mark(self.database, father)
self.doc.write_text(self._name_display.display(father), mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self.database.get_person_from_handle(mother_handle)
mark = utils.get_person_mark(self.database, mother)
self.doc.write_text(self._name_display.display(mother), mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
relation = family.get_relationship()
self.doc.write_text(str(relation))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_events(self):
""" write the events associated with the tag """
elist = self.database.get_event_handles()
filter_class = GenericFilterFactory('Event')
a_filter = filter_class()
a_filter.add_rule(rules.event.HasTag([self.tag]))
event_list = a_filter.apply(self.database, elist)
if not event_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Events")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('EventTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Participants"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Date"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for event_handle in event_list:
event = self.database.get_event_from_handle(event_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(event.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(self._(self._get_type(event.get_type())))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(get_participant_from_event(self.database,
event_handle))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
date = self._get_date(event.get_date_object())
if date:
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_places(self):
""" write the places associated with the tag """
plist = self.database.get_place_handles()
filter_class = GenericFilterFactory('Place')
a_filter = filter_class()
a_filter.add_rule(rules.place.HasTag([self.tag]))
place_list = a_filter.apply(self.database, plist)
if not place_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Places")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('PlaceTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Title"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Name"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for place_handle in place_list:
place = self.database.get_place_from_handle(place_handle)
place_title = _pd.display(self.database, place)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(place.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(place_title)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(place.get_name().get_value())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(str(place.get_type()))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_notes(self):
""" write the notes associated with the tag """
nlist = self.database.get_note_handles()
filter_class = GenericFilterFactory('Note')
a_filter = filter_class()
a_filter.add_rule(rules.note.HasTag([self.tag]))
note_list = a_filter.apply(self.database, nlist)
if not note_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Notes")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('NoteTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell', 2)
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Text"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for note_handle in note_list:
note = self.database.get_note_from_handle(note_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(note.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
note_type = note.get_type()
self.doc.write_text(str(note_type))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell', 2)
self.doc.write_styled_note(
note.get_styledtext(), note.get_format(), 'TR-Note',
contains_html=((note.get_type() == NoteType.HTML_CODE)))
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_media(self):
""" write the media associated with the tag """
mlist = self.database.get_media_handles(sort_handles=True,
locale=self._locale)
filter_class = GenericFilterFactory('Media')
a_filter = filter_class()
a_filter.add_rule(rules.media.HasTag([self.tag]))
media_list = a_filter.apply(self.database, mlist)
if not media_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Media")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('MediaTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Title"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Date"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for media_handle in media_list:
media = self.database.get_media_from_handle(media_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(media.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
title = media.get_description()
self.doc.write_text(str(title))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
mime_type = media.get_mime_type()
self.doc.write_text(str(mime_type))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
date = self._get_date(media.get_date_object())
if date:
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_repositories(self):
""" write the repositories associated with the tag """
rlist = self.database.get_repository_handles()
filter_class = GenericFilterFactory('Repository')
a_filter = filter_class()
a_filter.add_rule(rules.repository.HasTag([self.tag]))
repo_list = a_filter.apply(self.database, rlist)
if not repo_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Repositories")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('ReopTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Name"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Type"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Email Address"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for repo_handle in repo_list:
repo = self.database.get_repository_from_handle(repo_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(repo.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(repo.get_name())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(str(repo.get_type()))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
home_page = ''
for url in repo.get_url_list():
if url.get_type() == UrlType.EMAIL:
home_page = url.get_path()
break
self.doc.write_text(home_page)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_sources(self):
""" write the sources associated with the tag """
slist = self.database.get_source_handles(sort_handles=True,
locale=self._locale)
filter_class = GenericFilterFactory('Source')
a_filter = filter_class()
a_filter.add_rule(rules.source.HasTag([self.tag]))
source_list = a_filter.apply(self.database, slist)
if not source_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Source")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('SourceTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Title"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Author"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Publication Information"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for source_handle in source_list:
source = self.database.get_source_from_handle(source_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(source.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(source.get_title())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(source.get_author())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(source.get_publication_info())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def write_citations(self):
""" write the citations associated with the tag """
clist = self.database.get_citation_handles(sort_handles=True,
locale=self._locale)
filter_class = GenericFilterFactory('Citation')
a_filter = filter_class()
a_filter.add_rule(rules.citation.HasTag([self.tag]))
citation_list = a_filter.apply(self.database, clist)
if not citation_list:
return
self.doc.start_paragraph("TR-Heading")
header = self._("Citations")
mark = IndexMark(header, INDEX_TYPE_TOC, 2)
self.doc.write_text(header, mark)
self.doc.end_paragraph()
self.doc.start_table('CitationTable', 'TR-Table')
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Id"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Volume/Page"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Date"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal-Bold')
self.doc.write_text(self._("Source"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for citation_handle in citation_list:
citation = self.database.get_citation_from_handle(citation_handle)
self.doc.start_row()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(citation.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
self.doc.write_text(citation.get_page())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
date = self._get_date(citation.get_date_object())
if date:
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('TR-TableCell')
self.doc.start_paragraph('TR-Normal')
source_handle = citation.get_reference_handle()
source = self.database.get_source_from_handle(source_handle)
self.doc.write_text(source.get_title())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
def __init__(self, database, options, user):
"""
Create the Statistics object that produces the report.
Uses the Extractor class to extract the data from the database.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self._user = user
self.set_locale(menu.get_option_by_name('trans').get_value())
# override default gettext, or English output will have "person|Title"
self._ = self._locale.translation.sgettext
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu,
self._locale)
self.database = CacheProxyDb(self.database)
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
filter_opt = get_option_by_name('filter')
self.filter = filter_opt.get_filter()
self.fil_name = "(%s)" % self.filter.get_name(self._locale)
self.bar_items = get_value('bar_items')
year_from = get_value('year_from')
year_to = get_value('year_to')
gender = get_value('gender')
living_value = get_value('living_people')
for (value, description) in living_opt.get_items(xml_items=True):
if value == living_value:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)"
) % {'option_name' : living_desc}
# title needs both data extraction method name + gender name
if gender == Person.MALE:
genders = self._("Men")
elif gender == Person.FEMALE:
genders = self._("Women")
else:
genders = None
# needed for keyword based localization
mapping = {
'genders': genders,
'year_from': year_from,
'year_to': year_to
}
if genders:
span_string = self._("%(genders)s born "
"%(year_from)04d-%(year_to)04d"
) % mapping
else:
span_string = self._("Persons born "
"%(year_from)04d-%(year_to)04d"
) % mapping
people = self.filter.apply(self.database,
self.database.iter_person_handles(),
user=self._user)
# extract requested items from the database and count them
self._user.begin_progress(_('Statistics Charts'),
_('Collecting data...'),
self.database.get_number_of_people())
tables = _Extract.collect_data(self.database, people, menu,
gender, year_from, year_to,
get_value('no_years'),
self._user.step_progress,
self._locale)
self._user.end_progress()
self._user.begin_progress(_('Statistics Charts'),
_('Sorting data...'), len(tables))
self.data = []
sortby = get_value('sortby')
reverse = get_value('reverse')
for table in tables:
# generate sorted item lookup index index
lookup = self.index_items(table[1], sortby, reverse)
# document heading
heading = "%(str1)s -- %(str2)s" % {'str1' : self._(table[0]),
'str2' : span_string}
self.data.append((heading, table[0], table[1], lookup))
self._user.step_progress()
self._user.end_progress()
class RelGraphReport(Report):
def __init__(self, database, options, user):
"""
Create RelGraphReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the people of the database.
The option class carries its number, and the function
returning the list of filters.
arrow - Arrow styles for heads and tails.
showfamily - Whether to show family nodes.
inc_id - Whether to include IDs.
url - Whether to include URLs.
inclimg - Include images or not
imgpos - Image position, above/beside name
color - Whether to use outline, colored outline or filled color
in graph
color_males - Colour to apply to males
color_females - Colour to apply to females
color_unknown - Colour to apply to unknown genders
color_families - Colour to apply to families
dashed - Whether to use dashed lines for non-birth relationships
use_roundedcorners - Whether to use rounded corners for females
name_format - Preferred format to display names
incl_private - Whether to include private data
event_choice - Whether to include dates and/or places
occupation - Whether to include occupations
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
get_option_by_name = options.menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.includeid = get_value('inc_id')
self.includeurl = get_value('url')
self.includeimg = get_value('includeImages')
self.imgpos = get_value('imageOnTheSide')
self.use_roundedcorners = get_value('useroundedcorners')
self.adoptionsdashed = get_value('dashed')
self.show_families = get_value('showfamily')
self.use_subgraphs = get_value('usesubgraphs')
self.event_choice = get_value('event_choice')
self.occupation = get_value('occupation')
self.use_html_output = False
self.colorize = get_value('color')
color_males = get_value('colormales')
color_females = get_value('colorfemales')
color_unknown = get_value('colorunknown')
color_families = get_value('colorfamilies')
self.colors = {
'male': color_males,
'female': color_females,
'unknown': color_unknown,
'family': color_families
}
arrow_str = get_value('arrow')
if 'd' in arrow_str:
self.arrowheadstyle = 'normal'
else:
self.arrowheadstyle = 'none'
if 'a' in arrow_str:
self.arrowtailstyle = 'normal'
else:
self.arrowtailstyle = 'none'
filter_option = get_option_by_name('filter')
self._filter = filter_option.get_filter()
stdoptions.run_name_format_option(self, menu)
pid = get_value('pid')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.increlname = get_value('increlname')
if self.increlname:
self.rel_calc = get_relationship_calculator(reinit=True,
clocale=self._locale)
if __debug__:
self.advrelinfo = get_value('advrelinfo')
else:
self.advrelinfo = False
def write_report(self):
person_handles = self._filter.apply(self._db,
self._db.iter_person_handles(),
user=self._user)
person_handles = self.sort_persons(person_handles)
if len(person_handles) > 1:
if self._user:
self._user.begin_progress(_("Relationship Graph"),
_("Generating report"),
len(person_handles) * 2)
self.add_persons_and_families(person_handles)
self.add_child_links_to_families(person_handles)
if self._user:
self._user.end_progress()
def sort_persons(self, person_handle_list):
"sort persons by close relations"
# first make a list of all persons who don't have any parents
root_nodes = list()
for person_handle in person_handle_list:
person = self.database.get_person_from_handle(person_handle)
has_parent = False
for parent_handle in find_parents(self.database, person):
if parent_handle not in person_handle_list:
continue
has_parent = True
if not has_parent:
root_nodes.append(person_handle)
# now start from all root nodes we found and traverse their trees
outlist = list()
p_done = set()
for person_handle in root_nodes:
todolist = list()
todolist.append(person_handle)
while len(todolist) > 0:
# take the first person from todolist and do sanity check
cur = todolist.pop(0)
if cur in p_done:
continue
if cur not in person_handle_list:
p_done.add(cur)
continue
person = self.database.get_person_from_handle(cur)
# first check whether both parents are added
missing_parents = False
for parent_handle in find_parents(self.database, person):
if not parent_handle or parent_handle in p_done:
continue
if parent_handle not in person_handle_list:
continue
todolist.insert(0, parent_handle)
missing_parents = True
# if one of the parents is still missing, wait for them
if missing_parents:
continue
# add person to the sorted output
outlist.append(cur)
p_done.add(cur)
# add all spouses and children to the todo list
family_list = person.get_family_handle_list()
for fam_handle in family_list:
family = self.database.get_family_from_handle(fam_handle)
if family is None:
continue
if (family.get_father_handle() and
family.get_father_handle() != cur):
todolist.insert(0, family.get_father_handle())
if (family.get_mother_handle() and
family.get_mother_handle() != cur):
todolist.insert(0, family.get_mother_handle())
for child_ref in family.get_child_ref_list():
todolist.append(child_ref.ref)
# finally store the result
assert len(person_handle_list) == len(outlist)
return outlist
def add_child_links_to_families(self, person_handles):
"""
returns string of Graphviz edges linking parents to families or
children
"""
# Hash people in a dictionary for faster inclusion checking
person_dict = dict([handle, 1] for handle in person_handles)
for person_handle in person_handles:
if self._user:
self._user.step_progress()
person = self._db.get_person_from_handle(person_handle)
p_id = person.get_gramps_id()
for fam_handle in person.get_parent_family_handle_list():
family = self._db.get_family_from_handle(fam_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
for child_ref in family.get_child_ref_list():
if child_ref.ref == person_handle:
frel = child_ref.frel
mrel = child_ref.mrel
break
if (self.show_families and
((father_handle and father_handle in person_dict) or
(mother_handle and mother_handle in person_dict))):
# Link to the family node if either parent is in graph
self.add_family_link(p_id, family, frel, mrel)
else:
# Link to the parents' nodes directly, if they are in graph
if father_handle and father_handle in person_dict:
self.add_parent_link(p_id, father_handle, frel)
if mother_handle and mother_handle in person_dict:
self.add_parent_link(p_id, mother_handle, mrel)
def add_family_link(self, p_id, family, frel, mrel):
"Links the child to a family"
style = 'solid'
adopted = ((int(frel) != ChildRefType.BIRTH) or
(int(mrel) != ChildRefType.BIRTH))
# If birth relation to father is NONE, meaning there is no father and
# if birth relation to mother is BIRTH then solid line
if (int(frel) == ChildRefType.NONE and
int(mrel) == ChildRefType.BIRTH):
adopted = False
if adopted and self.adoptionsdashed:
style = 'dotted'
self.doc.add_link(family.get_gramps_id(), p_id, style,
self.arrowheadstyle, self.arrowtailstyle)
def add_parent_link(self, p_id, parent_handle, rel):
"Links the child to a parent"
style = 'solid'
if (int(rel) != ChildRefType.BIRTH) and self.adoptionsdashed:
style = 'dotted'
parent = self._db.get_person_from_handle(parent_handle)
self.doc.add_link(parent.get_gramps_id(), p_id, style,
self.arrowheadstyle, self.arrowtailstyle)
def add_persons_and_families(self, person_handles):
"adds nodes for persons and their families"
# variable to communicate with get_person_label
self.use_html_output = False
# The list of families for which we have output the node,
# so we don't do it twice
families_done = set()
for person_handle in person_handles:
if self._user:
self._user.step_progress()
# determine per person if we use HTML style label
if self.includeimg:
self.use_html_output = True
person = self._db.get_person_from_handle(person_handle)
if person is None:
continue
p_id = person.get_gramps_id()
# Output the person's node
label = self.get_person_label(person)
(shape, style, color, fill) = self.get_gender_style(person)
url = ""
if self.includeurl:
phan = person_handle
dirpath = "ppl/%s/%s" % (phan[-1], phan[-2])
dirpath = dirpath.lower()
url = "%s/%s.html" % (dirpath, phan)
self.doc.add_node(p_id, label, shape, color, style, fill, url)
# Output families where person is a parent
if self.show_families:
family_list = person.get_family_handle_list()
for fam_handle in family_list:
family = self._db.get_family_from_handle(fam_handle)
if family is None:
continue
if fam_handle not in families_done:
families_done.add(fam_handle)
self.__add_family(fam_handle)
# If subgraphs are not chosen then each parent is linked
# separately to the family. This gives Graphviz greater
# control over the layout of the whole graph but
# may leave spouses not positioned together.
if not self.use_subgraphs:
self.doc.add_link(p_id, family.get_gramps_id(), "",
self.arrowheadstyle,
self.arrowtailstyle)
def __add_family(self, fam_handle):
"""Add a node for a family and optionally link the spouses to it"""
fam = self._db.get_family_from_handle(fam_handle)
if fam is None:
return
fam_id = fam.get_gramps_id()
m_type = m_date = m_place = ""
d_type = d_date = d_place = ""
for event_ref in fam.get_event_ref_list():
event = self._db.get_event_from_handle(event_ref.ref)
if event is None:
continue
if (event.type == EventType.MARRIAGE and
(event_ref.get_role() == EventRoleType.FAMILY or
event_ref.get_role() == EventRoleType.PRIMARY)):
m_type = event.type
m_date = self.get_date_string(event)
if not (self.event_choice == 3 and m_date):
m_place = self.get_place_string(event)
break
if (event.type == EventType.DIVORCE and
(event_ref.get_role() == EventRoleType.FAMILY or
event_ref.get_role() == EventRoleType.PRIMARY)):
d_type = event.type
d_date = self.get_date_string(event)
if not (self.event_choice == 3 and d_date):
d_place = self.get_place_string(event)
break
labellines = list()
if self.includeid == 2:
# id on separate line
labellines.append("(%s)" % fam_id)
if self.event_choice == 7:
if m_type:
line = m_type.get_abbreviation()
if m_date:
line += ' %s' % m_date
if m_date and m_place:
labellines.append(line)
line = ''
if m_place:
line += ' %s' % m_place
labellines.append(line)
if d_type:
line = d_type.get_abbreviation()
if d_date:
line += ' %s' % d_date
if d_date and d_place:
labellines.append(line)
line = ''
if d_place:
line += ' %s' % d_place
labellines.append(line)
else:
if m_date:
labellines.append("(%s)" % m_date)
if m_place:
labellines.append("(%s)" % m_place)
label = "\\n".join(labellines)
labellines = list()
if self.includeid == 1:
# id on same line
labellines.append("(%s)" % fam_id)
if len(label):
labellines.append(label)
label = ' '.join(labellines)
color = ""
fill = ""
style = "solid"
if self.colorize == 'colored':
color = self.colors['family']
elif self.colorize == 'filled':
fill = self.colors['family']
style = "filled"
self.doc.add_node(fam_id, label, "ellipse", color, style, fill)
# If subgraphs are used then we add both spouses here and Graphviz
# will attempt to position both spouses closely together.
# TODO: A person who is a parent in more than one family may only be
# positioned next to one of their spouses. The code currently
# does not take into account multiple spouses.
if self.use_subgraphs:
self.doc.start_subgraph(fam_id)
f_handle = fam.get_father_handle()
m_handle = fam.get_mother_handle()
if f_handle:
father = self._db.get_person_from_handle(f_handle)
self.doc.add_link(father.get_gramps_id(),
fam_id, "",
self.arrowheadstyle,
self.arrowtailstyle)
if m_handle:
mother = self._db.get_person_from_handle(m_handle)
self.doc.add_link(mother.get_gramps_id(),
fam_id, "",
self.arrowheadstyle,
self.arrowtailstyle)
self.doc.end_subgraph()
def get_gender_style(self, person):
"return gender specific person style"
gender = person.get_gender()
shape = "box"
style = "solid"
color = ""
fill = ""
if gender == person.FEMALE and self.use_roundedcorners:
style = "rounded"
elif gender == person.UNKNOWN:
shape = "hexagon"
if person == self.center_person and self.increlname:
shape = "octagon"
if self.colorize == 'colored':
if gender == person.MALE:
color = self.colors['male']
elif gender == person.FEMALE:
color = self.colors['female']
else:
color = self.colors['unknown']
elif self.colorize == 'filled':
style += ",filled"
if gender == person.MALE:
fill = self.colors['male']
elif gender == person.FEMALE:
fill = self.colors['female']
else:
fill = self.colors['unknown']
return(shape, style, color, fill)
def get_person_label(self, person):
"return person label string"
# see if we have an image to use for this person
image_path = None
if self.use_html_output:
media_list = person.get_media_list()
if len(media_list) > 0:
media_handle = media_list[0].get_reference_handle()
media = self._db.get_media_from_handle(media_handle)
media_mime_type = media.get_mime_type()
if media_mime_type[0:5] == "image":
image_path = get_thumbnail_path(
media_path_full(self._db, media.get_path()),
rectangle=media_list[0].get_rectangle())
# test if thumbnail actually exists in thumbs
# (import of data means media files might not be present
image_path = find_file(image_path)
label = ""
line_delimiter = '\\n'
# If we have an image, then start an HTML table; remember to close
# the table afterwards!
#
# This isn't a free-form HTML format here...just a few keywords that
# happen to be
# similar to keywords commonly seen in HTML. For additional
# information on what
# is allowed, see:
#
# http://www.graphviz.org/info/shapes.html#html
#
if self.use_html_output and image_path:
line_delimiter = '<BR/>'
label += '<TABLE BORDER="0" CELLSPACING="2" CELLPADDING="0" '
label += 'CELLBORDER="0"><TR><TD></TD><TD>'
label += '<IMG SRC="%s"/></TD><TD></TD>' % image_path
if self.imgpos == 0:
#trick it into not stretching the image
label += '</TR><TR><TD COLSPAN="3">'
else:
label += '<TD>'
else:
#no need for html label with this person
self.use_html_output = False
# at the very least, the label must have the person's name
p_name = self._name_display.display(person)
if self.use_html_output:
# avoid < and > in the name, as this is html text
label += p_name.replace('<', '<').replace('>', '>')
else:
label += p_name
p_id = person.get_gramps_id()
if self.includeid == 1: # same line
label += " (%s)" % p_id
elif self.includeid == 2: # own line
label += "%s(%s)" % (line_delimiter, p_id)
if self.event_choice != 0:
b_date, d_date, b_place, d_place, b_type, d_type = \
self.get_event_strings(person)
if self.event_choice in [1, 2, 3, 4, 5] and (b_date or d_date):
label += '%s(' % line_delimiter
if b_date:
label += '%s' % b_date
label += ' - '
if d_date:
label += '%s' % d_date
label += ')'
if (self.event_choice in [2, 3, 5, 6] and
(b_place or d_place) and
not (self.event_choice == 3 and (b_date or d_date))
):
label += '%s(' % line_delimiter
if b_place:
label += '%s' % b_place
label += ' - '
if d_place:
label += '%s' % d_place
label += ')'
if self.event_choice == 7:
if b_type:
label += '%s%s' % (line_delimiter, b_type.get_abbreviation())
if b_date:
label += ' %s' % b_date
if b_place:
label += ' %s' % b_place
if d_type:
label += '%s%s' % (line_delimiter, d_type.get_abbreviation())
if d_date:
label += ' %s' % d_date
if d_place:
label += ' %s' % d_place
if self.increlname and self.center_person != person:
# display relationship info
if self.advrelinfo:
(relationship, _ga, _gb) = self.rel_calc.get_one_relationship(
self._db, self.center_person, person,
extra_info=True, olocale=self._locale)
if relationship:
label += "%s(%s Ga=%d Gb=%d)" % (line_delimiter,
relationship, _ga, _gb)
else:
relationship = self.rel_calc.get_one_relationship(
self._db, self.center_person, person,
olocale=self._locale)
if relationship:
label += "%s(%s)" % (line_delimiter, relationship)
if self.occupation > 0:
event_refs = person.get_primary_event_ref_list()
events = [event for event in
[self._db.get_event_from_handle(ref.ref)
for ref in event_refs]
if event.get_type() == EventType(EventType.OCCUPATION)]
if len(events) > 0:
events.sort(key=lambda x: x.get_date_object())
if self.occupation == 1:
occupation = events[-1].get_description()
if occupation:
label += "%s(%s)" % (line_delimiter, occupation)
elif self.occupation == 2:
for evt in events:
date = self.get_date_string(evt)
place = self.get_place_string(evt)
desc = evt.get_description()
if not date and not desc and not place:
continue
label += '%s(' % line_delimiter
if date:
label += '%s' % date
if desc:
label += ' '
if desc:
label += '%s' % desc
if place:
if date or desc:
label += self._(', ') # Arabic OK
label += '%s' % place
label += ')'
# see if we have a table that needs to be terminated
if self.use_html_output:
label += '</TD></TR></TABLE>'
return label
else:
# non html label is enclosed by "" so escape other "
return label.replace('"', '\\\"')
def get_event_strings(self, person):
"returns tuple of birth/christening and death/burying date strings"
birth_date = birth_place = death_date = death_place = ""
birth_type = death_type = ""
birth_event = get_birth_or_fallback(self._db, person)
if birth_event:
birth_type = birth_event.type
birth_date = self.get_date_string(birth_event)
birth_place = self.get_place_string(birth_event)
death_event = get_death_or_fallback(self._db, person)
if death_event:
death_type = death_event.type
death_date = self.get_date_string(death_event)
death_place = self.get_place_string(death_event)
return (birth_date, death_date, birth_place,
death_place, birth_type, death_type)
def get_date_string(self, event):
"""
return date string for an event label.
Based on the data availability and preferences, we select one
of the following for a given event:
year only
complete date
empty string
"""
if event and event.get_date_object() is not None:
event_date = event.get_date_object()
if event_date.get_year_valid():
if self.event_choice in [4, 5]:
return '%i' % event_date.get_year()
elif self.event_choice in [1, 2, 3, 7]:
return self._get_date(event_date)
return ''
def get_place_string(self, event):
"""
return place string for an event label.
Based on the data availability and preferences, we select one
of the following for a given event:
place name
empty string
"""
if event and self.event_choice in [2, 3, 5, 6, 7]:
return _pd.display_event(self._db, event)
return ''
class StatisticsChart(Report):
""" StatisticsChart report """
def __init__(self, database, options, user):
"""
Create the Statistics object that produces the report.
Uses the Extractor class to extract the data from the database.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self._user = user
lang = menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
# override default gettext, or English output will have "person|Title"
self._ = rlocale.translation.sgettext
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
filter_opt = get_option_by_name('filter')
self.filter = filter_opt.get_filter()
self.fil_name = "(%s)" % self.filter.get_name(rlocale)
self.bar_items = get_value('bar_items')
year_from = get_value('year_from')
year_to = get_value('year_to')
gender = get_value('gender')
living_value = get_value('living_people')
for (value, description) in living_opt.get_items(xml_items=True):
if value == living_value:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)"
) % {'option_name' : living_desc}
# title needs both data extraction method name + gender name
if gender == Person.MALE:
genders = self._("Men")
elif gender == Person.FEMALE:
genders = self._("Women")
else:
genders = None
# needed for keyword based localization
mapping = {
'genders': genders,
'year_from': year_from,
'year_to': year_to
}
if genders:
span_string = self._("%(genders)s born "
"%(year_from)04d-%(year_to)04d"
) % mapping
else:
span_string = self._("Persons born "
"%(year_from)04d-%(year_to)04d"
) % mapping
people = self.filter.apply(self.database,
self.database.iter_person_handles(),
user=self._user)
# extract requested items from the database and count them
self._user.begin_progress(_('Statistics Charts'),
_('Collecting data...'),
self.database.get_number_of_people())
tables = _Extract.collect_data(self.database, people, menu,
gender, year_from, year_to,
get_value('no_years'),
self._user.step_progress,
rlocale)
self._user.end_progress()
self._user.begin_progress(_('Statistics Charts'),
_('Sorting data...'), len(tables))
self.data = []
sortby = get_value('sortby')
reverse = get_value('reverse')
for table in tables:
# generate sorted item lookup index index
lookup = self.index_items(table[1], sortby, reverse)
# document heading
heading = "%(str1)s -- %(str2)s" % {'str1' : self._(table[0]),
'str2' : span_string}
self.data.append((heading, table[0], table[1], lookup))
self._user.step_progress()
self._user.end_progress()
def index_items(self, data, sort, reverse):
"""creates & stores a sorted index for the items"""
# sort by item keys
index = sorted(data, reverse=True if reverse else False)
if sort == _options.SORT_VALUE:
# set for the sorting function
self.lookup_items = data
# then sort by value
index.sort(key=lambda x: self.lookup_items[x],
reverse=True if reverse else False)
return index
def write_report(self):
"output the selected statistics..."
mark = IndexMark(self._('Statistics Charts'), INDEX_TYPE_TOC, 1)
self._user.begin_progress(_('Statistics Charts'),
_('Saving charts...'), len(self.data))
for data in sorted(self.data):
self.doc.start_page()
if mark:
self.doc.draw_text('SC-title', '', 0, 0, mark) # put it in TOC
mark = None # crock, but we only want one of them
if len(data[3]) < self.bar_items:
self.output_piechart(*data[:4])
else:
self.output_barchart(*data[:4])
self.doc.end_page()
self._user.step_progress()
self._user.end_progress()
def output_piechart(self, title1, typename, data, lookup):
# set layout variables
middle_w = self.doc.get_usable_width() / 2
middle_h = self.doc.get_usable_height() / 2
middle = min(middle_w, middle_h)
# start output
style_sheet = self.doc.get_style_sheet()
pstyle = style_sheet.get_paragraph_style('SC-Title')
mark = IndexMark(title1, INDEX_TYPE_TOC, 2)
self.doc.center_text('SC-title', title1, middle_w, 0, mark)
yoffset = utils.pt2cm(pstyle.get_font().get_size())
self.doc.center_text('SC-title', self.fil_name, middle_w, yoffset)
yoffset = 2 * utils.pt2cm(pstyle.get_font().get_size())
self.doc.center_text('SC-title', self.living_desc, middle_w, yoffset)
# collect data for output
color = 0
chart_data = []
for key in lookup:
style = "SC-color-%d" % color
text = "%s (%d)" % (self._(key), data[key])
# graphics style, value, and it's label
chart_data.append((style, data[key], text))
color = (color+1) % 7 # There are only 7 color styles defined
margin = 1.0
legendx = 2.0
# output data...
radius = middle - 2*margin
yoffset += margin + radius
draw_pie_chart(self.doc, middle_w, yoffset, radius, chart_data, -90)
yoffset += radius + 2*margin
if middle == middle_h: # Landscape
legendx = 1.0
yoffset = margin
text = self._("%s (persons):") % self._(typename)
draw_legend(self.doc, legendx, yoffset, chart_data, text, 'SC-legend')
def output_barchart(self, title1, typename, data, lookup):
pt2cm = utils.pt2cm
style_sheet = self.doc.get_style_sheet()
pstyle = style_sheet.get_paragraph_style('SC-Text')
font = pstyle.get_font()
# set layout variables
width = self.doc.get_usable_width()
row_h = pt2cm(font.get_size())
max_y = self.doc.get_usable_height() - row_h
pad = row_h * 0.5
# check maximum value
max_value = max(data[k] for k in lookup) if lookup else 0
# horizontal area for the gfx bars
margin = 1.0
middle = width/2.0
textx = middle + margin/2.0
stopx = middle - margin/2.0
maxsize = stopx - margin
# start output
pstyle = style_sheet.get_paragraph_style('SC-Title')
mark = IndexMark(title1, INDEX_TYPE_TOC, 2)
self.doc.center_text('SC-title', title1, middle, 0, mark)
yoffset = pt2cm(pstyle.get_font().get_size())
self.doc.center_text('SC-title', self.fil_name, middle, yoffset)
yoffset = 2 * pt2cm(pstyle.get_font().get_size())
self.doc.center_text('SC-title', self.living_desc, middle, yoffset)
yoffset = 3 * pt2cm(pstyle.get_font().get_size())
# header
yoffset += (row_h + pad)
text = self._("%s (persons):") % self._(typename)
self.doc.draw_text('SC-text', text, textx, yoffset)
for key in lookup:
yoffset += (row_h + pad)
if yoffset > max_y:
# for graphical report, page_break() doesn't seem to work
self.doc.end_page()
self.doc.start_page()
yoffset = 0
# right align bar to the text
value = data[key]
startx = stopx - (maxsize * value / max_value)
self.doc.draw_box('SC-bar', "",
startx, yoffset, stopx-startx, row_h)
# text after bar
text = "%s (%d)" % (self._(key), data[key])
self.doc.draw_text('SC-text', text, textx, yoffset)
return
def __init__(self, database, options, user):
"""
Create the DetAncestorReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
inc_id - Whether to include Gramps IDs
pagebgg - Whether to include page breaks between generations.
pageben - Whether to include page break before End Notes.
firstName - Whether to use first names instead of pronouns.
fulldate - Whether to use full dates instead of just year.
listchildren - Whether to list children.
list_children_spouses - Whether to list the spouses of the children
includenotes - Whether to include notes.
incattrs - Whether to include attributes
blankplace - Whether to replace missing Places with ___________.
blankDate - Whether to replace missing Dates with ___________.
calcageflag - Whether to compute age.
dupperson - Whether to omit duplicate ancestors
(e.g. when distant cousins marry).
verbose - Whether to use complete sentences
childref - Whether to add descendant references in child list.
addimages - Whether to include images.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
other_events - Whether to include other events.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self.map = {}
self._user = user
menu = options.menu
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.max_generations = get_value('gen')
self.pgbrk = get_value('pagebbg')
self.pgbrkenotes = get_value('pageben')
self.fulldate = get_value('fulldates')
use_fulldate = self.fulldate
self.listchildren = get_value('listc')
self.list_children_spouses = get_value('listc_spouses')
self.includenotes = get_value('incnotes')
use_call = get_value('usecall')
blankplace = get_value('repplace')
blankdate = get_value('repdate')
self.calcageflag = get_value('computeage')
self.dupperson = get_value('omitda')
self.verbose = get_value('verbose')
self.childref = get_value('desref')
self.addimages = get_value('incphotos')
self.inc_names = get_value('incnames')
self.inc_events = get_value('incevents')
self.inc_addr = get_value('incaddresses')
self.inc_sources = get_value('incsources')
self.inc_srcnotes = get_value('incsrcnotes')
self.inc_attrs = get_value('incattrs')
self.initial_sosa = get_value('initial_sosa')
self.want_ids = get_value('inc_id')
pid = get_value('pid')
self.other_events = get_value('incotherevents')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self._nd = self._name_display
self.gen_handles = {}
self.prev_gen_handles = {}
if blankdate:
empty_date = EMPTY_ENTRY
else:
empty_date = ""
if blankplace:
empty_place = EMPTY_ENTRY
else:
empty_place = ""
self.__narrator = Narrator(self._db, self.verbose, use_call,
use_fulldate, empty_date, empty_place,
nlocale=self._locale,
get_endnote_numbers=self.endnotes)
self.bibli = Bibliography(Bibliography.MODE_DATE|Bibliography.MODE_PAGE)
class DetAncestorReport(Report):
""" the Detailed Ancestor Report """
def __init__(self, database, options, user):
"""
Create the DetAncestorReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
inc_id - Whether to include Gramps IDs
pagebgg - Whether to include page breaks between generations.
pageben - Whether to include page break before End Notes.
firstName - Whether to use first names instead of pronouns.
fulldate - Whether to use full dates instead of just year.
listchildren - Whether to list children.
list_children_spouses - Whether to list the spouses of the children
includenotes - Whether to include notes.
incattrs - Whether to include attributes
blankplace - Whether to replace missing Places with ___________.
blankDate - Whether to replace missing Dates with ___________.
calcageflag - Whether to compute age.
dupperson - Whether to omit duplicate ancestors
(e.g. when distant cousins marry).
verbose - Whether to use complete sentences
childref - Whether to add descendant references in child list.
addimages - Whether to include images.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
other_events - Whether to include other events.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self.map = {}
self._user = user
menu = options.menu
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.max_generations = get_value('gen')
self.pgbrk = get_value('pagebbg')
self.pgbrkenotes = get_value('pageben')
self.fulldate = get_value('fulldates')
use_fulldate = self.fulldate
self.listchildren = get_value('listc')
self.list_children_spouses = get_value('listc_spouses')
self.includenotes = get_value('incnotes')
use_call = get_value('usecall')
blankplace = get_value('repplace')
blankdate = get_value('repdate')
self.calcageflag = get_value('computeage')
self.dupperson = get_value('omitda')
self.verbose = get_value('verbose')
self.childref = get_value('desref')
self.addimages = get_value('incphotos')
self.inc_names = get_value('incnames')
self.inc_events = get_value('incevents')
self.inc_addr = get_value('incaddresses')
self.inc_sources = get_value('incsources')
self.inc_srcnotes = get_value('incsrcnotes')
self.inc_attrs = get_value('incattrs')
self.initial_sosa = get_value('initial_sosa')
self.want_ids = get_value('inc_id')
pid = get_value('pid')
self.other_events = get_value('incotherevents')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self._nd = self._name_display
self.gen_handles = {}
self.prev_gen_handles = {}
if blankdate:
empty_date = EMPTY_ENTRY
else:
empty_date = ""
if blankplace:
empty_place = EMPTY_ENTRY
else:
empty_place = ""
self.__narrator = Narrator(self._db, self.verbose, use_call,
use_fulldate, empty_date, empty_place,
nlocale=self._locale,
get_endnote_numbers=self.endnotes)
self.bibli = Bibliography(Bibliography.MODE_DATE|Bibliography.MODE_PAGE)
def apply_filter(self, person_handle, index):
""" recurse up through the generations """
if (not person_handle) or (index >= 2**self.max_generations):
return
self.map[index] = person_handle
person = self._db.get_person_from_handle(person_handle)
family_handle = person.get_main_parents_family_handle()
if family_handle:
family = self._db.get_family_from_handle(family_handle)
self.apply_filter(family.get_father_handle(), index*2)
self.apply_filter(family.get_mother_handle(), (index*2)+1)
def write_report(self):
self.apply_filter(self.center_person.get_handle(), 1)
name = self._nd.display_name(self.center_person.get_primary_name())
if not name:
name = self._("Unknown")
self.doc.start_paragraph("DAR-Title")
# feature request 2356: avoid genitive form
title = self._("Ancestral Report for %s") % name
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
generation = 0
for key in sorted(self.map):
if generation == 0 or key >= 2**generation:
if self.pgbrk and generation > 0:
self.doc.page_break()
self.doc.start_paragraph("DAR-Generation")
text = self._("Generation %d") % (generation+1)
mark = IndexMark(text, INDEX_TYPE_TOC, 2)
self.doc.write_text(text, mark)
self.doc.end_paragraph()
generation += 1
if self.childref:
self.prev_gen_handles = self.gen_handles.copy()
self.gen_handles.clear()
person_handle = self.map[key]
person = self._db.get_person_from_handle(person_handle)
self.gen_handles[person_handle] = key
dupperson = self.write_person(key)
if dupperson == 0: # Is this a duplicate ind record
if self.listchildren or self.inc_events:
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
mother_handle = family.get_mother_handle()
if (mother_handle is None or
mother_handle not in iter(self.map.values()) or
person.get_gender() == Person.FEMALE):
# The second test above also covers the 1. person's
# mate, which is not an ancestor and as such is not
# included in the self.map dictionary
if self.listchildren:
self.write_children(family)
if self.inc_events:
self.write_family_events(family)
if self.inc_sources:
if self.pgbrkenotes:
self.doc.page_break()
# it ignores language set for Note type (use locale)
endnotes.write_endnotes(self.bibli, self._db, self.doc,
printnotes=self.inc_srcnotes,
elocale=self._locale)
def _get_s_s(self, key):
"""returns Sosa-Stradonitz (a.k.a. Kekule or Ahnentafel) number"""
generation = int(math.floor(math.log(key, 2))) # 0
gen_start = pow(2, generation) # 1
new_gen_start = self.initial_sosa * gen_start # 3
return new_gen_start + (key - gen_start) # 3+0
def write_person(self, key):
""" Output birth, death, parentage, marriage and notes information """
def write_more_header(first, name):
""" convenience function """
if first:
self.doc.start_paragraph('DAR-MoreHeader')
self.doc.write_text(self._('More about %(person_name)s:'
) % {'person_name' : name})
self.doc.end_paragraph()
return False
person_handle = self.map[key]
person = self._db.get_person_from_handle(person_handle)
plist = person.get_media_list()
self.__narrator.set_subject(person)
if self.addimages and len(plist) > 0:
photo = plist[0]
utils.insert_image(self._db, self.doc, photo, self._user)
self.doc.start_paragraph("DAR-First-Entry", "%d." % self._get_s_s(key))
name = self._nd.display(person)
if not name:
name = self._("Unknown")
mark = utils.get_person_mark(self._db, person)
self.doc.start_bold()
self.doc.write_text(name, mark)
if name[-1:] == '.':
self.doc.write_text_citation("%s " % self.endnotes(person))
elif name:
self.doc.write_text_citation("%s. " % self.endnotes(person))
self.doc.end_bold()
if self.want_ids:
self.doc.write_text('(%s) ' % person.get_gramps_id())
if self.dupperson:
# Check for duplicate record (result of distant cousins marrying)
for dkey in sorted(self.map):
if dkey >= key:
break
if self.map[key] == self.map[dkey]:
self.doc.write_text(
self._("%(name)s is the same person as [%(id_str)s]."
) % {'name' : '', 'id_str' : str(dkey)})
self.doc.end_paragraph()
return 1 # Duplicate person
if not self.verbose:
self.write_parents(person)
text = self.__narrator.get_born_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_baptised_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_christened_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_died_string(self.calcageflag)
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_buried_string()
if text:
self.doc.write_text_citation(text)
if self.verbose:
self.write_parents(person)
if not key % 2 or key == 1:
self.write_marriage(person)
self.doc.end_paragraph()
if key == 1:
self.write_mate(person)
notelist = person.get_note_list()
if len(notelist) > 0 and self.includenotes:
self.doc.start_paragraph("DAR-NoteHeader")
# feature request 2356: avoid genitive form
self.doc.write_text(self._("Notes for %s") % name)
self.doc.end_paragraph()
for notehandle in notelist:
note = self._db.get_note_from_handle(notehandle)
self.doc.write_styled_note(
note.get_styledtext(),
note.get_format(),
"DAR-Entry",
contains_html=(note.get_type() == NoteType.HTML_CODE)
)
first = True
if self.inc_names:
for alt_name in person.get_alternate_names():
first = write_more_header(first, name)
self.doc.start_paragraph('DAR-MoreDetails')
atype = self._get_type(alt_name.get_type())
self.doc.write_text_citation(
self._('%(type)s: %(value)s%(endnotes)s'
) % {'type' : self._(atype),
'value' : alt_name.get_regular_name(),
'endnotes' : self.endnotes(alt_name)})
self.doc.end_paragraph()
if self.inc_events:
birth_ref = person.get_birth_ref()
death_ref = person.get_death_ref()
for event_ref in person.get_primary_event_ref_list():
if event_ref == birth_ref or event_ref == death_ref:
continue
first = write_more_header(first, name)
self.write_event(event_ref)
if self.other_events:
for event_ref in person.get_event_ref_list():
role = event_ref.get_role()
if role in (EventRoleType.PRIMARY, EventRoleType.FAMILY):
continue
first = write_more_header(first, name)
self.write_event(event_ref)
if self.inc_addr:
for addr in person.get_address_list():
first = write_more_header(first, name)
self.doc.start_paragraph('DAR-MoreDetails')
text = utils.get_address_str(addr)
self.doc.write_text(self._('Address: '))
if self.fulldate:
date = self._get_date(addr.get_date_object())
else:
date = addr.get_date_object().get_year()
if date:
# translators: needed for Arabic, ignore otherwise
self.doc.write_text(self._('%s, ') % date)
self.doc.write_text(text)
self.doc.write_text_citation(self.endnotes(addr))
self.doc.end_paragraph()
if self.inc_attrs:
attrs = person.get_attribute_list()
if attrs:
first = write_more_header(first, name)
for attr in attrs:
self.doc.start_paragraph('DAR-MoreDetails')
attr_name = attr.get_type().type2base()
# translators: needed for French, ignore otherwise
text = self._("%(type)s: %(value)s%(endnotes)s"
) % {'type' : self._(attr_name),
'value' : attr.get_value(),
'endnotes' : self.endnotes(attr)}
self.doc.write_text_citation(text)
self.doc.end_paragraph()
return 0 # Not duplicate person
def write_event(self, event_ref):
""" write out the event """
text = ""
event = self._db.get_event_from_handle(event_ref.ref)
if self.fulldate:
date = self._get_date(event.get_date_object())
else:
date = event.get_date_object().get_year()
place = _pd.display_event(self._db, event)
self.doc.start_paragraph('DAR-MoreDetails')
if date and place:
# translators: needed for Arabic, ignore otherwise
text += self._('%(str1)s, %(str2)s'
) % {'str1' : date, 'str2' : place}
elif date:
text += '%s' % date
elif place:
text += '%s' % self._(place)
if event.get_description():
if text:
text += ". "
text += event.get_description()
text += self.endnotes(event)
if text:
text += ". "
event_name = self._(self._get_type(event.get_type()))
role = event_ref.get_role()
if role in (EventRoleType.PRIMARY, EventRoleType.FAMILY):
# translators: needed for French, ignore otherwise
text = self._('%(str1)s: %(str2)s'
) % {'str1' : event_name, 'str2' : text}
else:
primaries = get_participant_from_event(self._db, event_ref.ref)
text = self._('%(event_role)s at %(event_name)s '
'of %(primary_person)s: %(event_text)s'
) % {'event_role' : self._(role.xml_str()),
'event_name' : event_name,
'primary_person' : primaries,
'event_text' : text}
self.doc.write_text_citation(text)
if self.inc_attrs:
text = ""
attr_list = event.get_attribute_list()
attr_list.extend(event_ref.get_attribute_list())
for attr in attr_list:
if text:
# translators: needed for Arabic, ignore otherwise
text += self._("; ")
attr_name = attr.get_type().type2base()
# translators: needed for French, ignore otherwise
text += self._("%(type)s: %(value)s%(endnotes)s"
) % {'type' : self._(attr_name),
'value' : attr.get_value(),
'endnotes' : self.endnotes(attr)}
text = " " + text
self.doc.write_text_citation(text)
self.doc.end_paragraph()
if self.includenotes:
# if the event or event reference has a note attached to it,
# get the text and format it correctly
notelist = event.get_note_list()
notelist.extend(event_ref.get_note_list())
for notehandle in notelist:
note = self._db.get_note_from_handle(notehandle)
self.doc.write_styled_note(
note.get_styledtext(),
note.get_format(),
"DAR-MoreDetails",
contains_html=(note.get_type() == NoteType.HTML_CODE)
)
def write_parents(self, person):
""" write the parents """
family_handle = person.get_main_parents_family_handle()
if family_handle:
family = self._db.get_family_from_handle(family_handle)
mother_handle = family.get_mother_handle()
father_handle = family.get_father_handle()
if mother_handle:
mother = self._db.get_person_from_handle(mother_handle)
mother_name = self._nd.display_name(mother.get_primary_name())
mother_mark = utils.get_person_mark(self._db, mother)
else:
mother_name = ""
mother_mark = ""
if father_handle:
father = self._db.get_person_from_handle(father_handle)
father_name = self._nd.display_name(father.get_primary_name())
father_mark = utils.get_person_mark(self._db, father)
else:
father_name = ""
father_mark = ""
text = self.__narrator.get_child_string(father_name, mother_name)
if text:
self.doc.write_text(text)
if father_mark:
self.doc.write_text("", father_mark)
if mother_mark:
self.doc.write_text("", mother_mark)
def write_marriage(self, person):
"""
Output marriage sentence.
"""
is_first = True
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
spouse_handle = utils.find_spouse(person, family)
if spouse_handle:
spouse = self._db.get_person_from_handle(spouse_handle)
spouse_mark = utils.get_person_mark(self._db, spouse)
else:
spouse_mark = None
text = self.__narrator.get_married_string(family,
is_first,
self._nd)
if text:
self.doc.write_text_citation(text, spouse_mark)
if self.want_ids:
self.doc.write_text(' (%s)' % family.get_gramps_id())
is_first = False
def write_children(self, family):
"""
List children.
:param family: Family
:return:
"""
if not family.get_child_ref_list():
return
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self._db.get_person_from_handle(mother_handle)
mother_name = self._nd.display(mother)
if not mother_name:
mother_name = self._("Unknown")
else:
mother_name = self._("Unknown")
father_handle = family.get_father_handle()
if father_handle:
father = self._db.get_person_from_handle(father_handle)
father_name = self._nd.display(father)
if not father_name:
father_name = self._("Unknown")
else:
father_name = self._("Unknown")
self.doc.start_paragraph("DAR-ChildTitle")
self.doc.write_text(
self._("Children of %(mother_name)s and %(father_name)s"
) % {'father_name' : father_name,
'mother_name' : mother_name})
self.doc.end_paragraph()
cnt = 1
for child_ref in family.get_child_ref_list():
child_handle = child_ref.ref
child = self._db.get_person_from_handle(child_handle)
child_name = self._nd.display(child)
if not child_name:
child_name = self._("Unknown")
child_mark = utils.get_person_mark(self._db, child)
if self.childref and self.prev_gen_handles.get(child_handle):
value = int(self.prev_gen_handles.get(child_handle))
child_name += " [%d]" % self._get_s_s(value)
self.doc.start_paragraph("DAR-ChildList",
utils.roman(cnt).lower() + ".")
cnt += 1
self.__narrator.set_subject(child)
if child_name:
self.doc.write_text("%s. " % child_name, child_mark)
if self.want_ids:
self.doc.write_text('(%s) ' % child.get_gramps_id())
self.doc.write_text_citation(
self.__narrator.get_born_string() or
self.__narrator.get_christened_string() or
self.__narrator.get_baptised_string())
self.doc.write_text_citation(
self.__narrator.get_died_string() or
self.__narrator.get_buried_string())
# if the list_children_spouses option is selected:
if self.list_children_spouses:
# get the family of the child that contains the spouse
# of the child. There may be more than one spouse for each
# child
family_handle_list = child.get_family_handle_list()
# for the first spouse, this is true.
# For subsequent spouses, make it false
is_first_family = True
for family_handle in family_handle_list:
child_family = self.database.get_family_from_handle(
family_handle
)
self.doc.write_text_citation(
self.__narrator.get_married_string(
child_family, is_first_family, self._name_display
)
)
is_first_family = False
self.doc.end_paragraph()
def write_family_events(self, family):
""" write the family events """
if not family.get_event_ref_list():
return
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self._db.get_person_from_handle(mother_handle)
mother_name = self._nd.display(mother)
if not mother_name:
mother_name = self._("Unknown")
else:
mother_name = self._("Unknown")
father_handle = family.get_father_handle()
if father_handle:
father = self._db.get_person_from_handle(father_handle)
father_name = self._nd.display(father)
if not father_name:
father_name = self._("Unknown")
else:
father_name = self._("Unknown")
first = True
for event_ref in family.get_event_ref_list():
if first:
self.doc.start_paragraph('DAR-MoreHeader')
self.doc.write_text(
self._('More about %(mother_name)s and %(father_name)s:'
) % {'mother_name' : mother_name,
'father_name' : father_name})
self.doc.end_paragraph()
first = False
self.write_event(event_ref)
def write_mate(self, person):
"""Output birth, death, parentage, marriage and notes information """
ind = None
has_info = False
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
ind_handle = None
if person.get_gender() == Person.MALE:
ind_handle = family.get_mother_handle()
else:
ind_handle = family.get_father_handle()
if ind_handle:
ind = self._db.get_person_from_handle(ind_handle)
for event_ref in ind.get_primary_event_ref_list():
event = self._db.get_event_from_handle(event_ref.ref)
if event:
etype = event.get_type()
if (etype == EventType.BAPTISM or
etype == EventType.BURIAL or
etype == EventType.BIRTH or
etype == EventType.DEATH):
has_info = True
break
if not has_info:
family_handle = ind.get_main_parents_family_handle()
if family_handle:
fam = self._db.get_family_from_handle(family_handle)
if fam.get_mother_handle() or fam.get_father_handle():
has_info = True
break
if has_info:
self.doc.start_paragraph("DAR-MoreHeader")
plist = ind.get_media_list()
if self.addimages and len(plist) > 0:
photo = plist[0]
utils.insert_image(self._db, self.doc,
photo, self._user)
name = self._nd.display(ind)
if not name:
name = self._("Unknown")
mark = utils.get_person_mark(self._db, ind)
if family.get_relationship() == FamilyRelType.MARRIED:
self.doc.write_text(self._("Spouse: %s"
) % name,
mark)
else:
self.doc.write_text(self._("Relationship with: %s"
) % name,
mark)
if name[-1:] != '.':
self.doc.write_text(".")
if self.want_ids:
self.doc.write_text(' (%s)' % ind.get_gramps_id())
self.doc.write_text_citation(self.endnotes(ind))
self.doc.end_paragraph()
self.doc.start_paragraph("DAR-Entry")
self.__narrator.set_subject(ind)
text = self.__narrator.get_born_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_baptised_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_christened_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_died_string(self.calcageflag)
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_buried_string()
if text:
self.doc.write_text_citation(text)
self.write_parents(ind)
self.doc.end_paragraph()
def endnotes(self, obj):
""" cite the endnotes for the object """
if not obj or not self.inc_sources:
return ""
txt = endnotes.cite_source(self.bibli, self._db, obj, self._locale)
if txt:
txt = '<super>' + txt + '</super>'
return txt
class FamilyGroup(Report):
""" Family Group Report """
def __init__(self, database, options, user):
"""
Create the FamilyGroup object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the families of the database.
The option class carries its number, and the function
returning the list of filters.
incattrs - Whether to include attributes
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self._user = user
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
self._locale = self.set_locale(lang)
self._ = self._locale.translation.sgettext # needed for English
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.db = self.database
self.filter = menu.get_option_by_name('filter').get_filter()
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.gramps_ids = get_value('gramps_ids')
self.recursive = get_value('recursive')
self.missing_info = get_value('missinginfo')
self.generations = get_value('generations')
self.inc_fam_notes = get_value('incFamNotes')
self.inc_par_events = get_value('incParEvents')
self.inc_par_addr = get_value('incParAddr')
self.inc_par_notes = get_value('incParNotes')
self.inc_par_names = get_value('incParNames')
self.inc_par_mar = get_value('incParMar')
self.inc_rel_dates = get_value('incRelDates')
self.inc_chi_mar = get_value('incChiMar')
self.include_attrs = get_value('incattrs')
stdoptions.run_name_format_option(self, menu)
def dump_parent_event(self, name, event):
place = ""
date = ""
descr = ""
if event:
date = self._get_date(event.get_date_object())
place = _pd.display_event(self.db, event)
if place is None:
place = ''
descr = event.get_description()
if self.include_attrs:
for attr in event.get_attribute_list():
if descr:
# translators: needed for Arabic, ignore otherwise
descr += self._("; ")
attr_type = self._get_type(attr.get_type())
# translators: needed for French, ignore otherwise
descr += self._("%(str1)s: %(str2)s"
) % {'str1' : self._(attr_type),
'str2' : attr.get_value()}
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
if descr:
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(descr)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
if date or place:
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.end_paragraph()
self.doc.end_cell()
if (date or place) or not descr:
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(place)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def dump_parent_parents(self, person):
family_handle = person.get_main_parents_family_handle()
father_name = ""
mother_name = ""
if family_handle:
family = self.db.get_family_from_handle(family_handle)
father_handle = family.get_father_handle()
if father_handle:
father = self.db.get_person_from_handle(father_handle)
father_name = self._name_display.display(father)
if self.gramps_ids:
gid = father.get_gramps_id()
if gid:
father_name += " (%s)" % gid
if self.inc_rel_dates:
birth_ref = father.get_birth_ref()
birth = " "
if birth_ref:
event = self.db.get_event_from_handle(birth_ref.ref)
birth = self._get_date(event.get_date_object())
death_ref = father.get_death_ref()
death = " "
if death_ref:
event = self.db.get_event_from_handle(death_ref.ref)
death = self._get_date(event.get_date_object())
if birth_ref or death_ref:
father_name += " (%s - %s)" % (birth, death)
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self.db.get_person_from_handle(mother_handle)
mother_name = self._name_display.display(mother)
if self.gramps_ids:
gid = mother.get_gramps_id()
if gid:
mother_name += " (%s)" % gid
if self.inc_rel_dates:
birth_ref = mother.get_birth_ref()
birth = " "
if birth_ref:
event = self.db.get_event_from_handle(birth_ref.ref)
birth = self._get_date(event.get_date_object())
death_ref = mother.get_death_ref()
death = " "
if death_ref:
event = self.db.get_event_from_handle(death_ref.ref)
death = self._get_date(event.get_date_object())
if birth_ref or death_ref:
mother_name += " (%s - %s)" % (birth, death)
if father_name != "":
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(self._("Father"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.start_paragraph('FGR-Normal')
mark = utils.get_person_mark(self.db, father)
self.doc.write_text(father_name, mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
elif self.missing_info:
self.dump_parent_line(self._("Father"), "")
if mother_name != "":
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(self._("Mother"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.start_paragraph('FGR-Normal')
mark = utils.get_person_mark(self.db, mother)
self.doc.write_text(mother_name, mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
elif self.missing_info:
self.dump_parent_line(self._("Mother"), "")
def dump_parent_line(self, name, text):
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(text)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def dump_parent_noteline(self, name, note):
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.write_styled_note(
note.get_styledtext(), note.get_format(), 'FGR-Note',
contains_html=(note.get_type() == NoteType.HTML_CODE))
self.doc.end_cell()
self.doc.end_row()
def dump_parent(self, title, person_handle):
if not person_handle and not self.missing_info:
return
elif not person_handle:
person = Person()
else:
person = self.db.get_person_from_handle(person_handle)
name = self._name_display.display(person)
self.doc.start_table(title, 'FGR-ParentTable')
self.doc.start_row()
self.doc.start_cell('FGR-ParentHead', 3)
self.doc.start_paragraph('FGR-ParentName')
mark = utils.get_person_mark(self.db, person)
# translators: needed for French, ignore otherwise
self.doc.write_text(self._("%(str1)s: %(str2)s"
) % {'str1' : title,
'str2' : name},
mark)
if self.gramps_ids:
gid = person.get_gramps_id()
if gid:
self.doc.write_text(" (%s)" % gid)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
birth_ref = person.get_birth_ref()
birth = None
ev_name = self._("Birth")
if birth_ref:
birth = self.db.get_event_from_handle(birth_ref.ref)
if birth or self.missing_info:
self.dump_parent_event(ev_name, birth)
death_ref = person.get_death_ref()
death = None
ev_name = self._("Death")
if death_ref:
death = self.db.get_event_from_handle(death_ref.ref)
if death or self.missing_info:
self.dump_parent_event(ev_name, death)
self.dump_parent_parents(person)
if self.inc_par_events:
for event_ref in person.get_primary_event_ref_list():
if event_ref != birth_ref and event_ref != death_ref:
event = self.db.get_event_from_handle(event_ref.ref)
event_type = self._get_type(event.get_type())
self.dump_parent_event(self._(event_type), event)
if self.inc_par_addr:
addrlist = person.get_address_list()[:]
for addr in addrlist:
location = utils.get_address_str(addr)
date = self._get_date(addr.get_date_object())
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(self._("Address"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(location)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
if self.inc_par_notes:
for notehandle in person.get_note_list():
note = self.db.get_note_from_handle(notehandle)
self.dump_parent_noteline(self._("Note"), note)
if self.include_attrs:
for attr in person.get_attribute_list():
attr_type = self._get_type(attr.get_type())
self.dump_parent_line(self._(attr_type), attr.get_value())
if self.inc_par_names:
for alt_name in person.get_alternate_names():
name_type = self._get_type(alt_name.get_type())
name = self._name_display.display_name(alt_name)
self.dump_parent_line(self._(name_type), name)
self.doc.end_table()
def dump_marriage(self, family):
if not family:
return
mrg = None
family_list = family.get_event_ref_list()
for event_ref in family_list:
if event_ref:
event = self.db.get_event_from_handle(event_ref.ref)
if (event.get_type() == EventType.MARRIAGE and
(event_ref.get_role() == EventRoleType.FAMILY or
event_ref.get_role() == EventRoleType.PRIMARY)):
mrg = event
break
if len(family_list) > 0 or self.missing_info or self.include_attrs:
self.doc.start_table("MarriageInfo", 'FGR-ParentTable')
self.doc.start_row()
self.doc.start_cell('FGR-ParentHead', 3)
self.doc.start_paragraph('FGR-ParentName')
header = self._("Marriage")
if self.gramps_ids:
header += " (%s)" % family.get_gramps_id()
# translators: needed for French, ignore otherwise
self.doc.write_text(self._("%s:") % header)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.dump_parent_event(self._("Marriage"), mrg)
for event_ref in family_list:
if event_ref:
event = self.db.get_event_from_handle(event_ref.ref)
if event.get_type() != EventType.MARRIAGE:
event_type = self._get_type(event.get_type())
self.dump_parent_event(self._(event_type), event)
if self.include_attrs:
for attr in family.get_attribute_list():
attr_type = self._get_type(attr.get_type())
self.dump_parent_line(self._(attr_type), attr.get_value())
if self.inc_fam_notes:
for notehandle in family.get_note_list():
note = self.database.get_note_from_handle(notehandle)
self.dump_parent_noteline(self._("Note"), note)
self.doc.end_table()
def dump_child_event(self, text, name, event):
date = ""
place = ""
if event:
date = self._get_date(event.get_date_object())
place_handle = event.get_place_handle()
if place_handle:
place = _pd.display_event(self.db, event)
if place is None:
place = ''
self.doc.start_row()
self.doc.start_cell(text)
self.doc.start_paragraph('FGR-Normal')
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContents')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContents')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContentsEnd')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(place)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def dump_child(self, index, person_handle):
person = self.db.get_person_from_handle(person_handle)
families = len(person.get_family_handle_list())
birth_ref = person.get_birth_ref()
if birth_ref:
birth = self.db.get_event_from_handle(birth_ref.ref)
else:
birth = None
death_ref = person.get_death_ref()
if death_ref:
death = self.db.get_event_from_handle(death_ref.ref)
else:
death = None
spouse_count = 0
if self.inc_chi_mar:
for family_handle in person.get_family_handle_list():
family = self.db.get_family_from_handle(family_handle)
spouse_id = None
if person_handle == family.get_father_handle():
spouse_id = family.get_mother_handle()
else:
spouse_id = family.get_father_handle()
if spouse_id:
spouse_count += 1
self.doc.start_row()
if (spouse_count != 0
or self.missing_info
or death is not None
or birth is not None):
self.doc.start_cell('FGR-TextChild1')
else:
self.doc.start_cell('FGR-TextChild2')
self.doc.start_paragraph('FGR-ChildText')
index_str = ("%d" % index)
if person.get_gender() == Person.MALE:
self.doc.write_text(index_str + self._("acronym for male|M"))
elif person.get_gender() == Person.FEMALE:
self.doc.write_text(index_str + self._("acronym for female|F"))
else:
self.doc.write_text(self._("acronym for unknown|%dU") % index)
self.doc.end_paragraph()
self.doc.end_cell()
name = self._name_display.display(person)
mark = utils.get_person_mark(self.db, person)
self.doc.start_cell('FGR-ChildName', 3)
self.doc.start_paragraph('FGR-ChildText')
self.doc.write_text(name, mark)
if self.gramps_ids:
self.doc.write_text(" (%s)" % person.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
if self.missing_info or birth is not None:
if spouse_count != 0 or self.missing_info or death is not None:
self.dump_child_event('FGR-TextChild1', self._('Birth'), birth)
else:
self.dump_child_event('FGR-TextChild2', self._('Birth'), birth)
if self.missing_info or death is not None:
if spouse_count == 0 or not self.inc_chi_mar:
self.dump_child_event('FGR-TextChild2', self._('Death'), death)
else:
self.dump_child_event('FGR-TextChild1', self._('Death'), death)
if self.inc_chi_mar:
index = 0
for family_handle in person.get_family_handle_list():
mrg = None
index += 1
family = self.db.get_family_from_handle(family_handle)
for event_ref in family.get_event_ref_list():
if event_ref:
event = self.db.get_event_from_handle(event_ref.ref)
if event.type == EventType.MARRIAGE:
mrg = event
break
spouse_id = None
if person_handle == family.get_father_handle():
spouse_id = family.get_mother_handle()
else:
spouse_id = family.get_father_handle()
if spouse_id:
self.doc.start_row()
if mrg or index != families:
self.doc.start_cell('FGR-TextChild1')
else:
self.doc.start_cell('FGR-TextChild2')
self.doc.start_paragraph('FGR-Normal')
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContents')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(self._("Spouse"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContentsEnd', 2)
self.doc.start_paragraph('FGR-Normal')
spouse = self.db.get_person_from_handle(spouse_id)
spouse_name = self._name_display.display(spouse)
if self.gramps_ids:
gid = spouse.get_gramps_id()
if gid:
spouse_name += " (%s)" % gid
if self.inc_rel_dates:
birth = " "
birth_ref = spouse.get_birth_ref()
if birth_ref:
event = self.db.get_event_from_handle(birth_ref.ref)
birth = self._get_date(event.get_date_object())
death = " "
death_ref = spouse.get_death_ref()
if death_ref:
event = self.db.get_event_from_handle(death_ref.ref)
death = self._get_date(event.get_date_object())
if birth_ref or death_ref:
spouse_name += " (%s - %s)" % (birth, death)
if self.gramps_ids:
fid = family.get_gramps_id()
if fid:
spouse_name += " (%s)" % fid
mark = utils.get_person_mark(self.db, spouse)
self.doc.write_text(spouse_name, mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
if mrg:
ev_name = self._("Marriage")
if index == families:
self.dump_child_event('FGR-TextChild2', ev_name, mrg)
else:
self.dump_child_event('FGR-TextChild1', ev_name, mrg)
def dump_family(self, family_handle, generation):
self.doc.start_paragraph('FGR-Title')
if self.recursive and self.generations:
title = self._("Family Group Report - Generation %d") % generation
else:
title = self._("Family Group Report")
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
family = self.db.get_family_from_handle(family_handle)
self.dump_parent(self._("Husband"), family.get_father_handle())
self.doc.start_paragraph("FGR-blank")
self.doc.end_paragraph()
if self.inc_par_mar:
self.dump_marriage(family)
self.doc.start_paragraph("FGR-blank")
self.doc.end_paragraph()
self.dump_parent(self._("Wife"), family.get_mother_handle())
length = len(family.get_child_ref_list())
if length > 0:
self.doc.start_paragraph("FGR-blank")
self.doc.end_paragraph()
self.doc.start_table('FGR-Children', 'FGR-ChildTable')
self.doc.start_row()
self.doc.start_cell('FGR-ParentHead', 4)
self.doc.start_paragraph('FGR-ParentName')
self.doc.write_text(self._("Children"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
index = 1
for child_ref in family.get_child_ref_list():
self.dump_child(index, child_ref.ref)
index += 1
self.doc.end_table()
if self.recursive:
for child_ref in family.get_child_ref_list():
child = self.db.get_person_from_handle(child_ref.ref)
for child_family_handle in child.get_family_handle_list():
if child_family_handle != family_handle:
self.doc.page_break()
self.dump_family(child_family_handle, (generation+1))
def write_report(self):
flist = self.db.get_family_handles(sort_handles=True)
if not self.filter:
fam_list = flist
else:
fam_list = self.filter.apply(self.db, flist, user=self._user)
if fam_list:
with self._user.progress(_('Family Group Report'),
_('Writing families'),
len(fam_list)) as step:
for family_handle in fam_list:
self.dump_family(family_handle, 1)
self.doc.page_break()
step()
else:
raise ReportError(_('Empty report'),
_('You did not specify anybody'))
class DescendantReport(Report):
""" Descendant report """
def __init__(self, database, options, user):
"""
Create the DescendantReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
name_format - Preferred format to display names
dups - Whether to include duplicate descendant trees
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
inc_id - Whether to include Gramps IDs
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.max_generations = menu.get_option_by_name('gen').get_value()
self.want_ids = menu.get_option_by_name('inc_id').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
#Initialize the Printinfo class
self._showdups = menu.get_option_by_name('dups').get_value()
numbering = menu.get_option_by_name('numbering').get_value()
if numbering == "Simple":
obj = PrintSimple(self._showdups)
elif numbering == "Henry":
obj = PrintHenry()
elif numbering == "Modified Henry":
obj = PrintHenry(modified=True)
elif numbering == "d'Aboville":
obj = PrintDAboville()
elif numbering == "de Villiers/Pama":
obj = PrintVilliers()
elif numbering == "Meurgey de Tupigny":
obj = PrintMeurgey()
else:
raise AttributeError("no such numbering: '%s'" % numbering)
marrs = menu.get_option_by_name('marrs').get_value()
divs = menu.get_option_by_name('divs').get_value()
stdoptions.run_name_format_option(self, menu)
self.obj_print = Printinfo(self.doc, self.database, obj, marrs, divs,
self._name_display, self._locale,
self.want_ids)
def write_report(self):
self.doc.start_paragraph("DR-Title")
name = self._name_display.display(self.center_person)
# feature request 2356: avoid genitive form
title = self._("Descendants of %s") % name
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
recurse = RecurseDown(self.max_generations, self.database,
self.obj_print, self._showdups, self._locale)
recurse.recurse(1, self.center_person, None)
class AncestorTree(Report):
""" AncestorTree Report """
def __init__(self, database, options, user):
"""
Create AncestorTree object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
"""
Report.__init__(self, database, options, user)
self.options = options
self._user = user
lang = options.menu.get_option_by_name('trans').get_value()
self._locale = self.set_locale(lang)
stdoptions.run_private_data_option(self, options.menu)
stdoptions.run_living_people_option(self, options.menu, self._locale)
self.database = CacheProxyDb(self.database)
stdoptions.run_name_format_option(self, options.menu)
self._nd = self._name_display
def begin_report(self):
"""
This report needs the following parameters (class variables)
that come in the options class.
max_generations - Maximum number of generations to include.
pagebbg - Whether to include page breaks between generations.
dispf - Display format for the output box.
scale_report - Whether to scale the report to fit the width or all.
indblank - Whether to include blank pages.
compress - Whether to compress chart.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
We will
1. a canvas in its full one-page size
2. a page that we wish to print on
scale up/down either or both of the above as needed/desired.
almost all of this should be moved into Canvas!
"""
database = self.database
self.connect = GUIConnect()
self.connect.set__opts(self.options.menu, self._locale, self._nd)
#Set up the canvas that we will print on.
style_sheet = self.doc.get_style_sheet()
font_normal = style_sheet.get_paragraph_style("AC2-Normal").get_font()
#The canvas that we will put our report on and print off of
self.canvas = Canvas(self.doc,
ReportOptions(self.doc, font_normal, 'AC2-line'))
self.canvas.report_opts.box_shadow *= \
self.connect.get_val('shadowscale')
self.canvas.report_opts.box_pgap *= self.connect.get_val('box_Yscale')
self.canvas.report_opts.box_mgap *= self.connect.get_val('box_Yscale')
with self._user.progress(_('Ancestor Tree'), _('Making the Tree...'),
4) as step:
#make the tree onto the canvas
## inlc_marr = self.connect.get_val("inc_marr")
self.max_generations = self.connect.get_val('maxgen')
tree = MakeAncestorTree(database, self.canvas)
tree.start(self.connect.get_val('pid'))
tree = None
step()
#Title
title = self.connect.title_class(self.doc)
center = self.database.get_person_from_gramps_id(
self.connect.get_val('pid'))
title.calc_title(center)
self.canvas.add_title(title)
#make the report as big as it wants to be.
report = MakeReport(database, self.doc, self.canvas, font_normal)
report.start()
self.max_generations = report.get_generations() #already know
report = None
step()
#Note?
if self.connect.get_val("inc_note"):
note_box = NoteBox(self.doc, "AC2-note-box",
self.connect.get_val("note_place"))
subst = SubstKeywords(self.database, self._locale, self._nd,
None, None)
note_box.text = subst.replace_and_clean(
self.connect.get_val('note_disp'))
self.canvas.add_note(note_box)
#Now we have the report in its full size.
#Do we want to scale the report?
one_page = self.connect.get_val("resize_page")
scale_report = self.connect.get_val("scale_tree")
scale = self.canvas.scale_report(one_page, scale_report != 0,
scale_report == 2)
step()
if scale != 1 or self.connect.get_val('shadowscale') != 1.0:
self.scale_styles(scale)
def write_report(self):
one_page = self.connect.get_val("resize_page")
#scale_report = self.connect.get_val("scale_tree")
#inlc_marr = self.connect.get_val("inc_marr")
inc_border = self.connect.get_val('inc_border')
incblank = self.connect.get_val("inc_blank")
prnnum = self.connect.get_val("inc_pagenum")
#####################
#Setup page information
colsperpage = self.doc.get_usable_width()
colsperpage += self.canvas.report_opts.col_width
colsperpage = int(colsperpage /
(self.canvas.report_opts.max_box_width +
self.canvas.report_opts.col_width))
colsperpage = colsperpage or 1
#####################
#Vars
if prnnum:
page_num_box = PageNumberBox(self.doc, 'AC2-box', self._locale)
#TODO - Here
#####################
#ok, everyone is now ready to print on the canvas. Paginate?
self.canvas.paginate(colsperpage, one_page)
#####################
#Yeah!!!
#lets finally make some pages!!!
#####################
pages = self.canvas.page_count(incblank)
with self._user.progress(_('Ancestor Tree'), _('Printing the Tree...'),
pages) as step:
for page in self.canvas.page_iter_gen(incblank):
self.doc.start_page()
#do we need to print a border?
if inc_border:
page.draw_border('AC2-line')
#Do we need to print the page number?
if prnnum:
page_num_box.display(page)
#Print the individual people and lines
page.display()
step()
self.doc.end_page()
def scale_styles(self, scale):
"""
Scale the styles for this report.
"""
style_sheet = self.doc.get_style_sheet()
graph_style = style_sheet.get_draw_style("AC2-box")
graph_style.set_shadow(graph_style.get_shadow(),
self.canvas.report_opts.box_shadow * scale)
graph_style.set_line_width(graph_style.get_line_width() * scale)
style_sheet.add_draw_style("AC2-box", graph_style)
graph_style = style_sheet.get_draw_style("AC2-fam-box")
graph_style.set_shadow(graph_style.get_shadow(),
self.canvas.report_opts.box_shadow * scale)
graph_style.set_line_width(graph_style.get_line_width() * scale)
style_sheet.add_draw_style("AC2-fam-box", graph_style)
graph_style = style_sheet.get_draw_style("AC2-note-box")
#graph_style.set_shadow(graph_style.get_shadow(),
# self.canvas.report_opts.box_shadow * scale)
graph_style.set_line_width(graph_style.get_line_width() * scale)
style_sheet.add_draw_style("AC2-note-box", graph_style)
para_style = style_sheet.get_paragraph_style("AC2-Normal")
font = para_style.get_font()
font.set_size(font.get_size() * scale)
para_style.set_font(font)
style_sheet.add_paragraph_style("AC2-Normal", para_style)
para_style = style_sheet.get_paragraph_style("AC2-Note")
font = para_style.get_font()
font.set_size(font.get_size() * scale)
para_style.set_font(font)
style_sheet.add_paragraph_style("AC2-Note", para_style)
para_style = style_sheet.get_paragraph_style("AC2-Title")
font = para_style.get_font()
font.set_size(font.get_size() * scale)
para_style.set_font(font)
style_sheet.add_paragraph_style("AC2-Title", para_style)
graph_style = GraphicsStyle()
width = graph_style.get_line_width()
width = width * scale
graph_style.set_line_width(width)
style_sheet.add_draw_style("AC2-line", graph_style)
self.doc.set_style_sheet(style_sheet)
class AncestorReport(Report):
"""
Ancestor Report class
"""
def __init__(self, database, options, user):
"""
Create the AncestorReport object that produces the Ahnentafel report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
pagebbg - Whether to include page breaks between generations.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self.map = {}
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
self.max_generations = menu.get_option_by_name('maxgen').get_value()
self.pgbrk = menu.get_option_by_name('pagebbg').get_value()
self.opt_namebrk = menu.get_option_by_name('namebrk').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if (self.center_person == None):
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self.__narrator = Narrator(self.database,
use_fulldate=True,
nlocale=rlocale)
def apply_filter(self, person_handle, index, generation=1):
"""
Recursive function to walk back all parents of the current person.
When max_generations are hit, we stop the traversal.
"""
# check for end of the current recursion level. This happens
# if the person handle is None, or if the max_generations is hit
if not person_handle or generation > self.max_generations:
return
# store the person in the map based off their index number
# which is passed to the routine.
self.map[index] = person_handle
# retrieve the Person instance from the database from the
# passed person_handle and find the parents from the list.
# Since this report is for natural parents (birth parents),
# we have to handle that parents may not
person = self.database.get_person_from_handle(person_handle)
if person is None:
return
father_handle = None
mother_handle = None
for family_handle in person.get_parent_family_handle_list():
family = self.database.get_family_from_handle(family_handle)
# filter the child_ref_list to find the reference that matches
# the passed person. There should be exactly one, but there is
# nothing that prevents the same child in the list multiple times.
ref = [
c for c in family.get_child_ref_list()
if c.get_reference_handle() == person_handle
]
if ref:
# If the father_handle is not defined and the relationship is
# BIRTH, then we have found the birth father. Same applies to
# the birth mother. If for some reason, the we have multiple
# people defined as the birth parents, we will select based on
# priority in the list
if not father_handle and \
ref[0].get_father_relation() == ChildRefType.BIRTH:
father_handle = family.get_father_handle()
if not mother_handle and \
ref[0].get_mother_relation() == ChildRefType.BIRTH:
mother_handle = family.get_mother_handle()
# Recursively call the function. It is okay if the handle is None,
# since routine handles a handle of None
self.apply_filter(father_handle, index * 2, generation + 1)
self.apply_filter(mother_handle, (index * 2) + 1, generation + 1)
def write_report(self):
"""
The routine the actually creates the report. At this point, the document
is opened and ready for writing.
"""
# Call apply_filter to build the self.map array of people in the
# database that match the ancestry.
self.apply_filter(self.center_person.get_handle(), 1)
# Write the title line. Set in INDEX marker so that this section will be
# identified as a major category if this is included in a Book report.
name = self._name_display.display_formal(self.center_person)
# feature request 2356: avoid genitive form
title = self._("Ahnentafel Report for %s") % name
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.start_paragraph("AHN-Title")
self.doc.write_text(title, mark)
self.doc.end_paragraph()
# get the entries out of the map, and sort them.
generation = 0
for key in sorted(self.map):
# check the index number to see if we need to start a new generation
if generation == log2(key):
# generate a page break if requested
if self.pgbrk and generation > 0:
self.doc.page_break()
generation += 1
# Create the Generation title, set an index marker
gen_text = self._("Generation %d") % generation
mark = None # don't need any with no page breaks
if self.pgbrk:
mark = IndexMark(gen_text, INDEX_TYPE_TOC, 2)
self.doc.start_paragraph("AHN-Generation")
self.doc.write_text(gen_text, mark)
self.doc.end_paragraph()
# Build the entry
self.doc.start_paragraph("AHN-Entry", "%d." % key)
person = self.database.get_person_from_handle(self.map[key])
if person is None:
continue
name = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
# write the name in bold
self.doc.start_bold()
self.doc.write_text(name.strip(), mark)
self.doc.end_bold()
# terminate with a period if it is not already terminated.
# This can happen if the person's name ends with something 'Jr.'
if name[-1:] == '.':
self.doc.write_text(" ")
else:
self.doc.write_text(". ")
# Add a line break if requested (not implemented yet)
if self.opt_namebrk:
self.doc.write_text('\n')
self.__narrator.set_subject(person)
self.doc.write_text(self.__narrator.get_born_string())
self.doc.write_text(self.__narrator.get_baptised_string())
self.doc.write_text(self.__narrator.get_christened_string())
self.doc.write_text(self.__narrator.get_died_string())
self.doc.write_text(self.__narrator.get_buried_string())
self.doc.end_paragraph()
class DetDescendantReport(Report):
""" Detailed Descendant Report """
def __init__(self, database, options, user):
"""
Create the DetDescendantReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
gen - Maximum number of generations to include.
inc_id - Whether to include Gramps IDs
pagebgg - Whether to include page breaks between generations.
pageben - Whether to include page break before End Notes.
fulldates - Whether to use full dates instead of just year.
listc - Whether to list children.
list_children_spouses - Whether to list the spouses of the children
incnotes - Whether to include notes.
usecall - Whether to use the call name as the first name.
repplace - Whether to replace missing Places with ___________.
repdate - Whether to replace missing Dates with ___________.
computeage - Whether to compute age.
verbose - Whether to use complete sentences.
numbering - The descendancy numbering system to be utilized.
desref - Whether to add descendant references in child list.
incphotos - Whether to include images.
incnames - Whether to include other names.
incevents - Whether to include events.
incaddresses - Whether to include addresses.
incsrcnotes - Whether to include source notes in the Endnotes
section. Only works if Include sources is selected.
incmates - Whether to include information about spouses
incattrs - Whether to include attributes
incpaths - Whether to include the path of descendancy
from the start-person to each descendant.
incssign - Whether to include a sign ('+') before the
descendant number in the child-list
to indicate a child has succession.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
incmateref - Whether to print mate information or reference
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
structure - How to structure the report
"""
Report.__init__(self, database, options, user)
self.map = {}
self._user = user
menu = options.menu
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(get_value('trans'))
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.max_generations = get_value('gen')
self.pgbrk = get_value('pagebbg')
self.pgbrkenotes = get_value('pageben')
self.fulldate = get_value('fulldates')
use_fulldate = self.fulldate
self.listchildren = get_value('listc')
self.list_children_spouses = get_value('listc_spouses')
self.inc_notes = get_value('incnotes')
use_call = get_value('usecall')
blankplace = get_value('repplace')
blankdate = get_value('repdate')
self.calcageflag = get_value('computeage')
self.verbose = get_value('verbose')
self.numbering = get_value('numbering')
self.childref = get_value('desref')
self.addimages = get_value('incphotos')
self.structure = get_value('structure')
self.inc_names = get_value('incnames')
self.inc_events = get_value('incevents')
self.inc_addr = get_value('incaddresses')
self.inc_sources = get_value('incsources')
self.inc_srcnotes = get_value('incsrcnotes')
self.inc_mates = get_value('incmates')
self.inc_attrs = get_value('incattrs')
self.inc_paths = get_value('incpaths')
self.inc_ssign = get_value('incssign')
self.inc_materef = get_value('incmateref')
self.want_ids = get_value('inc_id')
pid = get_value('pid')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.gen_handles = {}
self.prev_gen_handles = {}
self.gen_keys = []
self.dnumber = {}
self.dmates = {}
self.numbers_printed = list()
if blankdate:
empty_date = EMPTY_ENTRY
else:
empty_date = ""
if blankplace:
empty_place = EMPTY_ENTRY
else:
empty_place = ""
stdoptions.run_name_format_option(self, menu)
self.__narrator = Narrator(self._db, self.verbose,
use_call, use_fulldate,
empty_date, empty_place,
nlocale=self._locale,
get_endnote_numbers=self.endnotes)
self.bibli = Bibliography(Bibliography.MODE_DATE|Bibliography.MODE_PAGE)
def apply_henry_filter(self, person_handle, index, pid, cur_gen=1):
""" Filter for Henry numbering """
if (not person_handle) or (cur_gen > self.max_generations):
return
if person_handle in self.dnumber:
if self.dnumber[person_handle] > pid:
self.dnumber[person_handle] = pid
else:
self.dnumber[person_handle] = pid
self.map[index] = person_handle
if len(self.gen_keys) < cur_gen:
self.gen_keys.append([index])
else:
self.gen_keys[cur_gen-1].append(index)
person = self._db.get_person_from_handle(person_handle)
index = 0
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
for child_ref in family.get_child_ref_list():
_ix = max(self.map)
self.apply_henry_filter(child_ref.ref, _ix+1,
pid+HENRY[index], cur_gen+1)
index += 1
def apply_mhenry_filter(self, person_handle, index, pid, cur_gen=1):
""" Filter for Modified Henry numbering """
def mhenry():
""" convenience finction """
return str(index) if index < 10 else "(" + str(index) + ")"
if (not person_handle) or (cur_gen > self.max_generations):
return
self.dnumber[person_handle] = pid
self.map[index] = person_handle
if len(self.gen_keys) < cur_gen:
self.gen_keys.append([index])
else:
self.gen_keys[cur_gen-1].append(index)
person = self._db.get_person_from_handle(person_handle)
index = 1
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
for child_ref in family.get_child_ref_list():
_ix = max(self.map)
self.apply_henry_filter(child_ref.ref, _ix+1,
pid+mhenry(), cur_gen+1)
index += 1
def apply_daboville_filter(self, person_handle, index, pid, cur_gen=1):
""" Filter for d'Aboville numbering """
if (not person_handle) or (cur_gen > self.max_generations):
return
self.dnumber[person_handle] = pid
self.map[index] = person_handle
if len(self.gen_keys) < cur_gen:
self.gen_keys.append([index])
else:
self.gen_keys[cur_gen-1].append(index)
person = self._db.get_person_from_handle(person_handle)
index = 1
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
for child_ref in family.get_child_ref_list():
_ix = max(self.map)
self.apply_daboville_filter(child_ref.ref, _ix+1,
pid+"."+str(index), cur_gen+1)
index += 1
def apply_mod_reg_filter_aux(self, person_handle, index, cur_gen=1):
""" Filter for Record-style (Modified Register) numbering """
if (not person_handle) or (cur_gen > self.max_generations):
return
self.map[index] = person_handle
if len(self.gen_keys) < cur_gen:
self.gen_keys.append([index])
else:
self.gen_keys[cur_gen-1].append(index)
person = self._db.get_person_from_handle(person_handle)
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
for child_ref in family.get_child_ref_list():
_ix = max(self.map)
self.apply_mod_reg_filter_aux(child_ref.ref, _ix+1, cur_gen+1)
def apply_mod_reg_filter(self, person_handle):
""" Entry Filter for Record-style (Modified Register) numbering """
self.apply_mod_reg_filter_aux(person_handle, 1, 1)
mod_reg_number = 1
for generation in range(len(self.gen_keys)):
for key in self.gen_keys[generation]:
person_handle = self.map[key]
if person_handle not in self.dnumber:
self.dnumber[person_handle] = mod_reg_number
mod_reg_number += 1
def write_report(self):
"""
This function is called by the report system and writes the report.
"""
if self.numbering == "Henry":
self.apply_henry_filter(self.center_person.get_handle(), 1, "1")
elif self.numbering == "Modified Henry":
self.apply_mhenry_filter(self.center_person.get_handle(), 1, "1")
elif self.numbering == "d'Aboville":
self.apply_daboville_filter(self.center_person.get_handle(), 1, "1")
elif self.numbering == "Record (Modified Register)":
self.apply_mod_reg_filter(self.center_person.get_handle())
else:
raise AttributeError("no such numbering: '%s'" % self.numbering)
name = self._name_display.display_name(
self.center_person.get_primary_name())
if not name:
name = self._("Unknown")
self.doc.start_paragraph("DDR-Title")
# feature request 2356: avoid genitive form
title = self._("Descendant Report for %(person_name)s"
) % {'person_name' : name}
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
self.numbers_printed = list()
if self.structure == "by generation":
for generation in range(len(self.gen_keys)):
if self.pgbrk and generation > 0:
self.doc.page_break()
self.doc.start_paragraph("DDR-Generation")
text = self._("Generation %d") % (generation+1)
mark = IndexMark(text, INDEX_TYPE_TOC, 2)
self.doc.write_text(text, mark)
self.doc.end_paragraph()
if self.childref:
self.prev_gen_handles = self.gen_handles.copy()
self.gen_handles.clear()
for key in self.gen_keys[generation]:
person_handle = self.map[key]
self.gen_handles[person_handle] = key
self.write_person(key)
elif self.structure == "by lineage":
for key in sorted(self.map):
self.write_person(key)
else:
raise AttributeError("no such structure: '%s'" % self.structure)
if self.inc_sources:
if self.pgbrkenotes:
self.doc.page_break()
# it ignores language set for Note type (use locale)
endnotes.write_endnotes(self.bibli, self._db, self.doc,
printnotes=self.inc_srcnotes,
elocale=self._locale)
def write_path(self, person):
""" determine the path of the person """
path = []
while True:
#person changes in the loop
family_handle = person.get_main_parents_family_handle()
if family_handle:
family = self._db.get_family_from_handle(family_handle)
mother_handle = family.get_mother_handle()
father_handle = family.get_father_handle()
if mother_handle and mother_handle in self.dnumber:
person = self._db.get_person_from_handle(mother_handle)
person_name = self._name_display.display_name(
person.get_primary_name())
path.append(person_name)
elif father_handle and father_handle in self.dnumber:
person = self._db.get_person_from_handle(father_handle)
person_name = self._name_display.display_name(
person.get_primary_name())
path.append(person_name)
else:
break
else:
break
index = len(path)
if index:
self.doc.write_text("(")
for name in path:
if index == 1:
self.doc.write_text(name + "-" + str(index) + ") ")
else:
# translators: needed for Arabic, ignore otherwise
self.doc.write_text(name + "-" + str(index) + self._("; "))
index -= 1
def write_person(self, key):
"""Output birth, death, parentage, marriage and notes information """
person_handle = self.map[key]
person = self._db.get_person_from_handle(person_handle)
val = self.dnumber[person_handle]
if val in self.numbers_printed:
return
else:
self.numbers_printed.append(val)
self.doc.start_paragraph("DDR-First-Entry", "%s." % val)
name = self._name_display.display(person)
if not name:
name = self._("Unknown")
mark = utils.get_person_mark(self._db, person)
self.doc.start_bold()
self.doc.write_text(name, mark)
if name[-1:] == '.':
self.doc.write_text_citation("%s " % self.endnotes(person))
elif name:
self.doc.write_text_citation("%s. " % self.endnotes(person))
self.doc.end_bold()
if self.want_ids:
self.doc.write_text('(%s)' % person.get_gramps_id())
if self.inc_paths:
self.write_path(person)
self.doc.end_paragraph()
self.write_person_info(person)
if (self.inc_mates or self.listchildren or self.inc_notes or
self.inc_events or self.inc_attrs):
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
if self.inc_mates:
self.__write_mate(person, family)
if self.listchildren:
self.__write_children(family)
if self.inc_notes:
self.__write_family_notes(family)
first = True
if self.inc_events:
first = self.__write_family_events(family)
if self.inc_attrs:
self.__write_family_attrs(family, first)
def write_event(self, event_ref):
""" write out the details of an event """
text = ""
event = self._db.get_event_from_handle(event_ref.ref)
if self.fulldate:
date = self._get_date(event.get_date_object())
else:
date = event.get_date_object().get_year()
place = _pd.display_event(self._db, event)
self.doc.start_paragraph('DDR-MoreDetails')
event_name = self._get_type(event.get_type())
if date and place:
# translators: needed for Arabic, ignore otherwise
text += self._('%(str1)s, %(str2)s'
) % {'str1' : date, 'str2' : place}
elif date:
text += '%s' % date
elif place:
text += '%s' % self._(place)
if event.get_description():
if text:
text += ". "
text += event.get_description()
text += self.endnotes(event)
if text:
text += ". "
# translators: needed for French, ignore otherwise
text = self._('%(str1)s: %(str2)s'
) % {'str1' : self._(event_name),
'str2' : text}
self.doc.write_text_citation(text)
if self.inc_attrs:
text = ""
attr_list = event.get_attribute_list()
attr_list.extend(event_ref.get_attribute_list())
for attr in attr_list:
if text:
# translators: needed for Arabic, ignore otherwise
text += self._("; ")
attr_name = attr.get_type().type2base()
# translators: needed for French, ignore otherwise
text += self._("%(type)s: %(value)s%(endnotes)s"
) % {'type' : self._(attr_name),
'value' : attr.get_value(),
'endnotes' : self.endnotes(attr)}
text = " " + text
self.doc.write_text_citation(text)
self.doc.end_paragraph()
if self.inc_notes:
# if the event or event reference has a note attached to it,
# get the text and format it correctly
notelist = event.get_note_list()
notelist.extend(event_ref.get_note_list())
for notehandle in notelist:
note = self._db.get_note_from_handle(notehandle)
self.doc.write_styled_note(
note.get_styledtext(),
note.get_format(), "DDR-MoreDetails",
contains_html=(note.get_type() == NoteType.HTML_CODE))
def __write_parents(self, person):
""" write out the main parents of a person """
family_handle = person.get_main_parents_family_handle()
if family_handle:
family = self._db.get_family_from_handle(family_handle)
mother_handle = family.get_mother_handle()
father_handle = family.get_father_handle()
if mother_handle:
mother = self._db.get_person_from_handle(mother_handle)
mother_name = self._name_display.display_name(
mother.get_primary_name())
mother_mark = utils.get_person_mark(self._db, mother)
else:
mother_name = ""
mother_mark = ""
if father_handle:
father = self._db.get_person_from_handle(father_handle)
father_name = self._name_display.display_name(
father.get_primary_name())
father_mark = utils.get_person_mark(self._db, father)
else:
father_name = ""
father_mark = ""
text = self.__narrator.get_child_string(father_name, mother_name)
if text:
self.doc.write_text(text)
if father_mark:
self.doc.write_text("", father_mark)
if mother_mark:
self.doc.write_text("", mother_mark)
def write_marriage(self, person):
"""
Output marriage sentence.
"""
is_first = True
for family_handle in person.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
spouse_handle = utils.find_spouse(person, family)
if spouse_handle:
spouse = self._db.get_person_from_handle(spouse_handle)
spouse_mark = utils.get_person_mark(self._db, spouse)
else:
spouse_mark = None
text = self.__narrator.get_married_string(family,
is_first,
self._name_display)
if text:
self.doc.write_text_citation(text, spouse_mark)
if self.want_ids:
self.doc.write_text('(%s)' % family.get_gramps_id())
is_first = False
def __write_mate(self, person, family):
"""
Write information about the person's spouse/mate.
"""
if person.get_gender() == Person.MALE:
mate_handle = family.get_mother_handle()
else:
mate_handle = family.get_father_handle()
if mate_handle:
mate = self._db.get_person_from_handle(mate_handle)
self.doc.start_paragraph("DDR-MoreHeader")
name = self._name_display.display(mate)
if not name:
name = self._("Unknown")
mark = utils.get_person_mark(self._db, mate)
if family.get_relationship() == FamilyRelType.MARRIED:
self.doc.write_text(self._("Spouse: %s"
) % name,
mark)
else:
self.doc.write_text(self._("Relationship with: %s"
) % name,
mark)
if name[-1:] != '.':
self.doc.write_text(".")
self.doc.write_text_citation(self.endnotes(mate))
if self.want_ids:
self.doc.write_text(' (%s)' % mate.get_gramps_id())
self.doc.end_paragraph()
if not self.inc_materef:
# Don't want to just print reference
self.write_person_info(mate)
else:
# Check to see if we've married a cousin
if mate_handle in self.dnumber:
self.doc.start_paragraph('DDR-MoreDetails')
self.doc.write_text_citation(
self._("Ref: %(number)s. %(name)s"
) % {'number' : self.dnumber[mate_handle],
'name' : name})
self.doc.end_paragraph()
else:
self.dmates[mate_handle] = person.get_handle()
self.write_person_info(mate)
def __get_mate_names(self, family):
""" get the names of the parents in a family """
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self._db.get_person_from_handle(mother_handle)
mother_name = self._name_display.display(mother)
if not mother_name:
mother_name = self._("Unknown")
else:
mother_name = self._("Unknown")
father_handle = family.get_father_handle()
if father_handle:
father = self._db.get_person_from_handle(father_handle)
father_name = self._name_display.display(father)
if not father_name:
father_name = self._("Unknown")
else:
father_name = self._("Unknown")
return mother_name, father_name
def __write_children(self, family):
"""
List the children for the given family.
:param family: Family
:return:
"""
if not family.get_child_ref_list():
return
mother_name, father_name = self.__get_mate_names(family)
self.doc.start_paragraph("DDR-ChildTitle")
self.doc.write_text(
self._("Children of %(mother_name)s and %(father_name)s"
) % {'father_name' : father_name,
'mother_name' : mother_name})
self.doc.end_paragraph()
cnt = 1
for child_ref in family.get_child_ref_list():
child_handle = child_ref.ref
child = self._db.get_person_from_handle(child_handle)
child_name = self._name_display.display(child)
if not child_name:
child_name = self._("Unknown")
child_mark = utils.get_person_mark(self._db, child)
if self.childref and self.prev_gen_handles.get(child_handle):
value = str(self.prev_gen_handles.get(child_handle))
child_name += " [%s]" % value
if self.inc_ssign:
prefix = " "
for family_handle in child.get_family_handle_list():
family = self._db.get_family_from_handle(family_handle)
if family.get_child_ref_list():
prefix = "+ "
break
else:
prefix = ""
if child_handle in self.dnumber:
self.doc.start_paragraph("DDR-ChildList",
prefix
+ str(self.dnumber[child_handle])
+ " "
+ utils.roman(cnt).lower()
+ ".")
else:
self.doc.start_paragraph("DDR-ChildList",
prefix
+ utils.roman(cnt).lower()
+ ".")
cnt += 1
self.doc.write_text("%s. " % child_name, child_mark)
if self.want_ids:
self.doc.write_text('(%s) ' % child.get_gramps_id())
self.__narrator.set_subject(child)
self.doc.write_text_citation(
self.__narrator.get_born_string() or
self.__narrator.get_christened_string() or
self.__narrator.get_baptised_string())
self.doc.write_text_citation(
self.__narrator.get_died_string() or
self.__narrator.get_buried_string())
# if the list_children_spouses option is selected:
if self.list_children_spouses:
# get the family of the child that contains the spouse
# of the child. There may be more than one spouse for each
# child
family_handle_list = child.get_family_handle_list()
# for the first spouse, this is true.
# For subsequent spouses, make it false
is_first_family = True
for family_handle in family_handle_list:
child_family = self.database.get_family_from_handle(
family_handle
)
self.doc.write_text_citation(
self.__narrator.get_married_string(
child_family, is_first_family, self._name_display
)
)
is_first_family = False
self.doc.end_paragraph()
def __write_family_notes(self, family):
"""
Write the notes for the given family.
"""
notelist = family.get_note_list()
if len(notelist) > 0:
mother_name, father_name = self.__get_mate_names(family)
self.doc.start_paragraph("DDR-NoteHeader")
self.doc.write_text(
self._('Notes for %(mother_name)s and %(father_name)s:'
) % {'mother_name' : mother_name,
'father_name' : father_name})
self.doc.end_paragraph()
for notehandle in notelist:
note = self._db.get_note_from_handle(notehandle)
self.doc.write_styled_note(note.get_styledtext(),
note.get_format(), "DDR-Entry")
def __write_family_events(self, family):
"""
List the events for the given family.
"""
if not family.get_event_ref_list():
return
mother_name, father_name = self.__get_mate_names(family)
first = True
for event_ref in family.get_event_ref_list():
if first:
self.doc.start_paragraph('DDR-MoreHeader')
self.doc.write_text(
self._('More about %(mother_name)s and %(father_name)s:'
) % {'mother_name' : mother_name,
'father_name' : father_name})
self.doc.end_paragraph()
first = False
self.write_event(event_ref)
return first
def __write_family_attrs(self, family, first):
"""
List the attributes for the given family.
"""
attrs = family.get_attribute_list()
if first and attrs:
mother_name, father_name = self.__get_mate_names(family)
self.doc.start_paragraph('DDR-MoreHeader')
self.doc.write_text(
self._('More about %(mother_name)s and %(father_name)s:'
) % {'mother_name' : mother_name,
'father_name' : father_name})
self.doc.end_paragraph()
for attr in attrs:
self.doc.start_paragraph('DDR-MoreDetails')
attr_name = self._get_type(attr.get_type())
text = self._("%(type)s: %(value)s%(endnotes)s"
) % {'type' : self._(attr_name),
'value' : attr.get_value(),
'endnotes' : self.endnotes(attr)}
self.doc.write_text_citation(text)
self.doc.end_paragraph()
if self.inc_notes:
# if the attr or attr reference has a note attached to it,
# get the text and format it correctly
notelist = attr.get_note_list()
for notehandle in notelist:
note = self._db.get_note_from_handle(notehandle)
self.doc.write_styled_note(note.get_styledtext(),
note.get_format(),
"DDR-MoreDetails")
def write_person_info(self, person):
""" write out all the person's information """
name = self._name_display.display(person)
if not name:
name = self._("Unknown")
self.__narrator.set_subject(person)
plist = person.get_media_list()
if self.addimages and len(plist) > 0:
photo = plist[0]
utils.insert_image(self._db, self.doc, photo, self._user)
self.doc.start_paragraph("DDR-Entry")
if not self.verbose:
self.__write_parents(person)
text = self.__narrator.get_born_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_baptised_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_christened_string()
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_died_string(self.calcageflag)
if text:
self.doc.write_text_citation(text)
text = self.__narrator.get_buried_string()
if text:
self.doc.write_text_citation(text)
if self.verbose:
self.__write_parents(person)
self.write_marriage(person)
self.doc.end_paragraph()
notelist = person.get_note_list()
if len(notelist) > 0 and self.inc_notes:
self.doc.start_paragraph("DDR-NoteHeader")
# feature request 2356: avoid genitive form
self.doc.write_text(self._("Notes for %s") % name)
self.doc.end_paragraph()
for notehandle in notelist:
note = self._db.get_note_from_handle(notehandle)
self.doc.write_styled_note(
note.get_styledtext(), note.get_format(), "DDR-Entry",
contains_html=(note.get_type() == NoteType.HTML_CODE))
first = True
if self.inc_names:
for alt_name in person.get_alternate_names():
if first:
self.doc.start_paragraph('DDR-MoreHeader')
self.doc.write_text(self._('More about %(person_name)s:'
) % {'person_name' : name})
self.doc.end_paragraph()
first = False
self.doc.start_paragraph('DDR-MoreDetails')
atype = self._get_type(alt_name.get_type())
aname = alt_name.get_regular_name()
self.doc.write_text_citation(
self._('%(type)s: %(value)s%(endnotes)s'
) % {'type' : self._(atype),
'value' : aname,
'endnotes' : self.endnotes(alt_name)})
self.doc.end_paragraph()
if self.inc_events:
for event_ref in person.get_primary_event_ref_list():
if first:
self.doc.start_paragraph('DDR-MoreHeader')
self.doc.write_text(self._('More about %(person_name)s:'
) % {'person_name' : name})
self.doc.end_paragraph()
first = 0
self.write_event(event_ref)
if self.inc_addr:
for addr in person.get_address_list():
if first:
self.doc.start_paragraph('DDR-MoreHeader')
self.doc.write_text(self._('More about %(person_name)s:'
) % {'person_name' : name})
self.doc.end_paragraph()
first = False
self.doc.start_paragraph('DDR-MoreDetails')
text = utils.get_address_str(addr)
if self.fulldate:
date = self._get_date(addr.get_date_object())
else:
date = addr.get_date_object().get_year()
self.doc.write_text(self._('Address: '))
if date:
# translators: needed for Arabic, ignore otherwise
self.doc.write_text(self._('%s, ') % date)
self.doc.write_text(text)
self.doc.write_text_citation(self.endnotes(addr))
self.doc.end_paragraph()
if self.inc_attrs:
attrs = person.get_attribute_list()
if first and attrs:
self.doc.start_paragraph('DDR-MoreHeader')
self.doc.write_text(
self._('More about %(person_name)s:'
) % {'person_name' : name})
self.doc.end_paragraph()
first = False
for attr in attrs:
self.doc.start_paragraph('DDR-MoreDetails')
attr_name = attr.get_type().type2base()
# translators: needed for French, ignore otherwise
text = self._("%(type)s: %(value)s%(endnotes)s"
) % {'type' : self._(attr_name),
'value' : attr.get_value(),
'endnotes' : self.endnotes(attr)}
self.doc.write_text_citation(text)
self.doc.end_paragraph()
def endnotes(self, obj):
""" write out any endnotes/footnotes """
if not obj or not self.inc_sources:
return ""
txt = endnotes.cite_source(self.bibli, self._db, obj, self._locale)
if txt:
txt = '<super>' + txt + '</super>'
return txt
class EndOfLineReport(Report):
""" EndOfLine Report """
def __init__(self, database, options, user):
"""
Create the EndOfLineReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
# eol_map is a map whose:
# keys are the generations of the people
# values are a map whose:
# keys are person handles
# values are an array whose:
# elements are an array of ancestor person handles that link
# the eol person handle to the person or interest
# eol_map[generation][person_handle][pedigree_idx][ancestor_handle_idx]
#
# There is an array of pedigrees because one person could show up twice
# in one generation (descendants marrying). Most people only have one
# pedigree.
#
# eol_map is populated by get_eol() which calls itself recursively.
self.eol_map = {}
self.get_eol(self.center_person, 1, [])
def get_eol(self, person, gen, pedigree):
"""
Recursively find the end of the line for each person
"""
person_handle = person.get_handle()
new_pedigree = list(pedigree) + [person_handle]
person_is_eol = False
families = person.get_parent_family_handle_list()
if person_handle in pedigree:
# This is a severe error!
# It indicates a loop in ancestry: A -> B -> A
person_is_eol = True
elif not families:
person_is_eol = True
else:
for family_handle in families:
family = self.database.get_family_from_handle(family_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
if father_handle:
father = self.database.get_person_from_handle(father_handle)
self.get_eol(father, gen+1, new_pedigree)
if mother_handle:
mother = self.database.get_person_from_handle(mother_handle)
self.get_eol(mother, gen+1, new_pedigree)
if not father_handle or not mother_handle:
person_is_eol = True
if person_is_eol:
# This person is the end of a line
if gen not in self.eol_map:
self.eol_map[gen] = {}
if person_handle not in self.eol_map[gen]:
self.eol_map[gen][person_handle] = []
self.eol_map[gen][person_handle].append(new_pedigree)
def write_report(self):
"""
The routine that actually creates the report.
At this point, the document is opened and ready for writing.
"""
pname = self._name_display.display(self.center_person)
self.doc.start_paragraph("EOL-Title")
# feature request 2356: avoid genitive form
title = self._("End of Line Report for %s") % pname
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
self.doc.start_paragraph("EOL-Subtitle")
# feature request 2356: avoid genitive form
title = self._("All the ancestors of %s who are missing a parent"
) % pname
self.doc.write_text(title)
self.doc.end_paragraph()
self.doc.start_table('EolTable', 'EOL-Table')
for generation, handles in sorted(self.eol_map.items()):
self.write_generation_row(generation)
for person_handle, pedigrees in handles.items():
self.write_person_row(person_handle)
list(map(self.write_pedigree_row, pedigrees))
self.doc.end_table()
def write_generation_row(self, generation):
"""
Write out a row in the table showing the generation.
"""
self.doc.start_row()
self.doc.start_cell('EOL_GenerationCell', 2)
self.doc.start_paragraph('EOL-Generation')
self.doc.write_text(self._("Generation %d") % generation)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def write_person_row(self, person_handle):
"""
Write a row in the table with information about the given person.
"""
person = self.database.get_person_from_handle(person_handle)
name = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
birth_date = ""
birth_ref = person.get_birth_ref()
if birth_ref:
event = self.database.get_event_from_handle(birth_ref.ref)
birth_date = self._get_date(event.get_date_object())
death_date = ""
death_ref = person.get_death_ref()
if death_ref:
event = self.database.get_event_from_handle(death_ref.ref)
death_date = self._get_date(event.get_date_object())
dates = ''
if birth_date or death_date:
dates = " (%(birth_date)s - %(death_date)s)" % {
'birth_date' : birth_date,
'death_date' : death_date}
self.doc.start_row()
self.doc.start_cell('EOL-TableCell', 2)
self.doc.start_paragraph('EOL-Normal')
self.doc.write_text(name, mark)
self.doc.write_text(dates)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def write_pedigree_row(self, pedigree):
"""
Write a row in the table with with the person's family line.
pedigree is an array containing the names of the people in the pedigree
"""
names = []
for person_handle in pedigree:
person = self.database.get_person_from_handle(person_handle)
names.append(self._name_display.display(person))
text = " -- ".join(names)
self.doc.start_row()
self.doc.start_cell('EOL-TableCell')
self.doc.end_cell()
self.doc.start_cell('EOL-TableCell')
self.doc.start_paragraph('EOL-Pedigree')
self.doc.write_text(text)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
class KinshipReport(Report):
""" Kinship Report """
def __init__(self, database, options, user):
"""
Create the KinshipReport object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
maxdescend - Maximum generations of descendants to include.
maxascend - Maximum generations of ancestors to include.
incspouses - Whether to include spouses.
inccousins - Whether to include cousins.
incaunts - Whether to include aunts/uncles/nephews/nieces.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
self.__db = self.database
self.max_descend = menu.get_option_by_name('maxdescend').get_value()
self.max_ascend = menu.get_option_by_name('maxascend').get_value()
self.inc_spouses = menu.get_option_by_name('incspouses').get_value()
self.inc_cousins = menu.get_option_by_name('inccousins').get_value()
self.inc_aunts = menu.get_option_by_name('incaunts').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.person = self.database.get_person_from_gramps_id(pid)
if self.person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self.rel_calc = get_relationship_calculator(reinit=True,
clocale=rlocale)
self.kinship_map = {}
self.spouse_map = {}
def write_report(self):
"""
The routine the actually creates the report. At this point, the document
is opened and ready for writing.
"""
pname = self._name_display.display(self.person)
self.doc.start_paragraph("KIN-Title")
# feature request 2356: avoid genitive form
title = self._("Kinship Report for %s") % pname
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
if self.inc_spouses:
spouse_handles = self.get_spouse_handles(self.person.get_handle())
if spouse_handles:
self.write_people(self._("Spouses"), spouse_handles)
# Collect all descendants of the person
self.traverse_down(self.person.get_handle(), 0, 1)
# Collect all ancestors/aunts/uncles/nephews/cousins of the person
self.traverse_up(self.person.get_handle(), 1, 0)
# Write Kin
for Ga, Gbs in self.kinship_map.items():
for Gb in Gbs:
# To understand these calculations, see:
# http://en.wikipedia.org/wiki/Cousin#Mathematical_definitions
_x_ = min(Ga, Gb)
_y_ = abs(Ga - Gb)
# Skip unrequested people
if _x_ == 1 and _y_ > 0 and not self.inc_aunts:
continue
elif _x_ > 1 and not self.inc_cousins:
continue
get_rel_str = self.rel_calc.get_plural_relationship_string
title = get_rel_str(Ga, Gb, in_law_b=False)
self.write_people(self._(title), self.kinship_map[Ga][Gb])
if (self.inc_spouses and
Ga in self.spouse_map and
Gb in self.spouse_map[Ga]):
title = get_rel_str(Ga, Gb, in_law_b=True)
self.write_people(self._(title), self.spouse_map[Ga][Gb])
def traverse_down(self, person_handle, Ga, Gb, skip_handle=None):
"""
Populate a map of arrays containing person handles for the descendants
of the passed person. This function calls itself recursively until it
reaches max_descend.
Parameters:
person_handle: the handle of the person to go to next
Ga: The number of generations from the main person to the common
ancestor. This should be incremented when going up generations, and
left alone when going down generations.
Gb: The number of generations from this person (person_handle) to the
common ancestor. This should be incremented when going down
generations and set back to zero when going up generations.
skip_handle: an optional handle to skip when going down. This is useful
to skip the descendant that brought you this generation in the first
place.
"""
for child_handle in self.get_children_handles(person_handle):
if child_handle != skip_handle:
self.add_kin(child_handle, Ga, Gb)
if self.inc_spouses:
for spouse_handle in self.get_spouse_handles(child_handle):
self.add_spouse(spouse_handle, Ga, Gb)
if Gb < self.max_descend:
self.traverse_down(child_handle, Ga, Gb+1)
def traverse_up(self, person_handle, Ga, Gb):
"""
Populate a map of arrays containing person handles for the ancestors
of the passed person. This function calls itself recursively until it
reaches max_ascend.
Parameters:
person_handle: the handle of the person to go to next
Ga: The number of generations from the main person to the common
ancestor. This should be incremented when going up generations, and
left alone when going down generations.
Gb: The number of generations from this person (person_handle) to the
common ancestor. This should be incremented when going down
generations and set back to zero when going up generations.
"""
parent_handles = self.get_parent_handles(person_handle)
for parent_handle in parent_handles:
self.add_kin(parent_handle, Ga, Gb)
self.traverse_down(parent_handle, Ga, Gb+1, person_handle)
if Ga < self.max_ascend:
self.traverse_up(parent_handle, Ga+1, 0)
def add_kin(self, person_handle, Ga, Gb):
"""
Add a person handle to the kin map.
"""
if Ga not in self.kinship_map:
self.kinship_map[Ga] = {}
if Gb not in self.kinship_map[Ga]:
self.kinship_map[Ga][Gb] = []
if person_handle not in self.kinship_map[Ga][Gb]:
self.kinship_map[Ga][Gb].append(person_handle)
def add_spouse(self, spouse_handle, Ga, Gb):
"""
Add a person handle to the spouse map.
"""
if Ga not in self.spouse_map:
self.spouse_map[Ga] = {}
if Gb not in self.spouse_map[Ga]:
self.spouse_map[Ga][Gb] = []
if spouse_handle not in self.spouse_map[Ga][Gb]:
self.spouse_map[Ga][Gb].append(spouse_handle)
def get_parent_handles(self, person_handle):
"""
Return an array of handles for all the parents of the
given person handle.
"""
parent_handles = []
person = self.__db.get_person_from_handle(person_handle)
family_handle = person.get_main_parents_family_handle()
if family_handle:
family = self.__db.get_family_from_handle(family_handle)
father_handle = family.get_father_handle()
if father_handle:
parent_handles.append(father_handle)
mother_handle = family.get_mother_handle()
if mother_handle:
parent_handles.append(mother_handle)
return parent_handles
def get_spouse_handles(self, person_handle):
"""
Return an array of handles for all the spouses of the
given person handle.
"""
spouses = []
person = self.__db.get_person_from_handle(person_handle)
for family_handle in person.get_family_handle_list():
family = self.__db.get_family_from_handle(family_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
spouse_handle = None
if mother_handle and father_handle == person_handle:
spouse_handle = mother_handle
elif father_handle and mother_handle == person_handle:
spouse_handle = father_handle
if spouse_handle and spouse_handle not in spouses:
spouses.append(spouse_handle)
return spouses
def get_children_handles(self, person_handle):
"""
Return an array of handles for all the children of the
given person handle.
"""
children = []
person = self.__db.get_person_from_handle(person_handle)
for family_handle in person.get_family_handle_list():
family = self.__db.get_family_from_handle(family_handle)
for child_ref in family.get_child_ref_list():
children.append(child_ref.get_reference_handle())
return children
def write_people(self, title, people_handles):
"""
Write information about a group of people - including the title.
"""
cap_title = title[0].upper() + title[1:]
subtitle = "%s (%d)" % (cap_title, len(people_handles))
self.doc.start_paragraph("KIN-Subtitle")
mark = IndexMark(cap_title, INDEX_TYPE_TOC, 2)
self.doc.write_text(subtitle, mark)
self.doc.end_paragraph()
list(map(self.write_person, people_handles))
def write_person(self, person_handle):
"""
Write information about the given person.
"""
person = self.database.get_person_from_handle(person_handle)
name = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
birth_date = ""
birth = get_birth_or_fallback(self.database, person)
if birth:
birth_date = self._get_date(birth.get_date_object())
death_date = ""
death = get_death_or_fallback(self.database, person)
if death:
death_date = self._get_date(death.get_date_object())
dates = ''
if birth_date or death_date:
dates = self._(" (%(birth_date)s - %(death_date)s)"
) % {'birth_date' : birth_date,
'death_date' : death_date}
self.doc.start_paragraph('KIN-Normal')
self.doc.write_text(name, mark)
self.doc.write_text(dates)
self.doc.end_paragraph()
def __init__(self, database, options, user):
"""
Create the PlaceReport object produces the Place report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - instance of a gen.user.User class
This report needs the following parameters (class variables)
that come in the options class.
places - List of places to report on.
center - Center of report, person or event
incl_private - Whether to include private data
name_format - Preferred format to display names
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self._user = user
menu = options.menu
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu,
self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self._lv = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == self._lv:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)"
) % {'option_name': living_desc}
places = menu.get_option_by_name('places').get_value()
self.center = menu.get_option_by_name('center').get_value()
stdoptions.run_name_format_option(self, menu)
self._nd = self._name_display
self.place_format = menu.get_option_by_name("place_format").get_value()
filter_option = menu.get_option_by_name('filter')
self.filter = filter_option.get_filter()
self.sort = Sort(self._db)
self.place_handles = []
if self.filter.get_name() != '':
# Use the selected filter to provide a list of place handles
plist = self._db.iter_place_handles()
self.place_handles = self.filter.apply(self._db, plist,
user=self._user)
if places:
# Add places selected individually
self.place_handles += self.__get_place_handles(places)
if not self.place_handles:
raise ReportError(
_('Place Report'),
_('Please select at least one place before running this.'))
self.place_handles.sort(key=self.sort.by_place_title_key)
class FamilyGroup(Report):
""" Family Group Report """
def __init__(self, database, options, user):
"""
Create the FamilyGroup object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the families of the database.
The option class carries its number, and the function
returning the list of filters.
incattrs - Whether to include attributes
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self._user = user
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
self._locale = self.set_locale(lang)
self._ = self._locale.translation.sgettext # needed for English
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.db = self.database
self.filter = menu.get_option_by_name('filter').get_filter()
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.gramps_ids = get_value('gramps_ids')
self.recursive = get_value('recursive')
self.missing_info = get_value('missinginfo')
self.generations = get_value('generations')
self.inc_fam_notes = get_value('incFamNotes')
self.inc_par_events = get_value('incParEvents')
self.inc_par_addr = get_value('incParAddr')
self.inc_par_notes = get_value('incParNotes')
self.inc_par_names = get_value('incParNames')
self.inc_par_mar = get_value('incParMar')
self.inc_rel_dates = get_value('incRelDates')
self.inc_chi_mar = get_value('incChiMar')
self.include_attrs = get_value('incattrs')
stdoptions.run_name_format_option(self, menu)
def dump_parent_event(self, name, event):
place = ""
date = ""
descr = ""
if event:
date = self._get_date(event.get_date_object())
place = _pd.display_event(self.db, event)
if place is None:
place = ''
descr = event.get_description()
if self.include_attrs:
for attr in event.get_attribute_list():
if descr:
# translators: needed for Arabic, ignore otherwise
descr += self._("; ")
attr_type = self._get_type(attr.get_type())
# translators: needed for French, ignore otherwise
descr += self._("%(str1)s: %(str2)s") % {
'str1': self._(attr_type),
'str2': attr.get_value()
}
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
if descr:
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(descr)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
if date or place:
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.end_paragraph()
self.doc.end_cell()
if (date or place) or not descr:
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(place)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def dump_parent_parents(self, person):
family_handle = person.get_main_parents_family_handle()
father_name = ""
mother_name = ""
if family_handle:
family = self.db.get_family_from_handle(family_handle)
father_handle = family.get_father_handle()
if father_handle:
father = self.db.get_person_from_handle(father_handle)
father_name = self._name_display.display(father)
if self.gramps_ids:
gid = father.get_gramps_id()
if gid:
father_name += " (%s)" % gid
if self.inc_rel_dates:
birth_ref = father.get_birth_ref()
birth = " "
if birth_ref:
event = self.db.get_event_from_handle(birth_ref.ref)
birth = self._get_date(event.get_date_object())
death_ref = father.get_death_ref()
death = " "
if death_ref:
event = self.db.get_event_from_handle(death_ref.ref)
death = self._get_date(event.get_date_object())
if birth_ref or death_ref:
father_name += " (%s - %s)" % (birth, death)
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self.db.get_person_from_handle(mother_handle)
mother_name = self._name_display.display(mother)
if self.gramps_ids:
gid = mother.get_gramps_id()
if gid:
mother_name += " (%s)" % gid
if self.inc_rel_dates:
birth_ref = mother.get_birth_ref()
birth = " "
if birth_ref:
event = self.db.get_event_from_handle(birth_ref.ref)
birth = self._get_date(event.get_date_object())
death_ref = mother.get_death_ref()
death = " "
if death_ref:
event = self.db.get_event_from_handle(death_ref.ref)
death = self._get_date(event.get_date_object())
if birth_ref or death_ref:
mother_name += " (%s - %s)" % (birth, death)
if father_name != "":
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(self._("Father"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.start_paragraph('FGR-Normal')
mark = utils.get_person_mark(self.db, father)
self.doc.write_text(father_name, mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
elif self.missing_info:
self.dump_parent_line(self._("Father"), "")
if mother_name != "":
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(self._("Mother"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.start_paragraph('FGR-Normal')
mark = utils.get_person_mark(self.db, mother)
self.doc.write_text(mother_name, mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
elif self.missing_info:
self.dump_parent_line(self._("Mother"), "")
def dump_parent_line(self, name, text):
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(text)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def dump_parent_noteline(self, name, note):
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.write_styled_note(
note.get_styledtext(),
note.get_format(),
'FGR-Note',
contains_html=(note.get_type() == NoteType.HTML_CODE))
self.doc.end_cell()
self.doc.end_row()
def dump_parent(self, title, person_handle):
if not person_handle and not self.missing_info:
return
elif not person_handle:
person = Person()
else:
person = self.db.get_person_from_handle(person_handle)
name = self._name_display.display(person)
self.doc.start_table(title, 'FGR-ParentTable')
self.doc.start_row()
self.doc.start_cell('FGR-ParentHead', 3)
self.doc.start_paragraph('FGR-ParentName')
mark = utils.get_person_mark(self.db, person)
# translators: needed for French, ignore otherwise
self.doc.write_text(
self._("%(str1)s: %(str2)s") % {
'str1': title,
'str2': name
}, mark)
if self.gramps_ids:
gid = person.get_gramps_id()
if gid:
self.doc.write_text(" (%s)" % gid)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
birth_ref = person.get_birth_ref()
birth = None
ev_name = self._("Birth")
if birth_ref:
birth = self.db.get_event_from_handle(birth_ref.ref)
if birth or self.missing_info:
self.dump_parent_event(ev_name, birth)
death_ref = person.get_death_ref()
death = None
ev_name = self._("Death")
if death_ref:
death = self.db.get_event_from_handle(death_ref.ref)
if death or self.missing_info:
self.dump_parent_event(ev_name, death)
self.dump_parent_parents(person)
if self.inc_par_events:
for event_ref in person.get_primary_event_ref_list():
if event_ref != birth_ref and event_ref != death_ref:
event = self.db.get_event_from_handle(event_ref.ref)
event_type = self._get_type(event.get_type())
self.dump_parent_event(self._(event_type), event)
if self.inc_par_addr:
addrlist = person.get_address_list()[:]
for addr in addrlist:
location = utils.get_address_str(addr)
date = self._get_date(addr.get_date_object())
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(self._("Address"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(location)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
if self.inc_par_notes:
for notehandle in person.get_note_list():
note = self.db.get_note_from_handle(notehandle)
self.dump_parent_noteline(self._("Note"), note)
if self.include_attrs:
for attr in person.get_attribute_list():
attr_type = self._get_type(attr.get_type())
self.dump_parent_line(self._(attr_type), attr.get_value())
if self.inc_par_names:
for alt_name in person.get_alternate_names():
name_type = self._get_type(alt_name.get_type())
name = self._name_display.display_name(alt_name)
self.dump_parent_line(self._(name_type), name)
self.doc.end_table()
def dump_marriage(self, family):
if not family:
return
mrg = None
family_list = family.get_event_ref_list()
for event_ref in family_list:
if event_ref:
event = self.db.get_event_from_handle(event_ref.ref)
if (event.get_type() == EventType.MARRIAGE and
(event_ref.get_role() == EventRoleType.FAMILY
or event_ref.get_role() == EventRoleType.PRIMARY)):
mrg = event
break
if len(family_list) > 0 or self.missing_info or self.include_attrs:
self.doc.start_table("MarriageInfo", 'FGR-ParentTable')
self.doc.start_row()
self.doc.start_cell('FGR-ParentHead', 3)
self.doc.start_paragraph('FGR-ParentName')
header = self._("Marriage")
if self.gramps_ids:
header += " (%s)" % family.get_gramps_id()
# translators: needed for French, ignore otherwise
self.doc.write_text(self._("%s:") % header)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.dump_parent_event(self._("Marriage"), mrg)
for event_ref in family_list:
if event_ref:
event = self.db.get_event_from_handle(event_ref.ref)
if event.get_type() != EventType.MARRIAGE:
event_type = self._get_type(event.get_type())
self.dump_parent_event(self._(event_type), event)
if self.include_attrs:
for attr in family.get_attribute_list():
attr_type = self._get_type(attr.get_type())
self.dump_parent_line(self._(attr_type), attr.get_value())
if self.inc_fam_notes:
for notehandle in family.get_note_list():
note = self.database.get_note_from_handle(notehandle)
self.dump_parent_noteline(self._("Note"), note)
self.doc.end_table()
def dump_child_event(self, text, name, event):
date = ""
place = ""
if event:
date = self._get_date(event.get_date_object())
place_handle = event.get_place_handle()
if place_handle:
place = _pd.display_event(self.db, event)
if place is None:
place = ''
self.doc.start_row()
self.doc.start_cell(text)
self.doc.start_paragraph('FGR-Normal')
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContents')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContents')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContentsEnd')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(place)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def dump_child(self, index, person_handle):
person = self.db.get_person_from_handle(person_handle)
families = len(person.get_family_handle_list())
birth_ref = person.get_birth_ref()
if birth_ref:
birth = self.db.get_event_from_handle(birth_ref.ref)
else:
birth = None
death_ref = person.get_death_ref()
if death_ref:
death = self.db.get_event_from_handle(death_ref.ref)
else:
death = None
spouse_count = 0
if self.inc_chi_mar:
for family_handle in person.get_family_handle_list():
family = self.db.get_family_from_handle(family_handle)
spouse_id = None
if person_handle == family.get_father_handle():
spouse_id = family.get_mother_handle()
else:
spouse_id = family.get_father_handle()
if spouse_id:
spouse_count += 1
self.doc.start_row()
if (spouse_count != 0 or self.missing_info or death is not None
or birth is not None):
self.doc.start_cell('FGR-TextChild1')
else:
self.doc.start_cell('FGR-TextChild2')
self.doc.start_paragraph('FGR-ChildText')
index_str = ("%d" % index)
if person.get_gender() == Person.MALE:
self.doc.write_text(index_str + self._("acronym for male|M"))
elif person.get_gender() == Person.FEMALE:
self.doc.write_text(index_str + self._("acronym for female|F"))
else:
self.doc.write_text(self._("acronym for unknown|%dU") % index)
self.doc.end_paragraph()
self.doc.end_cell()
name = self._name_display.display(person)
mark = utils.get_person_mark(self.db, person)
self.doc.start_cell('FGR-ChildName', 3)
self.doc.start_paragraph('FGR-ChildText')
self.doc.write_text(name, mark)
if self.gramps_ids:
self.doc.write_text(" (%s)" % person.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
if self.missing_info or birth is not None:
if spouse_count != 0 or self.missing_info or death is not None:
self.dump_child_event('FGR-TextChild1', self._('Birth'), birth)
else:
self.dump_child_event('FGR-TextChild2', self._('Birth'), birth)
if self.missing_info or death is not None:
if spouse_count == 0 or not self.inc_chi_mar:
self.dump_child_event('FGR-TextChild2', self._('Death'), death)
else:
self.dump_child_event('FGR-TextChild1', self._('Death'), death)
if self.inc_chi_mar:
index = 0
for family_handle in person.get_family_handle_list():
mrg = None
index += 1
family = self.db.get_family_from_handle(family_handle)
for event_ref in family.get_event_ref_list():
if event_ref:
event = self.db.get_event_from_handle(event_ref.ref)
if event.type == EventType.MARRIAGE:
mrg = event
break
spouse_id = None
if person_handle == family.get_father_handle():
spouse_id = family.get_mother_handle()
else:
spouse_id = family.get_father_handle()
if spouse_id:
self.doc.start_row()
if mrg or index != families:
self.doc.start_cell('FGR-TextChild1')
else:
self.doc.start_cell('FGR-TextChild2')
self.doc.start_paragraph('FGR-Normal')
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContents')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(self._("Spouse"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContentsEnd', 2)
self.doc.start_paragraph('FGR-Normal')
spouse = self.db.get_person_from_handle(spouse_id)
spouse_name = self._name_display.display(spouse)
if self.gramps_ids:
gid = spouse.get_gramps_id()
if gid:
spouse_name += " (%s)" % gid
if self.inc_rel_dates:
birth = " "
birth_ref = spouse.get_birth_ref()
if birth_ref:
event = self.db.get_event_from_handle(
birth_ref.ref)
birth = self._get_date(event.get_date_object())
death = " "
death_ref = spouse.get_death_ref()
if death_ref:
event = self.db.get_event_from_handle(
death_ref.ref)
death = self._get_date(event.get_date_object())
if birth_ref or death_ref:
spouse_name += " (%s - %s)" % (birth, death)
if self.gramps_ids:
fid = family.get_gramps_id()
if fid:
spouse_name += " (%s)" % fid
mark = utils.get_person_mark(self.db, spouse)
self.doc.write_text(spouse_name, mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
if mrg:
ev_name = self._("Marriage")
if index == families:
self.dump_child_event('FGR-TextChild2', ev_name, mrg)
else:
self.dump_child_event('FGR-TextChild1', ev_name, mrg)
def dump_family(self, family_handle, generation):
self.doc.start_paragraph('FGR-Title')
if self.recursive and self.generations:
title = self._("Family Group Report - Generation %d") % generation
else:
title = self._("Family Group Report")
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
family = self.db.get_family_from_handle(family_handle)
self.dump_parent(self._("Husband"), family.get_father_handle())
self.doc.start_paragraph("FGR-blank")
self.doc.end_paragraph()
if self.inc_par_mar:
self.dump_marriage(family)
self.doc.start_paragraph("FGR-blank")
self.doc.end_paragraph()
self.dump_parent(self._("Wife"), family.get_mother_handle())
length = len(family.get_child_ref_list())
if length > 0:
self.doc.start_paragraph("FGR-blank")
self.doc.end_paragraph()
self.doc.start_table('FGR-Children', 'FGR-ChildTable')
self.doc.start_row()
self.doc.start_cell('FGR-ParentHead', 4)
self.doc.start_paragraph('FGR-ParentName')
self.doc.write_text(self._("Children"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
index = 1
for child_ref in family.get_child_ref_list():
self.dump_child(index, child_ref.ref)
index += 1
self.doc.end_table()
if self.recursive:
for child_ref in family.get_child_ref_list():
child = self.db.get_person_from_handle(child_ref.ref)
for child_family_handle in child.get_family_handle_list():
if child_family_handle != family_handle:
self.doc.page_break()
self.dump_family(child_family_handle, (generation + 1))
def write_report(self):
flist = self.db.get_family_handles(sort_handles=True)
if not self.filter:
fam_list = flist
else:
with self._user.progress(_('Family Group Report'),
_('Applying filter...'),
self.db.get_number_of_families()) as step:
fam_list = self.filter.apply(self.db, flist, step)
if fam_list:
with self._user.progress(_('Family Group Report'),
_('Writing families'),
len(fam_list)) as step:
for family_handle in fam_list:
self.dump_family(family_handle, 1)
self.doc.page_break()
step()
else:
self.doc.start_paragraph('FGR-Title')
self.doc.write_text(self._("Family Group Report"))
self.doc.end_paragraph()
def __init__(self, database, options, user):
"""
Create FamilyLinesReport object that eventually produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the FamilyLinesOptions class for this report
user - a gen.user.User() instance
name_format - Preferred format to display names
incl_private - Whether to include private data
inc_id - Whether to include IDs.
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
# initialize several convenient variables
self._people = set() # handle of people we need in the report
self._families = set() # handle of families we need in the report
self._deleted_people = 0
self._deleted_families = 0
self._user = user
self._followpar = get_value('followpar')
self._followchild = get_value('followchild')
self._removeextra = get_value('removeextra')
self._gidlist = get_value('gidlist')
self._colormales = get_value('colormales')
self._colorfemales = get_value('colorfemales')
self._colorunknown = get_value('colorunknown')
self._colorfamilies = get_value('colorfamilies')
self._limitparents = get_value('limitparents')
self._maxparents = get_value('maxparents')
self._limitchildren = get_value('limitchildren')
self._maxchildren = get_value('maxchildren')
self._incimages = get_value('incimages')
self._imageonside = get_value('imageonside')
self._imagesize = get_value('imagesize')
self._useroundedcorners = get_value('useroundedcorners')
self._usesubgraphs = get_value('usesubgraphs')
self._incdates = get_value('incdates')
self._just_years = get_value('justyears')
self._incplaces = get_value('incplaces')
self._incchildcount = get_value('incchildcnt')
self.includeid = get_value('inc_id')
arrow_str = get_value('arrow')
if 'd' in arrow_str:
self._arrowheadstyle = 'normal'
else:
self._arrowheadstyle = 'none'
if 'a' in arrow_str:
self._arrowtailstyle = 'normal'
else:
self._arrowtailstyle = 'none'
# the gidlist is annoying for us to use since we always have to convert
# the GIDs to either Person or to handles, so we may as well convert the
# entire list right now and not have to deal with it ever again
self._interest_set = set()
if not self._gidlist:
raise ReportError(_('Empty report'),
_('You did not specify anybody'))
for gid in self._gidlist.split():
person = self._db.get_person_from_gramps_id(gid)
if person:
#option can be from another family tree, so person can be None
self._interest_set.add(person.get_handle())
stdoptions.run_name_format_option(self, menu)
# convert the 'surnamecolors' string to a dictionary of names and colors
self._surnamecolors = {}
tmp = get_value('surnamecolors')
if tmp.find('\xb0') >= 0:
# new style delimiter (see bug report #2162)
tmp = tmp.split('\xb0')
else:
# old style delimiter
tmp = tmp.split(' ')
while len(tmp) > 1:
surname = tmp.pop(0).encode('iso-8859-1', 'xmlcharrefreplace')
colour = tmp.pop(0)
self._surnamecolors[surname] = colour
self._colorize = get_value('color')
class TimeLine(Report):
""" TimeLine Report """
def __init__(self, database, options, user):
"""
Create the Timeline object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - instance of gen.user.User()
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the people of the database.
The option class carries its number, and the function
returning the list of filters.
sortby - Sorting method to be used.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self._user = user
menu = options.menu
lang = options.menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
self.filter = menu.get_option_by_name('filter').get_filter()
self.fil_name = "(%s)" % self.filter.get_name(rlocale)
living_value = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == living_value:
living_desc = self._(description)
break
self.living_desc = self._(
"(Living people: %(option_name)s)") % {'option_name': living_desc}
stdoptions.run_name_format_option(self, menu)
sort_func_num = menu.get_option_by_name('sortby').get_value()
sort_functions = _get_sort_functions(Sort(self.database))
self.sort_name = self._(sort_functions[sort_func_num][0])
self.sort_func = sort_functions[sort_func_num][1]
self.calendar = config.get('preferences.calendar-format-report')
self.plist = []
self.header = 2.6
def write_report(self):
# Apply the filter
with self._user.progress(_('Timeline'),
_('Applying filter...'),
self.database.get_number_of_people()) as step:
self.plist = self.filter.apply(self.database,
self.database.iter_person_handles(),
step)
# Find the range of dates to include
(low, high) = self.find_year_range()
# Generate the actual timeline
self.generate_timeline(low, high)
def generate_timeline(self, low, high):
""" generate the timeline """
st_size = self.name_size()
style_sheet = self.doc.get_style_sheet()
font = style_sheet.get_paragraph_style('TLG-Name').get_font()
incr = utils.pt2cm(font.get_size())
pad = incr * 0.75
_x1, _x2, _y1, _y2 = (0, 0, 0, 0)
start = st_size + 0.5
stop = self.doc.get_usable_width() - 0.5
size = stop - start
self.header = 2.6
# Sort the people as requested
with self._user.progress(_('Timeline'),
_('Sorting dates...'), 0) as step:
self.plist.sort(key=self.sort_func)
self.doc.start_page()
self.build_grid(low, high, start, stop, True)
index = 1
current = 1
length = len(self.plist)
with self._user.progress(_('Timeline'), _('Calculating timeline...'),
length) as step:
for p_id in self.plist:
person = self.database.get_person_from_handle(p_id)
birth = get_birth_or_fallback(self.database, person)
if birth:
bth = birth.get_date_object()
bth = bth.to_calendar(self.calendar).get_year()
else:
bth = None
death = get_death_or_fallback(self.database, person)
if death:
dth = death.get_date_object()
dth = dth.to_calendar(self.calendar).get_year()
else:
dth = None
dname = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
self.doc.draw_text('TLG-text', dname, incr + pad,
self.header + (incr + pad) * index, mark)
_y1 = self.header + (pad + incr) * index
_y2 = self.header + ((pad + incr) * index) + incr
_y3 = (_y1 + _y2) / 2.0
w05 = 0.05
if bth:
start_offset = ((float(bth - low) / float(high - low)) *
size)
_x1 = start + start_offset
path = [(_x1, _y1), (_x1 + w05, _y3),
(_x1, _y2), (_x1 - w05, _y3)]
self.doc.draw_path('TLG-line', path)
if dth:
start_offset = ((float(dth - low) / float(high - low)) *
size)
_x1 = start + start_offset
path = [(_x1, _y1), (_x1 + w05, _y3),
(_x1, _y2), (_x1 - w05, _y3)]
self.doc.draw_path('TLG-solid', path)
if bth and dth:
start_offset = ((float(bth - low) / float(high - low)) *
size) + w05
stop_offset = ((float(dth - low) / float(high - low)) *
size) - w05
_x1 = start + start_offset
_x2 = start + stop_offset
self.doc.draw_line('open', _x1, _y3, _x2, _y3)
if (_y2 + incr) >= self.doc.get_usable_height():
if current != length:
self.doc.end_page()
self.doc.start_page()
self.build_grid(low, high, start, stop)
index = 1
_x1, _x2, _y1, _y2 = (0, 0, 0, 0)
else:
index += 1
current += 1
step()
self.doc.end_page()
def build_grid(self, year_low, year_high, start_pos, stop_pos, toc=False):
"""
Draws the grid outline for the chart. Sets the document label,
draws the vertical lines, and adds the year labels. Arguments
are:
year_low - lowest year on the chart
year_high - highest year on the chart
start_pos - x position of the lowest leftmost grid line
stop_pos - x position of the rightmost grid line
"""
self.draw_title(toc)
self.draw_columns(start_pos, stop_pos)
if year_high is not None and year_low is not None:
self.draw_year_headings(year_low, year_high, start_pos, stop_pos)
else:
self.draw_no_date_heading()
def draw_columns(self, start_pos, stop_pos):
"""
Draws the columns out of vertical lines.
start_pos - x position of the lowest leftmost grid line
stop_pos - x position of the rightmost grid line
"""
top_y = self.header
bottom_y = self.doc.get_usable_height()
delta = (stop_pos - start_pos) / 5
for val in range(0, 6):
xpos = start_pos + (val * delta)
self.doc.draw_line('TLG-grid', xpos, top_y, xpos, bottom_y)
def draw_title(self, toc):
"""
Draws the title for the page.
"""
width = self.doc.get_usable_width()
title = "%(str1)s -- %(str2)s" % {
'str1' : self._("Timeline Chart"),
# feature request 2356: avoid genitive form
'str2' : self._("Sorted by %s") % self.sort_name}
title3 = self.living_desc
mark = None
if toc:
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.center_text('TLG-title', title, width / 2.0, 0, mark)
style_sheet = self.doc.get_style_sheet()
title_font = style_sheet.get_paragraph_style('TLG-Title').get_font()
title_y = 1.2 - (utils.pt2cm(title_font.get_size()) * 1.2)
self.doc.center_text('TLG-title', self.fil_name, width / 2.0, title_y)
title_y = 1.8 - (utils.pt2cm(title_font.get_size()) * 1.2)
self.doc.center_text('TLG-title', title3, width / 2.0, title_y)
def draw_year_headings(self, year_low, year_high, start_pos, stop_pos):
"""
Draws the column headings (years) for the page.
"""
style_sheet = self.doc.get_style_sheet()
label_font = style_sheet.get_paragraph_style('TLG-Label').get_font()
label_y = self.header - (utils.pt2cm(label_font.get_size()) * 1.2)
incr = (year_high - year_low) / 5
delta = (stop_pos - start_pos) / 5
for val in range(0, 6):
xpos = start_pos + (val * delta)
year_str = str(int(year_low + (incr * val)))
self.doc.center_text('TLG-label', year_str, xpos, label_y)
def draw_no_date_heading(self):
"""
Draws a single heading that says "No Date Information"
"""
width = self.doc.get_usable_width()
style_sheet = self.doc.get_style_sheet()
label_font = style_sheet.get_paragraph_style('TLG-Label').get_font()
label_y = self.header - (utils.pt2cm(label_font.get_size()) * 1.2)
self.doc.center_text('TLG-label', self._("No Date Information"),
width / 2.0, label_y)
def find_year_range(self):
"""
Finds the range of years that will be displayed on the chart.
Returns a tuple of low and high years. If no dates are found, the
function returns (None, None).
"""
low = None
high = None
def min_max_year(low, high, year):
""" convenience function """
if year is not None and year != 0:
if low is not None:
low = min(low, year)
else:
low = year
if high is not None:
high = max(high, year)
else:
high = year
return (low, high)
with self._user.progress(_('Timeline'),
_('Finding date range...'),
len(self.plist)) as step:
for p_id in self.plist:
person = self.database.get_person_from_handle(p_id)
birth = get_birth_or_fallback(self.database, person)
if birth:
bth = birth.get_date_object()
bth = bth.to_calendar(self.calendar).get_year()
(low, high) = min_max_year(low, high, bth)
death = get_death_or_fallback(self.database, person)
if death:
dth = death.get_date_object()
dth = dth.to_calendar(self.calendar).get_year()
(low, high) = min_max_year(low, high, dth)
step()
# round the dates to the nearest decade
if low is not None:
low = int((low / 10)) * 10
else:
low = high
if high is not None:
high = int(((high + 9) / 10)) * 10
else:
high = low
# Make sure the difference is a multiple of 50 so
# all year ranges land on a decade.
if low is not None and high is not None:
low -= 50 - ((high - low) % 50)
return (low, high)
def name_size(self):
""" get the length of the name """
self.plist = self.filter.apply(self.database,
self.database.iter_person_handles())
style_sheet = self.doc.get_style_sheet()
gstyle = style_sheet.get_draw_style('TLG-text')
pname = gstyle.get_paragraph_style()
pstyle = style_sheet.get_paragraph_style(pname)
font = pstyle.get_font()
size = 0
for p_id in self.plist:
person = self.database.get_person_from_handle(p_id)
dname = self._name_display.display(person)
size = max(self.doc.string_width(font, dname), size)
return utils.pt2cm(size)
def __init__(self, database, options, user):
"""
Create RelGraphReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the people of the database.
The option class carries its number, and the function
returning the list of filters.
arrow - Arrow styles for heads and tails.
showfamily - Whether to show family nodes.
inc_id - Whether to include IDs.
url - Whether to include URLs.
inclimg - Include images or not
imgpos - Image position, above/beside name
color - Whether to use outline, colored outline or filled color
in graph
color_males - Colour to apply to males
color_females - Colour to apply to females
color_unknown - Colour to apply to unknown genders
color_families - Colour to apply to families
dashed - Whether to use dashed lines for non-birth relationships
use_roundedcorners - Whether to use rounded corners for females
name_format - Preferred format to display names
incl_private - Whether to include private data
event_choice - Whether to include dates and/or places
occupation - Whether to include occupations
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
get_option_by_name = options.menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
self.set_locale(menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, menu)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._db = self.database
self.includeid = get_value('inc_id')
self.includeurl = get_value('url')
self.includeimg = get_value('includeImages')
self.imgpos = get_value('imageOnTheSide')
self.use_roundedcorners = get_value('useroundedcorners')
self.adoptionsdashed = get_value('dashed')
self.show_families = get_value('showfamily')
self.use_subgraphs = get_value('usesubgraphs')
self.event_choice = get_value('event_choice')
self.occupation = get_value('occupation')
self.use_html_output = False
self.colorize = get_value('color')
color_males = get_value('colormales')
color_females = get_value('colorfemales')
color_unknown = get_value('colorunknown')
color_families = get_value('colorfamilies')
self.colors = {
'male': color_males,
'female': color_females,
'unknown': color_unknown,
'family': color_families
}
arrow_str = get_value('arrow')
if 'd' in arrow_str:
self.arrowheadstyle = 'normal'
else:
self.arrowheadstyle = 'none'
if 'a' in arrow_str:
self.arrowtailstyle = 'normal'
else:
self.arrowtailstyle = 'none'
filter_option = get_option_by_name('filter')
self._filter = filter_option.get_filter()
stdoptions.run_name_format_option(self, menu)
pid = get_value('pid')
self.center_person = self._db.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.increlname = get_value('increlname')
if self.increlname:
self.rel_calc = get_relationship_calculator(reinit=True,
clocale=self._locale)
if __debug__:
self.advrelinfo = get_value('advrelinfo')
else:
self.advrelinfo = False
class TimeLine(Report):
""" TimeLine Report """
def __init__(self, database, options, user):
"""
Create the Timeline object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - instance of gen.user.User()
This report needs the following parameters (class variables)
that come in the options class.
filter - Filter to be applied to the people of the database.
The option class carries its number, and the function
returning the list of filters.
sortby - Sorting method to be used.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
self._user = user
menu = options.menu
self.set_locale(options.menu.get_option_by_name('trans').get_value())
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(
self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.filter = menu.get_option_by_name('filter').get_filter()
self.fil_name = "(%s)" % self.filter.get_name(self._locale)
living_value = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == living_value:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)") % {
'option_name': living_desc
}
stdoptions.run_name_format_option(self, menu)
sort_func_num = menu.get_option_by_name('sortby').get_value()
sort_functions = _get_sort_functions(Sort(self.database))
self.sort_name = self._(sort_functions[sort_func_num][0])
self.sort_func = sort_functions[sort_func_num][1]
self.calendar = config.get('preferences.calendar-format-report')
self.plist = []
self.header = 2.6
def write_report(self):
# Apply the filter
self.plist = self.filter.apply(self.database,
self.database.iter_person_handles(),
user=self._user)
# Find the range of dates to include
(low, high) = self.find_year_range()
# Generate the actual timeline
self.generate_timeline(low, high)
def generate_timeline(self, low, high):
""" generate the timeline """
st_size = self.name_size()
style_sheet = self.doc.get_style_sheet()
font = style_sheet.get_paragraph_style('TLG-Name').get_font()
incr = utils.pt2cm(font.get_size())
pad = incr * 0.75
_x1, _x2, _y1, _y2 = (0, 0, 0, 0)
start = st_size + 0.5
stop = self.doc.get_usable_width() - 0.5
size = stop - start
self.header = 2.6
# Sort the people as requested
with self._user.progress(_('Timeline'), _('Sorting dates...'),
0) as step:
self.plist.sort(key=self.sort_func)
self.doc.start_page()
self.build_grid(low, high, start, stop, True)
index = 1
current = 1
length = len(self.plist)
with self._user.progress(_('Timeline'), _('Calculating timeline...'),
length) as step:
for p_id in self.plist:
person = self.database.get_person_from_handle(p_id)
birth = get_birth_or_fallback(self.database, person)
if birth:
bth = birth.get_date_object()
bth = bth.to_calendar(self.calendar).get_year()
else:
bth = None
death = get_death_or_fallback(self.database, person)
if death:
dth = death.get_date_object()
dth = dth.to_calendar(self.calendar).get_year()
else:
dth = None
dname = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
self.doc.draw_text('TLG-text', dname, incr + pad,
self.header + (incr + pad) * index, mark)
_y1 = self.header + (pad + incr) * index
_y2 = self.header + ((pad + incr) * index) + incr
_y3 = (_y1 + _y2) / 2.0
w05 = 0.05
if bth:
start_offset = ((float(bth - low) / float(high - low)) *
size)
_x1 = start + start_offset
path = [(_x1, _y1), (_x1 + w05, _y3), (_x1, _y2),
(_x1 - w05, _y3)]
self.doc.draw_path('TLG-line', path)
if dth:
start_offset = ((float(dth - low) / float(high - low)) *
size)
_x1 = start + start_offset
path = [(_x1, _y1), (_x1 + w05, _y3), (_x1, _y2),
(_x1 - w05, _y3)]
self.doc.draw_path('TLG-solid', path)
if bth and dth:
start_offset = (
(float(bth - low) / float(high - low)) * size) + w05
stop_offset = (
(float(dth - low) / float(high - low)) * size) - w05
_x1 = start + start_offset
_x2 = start + stop_offset
self.doc.draw_line('open', _x1, _y3, _x2, _y3)
if (_y2 + incr) >= self.doc.get_usable_height():
if current != length:
self.doc.end_page()
self.doc.start_page()
self.build_grid(low, high, start, stop)
index = 1
_x1, _x2, _y1, _y2 = (0, 0, 0, 0)
else:
index += 1
current += 1
step()
self.doc.end_page()
def build_grid(self, year_low, year_high, start_pos, stop_pos, toc=False):
"""
Draws the grid outline for the chart. Sets the document label,
draws the vertical lines, and adds the year labels. Arguments
are:
year_low - lowest year on the chart
year_high - highest year on the chart
start_pos - x position of the lowest leftmost grid line
stop_pos - x position of the rightmost grid line
"""
self.draw_title(toc)
self.draw_columns(start_pos, stop_pos)
if year_high is not None and year_low is not None:
self.draw_year_headings(year_low, year_high, start_pos, stop_pos)
else:
self.draw_no_date_heading()
def draw_columns(self, start_pos, stop_pos):
"""
Draws the columns out of vertical lines.
start_pos - x position of the lowest leftmost grid line
stop_pos - x position of the rightmost grid line
"""
top_y = self.header
bottom_y = self.doc.get_usable_height()
delta = (stop_pos - start_pos) / 5
for val in range(0, 6):
xpos = start_pos + (val * delta)
self.doc.draw_line('TLG-grid', xpos, top_y, xpos, bottom_y)
def draw_title(self, toc):
"""
Draws the title for the page.
"""
width = self.doc.get_usable_width()
title = "%(str1)s -- %(str2)s" % {
'str1': self._("Timeline Chart"),
# feature request 2356: avoid genitive form
'str2': self._("Sorted by %s") % self.sort_name
}
title3 = self.living_desc
mark = None
if toc:
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.center_text('TLG-title', title, width / 2.0, 0, mark)
style_sheet = self.doc.get_style_sheet()
title_font = style_sheet.get_paragraph_style('TLG-Title').get_font()
title_y = 1.2 - (utils.pt2cm(title_font.get_size()) * 1.2)
self.doc.center_text('TLG-title', self.fil_name, width / 2.0, title_y)
title_y = 1.8 - (utils.pt2cm(title_font.get_size()) * 1.2)
self.doc.center_text('TLG-title', title3, width / 2.0, title_y)
def draw_year_headings(self, year_low, year_high, start_pos, stop_pos):
"""
Draws the column headings (years) for the page.
"""
style_sheet = self.doc.get_style_sheet()
label_font = style_sheet.get_paragraph_style('TLG-Label').get_font()
label_y = self.header - (utils.pt2cm(label_font.get_size()) * 1.2)
incr = (year_high - year_low) / 5
delta = (stop_pos - start_pos) / 5
for val in range(0, 6):
xpos = start_pos + (val * delta)
year_str = self._get_date(Date(year_low + int(incr * val)))
self.doc.center_text('TLG-label', year_str, xpos, label_y)
def draw_no_date_heading(self):
"""
Draws a single heading that says "No Date Information"
"""
width = self.doc.get_usable_width()
style_sheet = self.doc.get_style_sheet()
label_font = style_sheet.get_paragraph_style('TLG-Label').get_font()
label_y = self.header - (utils.pt2cm(label_font.get_size()) * 1.2)
self.doc.center_text('TLG-label', self._("No Date Information"),
width / 2.0, label_y)
def find_year_range(self):
"""
Finds the range of years that will be displayed on the chart.
Returns a tuple of low and high years. If no dates are found, the
function returns (None, None).
"""
low = None
high = None
def min_max_year(low, high, year):
""" convenience function """
if year is not None and year != 0:
if low is not None:
low = min(low, year)
else:
low = year
if high is not None:
high = max(high, year)
else:
high = year
return (low, high)
with self._user.progress(_('Timeline'), _('Finding date range...'),
len(self.plist)) as step:
for p_id in self.plist:
person = self.database.get_person_from_handle(p_id)
birth = get_birth_or_fallback(self.database, person)
if birth:
bth = birth.get_date_object()
bth = bth.to_calendar(self.calendar).get_year()
(low, high) = min_max_year(low, high, bth)
death = get_death_or_fallback(self.database, person)
if death:
dth = death.get_date_object()
dth = dth.to_calendar(self.calendar).get_year()
(low, high) = min_max_year(low, high, dth)
step()
# round the dates to the nearest decade
if low is not None:
low = int((low / 10)) * 10
else:
low = high
if high is not None:
high = int(((high + 9) / 10)) * 10
else:
high = low
# Make sure the difference is a multiple of 50 so
# all year ranges land on a decade.
if low is not None and high is not None:
low -= 50 - ((high - low) % 50)
return (low, high)
def name_size(self):
""" get the length of the name """
self.plist = self.filter.apply(self.database,
self.database.iter_person_handles(),
user=self._user)
style_sheet = self.doc.get_style_sheet()
gstyle = style_sheet.get_draw_style('TLG-text')
pname = gstyle.get_paragraph_style()
pstyle = style_sheet.get_paragraph_style(pname)
font = pstyle.get_font()
size = 0
for p_id in self.plist:
person = self.database.get_person_from_handle(p_id)
dname = self._name_display.display(person)
size = max(self.doc.string_width(font, dname), size)
return utils.pt2cm(size)
def __init__(self, database, options, user):
"""
Create the Statistics object that produces the report.
Uses the Extractor class to extract the data from the database.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self._user = user
lang = menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
# override default gettext, or English output will have "person|Title"
self._ = rlocale.translation.sgettext
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
filter_opt = get_option_by_name('filter')
self.filter = filter_opt.get_filter()
self.fil_name = "(%s)" % self.filter.get_name(rlocale)
self.bar_items = get_value('bar_items')
year_from = get_value('year_from')
year_to = get_value('year_to')
gender = get_value('gender')
living_value = get_value('living_people')
for (value, description) in living_opt.get_items(xml_items=True):
if value == living_value:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)"
) % {'option_name' : living_desc}
# title needs both data extraction method name + gender name
if gender == Person.MALE:
genders = self._("Men")
elif gender == Person.FEMALE:
genders = self._("Women")
else:
genders = None
# needed for keyword based localization
mapping = {
'genders': genders,
'year_from': year_from,
'year_to': year_to
}
if genders:
span_string = self._("%(genders)s born "
"%(year_from)04d-%(year_to)04d"
) % mapping
else:
span_string = self._("Persons born "
"%(year_from)04d-%(year_to)04d"
) % mapping
people = self.filter.apply(self.database,
self.database.iter_person_handles(),
user=self._user)
# extract requested items from the database and count them
self._user.begin_progress(_('Statistics Charts'),
_('Collecting data...'),
self.database.get_number_of_people())
tables = _Extract.collect_data(self.database, people, menu,
gender, year_from, year_to,
get_value('no_years'),
self._user.step_progress,
rlocale)
self._user.end_progress()
self._user.begin_progress(_('Statistics Charts'),
_('Sorting data...'), len(tables))
self.data = []
sortby = get_value('sortby')
reverse = get_value('reverse')
for table in tables:
# generate sorted item lookup index index
lookup = self.index_items(table[1], sortby, reverse)
# document heading
heading = "%(str1)s -- %(str2)s" % {'str1' : self._(table[0]),
'str2' : span_string}
self.data.append((heading, table[0], table[1], lookup))
self._user.step_progress()
self._user.end_progress()
class RecordsReport(Report):
""" Records Report """
def __init__(self, database, options, user):
"""
This report needs the following parameters (class variables)
that come in the options class.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = options.menu.get_option_by_name('trans').get_value()
self._locale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu,
self._locale)
self.database = CacheProxyDb(self.database)
self._lv = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == self._lv:
living_desc = self._(description)
break
self.living_desc = self._(
"(Living people: %(option_name)s)") % {'option_name': living_desc}
filter_option = menu.get_option_by_name('filter')
self.filter = filter_option.get_filter()
self.top_size = menu.get_option_by_name('top_size').get_value()
self.callname = menu.get_option_by_name('callname').get_value()
self.footer = menu.get_option_by_name('footer').get_value()
self.include = {}
for (text, varname, default) in RECORDS:
self.include[varname] = menu.get_option_by_name(varname).get_value()
self._nf = stdoptions.run_name_format_option(self, menu)
def write_report(self):
"""
Build the actual report.
"""
records = find_records(self.database, self.filter,
self.top_size, self.callname,
trans_text=self._, name_format=self._nf,
living_mode=self._lv)
self.doc.start_paragraph('REC-Title')
title = self._("Records")
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
self.doc.start_paragraph('REC-Subtitle')
filter_name = self.filter.get_name(self._locale)
self.doc.write_text("(%s)" % filter_name)
self.doc.end_paragraph()
if self._lv != LivingProxyDb.MODE_INCLUDE_ALL:
self.doc.start_paragraph('REC-Subtitle')
self.doc.write_text(self.living_desc)
self.doc.end_paragraph()
for (text, varname, top) in records:
if not self.include[varname]:
continue
self.doc.start_paragraph('REC-Heading')
self.doc.write_text(self._(text))
self.doc.end_paragraph()
last_value = None
rank = 0
for (number,
(sort, value, name, handletype, handle)) in enumerate(top):
mark = None
if handletype == 'Person':
person = self.database.get_person_from_handle(handle)
mark = utils.get_person_mark(self.database, person)
elif handletype == 'Family':
family = self.database.get_family_from_handle(handle)
# librecords.py checks that the family has both
# a father and a mother and also that each one is
# in the filter if any filter was used, so we don't
# have to do any similar checking here, it's been done
f_handle = family.get_father_handle()
dad = self.database.get_person_from_handle(f_handle)
f_mark = utils.get_person_mark(self.database, dad)
m_handle = family.get_mother_handle()
mom = self.database.get_person_from_handle(m_handle)
m_mark = utils.get_person_mark(self.database, mom)
else:
raise ReportError(_(
"Option '%(opt_name)s' is present "
"in %(file)s\n but is not known to "
"the module. Ignoring...")
% {'opt_name': handletype,
'file': 'libnarrate.py'})
# since the error is very unlikely I reused the string
if value != last_value:
last_value = value
rank = number
self.doc.start_paragraph('REC-Normal')
self.doc.write_text(
self._("%(number)s. ") % {'number': rank+1})
self.doc.write_markup(str(name), name.get_tags(), mark)
if handletype == 'Family':
self.doc.write_text('', f_mark)
self.doc.write_text('', m_mark)
if isinstance(value, Span):
tvalue = value.get_repr(dlocale=self._locale)
else:
tvalue = value
self.doc.write_text(" (%s)" % tvalue)
self.doc.end_paragraph()
self.doc.start_paragraph('REC-Footer')
self.doc.write_text(self.footer)
self.doc.end_paragraph()
class StatisticsChart(Report):
""" StatisticsChart report """
def __init__(self, database, options, user):
"""
Create the Statistics object that produces the report.
Uses the Extractor class to extract the data from the database.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self._user = user
self.set_locale(menu.get_option_by_name('trans').get_value())
# override default gettext, or English output will have "person|Title"
self._ = self._locale.translation.sgettext
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(self, menu,
self._locale)
self.database = CacheProxyDb(self.database)
get_option_by_name = menu.get_option_by_name
get_value = lambda name: get_option_by_name(name).get_value()
filter_opt = get_option_by_name('filter')
self.filter = filter_opt.get_filter()
self.fil_name = "(%s)" % self.filter.get_name(self._locale)
self.bar_items = get_value('bar_items')
year_from = get_value('year_from')
year_to = get_value('year_to')
gender = get_value('gender')
living_value = get_value('living_people')
for (value, description) in living_opt.get_items(xml_items=True):
if value == living_value:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)"
) % {'option_name' : living_desc}
# title needs both data extraction method name + gender name
if gender == Person.MALE:
genders = self._("Men")
elif gender == Person.FEMALE:
genders = self._("Women")
else:
genders = None
# needed for keyword based localization
mapping = {
'genders': genders,
'year_from': year_from,
'year_to': year_to
}
if genders:
span_string = self._("%(genders)s born "
"%(year_from)04d-%(year_to)04d"
) % mapping
else:
span_string = self._("Persons born "
"%(year_from)04d-%(year_to)04d"
) % mapping
people = self.filter.apply(self.database,
self.database.iter_person_handles(),
user=self._user)
# extract requested items from the database and count them
self._user.begin_progress(_('Statistics Charts'),
_('Collecting data...'),
self.database.get_number_of_people())
tables = _Extract.collect_data(self.database, people, menu,
gender, year_from, year_to,
get_value('no_years'),
self._user.step_progress,
self._locale)
self._user.end_progress()
self._user.begin_progress(_('Statistics Charts'),
_('Sorting data...'), len(tables))
self.data = []
sortby = get_value('sortby')
reverse = get_value('reverse')
for table in tables:
# generate sorted item lookup index index
lookup = self.index_items(table[1], sortby, reverse)
# document heading
heading = "%(str1)s -- %(str2)s" % {'str1' : self._(table[0]),
'str2' : span_string}
self.data.append((heading, table[0], table[1], lookup))
self._user.step_progress()
self._user.end_progress()
def index_items(self, data, sort, reverse):
"""creates & stores a sorted index for the items"""
# sort by item keys
index = sorted(data, reverse=True if reverse else False)
if sort == _options.SORT_VALUE:
# set for the sorting function
self.lookup_items = data
# then sort by value
index.sort(key=lambda x: self.lookup_items[x],
reverse=True if reverse else False)
return index
def write_report(self):
"output the selected statistics..."
mark = IndexMark(self._('Statistics Charts'), INDEX_TYPE_TOC, 1)
self._user.begin_progress(_('Statistics Charts'),
_('Saving charts...'), len(self.data))
for data in sorted(self.data):
self.doc.start_page()
if mark:
self.doc.draw_text('SC-title', '', 0, 0, mark) # put it in TOC
mark = None # crock, but we only want one of them
if len(data[3]) < self.bar_items:
self.output_piechart(*data[:4])
else:
self.output_barchart(*data[:4])
self.doc.end_page()
self._user.step_progress()
self._user.end_progress()
def output_piechart(self, title1, typename, data, lookup):
# set layout variables
middle_w = self.doc.get_usable_width() / 2
middle_h = self.doc.get_usable_height() / 2
middle = min(middle_w, middle_h)
# start output
style_sheet = self.doc.get_style_sheet()
pstyle = style_sheet.get_paragraph_style('SC-Title')
mark = IndexMark(title1, INDEX_TYPE_TOC, 2)
self.doc.center_text('SC-title', title1, middle_w, 0, mark)
yoffset = utils.pt2cm(pstyle.get_font().get_size())
self.doc.center_text('SC-title', self.fil_name, middle_w, yoffset)
yoffset = 2 * utils.pt2cm(pstyle.get_font().get_size())
self.doc.center_text('SC-title', self.living_desc, middle_w, yoffset)
# collect data for output
color = 0
chart_data = []
for key in lookup:
style = "SC-color-%d" % color
text = "%s (%d)" % (self._(key), data[key])
# graphics style, value, and it's label
chart_data.append((style, data[key], text))
color = (color+1) % 7 # There are only 7 color styles defined
margin = 1.0
legendx = 2.0
# output data...
radius = middle - 2*margin
yoffset += margin + radius
draw_pie_chart(self.doc, middle_w, yoffset, radius, chart_data, -90)
yoffset += radius + 2*margin
if middle == middle_h: # Landscape
legendx = 1.0
yoffset = margin
text = self._("%s (persons):") % self._(typename)
draw_legend(self.doc, legendx, yoffset, chart_data, text, 'SC-legend')
def output_barchart(self, title1, typename, data, lookup):
pt2cm = utils.pt2cm
style_sheet = self.doc.get_style_sheet()
pstyle = style_sheet.get_paragraph_style('SC-Text')
font = pstyle.get_font()
# set layout variables
width = self.doc.get_usable_width()
row_h = pt2cm(font.get_size())
max_y = self.doc.get_usable_height() - row_h
pad = row_h * 0.5
# check maximum value
max_value = max(data[k] for k in lookup) if lookup else 0
# horizontal area for the gfx bars
margin = 1.0
middle = width/2.0
textx = middle + margin/2.0
stopx = middle - margin/2.0
maxsize = stopx - margin
# start output
pstyle = style_sheet.get_paragraph_style('SC-Title')
mark = IndexMark(title1, INDEX_TYPE_TOC, 2)
self.doc.center_text('SC-title', title1, middle, 0, mark)
yoffset = pt2cm(pstyle.get_font().get_size())
self.doc.center_text('SC-title', self.fil_name, middle, yoffset)
yoffset = 2 * pt2cm(pstyle.get_font().get_size())
self.doc.center_text('SC-title', self.living_desc, middle, yoffset)
yoffset = 3 * pt2cm(pstyle.get_font().get_size())
# header
yoffset += (row_h + pad)
text = self._("%s (persons):") % self._(typename)
self.doc.draw_text('SC-text', text, textx, yoffset)
for key in lookup:
yoffset += (row_h + pad)
if yoffset > max_y:
# for graphical report, page_break() doesn't seem to work
self.doc.end_page()
self.doc.start_page()
yoffset = 0
# right align bar to the text
value = data[key]
startx = stopx - (maxsize * value / max_value)
self.doc.draw_box('SC-bar', "",
startx, yoffset, stopx-startx, row_h)
# text after bar
text = "%s (%d)" % (self._(key), data[key])
self.doc.draw_text('SC-text', text, textx, yoffset)
return
class KinshipReport(Report):
""" Kinship Report """
def __init__(self, database, options, user):
"""
Create the KinshipReport object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
maxdescend - Maximum generations of descendants to include.
maxascend - Maximum generations of ancestors to include.
incspouses - Whether to include spouses.
inccousins - Whether to include cousins.
incaunts - Whether to include aunts/uncles/nephews/nieces.
pid - The Gramps ID of the center person for the report.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
self.__db = self.database
self.max_descend = menu.get_option_by_name('maxdescend').get_value()
self.max_ascend = menu.get_option_by_name('maxascend').get_value()
self.inc_spouses = menu.get_option_by_name('incspouses').get_value()
self.inc_cousins = menu.get_option_by_name('inccousins').get_value()
self.inc_aunts = menu.get_option_by_name('incaunts').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.person = self.database.get_person_from_gramps_id(pid)
if self.person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
self.rel_calc = get_relationship_calculator(reinit=True,
clocale=rlocale)
self.kinship_map = {}
self.spouse_map = {}
def write_report(self):
"""
The routine the actually creates the report. At this point, the document
is opened and ready for writing.
"""
pname = self._name_display.display(self.person)
self.doc.start_paragraph("KIN-Title")
# feature request 2356: avoid genitive form
title = self._("Kinship Report for %s") % pname
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
if self.inc_spouses:
spouse_handles = self.get_spouse_handles(self.person.get_handle())
if spouse_handles:
self.write_people(self._("Spouses"), spouse_handles)
# Collect all descendants of the person
self.traverse_down(self.person.get_handle(), 0, 1)
# Collect all ancestors/aunts/uncles/nephews/cousins of the person
self.traverse_up(self.person.get_handle(), 1, 0)
# Write Kin
for Ga, Gbs in self.kinship_map.items():
for Gb in Gbs:
# To understand these calculations, see:
# http://en.wikipedia.org/wiki/Cousin#Mathematical_definitions
_x_ = min(Ga, Gb)
_y_ = abs(Ga - Gb)
# Skip unrequested people
if _x_ == 1 and _y_ > 0 and not self.inc_aunts:
continue
elif _x_ > 1 and not self.inc_cousins:
continue
get_rel_str = self.rel_calc.get_plural_relationship_string
title = get_rel_str(Ga, Gb, in_law_b=False)
self.write_people(self._(title), self.kinship_map[Ga][Gb])
if (self.inc_spouses and Ga in self.spouse_map
and Gb in self.spouse_map[Ga]):
title = get_rel_str(Ga, Gb, in_law_b=True)
self.write_people(self._(title), self.spouse_map[Ga][Gb])
def traverse_down(self, person_handle, Ga, Gb, skip_handle=None):
"""
Populate a map of arrays containing person handles for the descendants
of the passed person. This function calls itself recursively until it
reaches max_descend.
Parameters:
person_handle: the handle of the person to go to next
Ga: The number of generations from the main person to the common
ancestor. This should be incremented when going up generations, and
left alone when going down generations.
Gb: The number of generations from this person (person_handle) to the
common ancestor. This should be incremented when going down
generations and set back to zero when going up generations.
skip_handle: an optional handle to skip when going down. This is useful
to skip the descendant that brought you this generation in the first
place.
"""
for child_handle in self.get_children_handles(person_handle):
if child_handle != skip_handle:
self.add_kin(child_handle, Ga, Gb)
if self.inc_spouses:
for spouse_handle in self.get_spouse_handles(child_handle):
self.add_spouse(spouse_handle, Ga, Gb)
if Gb < self.max_descend:
self.traverse_down(child_handle, Ga, Gb + 1)
def traverse_up(self, person_handle, Ga, Gb):
"""
Populate a map of arrays containing person handles for the ancestors
of the passed person. This function calls itself recursively until it
reaches max_ascend.
Parameters:
person_handle: the handle of the person to go to next
Ga: The number of generations from the main person to the common
ancestor. This should be incremented when going up generations, and
left alone when going down generations.
Gb: The number of generations from this person (person_handle) to the
common ancestor. This should be incremented when going down
generations and set back to zero when going up generations.
"""
parent_handles = self.get_parent_handles(person_handle)
for parent_handle in parent_handles:
self.add_kin(parent_handle, Ga, Gb)
self.traverse_down(parent_handle, Ga, Gb + 1, person_handle)
if Ga < self.max_ascend:
self.traverse_up(parent_handle, Ga + 1, 0)
def add_kin(self, person_handle, Ga, Gb):
"""
Add a person handle to the kin map.
"""
if Ga not in self.kinship_map:
self.kinship_map[Ga] = {}
if Gb not in self.kinship_map[Ga]:
self.kinship_map[Ga][Gb] = []
if person_handle not in self.kinship_map[Ga][Gb]:
self.kinship_map[Ga][Gb].append(person_handle)
def add_spouse(self, spouse_handle, Ga, Gb):
"""
Add a person handle to the spouse map.
"""
if Ga not in self.spouse_map:
self.spouse_map[Ga] = {}
if Gb not in self.spouse_map[Ga]:
self.spouse_map[Ga][Gb] = []
if spouse_handle not in self.spouse_map[Ga][Gb]:
self.spouse_map[Ga][Gb].append(spouse_handle)
def get_parent_handles(self, person_handle):
"""
Return an array of handles for all the parents of the
given person handle.
"""
parent_handles = []
person = self.__db.get_person_from_handle(person_handle)
family_handle = person.get_main_parents_family_handle()
if family_handle:
family = self.__db.get_family_from_handle(family_handle)
father_handle = family.get_father_handle()
if father_handle:
parent_handles.append(father_handle)
mother_handle = family.get_mother_handle()
if mother_handle:
parent_handles.append(mother_handle)
return parent_handles
def get_spouse_handles(self, person_handle):
"""
Return an array of handles for all the spouses of the
given person handle.
"""
spouses = []
person = self.__db.get_person_from_handle(person_handle)
for family_handle in person.get_family_handle_list():
family = self.__db.get_family_from_handle(family_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
spouse_handle = None
if mother_handle and father_handle == person_handle:
spouse_handle = mother_handle
elif father_handle and mother_handle == person_handle:
spouse_handle = father_handle
if spouse_handle and spouse_handle not in spouses:
spouses.append(spouse_handle)
return spouses
def get_children_handles(self, person_handle):
"""
Return an array of handles for all the children of the
given person handle.
"""
children = []
person = self.__db.get_person_from_handle(person_handle)
for family_handle in person.get_family_handle_list():
family = self.__db.get_family_from_handle(family_handle)
for child_ref in family.get_child_ref_list():
children.append(child_ref.get_reference_handle())
return children
def write_people(self, title, people_handles):
"""
Write information about a group of people - including the title.
"""
cap_title = title[0].upper() + title[1:]
subtitle = "%s (%d)" % (cap_title, len(people_handles))
self.doc.start_paragraph("KIN-Subtitle")
mark = IndexMark(cap_title, INDEX_TYPE_TOC, 2)
self.doc.write_text(subtitle, mark)
self.doc.end_paragraph()
list(map(self.write_person, people_handles))
def write_person(self, person_handle):
"""
Write information about the given person.
"""
person = self.database.get_person_from_handle(person_handle)
name = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
birth_date = ""
birth = get_birth_or_fallback(self.database, person)
if birth:
birth_date = self._get_date(birth.get_date_object())
death_date = ""
death = get_death_or_fallback(self.database, person)
if death:
death_date = self._get_date(death.get_date_object())
dates = ''
if birth_date or death_date:
dates = " (%(birth_date)s - %(death_date)s)" % {
'birth_date': birth_date,
'death_date': death_date
}
self.doc.start_paragraph('KIN-Normal')
self.doc.write_text(name, mark)
self.doc.write_text(dates)
self.doc.end_paragraph()
class RecordsReport(Report):
""" Records Report """
def __init__(self, database, options, user):
"""
This report needs the following parameters (class variables)
that come in the options class.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(options.menu.get_option_by_name('trans').get_value())
stdoptions.run_private_data_option(self, menu)
living_opt = stdoptions.run_living_people_option(
self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self._lv = menu.get_option_by_name('living_people').get_value()
for (value, description) in living_opt.get_items(xml_items=True):
if value == self._lv:
living_desc = self._(description)
break
self.living_desc = self._("(Living people: %(option_name)s)") % {
'option_name': living_desc
}
filter_option = menu.get_option_by_name('filter')
self.filter = filter_option.get_filter()
self.top_size = menu.get_option_by_name('top_size').get_value()
self.callname = menu.get_option_by_name('callname').get_value()
self.footer = menu.get_option_by_name('footer').get_value()
self.include = {}
for (text, varname, default) in RECORDS:
self.include[varname] = menu.get_option_by_name(
varname).get_value()
self._nf = stdoptions.run_name_format_option(self, menu)
def write_report(self):
"""
Build the actual report.
"""
records = find_records(self.database,
self.filter,
self.top_size,
self.callname,
trans_text=self._,
name_format=self._nf,
living_mode=self._lv,
user=self._user)
self.doc.start_paragraph('REC-Title')
title = self._("Records")
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
self.doc.start_paragraph('REC-Subtitle')
filter_name = self.filter.get_name(self._locale)
self.doc.write_text("(%s)" % filter_name)
self.doc.end_paragraph()
if self._lv != LivingProxyDb.MODE_INCLUDE_ALL:
self.doc.start_paragraph('REC-Subtitle')
self.doc.write_text(self.living_desc)
self.doc.end_paragraph()
for (text, varname, top) in records:
if not self.include[varname]:
continue
self.doc.start_paragraph('REC-Heading')
self.doc.write_text(self._(text))
self.doc.end_paragraph()
last_value = None
rank = 0
for (number, (sort, value, name, handletype,
handle)) in enumerate(top):
mark = None
if handletype == 'Person':
person = self.database.get_person_from_handle(handle)
mark = utils.get_person_mark(self.database, person)
elif handletype == 'Family':
family = self.database.get_family_from_handle(handle)
# librecords.py checks that the family has both
# a father and a mother and also that each one is
# in the filter if any filter was used, so we don't
# have to do any similar checking here, it's been done
f_handle = family.get_father_handle()
dad = self.database.get_person_from_handle(f_handle)
f_mark = utils.get_person_mark(self.database, dad)
m_handle = family.get_mother_handle()
mom = self.database.get_person_from_handle(m_handle)
m_mark = utils.get_person_mark(self.database, mom)
else:
raise ReportError(
_("Option '%(opt_name)s' is present "
"in %(file)s\n but is not known to "
"the module. Ignoring...") % {
'opt_name': handletype,
'file': 'libnarrate.py'
})
# since the error is very unlikely I reused the string
if value != last_value:
last_value = value
rank = number
self.doc.start_paragraph('REC-Normal')
self.doc.write_text(
self._("%(number)s. ") % {'number': rank + 1})
self.doc.write_markup(str(name), name.get_tags(), mark)
if handletype == 'Family':
self.doc.write_text('', f_mark)
self.doc.write_text('', m_mark)
if isinstance(value, Span):
tvalue = value.get_repr(dlocale=self._locale)
else:
tvalue = value
self.doc.write_text(" (%s)" % tvalue)
self.doc.end_paragraph()
self.doc.start_paragraph('REC-Footer')
self.doc.write_text(self.footer)
self.doc.end_paragraph()
class AncestorTree(Report):
""" AncestorTree Report """
def __init__(self, database, options, user):
"""
Create AncestorTree object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
"""
Report.__init__(self, database, options, user)
self.options = options
self._user = user
self.set_locale(options.menu.get_option_by_name('trans').get_value())
stdoptions.run_date_format_option(self, options.menu)
stdoptions.run_private_data_option(self, options.menu)
stdoptions.run_living_people_option(self, options.menu, self._locale)
self.database = CacheProxyDb(self.database)
stdoptions.run_name_format_option(self, options.menu)
self._nd = self._name_display
def begin_report(self):
"""
This report needs the following parameters (class variables)
that come in the options class.
max_generations - Maximum number of generations to include.
pagebbg - Whether to include page breaks between generations.
dispf - Display format for the output box.
scale_report - Whether to scale the report to fit the width or all.
indblank - Whether to include blank pages.
compress - Whether to compress chart.
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
We will
1. a canvas in its full one-page size
2. a page that we wish to print on
scale up/down either or both of the above as needed/desired.
almost all of this should be moved into Canvas!
"""
database = self.database
self.connect = GUIConnect()
self.connect.set__opts(self.options.menu, self._locale, self._nd)
#Set up the canvas that we will print on.
style_sheet = self.doc.get_style_sheet()
font_normal = style_sheet.get_paragraph_style("AC2-Normal").get_font()
#The canvas that we will put our report on and print off of
self.canvas = Canvas(self.doc,
ReportOptions(self.doc, font_normal, 'AC2-line'))
self.canvas.report_opts.box_shadow *= \
self.connect.get_val('shadowscale')
self.canvas.report_opts.box_pgap *= self.connect.get_val('box_Yscale')
self.canvas.report_opts.box_mgap *= self.connect.get_val('box_Yscale')
with self._user.progress(_('Ancestor Tree'),
_('Making the Tree...'), 4) as step:
#make the tree onto the canvas
## inlc_marr = self.connect.get_val("inc_marr")
self.max_generations = self.connect.get_val('maxgen')
tree = MakeAncestorTree(database, self.canvas)
tree.start(self.connect.get_val('pid'))
tree = None
step()
#Title
title = self.connect.title_class(self.doc)
center = self.database.get_person_from_gramps_id(
self.connect.get_val('pid'))
title.calc_title(center)
self.canvas.add_title(title)
#make the report as big as it wants to be.
report = MakeReport(database, self.doc, self.canvas, font_normal)
report.start()
self.max_generations = report.get_generations() #already know
report = None
step()
#Note?
if self.connect.get_val("inc_note"):
note_box = NoteBox(self.doc, "AC2-note-box",
self.connect.get_val("note_place"))
subst = SubstKeywords(self.database, self._locale, self._nd,
None, None)
note_box.text = subst.replace_and_clean(
self.connect.get_val('note_disp'))
self.canvas.add_note(note_box)
#Now we have the report in its full size.
#Do we want to scale the report?
one_page = self.connect.get_val("resize_page")
scale_report = self.connect.get_val("scale_tree")
scale = self.canvas.scale_report(one_page,
scale_report != 0,
scale_report == 2)
step()
if scale != 1 or self.connect.get_val('shadowscale') != 1.0:
self.scale_styles(scale)
def write_report(self):
one_page = self.connect.get_val("resize_page")
#scale_report = self.connect.get_val("scale_tree")
#inlc_marr = self.connect.get_val("inc_marr")
inc_border = self.connect.get_val('inc_border')
incblank = self.connect.get_val("inc_blank")
prnnum = self.connect.get_val("inc_pagenum")
#####################
#Setup page information
colsperpage = self.doc.get_usable_width()
colsperpage += self.canvas.report_opts.col_width
colsperpage = int(colsperpage / (self.canvas.report_opts.max_box_width +
self.canvas.report_opts.col_width))
colsperpage = colsperpage or 1
#####################
#Vars
if prnnum:
page_num_box = PageNumberBox(self.doc, 'AC2-box', self._locale)
#TODO - Here
#####################
#ok, everyone is now ready to print on the canvas. Paginate?
self.canvas.paginate(colsperpage, one_page)
#####################
#Yeah!!!
#lets finally make some pages!!!
#####################
pages = self.canvas.page_count(incblank)
with self._user.progress(_('Ancestor Tree'),
_('Printing the Tree...'), pages) as step:
for page in self.canvas.page_iter_gen(incblank):
self.doc.start_page()
#do we need to print a border?
if inc_border:
page.draw_border('AC2-line')
#Do we need to print the page number?
if prnnum:
page_num_box.display(page)
#Print the individual people and lines
page.display()
step()
self.doc.end_page()
def scale_styles(self, scale):
"""
Scale the styles for this report.
"""
style_sheet = self.doc.get_style_sheet()
graph_style = style_sheet.get_draw_style("AC2-box")
graph_style.set_shadow(graph_style.get_shadow(),
self.canvas.report_opts.box_shadow * scale)
graph_style.set_line_width(graph_style.get_line_width() * scale)
style_sheet.add_draw_style("AC2-box", graph_style)
graph_style = style_sheet.get_draw_style("AC2-fam-box")
graph_style.set_shadow(graph_style.get_shadow(),
self.canvas.report_opts.box_shadow * scale)
graph_style.set_line_width(graph_style.get_line_width() * scale)
style_sheet.add_draw_style("AC2-fam-box", graph_style)
graph_style = style_sheet.get_draw_style("AC2-note-box")
#graph_style.set_shadow(graph_style.get_shadow(),
# self.canvas.report_opts.box_shadow * scale)
graph_style.set_line_width(graph_style.get_line_width() * scale)
style_sheet.add_draw_style("AC2-note-box", graph_style)
para_style = style_sheet.get_paragraph_style("AC2-Normal")
font = para_style.get_font()
font.set_size(font.get_size() * scale)
para_style.set_font(font)
style_sheet.add_paragraph_style("AC2-Normal", para_style)
para_style = style_sheet.get_paragraph_style("AC2-Note")
font = para_style.get_font()
font.set_size(font.get_size() * scale)
para_style.set_font(font)
style_sheet.add_paragraph_style("AC2-Note", para_style)
para_style = style_sheet.get_paragraph_style("AC2-Title")
font = para_style.get_font()
font.set_size(font.get_size() * scale)
para_style.set_font(font)
style_sheet.add_paragraph_style("AC2-Title", para_style)
graph_style = GraphicsStyle()
width = graph_style.get_line_width()
width = width * scale
graph_style.set_line_width(width)
style_sheet.add_draw_style("AC2-line", graph_style)
self.doc.set_style_sheet(style_sheet)
class FanChart(Report):
def __init__(self, database, options, user):
"""
Create the FanChart object that produces the report.
The arguments are:
database - the Gramps database instance
options - instance of the Options class for this report
user - a gen.user.User instance
This report needs the following parameters (class variables)
that come in the options class.
maxgen - Maximum number of generations to include.
circle - Draw a full circle, half circle, or quarter circle.
background - Background color is generation dependent or white.
radial - Print radial texts roundabout or as upright as possible.
draw_empty - draw background when there is no information
same_style - use the same style for all generation
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
self.set_locale(options.menu.get_option_by_name('trans').get_value())
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, self._locale)
self.database = CacheProxyDb(self.database)
self.max_generations = menu.get_option_by_name('maxgen').get_value()
self.circle = menu.get_option_by_name('circle').get_value()
self.background = menu.get_option_by_name('background').get_value()
self.radial = menu.get_option_by_name('radial').get_value()
pid = menu.get_option_by_name('pid').get_value()
self.draw_empty = menu.get_option_by_name('draw_empty').get_value()
self.same_style = menu.get_option_by_name('same_style').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
self.graphic_style = []
self.text_style = []
for i in range(0, self.max_generations):
self.graphic_style.append('FC-Graphic' + '%02d' % i)
self.text_style.append('FC-Text' + '%02d' % i)
self.calendar = 0
self.height = 0
self.map = [None] * 2**self.max_generations
self.text = {}
def apply_filter(self, person_handle, index):
"""traverse the ancestors recursively until either the end
of a line is found, or until we reach the maximum number of
generations that we want to deal with"""
if (not person_handle) or (index >= 2**self.max_generations):
return
self.map[index-1] = person_handle
self.text[index-1] = self.get_info(person_handle, log2(index))
person = self.database.get_person_from_handle(person_handle)
family_handle = person.get_main_parents_family_handle()
if family_handle:
family = self.database.get_family_from_handle(family_handle)
self.apply_filter(family.get_father_handle(), index*2)
self.apply_filter(family.get_mother_handle(), (index*2)+1)
def write_report(self):
self.doc.start_page()
self.apply_filter(self.center_person.get_handle(), 1)
p_rn = self.center_person.get_primary_name().get_regular_name()
if self.circle == FULL_CIRCLE:
max_angle = 360.0
start_angle = 90
max_circular = 5
_x_ = self.doc.get_usable_width() / 2.0
_y_ = self.doc.get_usable_height() / 2.0
min_xy = min(_x_, _y_)
elif self.circle == HALF_CIRCLE:
max_angle = 180.0
start_angle = 180
max_circular = 3
_x_ = (self.doc.get_usable_width()/2.0)
_y_ = self.doc.get_usable_height()
min_xy = min(_x_, _y_)
else: # quarter circle
max_angle = 90.0
start_angle = 270
max_circular = 2
_x_ = 0
_y_ = self.doc.get_usable_height()
min_xy = min(self.doc.get_usable_width(), _y_)
# choose one line or two lines translation according to the width
title = self._("%(generations)d Generation Fan Chart "
"for %(person)s") % {
'generations' : self.max_generations,
'person' : p_rn}
title_nb_lines = 1
style_sheet = self.doc.get_style_sheet()
if style_sheet:
p_style = style_sheet.get_paragraph_style('FC-Title')
if p_style:
font = p_style.get_font()
if font:
title_width = utils.pt2cm(self.doc.string_width(font,
title))
if title_width > self.doc.get_usable_width():
title = self._(
"%(generations)d Generation Fan Chart "
"for\n%(person)s") % {
'generations' : self.max_generations,
'person' : p_rn}
title_nb_lines = 2
if self.circle == FULL_CIRCLE or self.circle == QUAR_CIRCLE:
# adjust only if full circle or 1/4 circle in landscape mode
if self.doc.get_usable_height() <= self.doc.get_usable_width():
# Should be in Landscape now
style_sheet = self.doc.get_style_sheet()
p_style = style_sheet.get_paragraph_style('FC-Title')
if p_style:
font = p_style.get_font()
if font:
fontsize = utils.pt2cm(font.get_size())
# _y_ is vertical distance to center of circle,
# move center down 1 fontsize
_y_ += fontsize*title_nb_lines
# min_XY is the diameter of the circle,
# subtract two fontsize
# so we dont draw outside bottom of the paper
min_xy = min(min_xy, _y_ - 2*fontsize*title_nb_lines)
if self.max_generations > max_circular:
block_size = min_xy / (self.max_generations * 2 - max_circular)
else:
block_size = min_xy / self.max_generations
# adaptation of the fonts (title and others)
optimized_style_sheet = self.get_optimized_style_sheet(
title, max_circular, block_size, self.same_style,
not self.same_style,
# if same_style, use default generated colors
self.background == BACKGROUND_WHITE)
if optimized_style_sheet:
self.doc.set_style_sheet(optimized_style_sheet)
# title
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.center_text('FC-Graphic-title', title,
self.doc.get_usable_width() / 2, 0, mark)
# wheel
for generation in range(0, min(max_circular, self.max_generations)):
self.draw_circular(_x_, _y_,
start_angle, max_angle, block_size, generation)
for generation in range(max_circular, self.max_generations):
self.draw_radial(_x_, _y_,
start_angle, max_angle, block_size, generation)
self.doc.end_page()
def get_info(self, person_handle, generation):
""" get info about a person """
person = self.database.get_person_from_handle(person_handle)
p_pn = person.get_primary_name()
self.calendar = config.get('preferences.calendar-format-report')
birth = get_birth_or_fallback(self.database, person)
bth = ""
if birth:
bth = birth.get_date_object()
bth = str(bth.to_calendar(self.calendar).get_year())
if bth == 0:
bth = ""
elif birth.get_type() != EventType.BIRTH:
bth += '*'
death = get_death_or_fallback(self.database, person)
dth = ""
if death:
dth = death.get_date_object()
dth = str(dth.to_calendar(self.calendar).get_year())
if dth == 0:
dth = ""
elif death.get_type() != EventType.DEATH:
dth += '*'
if bth and dth:
val = "%s - %s" % (str(bth), str(dth))
elif bth:
val = "* %s" % (str(bth))
elif dth:
val = "+ %s" % (str(dth))
else:
val = ""
if generation > 7:
if (p_pn.get_first_name() != "") and (p_pn.get_surname() != ""):
name = p_pn.get_first_name() + " " + p_pn.get_surname()
else:
name = p_pn.get_first_name() + p_pn.get_surname()
if (name != "") and (val != ""):
string = name + ", " + val
else:
string = name + val
return [string]
elif generation == 7:
if (p_pn.get_first_name() != "") and (p_pn.get_surname() != ""):
name = p_pn.get_first_name() + " " + p_pn.get_surname()
else:
name = p_pn.get_first_name() + p_pn.get_surname()
if self.circle == FULL_CIRCLE:
return [name, val]
elif self.circle == HALF_CIRCLE:
return [name, val]
else:
if (name != "") and (val != ""):
string = name + ", " + val
else:
string = name + val
return [string]
elif generation == 6:
if self.circle == FULL_CIRCLE:
return [p_pn.get_first_name(), p_pn.get_surname(), val]
elif self.circle == HALF_CIRCLE:
return [p_pn.get_first_name(), p_pn.get_surname(), val]
else:
if (p_pn.get_first_name() != "") and (p_pn.get_surname() != ""):
name = p_pn.get_first_name() + " " + p_pn.get_surname()
else:
name = p_pn.get_first_name() + p_pn.get_surname()
return [name, val]
else:
return [p_pn.get_first_name(), p_pn.get_surname(), val]
def get_max_width_for_circles(self, rad1, rad2, max_centering_proportion):
r"""
(the "r" in the above line is to keep pylint happy)
__
/__\ <- compute the line width which is drawable between 2 circles.
/ _ \ max_centering_proportion : 0, touching the circle1, 1,
| |_| | touching the circle2, 0.5 : middle between the 2 circles
| |
\ /
\__/
basically, max_centering_proportion is
max_centering_proportion/nb_lines
"""
# radius at the center of the 2 circles
rmid = rad2 - (rad2-rad1)*max_centering_proportion
return sin(acos(rmid/rad2)) * rad2 * 2
def get_max_width_for_circles_line(self, rad1, rad2, line, nb_lines,
centering=False):
r"""
(the "r" in the above line is to keep pylint happy)
__
/__\ <- compute the line width which is drawable between 2 circles.
/ _ \ instead of a max_centering_proportion, you get a
| |_| | line/nb_lines position. (we suppose that lines have the
| | same heights.) for example, if you've 2 lines to draw,
\ / line 2 max width is at the 2/3 between the 2 circles
\__/
"""
if centering:
return self.get_max_width_for_circles(rad1, rad2, 1.0)
else:
return self.get_max_width_for_circles(rad1, rad2,
line/float(nb_lines+1))
def get_optimized_font_size_for_text(self, rad1, rad2, text, font,
centering=False):
"""
a text can be several lines
find the font size equals or lower than font.get_size() which fit
between rad1 and rad2 to display the text.
centering is a special case when you've the full circle
available to draw the text in the middle of it
"""
min_font_size = font.get_size()
i = 1
nb_lines = len(text)
for line in text:
font_size = self.get_optimized_font_size(
line, font,
self.get_max_width_for_circles_line(rad1, rad2, i, nb_lines,
centering))
i += 1
if min_font_size > font_size:
min_font_size = font_size
return min_font_size
def get_optimized_font_size(self, line, font, max_width):
"""
for a given width, guess the best font size which is equals
or smaller than font which make line fit into max_width
"""
test_font = FontStyle(font)
width = utils.pt2cm(self.doc.string_width(test_font, line))
while width > max_width and test_font.get_size() > 1:
test_font.set_size(test_font.get_size() -1)
width = utils.pt2cm(self.doc.string_width(test_font, line))
return test_font.get_size()
def get_optimized_style_sheet(self, title, max_circular, block_size,
map_style_from_single,
map_paragraphs_colors_to_graphics,
make_background_white):
"""
returns an optimized (modified) style sheet which make fanchart
look nicer
"""
new_style_sheet = self.doc.get_style_sheet()
if not new_style_sheet:
return self.doc.get_style_sheet()
# update title font size
pstyle_name = 'FC-Title'
p_style = new_style_sheet.get_paragraph_style(pstyle_name)
if p_style:
title_font = p_style.get_font()
if title_font:
title_width = utils.pt2cm(
self.doc.string_multiline_width(title_font, title))
while (title_width > self.doc.get_usable_width() and
title_font.get_size() > 1):
title_font.set_size(title_font.get_size()-1)
title_width = utils.pt2cm(
self.doc.string_multiline_width(title_font, title))
new_style_sheet.add_paragraph_style(pstyle_name, p_style)
# biggest font allowed is the one of the fist generation, after,
# always lower than the previous one
p_style = new_style_sheet.get_paragraph_style(self.text_style[0])
font = None
if p_style:
font = p_style.get_font()
if font:
previous_generation_font_size = font.get_size()
for generation in range(0, self.max_generations):
gstyle_name = self.graphic_style[generation]
pstyle_name = self.text_style[generation]
g_style = new_style_sheet.get_draw_style(gstyle_name)
# p_style is a copy of 'FC-Text' - use different style
# to be able to auto change some fonts for some generations
if map_style_from_single:
p_style = new_style_sheet.get_paragraph_style('FC-Text')
else:
p_style = new_style_sheet.get_paragraph_style(pstyle_name)
if g_style and p_style:
# set graphic colors to paragraph colors,
# while it's functionnaly
# the same for fanchart or make backgrounds white
if make_background_white:
g_style.set_fill_color((255, 255, 255))
new_style_sheet.add_draw_style(gstyle_name, g_style)
elif map_paragraphs_colors_to_graphics:
pstyle = new_style_sheet.get_paragraph_style(
pstyle_name)
if pstyle:
g_style.set_fill_color(
pstyle.get_background_color())
new_style_sheet.add_draw_style(gstyle_name,
g_style)
# adapt font size if too big
segments = 2**generation
if generation < min(max_circular, self.max_generations):
# adpatation for circular fonts
rad1, rad2 = self.get_circular_radius(
block_size, generation, self.circle)
font = p_style.get_font()
if font:
min_font_size = font.get_size()
# find the smallest font required
for index in range(segments - 1, 2*segments - 1):
if self.map[index]:
font_size = \
self.get_optimized_font_size_for_text(
rad1, rad2, self.text[index],
p_style.get_font(),
(self.circle == FULL_CIRCLE and
generation == 0)
)
if font_size < min_font_size:
min_font_size = font_size
font.set_size(min(previous_generation_font_size,
min_font_size))
else:
# adaptation for radial fonts
# find the largest string for the generation
longest_line = ""
longest_width = 0
for index in range(segments - 1, 2*segments - 1):
if self.map[index]:
for line in self.text[index]:
width = utils.pt2cm(
self.doc.string_multiline_width(
p_style.get_font(), line))
if width > longest_width:
longest_line = line
longest_width = width
# determine maximum width allowed for this generation
rad1, rad2 = self.get_radial_radius(
block_size, generation, self.circle)
max_width = rad2 - rad1
# reduce the font so that longest_width
# fit into max_width
font = p_style.get_font()
if font:
font.set_size(min(previous_generation_font_size,
self.get_optimized_font_size(
longest_line,
p_style.get_font(),
max_width)))
# redefine the style
new_style_sheet.add_paragraph_style(pstyle_name, p_style)
font = p_style.get_font()
if font:
previous_generation_font_size = font.get_size()
# finished
return new_style_sheet
def draw_circular(self, _x_, _y_,
start_angle, max_angle, size, generation):
segments = 2**generation
delta = max_angle / segments
end_angle = start_angle
text_angle = start_angle - 270 + (delta / 2.0)
rad1, rad2 = self.get_circular_radius(size, generation, self.circle)
graphic_style = self.graphic_style[generation]
for index in range(segments - 1, 2*segments - 1):
start_angle = end_angle
end_angle = start_angle + delta
(_xc, _yc) = draw_wedge(self.doc, graphic_style, _x_, _y_, rad2,
start_angle, end_angle,
self.map[index] or self.draw_empty, rad1)
if self.map[index]:
if (generation == 0) and self.circle == FULL_CIRCLE:
_yc = _y_
person = self.database.get_person_from_handle(self.map[index])
mark = utils.get_person_mark(self.database, person)
self.doc.rotate_text(graphic_style, self.text[index],
_xc, _yc, text_angle, mark)
text_angle += delta
def get_radial_radius(self, size, generation, circle):
""" determine the radius """
if circle == FULL_CIRCLE:
rad1 = size * ((generation * 2) - 5)
rad2 = size * ((generation * 2) - 3)
elif circle == HALF_CIRCLE:
rad1 = size * ((generation * 2) - 3)
rad2 = size * ((generation * 2) - 1)
else: # quarter circle
rad1 = size * ((generation * 2) - 2)
rad2 = size * (generation * 2)
return rad1, rad2
def get_circular_radius(self, size, generation, circle):
""" determine the radius """
return size * generation, size * (generation + 1)
def draw_radial(self, _x_, _y_,
start_angle, max_angle, size, generation):
segments = 2**generation
delta = max_angle / segments
end_angle = start_angle
text_angle = start_angle - delta / 2.0
graphic_style = self.graphic_style[generation]
rad1, rad2 = self.get_radial_radius(size, generation, self.circle)
for index in range(segments - 1, 2*segments - 1):
start_angle = end_angle
end_angle = start_angle + delta
(_xc, _yc) = draw_wedge(self.doc, graphic_style, _x_, _y_, rad2,
start_angle, end_angle,
self.map[index] or self.draw_empty, rad1)
text_angle += delta
if self.map[index]:
person = self.database.get_person_from_handle(self.map[index])
mark = utils.get_person_mark(self.database, person)
if (self.radial == RADIAL_UPRIGHT
and (start_angle >= 90)
and (start_angle < 270)):
self.doc.rotate_text(graphic_style, self.text[index],
_xc, _yc, text_angle + 180, mark)
else:
self.doc.rotate_text(graphic_style, self.text[index],
_xc, _yc, text_angle, mark)
class EndOfLineReport(Report):
""" EndOfLine Report """
def __init__(self, database, options, user):
"""
Create the EndOfLineReport object that produces the report.
The arguments are:
database - the GRAMPS database instance
options - instance of the Options class for this report
user - a gen.user.User() instance
This report needs the following parameters (class variables)
that come in the options class.
name_format - Preferred format to display names
incl_private - Whether to include private data
living_people - How to handle living people
years_past_death - Consider as living this many years after death
"""
Report.__init__(self, database, options, user)
menu = options.menu
lang = menu.get_option_by_name('trans').get_value()
rlocale = self.set_locale(lang)
stdoptions.run_private_data_option(self, menu)
stdoptions.run_living_people_option(self, menu, rlocale)
self.database = CacheProxyDb(self.database)
pid = menu.get_option_by_name('pid').get_value()
self.center_person = self.database.get_person_from_gramps_id(pid)
if self.center_person is None:
raise ReportError(_("Person %s is not in the Database") % pid)
stdoptions.run_name_format_option(self, menu)
# eol_map is a map whose:
# keys are the generations of the people
# values are a map whose:
# keys are person handles
# values are an array whose:
# elements are an array of ancestor person handles that link
# the eol person handle to the person or interest
# eol_map[generation][person_handle][pedigree_idx][ancestor_handle_idx]
#
# There is an array of pedigrees because one person could show up twice
# in one generation (descendants marrying). Most people only have one
# pedigree.
#
# eol_map is populated by get_eol() which calls itself recursively.
self.eol_map = {}
self.get_eol(self.center_person, 1, [])
def get_eol(self, person, gen, pedigree):
"""
Recursively find the end of the line for each person
"""
person_handle = person.get_handle()
new_pedigree = list(pedigree) + [person_handle]
person_is_eol = False
families = person.get_parent_family_handle_list()
if person_handle in pedigree:
# This is a severe error!
# It indicates a loop in ancestry: A -> B -> A
person_is_eol = True
elif not families:
person_is_eol = True
else:
for family_handle in families:
family = self.database.get_family_from_handle(family_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
if father_handle:
father = self.database.get_person_from_handle(
father_handle)
self.get_eol(father, gen + 1, new_pedigree)
if mother_handle:
mother = self.database.get_person_from_handle(
mother_handle)
self.get_eol(mother, gen + 1, new_pedigree)
if not father_handle or not mother_handle:
person_is_eol = True
if person_is_eol:
# This person is the end of a line
if gen not in self.eol_map:
self.eol_map[gen] = {}
if person_handle not in self.eol_map[gen]:
self.eol_map[gen][person_handle] = []
self.eol_map[gen][person_handle].append(new_pedigree)
def write_report(self):
"""
The routine that actually creates the report.
At this point, the document is opened and ready for writing.
"""
pname = self._name_display.display(self.center_person)
self.doc.start_paragraph("EOL-Title")
# feature request 2356: avoid genitive form
title = self._("End of Line Report for %s") % pname
mark = IndexMark(title, INDEX_TYPE_TOC, 1)
self.doc.write_text(title, mark)
self.doc.end_paragraph()
self.doc.start_paragraph("EOL-Subtitle")
# feature request 2356: avoid genitive form
title = self._(
"All the ancestors of %s who are missing a parent") % pname
self.doc.write_text(title)
self.doc.end_paragraph()
self.doc.start_table('EolTable', 'EOL-Table')
for generation, handles in self.eol_map.items():
self.write_generation_row(generation)
for person_handle, pedigrees in handles.items():
self.write_person_row(person_handle)
list(map(self.write_pedigree_row, pedigrees))
self.doc.end_table()
def write_generation_row(self, generation):
"""
Write out a row in the table showing the generation.
"""
self.doc.start_row()
self.doc.start_cell('EOL_GenerationCell', 2)
self.doc.start_paragraph('EOL-Generation')
self.doc.write_text(self._("Generation %d") % generation)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def write_person_row(self, person_handle):
"""
Write a row in the table with information about the given person.
"""
person = self.database.get_person_from_handle(person_handle)
name = self._name_display.display(person)
mark = utils.get_person_mark(self.database, person)
birth_date = ""
birth_ref = person.get_birth_ref()
if birth_ref:
event = self.database.get_event_from_handle(birth_ref.ref)
birth_date = self._get_date(event.get_date_object())
death_date = ""
death_ref = person.get_death_ref()
if death_ref:
event = self.database.get_event_from_handle(death_ref.ref)
death_date = self._get_date(event.get_date_object())
dates = ''
if birth_date or death_date:
dates = self._(" (%(birth_date)s - %(death_date)s)") % {
'birth_date': birth_date,
'death_date': death_date
}
self.doc.start_row()
self.doc.start_cell('EOL-TableCell', 2)
self.doc.start_paragraph('EOL-Normal')
self.doc.write_text(name, mark)
self.doc.write_text(dates)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def write_pedigree_row(self, pedigree):
"""
Write a row in the table with with the person's family line.
pedigree is an array containing the names of the people in the pedigree
"""
names = []
for person_handle in pedigree:
person = self.database.get_person_from_handle(person_handle)
names.append(self._name_display.display(person))
text = " -- ".join(names)
self.doc.start_row()
self.doc.start_cell('EOL-TableCell')
self.doc.end_cell()
self.doc.start_cell('EOL-TableCell')
self.doc.start_paragraph('EOL-Pedigree')
self.doc.write_text(text)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
