def column_birth_place(self, data):
index = data[COLUMN_BIRTH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
br = EventRef()
br.unserialize(local)
event = self.db.get_event_from_handle(br.ref)
if event:
place_title = place_displayer.display_event(self.db, event)
if place_title:
return escape(place_title)
except:
return ''
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()
if (etype in [EventType.BAPTISM, EventType.CHRISTEN] and
er.get_role() == EventRoleType.PRIMARY):
place_title = place_displayer.display_event(self.db, event)
if place_title:
return "<i>%s</i>" % escape(place_title)
return ""
def column_death_place(self, data):
index = data[COLUMN_DEATH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
dr = EventRef()
dr.unserialize(local)
event = self.db.get_event_from_handle(dr.ref)
if event:
place_title = place_displayer.display_event(self.db, event)
if place_title:
return escape(place_title)
except:
return ''
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()
if (etype in [EventType.BURIAL, EventType.CREMATION,
EventType.CAUSE_DEATH]
and er.get_role() == EventRoleType.PRIMARY):
place_title = place_displayer.display_event(self.db, event)
if place_title:
return "<i>%s</i>" % escape(place_title)
return ""
def column_death_place(self, data):
index = data[COLUMN_DEATH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
dr = EventRef()
dr.unserialize(local)
event = self.db.get_event_from_handle(dr.ref)
if event:
place_title = place_displayer.display_event(self.db, event)
if place_title:
return escape(place_title)
except:
return ''
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()
if (etype in [
EventType.BURIAL, EventType.CREMATION,
EventType.CAUSE_DEATH
] and er.get_role() == EventRoleType.PRIMARY):
place_title = place_displayer.display_event(self.db, event)
if place_title:
return "<i>%s</i>" % escape(place_title)
return ""
def column_birth_place(self, data):
index = data[COLUMN_BIRTH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
br = EventRef()
br.unserialize(local)
event = self.db.get_event_from_handle(br.ref)
if event:
place_title = place_displayer.display_event(self.db, event)
if place_title:
return escape(place_title)
except:
return ''
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()
if (etype in [EventType.BAPTISM, EventType.CHRISTEN]
and er.get_role() == EventRoleType.PRIMARY):
place_title = place_displayer.display_event(self.db, event)
if place_title:
return "<i>%s</i>" % escape(place_title)
return ""
def write_event_ref(self, vbox, ename, event):
if event:
dobj = event.get_date_object()
phandle = event.get_place_handle()
if phandle:
pname = place_displayer.display_event(self.dbstate.db, event)
else:
pname = None
value = {
'date' : displayer.display(dobj),
'place' : pname,
'event_type' : ename,
}
else:
pname = None
dobj = None
value = { 'event_type' : ename, }
if dobj:
if pname:
self.write_data(
vbox, _('%(event_type)s: %(date)s in %(place)s') %
value)
else:
self.write_data(
vbox, _('%(event_type)s: %(date)s') % value)
elif pname:
self.write_data(
vbox, _('%(event_type)s: %(place)s') % value)
else:
self.write_data(
vbox, '%(event_type)s:' % value)
def find_place(self, event):
"""
# Use the most recent occupation residence.
# """
placetxt = " "
placetxt = _pd.display_event(self.__db, event, self.pl_format)
return (placetxt[4:-2])
def column_place(self, data):
if data[COLUMN_PLACE]:
event = Event()
event.unserialize(data)
return place_displayer.display_event(self.db, event)
else:
return ''
def dump_child_event(self, text, name, event):
date = ""
place = ""
if event:
date = self._get_date(event.get_date_object())
place_handle = event.get_place_handle()
if place_handle:
place = place_displayer.display_event(self.database, event)
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 add_event_ref(self, event_ref, spouse=None):
"""
Add an event to the model.
"""
self.callman.register_handles({'event': [event_ref.ref]})
event = self.dbstate.db.get_event_from_handle(event_ref.ref)
event_date = get_date(event)
event_sort = '%012d' % event.get_date_object().get_sort_value()
person_age = self.column_age(event)
person_age_sort = self.column_sort_age(event)
place = place_displayer.display_event(self.dbstate.db, event)
participants = get_participant_from_event(self.dbstate.db,
event_ref.ref)
self.model.add((event.get_handle(),
str(event.get_type()),
participants,
event_date,
event_sort,
person_age,
person_age_sort,
place,
event.get_description(),
str(event_ref.get_role())))
def add_event_ref(self, event_ref, spouse=None, name=""):
"""
Add an event to the model.
"""
self.callman.register_handles({'event': [event_ref.ref]})
event = self.dbstate.db.get_event_from_handle(event_ref.ref)
event_date = get_date(event)
event_sort = '%012d' % event.get_date_object().get_sort_value()
place_name = place_displayer.display_event(self.dbstate.db, event)
place_handle = event.get_place_handle()
place_id = latitude = longitude = ""
if place_handle:
plc = self.dbstate.db.get_place_from_handle(place_handle)
if plc:
place_id = plc.get_gramps_id()
latitude = plc.get_latitude()
longitude = plc.get_longitude()
latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8")
description = event.get_description()
if description == "":
description = name
self.model.add((event.get_handle(),
str(event.get_type()),
description,
event_date,
event_sort,
place_name,
place_id,
latitude,
longitude
))
def column_death_place(self, data):
event_ref = data.get_death_ref()
if event_ref and event_ref.ref:
event = self.db.get_event_from_handle(event_ref.ref)
if event:
return place_displayer.display_event(self.db, event)
return ""
def add_event_ref(self, event_ref, spouse=None):
"""
Add an event to the model.
"""
self.callman.register_handles({'event': [event_ref.ref]})
event = self.dbstate.db.get_event_from_handle(event_ref.ref)
event_date = get_date(event)
event_sort = '%012d' % event.get_date_object().get_sort_value()
person_age = self.column_age(event)
person_age_sort = self.column_sort_age(event)
place = place_displayer.display_event(self.dbstate.db, event)
participants = get_participant_from_event(self.dbstate.db,
event_ref.ref)
self.model.add((event.get_handle(),
str(event.get_type()),
event.get_description(),
event_date,
event_sort,
person_age,
person_age_sort,
place,
participants,
str(event_ref.get_role())))
def dump_child_event(self,text, name,event):
date = ""
place = ""
if event:
date = self._get_date(event.get_date_object())
place_handle = event.get_place_handle()
if place_handle:
place = place_displayer.display_event(self.database, event)
if place is None:
place = ''
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 column_place(self,data):
if data[COLUMN_PLACE]:
event = Event()
event.unserialize(data)
return place_displayer.display_event(self.db, event)
else:
return ''
def format_event(self, event):
if event:
dobj = event.get_date_object()
phandle = event.get_place_handle()
if phandle:
pname = place_displayer.display_event(self.dbstate.db, event)
else:
pname = None
value = {
'date' : displayer.display(dobj),
'place' : pname,
}
else:
pname = None
dobj = None
if dobj:
if pname:
return _('%(date)s in %(place)s') % value
else:
return '%(date)s' % value
elif pname:
return pname
else:
return ''
def sort_places(dbase, handle_list, rlocale=glocale):
"""
will sort the database places
"""
pname_sub = defaultdict(list)
for place_name in handle_list.keys():
(hdle, pname, dummy_id, event) = handle_list[place_name]
place = dbase.get_place_from_handle(hdle)
pname = _pd.display(dbase, place)
apname = _pd.display_event(dbase, event)
pname_sub[pname].append(hdle)
if pname != apname:
pname_sub[apname].append(hdle)
sorted_lists = []
temp_list = sorted(pname_sub, key=rlocale.sort_key)
for name in temp_list:
if isinstance(name, bytes):
name = name.decode('utf-8')
sorted_lists.append((name, pname_sub[name][0]))
return sorted_lists
def get_event_text(self, the_type, handle, data):
"""
Come up with a short line of text that we can use as
a summary to represent this event.
"""
# get the event:
event = self.tables[the_type]['get_func'](handle)
# first check to see if the event has a descriptive name
text = event.get_description() # (this is rarely set for events)
# if we don't have a description...
if text == '':
# ... then we merge together several fields
# get the event type (marriage, birth, death, etc.)
text = str(event.get_type())
# see if there is a date
date = _dd.display(event.get_date_object())
if date != '':
text += '; %s' % date
# see if there is a place
if event.get_place_handle():
text += '; %s' % _pd.display_event(self.db, event)
return text
def get_event_text(self, the_type, handle, data):
"""
Come up with a short line of text that we can use as
a summary to represent this event.
"""
# get the event:
event = self.tables[the_type]['get_func'](handle)
# first check to see if the event has a descriptive name
text = event.get_description() # (this is rarely set for events)
# if we don't have a description...
if text == '':
# ... then we merge together several fields
# get the event type (marriage, birth, death, etc.)
text = str(event.get_type())
# see if there is a date
date = _dd.display(event.get_date_object())
if date != '':
text += '; %s' % date
# see if there is a place
if event.get_place_handle():
text += '; %s' % _pd.display_event(self.db, event)
return text
def column_death_place(self, data):
event_ref = data.get_death_ref()
if event_ref and event_ref.ref:
event = self.db.get_event_from_handle(event_ref.ref)
if event:
return place_displayer.display_event(self.db, event)
return ""
def get_place(self, event):
"return place for given event"
place_handle = event.get_place_handle()
if place_handle:
place = _pd.display_event(self.db, event)
if place:
return [place]
return [_T_("Place missing")]
def format_place():
""" start formatting a place in this event """
# TO_FIX: bug 9562
#place_format = PlaceFormat(self, self.string_in)
#place = place_format.get_place(self.database, event)
#return place_format.parse_format(self.database, place)
place = place_displayer.display_event(self.database, event)
return place
def get_place(self, event):
"return place for given event"
place_handle = event.get_place_handle()
if place_handle:
place = _pd.display_event(self.db, event)
if place:
return [place]
return [_T_("Place missing")]
def get_full_person_info(self, person):
retval = ""
b_date = "0"
b_place = ""
birth_ref = person.get_birth_ref()
for event_ref in person.get_event_ref_list():
role = int(event_ref.get_role())
if role != EventRoleType.PRIMARY:
next
event = self.db.get_event_from_handle(event_ref.ref)
etype = int(event.get_type())
val = PERSONCONSTANTEVENTS.get(etype)
if birth_ref:
birth = self.db.get_event_from_handle(birth_ref.ref)
if birth:
b_date = self.format_date(birth.get_date_object())
if not b_date:
b_date = "0"
place_handle = birth.get_place_handle()
if place_handle:
b_place = _pd.display_event(self.db, birth)
if probably_alive(person, self.db):
d_date = ""
else:
d_date = "0"
d_place = ""
death_ref = person.get_death_ref()
if death_ref:
death = self.db.get_event_from_handle(death_ref.ref)
if death:
d_date = self.format_date(death.get_date_object())
place_handle = death.get_place_handle()
if place_handle:
d_place = _pd.display_event(self.db, death)
retval = retval + "%s " % b_date
if b_place != "":
retval = retval + "#bp %s " % self.rem_spaces(b_place)
retval = retval + "%s " % d_date
if d_place != "":
retval = retval + "#dp %s " % self.rem_spaces(d_place)
return retval
def dump_parent_event(self, name, event):
place = ""
date = ""
descr = ""
if event:
date = self._get_date(event.get_date_object())
place = _pd.display_event(self.db, event)
if place is None:
place = ''
descr = event.get_description()
if self.include_attrs:
for attr in event.get_attribute_list():
if descr:
# translators: needed for Arabic, ignore otherwise
descr += self._("; ")
attr_type = self._get_type(attr.get_type())
# translators: needed for French, ignore otherwise
descr += self._("%(str1)s: %(str2)s") % {
'str1': self._(attr_type),
'str2': 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 dump_parent_event(self, name,event):
place = ""
date = ""
descr = ""
if event:
date = self._get_date(event.get_date_object())
place = place_displayer.display_event(self.database, event)
if place is None:
place = ''
descr = event.get_description()
if self.includeAttrs:
for attr in event.get_attribute_list():
if descr:
# translators: needed for Arabic, ignore otherwise
descr += self._("; ")
attr_type = self._get_type(attr.get_type())
# translators: needed for French, ignore otherwise
descr += self._("%(str1)s: %(str2)s") % {
'str1' : self._(attr_type),
'str2' : 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 add_residence(self, event):
"""
Add a residence event to the model.
"""
date = get_date(event)
place = ''
handle = event.get_place_handle()
if handle:
place = place_displayer.display_event(self.dbstate.db, event)
self.model.add((event.get_handle(), date, place))
def column_death_place(self, data):
handle = data[0]
cached, value = self.get_cached_value(handle, "DEATH_PLACE")
if cached:
return value
else:
index = data[COLUMN_DEATH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
dr = EventRef()
dr.unserialize(local)
event = self.db.get_event_from_handle(dr.ref)
if event:
place_title = place_displayer.display_event(
self.db, event)
if place_title:
value = escape(place_title)
self.set_cached_value(handle, "DEATH_PLACE", value)
return value
except:
value = ''
self.set_cached_value(handle, "DEATH_PLACE", value)
return value
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()
if (etype in [
EventType.BURIAL, EventType.CREMATION,
EventType.CAUSE_DEATH
] and er.get_role() == EventRoleType.PRIMARY):
place_title = place_displayer.display_event(self.db, event)
if place_title:
value = "<i>%s</i>" % escape(place_title)
self.set_cached_value(handle, "DEATH_PLACE", value)
return value
value = ""
self.set_cached_value(handle, "DEATH_PLACE", value)
return value
def add_residence(self, event):
"""
Add a residence event to the model.
"""
date = get_date(event)
place = ''
handle = event.get_place_handle()
if handle:
place = place_displayer.display_event(self.dbstate.db, event)
self.model.add((event.get_handle(), date, place))
def column_death_place(self, data):
handle = data[0]
cached, value = self.get_cached_value(handle, "DEATH_PLACE")
if cached:
return value
else:
index = data[COLUMN_DEATH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
dr = EventRef()
dr.unserialize(local)
event = self.db.get_event_from_handle(dr.ref)
if event:
place_title = place_displayer.display_event(self.db, event)
if place_title:
value = escape(place_title)
self.set_cached_value(handle, "DEATH_PLACE", value)
return value
except:
value = ""
self.set_cached_value(handle, "DEATH_PLACE", value)
return value
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()
if (
etype in [EventType.BURIAL, EventType.CREMATION, EventType.CAUSE_DEATH]
and er.get_role() == EventRoleType.PRIMARY
):
place_title = place_displayer.display_event(self.db, event)
if place_title:
value = "<i>%s</i>" % escape(place_title)
self.set_cached_value(handle, "DEATH_PLACE", value)
return value
value = ""
self.set_cached_value(handle, "DEATH_PLACE", value)
return value
def column_place(self,data):
if data[COLUMN_PLACE]:
cached, value = self.get_cached_value(data[0], "PLACE")
if not cached:
event = Event()
event.unserialize(data)
value = place_displayer.display_event(self.db, event)
self.set_cached_value(data[0], "PLACE", value)
return value
else:
return ''
def column_place(self, data):
if data[COLUMN_PLACE]:
cached, value = self.get_cached_value(data[0], "PLACE")
if not cached:
event = Event()
event.unserialize(data)
value = place_displayer.display_event(self.db, event)
self.set_cached_value(data[0], "PLACE", value)
return value
else:
return ''
def format_event(self, event):
"""
Format the event for display.
"""
date = get_date(event)
handle = event.get_place_handle()
if handle:
place = place_displayer.display_event(self.dbstate.db, event)
retval = _("%(date)s - %(place)s.") % {"date": date, "place": place}
else:
retval = _("%(date)s.") % dict(date=date)
return retval
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 = get_date(event)
event_sort = '%012d' % event.get_date_object().get_sort_value()
event_place = place_displayer.display_event(self.dbstate.db, event)
return (event_date, event_sort, event_place)
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 = get_date(event)
event_sort = '%012d' % event.get_date_object().get_sort_value()
event_place = place_displayer.display_event(self.dbstate.db, event)
return (event_date, event_sort, event_place)
def get_place_string(self, event):
"""
return place string for an event label.
Based on the data availability and preferences, we select one
of the following for a given event:
place name
empty string
"""
if event and self.event_choice in [2, 3, 5, 6, 7]:
return place_displayer.display_event(self._db, event)
return ''
def get_place_string(self, event):
"""
return place string for an event label.
Based on the data availability and preferences, we select one
of the following for a given event:
place name
empty string
"""
if event and self.event_choice in [2, 3, 5, 6, 7]:
return _pd.display_event(self._db, event)
return ''
def column_birth_place(self, data):
handle = data[0]
cached, value = self.get_cached_value(handle, "BIRTH_PLACE")
if cached:
return value
else:
index = data[COLUMN_BIRTH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
br = EventRef()
br.unserialize(local)
event = self.db.get_event_from_handle(br.ref)
if event:
place_title = place_displayer.display_event(
self.db, event)
if place_title:
value = escape(place_title)
self.set_cached_value(handle, "BIRTH_PLACE", value)
return value
except:
value = ''
self.set_cached_value(handle, "BIRTH_PLACE", value)
return value
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()
if (etype.is_birth_fallback()
and er.get_role() == EventRoleType.PRIMARY):
place_title = place_displayer.display_event(self.db, event)
if place_title:
value = "<i>%s</i>" % escape(place_title)
self.set_cached_value(handle, "BIRTH_PLACE", value)
return value
value = ""
self.set_cached_value(handle, "BIRTH_PLACE", value)
return value
def write_person(self, person_handle):
person = self.db.get_person_from_handle(person_handle)
if person:
birth_ref = person.get_birth_ref()
if birth_ref:
birth = self.db.get_event_from_handle(birth_ref.ref)
if birth:
b_date = birth.get_date_object()
place_handle = birth.get_place_handle()
if place_handle:
# feature requests 2356, 1657: avoid genitive form
place_title = _pd.display_event(self.db, birth)
self.write_vevent(
_("Birth of %s") %
person.get_primary_name().get_name(), b_date,
place_title)
else:
# feature requests 2356, 1657: avoid genitive form
self.write_vevent(
_("Birth of %s") %
person.get_primary_name().get_name(), b_date)
death_ref = person.get_death_ref()
if death_ref:
death = self.db.get_event_from_handle(death_ref.ref)
if death:
d_date = death.get_date_object()
place_handle = death.get_place_handle()
if place_handle:
# feature requests 2356, 1657: avoid genitive form
place_title = _pd.display_event(self.db, death)
self.write_vevent(
_("Death of %s") %
person.get_primary_name().get_name(), d_date,
place_title)
else:
# feature requests 2356, 1657: avoid genitive form
self.write_vevent(
_("Death of %s") %
person.get_primary_name().get_name(), d_date)
def write_person(self, person_handle):
person = self.db.get_person_from_handle(person_handle)
if person:
birth_ref = person.get_birth_ref()
if birth_ref:
birth = self.db.get_event_from_handle(birth_ref.ref)
if birth:
b_date = birth.get_date_object()
place_handle = birth.get_place_handle()
if place_handle:
# feature requests 2356, 1657: avoid genitive form
place_title = _pd.display_event(self.db, birth)
self.write_vevent(_("Birth of %s") %
person.get_primary_name().get_name(),
b_date, place_title)
else:
# feature requests 2356, 1657: avoid genitive form
self.write_vevent(_("Birth of %s") %
person.get_primary_name().get_name(),
b_date)
death_ref = person.get_death_ref()
if death_ref:
death = self.db.get_event_from_handle(death_ref.ref)
if death:
d_date = death.get_date_object()
place_handle = death.get_place_handle()
if place_handle:
# feature requests 2356, 1657: avoid genitive form
place_title = _pd.display_event(self.db, death)
self.write_vevent(_("Death of %s") %
person.get_primary_name().get_name(),
d_date,
place_title)
else:
# feature requests 2356, 1657: avoid genitive form
self.write_vevent(_("Death of %s") %
person.get_primary_name().get_name(),
d_date)
def format_event(self, event):
"""
Format the event for display.
"""
date = get_date(event)
handle = event.get_place_handle()
if handle:
place = place_displayer.display_event(self.dbstate.db, event)
retval = _('%(date)s - %(place)s.') % {'date' : date,
'place' : place}
else:
retval = _('%(date)s.') % dict(date = date)
return retval
def get_full_person_info(self, person):
# FIXME:
#if self.restrict:
# return "0 "
retval = ""
b_date = "0"
b_place = ""
birth_ref = person.get_birth_ref()
if birth_ref:
birth = self.db.get_event_from_handle(birth_ref.ref)
if birth:
b_date = self.format_date( birth.get_date_object())
place_handle = birth.get_place_handle()
if place_handle:
b_place = _pd.display_event(self.db, birth)
if probably_alive(person,self.db):
d_date = ""
else:
d_date = "0"
d_place = ""
death_ref = person.get_death_ref()
if death_ref:
death = self.db.get_event_from_handle(death_ref.ref)
if death:
d_date = self.format_date( death.get_date_object())
place_handle = death.get_place_handle()
if place_handle:
d_place = _pd.display_event(self.db, death)
retval = retval + "%s " % b_date
if b_place != "":
retval = retval + "#bp %s " % self.rem_spaces(b_place)
retval = retval + "%s " % d_date
if d_place != "":
retval = retval + "#dp %s " % self.rem_spaces(d_place)
return retval
def __init__(self, lds_list, db):
Gtk.ListStore.__init__(self, str, str, str, str, str, bool, object)
for lds_ord in lds_list:
self.append(row=[
lds_ord.type2str(),
get_date(lds_ord),
lds_ord.status2str(),
TEMPLES.name(lds_ord.get_temple()),
place_displayer.display_event(db, lds_ord),
lds_ord.get_privacy(),
lds_ord,
])
def add_event_ref(self, event_ref):
db = self.dbstate.db
event = db.get_event_from_handle(event_ref.ref)
if event:
role_text = str(event_ref.role)
place_text = place_displayer.display_event(db, event)
citation = get_form_citation(db, event)
if citation:
source_handle = citation.get_reference_handle()
source = db.get_source_from_handle(source_handle)
source_text = source.get_title()
self.model.append((citation, source_text, role_text,
get_date(event), place_text))
def get_full_person_info(self, person):
# FIXME:
#if self.restrict:
# return "0 "
retval = ""
b_date = "0"
b_place = ""
birth_ref = person.get_birth_ref()
if birth_ref:
birth = self.db.get_event_from_handle(birth_ref.ref)
if birth:
b_date = self.format_date(birth.get_date_object())
place_handle = birth.get_place_handle()
if place_handle:
b_place = _pd.display_event(self.db, birth)
if probably_alive(person, self.db):
d_date = ""
else:
d_date = "0"
d_place = ""
death_ref = person.get_death_ref()
if death_ref:
death = self.db.get_event_from_handle(death_ref.ref)
if death:
d_date = self.format_date(death.get_date_object())
place_handle = death.get_place_handle()
if place_handle:
d_place = _pd.display_event(self.db, death)
retval = retval + "%s " % b_date
if b_place != "":
retval = retval + "#bp %s " % self.rem_spaces(b_place)
retval = retval + "%s " % d_date
if d_place != "":
retval = retval + "#dp %s " % self.rem_spaces(d_place)
return retval
def __init__(self, lds_list, db):
Gtk.ListStore.__init__(self, str, str, str, str, str, bool, object)
for lds_ord in lds_list:
self.append(row=[
lds_ord.type2str(),
get_date(lds_ord),
lds_ord.status2str(),
TEMPLES.name(lds_ord.get_temple()),
place_displayer.display_event(db, lds_ord),
lds_ord.get_privacy(),
lds_ord,
])
def column_birth_place(self, data):
handle = data[0]
cached, value = self.get_cached_value(handle, "BIRTH_PLACE")
if cached:
return value
else:
index = data[COLUMN_BIRTH]
if index != -1:
try:
local = data[COLUMN_EVENT][index]
br = EventRef()
br.unserialize(local)
event = self.db.get_event_from_handle(br.ref)
if event:
place_title = place_displayer.display_event(self.db, event)
if place_title:
value = escape(place_title)
self.set_cached_value(handle, "BIRTH_PLACE", value)
return value
except:
value = ""
self.set_cached_value(handle, "BIRTH_PLACE", value)
return value
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()
if etype in [EventType.BAPTISM, EventType.CHRISTEN] and er.get_role() == EventRoleType.PRIMARY:
place_title = place_displayer.display_event(self.db, event)
if place_title:
value = "<i>%s</i>" % escape(place_title)
self.set_cached_value(handle, "BIRTH_PLACE", value)
return value
value = ""
self.set_cached_value(handle, "BIRTH_PLACE", value)
return value
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 = get_date(event)
place = place_displayer.display_event(self.database, event)
if date:
return ("%s, %s" % (date, place)) if place else date
else:
return place or ""
else:
return ""
def get_places(self, data):
"return places for given (person,event_handles)"
places = []
person, event_handles = data
for event_handle in event_handles:
event = self.db.get_event_from_handle(event_handle)
place_handle = event.get_place_handle()
if place_handle:
place = _pd.display_event(self.db, event)
if place:
places.append(place)
else:
places.append(_T_("Place missing"))
return places
def format_place(self, event):
"""
If places are included in the export return a link, else return a
formatted place for the given event.
"""
if self.include_places:
place_handle = event.get_place_handle()
if place_handle:
place = self.db.get_place_from_handle(place_handle)
if place:
return "[%s]" % place.get_gramps_id()
return ""
else:
return _pd.display_event(self.db, event)
def get_places(self, data):
"return places for given (person,event_handles)"
places = []
person, event_handles = data
for event_handle in event_handles:
event = self.db.get_event_from_handle(event_handle)
place_handle = event.get_place_handle()
if place_handle:
place = _pd.display_event(self.db, event)
if place:
places.append(place)
else:
places.append(_T_("Place missing"))
return places
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 = get_date(event)
place = place_displayer.display_event(self.database, event)
if date:
return ("%s, %s" % (date, place)) if place else date
else:
return place or ""
else:
return ""
def write_family(self, family_handle):
family = self.db.get_family_from_handle(family_handle)
if family:
for event_ref in family.get_event_ref_list():
event = self.db.get_event_from_handle(event_ref.ref)
if event.get_type() == EventType.MARRIAGE:
m_date = event.get_date_object()
place_handle = event.get_place_handle()
# feature requests 2356, 1657: avoid genitive form
text = _("Marriage of %s") % family_name(family, self.db)
if place_handle:
place_title = _pd.display_event(self.db, event)
self.write_vevent( text, m_date, place_title)
else:
self.write_vevent( text, m_date)
def write_LDS_ordinances(self):
""" write any LDS ordinances of the person """
ord_list = self.person.get_lds_ord_list()
if len(ord_list) == 0:
return
self.doc.start_table("ordinances", "IDS-IndTable")
self.doc.start_row()
self.doc.start_cell("IDS-TableHead", 2)
self.write_paragraph(self._('LDS Ordinance'), style='IDS-TableTitle')
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
self.doc.start_table("ordinances3", "IDS-OrdinanceTable")
self.doc.start_row()
self.write_cell(self._('Type'), style='IDS-Section')
self.write_cell(self._('Date'), style='IDS-Section')
self.write_cell(self._('Status'), style='IDS-Section')
self.write_cell(self._('Temple'), style='IDS-Section')
self.write_cell(self._('Place'), style='IDS-Section')
self.doc.end_row()
for lds_ord in ord_list:
otype = self._(lds_ord.type2str())
date = self._get_date(lds_ord.get_date_object())
status = self._(lds_ord.status2str())
temple = TEMPLES.name(lds_ord.get_temple())
place_name = ''
place_endnote = ''
place_handle = lds_ord.get_place_handle()
if place_handle:
place = self._db.get_place_from_handle(place_handle)
place_name = _pd.display_event(self._db, lds_ord)
place_endnote = self._cite_endnote(place)
endnotes = self._cite_endnote(lds_ord, prior=place_endnote)
self.doc.start_row()
self.write_cell(otype, endnotes)
self.write_cell(date)
self.write_cell(status)
self.write_cell(temple)
self.write_cell(place_name)
self.doc.end_row()
self.doc.end_table()
self.doc.start_paragraph('IDS-Normal')
self.doc.end_paragraph()
def __date_place(self, event):
if event:
date = get_date(event)
place_title = place_displayer.display_event(self.database, event)
if place_title:
return("%(event_abbrev)s %(date)s - %(place)s" % {
'event_abbrev': event.type.get_abbreviation(),
'date' : date,
'place' : place_title,
})
else:
return("%(event_abbrev)s %(date)s" % {
'event_abbrev': event.type.get_abbreviation(),
'date' : date
})
return ""
def __date_place(self, event):
""" return the date and/or place an event happened """
if event:
date = self._get_date(event.get_date_object())
place_handle = event.get_place_handle()
if place_handle:
place = _pd.display_event(self.database, event)
return("%(event_abbrev)s %(date)s - %(place)s" % {
'event_abbrev': event.type.get_abbreviation(self._),
'date' : date,
'place' : place,
})
else:
return("%(event_abbrev)s %(date)s" % {
'event_abbrev': event.type.get_abbreviation(self._),
'date' : date
})
return ""
def _Event_get_place_text(event, database, placeholder=False):
"""
Return a textual representation of the event's place to be used in textual
context. This is basically "in " + the place title.
@param placeholder: whether a series of underscores should be inserted as a
placeholder if the place is missing.
"""
place_handle = event.get_place_handle()
if place_handle:
place_title = place_displayer.display_event(database, event)
text = _("in %(place)s") % {'place': place_title}
elif placeholder and event.get_type() in _Event_needs_date_place:
text = _("in %(place)s") % {'place': "__________"}
else:
text = ""
return text
def get_wedding_data(self,family):
ret = "";
event_ref_list = family.get_event_ref_list()
m_date = ""
m_place = ""
m_source = ""
married = 0
eng_date = ""
eng_place = ""
eng_source = ""
engaged = 0
div_date = ""
divorced = 0
for event_ref in event_ref_list:
event = self.db.get_event_from_handle(event_ref.ref)
if event.get_type() == EventType.MARRIAGE:
married = 1
m_date = self.format_date( event.get_date_object())
place_handle = event.get_place_handle()
if place_handle:
m_place = _pd.display_event(self.db, event)
m_source = self.get_primary_source( event.get_citation_list())
if event.get_type() == EventType.ENGAGEMENT:
engaged = 1
eng_date = self.format_date( event.get_date_object())
place_handle = event.get_place_handle()
if place_handle:
eng_place = _pd.display_event(self.db, event)
eng_source = self.get_primary_source( event.get_citation_list())
if event.get_type() == EventType.DIVORCE:
divorced = 1
div_date = self.format_date( event.get_date_object())
if married == 1:
if m_date != "":
ret = ret + m_date
if m_place != "" and m_source != "":
ret = ret + " #mp %s #ms %s" % (self.rem_spaces( m_place), self.rem_spaces( m_source))
if m_place != "" and m_source == "":
ret = ret + " #mp %s" % self.rem_spaces( m_place)
if m_source != "" and m_place == "":
ret = ret + " #ms %s" % self.rem_spaces( m_source)
elif engaged == 1:
"""Geneweb only supports either Marriage or engagement"""
if eng_date != "":
ret = ret + eng_date
if m_place != "" and m_source != "":
ret = ret + " #mp %s #ms %s" % (self.rem_spaces( m_place), self.rem_spaces( m_source))
if eng_place != "" and m_source == "":
ret = ret + " #mp %s" % self.rem_spaces( m_place)
if eng_source != "" and m_place == "":
ret = ret + " #ms %s" % self.rem_spaces( m_source)
else:
if family.get_relationship() != FamilyRelType.MARRIED:
"""Not married or engaged"""
ret = ret + " #nm"
if divorced == 1:
if div_date != "":
ret = ret + " -%s" %div_date
else:
ret = ret + " -0"
return ret
def write_families(self):
family_handle_list = self.person.get_family_handle_list()
if not len(family_handle_list):
return
self.doc.start_table("three","IDS-IndTable")
self.doc.start_row()
self.doc.start_cell("IDS-TableHead", 2)
self.write_paragraph(self._('Marriages/Children'),
style='IDS-TableTitle')
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
for family_handle in family_handle_list:
self.doc.start_table("three","IDS-IndTable")
family = self._db.get_family_from_handle(family_handle)
self.family_notes_list += family.get_note_list()
if self.person.get_handle() == family.get_father_handle():
spouse_id = family.get_mother_handle()
else:
spouse_id = family.get_father_handle()
self.doc.start_row()
self.doc.start_cell("IDS-NormalCell", 2)
if spouse_id:
spouse = self._db.get_person_from_handle(spouse_id)
text = self.get_name(spouse)
mark = ReportUtils.get_person_mark(self._db, spouse)
else:
spouse = None
text = self._("unknown")
mark = None
endnotes = self._cite_endnote(family)
self.write_paragraph(text, endnotes=endnotes, mark=mark,
style='IDS-Spouse')
self.doc.end_cell()
self.doc.end_row()
event_ref_list = family.get_event_ref_list()
for event_ref, event in self.get_event_list(event_ref_list):
self.write_fact(event_ref, event)
child_ref_list = family.get_child_ref_list()
if len(child_ref_list):
self.doc.start_row()
self.write_cell(self._("Children"))
self.doc.start_cell("IDS-ListCell")
for child_ref in child_ref_list:
child = self._db.get_person_from_handle(child_ref.ref)
name = self.get_name(child)
mark = ReportUtils.get_person_mark(self._db, child)
endnotes = self._cite_endnote(child_ref)
self.write_paragraph(name, endnotes=endnotes, mark=mark)
self.doc.end_cell()
self.doc.end_row()
attr_list = family.get_attribute_list()
if len(attr_list):
self.doc.start_row()
self.write_cell(self._("Attributes"))
self.doc.start_cell("IDS-ListCell")
self.do_attributes(attr_list)
self.doc.end_cell()
self.doc.end_row()
self.doc.end_table()
ord_list = family.get_lds_ord_list()
if len(ord_list):
self.doc.start_table("ordinances2","IDS-OrdinanceTable2")
self.doc.start_row()
self.write_cell(self._('LDS Ordinance'))
self.write_cell(self._('Type'), style='IDS-Section')
self.write_cell(self._('Date'), style='IDS-Section')
self.write_cell(self._('Status'), style='IDS-Section')
self.write_cell(self._('Temple'), style='IDS-Section')
self.write_cell(self._('Place'), style='IDS-Section')
self.doc.end_row()
for lds_ord in ord_list:
type = self._(lds_ord.type2str())
date = self._get_date(lds_ord.get_date_object())
status = self._(lds_ord.status2str())
temple = TEMPLES.name(lds_ord.get_temple())
place_name = ''
place_endnote = ''
place_handle = lds_ord.get_place_handle()
if place_handle:
place = self._db.get_place_from_handle(place_handle)
place_name = place_displayer.display_event(self._db, lds_ord)
place_endnote = self._cite_endnote(place)
endnotes = self._cite_endnote(lds_ord, prior=place_endnote)
self.doc.start_row()
self.write_cell('')
self.write_cell(type, endnotes)
self.write_cell(date)
self.write_cell(status)
self.write_cell(temple)
self.write_cell(place_name)
self.doc.end_row()
self.doc.end_table()
self.doc.start_paragraph('IDS-Normal')
self.doc.end_paragraph()
def write_event(self, event_ref):
text = ""
event = self.db.get_event_from_handle(event_ref.ref)
if self.fulldate:
date = self._get_date(event.get_date_object())
else:
date = event.get_date_object().get_year()
place = place_displayer.display_event(self.db, event)
self.doc.start_paragraph('DDR-MoreDetails')
event_name = self._get_type(event.get_type())
if date and place:
text += self._('%(date)s, %(place)s') % {
'date' : date, 'place' : place }
elif date:
text += self._('%(date)s') % {'date' : date}
elif place:
text += self._('%(place)s') % { 'place' : place }
if event.get_description():
if text:
text += ". "
text += event.get_description()
text += self.endnotes(event)
if text:
text += ". "
text = self._('%(event_name)s: %(event_text)s') % {
'event_name' : self._(event_name),
'event_text' : text }
self.doc.write_text_citation(text)
if self.inc_attrs:
text = ""
attr_list = event.get_attribute_list()
attr_list.extend(event_ref.get_attribute_list())
for attr in attr_list:
if text:
# translators: needed for Arabic, ignore otherwise
text += self._("; ")
attrName = self._get_type(attr.get_type())
text += self._("%(type)s: %(value)s%(endnotes)s") % {
'type' : self._(attrName),
'value' : attr.get_value(),
'endnotes' : self.endnotes(attr) }
text = " " + text
self.doc.write_text_citation(text)
self.doc.end_paragraph()
if self.inc_notes:
# if the event or event reference has a note attached to it,
# get the text and format it correctly
notelist = event.get_note_list()
notelist.extend(event_ref.get_note_list())
for notehandle in notelist:
note = self.db.get_note_from_handle(notehandle)
self.doc.write_styled_note(note.get_styledtext(),
note.get_format(),"DDR-MoreDetails",
contains_html= note.get_type() == NoteType.HTML_CODE)
