def get_person_mark(db, person):
"""
Return a IndexMark that can be used to index a person in a report
@param db: the GRAMPS database instance
@param person: the the key is for
"""
if not person:
return None
name = person.get_primary_name().get_name()
birth = " "
death = " "
key = ""
birth_ref = person.get_birth_ref()
if birth_ref:
birthEvt = db.get_event_from_handle(birth_ref.ref)
birth = DateHandler.get_date(birthEvt)
death_ref = person.get_death_ref()
if death_ref:
deathEvt = db.get_event_from_handle(death_ref.ref)
death = DateHandler.get_date(deathEvt)
if birth == death == " ":
key = name
else:
key = "%s (%s - %s)" % (name, birth, death)
return IndexMark(key, INDEX_TYPE_ALP)
def dump_dates(self, person):
birth = get_birth_or_fallback(self.dbstate.db, person)
death = get_death_or_fallback(self.dbstate.db, person)
if birth:
birth_date = DateHandler.get_date(birth)
if death:
death_date = DateHandler.get_date(death)
if birth or death:
self.append_text(' (')
birth_place = ""
if birth:
bplace_handle = birth.get_place_handle()
if bplace_handle:
birth_place = self.dbstate.db.get_place_from_handle(
bplace_handle).get_title()
death_place = ""
if death:
dplace_handle = death.get_place_handle()
if dplace_handle:
death_place = self.dbstate.db.get_place_from_handle(
dplace_handle).get_title()
if birth:
if birth_place:
self.append_text(
"%(event_abbrev)s %(birth_date)s - %(place)s" % {
'event_abbrev': birth.type.get_abbreviation(),
'birth_date': birth_date,
'place': birth_place,
})
else:
self.append_text(
"%(event_abbrev)s %(birth_date)s" % {
'event_abbrev': birth.type.get_abbreviation(),
'birth_date': birth_date
})
if death:
if birth:
self.append_text(', ')
if death_place:
self.append_text(
"%(event_abbrev)s %(death_date)s - %(place)s" % {
'event_abbrev': death.type.get_abbreviation(),
'death_date': death_date,
'place': death_place,
})
else:
self.append_text(
"%(event_abbrev)s %(death_date)s" % {
'event_abbrev': death.type.get_abbreviation(),
'death_date': death_date
})
self.append_text(')')
def write_person_row(self, person_handle):
"""
Write a row in the table with information about the given person.
"""
person = self.database.get_person_from_handle(person_handle)
name = self._name_display.display(person)
mark = ReportUtils.get_person_mark(self.database, person)
birth_date = ""
birth_ref = person.get_birth_ref()
if birth_ref:
event = self.database.get_event_from_handle(birth_ref.ref)
birth_date = DateHandler.get_date( event )
death_date = ""
death_ref = person.get_death_ref()
if death_ref:
event = self.database.get_event_from_handle(death_ref.ref)
death_date = DateHandler.get_date( event )
dates = _(" (%(birth_date)s - %(death_date)s)") % {
'birth_date' : birth_date,
'death_date' : death_date }
self.doc.start_row()
self.doc.start_cell('EOL-TableCell', 2)
self.doc.start_paragraph('EOL-Normal')
self.doc.write_text(name, mark)
self.doc.write_text(dates)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def write_person(self, person_handle):
"""
Write information about the given person.
"""
person = self.database.get_person_from_handle(person_handle)
name = self._name_display.display(person)
mark = ReportUtils.get_person_mark(self.database, person)
birth_date = ""
birth = get_birth_or_fallback(self.database, person)
if birth:
birth_date = DateHandler.get_date(birth)
death_date = ""
death = get_death_or_fallback(self.database, person)
if death:
death_date = DateHandler.get_date(death)
dates = _(" (%(birth_date)s - %(death_date)s)") % {
'birth_date' : birth_date,
'death_date' : death_date }
self.doc.start_paragraph('KIN-Normal')
self.doc.write_text(name, mark)
self.doc.write_text(dates)
self.doc.end_paragraph()
def column_date(self, event_ref):
event = self.db.get_event_from_handle(event_ref.ref)
retval = DateHandler.get_date(event)
if not DateHandler.get_date_valid(event):
return invalid_date_format % cgi.escape(retval)
else:
return retval
def column_death_day(self, data):
death = get_death_or_fallback(self.db, data)
if death:
if death.get_type() == gen.lib.EventType.DEATH:
return DateHandler.get_date(death)
else:
return '<i>%s</i>' % cgi.escape(DateHandler.get_date(death))
else:
return u""
def citation_date(self, data):
if data[COLUMN_DATE]:
citation = gen.lib.Citation()
citation.unserialize(data)
date_str = DateHandler.get_date(citation)
if date_str != "":
retval = cgi.escape(date_str)
if not DateHandler.get_date_valid(citation):
return INVALID_DATE_FORMAT % retval
else:
return retval
return u''
def column_date(self,data):
if data[COLUMN_DATE]:
event = gen.lib.Event()
event.unserialize(data)
date_str = DateHandler.get_date(event)
if date_str != "":
retval = cgi.escape(date_str)
if not DateHandler.get_date_valid(event):
return INVALID_DATE_FORMAT % retval
else:
return retval
return u''
def dump_child_event(self, text, name, event):
date = ""
place = ""
if event:
date = DateHandler.get_date(event)
place_handle = event.get_place_handle()
if place_handle:
place = self.database.get_place_from_handle(
place_handle).get_title()
self.doc.start_row()
self.doc.start_cell(text)
self.doc.start_paragraph('FGR-Normal')
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContents')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContents')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell('FGR-TextContentsEnd')
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(place)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def get_tip(self):
global escape
birth_str = ""
birth_ref = self._obj.get_birth_ref()
if birth_ref:
birth = self._db.get_event_from_handle(birth_ref.ref)
date_str = DateHandler.get_date(birth)
if date_str != "":
birth_str = escape(date_str)
s = "<span size=\"larger\" weight=\"bold\">%s</span>\n"\
" <span weight=\"bold\">%s:</span> %s\n"\
" <span weight=\"bold\">%s:</span> %s\n" % (
_("Person"),
_("Name"),escape(self._obj.get_primary_name().get_name()),
_("Birth"),birth_str)
if len(self._obj.get_source_references()) > 0:
psrc_ref = self._obj.get_source_references()[0]
psrc_id = psrc_ref.get_reference_handle()
psrc = self._db.get_source_from_handle(psrc_id)
s += "\n<span size=\"larger\" weight=\"bold\">%s</span>\n"\
" <span weight=\"bold\">%s:</span> %s\n" % (
_("Primary source"),
_("Name"),
escape(short(psrc.get_title())))
return s
def write_addresses(self):
alist = self.person.get_address_list()
if len(alist) == 0:
return
self.doc.start_table("addresses", "IDS-IndTable")
self.doc.start_row()
self.doc.start_cell("IDS-TableHead", 2)
self.doc.start_paragraph("IDS-TableTitle")
self.doc.write_text(_("Addresses"))
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
for addr in alist:
text = ReportUtils.get_address_str(addr)
date = DateHandler.get_date(addr)
endnotes = ""
if self.use_srcs:
endnotes = Endnotes.cite_source(self.bibli, self.database,
addr)
self.doc.start_row()
self.normal_cell(date)
self.normal_cell(text, endnotes)
self.doc.end_row()
self.doc.end_table()
self.doc.start_paragraph('IDS-Normal')
self.doc.end_paragraph()
def citation_sort_date(self, data):
if data[COLUMN_DATE]:
citation = gen.lib.Citation()
citation.unserialize(data)
retval = "%09d" % citation.get_date_object().get_sort_value()
if not DateHandler.get_date_valid(citation):
return INVALID_DATE_FORMAT % retval
else:
return retval
return u''
def add_residence(self, event):
"""
Add a residence event to the model.
"""
date = DateHandler.get_date(event)
place = ''
handle = event.get_place_handle()
if handle:
place = self.dbstate.db.get_place_from_handle(handle).get_title()
self.model.add((event.get_handle(), date, place))
def dump_parent_event(self, name, event):
place = ""
date = ""
descr = ""
if event:
date = DateHandler.get_date(event)
place_handle = event.get_place_handle()
place = ReportUtils.place_name(self.database, place_handle)
descr = event.get_description()
if self.includeAttrs:
for attr in event.get_attribute_list():
if descr:
# translators: needed for Arabic, ignore otherwise
descr += self._("; ")
descr += _("%(type)s: %(value)s") % {
'type': attr.get_type(),
'value': attr.get_value()
}
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(name)
self.doc.end_paragraph()
self.doc.end_cell()
if descr:
self.doc.start_cell("FGR-TextContentsEnd", 2)
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(descr)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
if date or place:
self.doc.start_row()
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.end_paragraph()
self.doc.end_cell()
if (date or place) or not descr:
self.doc.start_cell("FGR-TextContents")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(date)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.start_cell("FGR-TextContentsEnd")
self.doc.start_paragraph('FGR-Normal')
self.doc.write_text(place)
self.doc.end_paragraph()
self.doc.end_cell()
self.doc.end_row()
def sort_date(self,data):
if data[COLUMN_DATE]:
event = gen.lib.Event()
event.unserialize(data)
retval = "%09d" % event.get_date_object().get_sort_value()
if not DateHandler.get_date_valid(event):
return INVALID_DATE_FORMAT % retval
else:
return retval
return u''
def write_fact(self, event_ref, event, show_type=True):
"""
Writes a single event.
"""
role = event_ref.get_role()
description = event.get_description()
date = DateHandler.get_date(event)
place = ''
place_handle = event.get_place_handle()
if place_handle:
place = self.database.get_place_from_handle(
place_handle).get_title()
date_place = combine(_('%s in %s. '), '%s. ', date, place)
if show_type:
# Groups with more than one type
column_1 = str(event.get_type())
if role not in (EventRoleType.PRIMARY, EventRoleType.FAMILY):
column_1 = column_1 + ' (' + str(role) + ')'
column_2 = combine('%s, %s', '%s', description, date_place)
else:
# Groups with a single type (remove event type from first column)
column_1 = date
column_2 = combine('%s, %s', '%s', description, place)
endnotes = ""
if self.use_srcs:
endnotes = Endnotes.cite_source(self.bibli, self.database, event)
self.doc.start_row()
self.normal_cell(column_1)
self.doc.start_cell('IDS-NormalCell')
self.doc.start_paragraph('IDS-Normal')
self.doc.write_text(column_2)
if endnotes:
self.doc.start_superscript()
self.doc.write_text(endnotes)
self.doc.end_superscript()
self.doc.end_paragraph()
for notehandle in event.get_note_list():
note = self.database.get_note_from_handle(notehandle)
text = note.get_styledtext()
note_format = note.get_format()
self.doc.write_styled_note(
text,
note_format,
'IDS-Normal',
contains_html=note.get_type() == NoteType.HTML_CODE)
self.doc.end_cell()
self.doc.end_row()
def _get_birth_data(self, data, sort_mode):
index = data[COLUMN_BIRTH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
b = EventRef()
b.unserialize(local)
birth = self.db.get_event_from_handle(b.ref)
if sort_mode:
retval = "%09d" % birth.get_date_object().get_sort_value()
else:
date_str = DateHandler.get_date(birth)
if date_str != "":
retval = cgi.escape(date_str)
if not DateHandler.get_date_valid(birth):
return invalid_date_format % retval
else:
return retval
except:
return u''
for event_ref in data[COLUMN_EVENT]:
er = EventRef()
er.unserialize(event_ref)
event = self.db.get_event_from_handle(er.ref)
etype = event.get_type()
date_str = DateHandler.get_date(event)
if (etype in [EventType.BAPTISM, EventType.CHRISTEN]
and er.get_role() == EventRoleType.PRIMARY
and date_str != ""):
if sort_mode:
retval = "%09d" % event.get_date_object().get_sort_value()
else:
retval = u"<i>%s</i>" % cgi.escape(date_str)
if not DateHandler.get_date_valid(event):
return invalid_date_format % retval
else:
return retval
return u""
def _get_death_data(self, data, sort_mode):
index = data[COLUMN_DEATH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
ref = EventRef()
ref.unserialize(local)
event = self.db.get_event_from_handle(ref.ref)
if sort_mode:
retval = "%09d" % event.get_date_object().get_sort_value()
else:
date_str = DateHandler.get_date(event)
if date_str != "":
retval = cgi.escape(date_str)
if not DateHandler.get_date_valid(event):
return invalid_date_format % retval
else:
return retval
except:
return u''
for event_ref in data[COLUMN_EVENT]:
er = EventRef()
er.unserialize(event_ref)
event = self.db.get_event_from_handle(er.ref)
etype = event.get_type()
date_str = DateHandler.get_date(event)
if (etype in [
EventType.BURIAL, EventType.CREMATION,
EventType.CAUSE_DEATH
] and er.get_role() == EventRoleType.PRIMARY and date_str):
if sort_mode:
retval = "%09d" % event.get_date_object().get_sort_value()
else:
retval = "<i>%s</i>" % cgi.escape(date_str)
if not DateHandler.get_date_valid(event):
return invalid_date_format % retval
else:
return retval
return u""
def column_marriage(self, data):
from gen.utils import get_marriage_or_fallback
family = self.db.get_family_from_handle(data[0])
event = get_marriage_or_fallback(self.db, family, "<i>%s</i>")
if event:
if event.date.format:
return event.date.format % DateHandler.displayer.display(event.date)
elif not DateHandler.get_date_valid(event):
return invalid_date_format % DateHandler.displayer.display(event.date)
else:
return "%s" % DateHandler.displayer.display(event.date)
else:
return u''
def format_event(self, event):
"""
Format the event for display.
"""
date = DateHandler.get_date(event)
handle = event.get_place_handle()
if handle:
place = self.dbstate.db.get_place_from_handle(handle).get_title()
retval = _('%(date)s - %(place)s.') % {'date' : date,
'place' : place}
else:
retval = _('%(date)s.') % dict(date = date)
return retval
def __init__(self, lds_list, db):
gtk.ListStore.__init__(self, str, str, str, str, str, object)
self.db = db
for lds_ord in lds_list:
self.append(row=[
lds_ord.type2str(),
DateHandler.get_date(lds_ord),
lds_ord.status2str(),
LdsUtils.TEMPLES.name(lds_ord.get_temple()),
self.column_place(lds_ord),
lds_ord,
])
def add_person(self, person):
"""
Add a person to the Graph. The node id will be the person's gramps id.
"""
p_id = person.get_gramps_id()
name = name_displayer.display_formal(person)
birth_evt = get_birth_or_fallback(self.__db, person)
if birth_evt:
birth = DateHandler.get_date(birth_evt)
else:
birth = ""
death_evt = get_death_or_fallback(self.__db, person)
if death_evt:
death = DateHandler.get_date(death_evt)
else:
death = ""
label = "%s \\n(%s - %s)" % (name, birth, death)
(shape, style, color, fill) = self.get_gender_style(person)
self.doc.add_node(p_id, label, shape, color, style, fill)
def get_event_info(self, handle):
"""Return date and place of an event as string."""
date = ""
place = ""
if handle:
event = self.database.get_event_from_handle(handle)
date = DateHandler.get_date(event)
place = self.place_name(event)
if date:
return ("%s, %s" % (date, place)) if place else date
else:
return place or ""
else:
return ""
def info_string(self, person):
birth = get_birth_or_fallback(self.dbstate.db, person)
if birth and birth.get_type() != gen.lib.EventType.BIRTH:
sdate = DateHandler.get_date(birth)
if sdate:
bdate = "<i>%s</i>" % cgi.escape(sdate)
else:
bdate = ""
elif birth:
bdate = cgi.escape(DateHandler.get_date(birth))
else:
bdate = ""
death = get_death_or_fallback(self.dbstate.db, person)
if death and death.get_type() != gen.lib.EventType.DEATH:
sdate = DateHandler.get_date(death)
if sdate:
ddate = "<i>%s</i>" % cgi.escape(sdate)
else:
ddate = ""
elif death:
ddate = cgi.escape(DateHandler.get_date(death))
else:
ddate = ""
if bdate and ddate:
value = _("(b. %(birthdate)s, d. %(deathdate)s)") % {
'birthdate': bdate,
'deathdate': ddate
}
elif bdate:
value = _("(b. %s)") % (bdate)
elif ddate:
value = _("(d. %s)") % (ddate)
else:
value = ""
return value
def get_date_place(self, event):
"""
Return the date and place of the given event.
"""
event_date = ''
event_place = ''
event_sort = '%012d' % 0
if event:
event_date = DateHandler.get_date(event)
event_sort = '%012d' % event.get_date_object().get_sort_value()
handle = event.get_place_handle()
if handle:
place = self.dbstate.db.get_place_from_handle(handle)
event_place = place.get_title()
return (event_date, event_sort, event_place)
def build_row_data(self):
self.progress_bar = ProgressMeter(_('Comparing Events'), '')
self.progress_bar.set_pass(_('Building data'), len(self.my_list))
for individual_id in self.my_list:
individual = self.db.get_person_from_handle(individual_id)
name = individual.get_primary_name().get_name()
gid = individual.get_gramps_id()
the_map = defaultdict(list)
for ievent_ref in individual.get_event_ref_list():
ievent = self.db.get_event_from_handle(ievent_ref.ref)
event_name = str(ievent.get_type())
the_map[event_name].append(ievent_ref.ref)
first = True
done = False
while not done:
added = False
tlist = [name, gid] if first else ["", ""]
for ename in self.event_titles:
if ename in the_map and len(the_map[ename]) > 0:
event_handle = the_map[ename][0]
del the_map[ename][0]
date = place = ""
if event_handle:
event = self.db.get_event_from_handle(event_handle)
date = DateHandler.get_date(event)
sortdate = "%09d" % (
event.get_date_object().get_sort_value())
place_handle = event.get_place_handle()
if place_handle:
place = self.db.get_place_from_handle(
place_handle).get_title()
tlist += [date, sortdate, place]
added = True
else:
tlist += [""] * 3
if first:
first = False
self.row_data.append(tlist)
elif not added:
done = True
else:
self.row_data.append(tlist)
self.progress_bar.step()
def __init__(self, obj_list, dbase):
"""
AddressModel derives from the ListStore, defining te items in the list
"""
gtk.ListStore.__init__(self, str, str, str, str, str, str, object)
self.db = dbase
for obj in obj_list:
self.append(row=[
DateHandler.get_date(obj),
obj.street,
obj.locality,
obj.city,
obj.state,
obj.country,
obj,
])
def add_family(self, family):
"""
Add a family to the Graph. The node id will be the family's gramps id.
"""
family_id = family.get_gramps_id()
label = ""
marriage = ReportUtils.find_marriage(self.__db, family)
if marriage:
label = DateHandler.get_date(marriage)
color = ""
fill = ""
style = "solid"
if self.colorize == 'colored':
color = self.colors['family']
elif self.colorize == 'filled':
fill = self.colors['family']
style = "filled"
self.doc.add_node(family_id, label, "ellipse", color, style, fill)
def __date_place(self, event):
if event:
date = DateHandler.get_date(event)
place_handle = event.get_place_handle()
if place_handle:
place = self.database.get_place_from_handle(
place_handle).get_title()
return ("%(event_abbrev)s %(date)s - %(place)s" % {
'event_abbrev': event.type.get_abbreviation(),
'date': date,
'place': place,
})
else:
return ("%(event_abbrev)s %(date)s" % {
'event_abbrev': event.type.get_abbreviation(),
'date': date
})
return ""
def get_event_info(self, handle):
date = ""
place = ""
if handle:
event = self.db.get_event_from_handle(handle)
date = DateHandler.get_date(event)
place = self.place_name(event)
if date:
if place:
return "%s, %s" % (date, place)
else:
return date
else:
if place:
return place
else:
return ""
else:
return ""
def get_event_info(self,handle):
date = ""
place = ""
if handle:
event = self.db.get_event_from_handle(handle)
date = DateHandler.get_date(event)
place = self.place_name(event)
if date:
if place:
return "%s, %s" % (date,place)
else:
return date
else:
if place:
return place
else:
return ""
else:
return ""
