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 get_person_filters(person, include_single=True):
"""
Return a list of filters that are relevant for the given person
@param person: the person the filters should apply to.
@type person: L{Person}
@param include_single: include a filter to include the single person
@type person: boolean
"""
from Filters import GenericFilter, Rules, CustomFilters
from gen.display.name import displayer as name_displayer
if person:
name = name_displayer.display(person)
gramps_id = person.get_gramps_id()
else:
# Do this in case of command line options query (show=filter)
name = _("PERSON")
gramps_id = ''
if include_single:
filt_id = GenericFilter()
filt_id.set_name(name)
filt_id.add_rule(Rules.Person.HasIdOf([gramps_id]))
all = GenericFilter()
all.set_name(_("Entire Database"))
all.add_rule(Rules.Person.Everyone([]))
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]))
if include_single:
the_filters = [filt_id, all, des, df, ans, com]
else:
the_filters = [all, des, df, ans, com]
the_filters.extend(CustomFilters.get_filters('Person'))
return the_filters
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, u'', u'', u'', u'', 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, u'', u''])
generic_filter.add_rule(rule)
# Build death event filter if needed
if death:
rule = HasDeath([death, u'', u''])
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 = unicode(model.get_value(node, 0))
rule = MatchesFilter([obj])
generic_filter.add_rule(rule)
return generic_filter