def update_has_data(self): """ Determine if a person has_data by checking: 1. has a birth, baptism, death, or burial event; OR 2. has a father; OR 3. has a mother """ active_handle = self.get_active('Person') has_data = False if active_handle: active_person = self.dbstate.db.get_person_from_handle(active_handle) if active_person: for event_type in [EventType(EventType.BIRTH), EventType(EventType.BAPTISM), EventType(EventType.DEATH), EventType(EventType.BURIAL)]: event = self.get_event(active_person, event_type) if event: has_data = True break if not has_data: 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: if self.dbstate.db.get_person_from_handle(handle): has_data = True else: handle = family.get_mother_handle() if handle: if self.dbstate.db.get_person_from_handle(handle): has_data = True self.set_has_data(has_data)
def init_gui(self): # Draw dialog and make it handle everything self.glade = Glade() self.auto1 = self.glade.get_object("original") self.auto2 = self.glade.get_object("new") # Need to display localized event names etype = EventType() event_names = sorted(etype.get_standard_names(), key=glocale.sort_key) fill_combo(self.auto1, event_names) fill_combo(self.auto2, event_names) etype.set_from_xml_str(self.options.handler.options_dict['fromtype']) self.auto1.get_child().set_text(str(etype)) etype.set_from_xml_str(self.options.handler.options_dict['totype']) self.auto2.get_child().set_text(str(etype)) window = self.glade.toplevel self.set_window(window, self.glade.get_object('title'), self.title) self.glade.connect_signals({ "on_close_clicked": self.close, "on_apply_clicked": self.on_apply_clicked, "on_delete_event": self.close, }) self.show()
def _prepare_eligible_events(self, event_filters: List[str]): """Prepare an event filter list.""" eligible_events = {"Birth", "Death"} event_type = EventType() default_event_types = event_type.get_standard_xml() default_event_map = event_type.get_map() custom_event_types = self.db_handle.get_event_types() for key in event_filters: if key in default_event_types: eligible_events.add(key) continue if key in custom_event_types: eligible_events.add(key) continue if key not in EVENT_CATEGORIES: raise ValueError( f"{key} is not a valid event or event category") for entry in event_type.get_menu_standard_xml(): event_key = entry[0].lower().replace("life events", "vital") if event_key in event_filters: for event_id in entry[1]: if event_id in default_event_map: eligible_events.add(default_event_map[event_id]) break if "custom" in event_filters: for event_name in custom_event_types: eligible_events.add(event_name) return eligible_events
def create_event(self, description=_("Estimated date"), type=None, date=None, source=None, note_text="", modifier=None): event = Event() event.set_description(description) note = Note() note.handle = create_id() note.type.set(NoteType.EVENT) note.set(note_text) self.db.add_note(note, self.trans) event.add_note(note.handle) if type: event.set_type(EventType(type)) if date: if modifier: date.set_modifier(modifier) date.set_quality(Date.QUAL_ESTIMATED) date.set_yr_mon_day(date.get_year(), 0, 0) event.set_date_object(date) if source: citation = Citation() citation.set_reference_handle(source.get_handle()) self.db.add_citation(citation, self.trans) event.add_citation(citation.get_handle()) self.db.commit_source(source, self.trans) self.db.add_event(event, self.trans) return event
def display_person(self, active_person): """ Display details of the active person. """ self.load_person_image(active_person) self.name.set_text(name_displayer.display(active_person)) self.clear_grid() self.display_alternate_names(active_person) self.display_parents(active_person) self.display_separator() self.display_type(active_person, EventType(EventType.BIRTH)) self.display_type(active_person, EventType(EventType.BAPTISM)) self.display_type(active_person, EventType(EventType.DEATH)) self.display_type(active_person, EventType(EventType.BURIAL)) self.display_separator() self.display_attribute(active_person, _('Occupation')) self.display_attribute(active_person, _('Title')) self.display_attribute(active_person, _('Religion'))
def display_person(self, active_person): """ Display details of the active person. """ self.load_person_image(active_person) self.name.set_markup( "<span size='large' weight='bold'>%s</span>" % markup_escape_text(name_displayer.display(active_person), -1)) self.clear_grid() self.display_alternate_names(active_person) self.display_parents(active_person) self.display_separator() self.display_type(active_person, EventType(EventType.BIRTH)) self.display_type(active_person, EventType(EventType.BAPTISM)) self.display_type(active_person, EventType(EventType.DEATH)) self.display_type(active_person, EventType(EventType.BURIAL)) self.display_separator() self.display_attribute(active_person, _('Occupation')) self.display_attribute(active_person, _('Title')) self.display_attribute(active_person, _('Religion'))
def add_occupation(self, fields, data): """Read the ROLE property of a VCard.""" occupation = data.strip() if occupation: event = Event() event.set_type(EventType(EventType.OCCUPATION)) event.set_description(self.unesc(occupation)) self.database.add_event(event, self.trans) event_ref = EventRef() event_ref.set_reference_handle(event.get_handle()) self.person.add_event_ref(event_ref)
def create_event(self,type,desc=None,date=None,place=None,source=None): event = Event() if type: event.set_type(EventType(type)) if desc: event.set_description(desc) if date: event.set_date_object(date) if place: event.set_place_handle(place.get_handle()) if source: event.add_citation(source.get_handle()) self.db.add_event(event,self.trans) self.db.commit_event(event,self.trans) return event
def on_apply_clicked(self, obj): # Need to store English names for later comparison the_type = EventType() the_type.set(self.auto1.get_child().get_text()) self.options.handler.options_dict['fromtype'] = the_type.xml_str() the_type.set(self.auto2.get_child().get_text()) self.options.handler.options_dict['totype'] = the_type.xml_str() self.run_tool(self.window) # Save options self.options.handler.save_options() self.close()
def default_type(self): type_list = [] # combine return info into a single flat sequence event = None for event_ref in self.get_data()[0]: if event_ref.get_role() == self.default_role(): event = self.dbstate.db.get_event_from_handle(event_ref.ref) type_list.append(event.get_type()) _std_types = self.default_types() for etype in _std_types: if etype not in type_list: return EventType(etype) return _std_types[0]
def find_occupation(self, person): """ Use the most recent occupation event. """ occupationtxt = " " event_refs = person.get_primary_event_ref_list() events = [event for event in [self.__db.get_event_from_handle(ref.ref) for ref in event_refs] if event.get_type() == EventType(EventType.OCCUPATION)] if len(events) > 0: events.sort(key=lambda x: x.get_date_object()) # print(events[0].get_description()) occupation = events[-1].get_description() if occupation: occupationtxt=("%s" % occupation) return(occupationtxt)
def __populate_gui(self, event): """ Populate the GUI for a given form event. """ # Set source handle = self.citation.get_reference_handle() source = self.db.get_source_from_handle(handle) source_text = self.widgets['source_text'] source_text.set_text(source.get_title()) form_id = get_form_id(source) # Set event type event_type = EventType() event_type.set_from_xml_str(get_form_type(form_id)) self.event.set_type(event_type) # Set date form_date = get_form_date(form_id) date_text = self.widgets['date_text'] date_button = self.widgets['date_button'] if form_date is not None: date_text.set_text(displayer.display(form_date)) self.event.set_date_object(form_date) self.citation.set_date_object(form_date) date_text.set_editable(False) date_button.set_sensitive(False) else: date_text.set_text(get_date(event)) date_text.set_editable(True) date_button.set_sensitive(True) # Create tabs self.details = DetailsTab(self.dbstate, self.uistate, self.track, self.event, self.citation, form_id) self.headings = HeadingsTab(self.dbstate, self.uistate, self.track, self.event, self.citation, form_id) self.gallery_list = GalleryTab(self.dbstate, self.uistate, self.track, self.citation.get_media_list()) self._add_tab(self.notebook, self.details) self._add_tab(self.notebook, self.headings) self._add_tab(self.notebook, self.gallery_list) self.notebook.show_all() self.notebook.set_current_page(0)
def add_birthday(self, fields, data): """Read the BDAY property of a VCard.""" date_str = data.strip() date_match = VCardParser.DATE_RE.match(date_str) date = Date() if date_match: if date_match.group(2): date_str = "%s-%s-%s" % (date_match.group(2), date_match.group(3), date_match.group(4)) else: date_str = date_match.group(1) y, m, d = [int(x, 10) for x in date_str.split('-')] try: date.set(value=(d, m, y, False)) except DateError: # TRANSLATORS: leave the {vcard_snippet} untranslated # in the format string, but you may re-order it if needed. self.__add_msg( _("Invalid date in BDAY {vcard_snippet}, " "preserving date as text.").format(vcard_snippet=data), self.line_num - 1) date.set(modifier=Date.MOD_TEXTONLY, text=data) else: if date_str: # TRANSLATORS: leave the {vcard_snippet} untranslated. self.__add_msg( _("Date {vcard_snippet} not in appropriate format " "yyyy-mm-dd, preserving date as text.").format( vcard_snippet=date_str), self.line_num - 1) date.set(modifier=Date.MOD_TEXTONLY, text=date_str) else: # silently ignore an empty BDAY record return event = Event() event.set_type(EventType(EventType.BIRTH)) event.set_date_object(date) self.database.add_event(event, self.trans) event_ref = EventRef() event_ref.set_reference_handle(event.get_handle()) self.person.set_birth_ref(event_ref)
def get_or_create_event(self, object_, type_, date=None, place=None, source=None): """ Add or find a type event on object """ # first, see if it exists LOG.debug("get_or_create_event") ref_list = object_.get_event_ref_list() LOG.debug("refs: %s", ref_list) # look for a match, and possible correction for ref in ref_list: event = self.db.get_event_from_handle(ref.ref) LOG.debug(" compare event type %s == %s", int(event.get_type()), type_) if int(event.get_type()) == type_: # Match! Let's update if date: event.set_date_object(date) if place: event.set_place_handle(place.get_handle()) if source: self.find_and_set_citation(event, source) self.db.commit_event(event, self.trans) LOG.debug(" returning existing event") return (0, event) # else create it: LOG.debug(" creating event") event = Event() if type_: event.set_type(EventType(type_)) if date: event.set_date_object(date) if place: event.set_place_handle(place.get_handle()) if source: self.find_and_set_citation(event, source) self.db.add_event(event, self.trans) return (1, event)
'~': Date.MOD_ABOUT, } _cal_map = { 'J': Date.CAL_JULIAN, 'H': Date.CAL_HEBREW, 'F': Date.CAL_FRENCH, } pevents_map = { "#birt": EventType.BIRTH, #Epers_Birth "#bapt": EventType.BAPTISM, #Epers_Baptism "#deat": EventType.DEATH, #Epers_Death "#buri": EventType.BURIAL, #Epers_Burial "#crem": EventType.CREMATION, "#acco": EventType((EventType.CUSTOM, _('Accomplishment'))), "#acqu": EventType((EventType.CUSTOM, _('Acquisition'))), "#adhe": EventType((EventType.CUSTOM, _('Adhesion'))), "#awar": EventType((EventType.CUSTOM, _('Award'))), "#bapl": LdsOrd.BAPTISM, #Epers_BaptismLDS "#barm": EventType.BAR_MITZVAH, #Epers_BarMitzvah "#basm": EventType.BAS_MITZVAH, #Epers_BatMitzvah "#bles": EventType.BLESS, #Epers_Benediction "#cens": EventType.CENSUS, "#chgn": EventType((EventType.CUSTOM, _('Change Name'))), "#circ": EventType((EventType.CUSTOM, _('Circumcision'))), "#conf": EventType.CONFIRMATION, #Epers_Confirmation "#conl": LdsOrd.CONFIRMATION, #Epers_ConfirmationLDS "#degr": EventType.DEGREE, "#demm": EventType((EventType.CUSTOM, _('Military Demobilisation'))), "#dist": EventType((EventType.CUSTOM, _('Award'))),
def default_types(self): return [ EventType(EventType.MARRIAGE), EventType(EventType.DIVORCE), ]
def show_one_person(self, person): """ Create all markers for each people's event in the database which has a lat/lon. """ dbstate = self.dbstate self.load_kml_files(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() edate = event.get_date_object().to_calendar(self.cal) eyear = str("%04d" % edate.get_year()) + \ str("%02d" % edate.get_month()) + \ str("%02d" % edate.get_day()) place_handle = event.get_place_handle() if place_handle and event_ref.ref not in self.event_list: self.event_list.append(event_ref.ref) 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.progress.step() 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: self.already_done.append(handle) descr1 = "%s - " % _nd.display(father) handle = fam.get_mother_handle() if handle: self.already_done.append(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 and event_ref.ref not in self.event_list): self.event_list.append(event_ref.ref) 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()) edate = event.get_date_object() edate = edate.to_calendar(self.cal) eyear = str("%04d" % edate.get_year()) + \ str("%02d" % edate.get_month())\ + str("%02d" % edate.get_day()) self.load_kml_files(place) if longitude and latitude: self.progress.step() 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) for pers in [ self._get_parent(person, True), self._get_parent(person, False) ]: if pers: self.show_one_person(pers)
def get_person_label(self, person): "return person label string" # see if we have an image to use for this person image_path = None if self.use_html_output: media_list = person.get_media_list() if len(media_list) > 0: media_handle = media_list[0].get_reference_handle() media = self._db.get_media_from_handle(media_handle) media_mime_type = media.get_mime_type() if media_mime_type[0:5] == "image": image_path = get_thumbnail_path( media_path_full(self._db, media.get_path()), rectangle=media_list[0].get_rectangle()) # test if thumbnail actually exists in thumbs # (import of data means media files might not be present image_path = find_file(image_path) label = "" line_delimiter = '\\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.use_html_output and image_path: line_delimiter = '<BR/>' label += '<TABLE BORDER="0" CELLSPACING="2" CELLPADDING="0" ' label += 'CELLBORDER="0"><TR><TD></TD><TD>' label += '<IMG SRC="%s"/></TD><TD></TD>' % image_path 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.use_html_output = False # at the very least, the label must have the person's name p_name = self._name_display.display(person) if self.use_html_output: # avoid < and > in the name, as this is html text label += p_name.replace('<', '<').replace('>', '>') else: label += p_name p_id = person.get_gramps_id() if self.includeid == 1: # same line label += " (%s)" % p_id elif self.includeid == 2: # own line label += "%s(%s)" % (line_delimiter, p_id) if self.event_choice != 0: b_date, d_date, b_place, d_place, b_type, d_type = \ self.get_event_strings(person) if self.event_choice in [1, 2, 3, 4, 5] and (b_date or d_date): label += '%s(' % line_delimiter if b_date: label += '%s' % b_date label += ' - ' if d_date: label += '%s' % d_date label += ')' if (self.event_choice in [2, 3, 5, 6] and (b_place or d_place) and not (self.event_choice == 3 and (b_date or d_date))): label += '%s(' % line_delimiter if b_place: label += '%s' % b_place label += ' - ' if d_place: label += '%s' % d_place label += ')' if self.event_choice == 7: if b_type: label += '%s%s' % (line_delimiter, b_type.get_abbreviation()) if b_date: label += ' %s' % b_date if b_place: label += ' %s' % b_place if d_type: label += '%s%s' % (line_delimiter, d_type.get_abbreviation()) if d_date: label += ' %s' % d_date if d_place: label += ' %s' % d_place if self.increlname and self.center_person != person: # display relationship info if self.advrelinfo: (relationship, _ga, _gb) = self.rel_calc.get_one_relationship( self._db, self.center_person, person, extra_info=True, olocale=self._locale) if relationship: label += "%s(%s Ga=%d Gb=%d)" % (line_delimiter, relationship, _ga, _gb) else: relationship = self.rel_calc.get_one_relationship( self._db, self.center_person, person, olocale=self._locale) if relationship: label += "%s(%s)" % (line_delimiter, relationship) if self.occupation > 0: event_refs = person.get_primary_event_ref_list() events = [ event for event in [ self._db.get_event_from_handle(ref.ref) for ref in event_refs ] if event.get_type() == EventType(EventType.OCCUPATION) ] if len(events) > 0: events.sort(key=lambda x: x.get_date_object()) if self.occupation == 1: occupation = events[-1].get_description() if occupation: label += "%s(%s)" % (line_delimiter, occupation) elif self.occupation == 2: for evt in events: date = self.get_date_string(evt) place = self.get_place_string(evt) desc = evt.get_description() if not date and not desc and not place: continue label += '%s(' % line_delimiter if date: label += '%s' % date if desc: label += ' ' if desc: label += '%s' % desc if place: if date or desc: label += ', ' label += '%s' % place label += ')' # see if we have a table that needs to be terminated if self.use_html_output: label += '</TD></TR></TABLE>' return label else: # non html label is enclosed by "" so escape other " return label.replace('"', '\\\"')
#------------------------------------------------------------------------ # # Global variables (ones used in both classes here, that is) # #------------------------------------------------------------------------ # _T_ is a gramps-defined keyword -- see po/update_po.py and po/genpot.sh def _T_(value): # enable deferred translations (see Python docs 22.1.3.4) return value CUSTOM = _T_("Custom") # Construct section list and type to group map SECTION_LIST = [] TYPE2GROUP = {} for event_group, type_list in EventType().get_menu_standard_xml(): SECTION_LIST.append(event_group) for event_type in type_list: TYPE2GROUP[event_type] = event_group SECTION_LIST.append(CUSTOM) TYPE2GROUP[EventType.CUSTOM] = CUSTOM #------------------------------------------------------------------------ # # IndivCompleteReport # #------------------------------------------------------------------------ class IndivCompleteReport(Report): def __init__(self, database, options, user): """
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 default_types(self): return [ EventType(EventType.BIRTH), EventType(EventType.DEATH), EventType(EventType.BURIAL), ]
def bubble_message(self, event, lat, lon, marks): self.menu = Gtk.Menu() menu = self.menu message = "" oldplace = "" prevmark = None for mark in marks: if message != "": add_item = Gtk.MenuItem(label=message) add_item.show() menu.append(add_item) self.itemoption = Gtk.Menu() itemoption = self.itemoption 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) evt = self.dbstate.db.get_event_from_gramps_id(mark[10]) hdle = evt.get_handle() bookm = Gtk.MenuItem(label=_("Bookmark this event")) bookm.show() bookm.connect("activate", self.add_bookmark_from_popup, hdle) itemoption.append(bookm) if mark[0] != oldplace: message = "%s :" % mark[0] self.add_place_bubble_message(event, lat, lon, marks, menu, message, mark) oldplace = mark[0] 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()) message = "(%s) %s : %s" % (date, EventType(mark[7]), mark[5]) prevmark = mark add_item = Gtk.MenuItem(label=message) add_item.show() menu.append(add_item) self.itemoption = Gtk.Menu() itemoption = self.itemoption 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) evt = self.dbstate.db.get_event_from_gramps_id(mark[10]) hdle = evt.get_handle() bookm = Gtk.MenuItem(label=_("Bookmark this event")) bookm.show() bookm.connect("activate", self.add_bookmark_from_popup, hdle) itemoption.append(bookm) menu.popup(None, None, None, None, event.button, event.time) return 1
from webargs import fields, validate from ...types import Handle from ..util import get_db_handle, get_locale_for_language, use_args from . import ProtectedResource from .emit import GrampsJSONEncoder from .filters import apply_filter from .util import ( get_person_profile_for_object, get_place_profile_for_object, get_rating, ) pd = PlaceDisplay() default_locale = GrampsLocale(lang="en") event_type = EventType() DEATH_INDICATORS = [ event_type.DEATH, event_type.BURIAL, event_type.CREMATION, event_type.CAUSE_DEATH, event_type.PROBATE, ] RELATIVES = [ "father", "mother", "brother", "sister", "wife",
def _createmap(self, active): """ Create all markers for each people's event in the database which has a lat/lon. @param: active is mandatory but unused in this view. Fix : 10088 """ 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.message_layer.set_font_attributes(None, None, None) 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 _createmap(self, person, color, place_list, reference): """ 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 = place_list self.place_without_coordinates = [] self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0 self.minyear = 9999 self.maxyear = 0 latitude = "" longitude = "" 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 fam = dbstate.db.get_family_from_handle(fhandle) handle = fam.get_father_handle() father = dbstate.db.get_person_from_handle(handle) if father: descr1 = "%s - " % _nd.display(father) handle = fam.get_mother_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 column_type(self, data): return str(EventType(data[COLUMN_TYPE]))