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)
