def dump(self, level, person):
self.append_text(" " * (level - 1))
self.append_text("%s. " % level)
self.link(name_displayer.display_name(person.get_primary_name()),
'Person', person.handle,
tooltip=_("Click to make active\n") + \
_("Right-click to edit"))
self.dump_dates(person)
self.append_text("\n")
if level >= self.max_generations:
return
for family_handle in person.get_family_handle_list():
family = self.dbstate.db.get_family_from_handle(family_handle)
spouse_handle = ReportUtils.find_spouse(person, family)
if spouse_handle:
spouse = self.dbstate.db.get_person_from_handle(spouse_handle)
self.append_text(" " * (level - 1))
self.append_text(_(" sp. "))
self.link(name_displayer.display_name(spouse.get_primary_name()),
'Person', spouse.handle,
tooltip=_("Click to make active\n") + \
_("Right-click to edit"))
self.dump_dates(spouse)
self.append_text("\n")
childlist = family.get_child_ref_list()[:]
for child_ref in childlist:
child = self.dbstate.db.get_person_from_handle(child_ref.ref)
self.dump(level + 1, child)
def get_name(self, person, maiden_name=None):
""" Return person's name, unless maiden_name given,
unless married_name listed.
"""
# Get all of a person's names:
primary_name = person.get_primary_name()
married_name = None
names = [primary_name] + person.get_alternate_names()
for name in names:
if int(name.get_type()) == gen.lib.NameType.MARRIED:
married_name = name
break # use first
# Now, decide which to use:
if maiden_name is not None:
if married_name is not None:
name = gen.lib.Name(married_name)
else:
name = gen.lib.Name(primary_name)
surname = gen.lib.Surname()
surname.set_surname(maiden_name)
name.set_surname_list([surname])
else:
name = gen.lib.Name(primary_name)
name.set_display_as(self.name_format)
return _nd.display_name(name)
def name_from_gramps_id(self, gramps_id):
if self.namespace == 'Person':
person = self.db.get_person_from_gramps_id(gramps_id)
name = _nd.display_name(person.get_primary_name())
elif self.namespace == 'Family':
family = self.db.get_family_from_gramps_id(gramps_id)
name = Utils.family_name(family, self.db)
elif self.namespace == 'Event':
event = self.db.get_event_from_gramps_id(gramps_id)
name = str(event.get_type)
elif self.namespace == 'Place':
place = self.db.get_place_from_gramps_id(gramps_id)
name = place.get_title()
elif self.namespace == 'Source':
source = self.db.get_source_from_gramps_id(gramps_id)
name = source.get_title()
elif self.namespace == 'Citation':
citation = self.db.get_citation_from_gramps_id(gramps_id)
name = citation.get_page()
elif self.namespace == 'MediaObject':
obj = self.db.get_object_from_gramps_id(gramps_id)
name = obj.get_path()
elif self.namespace == 'Repository':
repo = self.db.get_repository_from_gramps_id(gramps_id)
name = repo.get_name()
elif self.namespace == 'Note':
note = self.db.get_note_from_gramps_id(gramps_id)
name = note.get()
return name
def build_menu_names(self, name):
if name:
ntext = name_displayer.display_name(name)
submenu_label = '%s: %s' % (_('Name'), ntext)
else:
submenu_label = _('New Name')
menu_label = _('Name Editor')
return (menu_label, submenu_label)
def row(self, index, name):
"""
Returns the row of the model in group index, and name as a
list
"""
return [name_displayer.display_name(name),
str(name.get_type()),
(index, name),
self.colweight(index),
name.get_group_as(),
self.hassource(name),
self.notepreview(name)
]
def _Name_get_styled(name, callname, placeholder=False):
"""
Return a StyledText object with the name formatted according to the
parameters:
@param callname: whether the callname should be used instead of the first
name (CALLNAME_REPLACE), underlined within the first name
(CALLNAME_UNDERLINE_ADD) or not used at all (CALLNAME_DONTUSE).
@param placeholder: whether a series of underscores should be inserted as a
placeholder if first name or surname are missing.
"""
# Make a copy of the name object so we don't mess around with the real
# data.
n = Name(source=name)
# Insert placeholders.
if placeholder:
if not n.first_name:
n.first_name = "____________"
if not n.surname:
n.surname = "____________"
if n.call:
if callname == _Name_CALLNAME_REPLACE:
# Replace first name with call name.
n.first_name = n.call
elif callname == _Name_CALLNAME_UNDERLINE_ADD:
if n.call not in n.first_name:
# Add call name to first name.
n.first_name = "\"%(call)s\" (%(first)s)" % {
'call': n.call,
'first': n.first_name
}
text = name_displayer.display_name(n)
tags = []
if n.call:
if callname == _Name_CALLNAME_UNDERLINE_ADD:
# "name" in next line is on purpose: only underline the call name
# if it was a part of the *original* first name
if n.call in name.first_name:
# Underline call name
callpos = text.find(n.call)
tags = [
StyledTextTag(StyledTextTagType.UNDERLINE, True,
[(callpos, callpos + len(n.call))])
]
return StyledText(text, tags)
def display_alternate_names(self, active_person):
"""
Display other names of the person
"""
try:
nlist = active_person.get_alternate_names()
if len(nlist) > 0:
for altname in nlist:
name_type = str( altname.get_type() )
text = name_displayer.display_name(altname)
self.add_row(name_type, text)
self.display_separator()
except:
pass
def __process_person_2(self, person):
missingbits = []
primary_name = person.get_primary_name()
name = name_displayer.display_name(primary_name)
if not name:
name = _("(person with unknown name)")
if self.__person_complete_handle is not None and \
self.__person_complete_handle not in person.get_tag_list():
missingbits.append(_("person not complete"))
if missingbits:
self.link(name, 'Person', person.get_handle())
self.append_text(
_(": %(list)s\n") % {'list': _(", ").join(missingbits)})
self.__counter += 1
def __process_person(self, person, append_list):
if person.get_handle() in self.__processed_persons:
return
self.__processed_persons[person.get_handle()] = True
missingbits = []
primary_name = person.get_primary_name()
if not primary_name.get_first_name():
missingbits.append(_("first name unknown"))
if not primary_name.get_surname():
missingbits.append(_("surname unknown"))
name = name_displayer.display_name(primary_name)
if not name:
name = _("(person with unknown name)")
has_birth = False
for event_ref in person.get_primary_event_ref_list():
event = self.dbstate.db.get_event_from_handle(event_ref.ref)
if event.get_type() not in [EventType.BIRTH, EventType.DEATH]:
continue
missingbits.extend(self.__process_event(event))
if event.get_type() == EventType.BIRTH:
has_birth = True
if not has_birth:
missingbits.append(_("birth event missing"))
if missingbits:
self.link(name, 'Person', person.get_handle())
self.append_text(
_(": %(list)s\n") % {'list': _(", ").join(missingbits)})
self.__counter += 1
append_list.append(person)
def __init__(self,
dbstate,
uistate,
handle1,
handle2,
cb_update=None,
expand_context_info=True):
ManagedWindow.ManagedWindow.__init__(self, uistate, [], self.__class__)
self.database = dbstate.db
self.pr1 = self.database.get_person_from_handle(handle1)
self.pr2 = self.database.get_person_from_handle(handle2)
self.update = cb_update
self.define_glade('mergeperson', _GLADE_FILE)
self.set_window(self._gladeobj.toplevel,
self.get_widget("person_title"), _("Merge People"))
# Detailed selection widgets
name1 = name_displayer.display_name(self.pr1.get_primary_name())
name2 = name_displayer.display_name(self.pr2.get_primary_name())
entry1 = self.get_widget("name1")
entry2 = self.get_widget("name2")
entry1.set_text(name1)
entry2.set_text(name2)
if entry1.get_text() == entry2.get_text():
for widget_name in ('name1', 'name2', 'name_btn1', 'name_btn2'):
self.get_widget(widget_name).set_sensitive(False)
entry1 = self.get_widget("gender1")
entry2 = self.get_widget("gender2")
entry1.set_text(sex[self.pr1.get_gender()])
entry2.set_text(sex[self.pr2.get_gender()])
if entry1.get_text() == entry2.get_text():
for widget_name in ('gender1', 'gender2', 'gender_btn1',
'gender_btn2'):
self.get_widget(widget_name).set_sensitive(False)
gramps1 = self.pr1.get_gramps_id()
gramps2 = self.pr2.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")
rbutton_label1.set_label(name1 + " [" + gramps1 + "]")
rbutton_label2.set_label(name2 + " [" + gramps2 + "]")
rbutton1.connect("toggled", self.on_handle1_toggled)
expander2 = self.get_widget("expander2")
self.expander_handler = expander2.connect("notify::expanded",
self.cb_expander2_activated)
expander2.set_expanded(expand_context_info)
self.connect_button("person_help", self.cb_help)
self.connect_button("person_ok", self.cb_merge)
self.connect_button("person_cancel", self.close)
self.show()
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', pango.SCALE_LARGE)
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 = ReportUtils.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 = ReportUtils.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 writePeople(self):
self.doc.add_comment('')
# If we're going to attempt to include images, then use the HTML style
# of .gv file.
bUseHtmlOutput = False
if self._incimages:
bUseHtmlOutput = True
# loop through all the people we need to output
for handle in self._people:
person = self._db.get_person_from_handle(handle)
name = name_displayer.display_name(person.get_primary_name())
# figure out what colour to use
gender = person.get_gender()
colour = self._colorunknown
if gender == gen.lib.Person.MALE:
colour = self._colormales
elif gender == gen.lib.Person.FEMALE:
colour = self._colorfemales
# see if we have surname colours that match this person
surname = person.get_primary_name().get_surname().encode(
'iso-8859-1', 'xmlcharrefreplace')
if surname in self._surnamecolors:
colour = self._surnamecolors[surname]
# see if we have a birth/death or fallback dates we can use
if self._incdates or self._incplaces:
bth_event = get_birth_or_fallback(self._db, person)
dth_event = get_death_or_fallback(self._db, person)
else:
bth_event = None
dth_event = None
# output the birth or fallback event
birthStr = None
if bth_event and self._incdates:
if not bth_event.private or self._incprivate:
date = bth_event.get_date_object()
if self._just_years and date.get_year_valid():
birthStr = '%i' % date.get_year()
else:
birthStr = _dd.display(date)
# get birth place (one of: city, state, or country) we can use
birthplace = None
if bth_event and self._incplaces:
if not bth_event.private or self._incprivate:
place = self._db.get_place_from_handle(
bth_event.get_place_handle())
if place:
location = place.get_main_location()
if location.get_city:
birthplace = location.get_city()
elif location.get_state:
birthplace = location.get_state()
elif location.get_country:
birthplace = location.get_country()
# see if we have a deceased date we can use
deathStr = None
if dth_event and self._incdates:
if not dth_event.private or self._incprivate:
date = dth_event.get_date_object()
if self._just_years and date.get_year_valid():
deathStr = '%i' % date.get_year()
else:
deathStr = _dd.display(date)
# get death place (one of: city, state, or country) we can use
deathplace = None
if dth_event and self._incplaces:
if not dth_event.private or self._incprivate:
place = self._db.get_place_from_handle(
dth_event.get_place_handle())
if place:
location = place.get_main_location()
if location.get_city:
deathplace = location.get_city()
elif location.get_state:
deathplace = location.get_state()
elif location.get_country:
deathplace = location.get_country()
# see if we have an image to use for this person
imagePath = None
if self._incimages:
mediaList = person.get_media_list()
if len(mediaList) > 0:
mediaHandle = mediaList[0].get_reference_handle()
media = self._db.get_object_from_handle(mediaHandle)
mediaMimeType = media.get_mime_type()
if mediaMimeType[0:5] == "image":
imagePath = ThumbNails.get_thumbnail_path(
Utils.media_path_full(self._db, media.get_path()),
rectangle=mediaList[0].get_rectangle())
# put the label together and output this person
label = u""
lineDelimiter = '\\n'
if bUseHtmlOutput:
lineDelimiter = '<BR/>'
# if we have an image, then start an HTML table; remember to close the table afterwards!
if imagePath:
label = (u'<TABLE BORDER="0" CELLSPACING="2" CELLPADDING="0" '
u'CELLBORDER="0"><TR><TD><IMG SRC="%s"/></TD>' %
imagePath)
if self._imageonside == 0:
label += u'</TR><TR>'
label += '<TD>'
# at the very least, the label must have the person's name
label += name
if birthStr or deathStr:
label += '%s(' % lineDelimiter
if birthStr:
label += '%s' % birthStr
label += ' - '
if deathStr:
label += '%s' % deathStr
label += ')'
if birthplace or deathplace:
if birthplace == deathplace:
deathplace = None # no need to print the same name twice
label += '%s' % lineDelimiter
if birthplace:
label += '%s' % birthplace
if birthplace and deathplace:
label += ' / '
if deathplace:
label += '%s' % deathplace
# see if we have a table that needs to be terminated
if imagePath:
label += '</TD></TR></TABLE>'
shape = "box"
style = "solid"
border = colour
fill = colour
# do not use colour if this is B&W outline
if self._colorize == 'outline':
border = ""
fill = ""
if gender == person.FEMALE and self._useroundedcorners:
style = "rounded"
elif gender == person.UNKNOWN:
shape = "hexagon"
# if we're filling the entire node:
if self._colorize == 'filled':
style += ",filled"
border = ""
# we're done -- add the node
self.doc.add_node(person.get_gramps_id(),
label=label,
shape=shape,
color=border,
style=style,
fillcolor=fill,
htmloutput=bUseHtmlOutput)
def column_mother(self, data):
if data[3]:
person = self.db.get_person_from_handle(data[3])
return name_displayer.display_name(person.primary_name)
else:
return ""
def process_person(self, handle, generation, what):
if generation > self.max_generations:
return
person = self.dbstate.db.get_person_from_handle(handle)
family_list = person.get_parent_family_handle_list()
if what == "f":
if len(family_list) > 0:
family = self.dbstate.db.get_family_from_handle(family_list[0])
father = family.get_father_handle()
mother = family.get_mother_handle()
if father:
self.process_person(father, generation + 1, "f")
self.set_box(generation, 1)
self.process_person(father, generation + 1, "sf")
self.process_person(father, generation + 1, "m")
elif mother:
self.set_box(generation, 1)
elif what[0] == "s":
boxes = self.get_boxes(generation, what)
if what[-1] == 'f':
if self.box_mode == "UTF":
boxes = boxes.replace("+", u"\u250c")
else:
boxes = boxes.replace("+", u"/")
else:
if self.box_mode == "UTF":
boxes = boxes.replace("+", u"\u2514")
else:
boxes = boxes.replace("+", u"\\")
self.append_text(boxes)
self.link(name_displayer.display_name(person.get_primary_name()),
'Person', person.handle,
tooltip=_("Click to make active\n") + \
_("Right-click to edit"))
if self.show_dates:
self.append_text(" ")
self.render_text(self.info_string(person))
self.append_text("\n")
if generation not in self._generations:
self._generations[generation] = []
self._generations[generation].append(handle)
elif what == "a":
if self.box_mode == "UTF":
self.append_text(u"o" + (u"\u2500" * 3))
elif self.box_mode == "ASCII":
self.append_text(u"o---")
self.append_text(
"%s " %
name_displayer.display_name(person.get_primary_name()))
if self.show_dates:
self.render_text(self.info_string(person))
self.append_text("\n")
if generation not in self._generations:
self._generations[generation] = []
self._generations[generation].append(handle)
elif what == "m":
if len(family_list) > 0:
family = self.dbstate.db.get_family_from_handle(family_list[0])
mother = family.get_mother_handle()
if mother:
self.process_person(mother, generation + 1, "f")
self.process_person(mother, generation + 1, "sm")
self.set_box(generation, 0)
self.process_person(mother, generation + 1, "m")
self.set_box(generation, 0) # regardless, turn off line if on
def get_person_label(self, person):
"return person label string"
# see if we have an image to use for this person
imagePath = None
if self.bUseHtmlOutput:
mediaList = person.get_media_list()
if len(mediaList) > 0:
mediaHandle = mediaList[0].get_reference_handle()
media = self.database.get_object_from_handle(mediaHandle)
mediaMimeType = media.get_mime_type()
if mediaMimeType[0:5] == "image":
imagePath = ThumbNails.get_thumbnail_path(
Utils.media_path_full(self.database, media.get_path()),
rectangle=mediaList[0].get_rectangle())
# test if thumbnail actually exists in thumbs
# (import of data means media files might not be present
imagePath = Utils.find_file(imagePath)
label = u""
lineDelimiter = '\\n'
# If we have an image, then start an HTML table; remember to close
# the table afterwards!
#
# This isn't a free-form HTML format here...just a few keywords that
# happen to be
# similar to keywords commonly seen in HTML. For additional
# information on what
# is allowed, see:
#
# http://www.graphviz.org/info/shapes.html#html
#
if self.bUseHtmlOutput and imagePath:
lineDelimiter = '<BR/>'
label += '<TABLE BORDER="0" CELLSPACING="2" CELLPADDING="0" CELLBORDER="0"><TR><TD></TD><TD><IMG SRC="%s"/></TD><TD></TD>' % imagePath
if self.imgpos == 0:
#trick it into not stretching the image
label += '</TR><TR><TD COLSPAN="3">'
else:
label += '<TD>'
else:
#no need for html label with this person
self.bUseHtmlOutput = False
# at the very least, the label must have the person's name
nm = name_displayer.display_name(person.get_primary_name())
if self.bUseHtmlOutput:
# avoid < and > in the name, as this is html text
label += nm.replace('<', '<').replace('>', '>')
else:
label += nm
p_id = person.get_gramps_id()
if self.includeid:
label += " (%s)" % p_id
if self.includedates:
birth, death = self.get_date_strings(person)
label = label + '%s(%s - %s)' % (lineDelimiter, birth, death)
if self.increlname and self.center_person != person:
# display relationship info
if self.advrelinfo:
(relationship, Ga, Gb) = self.rel_calc.get_one_relationship(
self.database, self.center_person, person, True)
if relationship:
label += "%s(%s Ga=%d Gb=%d)" % (lineDelimiter,
relationship, Ga, Gb)
else:
relationship = self.rel_calc.get_one_relationship(
self.database, self.center_person, person)
if relationship:
label += "%s(%s)" % (lineDelimiter, relationship)
# see if we have a table that needs to be terminated
if self.bUseHtmlOutput:
label += '</TD></TR></TABLE>'
return label
else:
# non html label is enclosed by "" so escape other "
return label.replace('"', '\\\"')
