def link_place(self, menu, event, lat, lon): """ Link an existing place using longitude and latitude of location centered on the map If we have a place history, we must show all places to avoid an empty place selection in the PlaceSelection. """ if self.uistate.get_active('Place'): self._createmap(None) selector = SelectPlace(self.dbstate, self.uistate, []) place = selector.run() if place: parent_list = place.get_placeref_list() if len(parent_list) > 0: parent = parent_list[0].ref else: parent = None places_handle = self.dbstate.db.iter_place_handles() nb_places = 0 gids = "" place_title = _pd.display(self.dbstate.db, place) for place_hdl in places_handle: plce = self.dbstate.db.get_place_from_handle(place_hdl) plce_title = _pd.display(self.dbstate.db, plce) if plce_title == place_title: nb_places += 1 if gids == "": gids = plce.gramps_id else: # TODO for Arabic, should the next comma be translated? gids = gids + ", " + plce.gramps_id if nb_places > 1: from gramps.gui.dialog import WarningDialog WarningDialog( _('You have at least two places with the same title.'), _("The title of the places is:\n%(title)s\n" "The following places are similar: %(gid)s\n" "You should eiher rename the places or merge them.\n\n" "%(bold_start)s" "I can't proceed with your request" "%(bold_end)s.\n") % { 'bold_start' : '<b>', 'bold_end' : '</b>', 'title': '<b>' + place_title + '</b>', 'gid': gids}, parent=self.uistate.window ) else: self.mark = [None, None, None, None, None, None, None, None, None, place.gramps_id, None, None] self.select_fct = PlaceSelection(self.uistate, self.dbstate, self.osm, self.selection_layer, self.place_list, lat, lon, self.__edit_place, parent)
def match(self, lat, lon): """ coordinates matching. """ rds = float(self.radius) self.places = [] # place for entry in self.place_list: if (math.hypot(lat-float(entry[3]), lon-float(entry[4])) <= rds) == True: # Do we already have this place ? avoid duplicates (country, state, county, place, other) = self.get_location(entry[9]) if not [country, state, county, place, other] in self.places: self.places.append([country, state, county, place, other]) self.warning = False for place in self.dbstate.db.iter_places(): latn = place.get_latitude() lonn = place.get_longitude() if latn and lonn: latn, ignore = conv_lat_lon(latn, "0", "D.D8") if not latn: if not self.warning: self.close() warn1 = _("you have a wrong latitude for:") warn2 = _pd.display(self.dbstate.db, place) + "\n\n<b>" warn2 += _("Please, correct this before linking") + "</b>" WarningDialog(warn1, warn2, parent=self.uistate.window) self.warning = True continue ignore, lonn = conv_lat_lon("0", lonn, "D.D8") if not lonn: if not self.warning: self.close() warn1 = _("you have a wrong longitude for:") + "\n" warn2 = _pd.display(self.dbstate.db, place) + "\n\n<b>" warn2 += _("Please, correct this before linking") + "</b>" WarningDialog(warn1, warn2, parent=self.uistate.window) self.warning = True continue if (math.hypot(lat-float(latn), lon-float(lonn)) <= rds) == True: (country, state, county, place, other) = self.get_location(place.get_gramps_id()) if not [country, state, county, place, other] in self.places: self.places.append([country, state, county, place, other])
def main(self): self.reset_main() if self.gui.get_child().get_child() == self.results_win: self.gui.get_child().remove(self.results_win) self.gui.get_child().add(self.mainwin) active_handle = self.get_active('Place') self.top.get_object("edit_but").set_sensitive(False) self.top.get_object("find_but").set_sensitive(False) self.top.get_object("title_entry").set_sensitive(False) if active_handle: self.place = self.dbstate.db.get_place_from_handle(active_handle) self.mainwin.hide() if self.place: self.set_has_data(True) title = _pd.display(self.dbstate.db, self.place) item = self.top.get_object("title_entry") item.set_text(title) self.top.get_object("edit_but").set_sensitive(True) self.top.get_object("find_but").set_sensitive(True) self.top.get_object("title_entry").set_sensitive(True) else: self.set_has_data(False) self.mainwin.show() else: self.set_has_data(False)
def on_find_clicked(self, dummy): """ find a matching place. First try in the db, then try in the GeoNames. """ self.res_store.clear() self.top.get_object("select_but").set_sensitive(False) if self.geo_stage: self.search_geo() else: self.geo_stage = True item = self.top.get_object("title_entry") title = item.get_text() self.places = self.lookup_places_by_name(title) for index, place in enumerate(self.places): # make sure the place found isn't self, or a place # enclosed by the working place if place.handle != self.place.handle and not located_in( self.dbstate.db, place.handle, self.place.handle): title = _pd.display(self.dbstate.db, place) self.res_store.append(row=(index, title, str(place.place_type))) if len(self.res_store) > 0: self.res_lbl.set_text(_('%s\nLocal\nMatches') % len(self.res_store)) self.find_but.set_label(_("Find GeoNames")) else: self.search_geo()
def _create_one_place(self, place): """ Create one entry for one place with a lat/lon. """ if place is None: return if self.nbplaces >= self._config.get("geography.max_places"): return descr = _pd.display(self.dbstate.db, place) longitude = place.get_longitude() latitude = place.get_latitude() latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8") 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: colour = self.plc_color[int(place.get_type())+1] if int(place.get_type()) == PlaceType.CUSTOM: try: colour = (str(place.get_type()), self.plc_custom_color[str(place.get_type())]) except: colour = self.plc_color[PlaceType.CUSTOM + 1] self._append_to_places_list(descr, None, "", latitude, longitude, None, None, EventType.UNKNOWN, None, # person.gramps_id place.gramps_id, None, # event.gramps_id None, # family.gramps_id color=colour )
def __write_place(self, handle, place_nbr): """ This procedure writes out the details of a single place """ place = self.database.get_place_from_handle(handle) location = get_main_location(self.database, place) place_details = [ self._("Gramps ID: %s ") % place.get_gramps_id(), self._("Street: %s ") % location.get(PlaceType.STREET, ''), self._("Parish: %s ") % location.get(PlaceType.PARISH, ''), self._("Locality: %s ") % location.get(PlaceType.LOCALITY, ''), self._("City: %s ") % location.get(PlaceType.CITY, ''), self._("County: %s ") % location.get(PlaceType.COUNTY, ''), self._("State: %s") % location.get(PlaceType.STATE, ''), self._("Country: %s ") % location.get(PlaceType.COUNTRY, '')] self.doc.start_paragraph("PLC-PlaceTitle") place_title = place_displayer.display(self.database, place) self.doc.write_text(("%(nbr)s. %(place)s") % {'nbr' : place_nbr, 'place' : place_title}) self.doc.end_paragraph() for item in place_details: self.doc.start_paragraph("PLC-PlaceDetails") self.doc.write_text(item) self.doc.end_paragraph()
def name_from_gramps_id(self, gramps_id): if self.namespace == 'Person': person = self.db.get_person_from_gramps_id(gramps_id) name = _nd.display_name(person.get_primary_name()) elif self.namespace == 'Family': family = self.db.get_family_from_gramps_id(gramps_id) name = family_name(family, self.db) elif self.namespace == 'Event': event = self.db.get_event_from_gramps_id(gramps_id) name = str(event.get_type) elif self.namespace == 'Place': place = self.db.get_place_from_gramps_id(gramps_id) name = _pd.display(self.db, place) elif self.namespace == 'Source': source = self.db.get_source_from_gramps_id(gramps_id) name = source.get_title() elif self.namespace == 'Citation': citation = self.db.get_citation_from_gramps_id(gramps_id) name = citation.get_page() elif self.namespace == 'Media': obj = self.db.get_media_from_gramps_id(gramps_id) name = obj.get_path() elif self.namespace == 'Repository': repo = self.db.get_repository_from_gramps_id(gramps_id) name = repo.get_name() elif self.namespace == 'Note': note = self.db.get_note_from_gramps_id(gramps_id) name = note.get() return name
def calc_url(self): """ Determine the url to use Logic: use lat lon if present otherwise use city and country if present otherwise use description of the place """ place = self._get_first_place()[0] latitude, longitude = self._lat_lon(place) if longitude and latitude: self.url = "http://www.openstreetmap.org/" \ "?lat=%s&lon=%s&zoom=15" % (latitude, longitude) return location = get_main_location(self.database, place) city = location.get(PlaceType.CITY) country = location.get(PlaceType.COUNTRY) if city and country: self.url = "http://nominatim.openstreetmap.org/"\ "search.php?q=%s%%2C%s" % (city, country) return titledescr = place_displayer.display(self.database, place) self.url = "http://nominatim.openstreetmap.org/"\ "search.php?q=%s" % '+'.join(titledescr.split())
def _create_one_place(self,place): """ Create one entry for one place with a lat/lon. """ if place is None: return if self.nbplaces >= self._config.get("geography.max_places"): return descr = _pd.display(self.dbstate.db, place) longitude = place.get_longitude() latitude = place.get_latitude() latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8") # place.get_longitude and place.get_latitude return # one string. We have coordinates when the two values # contains non null string. if ( longitude and latitude ): self._append_to_places_list(descr, None, "", latitude, longitude, None, None, EventType.UNKNOWN, None, # person.gramps_id place.gramps_id, None, # event.gramps_id None # family.gramps_id )
def get_menu_title(self): if self.obj and self.obj.get_handle(): title = place_displayer.display(self.db, self.obj) dialog_title = _('Place: %s') % title else: dialog_title = _('New Place') return dialog_title
def __write_place(self, handle, place_nbr): """ This procedure writes out the details of a single place """ place = self._db.get_place_from_handle(handle) place_details = [self._("Gramps ID: %s ") % place.get_gramps_id()] for level in get_location_list(self._db, place): # translators: needed for French, ignore otherwise place_details.append(self._("%(str1)s: %(str2)s" ) % {'str1': self._(level[1].xml_str()), 'str2': level[0]}) place_names = '' all_names = place.get_all_names() if len(all_names) > 1 or __debug__: for place_name in all_names: if place_names != '': # translators: needed for Arabic, ignore otherwise place_names += self._(", ") place_names += '%s' % place_name.get_value() if place_name.get_language() != '' or __debug__: place_names += ' (%s)' % place_name.get_language() place_details += [self._("places|All Names: %s") % place_names,] self.doc.start_paragraph("PLC-PlaceTitle") place_title = _pd.display(self._db, place, None, self.place_format) self.doc.write_text(("%(nbr)s. %(place)s") % {'nbr' : place_nbr, 'place' : place_title}) self.doc.end_paragraph() for item in place_details: self.doc.start_paragraph("PLC-PlaceDetails") self.doc.write_text(item) self.doc.end_paragraph()
def getPlaceKey(self, group_entry): """ Return the place description to use when sorting the place records. """ p_handle = group_entry[_REF_HANDLE_POS] place = self.database.get_place_from_handle(p_handle) title = place_displayer.display(self.database, place) return title.upper()
def save(self, *obj): self.ok_button.set_sensitive(False) if self.object_is_empty(): ErrorDialog(_("Cannot save place"), _("No data exists for this place. Please " "enter data or cancel the edit.")) self.ok_button.set_sensitive(True) return if self.obj.get_name().strip() == '': msg1 = _("Cannot save location. Name not entered.") msg2 = _("You must enter a name before saving.") ErrorDialog(msg1, msg2) self.ok_button.set_sensitive(True) return (uses_dupe_id, id) = self._uses_duplicate_id() if uses_dupe_id: prim_object = self.get_from_gramps_id(id) name = place_displayer.display(self.db, prim_object) msg1 = _("Cannot save place. ID already exists.") msg2 = _("You have attempted to use the existing Gramps ID with " "value %(id)s. This value is already used by '" "%(prim_object)s'. Please enter a different ID or leave " "blank to get the next available ID value.") % { 'id' : id, 'prim_object' : name } ErrorDialog(msg1, msg2) self.ok_button.set_sensitive(True) return with DbTxn('', self.db) as trans: place_title = place_displayer.display(self.db, self.obj) if not self.obj.get_handle(): self.db.add_place(self.obj, trans) msg = _("Add Place (%s)") % place_title else: if not self.obj.get_gramps_id(): self.obj.set_gramps_id(self.db.find_next_place_gramps_id()) self.db.commit_place(self.obj, trans) msg = _("Edit Place (%s)") % place_title trans.set_description(msg) self.close() if self.callback: self.callback(self.obj)
def column_title(self, data): handle = data[0] cached, value = self.get_cached_value(handle, "PLACE") if not cached: place = Place() place.unserialize(data) value = place_displayer.display(self.db, place) self.set_cached_value(handle, "PLACE", value) return value
def get_or_create_place(self, place_name): "Return the requested place object tuple-packed with a new indicator." LOG.debug("get_or_create_place: looking for: %s", place_name) for place_handle in self.db.iter_place_handles(): place = self.db.get_place_from_handle(place_handle) place_title = place_displayer.display(self.db, place) if place_title == place_name: return (0, place) place = Place() place.set_title(place_name) self.db.add_place(place, self.trans) return (1, place)
def save(self, *obj): self.ok_button.set_sensitive(False) if self.obj.get_name().get_value().strip() == '': msg1 = _("Cannot save place. Name not entered.") msg2 = _("You must enter a name before saving.") ErrorDialog(msg1, msg2, parent=self.window) self.ok_button.set_sensitive(True) return (uses_dupe_id, id) = self._uses_duplicate_id() if uses_dupe_id: prim_object = self.get_from_gramps_id(id) name = place_displayer.display(self.db, prim_object) msg1 = _("Cannot save place. ID already exists.") msg2 = _("You have attempted to use the existing Gramps ID with " "value %(id)s. This value is already used by '" "%(prim_object)s'. Please enter a different ID or leave " "blank to get the next available ID value.") % { 'id' : id, 'prim_object' : name } ErrorDialog(msg1, msg2, parent=self.window) self.ok_button.set_sensitive(True) return place_title = place_displayer.display(self.db, self.obj) if not self.obj.handle: with DbTxn(_("Add Place (%s)") % place_title, self.db) as trans: self.db.add_place(self.obj, trans) else: if self.data_has_changed(): with DbTxn(_("Edit Place (%s)") % place_title, self.db) as trans: if not self.obj.get_gramps_id(): self.obj.set_gramps_id(self.db.find_next_place_gramps_id()) self.db.commit_place(self.obj, trans) self._do_close() if self.callback: self.callback(self.obj)
def get_subject(self): """ Return a string that describes the subject of the report. """ subject = "" if self.__filter.get_filter().get_name(): # Use the selected filter's name, if any subject += self.__filter.get_filter().get_name() if self.__places.get_value(): # Add places selected individually, if any for place_id in self.__places.get_value().split(): if subject: subject += " + " place = self.__db.get_place_from_gramps_id(place_id) subject += _pd.display(self.__db, place) return subject
def __write_place(self, handle, place_nbr): """ This procedure writes out the details of a single place """ place = self.database.get_place_from_handle(handle) location = get_main_location(self.database, place) city = location.get(PlaceType.CITY) place_title = _pd.display(self.database, place) if city == '' and place_title: city = place_title return city
def write_place(self): handles = sorted(self.database.get_place_handles(), key=self._getPlaceTimestamp) if len(handles) > 0: self._table_begin(_("Places Changed"), "PlaceTable") self._table_header(_('ID'), _('Place'), _('Changed On')) for handle in reversed(handles[-10:]): place = self.database.get_place_from_handle(handle) if place is not None: self._table_row(place.gramps_id, place_displayer.display(self.database, place), self._convert_date(place.change)) self._table_end()
def calc_url(self): """ Determine the url to use on maps.google.com Logic: use lat lon if present otherwise use description of the place """ place = self._get_first_place()[0] latitude, longitude = self._lat_lon(place) if longitude and latitude: self.url = "http://maps.google.com/maps/mm?sll=%s,%s&z=15" % (latitude, longitude) return titledescr = place_displayer.display(self.database, place) self.url = "http://maps.google.com/maps?q=%s" % \ '+'.join(titledescr.split())
def calc_url(self): """ Determine the url to use Logic: Use lat lon if present otherwise use description of the place """ place = self._get_first_place()[0] latitude, longitude = self._lat_lon(place) if longitude and latitude: self.url = "http://www.openstreetmap.org/" \ "?lat=%s&lon=%s&zoom=15" % (latitude, longitude) return titledescr = place_displayer.display(self.database, place) self.url = "http://nominatim.openstreetmap.org/"\ "search.php?q=%s" % '+'.join(titledescr.split())
def entry_change(self, entry): value = entry.get_text() if value.isnumeric() or value == "": self.last = value # This entry is numeric and valid. else: entry.set_text(self.last) # reset to the last valid entry _db = self.dbstate.db active_reference = self.uistate.get_active('Place') place_name = None if active_reference: place = _db.get_place_from_handle(active_reference) place_name = _pd.display(self.dbstate.db, place) if place_name is None: self.set_tooltip_text(self.tooltip) else: self.set_tooltip_text(place_name)
def __init__(self, dbstate, user, options_class, name, callback=None): uistate = user.uistate self.label = _('Check Place title') tool.BatchTool.__init__(self, dbstate, user, options_class, name) if self.fail: return ManagedWindow.__init__(self,uistate,[], self.__class__) self.set_window(Gtk.Window(),Gtk.Label(),'') # retrieve options CLI? #copy = self.options.handler.options_dict['copy'] #clean = self.options.handler.options_dict['clean'] self.db = dbstate.db self.total = self.db.get_number_of_places() self.progress = ProgressMeter(_('Checking Place Titles'), '', parent=uistate.window) self.progress.set_pass(_('Looking for place fields'), self.total) self.name_list = [] count = 0 for handle in self.db.get_place_handles(True): self.progress.step() place = self.db.get_place_from_handle(handle) title = place.title descr = place_displayer.display(self.db, place) if title != (descr and ""): count += 1 if title != "": self.name_list.append((handle.decode('utf8'), title, descr)) self.progress.close() if self.name_list: self.display() OkDialog(_('Differences'), '%s/%s' % (count, self.total), parent=uistate.window) else: self.progress.close() self.close() OkDialog(_('No need modifications'), _("No changes need."), parent=uistate.window)
def _build_title(db, place): """ Builds descrition string for title parameter in url """ descr = place_displayer.display(db, place) location = get_main_location(db, place) parish = location.get(PlaceType.PARISH) city = location.get(PlaceType.CITY) state = location.get(PlaceType.STATE) title_descr = "" if descr: title_descr += descr.strip() if parish: title_descr += ', ' + parish.strip() + _(" parish") if city: title_descr += ', ' + city.strip() if state: title_descr += ', ' + state.strip() + _(" state") return _strip_leading_comma(title_descr)
def write_place(self): """ Find and write Places """ handles = sorted(self.database.get_place_handles(), key=self._get_place_timestamp) if handles: self._table_begin(_("Places Changed"), "PlaceTable") self._table_header(_('ID'), _('Place'), _('Changed On')) for handle in reversed(handles[-10:]): place = self.database.get_place_from_handle(handle) if place is not None: self._table_row(place.gramps_id, place_displayer.display(self.database, place), format_time(place.change)) self._table_end()
def __write_place(self, handle, place_nbr): """ This procedure writes out the details of a single place """ place = self.database.get_place_from_handle(handle) location = get_main_location(self.database, place) city = '' for pl_type in [PlaceType.HAMLET, PlaceType.VILLAGE, PlaceType.TOWN, PlaceType.CITY]: if location.get(pl_type): city = location.get(pl_type) break place_title = _pd.display(self.database, place) if city == '' and place_title: return place_title return city
def write_kml_point_data(self): """ Writes the point data of the kml/kmz file. """ self.kml_file.write('<Document>\n') self.kml_file.write(' <name>GrampsPlaces</name>\n') for place, descr in self._all_places(): latitude, longitude = self._lat_lon(place) if latitude == None or longitude == None: location = get_main_location(self.database, place) LOG.warning(" %s : Missing coordinates(latitude/longitude): \ Skipping entry: " % (location)) continue if not descr: descr = place_displayer.display(self.database, place) location = get_main_location(self.database, place) parish_descr = location.get(PlaceType.PARISH) if parish_descr == None: parish_descr = "" city = location.get(PlaceType.CITY) county = location.get(PlaceType.COUNTY) city_county_descr = _combine(city, county) state = location.get(PlaceType.STATE) country = location.get(PlaceType.COUNTRY) state_country_descr = _combine(state, country) id = place.get_gramps_id() self.kml_file.write(' <Placemark id="%s">\n' % id) self.kml_file.write(" <name>%s</name>\n" % descr) self.kml_file.write(" <description>\n") self.kml_file.write(" <![CDATA[\n") self.kml_file.write(" %s\n" % parish_descr) self.kml_file.write(" %s\n" % city_county_descr) self.kml_file.write(" %s\n" % state_country_descr) self.kml_file.write(" ]]>\n") self.kml_file.write(" </description>\n") self.kml_file.write(" <Point>\n") self.kml_file.write(" <coordinates>%s" % longitude) self.kml_file.write(",%s</coordinates>\n" % latitude) self.kml_file.write(" </Point>\n") self.kml_file.write(" </Placemark>\n") self.kml_file.write("</Document>\n")
def _write_place(self, place_handle): """ Generate a table row with the place record information. """ place = self.database.get_place_from_handle(place_handle) self.doc.start_row() self.doc.start_cell('TR-TableCell') self.doc.start_paragraph('TR-Normal') self.doc.write_text(place.get_gramps_id()) self.doc.end_paragraph() self.doc.end_cell() self.doc.start_cell('TR-TableCell', 3) self.doc.start_paragraph('TR-Normal') self.doc.write_text(place_displayer.display(self.database, place)) self.doc.end_paragraph() self.doc.end_cell() self.doc.end_row()
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 = database.get_place_from_handle(place_handle) place_title = place_displayer.display(database, place) 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_gendex_data(database, event_ref): """ Given an event, return the date and place a strings @param: database -- The database @param: event_ref -- The event reference """ doe = "" # date of event poe = "" # place of event if event_ref and event_ref.ref: event = database.get_event_from_handle(event_ref.ref) if event: date = event.get_date_object() doe = format_date(date) if event.get_place_handle(): place_handle = event.get_place_handle() if place_handle: place = database.get_place_from_handle(place_handle) if place: poe = _pd.display(database, place, date) return doe, poe
def display_place(self, place): """ Display details of the active place. """ self.load_place_image(place) title = place_displayer.display(self.dbstate.db, place) self.title.set_text(title) self.clear_grid() self.add_row(_('Name'), place.get_name().get_value()) self.add_row(_('Type'), place.get_type()) self.display_separator() self.display_alt_names(place) self.display_separator() lat, lon = conv_lat_lon(place.get_latitude(), place.get_longitude(), format='DEG') if lat: self.add_row(_('Latitude'), lat) if lon: self.add_row(_('Longitude'), lon)
def write_kml_point_data(self): """ Writes the point data of the kml/kmz file. """ self.kml_file.write('<Document>\n') self.kml_file.write(' <name>GrampsPlaces</name>\n') for place, descr in self._all_places(): latitude, longitude = self._lat_lon(place) if latitude == None or longitude == None: continue if not descr: descr = place_displayer.display(self.database, place) location = get_main_location(self.database, place) parish_descr = location.get(PlaceType.PARISH) if parish_descr == None: parish_descr = "" city = location.get(PlaceType.CITY) county = location.get(PlaceType.COUNTY) city_county_descr = _combine(city, county) state = location.get(PlaceType.STATE) country = location.get(PlaceType.COUNTRY) state_country_descr = _combine(state, country) id = place.get_gramps_id() self.kml_file.write(' <Placemark id="%s">\n' % id) self.kml_file.write(" <name>%s</name>\n" % descr) self.kml_file.write(" <description>\n") self.kml_file.write(" <![CDATA[\n") self.kml_file.write(" %s\n" % parish_descr) self.kml_file.write(" %s\n" % city_county_descr) self.kml_file.write(" %s\n" % state_country_descr) self.kml_file.write(" ]]>\n") self.kml_file.write(" </description>\n") self.kml_file.write(" <Point>\n") self.kml_file.write(" <coordinates>%s" % longitude) self.kml_file.write(",%s</coordinates>\n" % latitude) self.kml_file.write(" </Point>\n") self.kml_file.write(" </Placemark>\n") self.kml_file.write("</Document>\n")
def get_name_id(self, handle): if self.namespace == 'Person': person = self.db.get_person_from_handle(handle) name = _nd.sorted(person) gid = person.get_gramps_id() elif self.namespace == 'Family': family = self.db.get_family_from_handle(handle) name = family_name(family, self.db) gid = family.get_gramps_id() elif self.namespace == 'Event': event = self.db.get_event_from_handle(handle) name = event.get_description() gid = event.get_gramps_id() elif self.namespace == 'Source': source = self.db.get_source_from_handle(handle) name = source.get_title() gid = source.get_gramps_id() elif self.namespace == 'Citation': citation = self.db.get_citation_from_handle(handle) name = citation.get_page() gid = citation.get_gramps_id() elif self.namespace == 'Place': place = self.db.get_place_from_handle(handle) name = _pd.display(self.db, place) gid = place.get_gramps_id() elif self.namespace == 'Media': obj = self.db.get_object_from_handle(handle) name = obj.get_description() gid = obj.get_gramps_id() elif self.namespace == 'Repository': repo = self.db.get_repository_from_handle(handle) name = repo.get_name() gid = repo.get_gramps_id() elif self.namespace == 'Note': note = self.db.get_note_from_handle(handle) name = note.get().replace('\n', ' ') if len(name) > 80: name = name[:80] + "..." gid = note.get_gramps_id() return (name, gid)
def __write_place(self, handle, place_nbr): """ This procedure writes out the details of a single place """ place = self._db.get_place_from_handle(handle) place_details = [self._("Gramps ID: %s ") % place.get_gramps_id()] for level in get_location_list(self._db, place): # translators: needed for French, ignore otherwise place_details.append( self._("%(str1)s: %(str2)s") % { 'str1': self._(level[1].xml_str()), 'str2': level[0] }) place_names = '' all_names = place.get_all_names() if len(all_names) > 1 or __debug__: for place_name in all_names: if place_names != '': # translators: needed for Arabic, ignore otherwise place_names += self._(", ") place_names += '%s' % place_name.get_value() if place_name.get_language() != '' or __debug__: place_names += ' (%s)' % place_name.get_language() place_details += [ self._("places|All Names: %s") % place_names, ] self.doc.start_paragraph("PLC-PlaceTitle") place_title = _pd.display(self._db, place) self.doc.write_text(("%(nbr)s. %(place)s") % { 'nbr': place_nbr, 'place': place_title }) self.doc.end_paragraph() for item in place_details: self.doc.start_paragraph("PLC-PlaceDetails") self.doc.write_text(item) self.doc.end_paragraph()
def sort_places(dbase, handle_list, rlocale=glocale): """ will sort the database place """ pname_sub = defaultdict(list) sortnames = {} for place_handle in handle_list: place = dbase.get_place_from_handle(place_handle) pname = _pd.display(dbase, place) sortnames[place_handle] = pname pname_sub[pname].append(place_handle) 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_simple_event(self, event_ref): if event_ref: event = self.database.get_event_from_handle(event_ref.ref) event_date = event.get_date_object() date_text = self._get_date_text(event_date) # date_text = datehandler.displayer.display(event_date) place_handle = event.get_place_handle() description = event.get_description() event_type = event.get_type() else: date_text = "" event_type = None description = "" if event_ref and place_handle: place = self.database.get_place_from_handle(place_handle) place_text = place_displayer.display(self.database, place, event_date) else: place_text = "" return event_type, date_text, place_text, description
def _create_one_place(self, place): """ Create one entry for one place with a lat/lon. """ if place is None: return if self.nbplaces >= self._config.get("geography.max_places"): return descr = _pd.display(self.dbstate.db, place) longitude = place.get_longitude() latitude = place.get_latitude() latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8") 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: colour = self.plc_color[int(place.get_type()) + 1] if int(place.get_type()) == PlaceType.CUSTOM: try: colour = (str(place.get_type()), self.plc_custom_color[str(place.get_type())]) except: colour = self.plc_color[PlaceType.CUSTOM + 1] self._append_to_places_list( descr, None, "", latitude, longitude, None, None, EventType.UNKNOWN, None, # person.gramps_id place.gramps_id, None, # event.gramps_id None, # family.gramps_id color=colour)
def calc_url(self): """ Determine the url to use on maps.google.com Logic: use lat lon if present otherwise use city and country if present otherwise use description of the place """ place = self._get_first_place()[0] latitude, longitude = self._lat_lon(place) if longitude and latitude: self.url = "http://maps.google.com/maps/mm?sll=%s,%s&z=15" % ( latitude, longitude) return location = get_main_location(self.database, place) city = location.get(PlaceType.CITY) country = location.get(PlaceType.COUNTRY) if city and country: self.url = "http://maps.google.com/maps?q=%s,%s" % (city, country) return titledescr = place_displayer.display(self.database, place) self.url = "http://maps.google.com/maps?q=%s" % \ '+'.join(titledescr.split())
def sort_val_from_handle(self, handle): if self.namespace == 'Person': name = self.db.get_person_from_handle(handle).get_primary_name() sortname = _nd.sort_string(name) elif self.namespace == 'Family': sortname = family_name(self.db.get_family_from_handle(handle), self.db) elif self.namespace == 'Event': sortname = self.db.get_event_from_handle(handle).get_description() elif self.namespace == 'Source': sortname = self.db.get_source_from_handle(handle).get_title() elif self.namespace == 'Citation': sortname = self.db.get_citation_from_handle(handle).get_page() elif self.namespace == 'Place': place = self.db.get_place_from_handle(handle) sortname = _pd.display(self.db, place) elif self.namespace == 'Media': sortname = self.db.get_object_from_handle(handle).get_description() elif self.namespace == 'Repository': sortname = self.db.get_repository_from_handle(handle).get_name() elif self.namespace == 'Note': gid = self.db.get_note_from_handle(handle).get_gramps_id() sortname = gid return (sortname, handle)
def query_response(self): place_title = place_displayer.display(self.db, self.obj) with DbTxn(_("Delete Place (%s)") % place_title, self.db) as trans: self.db.disable_signals() place_handle = self.obj.get_handle() for handle in self.person_list: person = self.db.get_person_from_handle(handle) person.remove_handle_references('Place', place_handle) self.db.commit_person(person, trans) for handle in self.family_list: family = self.db.get_family_from_handle(handle) family.remove_handle_references('Place', place_handle) self.db.commit_family(family, trans) for handle in self.event_list: event = self.db.get_event_from_handle(handle) event.remove_handle_references('Place', place_handle) self.db.commit_event(event, trans) self.db.enable_signals() self.db.remove_place(place_handle, trans)
def __init__(self, dbstate, uistate, track, handle1, handle2, callback=None): ManagedWindow.__init__(self, uistate, track, self.__class__) self.dbstate = dbstate database = dbstate.db self.callback = callback self.pl1 = database.get_place_from_handle(handle1) self.pl2 = database.get_place_from_handle(handle2) self.define_glade('mergeplace', _GLADE_FILE) self.set_window(self._gladeobj.toplevel, self.get_widget('place_title'), _("Merge Places")) self.setup_configs('interface.merge-place', 500, 250) # Detailed selection widgets if not config.get('preferences.place-auto'): title1 = self.pl1.get_title() title2 = self.pl2.get_title() entry1 = self.get_widget("title1") entry2 = self.get_widget("title2") entry1.set_text(title1) entry2.set_text(title2) if entry1.get_text() == entry2.get_text(): for widget_name in ('title1', 'title2', 'title_btn1', 'title_btn2'): self.get_widget(widget_name).set_sensitive(False) for widget_name in ('title1', 'title2', 'title_btn1', 'title_btn2'): self.get_widget(widget_name).show() for widget_name in ('name_btn1', 'name_btn2'): self.get_widget(widget_name).set_label(PLACE_NAME) entry1 = self.get_widget("name1") entry2 = self.get_widget("name2") entry1.set_text(self.pl1.get_name().get_value()) entry2.set_text(self.pl2.get_name().get_value()) if entry1.get_text() == entry2.get_text(): for widget_name in ('name1', 'name2', 'name_btn1', 'name_btn2'): self.get_widget(widget_name).set_sensitive(False) entry1 = self.get_widget("type1") entry2 = self.get_widget("type2") entry1.set_text(str(self.pl1.get_type())) entry2.set_text(str(self.pl2.get_type())) if entry1.get_text() == entry2.get_text(): for widget_name in ('type1', 'type2', 'type_btn1', 'type_btn2'): self.get_widget(widget_name).set_sensitive(False) entry1 = self.get_widget("code1") entry2 = self.get_widget("code2") entry1.set_text(self.pl1.get_code()) entry2.set_text(self.pl2.get_code()) if entry1.get_text() == entry2.get_text(): for widget_name in ('code1', 'code2', 'code_btn1', 'code_btn2'): self.get_widget(widget_name).set_sensitive(False) entry1 = self.get_widget("lat1") entry2 = self.get_widget("lat2") entry1.set_text(self.pl1.get_latitude()) entry2.set_text(self.pl2.get_latitude()) if entry1.get_text() == entry2.get_text(): for widget_name in ('lat1', 'lat2', 'lat_btn1', 'lat_btn2'): self.get_widget(widget_name).set_sensitive(False) entry1 = self.get_widget("long1") entry2 = self.get_widget("long2") entry1.set_text(self.pl1.get_longitude()) entry2.set_text(self.pl2.get_longitude()) if entry1.get_text() == entry2.get_text(): for widget_name in ('long1', 'long2', 'long_btn1', 'long_btn2'): self.get_widget(widget_name).set_sensitive(False) gramps1 = self.pl1.get_gramps_id() gramps2 = self.pl2.get_gramps_id() entry1 = self.get_widget("gramps1") entry2 = self.get_widget("gramps2") entry1.set_text(gramps1) entry2.set_text(gramps2) if entry1.get_text() == entry2.get_text(): for widget_name in ('gramps1', 'gramps2', 'gramps_btn1', 'gramps_btn2'): self.get_widget(widget_name).set_sensitive(False) # Main window widgets that determine which handle survives title1 = place_displayer.display(database, self.pl1) title2 = place_displayer.display(database, self.pl2) rbutton1 = self.get_widget("handle_btn1") rbutton_label1 = self.get_widget("label_handle_btn1") rbutton_label2 = self.get_widget("label_handle_btn2") rbutton_label1.set_label(title1 + " [" + gramps1 + "] " + str(self.pl1.place_type)) rbutton_label2.set_label(title2 + " [" + gramps2 + "] " + str(self.pl2.place_type)) rbutton1.connect("toggled", self.on_handle1_toggled) self.connect_button('place_help', self.cb_help) self.connect_button('place_ok', self.cb_merge) self.connect_button('place_cancel', self.close) self.show()
def update_title(self): new_title = place_displayer.display(self.db, self.source) self.top.get_object("preview_title").set_text(new_title)
def display(self): self.top = Glade("changenames.glade") window = self.top.toplevel self.top.connect_signals({ "destroy_passed_object" : self.close, "on_ok_clicked" : self.on_ok_clicked, "on_help_clicked" : self.on_help_clicked, "on_delete_event" : self.close, }) self.list = self.top.get_object("list") self.set_window(window, self.top.get_object('title'), self.label) lbl = self.top.get_object('info') lbl.set_line_wrap(True) lbl.set_text( _('Below is a list of Places with the possible data that can ' 'be extracted from the place title. Select the places you ' 'wish Gramps to convert.')) self.model = Gtk.ListStore(GObject.TYPE_BOOLEAN, GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING, GObject.TYPE_STRING) r = Gtk.CellRendererToggle() r.connect('toggled', self.toggled) c = Gtk.TreeViewColumn(_('Select'), r, active=0) self.list.append_column(c) for (title, col) in COLS: render = Gtk.CellRendererText() if col > 1: render.set_property('editable', True) render.connect('edited', self.__change_name, col) self.list.append_column( Gtk.TreeViewColumn(title, render, text=col)) self.list.set_model(self.model) self.iter_list = [] self.progress.set_pass(_('Building display'), len(self.name_list)) for (id, data) in self.name_list: place = self.db.get_place_from_handle(id) descr = place_displayer.display(self.db, place) handle = self.model.append() self.model.set_value(handle, 0, True) self.model.set_value(handle, 1, descr) if data[0]: self.model.set_value(handle, 2, data[0]) if data[1]: self.model.set_value(handle, 3, data[1]) if data[2]: self.model.set_value(handle, 4, data[2]) if data[3]: self.model.set_value(handle, 5, data[3]) self.model.set_value(handle, 6, id) self.iter_list.append(handle) self.progress.step() self.progress.close() self.show()
def write_places(self): """ write the places associated with the tag """ plist = self.database.get_place_handles() filter_class = GenericFilterFactory('Place') a_filter = filter_class() a_filter.add_rule(rules.place.HasTag([self.tag])) place_list = a_filter.apply(self.database, plist) if not place_list: return self.doc.start_paragraph("TR-Heading") header = self._("Places") mark = IndexMark(header, INDEX_TYPE_TOC, 2) self.doc.write_text(header, mark) self.doc.end_paragraph() self.doc.start_table('PlaceTable', 'TR-Table') self.doc.start_row() self.doc.start_cell('TR-TableCell') self.doc.start_paragraph('TR-Normal-Bold') self.doc.write_text(self._("Id")) self.doc.end_paragraph() self.doc.end_cell() self.doc.start_cell('TR-TableCell') self.doc.start_paragraph('TR-Normal-Bold') self.doc.write_text(self._("Title")) self.doc.end_paragraph() self.doc.end_cell() self.doc.start_cell('TR-TableCell') self.doc.start_paragraph('TR-Normal-Bold') self.doc.write_text(self._("Name")) self.doc.end_paragraph() self.doc.end_cell() self.doc.start_cell('TR-TableCell') self.doc.start_paragraph('TR-Normal-Bold') self.doc.write_text(self._("Type")) self.doc.end_paragraph() self.doc.end_cell() self.doc.end_row() for place_handle in place_list: place = self.database.get_place_from_handle(place_handle) place_title = _pd.display(self.database, place) self.doc.start_row() self.doc.start_cell('TR-TableCell') self.doc.start_paragraph('TR-Normal') self.doc.write_text(place.get_gramps_id()) self.doc.end_paragraph() self.doc.end_cell() self.doc.start_cell('TR-TableCell') self.doc.start_paragraph('TR-Normal') self.doc.write_text(place_title) self.doc.end_paragraph() self.doc.end_cell() self.doc.start_cell('TR-TableCell') self.doc.start_paragraph('TR-Normal') self.doc.write_text(place.get_name().get_value()) self.doc.end_paragraph() self.doc.end_cell() self.doc.start_cell('TR-TableCell') self.doc.start_paragraph('TR-Normal') self.doc.write_text(str(place.get_type())) self.doc.end_paragraph() self.doc.end_cell() self.doc.end_row() self.doc.end_table()
def print_object(self, level, o): if issubclass(o.__class__, gramps.gen.lib.address.Address): # Details of address are printed by the subclass conditions, # primarily by LocationBase, because address is a subclass of # LocationBase pass if issubclass(o.__class__, gramps.gen.lib.addressbase.AddressBase): for address in o.get_address_list(): self.print_header(level, _("Address"), ref=address) self.print_object(level + 1, address) if isinstance(o, gramps.gen.lib.Attribute): # The unique information about attributes (the type) is printed by # AttributeBase pass if issubclass(o.__class__, gramps.gen.lib.attrbase.AttributeBase): for attribute in o.get_attribute_list(): self.print_header(level, _("Attribute") + ". ", type_desc=str(attribute.get_type()), obj_type=attribute.get_value(), privacy=attribute.get_privacy(), ref=attribute) self.print_object(level + 1, attribute) if isinstance(o, gramps.gen.lib.ChildRef): # The unique information about ChildRef (the father relation and # mother relation) is printed by the main write_report function pass if issubclass(o.__class__, gramps.gen.lib.citationbase.CitationBase): if self.print_citations: self.print_header(level, "CitationBase tbd") for citation_handle in o.get_citation_list(): citation = self.database.get_citation_from_handle( citation_handle) self.print_object(level + 1, citation) if isinstance(o, gramps.gen.lib.Citation): # the unique information about Citation (the page) is printed by the # bibliography code. The other unique information, the confidence is # printed here if o.get_confidence_level() != gramps.gen.lib.Citation.CONF_NORMAL: self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Confidence") + " : ") self.doc.end_bold() self.doc.write_text( conf_strings.get(o.get_confidence_level(), _('Unknown'))) self.doc.end_paragraph() if self.print_citations: source_handle = o.get_reference_handle() source = self.database.get_source_from_handle(source_handle) self.print_object(level + 1, source) if issubclass(o.__class__, gramps.gen.lib.datebase.DateBase): if o.get_date_object() and not o.get_date_object().is_empty(): self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Date") + " : ") self.doc.end_bold() self.doc.write_text(displayer.display(o.get_date_object())) self.doc.end_paragraph() if isinstance(o, gramps.gen.lib.Event): # The event type is printed by the main write_report function self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Description") + " : ") self.doc.end_bold() self.doc.write_text(str(o.get_description())) self.doc.end_paragraph() if issubclass(o.__class__, gramps.gen.lib.eventref.EventRef): # The unique information about EventRef (the EventRoleType) is # printed by the main write_report function event = self.database.get_event_from_handle( o.get_reference_handle()) self.print_header(level, _("Event"), event.get_gramps_id(), _("Event type"), str(event.get_type()), event.get_privacy(), ref=event) self.print_object(level + 1, event) if isinstance(o, gramps.gen.lib.Family): # The unique information about Family (father, mother and children, # FamilyRelType and event references) are printed by the main # write_report function pass if isinstance(o, gramps.gen.lib.LdsOrd): # The Ordinance type is printed by LdsOrdBase self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Temple and status") + " : ") self.doc.end_bold() self.doc.write_text(", ".join( (TEMPLES.name(o.get_temple()), o.status2str()))) self.doc.end_paragraph() f_h = o.get_family_handle() if f_h: family = self.database.get_family_from_handle(f_h) self.print_family_summary(level + 1, family, _("LDS Ordinance family")) if issubclass(o.__class__, gramps.gen.lib.ldsordbase.LdsOrdBase): for ldsord in o.get_lds_ord_list(): self.print_header(level, _("LDS "), type_desc=_("Ordinance"), obj_type=ldsord.type2str(), privacy=ldsord.get_privacy(), ref=ldsord) self.print_object(level + 1, ldsord) if isinstance(o, gramps.gen.lib.Location): # The unique information about location (Parish) is printed by # Place. Location otherwise serves as a pointer to a LocationBase # object pass if issubclass(o.__class__, gramps.gen.lib.locationbase.LocationBase): self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text( _("Street, City, County, State, Postal Code, " "Country, Phone number") + " : ") self.doc.end_bold() self.doc.write_text(", ".join( (o.get_street(), o.get_city(), o.get_county(), o.get_state(), o.get_postal_code(), o.get_country(), o.get_phone()))) self.doc.end_paragraph() if issubclass(o.__class__, gramps.gen.lib.mediabase.MediaBase): for mediaref in o.get_media_list(): self.print_header(level, _("Media Reference"), ref=mediaref) self.print_object(level + 1, mediaref) if isinstance(o, gramps.gen.lib.Media): # thumb is not printed. The mime type is printed by MediaRef self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Description and Path") + " : ") self.doc.end_bold() self.doc.write_text(o.get_description() + ", ") path = o.get_path() if path: mark = IndexMark( "file://:" + media_path_full(self.database, path), LOCAL_HYPERLINK) self.doc.write_text(path, mark=mark) self.doc.end_paragraph() mime_type = o.get_mime_type() if mime_type and mime_type.startswith("image"): filename = media_path_full(self.database, o.get_path()) if os.path.exists(filename): self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.add_media(filename, "single", 4.0, 4.0) self.doc.end_paragraph() else: self._user.warn( _("Could not add photo to page"), "%s: %s" % (filename, _('File does not exist'))) if isinstance(o, gramps.gen.lib.MediaRef): media_handle = o.get_reference_handle() media = self.database.get_media_from_handle(media_handle) if o.get_rectangle(): self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Referenced Region") + " : ") self.doc.end_bold() self.doc.write_text(", ".join( (("%d" % i) for i in o.get_rectangle()))) self.doc.end_paragraph() mime_type = media.get_mime_type() if mime_type and mime_type.startswith("image"): filename = media_path_full(self.database, media.get_path()) if os.path.exists(filename): self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.add_media(filename, "single", 4.0, 4.0, crop=o.get_rectangle()) self.doc.end_paragraph() desc = get_description(media.get_mime_type()) if not desc: desc = _("unknown") self.print_header(level, _("Media Object"), media.get_gramps_id(), _("Mime type"), desc, media.get_privacy(), ref=media) self.print_object(level + 1, media) if isinstance(o, gramps.gen.lib.Name): # group_as, sort_as and display_as are not printed. NameType is # printed by the main write_report function self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text( _("Given name(s): Title, Given, Suffix, " "Call Name, Nick Name, Family Nick Name") + " : ") self.doc.end_bold() self.doc.write_text(", ".join( (o.get_title(), o.get_first_name(), o.get_suffix(), o.get_call_name(), o.get_nick_name(), o.get_family_nick_name()))) self.doc.end_paragraph() if isinstance(o, gramps.gen.lib.Note): # The NoteType is printed by NoteBase. Whether the note is flowed or # not is not printed, but affects the way the note appears self.doc.write_styled_note( o.get_styledtext(), o.get_format(), "PE-Level%d" % min(level, 32), contains_html=o.get_type() == gramps.gen.lib.notetype.NoteType.HTML_CODE) if issubclass(o.__class__, gramps.gen.lib.notebase.NoteBase): for n_h in o.get_note_list(): note = self.database.get_note_from_handle(n_h) self.print_header(level, _("Note"), note.get_gramps_id(), _("Note type"), str(note.get_type()), note.get_privacy()) self.print_object(level + 1, note) if issubclass(o.__class__, gramps.gen.lib.Person): # This is printed by the main write-report function pass if isinstance(o, gramps.gen.lib.Place): # The title, name, type, code and lat/long are printed by PlaceBase for placeref in o.get_placeref_list(): self.print_header(level, _("Parent Place")) self.print_object(level + 1, placeref) # location = o.get_main_location() # if location.get_parish(): # self.print_header(level, _("Main Location"), # type_desc=_("Parish"), # obj_type=location.get_parish()) # else: # self.print_header(level, _("Main Location")) # # self.print_object(level+1, location) # for location in o.get_alternate_locations(): if location.get_parish(): self.print_header(level, _("Alternate Location"), type_desc=_("Parish"), obj_type=location.get_parish()) else: self.print_header(level, _("Alternate Location")) self.print_object(level + 1, location) if issubclass(o.__class__, gramps.gen.lib.placebase.PlaceBase) or \ issubclass(o.__class__, gramps.gen.lib.placeref.PlaceRef): if issubclass(o.__class__, gramps.gen.lib.placebase.PlaceBase): place_handle = o.get_place_handle() else: place_handle = o.get_reference_handle() if place_handle: place = self.database.get_place_from_handle(place_handle) if place: place_title = place_displayer.display(self.database, place) self.print_header(level, _("Place"), place.get_gramps_id(), _("Place Title"), place_title, privacy=place.get_privacy(), ref=place) self.doc.start_paragraph("PE-Level%d" % min(level + 1, 32)) self.doc.start_bold() self.doc.write_text(_("Name") + " : ") self.doc.end_bold() self.doc.write_text(place.get_name().value) self.doc.start_bold() self.doc.write_text(" " + _("Type") + " : ") self.doc.end_bold() self.doc.write_text(str(place.get_type())) self.doc.start_bold() self.doc.write_text(" " + _("Code") + " : ") self.doc.end_bold() self.doc.write_text(place.get_code()) self.doc.end_paragraph() for name in place.get_alternative_names(): self.doc.start_paragraph("PE-Level%d" % min(level + 1, 32)) self.doc.start_bold() self.doc.write_text(_("Alternative Name") + " : ") self.doc.end_bold() self.doc.write_text(name.value) self.doc.end_paragraph() if place.get_longitude() or place.get_latitude(): self.doc.start_paragraph("PE-Level%d" % min(level + 1, 32)) self.doc.start_bold() self.doc.write_text(_("Latitude, Longitude") + " : ") self.doc.end_bold() self.doc.write_text(", ".join( (place.get_longitude(), place.get_latitude()))) self.doc.end_paragraph() self.print_object(level + 1, place) if issubclass(o.__class__, gramps.gen.lib.primaryobj.BasicPrimaryObject): # The Gramps ID is printed by the enclosing object pass if issubclass(o.__class__, gramps.gen.lib.privacybase.PrivacyBase): # The privacy is printed by the enclosing object pass if isinstance(o, gramps.gen.lib.RepoRef): # The media type is printed by source self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Call number") + " : ") self.doc.end_bold() self.doc.write_text(o.get_call_number()) self.doc.end_paragraph() repository_handle = o.get_reference_handle() repository = self.database.get_repository_from_handle( repository_handle) self.print_header(level, _("Repository"), repository.get_gramps_id(), _("Repository type"), str(repository.get_type()), privacy=repository.get_privacy()) self.print_object(level + 1, repository) if isinstance(o, gramps.gen.lib.Repository): # the repository type is printed by RepoRef pass if isinstance(o, gramps.gen.lib.Source): # The title, author, abbreviation and publication information are # printed by the bibliography code # data_map = o.get_data_map() # for key in data_map.keys(): # self.doc.start_paragraph("PE-Level%d" % min(level, 32)) # self.doc.start_bold() # self.doc.write_text(_("Data") + ". " + key + " : ") # self.doc.end_bold() # self.doc.write_text(data_map[key]) # self.doc.end_paragraph() reporef_list = o.get_reporef_list() for reporef in reporef_list: self.print_header(level, _("Repository reference"), type_desc=_("Media type"), obj_type=str(reporef.get_media_type()), privacy=reporef.get_privacy()) self.print_object(level + 1, reporef) if isinstance(o, gramps.gen.lib.Surname): if o.get_origintype(): self.print_header(level, _("Surname"), type_desc=_("Origin type"), obj_type=str(o.get_origintype())) else: self.print_header(level, _("Surname"), privacy=o.get_privacy()) self.doc.start_paragraph("PE-Level%d" % min(level + 1, 32)) self.doc.start_bold() self.doc.write_text(_("Prefix, surname, connector") + " : ") self.doc.end_bold() self.doc.write_text(", ".join( (o.get_prefix(), o.get_surname(), o.get_connector()))) if o.get_primary(): self.doc.write_text(" " + _("{This is the primary surname}")) self.doc.end_paragraph() if isinstance(o, gramps.gen.lib.surnamebase.SurnameBase): surname_list = o.get_surname_list() for surname in surname_list: self.print_object(level, surname) if issubclass(o.__class__, gramps.gen.lib.tagbase.TagBase): for tag_handle in o.get_tag_list(): tag = self.database.get_tag_from_handle(tag_handle) self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Tag name") + " : ") self.doc.end_bold() self.doc.write_text(tag.get_name()) self.doc.end_paragraph() self.print_object(level + 1, tag) if issubclass(o.__class__, gramps.gen.lib.Tag): # The tag name is printed by TagBase if o.get_color() != "#000000000000" or o.get_priority() != 0: self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Tag colour and priority") + " : ") self.doc.end_bold() self.doc.write_text(o.get_color() + ", " + "%d" % o.get_priority()) self.doc.end_paragraph() if issubclass(o.__class__, gramps.gen.lib.urlbase.UrlBase): for url in o.get_url_list(): self.print_header(level, _("URL"), type_desc=_("Type"), obj_type=str(url.get_type()), privacy=url.get_privacy()) self.print_object(level + 1, url) if isinstance(o, gramps.gen.lib.Url): self.doc.start_paragraph("PE-Level%d" % min(level, 32)) self.doc.start_bold() self.doc.write_text(_("Description and Path") + " : ") self.doc.end_bold() self.doc.write_text(o.get_description() + ", ") path = o.get_path() if path: mark = IndexMark(path, LOCAL_HYPERLINK) self.doc.write_text(path, mark=mark) self.doc.end_paragraph() return o
def list_people_changed(self, object_type): """ List all records with last change date """ nb_items = 0 def sort_on_change(handle): """ sort records based on the last change time """ obj = fct(handle) timestamp = obj.get_change_time() return timestamp if object_type == Person: fct = self.report.database.get_person_from_handle fct_link = self.new_person_link elif object_type == Family: fct = self.report.database.get_family_from_handle fct_link = self.family_link elif object_type == Event: fct = self.report.database.get_event_from_handle elif object_type == Place: fct = self.report.database.get_place_from_handle fct_link = self.place_link elif object_type == Source: fct = self.report.database.get_place_from_handle fct_link = self.source_link elif object_type == Repository: fct = self.report.database.get_place_from_handle fct_link = self.repository_link elif object_type == Media: fct = self.report.database.get_place_from_handle obj_list = sorted(self.report.obj_dict[object_type], key=sort_on_change, reverse=True) with Html("table", class_="list", id="list") as section: for handle in obj_list: date = obj = None name = "" obj = fct(handle) if object_type == Person: name = fct_link(handle) elif object_type == Family: name = self.report.get_family_name(obj) name = fct_link(handle, name) elif object_type == Event: otype = obj.get_type() date = obj.get_date_object() if int(otype) in _EVENTMAP: handle_list = set( self.report.database.find_backlink_handles( handle, include_classes=['Family', 'Person'])) else: handle_list = set( self.report.database.find_backlink_handles( handle, include_classes=['Person'])) if handle_list: name = Html("span", self._(otype.xml_str())+" ") for obj_t, r_handle in handle_list: if obj_t == 'Person': name += self.new_person_link(r_handle) else: srbd = self.report.database fam = srbd.get_family_from_handle(r_handle) srgfn = self.report.get_family_name name += self.family_link(r_handle, srgfn(fam)) elif object_type == Place: name = _pd.display(self.report.database, obj) name = fct_link(handle, name) elif object_type == Source: name = obj.get_title() name = fct_link(handle, name) elif object_type == Repository: name = obj.get_name() name = fct_link(handle, name) elif object_type == Media: name = obj.get_description() url = self.report.build_url_fname_html(handle, "img") name = Html("a", name, href=url, title=name) if obj: timestamp = obj.get_change_time() if timestamp - self.maxdays > 0: nb_items += 1 if nb_items > self.nbr: break tims = localtime(timestamp) odat = Date(tims.tm_year, tims.tm_mon, tims.tm_mday) date = self.rlocale.date_displayer.display(odat) date += strftime(' %X', tims) row = Html("tr") section += row row += Html("td", date, class_="date") row += Html("td", name) return section
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 longname(self): return place_displayer.display(self.db, self.place)
def list_notes(self): """ List all notes with last change date """ nb_items = 0 section = "" def sort_on_change(handle): """ sort records based on the last change time """ fct = self.report.database.get_note_from_handle obj = fct(handle) timestamp = obj.get_change_time() return timestamp note_list = self.report.database.get_note_handles() obj_list = sorted(note_list, key=sort_on_change, reverse=True) with Html("table", class_="list", id="list") as section: for handle in obj_list: show = False date = obj = None obj = self.report.database.get_note_from_handle(handle) if obj: text = html_escape(obj.get()[:50]) timestamp = obj.get_change_time() if timestamp - self.maxdays > 0: handle_list = set( self.report.database.find_backlink_handles( handle, include_classes=['Person', 'Family', 'Event', 'Place', 'Media', 'Source', 'Citation', 'Repository', ])) tims = localtime(timestamp) odat = Date(tims.tm_year, tims.tm_mon, tims.tm_mday) date = self.rlocale.date_displayer.display(odat) date += strftime(' %X', tims) if handle_list: srbd = self.report.database srbkref = self.report.bkref_dict for obj_t, r_handle in handle_list: if obj_t == 'Person': if r_handle in srbkref[Person]: name = self.new_person_link(r_handle) show = True elif obj_t == 'Family': if r_handle in srbkref[Family]: fam = srbd.get_family_from_handle( r_handle) fam = self._("Family") name = self.family_link(r_handle, fam) if self.inc_families: show = True elif obj_t == 'Place': if r_handle in srbkref[Place]: plc = srbd.get_place_from_handle( r_handle) plcn = _pd.display(self.report.database, plc) name = self.place_link(r_handle, plcn) if self.inc_places: show = True elif obj_t == 'Event': if r_handle in srbkref[Event]: evt = srbd.get_event_from_handle( r_handle) evtn = self._(evt.get_type().xml_str()) name = self.event_link(r_handle, evtn) if self.inc_events: show = True elif obj_t == 'Media': if r_handle in srbkref[Media]: media = srbd.get_media_from_handle( r_handle) evtn = media.get_description() name = self.media_link(r_handle, evtn, evtn, usedescr=False) if self.inc_gallery: show = True elif obj_t == 'Citation': if r_handle in srbkref[Citation]: cit = srbd.get_event_from_handle( r_handle) citsrc = cit.source_handle evtn = self._("Citation") name = self.source_link(citsrc, evtn) if self.inc_sources: show = True elif obj_t == 'Source': if r_handle in srbkref[Source]: src = srbd.get_source_from_handle( r_handle) evtn = src.get_title() name = self.source_link(r_handle, evtn) if self.inc_sources: show = True elif obj_t == 'Repository': if r_handle in srbkref[Repository]: rep = srbd.get_repository_from_handle( r_handle) evtn = rep.get_name() name = self.repository_link(r_handle, evtn) if self.inc_repository: show = True if show: row = Html("tr") section += row row += Html("td", date, class_="date") row += Html("td", text) row += Html("td", name) nb_items += 1 if nb_items > self.nbr: break return section
def _default_format(self, place): return _pd.display(self.database, place, date=self.date)
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 _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 run(self, db): """ Performs the actual extraction of information """ self.progress = ProgressMeter(_('Checking Place Titles'), '') self.progress.set_pass(_('Looking for place fields'), self.db.get_number_of_places()) self.name_list = [] self.place_import = PlaceImport(db) for place in db.iter_places(): descr = place_displayer.display(db, place) self.progress.step() loc = get_main_location(db, place) location = ((loc.get(PlaceType.STREET, '')), (loc.get(PlaceType.LOCALITY, '')), (loc.get(PlaceType.PARISH, '')), (loc.get(PlaceType.CITY, '')), (loc.get(PlaceType.COUNTY, '')), (loc.get(PlaceType.STATE, '')), (loc.get(PlaceType.COUNTRY, ''))) self.place_import.store_location(location, place.handle) if len(place.get_placeref_list()) == 0: match = CITY_STATE_ZIP.match(descr.strip()) if match: data = match.groups() city = data[0] state = data[2] postal = data[5] val = " ".join(state.strip().split()).upper() if state: new_state = STATE_MAP.get(val.upper()) if new_state: self.name_list.append( (place.handle, (city, new_state[0], postal, COUNTRY[new_state[1]]))) continue # Check if there is a left parant. in the string, might be Swedish laen. match = CITY_LAEN.match(descr.strip().replace(","," ")) if match: data = match.groups() city = data[0] state = '(' + data[1] + ')' postal = None val = " ".join(state.strip().split()).upper() if state: new_state = STATE_MAP.get(val.upper()) if new_state: self.name_list.append( (place.handle, (city, new_state[0], postal, COUNTRY[new_state[1]]))) continue match = CITY_STATE.match(descr.strip()) if match: data = match.groups() city = data[0] state = data[1] postal = None if state: m0 = STATE_ZIP.match(state) if m0: (state, postal) = m0.groups() val = " ".join(state.strip().split()).upper() if state: new_state = STATE_MAP.get(val.upper()) if new_state: self.name_list.append( (place.handle, (city, new_state[0], postal, COUNTRY[new_state[1]]))) continue val = " ".join(descr.strip().split()).upper() new_state = STATE_MAP.get(val) if new_state: self.name_list.append( (place.handle, (None, new_state[0], None, COUNTRY[new_state[1]]))) self.progress.close() if self.name_list: self.display() else: self.close() from gramps.gui.dialog import OkDialog OkDialog(_('No modifications made'), _("No place information could be extracted."))
def load_model(self): """ Objects can have very large backreferences. To avoid blocking the interface up to the moment that the model is created, this method is called via GLib.idle_add. WARNING: a consequence of above is that loading can still be happening while the GUI using this model is no longer used. Disconnect any methods before closing the GUI. """ self.loading = True self.count = 0 for ref in self.sref_list: self.count += 1 dtype = ref[0] if dtype == 'Person': p = self.db.get_person_from_handle(ref[1]) if not p: continue gid = p.gramps_id handle = p.handle name = name_displayer.display(p) elif dtype == 'Family': p = self.db.get_family_from_handle(ref[1]) if not p: continue gid = p.gramps_id handle = p.handle name = family_name(p, self.db) elif dtype == 'Source': p = self.db.get_source_from_handle(ref[1]) if not p: continue gid = p.gramps_id handle = p.handle name = p.get_title() elif dtype == 'Citation': p = self.db.get_citation_from_handle(ref[1]) if not p: continue gid = p.gramps_id handle = p.handle name = p.get_page() elif dtype == 'Event': p = self.db.get_event_from_handle(ref[1]) if not p: continue gid = p.gramps_id handle = p.handle name = p.get_description() if name: name = self.dispstr % { 'part1': str(p.get_type()), 'part2': name } else: name = str(p.get_type()) part = get_participant_from_event(self.db, ref[1]) if part: name = self.dispstr % {'part1': name, 'part2': part} elif dtype == 'Place': p = self.db.get_place_from_handle(ref[1]) if not p: continue name = place_displayer.display(self.db, p) gid = p.gramps_id handle = p.handle elif dtype == 'Repository': p = self.db.get_repository_from_handle(ref[1]) if not p: continue name = p.get_name() gid = p.gramps_id handle = p.handle else: p = self.db.get_object_from_handle(ref[1]) if not p: continue name = p.get_description() gid = p.gramps_id handle = p.handle # dtype is the class name, i.e. is English # We need to use localized string in the model. # we also need to keep class names to get the object type, # but we don't need to show that in the view. self.append(row=[_(dtype), gid, name, handle, dtype]) yield True self.loading = False yield False
def _createmap_for_one_event(self, event): """ Create all markers for each people's event in the database which has a lat/lon. """ dbstate = self.dbstate if self.nbplaces >= self._config.get("geography.max_places"): return descr1 = descr2 = "" if event: place_handle = event.get_place_handle() eventyear = event.get_date_object().to_calendar(self.cal).get_year() else: place_handle = None if place_handle: place = dbstate.db.get_place_from_handle(place_handle) if place: descr1 = _pd.display(dbstate.db, place) longitude = place.get_longitude() latitude = place.get_latitude() latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8") # place.get_longitude and place.get_latitude return # one string. We have coordinates when the two values # contains non null string. if longitude and latitude: person_list = [ dbstate.db.get_person_from_handle(ref_handle) for (ref_type, ref_handle) in dbstate.db.find_backlink_handles(event.handle) if ref_type == 'Person' ] if person_list: for person in person_list: if descr2 == "": descr2 = ("%s") % _nd.display(person) else: descr2 = ("%s - %s") % (descr2, _nd.display(person)) else: # family list ? family_list = [ dbstate.db.get_family_from_handle(ref_handle) for (ref_type, ref_handle) in dbstate.db.find_backlink_handles(event.handle) if ref_type == 'Family' ] if family_list: for family in family_list: father = mother = None hdle = family.get_father_handle() if hdle: father = dbstate.db.get_person_from_handle( hdle) hdle = family.get_mother_handle() if hdle: mother = dbstate.db.get_person_from_handle( hdle) descr2 = ("%(father)s - %(mother)s") % { 'father': _nd.display(father) if father is not None else "?", 'mother': _nd.display(mother) if mother is not None else "?" } else: descr2 = _("incomplete or unreferenced event ?") self._append_to_places_list(descr1, None, None, latitude, longitude, descr2, eventyear, event.get_type(), None, # person.gramps_id place.gramps_id, event.gramps_id, None )
def _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 get_label(self, place): place_title = place_displayer.display(self.db, place) return "%s [%s]" % (place_title, place.gramps_id)