class FamilyEvents(Events):
"""
Displays the events for a family.
"""
def db_changed(self):
self.connect(self.dbstate.db, 'family-update', self.update)
self.connect_signal('Family', self.update)
def update_has_data(self):
active_handle = self.get_active('Family')
active = None
if active_handle:
active = self.dbstate.db.get_family_from_handle(active_handle)
self.set_has_data(self.get_has_data(active))
def get_has_data(self, active_family):
"""
Return True if the gramplet has data, else return False.
"""
if active_family:
for event_ref in active_family.get_event_ref_list():
return True
return False
def main(self): # return false finishes
active_handle = self.get_active('Family')
self.db = CacheProxyDb(self.dbstate.db)
self.model.clear()
self.callman.unregister_all()
if active_handle:
self.display_family(active_handle)
else:
self.set_has_data(False)
self.db = None
def display_family(self, active_handle):
"""
Display the events for the active family.
"""
active_family = self.db.get_family_from_handle(active_handle)
self.cached_start_date = self.get_start_date()
for event_ref in active_family.get_event_ref_list():
self.add_event_ref(event_ref)
self.set_has_data(self.model.count > 0)
def get_start_date(self):
"""
Get the start date for a family, usually a marriage date, or
something close to marriage.
"""
active_handle = self.get_active('Family')
active = self.db.get_family_from_handle(active_handle)
event = get_marriage_or_fallback(self.db, active)
return event.get_date_object() if event else None
def main(self): # return false finishes
active_handle = self.get_active('Family')
self.db = CacheProxyDb(self.dbstate.db)
self.model.clear()
self.callman.unregister_all()
if active_handle:
self.display_family(active_handle)
else:
self.set_has_data(False)
self.db = None
def _rebuild_filter(self, ignore=None):
""" function called when view must be build, given filter options
in the filter sidebar
"""
self.clear_cache()
self._in_build = True
if (self.db is not None) and self.db.is_open():
cdb = CacheProxyDb(self.db)
allkeys = self.node_map.full_srtkey_hndl_map()
if not allkeys:
allkeys = self.sort_keys()
if self.search:
ident = False
if ignore is None:
dlist = self.search.apply(cdb,
allkeys,
tupleind=1,
user=self.user)
else:
dlist = self.search.apply(
cdb, [k for k in allkeys if k[1] != ignore],
tupleind=1)
elif ignore is None:
ident = True
dlist = allkeys
else:
ident = False
dlist = [k for k in allkeys if k[1] != ignore]
self.node_map.set_path_map(dlist,
allkeys,
identical=ident,
reverse=self._reverse)
else:
self.node_map.clear_map()
self._in_build = False
def __rebuild_filter(self, dfilter, skip, items, gen_cursor, data_map,
add_func):
"""
Rebuild the data map for a single Gramps object type, where a filter
is applied.
"""
pmon = progressdlg.ProgressMonitor(
progressdlg.StatusProgress, (self.uistate,), popup_time=2,
title=_("Loading items..."))
status_ppl = progressdlg.LongOpStatus(total_steps=items,
interval=items // 20)
pmon.add_op(status_ppl)
self.__total += items
assert not skip
if dfilter:
cdb = CacheProxyDb(self.db)
for handle in dfilter.apply(cdb, tree=True,
user=User(parent=self.uistate.window)):
status_ppl.heartbeat()
data = data_map(handle)
add_func(handle, data)
self.__displayed += 1
else:
with gen_cursor() as cursor:
for handle, data in cursor:
status_ppl.heartbeat()
add_func(handle, data)
self.__displayed += 1
status_ppl.end()
def __init__(self, event_list, db, groups, **kwargs):
"""
@param event_list: A list of lists, every entry is a group, the entries
in a group are the data that needs to be shown subordinate to the
group
@param db: a database objects that can be used to obtain info
@param groups: a list of (key, name) tuples. key is a key for the group
that might be used. name is the name for the group.
@param kwargs: A dictionary of additional settings/values.
"""
self.start_date = kwargs.get("start_date", None)
typeobjs = (x[1] for x in self.COLS)
Gtk.TreeStore.__init__(self, *typeobjs)
self.db = CacheProxyDb(db)
self.groups = groups
for index, group in enumerate(event_list):
parentiter = self.append(None, row=self.row_group(index, group))
for eventref in group:
event = db.get_event_from_handle(eventref.ref)
self.append(parentiter, row=self.row(index, eventref, event))
class PersonEvents(Events):
"""
Displays the events for a person.
"""
def db_changed(self):
self.connect(self.dbstate.db, 'person-update', self.update)
def active_changed(self, handle):
self.update()
def update_has_data(self):
active_handle = self.get_active('Person')
active = None
if active_handle:
active = self.dbstate.db.get_person_from_handle(active_handle)
self.set_has_data(self.get_has_data(active))
def get_has_data(self, active_person):
"""
Return True if the gramplet has data, else return False.
"""
if active_person:
if active_person.get_event_ref_list():
return True
for family_handle in active_person.get_family_handle_list():
family = self.dbstate.db.get_family_from_handle(family_handle)
if family:
for event_ref in family.get_event_ref_list():
return True
return False
def main(self): # return false finishes
active_handle = self.get_active('Person')
self.db = CacheProxyDb(self.dbstate.db)
self.model.clear()
self.callman.unregister_all()
if active_handle:
self.display_person(active_handle)
else:
self.set_has_data(False)
self.db = None
def display_person(self, active_handle):
"""
Display the events for the active person.
"""
active_person = self.db.get_person_from_handle(active_handle)
if active_person:
self.cached_start_date = self.get_start_date()
for event_ref in active_person.get_event_ref_list():
self.add_event_ref(event_ref)
for family_handle in active_person.get_family_handle_list():
family = self.db.get_family_from_handle(family_handle)
self.display_family(family, active_person)
else:
self.cached_start_date = None
self.set_has_data(self.model.count > 0)
def display_family(self, family, active_person):
"""
Display the events for the given family.
"""
spouse_handle = find_spouse(active_person, family)
if spouse_handle:
spouse = self.db.get_person_from_handle(spouse_handle)
else:
spouse = None
if family:
for event_ref in family.get_event_ref_list():
self.add_event_ref(event_ref, spouse)
def get_start_date(self):
"""
Get the start date for a person, usually a birth date, or
something close to birth.
"""
active_handle = self.get_active('Person')
active = self.db.get_person_from_handle(active_handle)
event = get_birth_or_fallback(self.db, active)
return event.get_date_object() if event else None
class EventRefModel(Gtk.TreeStore):
#index of the working group
_ROOTINDEX = 0
_GROUPSTRING = _('%(groupname)s - %(groupnumber)d')
COL_DESCR = (0, str)
COL_TYPE = (1, str)
COL_GID = (2, str)
COL_DATE = (3, str)
COL_PLACE = (4, str)
COL_ROLE = (5, str)
COL_PARTIC = (6, str)
COL_SORTDATE = (7, str)
COL_EVENTREF = (8, object)
COL_FONTWEIGHT = (9, int)
COL_AGE = (10, str)
COL_SORTAGE = (11, str)
COL_PRIVATE = (12, bool)
COL_HAS_SOURCE = (13, bool)
COLS = (COL_DESCR, COL_TYPE, COL_GID, COL_DATE, COL_PLACE, COL_ROLE,
COL_PARTIC, COL_SORTDATE, COL_EVENTREF, COL_FONTWEIGHT, COL_AGE,
COL_SORTAGE, COL_PRIVATE, COL_HAS_SOURCE)
def __init__(self, event_list, db, groups, **kwargs):
"""
@param event_list: A list of lists, every entry is a group, the entries
in a group are the data that needs to be shown subordinate to the
group
@param db: a database objects that can be used to obtain info
@param groups: a list of (key, name) tuples. key is a key for the group
that might be used. name is the name for the group.
@param kwargs: A dictionary of additional settings/values.
"""
self.start_date = kwargs.get("start_date", None)
typeobjs = (x[1] for x in self.COLS)
Gtk.TreeStore.__init__(self, *typeobjs)
self.db = CacheProxyDb(db)
self.groups = groups
for index, group in enumerate(event_list):
parentiter = self.append(None, row=self.row_group(index, group))
for eventref in group:
event = db.get_event_from_handle(eventref.ref)
self.append(parentiter, row=self.row(index, eventref, event))
def row_group(self, index, group):
name = self.namegroup(index, len(group))
spouse = self.groups[index][2]
return [
spouse, name, '', '', '', '', '', '', (index, None), WEIGHT_BOLD,
'', '', None, None
]
def namegroup(self, groupindex, length):
return self._GROUPSTRING % {
'groupname': self.groups[groupindex][1],
'groupnumber': length
}
def row(self, index, eventref, event):
return [
event.get_description(),
str(event.get_type()),
event.get_gramps_id(),
self.column_date(eventref),
self.column_place(eventref),
self.column_role(eventref),
self.column_participant(eventref),
self.column_sort_date(eventref),
(index, eventref),
self.colweight(index),
self.column_age(event),
self.column_sort_age(event),
eventref.get_privacy(),
event.has_citations(),
]
def colweight(self, index):
return WEIGHT_NORMAL
def column_role(self, event_ref):
return str(event_ref.get_role())
def column_date(self, event_ref):
event = self.db.get_event_from_handle(event_ref.ref)
retval = get_date(event)
if not get_date_valid(event):
return invalid_date_format % escape(retval)
else:
return retval
def column_sort_date(self, event_ref):
event = self.db.get_event_from_handle(event_ref.ref)
date = event.get_date_object()
if date:
return "%09d" % date.get_sort_value()
else:
return ""
def column_place(self, event_ref):
if event_ref and event_ref.ref:
event = self.db.get_event_from_handle(event_ref.ref)
if event:
return place_displayer.display_event(self.db, event)
return ""
def column_participant(self, event_ref):
return get_participant_from_event(self.db, event_ref.ref)
def column_age(self, event):
"""
Returns a string representation of age in years. Change
precision=2 for "year, month", or precision=3 for "year,
month, days"
"""
date = event.get_date_object()
if date and self.start_date:
if (date == self.start_date and date.modifier == Date.MOD_NONE
and not (event.get_type().is_death_fallback()
or event.get_type() == EventType.DEATH)):
return ""
else:
return (date - self.start_date).format(precision=age_precision)
else:
return ""
def column_sort_age(self, event):
"""
Returns a string version of number of days of age.
"""
date = event.get_date_object()
if date and self.start_date:
return "%09d" % int(date - self.start_date)
else:
return ""