def display_family(self, active_handle):
"""
Display the events for the active family.
"""
active_family = self.dbstate.db.get_family_from_handle(active_handle)
for event_ref in active_family.get_event_ref_list():
self.add_event_ref(event_ref)
self.set_has_data(self.model.count > 0)
# for father, add all events
father_handle = active_family.get_father_handle()
if father_handle:
father = self.dbstate.db.get_person_from_handle(father_handle)
if father:
for event_ref in father.get_event_ref_list():
surname = name_displayer.display(father)
self.add_event_ref(event_ref, name=surname)
# for mother, add all events
mother_handle = active_family.get_mother_handle()
if mother_handle:
mother = self.dbstate.db.get_person_from_handle(mother_handle)
if mother:
for event_ref in mother.get_event_ref_list():
surname = name_displayer.display(mother)
self.add_event_ref(event_ref, name=surname)
# for each child, add all events
child_ref_list = active_family.get_child_ref_list()
if child_ref_list:
for chld_ref in child_ref_list:
if chld_ref:
child = self.dbstate.db.get_person_from_handle(chld_ref.ref)
if child:
for event_ref in child.get_event_ref_list():
surname = name_displayer.display(child)
self.add_event_ref(event_ref, name=surname)
def family_label(self,family):
if family is None:
return "Unknown"
f = self.dbstate.db.get_person_from_handle(
family.get_father_handle())
m = self.dbstate.db.get_person_from_handle(
family.get_mother_handle())
if f and m:
label = _("%(gramps_id)s : %(father)s and %(mother)s") % {
'father' : _nd.display(f),
'mother' : _nd.display(m),
'gramps_id' : family.gramps_id,
}
elif f:
label = "%(gramps_id)s : %(father)s" % {
'father' : _nd.display(f),
'gramps_id' : family.gramps_id,
}
elif m:
label = "%(gramps_id)s : %(mother)s" % {
'mother' : _nd.display(m),
'gramps_id' : family.gramps_id,
}
else:
# No translation for bare gramps_id
label = "%(gramps_id)s :" % {
'gramps_id' : family.gramps_id,
}
return label
def family_label(self, family):
"""
Create the family label depending on existence of the father and mother
"""
if family is None:
return "Unknown"
father = mother = None
hdl = family.get_father_handle()
if hdl:
father = self.dbstate.db.get_person_from_handle(hdl)
hdl = family.get_mother_handle()
if hdl:
mother = self.dbstate.db.get_person_from_handle(hdl)
if father and mother:
label = _("%(gramps_id)s : %(father)s and %(mother)s") % {
'father' : _nd.display(father),
'mother' : _nd.display(mother),
'gramps_id' : family.gramps_id,
}
elif father:
label = "%(gramps_id)s : %(father)s" % {
'father' : _nd.display(father),
'gramps_id' : family.gramps_id,
}
elif mother:
label = "%(gramps_id)s : %(mother)s" % {
'mother' : _nd.display(mother),
'gramps_id' : family.gramps_id,
}
else:
# No translation for bare gramps_id
label = "%(gramps_id)s :" % {
'gramps_id' : family.gramps_id,
}
return label
def __process_family_2(self, family, person1, person2):
missingbits = []
if person1 is UnknownPerson or person1 is None:
name1 = _("(unknown person)")
else:
name1 = name_displayer.display(person1)
if not name1:
name1 = _("(person with unknown name)")
if person2 is UnknownPerson or person2 is None:
name2 = _("(unknown person)")
else:
name2 = name_displayer.display(person2)
if not name2:
name2 = _("(person with unknown name)")
name = _("%(name1)s and %(name2)s") % {
'name1': name1,
'name2': name2}
if self.__family_complete_handle is not None and \
self.__family_complete_handle not in family.get_tag_list():
missingbits.append(_("family not complete"))
if missingbits:
self.link(name, 'Family', family.get_handle())
self.append_text(_(": %(list)s\n") % {
'list': _(", ").join(missingbits)})
self.__counter += 1
def update_parent_label(self):
handle = self.obj.get_family_handle()
if handle:
family = self.dbstate.db.get_family_from_handle(handle)
f = self.dbstate.db.get_person_from_handle(
family.get_father_handle())
m = self.dbstate.db.get_person_from_handle(
family.get_mother_handle())
if f and m:
label = _("%(father)s and %(mother)s [%(gramps_id)s]") % {
'father' : name_displayer.display(f),
'mother' : name_displayer.display(m),
'gramps_id' : family.gramps_id,
}
elif f:
label = _("%(father)s [%(gramps_id)s]") % {
'father' : name_displayer.display(f),
'gramps_id' : family.gramps_id,
}
elif m:
label = _("%(mother)s [%(gramps_id)s]") % {
'mother' : name_displayer.display(m),
'gramps_id' : family.gramps_id,
}
else:
# No translation for bare gramps_id
label = "[%(gramps_id)s]" % {
'gramps_id' : family.gramps_id,
}
else:
label = ""
self.parents.set_text(label)
def display_parents(self, active_person):
"""
Display the parents of the active person.
"""
family_handle = active_person.get_main_parents_family_handle()
if family_handle:
family = self.dbstate.db.get_family_from_handle(family_handle)
handle = family.get_father_handle()
if handle:
father = self.dbstate.db.get_person_from_handle(handle)
father_name = name_displayer.display(father)
else:
father_name = _('Unknown')
handle = family.get_mother_handle()
if handle:
mother = self.dbstate.db.get_person_from_handle(handle)
mother_name = name_displayer.display(mother)
else:
mother_name = _('Unknown')
else:
father_name = _('Unknown')
mother_name = _('Unknown')
self.add_row(_('Father'), father_name)
self.add_row(_('Mother'), mother_name)
def _createmap_for_one_family(self, family, color, place_list, reference):
"""
Create all markers for one family : all event's places with a lat/lon.
"""
dbstate = self.dbstate
person = None
try:
person = dbstate.db.get_person_from_handle(family.get_father_handle())
except:
return
family_id = family.gramps_id
if person is None: # family without father ?
handle = family.get_mother_handle()
if handle:
person = dbstate.db.get_person_from_handle(handle)
if person is None:
handle = self.uistate.get_active('Person')
if handle:
person = dbstate.db.get_person_from_handle(handle)
if person is not None:
family_list = person.get_family_handle_list()
if len(family_list) > 0:
fhandle = family_list[0] # first is primary
fam = dbstate.db.get_family_from_handle(fhandle)
father = mother = None
handle = fam.get_father_handle()
if handle:
father = dbstate.db.get_person_from_handle(handle)
if father:
comment = _("Father : %(id)s : %(name)s") % {'id': father.gramps_id,
'name': _nd.display(father)}
self._createmap_for_one_person(father, color, place_list, reference)
handle = fam.get_mother_handle()
if handle:
mother = dbstate.db.get_person_from_handle(handle)
if mother:
comment = _("Mother : %(id)s : %(name)s") % {'id': mother.gramps_id,
'name': _nd.display(mother)}
self._createmap_for_one_person(mother, color, place_list, reference)
index = 0
child_ref_list = fam.get_child_ref_list()
if child_ref_list:
for child_ref in child_ref_list:
child = dbstate.db.get_person_from_handle(child_ref.ref)
if child:
index += 1
comment = _("Child : %(id)s - %(index)d "
": %(name)s") % {
'id' : child.gramps_id,
'index' : index,
'name' : _nd.display(child)
}
self._createmap_for_one_person(child, color, place_list, reference)
else:
comment = _("Person : %(id)s %(name)s has no family.") % {
'id' : person.gramps_id ,
'name' : _nd.display(person)
}
self._createmap_for_one_person(person, color, place_list, reference)
def _write_family(self, family_handle):
"""
Generate a table row for this family record
"""
family = self.database.get_family_from_handle(family_handle)
self.doc.start_row()
self.doc.start_cell("TR-TableCell")
self.doc.start_paragraph("TR-Normal")
self.doc.write_text(family.get_gramps_id())
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("TR-TableCell")
self.doc.start_paragraph("TR-Normal")
father_handle = family.get_father_handle()
if father_handle:
father = self.database.get_person_from_handle(father_handle)
mark = ReportUtils.get_person_mark(self.database, father)
self.doc.write_text(name_displayer.display(father), mark)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("TR-TableCell")
self.doc.start_paragraph("TR-Normal")
mother_handle = family.get_mother_handle()
if mother_handle:
mother = self.database.get_person_from_handle(mother_handle)
mark = ReportUtils.get_person_mark(self.database, mother)
self.doc.write_text(name_displayer.display(mother), mark)
self.doc.end_paragraph()
self.doc.end_cell()
# see if we can find a relationship event to include
relationship_date = _PLACEHOLDER
for evt_ref in family.get_event_ref_list():
evt_handle = evt_ref.get_reference_handle()
evt = self.database.get_event_from_handle(evt_handle)
# FIXME: where are the event types defined in Gramps,
# and are these the only important ones?
# print repr(evt.get_type().string)
if evt.get_type().string in ["Marriage", "Civil Union"]:
relationship_date = gramps.gen.datehandler.get_date(evt)
rel_msg = _("%(relationship_type)s on %(relationship_date)s") % {
"relationship_type": family.get_relationship(),
"relationship_date": relationship_date,
}
self.doc.start_cell("TR-TableCell")
self.doc.start_paragraph("TR-Normal")
self.doc.write_text(rel_msg)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def write_report(self):
self.doc.start_paragraph("LOD-Title")
self.doc.write_text(_("Lines of Descendency from %(ancestor)s to"
" %(descendent)s" % { 'ancestor' : _nd.display(self.ancestor),
'descendent' : _nd.display(self.descendent) }))
self.doc.end_paragraph()
self.line = 1
self.traverse(self.ancestor.get_handle())
def _get_subject(options, dbase):
"""
Attempts to determine the subject of a set of options. The subject would
likely be a person (using a PersonOption) or a filter (using a
FilterOption)
options: The ReportOptions class
dbase: the database for which it corresponds
"""
if not hasattr(options, "menu"):
return ""
menu = options.menu
option_names = menu.get_all_option_names()
if not option_names:
return _("Entire Database")
for name in option_names:
option = menu.get_option_by_name(name)
if isinstance(option, FilterOption):
return option.get_filter().get_name()
elif isinstance(option, PersonOption):
gid = option.get_value()
person = dbase.get_person_from_gramps_id(gid)
return _nd.display(person)
elif isinstance(option, FamilyOption):
family = dbase.get_family_from_gramps_id(option.get_value())
if not family:
return ""
family_id = family.get_gramps_id()
fhandle = family.get_father_handle()
mhandle = family.get_mother_handle()
if fhandle:
father = dbase.get_person_from_handle(fhandle)
father_name = _nd.display(father)
else:
father_name = _("unknown father")
if mhandle:
mother = dbase.get_person_from_handle(mhandle)
mother_name = _nd.display(mother)
else:
mother_name = _("unknown mother")
name = _("%(father)s and %(mother)s (%(id)s)") % {
'father' : father_name,
'mother' : mother_name,
'id' : family_id }
return name
return ""
def get_menu_title(self):
if self.obj and self.obj.get_handle():
name = name_displayer.display(self.obj)
title = _('Person: %(name)s') % {'name': name}
else:
name = name_displayer.display(self.obj)
if name:
title = _('New Person: %(name)s') % {'name': name}
else:
title = _('New Person')
return title
def get_menu_title(self):
if self.obj and self.obj.get_handle():
name = name_displayer.display(self.obj)
title = _("Person: %(name)s") % {"name": name}
else:
name = name_displayer.display(self.obj)
if name:
title = _("New Person: %(name)s") % {"name": name}
else:
title = _("New Person")
return title
def __rec_fill_data(self, gen, person, pos):
"""
Recursively fill in the data
"""
totdesc = 0
nrfam = len(person.get_family_handle_list())
self.gen2people[gen][pos][6] = nrfam
for family_handle in person.get_family_handle_list():
totdescfam = 0
family = self.dbstate.db.get_family_from_handle(family_handle)
spouse_handle = find_spouse(person, family)
if spouse_handle:
spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
spname = name_displayer.display(spouse)
else:
spname = ''
spouse = None
if family_handle in self.famhandle2desc:
#family occurs via father and via mother in the chart, only
#first to show and count.
famdup = True
else:
famdup = False
# family, duplicate or not, start angle, slice size,
# text, spouse pos in gen, nrchildren, userdata, parnter, status
self.gen2fam[gen].append([family, famdup, 0, 0, spname, pos, 0, [],
spouse, NORMAL])
posfam = len(self.gen2fam[gen]) - 1
if not famdup:
nrchild = len(family.get_child_ref_list())
self.gen2fam[gen][-1][6] = nrchild
for child_ref in family.get_child_ref_list():
child = self.dbstate.db.get_person_from_handle(child_ref.ref)
chname = name_displayer.display(child)
if child_ref.ref in self.handle2desc:
dup = True
else:
dup = False
self.handle2desc[child_ref.ref] = 0
# person, duplicate or not, start angle, slice size,
# text, parent pos in fam, nrfam, userdata, status
self.gen2people[gen+1].append([child, dup, 0, 0, chname,
posfam, 0, [], NORMAL])
totdescfam += 1 #add this person as descendant
pospers = len(self.gen2people[gen+1]) - 1
if not dup and not(self.generations == gen+2):
nrdesc = self.__rec_fill_data(gen+1, child, pospers)
self.handle2desc[child_ref.ref] += nrdesc
totdescfam += nrdesc # add children of him as descendants
self.famhandle2desc[family_handle] = totdescfam
totdesc += totdescfam
return totdesc
def write_path(self, path):
gen = 1
handle = path[0]
next_person = self.database.get_person_from_handle(path[0])
self.doc.start_paragraph('LOD-Line')
self.doc.write_text('%(line)s. line:' % { 'line': self.line })
self.doc.end_paragraph()
self.line +=1
for next_handle in path[1:]:
person = next_person
next_person = self.database.get_person_from_handle(next_handle)
name = _nd.display(person)
family_handle = next_person.get_main_parents_family_handle()
family = self.database.get_family_from_handle(family_handle)
mother = family.get_mother_handle()
spouse_handle = \
mother if mother != handle \
else family.get_father_handle()
handle = next_handle
spouse = self.database.get_person_from_handle(spouse_handle)
if spouse:
spouse_name = _nd.display(spouse)
else:
spouse_name = 'N.N.'
if family.get_relationship() == FamilyRelType.MARRIED:
abbrev = 'm.'
else:
abbrev = 'rw.'
self.doc.start_paragraph("LOD-Entry")
self.doc.write_text("%(gen)s. %(person)s %(abbrev)s %(spouse)s" % {
'gen' : gen,
'person' : name,
'abbrev' : abbrev,
'spouse' : spouse_name
})
self.doc.end_paragraph()
gen += 1
self.doc.start_paragraph("LOD-Entry")
self.doc.write_text("%(gen)s. %(person)s" % {
'gen' : gen,
'person' : _nd.display(next_person)
})
self.doc.end_paragraph()
def __process_family(self, family, person1, person2, append_list):
if family.get_handle() in self.__processed_families:
return
self.__processed_families[family.get_handle()] = True
missingbits = []
if person1 is UnknownPerson or person1 is None:
name1 = _("(unknown person)")
else:
name1 = name_displayer.display(person1)
if not name1:
name1 = _("(person with unknown name)")
if person2 is UnknownPerson or person2 is None:
name2 = _("(unknown person)")
else:
name2 = name_displayer.display(person2)
if not name2:
name2 = _("(person with unknown name)")
name = _("%(name1)s and %(name2)s") % {
'name1': name1,
'name2': name2}
has_marriage = False
for event_ref in family.get_event_ref_list():
event = self.dbstate.db.get_event_from_handle(event_ref.ref)
if event.get_type() not in [EventType.MARRIAGE, EventType.DIVORCE]:
continue
missingbits.extend(self.__process_event(event))
if event.get_type() == EventType.MARRIAGE:
has_marriage = True
if family.get_relationship() == FamilyRelType.MARRIED:
if not has_marriage:
missingbits.append(_("marriage event missing"))
elif family.get_relationship() == FamilyRelType.UNKNOWN:
missingbits.append(_("relation type unknown"))
if missingbits:
self.link(name, 'Family', family.get_handle())
self.append_text(_(": %(list)s\n") % {
'list': _(", ").join(missingbits)})
self.__counter += 1
append_list.append((family, person1, person2))
def _createmap_for_one_family(self, family):
"""
Create all markers for one family : all event's places with a lat/lon.
"""
dbstate = self.dbstate
self.message_layer.add_message(_("Family places for %s") % self.family_label(family))
try:
person = dbstate.db.get_person_from_handle(family.get_father_handle())
except:
return
family_id = family.gramps_id
if person is None: # family without father ?
person = dbstate.db.get_person_from_handle(family.get_mother_handle())
if person is None:
person = dbstate.db.get_person_from_handle(self.uistate.get_active("Person"))
if person is not None:
family_list = person.get_family_handle_list()
if len(family_list) > 0:
fhandle = family_list[0] # first is primary
fam = dbstate.db.get_family_from_handle(fhandle)
handle = fam.get_father_handle()
father = dbstate.db.get_person_from_handle(handle)
if father:
comment = _("Father : %(id)s : %(name)s") % {"id": father.gramps_id, "name": _nd.display(father)}
self._createpersonmarkers(dbstate, father, comment, family_id)
handle = fam.get_mother_handle()
mother = dbstate.db.get_person_from_handle(handle)
if mother:
comment = _("Mother : %(id)s : %(name)s") % {"id": mother.gramps_id, "name": _nd.display(mother)}
self._createpersonmarkers(dbstate, mother, comment, family_id)
index = 0
child_ref_list = fam.get_child_ref_list()
if child_ref_list:
for child_ref in child_ref_list:
child = dbstate.db.get_person_from_handle(child_ref.ref)
if child:
index += 1
comment = _("Child : %(id)s - %(index)d " ": %(name)s") % {
"id": child.gramps_id,
"index": index,
"name": _nd.display(child),
}
self._createpersonmarkers(dbstate, child, comment, family_id)
else:
comment = _("Person : %(id)s %(name)s has no family.") % {
"id": person.gramps_id,
"name": _nd.display(person),
}
self._createpersonmarkers(dbstate, person, comment, family_id)
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
self.label = _("Associations state tool")
tool.Tool.__init__(self, dbstate, options_class, name)
if uistate:
ManagedWindow.__init__(self,uistate,[],
self.__class__)
stats_list = []
plist = dbstate.db.get_person_handles(sort_handles=True)
for handle in plist:
person = dbstate.db.get_person_from_handle(handle)
name1 = name_displayer.display(person)
refs = person.get_person_ref_list()
if refs:
for ref in person.serialize()[-1]:
(a, b, c, two, value) = ref
person2 = dbstate.db.get_person_from_handle(two)
name2 = name_displayer.display(person2)
stats_list.append((name1, value, name2))
if uistate:
titles = [
(_('Name'), 0, 200),
(_('Type of link'), 1, 200),
(_('Of'), 2, 200),
]
treeview = Gtk.TreeView()
model = ListModel(treeview, titles)
for entry in stats_list:
model.add(entry, entry[0])
window = Gtk.Window()
window.set_default_size(800, 600)
s = Gtk.ScrolledWindow()
s.add(treeview)
window.add(s)
window.show_all()
self.set_window(window, None, self.label)
self.show()
else:
print('\t%s'*3 % ('Name','Type of link','Of'))
print()
for entry in stats_list:
print('\t%s'*3 % entry)
def goto_handle(self, handle=None):
"""
Rebuild the tree with the given person handle as the root.
"""
self.place_list_active = []
self.place_list_ref = []
self.all_place_list = []
self.sort = []
self.places_found = []
self.nbmarkers = 0
self.nbplaces = 0
self.place_without_coordinates = []
self.remove_all_gps()
self.remove_all_markers()
self.lifeway_layer.clear_ways()
self.message_layer.clear_messages()
active = self.get_active()
if active:
indiv1 = self.dbstate.db.get_person_from_handle(active)
color = self._config.get('geography.color2')
self._createmap(indiv1, color, self.place_list_active, False)
if self.refperson:
color = self._config.get('geography.color1')
self.message_layer.add_message(
_("Reference : %(name)s ( %(birth)s - %(death)s )") % {
'name': _nd.display(self.refperson),
'birth': self.birth(self.refperson),
'death': self.death(self.refperson)})
if indiv1:
self.message_layer.add_message(
_("The other : %(name)s ( %(birth)s - %(death)s )") % {
'name': _nd.display(indiv1),
'birth': self.birth(indiv1),
'death': self.death(indiv1)})
else:
self.message_layer.add_message(_("The other person is unknown"))
self._createmap(self.refperson, color, self.place_list_ref, True)
if self.refperson_bookmark is None:
self.refperson_bookmark = self.refperson.get_handle()
self.add_bookmark_from_popup(None, self.refperson_bookmark)
else:
self.message_layer.add_message(
_("You must choose one reference person."))
self.message_layer.add_message(_("Go to the person view and select "
"the people you want to compare. "
"Return to this view and use the"
" history."))
self.possible_meeting(self.place_list_ref, self.place_list_active)
self.uistate.modify_statusbar(self.dbstate)
def log(self, ltype, action, handles):
for handle in set(handles):
if self.last_log == (ltype, action, handle):
continue
self.last_log = (ltype, action, handle)
self.timestamp()
# translators: needed for French, ignore otherwise
self.append_text(_("%s: ") % _(action))
if action == 'Deleted':
transaction = self.dbstate.db.transaction
if ltype == 'Person':
name = 'a person'
if transaction is not None:
for i in transaction.get_recnos(reverse=True):
(obj_type, trans_type, hndl, old_data, dummy) = \
transaction.get_record(i)
if isinstance(hndl, bytes):
hndl = str(hndl, "utf-8")
if (obj_type == PERSON_KEY and trans_type == TXNDEL
and hndl == handle):
person = Person()
person.unserialize(old_data)
name = name_displayer.display(person)
break
elif ltype == 'Family':
name = 'a family'
if transaction is not None:
for i in transaction.get_recnos(reverse=True):
(obj_type, trans_type, hndl, old_data, dummy) = \
transaction.get_record(i)
if isinstance(hndl, bytes):
hndl = str(hndl, "utf-8")
if (obj_type == FAMILY_KEY and trans_type == TXNDEL
and hndl == handle):
family = Family()
family.unserialize(old_data)
name = family_name(family, self.dbstate.db, name)
break
self.append_text(name)
else:
if ltype == 'Person':
person = self.dbstate.db.get_person_from_handle(handle)
name = name_displayer.display(person)
elif ltype == 'Family':
family = self.dbstate.db.get_family_from_handle(handle)
name = family_name(family, self.dbstate.db, 'a family')
self.link(name, ltype, handle)
self.append_text("\n")
def refresh_list(self):
self.treestore.clear()
for (i, region) in enumerate(self.regions, start=1):
name = name_displayer.display(region.person) if region.person else ""
thumbnail = self.selection_widget.get_thumbnail(region,
THUMBNAIL_IMAGE_SIZE)
self.treestore.append(None, (i, thumbnail, name))
def ok_clicked(self, obj):
name = name_displayer.display(self.person)
msg = _("Reorder Relationships: %s") % name
with DbTxn(msg, self.dbstate.db) as trans:
self.dbstate.db.commit_person(self.person, trans)
self.close()
def populate_gui(self, event):
"""
Populate the model.
"""
person_list = []
for item in self.db.find_backlink_handles(event.get_handle(),
include_classes=['Person']):
handle = item[1]
person = self.db.get_person_from_handle(handle)
for event_ref in person.get_event_ref_list():
if (event_ref.ref == event.get_handle() and
event_ref.get_role() == self.role):
self.initial_people.append(handle)
attrs = {}
order = 0
for attr in event_ref.get_attribute_list():
attr_type = str(attr.get_type())
if attr_type == ORDER_ATTR:
order = int(attr.get_value())
else:
attrs[attr_type] = attr.get_value()
name = name_displayer.display(person)
person_list.append([order, handle, name, attrs])
person_list.sort()
for person_data in person_list:
row = person_data[1:2] # handle
for attr in self.columns:
if attr == _('Name'):
row.append(person_data[3].get(attr, person_data[2]))
else:
row.append(person_data[3].get(attr))
self.model.append(tuple(row))
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 add_to_tree(self, parent_id, person_handle):
person = self.dbstate.db.get_person_from_handle(person_handle)
name = name_displayer.display(person)
birth = get_birth_or_fallback(self.dbstate.db, person)
death = get_death_or_fallback(self.dbstate.db, person)
birth_text = birth_date = birth_sort = ''
if birth:
birth_date = get_date(birth)
birth_sort = '%012d' % birth.get_date_object().get_sort_value()
birth_text = _('%(abbr)s %(date)s') % \
{'abbr': birth.type.get_abbreviation(),
'date': birth_date}
death_date = death_sort = death_text = ''
if death:
death_date = get_date(death)
death_sort = '%012d' % death.get_date_object().get_sort_value()
death_text = _('%(abbr)s %(date)s') % \
{'abbr': death.type.get_abbreviation(),
'date': death_date}
tooltip = name + '\n' + birth_text + '\n' + death_text
item_id = self.model.add([name, birth_date, birth_sort,
tooltip, person_handle], node=parent_id)
for family_handle in person.get_family_handle_list():
family = self.dbstate.db.get_family_from_handle(family_handle)
for child_ref in family.get_child_ref_list():
self.add_to_tree(item_id, child_ref.ref)
return item_id
def call_edit_childref(self, ref):
p = self.dbstate.db.get_person_from_handle(ref.ref)
n = name_displayer.display(p)
try:
EditChildRef(n, self.dbstate, self.uistate, self.track, ref, self.child_ref_edited)
except WindowActiveError:
pass
def get_data(self):
if not self._data or self.changed:
self._data = [self.obj.get_event_ref_list()]
self._groups = [(self.obj.get_handle(), self._WORKNAME, '')]
# own family events
family_handle_list = self.obj.get_family_handle_list()
if family_handle_list:
for family_handle in family_handle_list:
family = self.dbstate.db.get_family_from_handle(family_handle)
if family is None:
continue
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
if self.obj.get_handle() == father_handle:
handlepartner = mother_handle
else:
handlepartner = father_handle
if handlepartner:
partner = self.dbstate.db.get_person_from_handle(
handlepartner)
groupname = name_displayer.display(partner)
else:
groupname = self._UNKNOWNNAME
self._data.append(family.get_event_ref_list())
self._groups.append((family_handle, self._FAMNAME,
groupname))
self.changed = False
return self._data
def prepare_context_menu(self):
selected = self.selection_widget.get_current()
self.context_button_add.set_sensitive(selected is not None)
self.context_button_select.set_sensitive(selected is not None)
self.context_button_clear.set_sensitive(
selected is not None and selected.person is not None)
self.context_button_remove.set_sensitive(selected is not None)
# clear temporary items
for item in self.additional_items:
self.context_menu.remove(item)
self.additional_items = []
# populate the context menu
persons = self.all_referenced_persons()
if selected.person is not None:
persons.remove(selected.person)
if persons:
self.additional_items.append(Gtk.SeparatorMenuItem())
sorted_persons = sorted(list(persons), key=name_displayer.display)
for person in sorted_persons:
item = Gtk.MenuItem(
_("Replace {0}").format(name_displayer.display(person)))
item.connect("activate", self.replace_reference, person)
self.additional_items.append(item)
for item in self.additional_items:
self.context_menu.append(item)
def save(self, trans):
"""
Save the census details to the database.
"""
# Update people on the census
all_people = []
for order, row in enumerate(self.model):
all_people.append(row[0])
person = self.db.get_person_from_handle(row[0])
event_ref = self.get_census_event_ref(person)
if event_ref is None:
# Add new link to census
event_ref = EventRef()
event_ref.ref = self.event.get_handle()
event_ref.set_role(EventRoleType.PRIMARY)
person.add_event_ref(event_ref)
# Write attributes
attrs = event_ref.get_attribute_list()
set_attribute(event_ref, attrs, ORDER_ATTR, str(order + 1))
for offset, name in enumerate(self.columns):
value = row[offset + 1]
if name == _('Name'):
if value != name_displayer.display(person):
set_attribute(event_ref, attrs, name, value)
else:
set_attribute(event_ref, attrs, name, value)
self.db.commit_person(person, trans)
# Remove links to people no longer on census
for handle in (set(self.initial_people) - set(all_people)):
person = self.db.get_person_from_handle(handle)
ref_list = [event_ref for event_ref in person.get_event_ref_list()
if event_ref.ref != self.event.handle]
person.set_event_ref_list(ref_list)
self.db.commit_person(person, trans)
def _createmap(self, person):
"""
Create all markers for each family's person in the database which has
a lat/lon.
"""
dbstate = self.dbstate
self.cal = config.get('preferences.calendar-format-report')
self.place_list = []
self.person_list = []
self.count = dict()
self.place_without_coordinates = []
self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0
latitude = ""
longitude = ""
self.message_layer.clear_messages()
self.place_without_coordinates = []
self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0
if person is None:
person = self.dbstate.db.get_person_from_handle(self.uistate.get_active('Person'))
if not person:
return
self.message_layer.add_message(_("All descendance for %s") % _nd.display(person))
color = Gdk.color_parse(self._config.get('geography.color_base'))
GLib.timeout_add(int(self._config.get("geography.generation_interval")),
self.animate_moves, 0, person, color)
def ask_and_set_person(self, region, person):
if region and person:
other_references = self.regions_referencing_person(person)
ref_count = len(other_references)
if ref_count > 0:
person = other_references[0].person
if REPLACE_WITHOUT_ASKING:
self.delete_regions(other_references)
else:
if ref_count == 1:
message_text = _("Another region of this image is associated with {name}. Remove it?")
else:
message_text = _("{count} other regions of this image are associated with {name}. Remove them?")
message = message_text.format(
name=name_displayer.display(person),
count=ref_count)
dialog = Gtk.MessageDialog(
parent=None,
type=Gtk.MessageType.QUESTION,
buttons=Gtk.ButtonsType.YES_NO,
message_format=message)
response = dialog.run()
dialog.destroy()
if response == Gtk.ResponseType.YES:
self.delete_regions(other_references)
self.set_person(region, person)
def descendants(self, person_handle, pset):
"""
Find the descendants of a given person.
Returns False if a loop for the person is NOT found, True if loop found
We use the return value to ensure a person is not put on done list if
part of a loop
"""
if person_handle in self.done:
return False # We have already verified no loops for this one
if person_handle in pset:
# We found one loop.
# person_handle is child, self.parent, self.curr_fam valid
# see if it has already been put into display
person = self.db.get_person_from_handle(person_handle)
pers_id = person.get_gramps_id()
pers_name = _nd.display(person)
parent_id = self.parent.get_gramps_id()
parent_name = _nd.display(self.parent)
value = (parent_id, parent_name, pers_id, pers_name, self.curr_fam)
found = False
for pth in range(len(self.model)):
path = Gtk.TreePath(pth)
treeiter = self.model.get_iter(path)
find = (self.model.get_value(treeiter, 0),
self.model.get_value(treeiter, 1),
self.model.get_value(treeiter, 2),
self.model.get_value(treeiter, 3),
self.model.get_value(treeiter, 4))
if find == value:
found = True # This loop is in display model
break
if not found:
# Need to put loop in display model.
self.loop += 1
# place first node
self.model.append(value + (str(self.loop), ))
state = 0
# Now search for loop beginning.
for hndl in pset.keys():
if hndl != person_handle and state == 0:
continue # beginning not found
if state == 0:
state = 1 # found beginning, get first item to display
continue
# we have a good handle, now put item on display list
self.parent = person
person = self.db.get_person_from_handle(hndl)
# Get the family that is both parent/person
for fam_h in person.get_parent_family_handle_list():
if fam_h in self.parent.get_family_handle_list():
break
family = self.db.get_family_from_handle(fam_h)
fam_id = family.get_gramps_id()
pers_id = person.get_gramps_id()
pers_name = _nd.display(person)
parent_id = self.parent.get_gramps_id()
parent_name = _nd.display(self.parent)
value = (parent_id, parent_name, pers_id, pers_name,
fam_id, str(self.loop))
self.model.append(value)
return True
# We are not part of loop (yet) so search descendents
person = self.db.get_person_from_handle(person_handle)
# put in the pset path list for recursive calls to find
pset[person_handle] = None
loop = False
for family_handle in person.get_family_handle_list():
family = self.db.get_family_from_handle(family_handle)
if not family:
# can happen with LivingProxyDb(PrivateProxyDb(db))
continue
for child_ref in family.get_child_ref_list():
child_handle = child_ref.ref
self.curr_fam = family.get_gramps_id()
self.parent = person
# if any descendants are part of loop, so is search person
loop |= self.descendants(child_handle, pset)
# we have completed search, we can pop the person off pset list
person_handle, dummy = pset.popitem(last=True)
if not loop:
# person was not in loop, so add to done list and update progress
self.done.add(person_handle)
self.count += 1
self.progress.set_header("%d/%d" % (self.count, self.total))
self.progress.step()
return False
# person was in loop...
return True
def __init__(self, dbstate, uistate, handle1, handle2):
ManagedWindow.__init__(self, uistate, [], self.__class__)
self.database = dbstate.db
self.fy1 = self.database.get_family_from_handle(handle1)
self.fy2 = self.database.get_family_from_handle(handle2)
self.define_glade('mergefamily', _GLADE_FILE)
self.set_window(self._gladeobj.toplevel,
self.get_widget("family_title"),
_("Merge Families"))
# Detailed selection widgets
father1 = self.fy1.get_father_handle()
father2 = self.fy2.get_father_handle()
father1 = self.database.get_person_from_handle(father1)
father2 = self.database.get_person_from_handle(father2)
father_id1 = father1.get_gramps_id() if father1 else ""
father_id2 = father2.get_gramps_id() if father2 else ""
father1 = name_displayer.display(father1) if father1 else ""
father2 = name_displayer.display(father2) if father2 else ""
entry1 = self.get_widget("father1")
entry2 = self.get_widget("father2")
entry1.set_text("%s [%s]" % (father1, father_id1))
entry2.set_text("%s [%s]" % (father2, father_id2))
deactivate = False
if father_id1 == "" and father_id2 == "":
deactivate = True
elif father_id2 == "":
self.get_widget("father_btn1").set_active(True)
deactivate = True
elif father_id1 == "":
self.get_widget("father_btn2").set_active(True)
deactivate = True
elif entry1.get_text() == entry2.get_text():
deactivate = True
if deactivate:
for widget_name in ('father1', 'father2', 'father_btn1',
'father_btn2'):
self.get_widget(widget_name).set_sensitive(False)
mother1 = self.fy1.get_mother_handle()
mother2 = self.fy2.get_mother_handle()
mother1 = self.database.get_person_from_handle(mother1)
mother2 = self.database.get_person_from_handle(mother2)
mother_id1 = mother1.get_gramps_id() if mother1 else ""
mother_id2 = mother2.get_gramps_id() if mother2 else ""
mother1 = name_displayer.display(mother1) if mother1 else ""
mother2 = name_displayer.display(mother2) if mother2 else ""
entry1 = self.get_widget("mother1")
entry2 = self.get_widget("mother2")
entry1.set_text("%s [%s]" % (mother1, mother_id1))
entry2.set_text("%s [%s]" % (mother2, mother_id2))
deactivate = False
if mother_id1 == "" and mother_id2 == "":
deactivate = True
elif mother_id1 == "":
self.get_widget("mother_btn2").set_active(True)
deactivate = True
elif mother_id2 == "":
self.get_widget("mother_btn1").set_active(True)
deactivate = True
elif entry1.get_text() == entry2.get_text():
deactivate = True
if deactivate:
for widget_name in ('mother1', 'mother2', 'mother_btn1',
'mother_btn2'):
self.get_widget(widget_name).set_sensitive(False)
entry1 = self.get_widget("rel1")
entry2 = self.get_widget("rel2")
entry1.set_text(str(self.fy1.get_relationship()))
entry2.set_text(str(self.fy2.get_relationship()))
if entry1.get_text() == entry2.get_text():
for widget_name in ('rel1', 'rel2', 'rel_btn1', 'rel_btn2'):
self.get_widget(widget_name).set_sensitive(False)
gramps1 = self.fy1.get_gramps_id()
gramps2 = self.fy2.get_gramps_id()
entry1 = self.get_widget("gramps1")
entry2 = self.get_widget("gramps2")
entry1.set_text(gramps1)
entry2.set_text(gramps2)
if entry1.get_text() == entry2.get_text():
for widget_name in ('gramps1', 'gramps2', 'gramps_btn1',
'gramps_btn2'):
self.get_widget(widget_name).set_sensitive(False)
# Main window widgets that determine which handle survives
rbutton1 = self.get_widget("handle_btn1")
rbutton_label1 = self.get_widget("label_handle_btn1")
rbutton_label2 = self.get_widget("label_handle_btn2")
add = _("and")
rbutton_label1.set_label("%s %s %s [%s]" %(father1, add, mother1, gramps1))
rbutton_label2.set_label("%s %s %s [%s]" %(father2, add, mother2, gramps2))
rbutton1.connect("toggled", self.on_handle1_toggled)
self.connect_button("family_help", self.cb_help)
self.connect_button("family_ok", self.cb_merge)
self.connect_button("family_cancel", self.close)
self.show()
def _createmap_for_one_event(self, event):
"""
Create all markers for each people's event in the database which has
a lat/lon.
"""
dbstate = self.dbstate
if self.nbplaces >= self._config.get("geography.max_places"):
return
descr1 = descr2 = ""
if event:
place_handle = event.get_place_handle()
eventyear = event.get_date_object().to_calendar(self.cal).get_year()
else:
place_handle = None
if place_handle:
place = dbstate.db.get_place_from_handle(place_handle)
if place:
descr1 = _pd.display(dbstate.db, place)
longitude = place.get_longitude()
latitude = place.get_latitude()
latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8")
# place.get_longitude and place.get_latitude return
# one string. We have coordinates when the two values
# contains non null string.
if longitude and latitude:
person_list = [
dbstate.db.get_person_from_handle(ref_handle)
for (ref_type, ref_handle) in
dbstate.db.find_backlink_handles(event.handle)
if ref_type == 'Person'
]
if person_list:
for person in person_list:
if descr2 == "":
descr2 = ("%s") % _nd.display(person)
else:
descr2 = ("%s - %s") % (descr2,
_nd.display(person))
else:
# family list ?
family_list = [
dbstate.db.get_family_from_handle(ref_handle)
for (ref_type, ref_handle) in
dbstate.db.find_backlink_handles(event.handle)
if ref_type == 'Family'
]
if family_list:
for family in family_list:
father = mother = None
hdle = family.get_father_handle()
if hdle:
father = dbstate.db.get_person_from_handle(
hdle)
hdle = family.get_mother_handle()
if hdle:
mother = dbstate.db.get_person_from_handle(
hdle)
descr2 = ("%(father)s - %(mother)s") % {
'father': _nd.display(father) if father is not None else "?",
'mother': _nd.display(mother) if mother is not None else "?"
}
else:
descr2 = _("incomplete or unreferenced event ?")
self._append_to_places_list(descr1, None,
None,
latitude, longitude,
descr2,
eventyear,
event.get_type(),
None, # person.gramps_id
place.gramps_id,
event.gramps_id,
None
)
def update_person(self, person):
if person:
self.obj.ref = person.get_handle()
self.person_label.set_text(name_displayer.display(person))
self._update_dnd_capability()
def person_change(self, handles):
# check to see if the handle matches the current object
if self.obj.ref in handles:
p = self.dbstate.db.get_person_from_handle(self.obj.ref)
self.name = name_displayer.display(p)
self.name_label.set_text(self.name)
def _createmap_for_one_family(self, family):
"""
Create all markers for one family : all event's places with a lat/lon.
"""
dbstate = self.dbstate
self.message_layer.add_message(
_("Family places for %s") % self.family_label(family))
person = None
if family:
person = dbstate.db.get_person_from_handle(
family.get_father_handle())
else:
return
family_id = family.gramps_id
if person is None: # family without father ?
handle = family.get_mother_handle()
if handle:
person = dbstate.db.get_person_from_handle(handle)
if person is None:
handle = self.uistate.get_active('Person')
if handle:
person = dbstate.db.get_person_from_handle(handle)
if person is not None:
family_list = person.get_family_handle_list()
if len(family_list) > 0:
fhandle = family_list[0] # first is primary
fam = dbstate.db.get_family_from_handle(fhandle)
father = mother = None
handle = fam.get_father_handle()
if handle:
father = dbstate.db.get_person_from_handle(handle)
if father:
comment = _("Father : %(id)s : %(name)s") % {
'id': father.gramps_id,
'name': _nd.display(father)}
self._createpersonmarkers(dbstate, father,
comment, family_id)
handle = fam.get_mother_handle()
if handle:
mother = dbstate.db.get_person_from_handle(handle)
if mother:
comment = _("Mother : %(id)s : %(name)s") % {
'id': mother.gramps_id,
'name': _nd.display(mother)}
self._createpersonmarkers(dbstate, mother,
comment, family_id)
index = 0
child_ref_list = fam.get_child_ref_list()
if child_ref_list:
for child_ref in child_ref_list:
child = dbstate.db.get_person_from_handle(child_ref.ref)
if child:
index += 1
comment = _("Child : %(id)s - %(index)d "
": %(name)s") % {
'id' : child.gramps_id,
'index' : index,
'name' : _nd.display(child)
}
self._createpersonmarkers(dbstate, child,
comment, family_id)
else:
comment = _("Person : %(id)s %(name)s has no family.") % {
'id' : person.gramps_id,
'name' : _nd.display(person)
}
self._createpersonmarkers(dbstate, person, comment, family_id)
def _createpersonmarkers(self, dbstate, person, comment, fam_id):
"""
Create all markers for the specified person.
"""
self.cal = config.get('preferences.calendar-format-report')
latitude = longitude = ""
if person:
# For each event, if we have a place, set a marker.
for event_ref in person.get_event_ref_list():
if not event_ref:
continue
role = event_ref.get_role()
event = dbstate.db.get_event_from_handle(event_ref.ref)
eyear = event.get_date_object().to_calendar(self.cal).get_year()
place_handle = event.get_place_handle()
if place_handle:
place = dbstate.db.get_place_from_handle(place_handle)
if place:
longitude = place.get_longitude()
latitude = place.get_latitude()
latitude, longitude = conv_lat_lon(latitude,
longitude, "D.D8")
descr = _pd.display(dbstate.db, place)
evt = EventType(event.get_type())
descr1 = _("%(eventtype)s : %(name)s") % {
'eventtype': evt,
'name': _nd.display(person)}
# place.get_longitude and place.get_latitude return
# one string. We have coordinates when the two values
# contains non null string.
if longitude and latitude:
if not self._present_in_places_list(2,
str(descr1 + descr + str(evt))):
self._append_to_places_list(descr,
str(descr1 + descr + str(evt)),
_nd.display(person),
latitude, longitude,
role, eyear,
event.get_type(),
person.gramps_id,
place.gramps_id,
event.gramps_id,
fam_id
)
else:
self._append_to_places_without_coord(
place.gramps_id, descr)
family_list = person.get_family_handle_list()
for family_hdl in family_list:
family = self.dbstate.db.get_family_from_handle(family_hdl)
if family is not None:
for event_ref in family.get_event_ref_list():
if event_ref:
event = dbstate.db.get_event_from_handle(
event_ref.ref)
role = event_ref.get_role()
if event.get_place_handle():
place_handle = event.get_place_handle()
if place_handle:
place = dbstate.db.get_place_from_handle(
place_handle)
if place:
longitude = place.get_longitude()
latitude = place.get_latitude()
(latitude,
longitude) = conv_lat_lon(latitude,
longitude,
"D.D8")
descr = _pd.display(dbstate.db, place)
evt = EventType(event.get_type())
(father_name,
mother_name) = self._get_father_and_mother_name(event)
descr1 = "%s : %s - " % (evt,
father_name)
descr1 = "%s%s" % (descr1, mother_name)
eyear = event.get_date_object().to_calendar(self.cal).get_year()
if longitude and latitude:
if not self._present_in_places_list(
2, str(descr1 + descr + str(evt))):
self._append_to_places_list(
descr,
str(descr1 + descr + str(evt)),
_nd.display(person),
latitude, longitude,
role, eyear,
event.get_type(),
person.gramps_id,
place.gramps_id,
event.gramps_id,
family.gramps_id
)
else:
self._append_to_places_without_coord(place.gramps_id, descr)
def bubble_message(self, event, lat, lon, marks):
"""
Create the menu for the selected marker
"""
self.menu = Gtk.Menu()
menu = self.menu
menu.set_title("descendance")
events = []
message = ""
oldplace = ""
prevmark = None
# Be sure all markers are sorted by place then dates.
for mark in sorted(marks, key=operator.itemgetter(0,6)):
if mark[10] in events:
continue # avoid duplicate events
else:
events.append(mark[10])
if mark[0] != oldplace:
message = "%s :" % mark[0]
self.add_place_bubble_message(event, lat, lon,
marks, menu,
message, mark)
oldplace = mark[0]
message = ""
evt = self.dbstate.db.get_event_from_gramps_id(mark[10])
# format the date as described in preferences.
date = displayer.display(evt.get_date_object())
if date == "":
date = _("Unknown")
if ( mark[11] == EventRoleType.PRIMARY ):
person = self.dbstate.db.get_person_from_gramps_id(mark[1])
message = "(%s) %s : %s" % ( date, mark[2], _nd.display(person) )
elif ( mark[11] == EventRoleType.FAMILY ):
(father_name, mother_name) = self._get_father_and_mother_name(evt)
message = "(%s) %s : %s - %s" % (date, mark[2],
father_name,
mother_name )
else:
descr = evt.get_description()
if descr == "":
descr = _('No description')
message = "(%s) %s => %s" % ( date, mark[11], descr)
prevmark = mark
add_item = Gtk.MenuItem(label=message)
add_item.show()
menu.append(add_item)
self.itemoption = Gtk.Menu()
itemoption = self.itemoption
itemoption.set_title(message)
itemoption.show()
add_item.set_submenu(itemoption)
modify = Gtk.MenuItem(label=_("Edit Event"))
modify.show()
modify.connect("activate", self.edit_event,
event, lat, lon, prevmark)
itemoption.append(modify)
center = Gtk.MenuItem(label=_("Center on this place"))
center.show()
center.connect("activate", self.center_here,
event, lat, lon, prevmark)
itemoption.append(center)
person = self.dbstate.db.get_person_from_gramps_id(mark[8])
hdle = person.get_handle()
bookm = Gtk.MenuItem(label=_("Bookmark this person"))
bookm.show()
bookm.connect("activate", self.add_bookmark_from_popup, hdle)
itemoption.append(bookm)
menu.show()
menu.popup(None, None,
lambda menu, data: (event.get_root_coords()[0],
event.get_root_coords()[1], True),
None, event.button, event.time)
return 1
def _createmap_for_one_family(self, family, color, place_list, reference):
"""
Create all markers for one family : all event's places with a lat/lon.
"""
dbstate = self.dbstate
try:
person = dbstate.db.get_person_from_handle(
family.get_father_handle())
except:
return
family_id = family.gramps_id
if person is None: # family without father ?
person = dbstate.db.get_person_from_handle(
family.get_mother_handle())
if person is None:
person = dbstate.db.get_person_from_handle(
self.uistate.get_active('Person'))
if person is not None:
family_list = person.get_family_handle_list()
if len(family_list) > 0:
fhandle = family_list[0] # first is primary
fam = dbstate.db.get_family_from_handle(fhandle)
handle = fam.get_father_handle()
father = dbstate.db.get_person_from_handle(handle)
if father:
comment = _("Father : %(id)s : %(name)s") % {
'id': father.gramps_id,
'name': _nd.display(father)
}
self._createmap_for_one_person(father, color, place_list,
reference)
handle = fam.get_mother_handle()
mother = dbstate.db.get_person_from_handle(handle)
if mother:
comment = _("Mother : %(id)s : %(name)s") % {
'id': mother.gramps_id,
'name': _nd.display(mother)
}
self._createmap_for_one_person(mother, color, place_list,
reference)
index = 0
child_ref_list = fam.get_child_ref_list()
if child_ref_list:
for child_ref in child_ref_list:
child = dbstate.db.get_person_from_handle(
child_ref.ref)
if child:
index += 1
comment = _("Child : %(id)s - %(index)d "
": %(name)s") % {
'id': child.gramps_id,
'index': index,
'name': _nd.display(child)
}
self._createmap_for_one_person(
child, color, place_list, reference)
else:
comment = _("Person : %(id)s %(name)s has no family.") % {
'id': person.gramps_id,
'name': _nd.display(person)
}
self._createmap_for_one_person(person, color, place_list,
reference)
def init_report_options_help(self):
"""
Initialize help for the options that are defined by each report.
(And also any docgen options, if defined by the docgen.)
"""
if not hasattr(self.option_class, "menu"):
return
menu = self.option_class.menu
for name in menu.get_all_option_names():
option = menu.get_option_by_name(name)
self.options_help[name] = [ "", option.get_help() ]
if isinstance(option, PersonOption):
id_list = []
for person_handle in self.database.get_person_handles(True):
person = self.database.get_person_from_handle(person_handle)
id_list.append("%s\t%s" % (
person.get_gramps_id(),
name_displayer.display(person)))
self.options_help[name].append(id_list)
elif isinstance(option, FamilyOption):
id_list = []
for family in self.database.iter_families():
mname = ""
fname = ""
mhandle = family.get_mother_handle()
if mhandle:
mother = self.database.get_person_from_handle(mhandle)
if mother:
mname = name_displayer.display(mother)
fhandle = family.get_father_handle()
if fhandle:
father = self.database.get_person_from_handle(fhandle)
if father:
fname = name_displayer.display(father)
text = "%s:\t%s, %s" % \
(family.get_gramps_id(), fname, mname)
id_list.append(text)
self.options_help[name].append(id_list)
elif isinstance(option, NoteOption):
id_list = []
for nhandle in self.database.get_note_handles():
note = self.database.get_note_from_handle(nhandle)
id_list.append(note.get_gramps_id())
self.options_help[name].append(id_list)
elif isinstance(option, MediaOption):
id_list = []
for mhandle in self.database.get_media_object_handles():
mobject = self.database.get_object_from_handle(mhandle)
id_list.append(mobject.get_gramps_id())
self.options_help[name].append(id_list)
elif isinstance(option, PersonListOption):
self.options_help[name].append("")
elif isinstance(option, NumberOption):
self.options_help[name].append("A number")
elif isinstance(option, BooleanOption):
self.options_help[name].append(["False", "True"])
elif isinstance(option, DestinationOption):
self.options_help[name].append("A file system path")
elif isinstance(option, StringOption):
self.options_help[name].append("Any text")
elif isinstance(option, TextOption):
self.options_help[name].append(
"A list of text values. Each entry in the list "
"represents one line of text." )
elif isinstance(option, EnumeratedListOption):
ilist = []
for (value, description) in option.get_items():
ilist.append("%s\t%s" % (value, description))
self.options_help[name].append(ilist)
elif isinstance(option, Option):
self.options_help[name].append(option.get_help())
else:
print(_("Unknown option: %s") % option, file=sys.stderr)
print(_(" Valid options are:") +
", ".join(list(self.options_dict.keys())),
file=sys.stderr)
print(_(" Use '%(donottranslate)s' to see description "
"and acceptable values")
% {'donottranslate' : "show=option"},
file=sys.stderr)
def __init__(self, dbstate, user, options_class, name, callback=None):
uistate = user.uistate
"""
Relationship calculator class.
"""
tool.Tool.__init__(self, dbstate, options_class, name)
ManagedWindow.__init__(self,uistate,[],self.__class__)
#set the columns to see
for data in BasePersonView.CONFIGSETTINGS:
if data[0] == 'columns.rank':
colord = data[1]
elif data[0] == 'columns.visible':
colvis = data[1]
elif data[0] == 'columns.size':
colsize = data[1]
self.colord = []
for col, size in zip(colord, colsize):
if col in colvis:
self.colord.append((1, col, size))
else:
self.colord.append((0, col, size))
self.dbstate = dbstate
self.relationship = get_relationship_calculator(glocale)
self.relationship.connect_db_signals(dbstate)
self.glade = Glade()
self.person = self.db.get_person_from_handle(
uistate.get_active('Person'))
name = ''
if self.person:
name = name_displayer.display(self.person)
self.title = _('Relationship calculator: %(person_name)s'
) % {'person_name' : name}
window = self.glade.toplevel
self.titlelabel = self.glade.get_object('title')
self.set_window(window, self.titlelabel,
_('Relationship to %(person_name)s'
) % {'person_name' : name},
self.title)
self.setup_configs('interface.relcalc', 600, 400)
self.tree = self.glade.get_object("peopleList")
self.text = self.glade.get_object("text1")
self.textbuffer = Gtk.TextBuffer()
self.text.set_buffer(self.textbuffer)
self.model = PersonTreeModel(self.db)
self.tree.set_model(self.model)
self.tree.connect('key-press-event', self._key_press)
self.selection = self.tree.get_selection()
self.selection.set_mode(Gtk.SelectionMode.SINGLE)
#keep reference of column so garbage collection works
self.columns = []
for pair in self.colord:
if not pair[0]:
continue
name = column_names[pair[1]]
column = Gtk.TreeViewColumn(name, Gtk.CellRendererText(),
markup=pair[1])
column.set_resizable(True)
column.set_min_width(60)
column.set_sizing(Gtk.TreeViewColumnSizing.GROW_ONLY)
self.tree.append_column(column)
#keep reference of column so garbage collection works
self.columns.append(column)
self.sel = self.tree.get_selection()
self.changedkey = self.sel.connect('changed',self.on_apply_clicked)
self.closebtn = self.glade.get_object("button5")
self.closebtn.connect('clicked', self.close)
if not self.person:
self.window.hide()
ErrorDialog(_('Active person has not been set'),
_('You must select an active person for this '
'tool to work properly.'),
parent=uistate.window)
self.close()
return
self.show()
def person_name(self, person_handle):
if not person_handle: return ""
person = self.dbstate.db.get_person_from_handle(person_handle)
return name_displayer.display(person)
def _createmap(self):
"""
Create all markers for each people's event in the database which has
a lat/lon.
"""
dbstate = self.dbstate
self.cal = config.get('preferences.calendar-format-report')
self.place_list = []
self.place_without_coordinates = []
self.places_found = []
self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0
self.minyear = 9999
self.maxyear = 0
latitude = ""
longitude = ""
self.nbplaces = 0
self.nbmarkers = 0
self.message_layer.clear_messages()
self.kml_layer.clear()
person_handle = self.uistate.get_active('Person')
person = None
if person_handle:
person = dbstate.db.get_person_from_handle(person_handle)
if person is not None:
# For each event, if we have a place, set a marker.
self.load_kml_files(person)
self.message_layer.add_message(
_("Person places for %s") % _nd.display(person))
for event_ref in person.get_event_ref_list():
if not event_ref:
continue
event = dbstate.db.get_event_from_handle(event_ref.ref)
self.load_kml_files(event)
role = event_ref.get_role()
eyear = str("%04d" % event.get_date_object().to_calendar(self.cal).get_year()) + \
str("%02d" % event.get_date_object().to_calendar(self.cal).get_month()) + \
str("%02d" % event.get_date_object().to_calendar(self.cal).get_day())
place_handle = event.get_place_handle()
if place_handle:
place = dbstate.db.get_place_from_handle(place_handle)
if place:
longitude = place.get_longitude()
latitude = place.get_latitude()
latitude, longitude = conv_lat_lon(
latitude, longitude, "D.D8")
descr = _pd.display(dbstate.db, place)
evt = EventType(event.get_type())
descr1 = _("%(eventtype)s : %(name)s") % {
'eventtype': evt,
'name': _nd.display(person)
}
self.load_kml_files(place)
# place.get_longitude and place.get_latitude return
# one string. We have coordinates when the two values
# contains non null string.
if (longitude and latitude):
self._append_to_places_list(
descr, evt, _nd.display(person),
latitude, longitude, descr1, eyear,
event.get_type(), person.gramps_id,
place.gramps_id, event.gramps_id, role)
else:
self._append_to_places_without_coord(
place.gramps_id, descr)
family_list = person.get_family_handle_list()
for family_hdl in family_list:
family = self.dbstate.db.get_family_from_handle(family_hdl)
if family is not None:
fhandle = family_list[0] # first is primary
fam = dbstate.db.get_family_from_handle(fhandle)
father = mother = None
handle = fam.get_father_handle()
if handle:
father = dbstate.db.get_person_from_handle(handle)
descr1 = " - "
if father:
descr1 = "%s - " % _nd.display(father)
handle = fam.get_mother_handle()
if handle:
mother = dbstate.db.get_person_from_handle(handle)
if mother:
descr1 = "%s%s" % (descr1, _nd.display(mother))
for event_ref in family.get_event_ref_list():
if event_ref:
event = dbstate.db.get_event_from_handle(
event_ref.ref)
self.load_kml_files(event)
role = event_ref.get_role()
if event.get_place_handle():
place_handle = event.get_place_handle()
if place_handle:
place = dbstate.db.get_place_from_handle(
place_handle)
if place:
longitude = place.get_longitude()
latitude = place.get_latitude()
latitude, longitude = conv_lat_lon(
latitude, longitude, "D.D8")
descr = _pd.display(dbstate.db, place)
evt = EventType(event.get_type())
eyear = str("%04d" % event.get_date_object().to_calendar(self.cal).get_year()) + \
str("%02d" % event.get_date_object().to_calendar(self.cal).get_month()) + \
str("%02d" % event.get_date_object().to_calendar(self.cal).get_day())
self.load_kml_files(place)
if (longitude and latitude):
self._append_to_places_list(
descr, evt,
_nd.display(person), latitude,
longitude, descr1, eyear,
event.get_type(),
person.gramps_id,
place.gramps_id,
event.gramps_id, role)
else:
self._append_to_places_without_coord(
place.gramps_id, descr)
self.sort = sorted(self.place_list, key=operator.itemgetter(6))
self._create_markers()
def __do_save(self):
self.ok_button.set_sensitive(False)
if not self.added:
original = self.db.get_family_from_handle(self.obj.handle)
else:
original = None
# do some basic checks
child_list = [ref.ref for ref in self.obj.get_child_ref_list()]
if self.obj.get_father_handle() in child_list:
father = self.db.get_person_from_handle(
self.obj.get_father_handle())
name = "%s [%s]" % (name_displayer.display(father),
father.gramps_id)
ErrorDialog(
_("A father cannot be his own child"),
_("%s is listed as both the father and child "
"of the family.") % name)
self.ok_button.set_sensitive(True)
return
elif self.obj.get_mother_handle() in child_list:
mother = self.db.get_person_from_handle(
self.obj.get_mother_handle())
name = "%s [%s]" % (name_displayer.display(mother),
mother.gramps_id)
ErrorDialog(
_("A mother cannot be her own child"),
_("%s is listed as both the mother and child "
"of the family.") % name)
self.ok_button.set_sensitive(True)
return
if not original and self.object_is_empty():
ErrorDialog(
_("Cannot save family"),
_("No data exists for this family. "
"Please enter data or cancel the edit."))
self.ok_button.set_sensitive(True)
return
(uses_dupe_id, id) = self._uses_duplicate_id()
if uses_dupe_id:
msg1 = _("Cannot save family. ID already exists.")
msg2 = _("You have attempted to use the existing Gramps ID with "
"value %(id)s. This value is already used. Please "
"enter a different ID or leave "
"blank to get the next available ID value.") % {
'id': id
}
ErrorDialog(msg1, msg2)
self.ok_button.set_sensitive(True)
return
# We disconnect the callbacks to all signals we connected earlier.
# This prevents the signals originating in any of the following
# commits from being caught by us again.
self._cleanup_callbacks()
if not original and not self.object_is_empty():
with DbTxn(_("Add Family"), self.db) as trans:
# find the father, add the family handle to the father
handle = self.obj.get_father_handle()
if handle:
parent = self.db.get_person_from_handle(handle)
parent.add_family_handle(self.obj.handle)
self.db.commit_person(parent, trans)
# find the mother, add the family handle to the mother
handle = self.obj.get_mother_handle()
if handle:
parent = self.db.get_person_from_handle(handle)
parent.add_family_handle(self.obj.handle)
self.db.commit_person(parent, trans)
# for each child, add the family handle to the child
for ref in self.obj.get_child_ref_list():
child = self.db.get_person_from_handle(ref.ref)
# fix - relationships need to be extracted from the list
child.add_parent_family_handle(self.obj.handle)
self.db.commit_person(child, trans)
self.db.add_family(self.obj, trans)
elif original.serialize() != self.obj.serialize():
with DbTxn(_("Edit Family"), self.db) as trans:
self.fix_parent_handles(original.get_father_handle(),
self.obj.get_father_handle(), trans)
self.fix_parent_handles(original.get_mother_handle(),
self.obj.get_mother_handle(), trans)
orig_set = set(original.get_child_ref_list())
new_set = set(self.obj.get_child_ref_list())
# remove the family from children which have been removed
for ref in orig_set.difference(new_set):
person = self.db.get_person_from_handle(ref.ref)
person.remove_parent_family_handle(self.obj.handle)
self.db.commit_person(person, trans)
# add the family to children which have been added
for ref in new_set.difference(orig_set):
person = self.db.get_person_from_handle(ref.ref)
person.add_parent_family_handle(self.obj.handle)
self.db.commit_person(person, trans)
if self.object_is_empty():
self.db.remove_family_relationships(self.obj.handle, trans)
else:
if not self.obj.get_gramps_id():
self.obj.set_gramps_id(
self.db.find_next_family_gramps_id())
self.db.commit_family(self.obj, trans)
self._do_close()
if self.callback:
self.callback(self.obj)
self.callback = None
def listpersonref(self):
sc = {'source': 'S_ID',
'citalist': 'C_ID' }
stc = {}
citation_without_notes = 0
EMPTY = " "
def toYear(date):
yeartext = date.get_year()
return yeartext
def toNbr(text):
text = text[1:]
while text[0] == "0":
text = text[1:]
return text
genderlist = ['F','M','X']
# build citasource dictionary and cl list
sc = defaultdict(list)
cl = []
i=1
for ci in self.__db.iter_citations():
if ci.source_handle in self.source_handles:
sc[ci.source_handle].append(ci.handle)
cl.append(ci.handle)
# build citations - event dic xy
#(a,b): set([('Citation', 'c4a8c46041e08799b17')])
# event: c4a8c4f95b01e38564a event: Taufe
ci = defaultdict(list)
for ev in self.__db.iter_events():
refhandlelist = ev.get_referenced_handles()
for (a,b) in refhandlelist:
if a == 'Citation':
if b in cl: #!
ci[ev.handle].append(b)
ci_evkeys = ci.keys()
#***********************************************************************
# # build godparentsdict of all persons
#
gpdic ={}
gpdic = defaultdict(list)
for pe in self.__db.get_person_handles():
for eventref in self.__db.get_person_from_handle(pe).event_ref_list:
if not eventref.get_role().is_primary():
if eventref.get_role() == "Pate":
gpdic[eventref.ref].append((eventref.get_role(),pe))
gpdickeys = gpdic.keys()
for i in gpdic.keys():
print(self.__db.get_event_from_handle(i).get_date_object())
for (a,b) in gpdic[i]:
print("TEIL ",a
,name_displayer.display(self.__db.get_person_from_handle(b))
,self.__db.get_person_from_handle(b).gramps_id)
print("GPDIC ",len(gpdickeys))
#***********************************************************************
# # build family list of all families with familyevent in citation
#
# a family handle
#
famlist =[]
# famdic = {}
for fh in self.__db.get_family_handles():
for eventref in self.__db.get_family_from_handle(fh).event_ref_list:
if eventref.ref in ci_evkeys:
famlist.append(fh)
# Each family only once
famlist = list(set(famlist))
# for fi,f in enumerate(famlist):
# famdic[f]=fi
#***********************************************************************
# # build pedic of all persons in families with familyevent in citation
#
# k gramps_id
# v 1...n
pedic ={}
self.doc.start_paragraph("SRC-SourceTitle")
self.doc.write_text(_("Person with Citations"))
self.doc.end_paragraph()
indexlist = list()
self.doc.start_table("Corpus Attributes", "SRC-VISONETable")
name_list =["Zeile 1", "Zeile 2"]
self.progress.set_pass(_('Start Table Corpus'), len(name_list))
for nl in name_list:
self.doc.start_row()
self.doc.start_cell("SRC-TableColumn")
self.doc.start_paragraph("SRC-ColumnTitle")
self.doc.write_text(nl)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
self.progress.set_pass(_('Start Table Families'), len(famlist))
self.doc.start_table("Families", "SRC-VISONETable")
## column_titles = [_("Prim_ID"), _("Gramps_ID"), _("Role"), _("Relation"), _("LNr"), _("Ev ID"),_("Event"), _("Date"), _("Year"), _("Age Primary"), _("Age Person"), _("gender Primary"), _("gender Person") , _("Person"),_("Primary"), _("Person birth"), _("Person Clan"),_("Primary Clan"),_("Event Place"),_("FamID"),_("AnzKind")]
column_titles = [_("Id"), "Status", "FatherId", "MotherId", "Children", "HUSB_ORD", "WIFE_ORD", _("Fam_ID"), _("Father_ID"), _("Mother_ID"), _("Children_ID")]
i = 0
self.doc.start_row()
for title in column_titles:
self.doc.start_cell("SRC-TableColumn")
self.doc.start_paragraph("SRC-ColumnTitle")
self.doc.write_text(title)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
i=0
ii=0
fid = 0
for f in sorted(famlist):
famidtext = ""
fathernametxt = ""
mothernametxt = ""
fatheridtxt = ""
motheridtxt = ""
childtxt = ""
fatherordertxt = ""
motherordertxt = ""
family = self.__db.get_family_from_handle(f)
famidtxt = (" [%s]" % family.gramps_id)
famreltxt = family.get_relationship()
if famreltxt == "Verheiratet":
famreltxt = "M"
elif famreltxt == "Unverheiratet":
# print(famreltxt)
famreltxt = " "
# print("FAM ",famreltxt)
elif famreltxt == "Unbekannt":
famreltxt = " "
if family.get_father_handle():
fathernametxt = fathernametxt + self.__db.get_person_from_handle(family.get_father_handle()).primary_name.get_name()
famhandlelist = self.__db.get_person_from_handle(family.get_father_handle()).get_family_handle_list()
fatherordertxt = ("%s" % len(famhandlelist))
fatheridtxt = self.__db.get_person_from_handle(family.get_father_handle()).gramps_id
indexlist.append(fatheridtxt)
fatheridtxt = toNbr(fatheridtxt)
if family.get_mother_handle():
mothernametxt = mothernametxt + self.__db.get_person_from_handle(family.get_mother_handle()).primary_name.get_name()
famhandlelist = self.__db.get_person_from_handle(family.get_mother_handle()).get_family_handle_list()
motheridtxt = self.__db.get_person_from_handle(family.get_mother_handle()).gramps_id
motherordertxt = ("%s" % len(famhandlelist))
indexlist.append(motheridtxt)
motheridtxt = toNbr(motheridtxt)
# BUG only count not order
childtxt =""
for ch in family.get_child_ref_list():
child = self.__db.get_person_from_handle(ch.ref)
if child:
childtxt1 = child.get_gramps_id()
childtxt1 = childtxt1 + ";"
indexlist.append(child.get_gramps_id())
childtxt1 = toNbr(childtxt1)
childtxt = childtxt + childtxt1
fid += 1
line = []
line.append(fid)
line.append(famreltxt)
line.append(fatheridtxt)
line.append(motheridtxt)
line.append(childtxt)
line.append(fatherordertxt)
line.append(motherordertxt)
line.append(famidtxt)
line.append(fathernametxt)
line.append(mothernametxt)
self.doc.start_row()
for l in line:
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
l)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
self.progress.step()
self.doc.end_table()
self.doc.start_table("Individuals", "SRC-VISONETable")
column_titles = [_("Id"), "Name", "Gender", "ORD", "BIRT_DATE", "BIRT_PLACE", "DEAT_DATE", "DEAT_PLACE", "OCCU", "PersonID2"]
# Id Name Gender ORD BIRT_DATE Rolle PersonID2
i = 0
self.doc.start_row()
for title in column_titles:
self.doc.start_cell("SRC-TableColumn")
self.doc.start_paragraph("SRC-ColumnTitle")
self.doc.write_text(title)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
l = len(indexlist)
indexlist = list(set(indexlist))
self.progress.set_pass(_('Start Table Individuals'), len(indexlist))
# for m in indexlist:
# print(m)
pi = 1
for il in indexlist:
self.doc.start_row()
person = self.__db.get_person_from_gramps_id(il)
# Id
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
toNbr(il))
self.doc.end_paragraph()
self.doc.end_cell()
# Name
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
person.primary_name.get_gedcom_name())
self.doc.end_paragraph()
self.doc.end_cell()
# Gender
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
genderlist[person.get_gender()])
self.doc.end_paragraph()
self.doc.end_cell()
# Ord
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
" ")
# person.primary_name.get_name())
self.doc.end_paragraph()
self.doc.end_cell()
# Birth Date
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
birth_ref = person.get_birth_ref()
birth_date = None
birthtxt = " "
birthplacetxt = " "
if birth_ref:
birthtxt = self.__format_date(self.__db.get_event_from_handle(birth_ref.ref).get_date_object())
# birthplacetxt = self.find_place(self.__db.get_event_from_handle(birth_ref.ref).place)
birthplacetxt = place_displayer.display_event(self.__db, self.__db.get_event_from_handle(birth_ref.ref), self.pl_format)
self.doc.write_text(_("%s") %
birthtxt)
self.doc.end_paragraph()
self.doc.end_cell()
# Place of Event
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
birthplacetxt[4:-2])
self.doc.end_paragraph()
self.doc.end_cell()
# Death Date
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
death_ref = person.get_death_ref()
death_date = None
deathtxt = " "
deathplacetxt = " "
if death_ref:
deathtxt = self.__format_date(self.__db.get_event_from_handle(death_ref.ref).get_date_object())
deathplacetxt = place_displayer.display_event(self.__db, self.__db.get_event_from_handle(death_ref.ref), self.pl_format)
self.doc.write_text(_("%s") %
deathtxt)
self.doc.end_paragraph()
self.doc.end_cell()
# Place of Event
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
deathplacetxt[4:-2])
self.doc.end_paragraph()
self.doc.end_cell()
# Occupation
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
self.find_occupation(person))
self.doc.end_paragraph()
self.doc.end_cell()
# Person_ID
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
il)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
pi += 1
print (l,len(indexlist))
self.progress.step()
self.doc.end_table()
self.progress.set_pass(_('Start Table Relation'), len(indexlist))
self.doc.start_table("Relation", "SRC-VISONETable")
column_titles = [_("Id"), "Name", "Candidate", "Godparent", "#DATE"]
#_("Id"), "Name", "Candidate", "Godparent", "#DATE"
#
#
self.doc.start_row()
self.doc.start_cell("SRC-TableColumn")
self.doc.start_paragraph("SRC-ColumnTitle")
self.doc.write_text("Patenschaften")
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
#
i = 0
self.doc.start_row()
for title in column_titles:
self.doc.start_cell("SRC-TableColumn")
self.doc.start_paragraph("SRC-ColumnTitle")
self.doc.write_text(title)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
l = len(indexlist)
indexlist = list(set(indexlist))
# for m in indexlist:
# print(m)
pi = 1
for il in indexlist:
person = self.__db.get_person_from_gramps_id(il)
for eventref in person.get_event_ref_list():
event = self.__db.get_event_from_handle(eventref.ref)
## if event and event.type.is_baptism():
if event.type.is_baptism():
self.doc.start_row()
# EventId
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
toNbr(event.gramps_id))
self.doc.end_paragraph()
self.doc.end_cell()
# Name
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("Bapt %s") %
event.get_description())
self.doc.end_paragraph()
self.doc.end_cell()
# Candidate
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
toNbr(il))
self.doc.end_paragraph()
self.doc.end_cell()
# Godparents
patentxt =""
for i in gpdickeys:
if self.__db.get_event_from_handle(i).gramps_id == event.gramps_id:
for (a,b) in gpdic[i]:
patentxt = patentxt + toNbr(self.__db.get_person_from_handle(b).gramps_id) +";"
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_("%s") %
patentxt)
self.doc.end_paragraph()
self.doc.end_cell()
# Date
self.doc.start_cell("SRC-Cell")
self.doc.start_paragraph("SRC-SourceDetails")
self.doc.write_text(_(" %s") %
self.__format_date(event.get_date_object()))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
pi += 1
self.progress.step()
print (l,len(indexlist))
self.doc.end_table()
def _createmap_for_one_person(self, person, color, place_list, reference):
"""
Create all markers for each people's event in the database which has
a lat/lon.
"""
self.place_list = []
dbstate = self.dbstate
if person is not None:
# For each event, if we have a place, set a marker.
for event_ref in person.get_event_ref_list():
if not event_ref:
continue
event = dbstate.db.get_event_from_handle(event_ref.ref)
role = event_ref.get_role()
try:
date = event.get_date_object().to_calendar(self.cal)
except:
continue
eyear = str("%04d" % date.get_year()) + \
str("%02d" % date.get_month()) + \
str("%02d" % date.get_day())
place_handle = event.get_place_handle()
if place_handle:
place = dbstate.db.get_place_from_handle(place_handle)
if place:
longitude = place.get_longitude()
latitude = place.get_latitude()
latitude, longitude = conv_lat_lon(
latitude, longitude, "D.D8")
descr = _pd.display(dbstate.db, place)
evt = EventType(event.get_type())
descr1 = _("%(eventtype)s : %(name)s") % {
'eventtype': evt,
'name': _nd.display(person)
}
# place.get_longitude and place.get_latitude return
# one string. We have coordinates when the two values
# contains non null string.
if longitude and latitude:
self._append_to_places_list(
descr, evt, _nd.display(person),
latitude, longitude, descr1, eyear,
event.get_type(), person.gramps_id,
place.gramps_id, event.gramps_id, role)
else:
self._append_to_places_without_coord(
place.gramps_id, descr)
family_list = person.get_family_handle_list()
descr1 = " - "
for family_hdl in family_list:
family = self.dbstate.db.get_family_from_handle(family_hdl)
if family is not None:
fhandle = family_list[0] # first is primary
father = mother = None
fam = dbstate.db.get_family_from_handle(fhandle)
handle = fam.get_father_handle()
if handle:
father = dbstate.db.get_person_from_handle(handle)
if father:
descr1 = "%s - " % _nd.display(father)
handle = fam.get_mother_handle()
if handle:
mother = dbstate.db.get_person_from_handle(handle)
if mother:
descr1 = "%s%s" % (descr1, _nd.display(mother))
for event_ref in family.get_event_ref_list():
if event_ref:
event = dbstate.db.get_event_from_handle(
event_ref.ref)
role = event_ref.get_role()
if event.get_place_handle():
place_handle = event.get_place_handle()
if place_handle:
place = dbstate.db.get_place_from_handle(
place_handle)
if place:
longitude = place.get_longitude()
latitude = place.get_latitude()
latitude, longitude = conv_lat_lon(
latitude, longitude, "D.D8")
descr = _pd.display(dbstate.db, place)
evt = EventType(event.get_type())
eyear = str(
"%04d" % event.get_date_object().to_calendar(self.cal).get_year()) + \
str("%02d" % event.get_date_object().to_calendar(self.cal).get_month()) + \
str("%02d" % event.get_date_object().to_calendar(self.cal).get_day())
if longitude and latitude:
self._append_to_places_list(
descr, evt,
_nd.display(person), latitude,
longitude, descr1, eyear,
event.get_type(),
person.gramps_id,
place.gramps_id,
event.gramps_id, role)
else:
self._append_to_places_without_coord(
place.gramps_id, descr)
sort1 = sorted(self.place_list, key=operator.itemgetter(6))
self.draw(None, sort1, color, reference)
# merge with the last results
merge_list = []
for the_list in self.sort, sort1:
merge_list += the_list
self.sort = sorted(merge_list, key=operator.itemgetter(6))
def get_subject(self):
""" Return a string that describes the subject of the report. """
from gramps.gen.display.name import displayer as _nd
gid = self.__pid.get_value()
person = self.__db.get_person_from_gramps_id(gid)
return _nd.display(person)
def exportData(db, filename,
error_dialog=None, option_box=None, callback=None):
if not callable(callback):
callback = lambda percent: None # dummy
with OpenFileOrStdout(filename) as fp:
total = (db.get_number_of_notes() +
db.get_number_of_people() +
db.get_number_of_events() +
db.get_number_of_families() +
db.get_number_of_repositories() +
db.get_number_of_places() +
db.get_number_of_media() +
db.get_number_of_sources())
count = 0.0
# GProlog ISO directives:
# /number must match the number of arguments to functions:
fp.write(":- discontiguous(data/2).\n")
fp.write(":- discontiguous(is_alive/2).\n")
fp.write(":- discontiguous(parent/2).\n")
# Rules:
fp.write("grandparent(X, Y) :- parent(X, Z), parent(Z, Y).\n")
fp.write("ancestor(X, Y) :- parent(X, Y).\n")
fp.write("ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y).\n")
fp.write("sibling(X, Y) :- parent(Z, X), parent(Z, Y), X \= Y.\n")
# ---------------------------------
# Notes
# ---------------------------------
for note in db.iter_notes():
#write_line(fp, "note_details(%s, %s)" % (note.handle, note))
count += 1
callback(100 * count/total)
# ---------------------------------
# Event
# ---------------------------------
for event in db.iter_events():
#write_line(fp, "event:", event.handle, event)
count += 1
callback(100 * count/total)
# ---------------------------------
# Person
# ---------------------------------
for person in db.iter_people():
gid = person.gramps_id.lower()
fp.write("data(%s, '%s').\n" % (gid, escape(name_displayer.display(person))))
fp.write("is_alive(%s, '%s').\n" % (gid, probably_alive(person, database)))
count += 1
callback(100 * count/total)
# ---------------------------------
# Family
# ---------------------------------
for family in db.iter_families():
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
parents = []
if mother_handle:
mother = database.get_person_from_handle(mother_handle)
if mother:
parents.append(mother.gramps_id.lower())
if father_handle:
father = database.get_person_from_handle(father_handle)
if father:
parents.append(father.gramps_id.lower())
children = []
for child_ref in family.get_child_ref_list():
child_handle = child_ref.ref
child = database.get_person_from_handle(child_handle)
if child:
children.append(child.gramps_id.lower())
for pid in parents:
for cid in children:
fp.write("parent(%s, %s).\n" % (pid, cid))
count += 1
callback(100 * count/total)
# ---------------------------------
# Repository
# ---------------------------------
for repository in db.iter_repositories():
#write_line(fp, "repository:", repository.handle, repository)
count += 1
callback(100 * count/total)
# ---------------------------------
# Place
# ---------------------------------
for place in db.iter_places():
#write_line(fp, "place:", place.handle, place)
count += 1
callback(100 * count/total)
# ---------------------------------
# Source
# ---------------------------------
for source in db.iter_sources():
#write_line(fp, "source:", source.handle, source)
count += 1
callback(100 * count/total)
# ---------------------------------
# Media
# ---------------------------------
for media in db.iter_media():
#write_line(fp, "media:", media.handle, media)
count += 1
callback(100 * count/total)
return True
def name_of(p):
if not p:
return ""
return "%s (%s)" % (name_displayer.display(p), p.get_handle())
def on_apply_clicked(self, obj):
model, iter_ = self.tree.get_selection().get_selected()
if not iter_:
return
other_person = None
handle = model.get_handle_from_iter(iter_)
if handle:
other_person = self.db.get_person_from_handle(handle)
if other_person is None:
self.textbuffer.set_text("")
return
#now determine the relation, and print it out
rel_strings, common_an = self.relationship.get_all_relationships(
self.db, self.person, other_person)
p1 = name_displayer.display(self.person)
p2 = name_displayer.display(other_person)
text = []
if other_person is None:
pass
elif self.person.handle == other_person.handle:
rstr = _("%(person)s and %(active_person)s are the same person.") % {
'person': p1,
'active_person': p2
}
text.append((rstr, ""))
elif len(rel_strings) == 0:
rstr = _("%(person)s and %(active_person)s are not related.") % {
'person': p2,
'active_person': p1
}
text.append((rstr, ""))
for rel_string, common in zip(rel_strings, common_an):
rstr = _("%(person)s is the %(relationship)s of %(active_person)s."
) % {'person': p2,
'relationship': rel_string,
'active_person': p1
}
length = len(common)
if length == 1:
person = self.db.get_person_from_handle(common[0])
if common[0] in [other_person.handle, self.person.handle]:
commontext = ''
else :
name = name_displayer.display(person)
commontext = " " + _("Their common ancestor is %s.") % name
elif length == 2:
p1c = self.db.get_person_from_handle(common[0])
p2c = self.db.get_person_from_handle(common[1])
p1str = name_displayer.display(p1c)
p2str = name_displayer.display(p2c)
commontext = " " + _("Their common ancestors are %(ancestor1)s and %(ancestor2)s.") % {
'ancestor1': p1str,
'ancestor2': p2str
}
elif length > 2:
index = 0
commontext = " " + _("Their common ancestors are: ")
for person_handle in common:
person = self.db.get_person_from_handle(person_handle)
if index:
commontext += ", "
commontext += name_displayer.display(person)
index += 1
commontext += "."
else:
commontext = ""
text.append((rstr, commontext))
textval = ""
for val in text:
textval += "%s %s\n" % (val[0], val[1])
self.textbuffer.set_text(textval)
def get_preview_name(self):
prevname = name_displayer.display(self.obj)
return prevname
def get_subject(self):
""" Return a string that describes the subject of the report. """
gid = self.__pid.get_value()
person = self.__db.get_person_from_gramps_id(gid)
return displayer.display(person)
def run(self):
self.remove = self.options.menu.get_option_by_name('remove').get_value()
if not self.remove:
with DbTxn(_("Set Attribute"), self.db, batch=True) as self.trans:
self.add_results_frame(_("Results"))
self.results_write(_("Processing...\n"))
self.db.disable_signals()
self.filter_option = self.options.menu.get_option_by_name('filter')
self.filter = self.filter_option.get_filter() # the actual filter
# FIXME: currently uses old style for gramps31 compatible
# people = self.filter.apply(self.db,
# self.db.iter_person_handles())
people = self.filter.apply(self.db,
self.db.get_person_handles(sort_handles=False))
# FIXME: currently uses old style for gramps31 compatible
# num_people = self.db.get_number_of_people()
num_people = len(people)
self.progress.set_pass(_('Setting attributes...'),
num_people)
count = 0
attribute_text = self.options.handler.options_dict['attribute_text']
attribute_value = self.options.handler.options_dict['attribute_value']
specified_type = gramps.gen.lib.AttributeType()
specified_type.set(attribute_text)
self.results_write(_("Setting '%s' attributes to '%s'...\n\n" %
(attribute_text, attribute_value)))
for person_handle in people:
count += 1
self.progress.step()
person = self.db.get_person_from_handle(person_handle)
done = False
for attr in person.get_attribute_list():
if attr.get_type() == specified_type:
self.results_write(" %d) Changed" % count)
self.results_write_link(name_displayer.display(person),
person, person_handle)
self.results_write(" from '%s'\n" % attr.get_value())
attr.set_value(attribute_value)
done = True
break
if not done:
attr = gramps.gen.lib.Attribute()
attr.set_type(specified_type)
attr.set_value(attribute_value)
person.add_attribute(attr)
# Update global attribute list:
if attr.type.is_custom() and str(attr.type):
self.db.individual_attributes.update([str(attr.type)])
self.results_write(" %d) Added attribute to" % count)
self.results_write_link(name_displayer.display(person),
person, person_handle)
self.results_write("\n")
self.db.commit_person(person, self.trans)
self.db.enable_signals()
self.db.request_rebuild()
self.results_write(_("\nSet %d '%s' attributes to '%s'\n" %
(count, attribute_text, attribute_value)))
self.results_write(_("Done!\n"))
else:
with DbTxn(_("Remove Attribute"), self.db, batch=True) as self.trans:
self.add_results_frame(_("Results"))
self.results_write(_("Processing...\n"))
self.db.disable_signals()
self.filter_option = self.options.menu.get_option_by_name('filter')
self.filter = self.filter_option.get_filter() # the actual filter
# FIXME: currently uses old style for gramps31 compatible
# people = self.filter.apply(self.db,
# self.db.iter_person_handles())
people = self.filter.apply(self.db,
self.db.get_person_handles(sort_handles=False))
# FIXME: currently uses old style for gramps31 compatible
# num_people = self.db.get_number_of_people()
num_people = len(people)
self.progress.set_pass(_('Removing attributes...'),
num_people)
count = 0
attribute_text = self.options.handler.options_dict['attribute_text']
attribute_value = self.options.handler.options_dict['attribute_value']
specified_type = gramps.gen.lib.AttributeType()
specified_type.set(attribute_text)
for person_handle in people:
count += 1
self.progress.step()
person = self.db.get_person_from_handle(person_handle)
done = False
for attr in person.get_attribute_list():
if attr.get_type() == specified_type and \
(attribute_value == '' or attr.get_value() == attribute_value):
person.remove_attribute(attr)
# Update global attribute list:
self.db.individual_attributes.update([str(attr.type)])
self.results_write(" %d) Changed" % count)
self.results_write_link(name_displayer.display(person),
person, person_handle)
self.results_write(" from '%s'\n" % attr.get_value())
done = True
break
if done:
self.results_write(_("\nRemoving %d '%s' attributes to '%s'\n" %
(count, attribute_text, attribute_value)))
self.db.commit_person(person, self.trans)
self.db.enable_signals()
self.db.request_rebuild()
self.results_write(_("Done!\n"))
def on_draw(self, widget, cr, scale=1.):
"""
The main method to do the drawing.
If widget is given, we assume we draw in GTK3 and use the allocation.
To draw raw on the cairo context cr, set widget=None.
"""
# first do size request of what we will need
halfdist = self.halfdist()
if widget:
if self.form == FORM_CIRCLE:
self.set_size_request(2 * halfdist, 2 * halfdist)
elif self.form == FORM_HALFCIRCLE:
self.set_size_request(2 * halfdist,
halfdist + self.CENTER + PAD_PX)
elif self.form == FORM_QUADRANT:
self.set_size_request(halfdist + self.CENTER + PAD_PX,
halfdist + self.CENTER + PAD_PX)
#obtain the allocation
alloc = self.get_allocation()
x, y, w, h = alloc.x, alloc.y, alloc.width, alloc.height
cr.scale(scale, scale)
# when printing, we need not recalculate
if widget:
if self.form == FORM_CIRCLE:
self.center_x = w / 2 - self.center_xy[0]
self.center_y = h / 2 - self.center_xy[1]
elif self.form == FORM_HALFCIRCLE:
self.center_x = w / 2. - self.center_xy[0]
self.center_y = h - self.CENTER - PAD_PX - self.center_xy[1]
elif self.form == FORM_QUADRANT:
self.center_x = self.CENTER + PAD_PX - self.center_xy[0]
self.center_y = h - self.CENTER - PAD_PX - self.center_xy[1]
cr.translate(self.center_x, self.center_y)
cr.save()
#draw center
cr.set_source_rgb(1, 1, 1) # white
cr.move_to(0, 0)
cr.arc(0, 0, self.CENTER - PIXELS_PER_GENFAMILY, 0, 2 * math.pi)
cr.fill()
cr.set_source_rgb(0, 0, 0) # black
cr.arc(0, 0, self.CENTER - PIXELS_PER_GENFAMILY, 0, 2 * math.pi)
cr.stroke()
cr.restore()
# Draw center person:
(person, dup, start, slice, text, parentfampos, nrfam, userdata, status) \
= self.gen2people[0][0]
if person:
r, g, b, a = self.background_box(person, 0, userdata)
cr.arc(0, 0, self.CENTER - PIXELS_PER_GENFAMILY, 0, 2 * math.pi)
if self.parentsroot:
cr.arc_negative(0, 0, TRANSLATE_PX + CHILDRING_WIDTH,
2 * math.pi, 0)
cr.close_path()
cr.set_source_rgba(r / 255, g / 255, b / 255, a)
cr.fill()
cr.save()
name = name_displayer.display(person)
self.draw_text(
cr, name, self.CENTER - PIXELS_PER_GENFAMILY -
(self.CENTER - PIXELS_PER_GENFAMILY -
(CHILDRING_WIDTH + TRANSLATE_PX)) / 2, 95, 455, 10, False,
self.fontcolor(r, g, b, a), self.fontbold(a))
cr.restore()
#draw center to move chart
cr.set_source_rgb(0, 0, 0) # black
cr.move_to(TRANSLATE_PX, 0)
cr.arc(0, 0, TRANSLATE_PX, 0, 2 * math.pi)
if self.parentsroot: # has at least one parent
cr.fill()
self.draw_parentring(cr)
else:
cr.stroke()
#now write all the families and children
cr.save()
cr.rotate(self.rotate_value * math.pi / 180)
radstart = self.CENTER - PIXELS_PER_GENFAMILY - PIXELS_PER_GENPERSON
for gen in range(self.generations - 1):
radstart += PIXELS_PER_GENPERSON
for famdata in self.gen2fam[gen]:
# family, duplicate or not, start angle, slice size,
# text, spouse pos in gen, nrchildren, userdata, status
fam, dup, start, slice, text, posfam, nrchild, userdata,\
partner, status = famdata
if status != COLLAPSED:
self.draw_person(cr,
text,
start,
slice,
radstart,
radstart + PIXELS_PER_GENFAMILY,
gen,
dup,
partner,
userdata,
family=True,
thick=status != NORMAL)
radstart += PIXELS_PER_GENFAMILY
for pdata in self.gen2people[gen + 1]:
# person, duplicate or not, start angle, slice size,
# text, parent pos in fam, nrfam, userdata, status
pers, dup, start, slice, text, pospar, nrfam, userdata, status = \
pdata
if status != COLLAPSED:
self.draw_person(cr,
text,
start,
slice,
radstart,
radstart + PIXELS_PER_GENPERSON,
gen + 1,
dup,
pers,
userdata,
thick=status != NORMAL)
cr.restore()
if self.background in [BACKGROUND_GRAD_AGE, BACKGROUND_GRAD_PERIOD]:
self.draw_gradient(cr, widget, halfdist)
def load_model(self):
"""
Objects can have very large backreferences. To avoid blocking the
interface up to the moment that the model is created, this method is
called via GLib.idle_add.
WARNING: a consequence of above is that loading can still be happening
while the GUI using this model is no longer used. Disconnect any
methods before closing the GUI.
"""
self.loading = True
self.count = 0
for ref in self.sref_list:
self.count += 1
dtype = ref[0]
if dtype == 'Person':
p = self.db.get_person_from_handle(ref[1])
if not p:
continue
gid = p.gramps_id
handle = p.handle
name = name_displayer.display(p)
elif dtype == 'Family':
p = self.db.get_family_from_handle(ref[1])
if not p:
continue
gid = p.gramps_id
handle = p.handle
name = family_name(p, self.db)
elif dtype == 'Source':
p = self.db.get_source_from_handle(ref[1])
if not p:
continue
gid = p.gramps_id
handle = p.handle
name = p.get_title()
elif dtype == 'Citation':
p = self.db.get_citation_from_handle(ref[1])
if not p:
continue
gid = p.gramps_id
handle = p.handle
name = p.get_page()
elif dtype == 'Event':
p = self.db.get_event_from_handle(ref[1])
if not p:
continue
gid = p.gramps_id
handle = p.handle
name = p.get_description()
if name:
name = self.dispstr % {
'part1': str(p.get_type()),
'part2': name
}
else:
name = str(p.get_type())
part = get_participant_from_event(self.db, ref[1])
if part:
name = self.dispstr % {'part1': name, 'part2': part}
elif dtype == 'Place':
p = self.db.get_place_from_handle(ref[1])
if not p:
continue
name = place_displayer.display(self.db, p)
gid = p.gramps_id
handle = p.handle
elif dtype == 'Repository':
p = self.db.get_repository_from_handle(ref[1])
if not p:
continue
name = p.get_name()
gid = p.gramps_id
handle = p.handle
else:
p = self.db.get_media_from_handle(ref[1])
if not p:
continue
name = p.get_description()
gid = p.gramps_id
handle = p.handle
# dtype is the class name, i.e. is English
# We need to use localized string in the model.
# we also need to keep class names to get the object type,
# but we don't need to show that in the view.
self.append(row=[_(dtype), gid, name, handle, dtype])
yield True
self.loading = False
yield False
def display(self, tobj, person):
"""Fill text buffer tobj with detailed info on person person."""
normal = tobj.create_tag()
normal.set_property('indent', 10)
normal.set_property('pixels-above-lines', 1)
normal.set_property('pixels-below-lines', 1)
indent = tobj.create_tag()
indent.set_property('indent', 30)
indent.set_property('pixels-above-lines', 1)
indent.set_property('pixels-below-lines', 1)
title = tobj.create_tag()
title.set_property('weight', Pango.Weight.BOLD)
title.set_property('scale', 1.2)
self.add(tobj, title, name_displayer.display(person))
self.add(tobj, normal, "%s:\t%s" % (_('ID'), person.get_gramps_id()))
self.add(tobj, normal,
"%s:\t%s" % (_('Gender'), sex[person.get_gender()]))
bref = person.get_birth_ref()
if bref:
self.add(tobj, normal,
"%s:\t%s" % (_('Birth'), self.get_event_info(bref.ref)))
dref = person.get_death_ref()
if dref:
self.add(tobj, normal,
"%s:\t%s" % (_('Death'), self.get_event_info(dref.ref)))
nlist = person.get_alternate_names()
if len(nlist) > 0:
self.add(tobj, title, _("Alternate Names"))
for name in nlist:
self.add(tobj, normal, name_displayer.display_name(name))
elist = person.get_event_ref_list()
if len(elist) > 0:
self.add(tobj, title, _("Events"))
for event_ref in person.get_event_ref_list():
event_handle = event_ref.ref
role = event_ref.get_role()
name = str(
self.database.get_event_from_handle(
event_handle).get_type())
if role.is_primary():
self.add(
tobj, normal,
"%s:\t%s" % (name, self.get_event_info(event_handle)))
else:
self.add(
tobj, normal, "%s (%s):\t%s" %
(name, role, self.get_event_info(event_handle)))
plist = person.get_parent_family_handle_list()
if len(plist) > 0:
self.add(tobj, title, _("Parents"))
for fid in person.get_parent_family_handle_list():
(fname, mname, gid) = self.get_parent_info(fid)
self.add(tobj, normal, "%s:\t%s" % (_('Family ID'), gid))
if fname:
self.add(tobj, indent, "%s:\t%s" % (_('Father'), fname))
if mname:
self.add(tobj, indent, "%s:\t%s" % (_('Mother'), mname))
else:
self.add(tobj, normal, _("No parents found"))
self.add(tobj, title, _("Spouses"))
slist = person.get_family_handle_list()
if len(slist) > 0:
for fid in slist:
(fname, mname, pid) = self.get_parent_info(fid)
family = self.database.get_family_from_handle(fid)
self.add(tobj, normal, "%s:\t%s" % (_('Family ID'), pid))
spouse_id = utils.find_spouse(person, family)
if spouse_id:
spouse = self.database.get_person_from_handle(spouse_id)
self.add(tobj, indent,
"%s:\t%s" % (_('Spouse'), name_of(spouse)))
relstr = str(family.get_relationship())
self.add(tobj, indent, "%s:\t%s" % (_('Type'), relstr))
event = utils.find_marriage(self.database, family)
if event:
self.add(
tobj, indent,
"%s:\t%s" % (_('Marriage'),
self.get_event_info(event.get_handle())))
for child_ref in family.get_child_ref_list():
child = self.database.get_person_from_handle(child_ref.ref)
self.add(tobj, indent,
"%s:\t%s" % (_('Child'), name_of(child)))
else:
self.add(tobj, normal, _("No spouses or children found"))
alist = person.get_address_list()
if len(alist) > 0:
self.add(tobj, title, _("Addresses"))
for addr in alist:
location = ", ".join([
addr.get_street(),
addr.get_city(),
addr.get_state(),
addr.get_country(),
addr.get_postal_code(),
addr.get_phone()
])
self.add(tobj, normal, location.strip())
def main(self):
# Write heading text to gramplet
self.set_text(_("Relations of related people in your database:"))
# Define basic variables
database = self.dbstate.db
rel_calc = get_relationship_calculator()
family_handle_list = [] # Will keep list of families with no ancestors
# Find all base families with no ancestors in the database.
flist = database.iter_family_handles()
for familyhandle in flist:
family = database.get_family_from_handle(familyhandle)
# Check if mother of this family is child of another family
# If this is the case, skip this family
ancestorHandle = family.get_mother_handle()
if ancestorHandle:
mother = database.get_person_from_handle(ancestorHandle)
parent_handle_list = mother.get_parent_family_handle_list()
if parent_handle_list:
continue
# Check if father of this family is child of another family
# If this is the case, skip this family
ancestorHandle = family.get_father_handle()
if ancestorHandle:
father = database.get_person_from_handle(ancestorHandle)
parent_handle_list = father.get_parent_family_handle_list()
if parent_handle_list:
continue
# Members of this family have no ancestors. Add family to base
# family handle list
family_handle_list.append(familyhandle)
yield True
# The base family handle list now contains all families that have
# no ancestors. Now iterate through found families. For each family
# first find all descendants and then check if one person in this
# family tree is partner of another person in the same tree.
#
# Related relatives may be found more than once from different base
# families. Therefore we hold a list of all found pairs to avoid
# listing them more than once
pair_p1_list = [] # List of all 1st related partners for all families
pair_p2_list = [] # List of all 2nd related partners for all families
for familyhandle in family_handle_list:
# Build list of all related persons (descendants) of this family.
self.person_handle_list = []
family = database.get_family_from_handle(familyhandle)
# Add all descendants of the father to person list of this family
father_handle = family.get_father_handle()
if father_handle:
father = database.get_person_from_handle(father_handle)
# Add all descendants of the father
self.addDescendants(father_handle)
mother_handle = family.get_mother_handle()
# Add all descendants of the mother to person list of this family
if mother_handle:
mother = database.get_person_from_handle(mother_handle)
# Add all descendants of the mother
self.addDescendants(mother_handle)
# The person list of all descendants for this family is complete.
# Now check for every person in the list if it has a partner that
# is also in this list
for checkHandle in self.person_handle_list:
person = database.get_person_from_handle(checkHandle)
if person:
pfamily_handle_list = person.get_family_handle_list()
if pfamily_handle_list:
for family_handle in pfamily_handle_list:
# Skip the family if it is listed in the base
# families list (which should be quite short).
if family_handle in family_handle_list:
continue
# If current person is father or mother in a family
# find the handle of the partner
family = database.get_family_from_handle(
family_handle)
father_handle = family.get_father_handle()
mother_handle = family.get_mother_handle()
if checkHandle == father_handle:
handlepartner = mother_handle
else:
handlepartner = father_handle
# If the partner is in our list of persons of this
# family tree, both are related.
if handlepartner in self.person_handle_list:
newEntry = True
# Check if this pair is already in the lists of
# related partners. A and B will also appear as
# B and A. So we have to cross check
for ii in range(len(pair_p1_list)):
if checkHandle == pair_p1_list[ii]:
if handlepartner == pair_p2_list[ii]:
newEntry = False
if checkHandle == pair_p2_list[ii]:
if handlepartner == pair_p1_list[ii]:
newEntry = False
# If this pair is not yet listed, add them to
# the list and show their relationship in the
# gramplet window.
if newEntry:
# Add pair to list of found related relatives
pair_p1_list.append(checkHandle)
pair_p2_list.append(handlepartner)
partner = self.dbstate.db. \
get_person_from_handle(handlepartner)
# Find relation between the partners by use
# of the relationship calculator. Print all
# relationships A to B and B to A.
rel_strings, common_an = \
rel_calc.get_all_relationships(database,
person,
partner)
rel_strings1, common_an1 = \
rel_calc.get_all_relationships(database,
partner,
person)
if len(rel_strings) > 1:
# Output names of both partners as links
p1name = name_displayer.display(person)
self.append_text("\n\n")
self.link(p1name, 'Person',
checkHandle)
p2name = name_displayer.display(
partner)
self.append_text(" " + _("and") + " ")
self.link(p2name, 'Person',
handlepartner)
self.append_text(" " + \
_("are partners and") + \
":")
# Omit the first relationship from list
for x in range(1, len(rel_strings)):
self.append_text("\n%s" %
rel_strings[x])
try:
self.append_text(
" & %s" % rel_strings1[x])
except:
continue
# Print list of common ancestors for
# the found relation.
# Remove duplicate ancestors
anc_list = list(set(common_an[x]))
for anc in anc_list:
person = database. \
get_person_from_handle(anc)
if person:
# Print ancestor as link
pname = name_displayer. \
display(person)
self.append_text("\n\t" \
+ _("Common ancestor") \
+ " ")
self.link(
pname, 'Person', anc)
# After the check for each persons family allow other
# threads to do some work.
yield True
# If the list of related pairs is empty we did not find any related
# relatives in the database.
if len(pair_p1_list) == 0:
self.append_text("\n" + _("No relatives in a relation found") +
".\n")
self.append_text("\n\n" + _("END") + "\n")
return
def name_of(person):
"""Return string with name and ID of a person."""
if not person:
return ""
return "%s [%s]" % (name_displayer.display(person), person.get_gramps_id())
def get_person_title(self, obj):
return "{gramps_id}: {name}".format(gramps_id=obj.get_gramps_id(),
name=name_displayer.display(obj))
def _message1_format(self, person):
return _('Delete %s?') % (name_displayer.display(person) +
(" [%s]" % person.gramps_id))
