def on_filters_changed(self, name_space): if name_space == 'Person': all_filter = GenericFilter() all_filter.set_name(_("None")) all_filter.add_rule(rules.person.Everyone([])) self.generic.set_model(build_filter_model('Person', [all_filter])) self.generic.set_active(0)
def filter_with_rule(self, rule): """ Apply a filter with the given rule. """ filter_ = GenericFilter() filter_.add_rule(rule) results = filter_.apply(self.db) return set(results)
def on_filters_changed(self, name_space): if name_space == "Person": all_filter = GenericFilter() all_filter.set_name(_("Entire Database")) all_filter.add_rule(rules.person.Everyone([])) self.filter_model = build_filter_model("Person", [all_filter]) self.filters.set_model(self.filter_model) self.filters.set_active(0)
def add_menu_options(self, menu): """ Add options to the menu for the place report. """ category_name = _("Report Options") # Reload filters to pick any new ones CustomFilters = None from gramps.gen.filters import CustomFilters, GenericFilter opt = FilterOption(_("Select using filter"), 0) opt.set_help(_("Select places using a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Place')) opt.set_filters(filter_list) menu.add_option(category_name, "filter", opt) stdoptions.add_name_format_option(menu, category_name) places = PlaceListOption(_("Select places individually")) places.set_help(_("List of places to report on")) menu.add_option(category_name, "places", places) stdoptions.add_place_format_option(menu, category_name) incpriv = BooleanOption(_("Include private data"), True) incpriv.set_help(_("Whether to include private data")) menu.add_option(category_name, "incpriv", incpriv) showgodparents = BooleanOption(_("show godparents"), True) showgodparents.set_help(_("Whether to include and show godparents")) menu.add_option(category_name, "showgodparents", showgodparents) stdoptions.add_localization_option(menu, category_name)
def add_menu_options(self, menu): """ Add options to the menu for the place report. """ category_name = _("Report Options") # Reload filters to pick any new ones CustomFilters = None from gramps.gen.filters import CustomFilters, GenericFilter opt = FilterOption(_("Select using filter"), 0) opt.set_help(_("Select places using a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Place')) opt.set_filters(filter_list) menu.add_option(category_name, "filter", opt) stdoptions.add_name_format_option(menu, category_name) places = PlaceListOption(_("Select places individually")) places.set_help(_("List of places to report on")) menu.add_option(category_name, "places", places) classwidth = EnumeratedListOption(_("Class wdith"), "classwidth") classwidth.set_items([("20 Years", _("10 Years")), ("20 Years", _("20 Years"))]) classwidth.set_help(_("classwidth fpr Analysis")) menu.add_option(category_name, "classwidth", classwidth) incpriv = BooleanOption(_("Include private data"), True) incpriv.set_help(_("Whether to include private data")) menu.add_option(category_name, "incpriv", incpriv) stdoptions.add_localization_option(menu, category_name)
def test_filter_1(self): from gramps.gen.filters.rules.person import (IsDescendantOf, IsAncestorOf) from gramps.gen.filters import GenericFilter filter = GenericFilter() filter.set_logical_op("or") filter.add_rule(IsDescendantOf(["I0057", True])) filter.add_rule(IsAncestorOf(["I0057", True])) result = self.db.Person.filter(filter).count() self.assertTrue(result == 14, result) filter.where = lambda person: person.private == True result = self.db.Person.filter(filter).count() self.assertTrue(result == 1, result) filter.where = lambda person: person.private != True result = self.db.Person.filter(filter).count() self.assertTrue(result == 13, result)
def add_menu_options(self, menu): """ Add options to the menu for the place report. """ category_name = _("Report Options") # Reload filters to pick any new ones CustomFilters = None from gramps.gen.filters import CustomFilters, GenericFilter opt = FilterOption(_("Select using filter"), 0) opt.set_help(_("Select places using a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Place')) opt.set_filters(filter_list) menu.add_option(category_name, "filter", opt) places = PlaceListOption(_("Select places individually")) places.set_help(_("List of places to report on")) menu.add_option(category_name, "places", places) reporttype = EnumeratedListOption(_("Type de Liste"), "ListeType") reporttype.set_items([("ListeEclair", _("Tiny Tafel")), ("cousingenweb", _("cousingenweb"))]) reporttype.set_help(_("Type de liste")) menu.add_option(category_name, "reporttype", reporttype) incpriv = BooleanOption(_("Include private data"), True) incpriv.set_help(_("Whether to include private data")) menu.add_option(category_name, "incpriv", incpriv)
def add_menu_options(self, menu): """ Add options to the menu for the place report. """ category_name = _("Report Options") # Reload filters to pick any new ones CustomFilters = None from gramps.gen.filters import CustomFilters, GenericFilter opt = FilterOption(_("Select using filter"), 0) opt.set_help(_("Select places using a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Place')) opt.set_filters(filter_list) menu.add_option(category_name, "filter", opt) places = PlaceListOption(_("Select places individually")) places.set_help(_("List of places to report on")) menu.add_option(category_name, "places", places) stdoptions.add_private_data_option(menu, category_name) stdoptions.add_living_people_option(menu, category_name) stdoptions.add_name_format_option(menu, category_name) center = EnumeratedListOption(_("Center on"), "Event") center.set_items([("Event", _("Event")), ("Person", _("Person"))]) center.set_help(_("If report is event or person centered")) menu.add_option(category_name, "center", center) stdoptions.add_localization_option(menu, category_name)
def add_menu_options(self, menu): """ Add options to the menu for the place report. """ category_name = _("Report Options") # Reload filters to pick any new ones CustomFilters = None #p from Filters import CustomFilters, GenericFilter from gramps.gen.filters import CustomFilters, GenericFilter opt = FilterOption(_("Select using filter"), 0) opt.set_help(_("Select places using a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Place')) opt.set_filters(filter_list) menu.add_option(category_name, "filter", opt) places = PlaceListOption(_("Select places individually")) places.set_help(_("List of places to report on")) menu.add_option(category_name, "places", places) center = EnumeratedListOption(_("Center on"), "Event") center.set_items([ ("Event", _("Event")), ("Person", _("Person"))]) center.set_help(_("If report is event or person centered")) menu.add_option(category_name, "center", center) incpriv = BooleanOption(_("Include private data"), True) incpriv.set_help(_("Whether to include private data")) menu.add_option(category_name, "incpriv", incpriv)
def build_model(self, namespace): """ Build a model for the combo box selector. """ from gi.repository import Gtk from gi.repository import GObject from gramps.gen.filters import CustomFilters if namespace == "person": # Populate the Person Filter entire_db = GenericFilter() entire_db.set_name(_("Include all selected people")) the_filters = [entire_db] if self.person: the_filters += self.__define_person_filters() the_filters.extend(CustomFilters.get_filters('Person')) model = Gtk.ListStore(GObject.TYPE_STRING, object) for item in the_filters: model.append(row=[item.get_name(), item]) elif namespace == "note": # Populate the Notes Filter entire_db = GenericFilter() entire_db.set_name(_("Include all selected notes")) notes_filters = [entire_db] notes_filters.extend(CustomFilters.get_filters('Note')) model = Gtk.ListStore(GObject.TYPE_STRING, object) for item in notes_filters: model.append(row=[item.get_name(), item]) elif namespace == "living": model = Gtk.ListStore(GObject.TYPE_STRING, int) row = 0 for item in [ _('Include all selected people'), _('Replace given names of living people'), _('Replace complete name of living people'), _('Do not include living people'), ]: model.append(row=[item, row]) row += 1 elif namespace == "reference": model = Gtk.ListStore(GObject.TYPE_STRING, int) row = 0 for item in [ _('Include all selected records'), _('Do not include records not linked to a selected person' ), ]: model.append(row=[item, row]) row += 1 return model
def add_menu_options(self, menu): """ Add the options for this report """ category_name = _("Report Options") title = StringOption(_('book|Title'), _('Title of the Book')) title.set_help(_("Title string for the book.")) menu.add_option(category_name, "title", title) subtitle = StringOption(_('Subtitle'), _('Subtitle of the Book')) subtitle.set_help(_("Subtitle string for the book.")) menu.add_option(category_name, "subtitle", subtitle) dateinfo = time.localtime(time.time()) #rname = self.__db.get_researcher().get_name() rname = "researcher name" footer_string = _('Copyright %(year)d %(name)s') % { 'year': dateinfo[0], 'name': rname } footer = StringOption(_('Footer'), footer_string) footer.set_help(_("Footer string for the page.")) menu.add_option(category_name, "footer", footer) # Reload filters to pick any new ones CustomFilters = None #p from Filters import CustomFilters, GenericFilter from gramps.gen.filters import CustomFilters, GenericFilter opt = FilterOption(_("Select using filter"), 0) opt.set_help(_("Select places using a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Source')) opt.set_filters(filter_list) menu.add_option(category_name, "filter", opt) showinlaw = BooleanOption(_("Show inlaw"), True) showinlaw.set_help(_("Whether to show inlaw persons")) menu.add_option(category_name, "showinlaw", showinlaw) showperson = BooleanOption(_("Show persons"), True) showperson.set_help( _("Whether to show events and persons mentioned in the note")) menu.add_option(category_name, "showperson", showperson) incphotos = BooleanOption(_("Include Photos"), True) incphotos.set_help( _("Whether to show photos mentioned in the citation")) menu.add_option(category_name, "incphotos", incphotos)
def _find_dependent_filters(self, namespace: str, base_filter: GenericFilter, filter_set: Set[GenericFilter]): """Recursively search for all dependent filters.""" base_filter_name = base_filter.get_name() for custom_filter in filters.CustomFilters.get_filters(namespace): if custom_filter.get_name() == base_filter_name: continue for custom_filter_rule in custom_filter.get_rules(): if base_filter_name in custom_filter_rule.values(): self._find_dependent_filters(namespace, custom_filter, filter_set) break filter_set.add(base_filter)
def build_model(self, namespace): """ Build a model for the combo box selector. """ from gi.repository import Gtk from gi.repository import GObject from gramps.gen.filters import CustomFilters if namespace == "person": # Populate the Person Filter entire_db = GenericFilter() entire_db.set_name(_("Include all selected people")) the_filters = [entire_db] if self.person: the_filters += self.__define_person_filters() the_filters.extend(CustomFilters.get_filters('Person')) model = Gtk.ListStore(GObject.TYPE_STRING, object) for item in the_filters: model.append(row=[item.get_name(), item]) elif namespace == "note": # Populate the Notes Filter entire_db = GenericFilter() entire_db.set_name(_("Include all selected notes")) notes_filters = [entire_db] notes_filters.extend(CustomFilters.get_filters('Note')) model = Gtk.ListStore(GObject.TYPE_STRING, object) for item in notes_filters: model.append(row=[item.get_name(), item]) elif namespace == "living": model = Gtk.ListStore(GObject.TYPE_STRING, int) row = 0 for item in [_('Include all selected people'), _('Replace given names of living people'), _('Replace complete name of living people'), _('Do not include living people'), ]: model.append(row=[item, row]) row += 1 elif namespace == "reference": model = Gtk.ListStore(GObject.TYPE_STRING, int) row = 0 for item in [ _('Include all selected records'), _('Do not include records not linked to a selected person'),]: model.append(row=[item, row]) row += 1 return model
def add_menu_options(self, menu): """ Add options to the menu for the place report. """ category_name = _("Report Options") # Reload filters to pick any new ones CustomFilters = None from gramps.gen.filters import CustomFilters, GenericFilter opt = FilterOption(_("Select using filter"), 0) opt.set_help(_("Select places using a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Place')) opt.set_filters(filter_list) menu.add_option(category_name, "filter", opt) stdoptions.add_name_format_option(menu, category_name) places = PlaceListOption(_("Select places individually")) places.set_help(_("List of places to report on")) menu.add_option(category_name, "places", places) placeformat = EnumeratedListOption(_("Place Format"), "Default") placeformat.set_items([ ("default", _("Default")), ("first", _("First")), ("firstplace", _("Firstplace")), ("firstplace-country", _("Firstplace-Country")), ("country", _("Country")), ("long", _("Long"))]) placeformat.set_help(_("If Placename is given long or short")) menu.add_option(category_name, "placeformat", placeformat) incpriv = BooleanOption(_("Include private data"), True) incpriv.set_help(_("Whether to include private data")) menu.add_option(category_name, "incpriv", incpriv) showgodparents = BooleanOption(_("show godparents"), True) showgodparents.set_help(_("Whether to include and show godparents")) menu.add_option(category_name, "showgodparents", showgodparents) stdoptions.add_localization_option(menu, category_name)
def add_menu_options(self, menu): """ Add the options for this report """ category_name = _("Report Options") title = StringOption(_('Report Title'), _('Title of the Report')) title.set_help(_("Title string for the report.")) menu.add_option(category_name, "title", title) subtitle = StringOption(_('Subtitle'), _('Subtitle of the Report')) subtitle.set_help(_("Subtitle string for the report.")) menu.add_option(category_name, "subtitle", subtitle) dateinfo = time.localtime(time.time()) #rname = self.__db.get_researcher().get_name() rname = "researcher name" footer_string = _('Copyright %(year)d %(name)s') % { 'year': dateinfo[0], 'name': rname } footer = StringOption(_('Footer'), footer_string) footer.set_help(_("Footer string for the page.")) menu.add_option(category_name, "footer", footer) # Reload filters to pick any new ones CustomFilters = None from gramps.gen.filters import CustomFilters, GenericFilter self.__filter = FilterOption(_("Select using filter"), 0) self.__filter.set_help(_("Select sources using a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Source')) self.__filter.set_filters(filter_list) menu.add_option(category_name, "filter", self.__filter) showperson = BooleanOption(_("Show persons"), True) showperson.set_help( _("Whether to show events and persons mentioned in the note")) menu.add_option(category_name, "showperson", showperson) locale_opt = stdoptions.add_localization_option(menu, category_name) stdoptions.add_date_format_option(menu, category_name, locale_opt)
def __define_person_filters(self): """Add person filters if the active person is defined.""" name = name_displayer.display(self.person) gramps_id = self.person.get_gramps_id() des = GenericFilter() # feature request 2356: avoid genitive form des.set_name(_("Descendants of %s") % name) des.add_rule(rules.person.IsDescendantOf([gramps_id, 1])) df = GenericFilter() # feature request 2356: avoid genitive form df.set_name(_("Descendant Families of %s") % name) df.add_rule(rules.person.IsDescendantFamilyOf([gramps_id, 1])) ans = GenericFilter() # feature request 2356: avoid genitive form ans.set_name(_("Ancestors of %s") % name) ans.add_rule(rules.person.IsAncestorOf([gramps_id, 1])) com = GenericFilter() com.set_name(_("People with common ancestor with %s") % name) com.add_rule(rules.person.HasCommonAncestorWith([gramps_id])) return [des, df, ans, com]
def get_filter(self): """ Extracts the text strings from the sidebar, and uses them to build up a new filter. """ # extract text values from the entry widgets name = extract_text(self.filter_name) gid = extract_text(self.filter_id) birth = extract_text(self.filter_birth) death = extract_text(self.filter_death) note = extract_text(self.filter_note) # extract remaining data from the menus etype = self.filter_event.get_type().xml_str() gender = self.filter_gender.get_active() regex = self.filter_regex.get_active() tag = self.tag.get_active() > 0 generic = self.generic.get_active() > 0 # check to see if the filter is empty. If it is empty, then # we don't build a filter empty = not (name or gid or birth or death or etype or note or gender or regex or tag or generic) if empty: generic_filter = None else: # build a GenericFilter generic_filter = GenericFilter() # if the name is not empty, choose either the regular expression # version or the normal text match if name: rule = RegExpName([name], use_regex=regex) generic_filter.add_rule(rule) # if the id is not empty, choose either the regular expression # version or the normal text match if gid: rule = RegExpIdOf([gid], use_regex=regex) generic_filter.add_rule(rule) # check the gender, and select the right rule based on gender if gender > 0: if gender == 1: generic_filter.add_rule(IsMale([])) elif gender == 2: generic_filter.add_rule(IsFemale([])) else: generic_filter.add_rule(HasUnknownGender([])) # Build an event filter if needed if etype: rule = HasEvent([etype, '', '', '', '', True], use_regex=regex) generic_filter.add_rule(rule) # Build birth event filter if needed # Arguments for the HasBirth filter are Date, Place, and Description # Since the value we extracted to the "birth" variable is the # request date, we pass it as the first argument if birth: rule = HasBirth([birth, '', '']) generic_filter.add_rule(rule) # Build death event filter if needed if death: rule = HasDeath([death, '', '']) generic_filter.add_rule(rule) # Build note filter if needed if note: rule = HasNoteRegexp([note], use_regex=regex) generic_filter.add_rule(rule) # check the Tag if tag: model = self.tag.get_model() node = self.tag.get_active_iter() attr = model.get_value(node, 0) rule = HasTag([attr]) generic_filter.add_rule(rule) if self.generic.get_active() != 0: model = self.generic.get_model() node = self.generic.get_active_iter() obj = str(model.get_value(node, 0)) rule = MatchesFilter([obj]) generic_filter.add_rule(rule) return generic_filter
def filter_with_rule(self, rule): filter_ = GenericFilter() filter_.add_rule(rule) results = filter_.apply(self.db) return set(results)
def get_filter(self): """ Extracts the text strings from the sidebar, and uses them to build up a new filter. """ # extract text values from the entry widgets name = extract_text(self.filter_name) gid = extract_text(self.filter_id) birth = extract_text(self.filter_birth) death = extract_text(self.filter_death) note = extract_text(self.filter_note) # extract remaining data from the menus etype = self.filter_event.get_type().xml_str() gender = self.filter_gender.get_active() regex = self.filter_regex.get_active() tag = self.tag.get_active() > 0 generic = self.generic.get_active() > 0 # check to see if the filter is empty. If it is empty, then # we don't build a filter empty = not (name or gid or birth or death or etype or note or gender or regex or tag or generic) if empty: generic_filter = None else: # build a GenericFilter generic_filter = GenericFilter() # if the name is not empty, choose either the regular expression # version or the normal text match if name: name_parts = name.split(sep=" ") for name_part in name_parts: rule = RegExpName([name_part], use_regex=regex) generic_filter.add_rule(rule) # if the id is not empty, choose either the regular expression # version or the normal text match if gid: rule = RegExpIdOf([gid], use_regex=regex) generic_filter.add_rule(rule) # check the gender, and select the right rule based on gender if gender > 0: if gender == 1: generic_filter.add_rule(IsMale([])) elif gender == 2: generic_filter.add_rule(IsFemale([])) else: generic_filter.add_rule(HasUnknownGender([])) # Build an event filter if needed if etype: rule = HasEvent([etype, '', '', '', '', '1'], use_regex=regex) generic_filter.add_rule(rule) # Build birth event filter if needed # Arguments for the HasBirth filter are Date, Place, and Description # Since the value we extracted to the "birth" variable is the # request date, we pass it as the first argument if birth: rule = HasBirth([birth, '', '']) generic_filter.add_rule(rule) # Build death event filter if needed if death: rule = HasDeath([death, '', '']) generic_filter.add_rule(rule) # Build note filter if needed if note: rule = HasNoteRegexp([note], use_regex=regex) generic_filter.add_rule(rule) # check the Tag if tag: model = self.tag.get_model() node = self.tag.get_active_iter() attr = model.get_value(node, 0) rule = HasTag([attr]) generic_filter.add_rule(rule) if self.generic.get_active() != 0: model = self.generic.get_model() node = self.generic.get_active_iter() obj = str(model.get_value(node, 0)) rule = MatchesFilter([obj]) generic_filter.add_rule(rule) return generic_filter
def add_menu_options(self, menu): """ Add options to the menu for the place report. """ common_name = _('Report Options') repository_name = _('Repositories') source_name = _('Sources') # Reload filters to pick any new ones CustomFilters = None from gramps.gen.filters import CustomFilters, GenericFilter opt = FilterOption(_("Select using filter"), 0) opt.set_help(_("Selection with a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Repository')) opt.set_filters(filter_list) menu.add_option(repository_name, "filter", opt) from functools import partial addopt = partial(menu.add_option, common_name) raddopt = partial(menu.add_option, repository_name) saddopt = partial(menu.add_option, source_name) incintern = BooleanOption(_("Include repository's urls"), False) incintern.set_help(_('Whether to include urls on repository.')) raddopt('incintern', incintern) incaddres = BooleanOption(_("Include repository's address"), False) incaddres.set_help(_('Whether to include addresses on repository.')) raddopt('incaddres', incaddres) incauthor = BooleanOption(_("Include source's author"), False) incauthor.set_help(_('Whether to include author.')) saddopt('incauthor', incauthor) incabbrev = BooleanOption(_("Include source's abbreviation"), False) incabbrev.set_help(_('Whether to include abbreviation.')) saddopt('incabbrev', incabbrev) incpublic = BooleanOption( _("Include source's publication information"), False) incpublic.set_help(_('Whether to include publication information.')) saddopt('incpublic', incpublic) incdatamp = BooleanOption(_("Include source's data"), False) incdatamp.set_help(_('Whether to include keys and values.')) saddopt('incdatamp', incdatamp) inclunote = BooleanOption(_('Include notes'), False) inclunote.set_help( _('Whether to include notes on repositories and sources.')) addopt('inclunote', inclunote) inclmedia = BooleanOption(_('Include media'), False) inclmedia.set_help(_('Whether to include media.')) addopt('inclmedia', inclmedia) inclcitat = BooleanOption(_('Include citations'), False) inclcitat.set_help(_('Whether to include citations on sources.')) saddopt('inclcitat', inclcitat) incprivat = BooleanOption(_('Include private records'), False) incprivat.set_help( _('Whether to include repositories and sources marked as private.') ) addopt('incprivat', incprivat) incempty = BooleanOption(_('Display empty values'), False) incempty.set_help( _('Whether to include key records with empty values.')) addopt('incempty', incempty) stdoptions.add_localization_option(menu, common_name)
def add_menu_options(self, menu): """ Add the options for this report """ category_name = _("Report Options") title = StringOption(_('book|Title'), _('Title of the Book') ) title.set_help(_("Title string for the book.")) menu.add_option(category_name, "title", title) subtitle = StringOption(_('Subtitle'), _('Subtitle of the Book') ) subtitle.set_help(_("Subtitle string for the book.")) menu.add_option(category_name, "subtitle", subtitle) dateinfo = time.localtime(time.time()) #rname = self.__db.get_researcher().get_name() rname = "researcher name" footer_string = _('Copyright %(year)d %(name)s') % { 'year' : dateinfo[0], 'name' : rname } footer = StringOption(_('Footer'), footer_string ) footer.set_help(_("Footer string for the page.")) menu.add_option(category_name, "footer", footer) # Reload filters to pick any new ones CustomFilters = None #p- from Filters import CustomFilters, GenericFilter from gramps.gen.filters import CustomFilters, GenericFilter # opt = FilterOption(_("Select using filter"), 0) # opt.set_help(_("Select places using a filter")) # filter_list = [] # filter_list.append(GenericFilter()) # filter_list.extend(CustomFilters.get_filters('Source')) # opt.set_filters(filter_list) # menu.add_option(category_name, "filter", opt) # # showpersons = BooleanOption(_("Show persons"), True) # showpersons.set_help(_("Whether to show events and persons mentioned in the note")) # menu.add_option(category_name, "showpersons", showpersons) # # incphotos = BooleanOption(_("Include Photos"), True) # incphotos.set_help(_("Whether to show photos mentioned in the citation")) # menu.add_option(category_name, "incphotos", incphotos) category_name = _("Calc Options") # Reload filters to pick any new ones CustomFilters = None from gramps.gen.filters import CustomFilters, GenericFilter opt = FilterOption(_("Select using filter"), 0) opt.set_help(_("Select places using a filter")) filter_list = [] filter_list.append(GenericFilter()) filter_list.extend(CustomFilters.get_filters('Source')) opt.set_filters(filter_list) menu.add_option(category_name, "filter", opt) # opt = FilterOption(_("Select Person filter"), 0) # opt.set_help(_("Select places using a person filter")) # filter_list = [] # filter_list.append(GenericFilter()) # filter_list.extend(CustomFilters.get_filters('Person')) # opt.set_filters(filter_list) # menu.add_option(category_name, "filter", opt) showallfamilies = BooleanOption(_("Show surnames of all famiies in clans"), True) showallfamilies.set_help(_("Whether to show the names of all families as surname")) menu.add_option(category_name, "showallfamilies", showallfamilies) placeformat = EnumeratedListOption(_("Place Format"), "Default") placeformat.set_items([ ("default", _("Default")), ("first", _("First")), ("firstplace", _("Firstplace")), ("firstplace-country", _("Firstplace-Country")), ("country", _("Country")), ("long", _("Long"))]) placeformat.set_help(_("If Placename is given long or short")) menu.add_option(category_name, "placeformat", placeformat)