def __init__(self, database, options, user): Report.__init__(self, database, options, user) self._user = user menu = options.menu mgobn = lambda name:options.menu.get_option_by_name(name).get_value() stdoptions.run_private_data_option(self, menu) # (this report has its own "living people" option ("alive") already) self.titletext = mgobn('titletext') self.relationships = mgobn('relationships') self.year = mgobn('year') self.country = mgobn('country') self.anniversaries = mgobn('anniversaries') self.start_dow = mgobn('start_dow') self.maiden_name = mgobn('maiden_name') self.alive = mgobn('alive') self.birthdays = mgobn('birthdays') self.text1 = mgobn('text1') self.text2 = mgobn('text2') self.text3 = mgobn('text3') self.filter_option = menu.get_option_by_name('filter') self.filter = self.filter_option.get_filter() pid = mgobn('pid') lang = menu.get_option_by_name('trans').get_value() self._locale = self.set_locale(lang) stdoptions.run_name_format_option(self, menu) 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 )
def __init__(self, database, options, user): """ Create SimpleBookTitle 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. title - Title string. subtitle - Subtitle string. imgid - Gramps ID of the media object to use as an image. imgsize - Size for the image. footer - Footer string. """ Report.__init__(self, database, options, user) self._user = user menu = options.menu self.title_string = menu.get_option_by_name("title").get_value() self.image_size = menu.get_option_by_name("imgsize").get_value() self.subtitle_string = menu.get_option_by_name("subtitle").get_value() self.footer_string = menu.get_option_by_name("footer").get_value() self.object_id = menu.get_option_by_name("imgid").get_value()
def __init__(self, database, options, user): """ Create the SourceReport 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. Sources - List of places to report on. """ Report.__init__(self, database, options, user) self.__db = database menu = options.menu self.title_string = menu.get_option_by_name('title').get_value() self.subtitle_string = menu.get_option_by_name('subtitle').get_value() self.footer_string = menu.get_option_by_name('footer').get_value() self.showperson = menu.get_option_by_name('showperson').get_value() filter_option = menu.get_option_by_name('filter') self.filter = filter_option.get_filter() if self.filter.get_name() != '': # Use the selected filter to provide a list of source handles sourcefilterlist = self.__db.iter_source_handles() self.source_handles = self.filter.apply(self.__db, sourcefilterlist) else: self.source_handles = self.__db.get_source_handles()
def __init__(self, database, options, user): """ Create the NumberOfAncestorsReport 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 Menu options: name_format - Preferred format to display names incl_private - Whether to include private data """ Report.__init__(self, database, options, user) stdoptions.run_private_data_option(self, options.menu) self.__db = self.database pid = options.menu.get_option_by_name('pid').get_value() self.__person = self.__db.get_person_from_gramps_id(pid) if (self.__person == None) : raise ReportError(_("Person %s is not in the Database") % pid ) lang = options.menu.get_option_by_name('trans').get_value() self._locale = self.set_locale(lang) stdoptions.run_name_format_option(self, options.menu)
def __init__(self, database, options_class, user): Report.__init__(self, database, options_class, user) menu = options_class.menu places = menu.get_option_by_name('places').get_value() self.reporttype = menu.get_option_by_name('reporttype').get_value() self.incpriv = menu.get_option_by_name('incpriv').get_value() #self.incliving = menu.get_option_by_name('incliving').get_value() if self.incpriv: self.database = database else: self.database = PrivateProxyDb(database) #self.database = LivingProxyDb(database, LivingProxyDb.MODE_EXCLUDE_ALL) filter_option = menu.get_option_by_name('filter') self.filter = filter_option.get_filter() self.sort = Sort(self.database) if self.filter.get_name() != '': # Use the selected filter to provide a list of place handles plist = self.database.iter_place_handles() self.place_handles = self.filter.apply(self.database, plist) else: # Use the place handles selected without a filter self.place_handles = self.__get_place_handles(places) self.place_handles.sort(key=self.sort.by_place_title_key)
def __init__(self, database, options_class, user): Report.__init__(self, database, options_class, user) menu_option = options_class.menu.get_option_by_name("what_types") self.what_types = menu_option.get_selected() # TODO: handle an empty selection of what_types if len(self.what_types) == 0: raise ReportError(_("Last Change Report"), _("You must select at least one type of record."))
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 """ Report.__init__(self, database, options, user) menu = options.menu stdoptions.run_private_data_option(self, menu) 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.')) self.set_locale(menu.get_option_by_name('trans').get_value()) stdoptions.run_name_format_option(self, menu)
def __init__(self, database, options, user): Report.__init__(self, database, options, user) menu = options.menu self._user = user stdoptions.run_private_data_option(self, menu) get_value = lambda name: menu.get_option_by_name(name).get_value() self.year = get_value('year') self.name_format = get_value('name_format') self.country = get_value('country') self.anniversaries = get_value('anniversaries') self.start_dow = get_value('start_dow') self.maiden_name = get_value('maiden_name') self.alive = get_value('alive') self.birthdays = get_value('birthdays') self.text1 = get_value('text1') self.text2 = get_value('text2') self.text3 = get_value('text3') self.filter_option = menu.get_option_by_name('filter') self.filter = self.filter_option.get_filter() pid = get_value('pid') 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 ) self._locale = self.set_locale(get_value('trans'))
def __init__(self, database, options_class, user): """ Create the Census report. The arguments are: database - the GRAMPS database instance options_class - instance of the Options class for this report user - a gen.user.User() instance The following parameters are defined in the options class: pid - Selected person. pg_break - Whether to include page breaks between generations. """ Report.__init__(self, database, options_class, user) menu = options_class.menu self.pgbrk = menu.get_option_by_name('pg_break').get_value() self.report_type = menu.get_option_by_name('report_type').get_value() pid = menu.get_option_by_name('pid').get_value() self.person = database.get_person_from_gramps_id(pid) if (self.person == None) : user.notify_error(_("Census Report"), _("Person %s is not in the Database") % pid) self.src_handle = menu.get_option_by_name('src_handle').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 """ Report.__init__(self, database, options, user) menu = options.menu stdoptions.run_private_data_option(self, menu) self.filter_option = menu.get_option_by_name('filter') self.filter = self.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._lang = options.menu.get_option_by_name('trans').get_value() self._locale = self.set_locale(self._lang) self._nf = 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 DescendantBook 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 filter_option - Specific report filter to use. """ Report.__init__(self, database, options, user) menu = options.menu self.user = user self.title = _('Descendants Report') self.max_generations = menu.get_option_by_name('gen').get_value() pid = menu.get_option_by_name('pid').get_value() self.center_person = database.get_person_from_gramps_id(pid) if (self.center_person == None) : raise ReportError(_("Person %s is not in the Database") % pid ) sort = Sort(self.database) self.by_birthdate_key = sort.by_birthdate_key #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'" % self.numbering) marrs = menu.get_option_by_name('marrs').get_value() divs = menu.get_option_by_name('divs').get_value() self.filter_option = menu.get_option_by_name('filter') self.filter = self.filter_option.get_filter() # Copy the global NameDisplay so that we don't change application defaults. self._name_display = copy.deepcopy(global_name_display) name_format = menu.get_option_by_name("name_format").get_value() if name_format != 0: self._name_display.set_default_format(name_format) self.objPrint = Printinfo(self.doc, database, obj, marrs, divs, self._name_display)
def __init__(self, database, options, user): """ Create the AncestralCollapsibleTree object that produces the Ancestral Collapsible Tree 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. max_gen - Maximum number of generations to include. name_format - Preferred format to display names male_bg - Background color for males female_bg - Background color for females exp_male_bg - Background color for expandable males exp_female_bg - Background color for expandable females dest_path - Destination Path dest_file - Destination HTML filename """ Report.__init__(self, database, options, user) self.map = {} menu = options.menu self.max_gen = menu.get_option_by_name('maxgen').get_value() self.male_bg = menu.get_option_by_name('male_bg').get_value() self.female_bg = menu.get_option_by_name('female_bg').get_value() self.exp_male_bg = menu.get_option_by_name('exp_male_bg').get_value() self.exp_female_bg = \ menu.get_option_by_name('exp_female_bg').get_value() self.dest_path = conv_to_unicode( menu.get_option_by_name('dest_path').get_value(), 'utf8') self.dest_file = conv_to_unicode( menu.get_option_by_name('dest_file').get_value(), 'utf8') self.destprefix, self.destext = \ os.path.splitext(os.path.basename(self.dest_file)) self.destjson = conv_to_unicode( os.path.join(self.dest_path, "json", "%s.json" % (self.destprefix))) self.destjs = conv_to_unicode( os.path.join(self.dest_path, "js", "%s.js" % (self.destprefix))) self.desthtml = conv_to_unicode( os.path.join(self.dest_path, os.path.basename(self.dest_file))) pid = menu.get_option_by_name('pid').get_value() self.center_person = database.get_person_from_gramps_id(pid) if (self.center_person == None) : raise ReportError(_("Person %s is not in the Database") % pid ) # Copy the global NameDisplay so that we don't change application # defaults. self._name_display = copy.deepcopy(global_name_display) name_format = menu.get_option_by_name("name_format").get_value() if name_format != 0: self._name_display.set_default_format(name_format)
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.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 == None) : raise ReportError(_("Person %s is not in the Database") % pid ) sort = Sort(self.database) #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'" % self.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.objPrint = Printinfo(self.doc, self.database, obj, marrs, divs, self._name_display, self._locale)
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_class, user): Report.__init__(self, database, options_class, user) self.counter = 0 menu_option = options_class.menu.get_option_by_name('what_types') self.what_types = menu_option.get_selected() if not self.what_types: raise ReportError(_('Last Change Report'), _('You must select at least one type of' ' record.'))
def __init__(self, database, options, user): Report.__init__(self, database, options, user) self._user = user menu = options.menu mgobn = lambda name:options.menu.get_option_by_name(name).get_value() self.filename = mgobn('filename') self.show_diff = mgobn('show_diff') self.show_missing = mgobn('show_missing') self.show_added = mgobn('show_added')
def __init__(self, database, options, user): """ Create the PlaceFamilyReport object produces the PlaceFamily 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. # placeformat - Format of Place to display incpriv - Whether to include private data showgodparents - Whether to include and show godparents """ Report.__init__(self, database, options, user) self._user = user menu = options.menu places = menu.get_option_by_name('places').get_value() self.pl_format = menu.get_option_by_name('placeformat').get_value() #U self.placeformat = get_value('placeformat') self.incpriv = menu.get_option_by_name('incpriv').get_value() self.showgodparents = menu.get_option_by_name('showgodparents').get_value() self.set_locale(menu.get_option_by_name('trans').get_value()) name_format = menu.get_option_by_name("name_format").get_value() if name_format != 0: self._name_display.set_default_format(name_format) self._nd = self._name_display if self.incpriv: self.database = database else: self.database = PrivateProxyDb(database) filter_option = menu.get_option_by_name('filter') self.filter = filter_option.get_filter() self.sort = Sort(self.database) if self.filter.get_name() != '': # Use the selected filter to provide a list of place handles plist = self.database.iter_place_handles() self.place_handles = self.filter.apply(self.database, plist) else: # Use the place handles selected without a filter self.place_handles = self.__get_place_handles(places) self.place_handles.sort(key=self.sort.by_place_title_key)
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.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.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): Report.__init__(self, database, options, user) menu = options.menu pid = menu.get_option_by_name('pid').get_value() self.descendent = database.get_person_from_gramps_id(pid) self.descendent_handle = self.descendent.get_handle() ancestor = menu.get_option_by_name('ancestor').get_value() self.ancestor = database.get_person_from_gramps_id(ancestor) if (self.descendent == None) : raise ReportError(_("Person %s is not in the Database") % pid )
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 """ Report.__init__(self, database, options, user) self._user = user menu = options.menu stdoptions.run_private_data_option(self, menu) places = menu.get_option_by_name('places').get_value() self.center = menu.get_option_by_name('center').get_value() self.set_locale(menu.get_option_by_name('trans').get_value()) stdoptions.run_name_format_option(self, menu) self._nd = self._name_display filter_option = menu.get_option_by_name('filter') self.filter = filter_option.get_filter() self.sort = Sort(self.database) if self.filter.get_name() != '': # Use the selected filter to provide a list of place handles plist = self.database.iter_place_handles() self.place_handles = self.filter.apply(self.database, plist) else: # Use the place handles selected without a filter 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)
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 RepositoryReport object produces the Repositories 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. incintern - Whether to include urls for repository. incaddres - Whether to include addresses for repository. incauthor - Whether to include author of source. incabbrev - Whether to include abbreviation of source. incpublic - Whether to include publication information of source. incdatamp - Whether to include data keys and values of source. inclunote - Whether to include notes of source or repository. inclmedia - Whether to include media of source. inclcitat - Whether to include citations of source. incprivat - Whether to include private records. incempty - Whether to include empty lines with keys for filling. trans - Select translation """ Report.__init__(self, database, options, user) 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.inc_intern = get_value('incintern') self.inc_addres = get_value('incaddres') self.inc_author = get_value('incauthor') self.inc_abbrev = get_value('incabbrev') self.inc_public = get_value('incpublic') self.inc_datamp = get_value('incdatamp') self.inclu_note = get_value('inclunote') self.incl_media = get_value('inclmedia') self.incl_citat = get_value('inclcitat') self.inc_privat = get_value('incprivat') self.incl_empty = get_value('incempty') language = get_value('trans') locale = self.set_locale(language) filter_option = get_option_by_name('filter') self.filter = filter_option.get_filter()
def __init__(self, database, options, user): """ Create the IndivCompleteReport 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. cites - Whether or not to include source information. sort - Whether or not to sort events into chronological order. images - Whether or not to include images. sections - Which event groups should be given separate sections. 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) stdoptions.run_private_data_option(self, menu) stdoptions.run_living_people_option(self, menu, self._locale) self._db = self.database self.use_pagebreak = menu.get_option_by_name('pageben').get_value() self.use_srcs = menu.get_option_by_name('cites').get_value() self.use_srcs_notes = menu.get_option_by_name('incsrcnotes').get_value() self.sort = menu.get_option_by_name('sort').get_value() self.use_images = menu.get_option_by_name('images').get_value() self.use_gramps_id = menu.get_option_by_name('grampsid').get_value() filter_option = options.menu.get_option_by_name('filter') self.filter = filter_option.get_filter() self.bibli = None self.section_list = menu.get_option_by_name('sections').get_selected() 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 TableOfContents 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.set_locale(options.menu.get_option_by_name('trans').get_value())
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 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 """ Report.__init__(self, database, options, user) menu = options.menu stdoptions.run_private_data_option(self, menu) 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 == 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 = {} self.set_locale(menu.get_option_by_name('trans').get_value())
def __init__(self, database, options, user): """ Create AlphabeticalIndex 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._user = user self.set_locale(options.menu.get_option_by_name("trans").get_value())
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 use_hexagons - Whether to use hexagons for individuals of unknown gender 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.use_hexagons = get_value('usehexagons') self.adoptionsdashed = get_value('dashed') self.show_families = get_value('showfamily') self.show_family_leaves = get_value('show_family_leaves') 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 __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, get_endnote_numbers=self.endnotes) self.bibli = Bibliography(Bibliography.MODE_DATE|Bibliography.MODE_PAGE)
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 # 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, self.filter, 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 __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 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. 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. 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. omitda - Whether to omit duplicate ancestors (e.g. when distant cousins marry). 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 """ 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() stdoptions.run_private_data_option(self, menu) 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.inc_notes = get_value('incnotes') use_call = get_value('usecall') blankplace = get_value('repplace') blankdate = get_value('repdate') self.calcageflag = get_value('computeage') self.dubperson = get_value('omitda') self.verbose = get_value('verbose') self.numbering = get_value('numbering') 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_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') pid = get_value('pid') self.center_person = self.db.get_person_from_gramps_id(pid) if (self.center_person == 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 = {} if blankdate: empty_date = EMPTY_ENTRY else: empty_date = "" if blankplace: empty_place = EMPTY_ENTRY else: empty_place = "" self._locale = self.set_locale(get_value('trans')) 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)