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): """ 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 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 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 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)
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()