def add_menu_options(self, menu): """Add the menu options for the tool.""" # Get generic 'all families' filter and all custom familiy filters menu.filter_list = CustomFilters.get_filters("Family") all_families = GenericFilterFactory("Family")() all_families.set_name(_("All Families")) all_families.add_rule(rules.family.AllFamilies([])) all_filter_in_list = False for fltr in menu.filter_list: if fltr.get_name() == all_families.get_name(): all_filter_in_list = True if not all_filter_in_list: menu.filter_list.insert(0, all_families) # family filter menu option fam = FilterOption(_("Family Filter"), 0) fam.set_help(_("Choose the set of families to process.\n" "Create custom filters if empty.")) fam.set_filters(menu.filter_list) menu.add_option(_("Options"), "families", fam) # add family relationship type menu option rel = FilterOption(_("Relationship Type"), 0) rel.set_help(_("Choose the new family relationship type.\n" "Custom relationship types aren't supported.")) rel.set_items([(0, _("Married")), (1, _("Unmarried")), (2, _("Civil Union")), (3, _("Unknown"))]) menu.add_option(_("Options"), "relationship", rel)
class RemoveTagOptions(MenuToolOptions): """ Class for creating 'Remove Tag Tool' menu options. The options are needed for processing tag removal in :class RemoveTagWindow:. """ def __init__(self, name, person_id=None, dbstate=None): self.__db = dbstate.get_database() MenuToolOptions.__init__(self, name, person_id, dbstate) def get_enum_tag_name_list(self): """ Returns an enumerated tag name list. :rtype: list """ tag_list = list(self.__db.iter_tags()) if tag_list: L = list(map(lambda x: x.get_name(), tag_list)) return list(enumerate(L)) def is_db_empty(self): """ Check if database has at least one person, family and tag. :returns: True or False """ try: next(self.__db.iter_person_handles()) next(self.__db.iter_family_handles()) next(self.__db.iter_tag_handles()) except StopIteration: # StopIteration is raised if at least one category has no objects return True # Empty return False # Not empty def add_menu_options(self, menu): """ Add the menu options for the Remove Tag Tool. """ if self.is_db_empty(): txt = [ _("The Remove Tag Tool requires at least " "one person, family and tag to execute.") ] self.empty = TextOption(_("ERROR"), txt) menu.add_option(_("ERROR"), "empty", self.empty) else: self.__add_tag_category_options(menu) self.__add_person_options(menu) self.__add_family_options(menu) self.filter_dict = {} lst = [("events", _("Event Filter"), "event_filter", 'Event', _("All Events")), ("places", _("Place Filter"), "place_filter", 'Place', _("All Places")), ("sources", _("Source Filter"), "scource_filter", 'Source', _("All Sources")), ("citations", _("Citation Filter"), "cit_filter", 'Citation', _("All Citations")), ("repositories", _("Repository Filter"), "repo_filter", 'Repository', _("All Repositories")), ("media", _("Media Filter"), "media_filter", 'Media', _("All Media")), ("notes", _("Note Filter"), "note_filter", 'Note', _("All Notes"))] for entry in lst: filter_name = FilterOption(entry[1], 0) filter_name.set_help( _("Select filter to restrict {}".format(entry[0]))) menu.add_option(_("Option 2"), entry[2], filter_name) self.filter_dict[entry[3]] = filter_name filter_list = CustomFilters.get_filters(entry[3]) GenericFilter = GenericFilterFactory(entry[3]) all_filter = GenericFilter() all_filter.set_name(entry[4]) all_filter.add_rule(rules.event.AllEvents([])) all_filter_in_list = False for fltr in filter_list: if fltr.get_name() == all_filter.get_name(): all_filter_in_list = True if not all_filter_in_list: filter_list.insert(0, all_filter) self.filter_dict[entry[3]].set_filters(filter_list) def __add_tag_category_options(self, menu): """ Menu Options for general category tab. Users select from which category they'd like to remove a tag. The chosen category also restricts the tag removal to this category e.g. remove tag 'ToDo' from filtered persons, but not from places, events, etc. """ lst = [ "People", "Families", "Events", "Places", "Sources", "Citations", "Repositories", "Media", "Notes" ] category_list = list(enumerate(lst)) self.__tag_category = FilterOption(_("Category"), 0) self.__tag_category.set_help(_("Choose a category.")) menu.add_option(_("Option 1"), "category", self.__tag_category) self.__tag_category.set_items(category_list) self.__tag_category.connect('value-changed', self.__update_options) tag_list = self.get_enum_tag_name_list() self.__tag_name = FilterOption("Remove Tag", 0) self.__tag_name.set_help(_("Choose a tag to remove.")) menu.add_option(_("Option 1"), "tag_name", self.__tag_name) self.__tag_name.set_items(tag_list) def __update_options(self): """ Turn availability on depending on user selection. """ self.__disable_all_options() value = self.__tag_category.get_value() if value == 0: self.__person_filter.set_available(True) self.__filter_changed() elif value == 1: self.__family_filter.set_available(True) self.__family_filter_changed() elif value == 2: self.filter_dict['Event'].set_available(True) elif value == 3: self.filter_dict['Place'].set_available(True) elif value == 4: self.filter_dict['Source'].set_available(True) elif value == 5: self.filter_dict['Citation'].set_available(True) elif value == 6: self.filter_dict['Repository'].set_available(True) elif value == 7: self.filter_dict['Media'].set_available(True) elif value == 8: self.filter_dict['Note'].set_available(True) def __disable_all_options(self): """ Turn all options off, except options 'category' and 'tag_name' """ self.__person_filter.set_available(False) self.__pid.set_available(False) self.__family_filter.set_available(False) self.__fid.set_available(False) for entry in [ 'Event', 'Place', 'Source', 'Citation', 'Repository', 'Media', 'Note' ]: self.filter_dict[entry].set_available(False) def __add_person_options(self, menu): """ Menu Options for person category. Menu Option 'pers_filter' is used to choose a generic or custom person filter. Menu Option 'pid' selects the center person, which is needed for some person filters. :param menu: a menu object where options can be added :type menu: :class Menu: object """ self.__person_filter = FilterOption(_("Person Filter"), 0) self.__person_filter.set_help(_("Select filter to restrict people")) menu.add_option(_("Option 1"), "pers_filter", self.__person_filter) self.__person_filter.connect('value-changed', self.__filter_changed) self.__pid = PersonOption(_("Center Person")) self.__pid.set_help(_("The center person for the filter")) menu.add_option(_("Option 1"), "pid", self.__pid) self.__pid.connect('value-changed', self.__update_filters) self.__update_filters() def __update_filters(self): """ Update the filter list based on the selected person. """ gid = self.__pid.get_value() person = self.__db.get_person_from_gramps_id(gid) filter_list = ReportUtils.get_person_filters(person, False) self.__person_filter.set_filters(filter_list) def __filter_changed(self): """ Handle person filter change. If the filter is not specific to a person, disable the person option. """ filter_value = self.__person_filter.get_value() if filter_value in [1, 2, 3, 4]: self.__pid.set_available(True) else: self.__pid.set_available(False) def __add_family_options(self, menu): """ Menu Options for family category. Menu Option 'family_filter' is used to choose a generic or custom family filter. Menu Option 'fid' selects the center family, which is needed for some filters. :param menu: a menu object where options can be added :type menu: :class Menu: object """ self.__family_filter = FilterOption(_("Family Filter"), 0) self.__family_filter.set_help(_("Select filter to restrict families")) menu.add_option(_("Option 1"), "family_filter", self.__family_filter) self.__family_filter.connect('value-changed', self.__family_filter_changed) self.__fid = FamilyOption(_("Center Family")) self.__fid.set_help(_("The center person for the filter")) menu.add_option(_("Option 1"), "fid", self.__fid) self.__fid.connect('value-changed', self.__update_family_filters) self.__update_family_filters() def __update_family_filters(self): """ Update the filter list based on the selected family. """ gid = self.__fid.get_value() family = self.__db.get_family_from_gramps_id(gid) filter_list = ReportUtils.get_family_filters(self.__db, family, False) self.__family_filter.set_filters(filter_list) def __family_filter_changed(self): """ Handle family filter change. If the filter is not specific to a family, disable the family option. """ filter_value = self.__family_filter.get_value() if filter_value in [1, 2]: self.__fid.set_available(True) else: self.__fid.set_available(False)
class RemoveTagOptions(MenuToolOptions): """Class for creating menu options.""" def __init__(self, name, person_id=None, dbstate=None): self.db = dbstate.get_database() MenuToolOptions.__init__(self, name, person_id, dbstate) def add_menu_options(self, menu): """Add the menu options for the tool.""" if self.__is_db_empty(): txt = [_("The Tool requires at least one tag to execute.")] self.empty = TextOption(_("ERROR"), txt) self.empty.set_available(False) menu.add_option(_("ERROR"), "empty", self.empty) return # stop other menu option creation else: self.__general_options(menu) self.__filter_options(menu) def __enum_tag_list(self): """Return an enumerated tag name list.""" tag_list = list(self.db.iter_tags()) if tag_list: L = list(map(lambda x: x.get_name(), tag_list)) return list(enumerate(L)) def __is_db_empty(self): """Check if database has at least one tag.""" try: next(self.db.iter_tag_handles()) except StopIteration: # StopIteration is raised when the category has no objects return True # Empty return False # Not empty def __general_options(self, menu): """Menu Options for general option tab.""" # Add or remove tags menu option self.add_remove = FilterOption(_("Add/Remove"), 0) self.add_remove.set_help(_("Add or remove tags from objects.")) self.add_remove.set_items([(0, _("Add Tags")), (1, _("Remove Tags"))]) menu.add_option(_("General options"), "add_remove", self.add_remove) # category menu option lst = [ _("People"), _("Families"), _("Events"), _("Places"), _("Sources"), _("Citations"), _("Repositories"), _("Media"), _("Notes") ] category_list = list(enumerate(lst)) self.tag_category = FilterOption(_("Category"), 0) self.tag_category.set_help(_("Choose a category.")) menu.add_option(_("General options"), "category", self.tag_category) self.tag_category.set_items(category_list) self.tag_category.connect('value-changed', self.__update_options) # tag name list menu option tag_list = self.__enum_tag_list() self.tag_name = FilterOption(_("Choose Tag"), 0) self.tag_name.set_help(_("Choose a tag to remove.")) menu.add_option(_("General options"), "tag_name", self.tag_name) self.tag_name.set_items(tag_list) def __filter_options(self, menu): """Menu Options for filter option tab.""" self.filter_dict = {} # get all filter rules, used for generic filters all_persons = rules.person.Everyone([]) all_families = rules.family.AllFamilies([]) all_events = rules.event.AllEvents([]) all_places = rules.place.AllPlaces([]) all_sources = rules.source.AllSources([]) all_cits = rules.citation.AllCitations([]) all_repos = rules.repository.AllRepos([]) all_media = rules.media.AllMedia([]) all_notes = rules.note.AllNotes([]) # create a list used for menu filter option creation later lst = [(_("Person Filter"), 'Person', _("Persons"), all_persons), (_("Family Filter"), 'Family', _("Families"), all_families), (_("Event Filter"), 'Event', _("Events"), all_events), (_("Place Filter"), 'Place', _("Places"), all_places), (_("Source Filter"), 'Source', _("Sources"), all_sources), (_("Citation Filter"), 'Citation', _("Citations"), all_cits), (_("Repository Filter"), 'Repository', _("Repositories"), all_repos), (_("Media Filter"), 'Media', _("Media"), all_media), (_("Note Filter"), 'Note', _("Notes"), all_notes)] for entry in lst: # create a filter option for each category e.g. person, events # filter option is a combination of custom filters and # a generic filter for all objects of one category filter_name = FilterOption(entry[0], 0) menu.add_option(_("Filter options"), entry[1].lower(), filter_name) self.filter_dict[entry[1]] = filter_name # custom filter: filter_list = CustomFilters.get_filters(entry[1]) # generic filter: GenericFilter = GenericFilterFactory(entry[1]) all_filter = GenericFilter() all_filter.set_name(_("All %s") % (entry[2])) all_filter.add_rule(entry[3]) # only add the generic filter if it isn't already in the menu all_filter_in_list = False for fltr in filter_list: if fltr.get_name() == all_filter.get_name(): all_filter_in_list = True if not all_filter_in_list: filter_list.insert(0, all_filter) # add the list of custom and generic filters # to the filter option self.filter_dict[entry[1]].set_filters(filter_list) def __update_options(self): """Turn availability on and off depending on user selection.""" lst = [ 'Person', 'Family', 'Event', 'Place', 'Source', 'Citation', 'Repository', 'Media', 'Note' ] for entry in lst: self.filter_dict[entry].set_available(False) value = self.tag_category.get_value() self.filter_dict[lst[value]].set_available(True)
class AvatarGeneratorOptions(MenuToolOptions): def __init__(self, name, person_id=None, dbstate=None): self.__db = dbstate.get_database() MenuToolOptions.__init__(self, name, person_id, dbstate) def add_menu_options(self, menu): """ Add all menu options to the tool window. """ # generate list for category menu option words = [ _("male"), _("female"), _("unknown"), _("Option"), _("single image mode") ] itm1 = "{} 1: {}".format(words[3], words[4]) itm2 = "{} 2: {}/{}/{}".format(words[3], words[0], words[1], words[2]) category_names = [(0, itm1), (1, itm2)] # add all menu options self.__category = FilterOption(_("Category"), 0) text = _("Choose how many images you'd like to use.") self.__category.set_help(text) menu.add_option(_("Options"), "category", self.__category) self.__category.set_items(category_names) self.__category.connect('value-changed', self.__update_options) self.__media1 = MediaOption(_("Unknown")) self.__media1.set_help(_("Image for people with unknown gender.")) menu.add_option(_("Options"), "media1", self.__media1) self.__media2 = MediaOption(_("Male")) self.__media2.set_help(_("Image for males.")) menu.add_option(_("Options"), "media2", self.__media2) self.__media3 = MediaOption(_("Female")) self.__media3.set_help(_("Image for females")) menu.add_option(_("Options"), "media3", self.__media3) self.__person_filter = FilterOption(_("Person Filter"), 0) self.__person_filter.set_help(_("Select filter to restrict people")) menu.add_option(_("Options"), "person_filter", self.__person_filter) self.__person_filter.connect('value-changed', self.__filter_changed) self.__pid = PersonOption(_("Center Person")) self.__pid.set_help(_("The center person for the filter")) menu.add_option(_("Options"), "pid", self.__pid) self.__pid.connect('value-changed', self.__update_filters) self.__remove = BooleanOption(_("Remove images from people"), False) txt = _("Remove selected image(s).") self.__remove.set_help(txt) menu.add_option(_("Options"), "remove", self.__remove) def __update_filters(self): """ Update filter list based on the selected person. """ gid = self.__pid.get_value() person = self.__db.get_person_from_gramps_id(gid) filter_list = ReportUtils.get_person_filters(person, False) self.__person_filter.set_filters(filter_list) def __filter_changed(self): """ Handle filter change. If the filter is not specific to a person, disable the person option. """ filter_value = self.__person_filter.get_value() if filter_value in [1, 2, 3, 4]: self.__pid.set_available(True) else: self.__pid.set_available(False) def __update_options(self): """ Update the availability of media options in the menu depending on what the user selects in menu option"category". """ self.__media2.set_available(False) self.__media3.set_available(False) if self.__category.get_value() == 1: self.__media2.set_available(True) self.__media3.set_available(True)
class RemoveTagOptions(MenuToolOptions): """ Class for creating the remove tag menu options wich are needed for processing tag removal in class RemoveTagWindow. """ def __init__(self, name, person_id=None, dbstate=None): self.__db = dbstate.get_database() self.__tag_dict = self.__get_tag_dict() self.__item_list = self.__get_item_list() MenuToolOptions.__init__(self, name, person_id, dbstate) def __get_tag_dict(self): """ Return a dict in format: {tag_name <type:string> : tag_handle <type:string>} """ db = self.__db tag_list = db.iter_tags() tag_dict = {} for Tag in tag_list: serialized = Tag.serialize() tag_handle = serialized[0] tag_name = serialized[1] tag_dict[tag_name] = tag_handle return tag_dict def __get_item_list(self): """ Return an enumerated list containing the tag touples. Needed so users can select a tag name from the list. format: (number <int>, tag_name <str>) """ item_list = [] number = 0 for tag_name in self.__tag_dict: item = (number, tag_name) item_list.append(item) number += 1 return item_list def add_menu_options(self, menu): """ Add the menu options for the Remove Tag Tool. """ self.__add_tag_category_options(menu) self.__add_person_options(menu) self.__add_family_options(menu) self.__add_event_options(menu) self.__add_place_options(menu) self.__add_source_options(menu) self.__add_citation_options(menu) self.__add_repository_options(menu) self.__add_media_options(menu) self.__add_note_options(menu) self.__update_options() def __add_tag_category_options(self, menu): """ Menu Options for general category. Users selects from which category they'd like to remove a tag. The chosen category also restricts the tag removal to this category e.g. remove tag 'ToDo' from filtered persons, but not from places, events, etc. """ item_list = [] self.category_names = ["People", "Families", "Events", "Places", "Sources", "Citations", "Repositories", "Media", "Notes"] for i in range(1, 10): txt = i, _(self.category_names[i-1]) item_list.append(txt) self.__tag_category = FilterOption(_("Category"), 1) text = _("Choose a category from where would you like to remove a tag") tag_category_text = text self.__tag_category.set_help(tag_category_text) menu.add_option(_("Configuration"), "tag_category", self.__tag_category) self.__tag_category.set_items(item_list) self.__tag_category.connect('value-changed', self.__update_options) item_list = self.__item_list self.__tag_name = FilterOption("Remove Tag", 0) self.__tag_name.set_help(_("Choose a tag to remove")) menu.add_option(_("Configuration"), "tag_name", self.__tag_name) self.__tag_name.set_items(item_list) def __update_options(self): self.__filter.set_available(False) self.__pid.set_available(False) self.__family_filter.set_available(False) self.__fid.set_available(False) self.__event_filter.set_available(False) self.__place_filter.set_available(False) self.__source_filter.set_available(False) self.__cit_filter.set_available(False) self.__repo_filter.set_available(False) self.__media_filter.set_available(False) self.__note_filter.set_available(False) value = self.__tag_category.get_value() if value == 1: self.__filter.set_available(True) self.__filter_changed() elif value == 2: self.__family_filter.set_available(True) self.__family_filter_changed() elif value == 3: self.__event_filter.set_available(True) elif value == 4: self.__place_filter.set_available(True) elif value == 5: self.__source_filter.set_available(True) elif value == 6: self.__cit_filter.set_available(True) elif value == 7: self.__repo_filter.set_available(True) elif value == 8: self.__media_filter.set_available(True) elif value == 9: self.__note_filter.set_available(True) def __add_person_options(self, menu): """ Menu Options for person category. Menu Option 'filter' is used to choose a generic or custom person filter. Menu Option 'pid' selects the center person, which is needed for some person filters. """ self.__filter = FilterOption(_("Person Filter"), 0) self.__filter.set_help(_("Select filter to restrict people")) menu.add_option(_("Configuration"), "filter", self.__filter) self.__filter.connect('value-changed', self.__filter_changed) self.__pid = PersonOption(_("Center Person")) self.__pid.set_help(_("The center person for the filter")) menu.add_option(_("Configuration"), "pid", self.__pid) self.__pid.connect('value-changed', self.__update_filters) def __update_filters(self): """ Update the filter list based on the selected person. """ gid = self.__pid.get_value() person = self.__db.get_person_from_gramps_id(gid) filter_list = ReportUtils.get_person_filters(person, False) self.__filter.set_filters(filter_list) def __filter_changed(self): """ Handle filter change. If the filter is not specific to a person, disable the person option. """ filter_value = self.__filter.get_value() if filter_value in [1, 2, 3, 4]: self.__pid.set_available(True) else: self.__pid.set_available(False) def __add_family_options(self, menu): """ Menu Options for family category. Menu Option 'family_filter' is used to choose a generic or custom family filter. Menu Option 'fid' selects the center family, which is needed for some filters. """ self.__family_filter = FilterOption(_("Family Filter"), 0) self.__family_filter.set_help(_("Select filter to restrict families")) menu.add_option(_("Configuration"), "family_filter", self.__family_filter) self.__family_filter.connect('value-changed', self.__family_filter_changed) self.__fid = FamilyOption(_("Center Family")) self.__fid.set_help(_("The center person for the filter")) menu.add_option(_("Configuration"), "fid", self.__fid) self.__fid.connect('value-changed', self.__update_family_filters) def __update_family_filters(self): """ Update the filter list based on the selected family. """ gid = self.__fid.get_value() family = self.__db.get_family_from_gramps_id(gid) filter_list = ReportUtils.get_family_filters(self.__db, family, False) self.__family_filter.set_filters(filter_list) def __family_filter_changed(self): """ Handle filter change. If the filter is not specific to a family, disable the family option. """ filter_value = self.__family_filter.get_value() if filter_value in [1, 2]: self.__fid.set_available(True) else: self.__fid.set_available(False) def __add_event_options(self, menu): """ Menu Options for event category. Menu Option 'event_filter' is used to choose a custom event filter. """ self.__event_filter = FilterOption(_("Event Filter"), 0) self.__event_filter.set_help(_("Select filter to restrict events")) menu.add_option(_("Configuration"), "event_filter", self.__event_filter) filter_list = CustomFilters.get_filters('Event') self.__event_filter.set_filters(filter_list) def __add_place_options(self, menu): """ Menu Options for place category. Menu Option 'place_filter' is used to choose a custom place filter. """ self.__place_filter = FilterOption(_("Place Filter"), 0) self.__place_filter.set_help(_("Select filter to restrict places")) menu.add_option(_("Configuration"), "place_filter", self.__place_filter) filter_list = CustomFilters.get_filters('Place') self.__place_filter.set_filters(filter_list) def __add_source_options(self, menu): """ Menu Options for scoure category. Menu Option 'source_filter' is used to choose a custom source filter. """ self.__source_filter = FilterOption(_("Source Filter"), 0) self.__source_filter.set_help(_("Select filter to restrict sources")) menu.add_option(_("Configuration"), "source_filter", self.__source_filter) filter_list = CustomFilters.get_filters('Source') self.__source_filter.set_filters(filter_list) def __add_citation_options(self, menu): """ Menu Options for citation category. Menu Option 'cit_filter' is used to choose a custom citation filter. """ self.__cit_filter = FilterOption(_("Citation Filter"), 0) self.__cit_filter.set_help(_("Select filter to restrict citations")) menu.add_option(_("Configuration"), "cit_filter", self.__cit_filter) filter_list = CustomFilters.get_filters('Citation') self.__cit_filter.set_filters(filter_list) def __add_repository_options(self, menu): """ Menu Options for repository category. Menu Option 'repo_filter' is usedto choose a custom repository filter. """ self.__repo_filter = FilterOption(_("Repository Filter"), 0) text = _("Select filter to restrict repositories") self.__repo_filter.set_help(text) menu.add_option(_("Configuration"), "repo_filter", self.__repo_filter) filter_list = CustomFilters.get_filters('Repository') self.__repo_filter.set_filters(filter_list) def __add_media_options(self, menu): """ Menu Options for media category. Menu Option 'media_filter' is used to choose a custom media filter. """ self.__media_filter = FilterOption(_("Media Filter"), 0) self.__media_filter.set_help(_("Select filter to restrict media")) menu.add_option(_("Configuration"), "media_filter", self.__media_filter) filter_list = CustomFilters.get_filters('Media') self.__media_filter.set_filters(filter_list) def __add_note_options(self, menu): """ Menu Options for notes category. Menu Option 'note_filter' is used to choose a custom note filter. """ self.__note_filter = FilterOption(_("Note Filter"), 0) self.__note_filter.set_help(_("Select filter to restrict notes")) menu.add_option(_("Configuration"), "note_filter", self.__note_filter) filter_list = CustomFilters.get_filters('Note') self.__note_filter.set_filters(filter_list)