def _validate_coordinate(self, widget, text, typedeg): if (typedeg == 'lat') and not conv_lat_lon(text, "0", "ISO-D"): return ValidationError(_("Invalid latitude (syntax: 18\u00b09'") + _('48.21"S, -18.2412 or -18:9:48.21)')) elif (typedeg == 'lon') and not conv_lat_lon("0", text, "ISO-D"): return ValidationError(_("Invalid longitude (syntax: 18\u00b09'") + _('48.21"E, -18.2412 or -18:9:48.21)'))
def format_gps(raw_dms, nsew): """ Convert raw degrees, minutes, seconds and a direction reference into a string for display. """ value = 0.0 divisor = 1.0 for val in raw_dms.split(' '): try: num = float(val.split('/')[0]) / float(val.split('/')[1]) except (ValueError, IndexError): value = None break value += num / divisor divisor *= 60 if nsew == 'N': result = conv_lat_lon(str(value), '0', 'DEG')[0] elif nsew == 'S': result = conv_lat_lon('-' + str(value), '0', 'DEG')[0] elif nsew == 'E': result = conv_lat_lon('0', str(value), 'DEG')[1] elif nsew == 'W': result = conv_lat_lon('0', '-' + str(value), 'DEG')[1] else: result = None return result if result is not None else _('Invalid format')
def _validate_coordinate(self, widget, text, typedeg): if (typedeg == 'lat') and not conv_lat_lon(text, "0", "ISO-D"): return ValidationError(_("Invalid latitude (syntax: 18\u00b09'") + _('48.21"S, -18.2412 or -18:9:48.21)')) elif (typedeg == 'lon') and not conv_lat_lon("0", text, "ISO-D"): return ValidationError(_("Invalid longitude (syntax: 18\u00b09'") + _('48.21"E, -18.2412 or -18:9:48.21)'))
def person_count(self, person): """ Count the number of events associated to a place with coordinates """ dbstate = self.dbstate for event_ref in person.get_event_ref_list(): if not event_ref: continue event = dbstate.db.get_event_from_handle(event_ref.ref) 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") if longitude and latitude: self.nb_evts += 1 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) if father: self.already_done.append(handle) handle = fam.get_mother_handle() if handle: self.already_done.append(handle) mother = dbstate.db.get_person_from_handle(handle) for event_ref in family.get_event_ref_list(): if event_ref: event = dbstate.db.get_event_from_handle(event_ref.ref) 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") if longitude and latitude: self.nb_evts += 1 for pers in [ self._get_parent(person, True), self._get_parent(person, False) ]: if pers: self.person_count(pers)
def _test_formats_success(self, lat, lon): for format_ in ["D.D4", "D.D8", "DEG", "DEG-:", "RT90", "GEDCOM"]: res1, res2 = conv_lat_lon(lat, lon, format_) self.assertIsNotNone(res1, 'Failed for %s %s' % (lat, lon)) self.assertIsNotNone(res2, 'Failed for %s %s' % (lat, lon)) for format_ in ["ISO-D", "ISO-DM", "ISO-DMS"]: res = conv_lat_lon(lat, lon, format_) self.assertIsNotNone(res, 'Failed for %s %s' % (lat, lon))
def _test_formats_success(self, lat, lon): for format_ in ["D.D4", "D.D8", "DEG", "DEG-:", "RT90", "GEDCOM"]: res1, res2 = conv_lat_lon(lat, lon, format_) self.assertIsNotNone(res1, 'Failed for %s %s' % (lat, lon)) self.assertIsNotNone(res2, 'Failed for %s %s' % (lat, lon)) for format_ in ["ISO-D", "ISO-DM", "ISO-DMS"]: res = conv_lat_lon(lat, lon, format_) self.assertIsNotNone(res, 'Failed for %s %s' % (lat, lon))
def _validate_coordinate(self, widget, text, typedeg): if (typedeg == 'lat') and not conv_lat_lon(text, "0", "ISO-D"): return ValidationError( # translators: translate the "S" too (and the "or" of course) _('Invalid latitude\n(syntax: ' '18\u00b09\'48.21"S, -18.2412 or -18:9:48.21)')) elif (typedeg == 'lon') and not conv_lat_lon("0", text, "ISO-D"): return ValidationError( # translators: translate the "E" too (and the "or" of course) _('Invalid longitude\n(syntax: ' '18\u00b09\'48.21"E, -18.2412 or -18:9:48.21)'))
def _validate_coordinate(self, widget, text, typedeg): if (typedeg == 'lat') and not conv_lat_lon(text, "0", "ISO-D"): return ValidationError( # translators: translate the "S" too (and the "or" of course) _('Invalid latitude\n(syntax: ' '18\u00b09\'48.21"S, -18.2412 or -18:9:48.21)')) elif (typedeg == 'lon') and not conv_lat_lon("0", text, "ISO-D"): return ValidationError( # translators: translate the "E" too (and the "or" of course) _('Invalid longitude\n(syntax: ' '18\u00b09\'48.21"E, -18.2412 or -18:9:48.21)'))
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 _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 ) else: self._append_to_places_without_coord(place.gramps_id, descr)
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 column_longitude(self, data): if not data[3]: return '' value = conv_lat_lon('0', data[3], format='DEG')[1] if not value: return _("Error in format") return value
def column_latitude(self, data): if not data[4]: return '' value = conv_lat_lon(data[4], '0', format='DEG')[0] if not value: return _("Error in format") return value
def sort_latitude(self, data): if not data[4]: return '' value = conv_lat_lon(data[4], '0', format='ISO-DMS') if data[4] else '' if not value: return _("Error in format") return value
def on_fromDBButton_clicked(self, widget): latitude = self.entry_lat_db.get_text() longitude = self.entry_long_db.get_text() if latitude != "" and longitude != "": self.entry_lat.set_text(self.entry_lat_db.get_text()) self.entry_long.set_text(self.entry_long_db.get_text()) try: latitude, longitude = conv_lat_lon( latitude, longitude, format="D.D8") latitude = float(latitude) longitude = float(longitude) except: self.entry_foundName.set_text( _("Failed to interpret the input format.")) # self.osm.grab_focus() try: loc = GeocodeGlib.Location.new(latitude, longitude, 0) obj = GeocodeGlib.Reverse.new_for_location(loc) result = GeocodeGlib.Reverse.resolve(obj) location_information = dict((p.name, result.get_property( p.name)) for p in result.list_properties() if result.get_property(p.name)) self.entry_foundName.set_text( generate_address_string(location_information)) except Exception as e: self.entry_foundName.set_text(_("The place was not identified.") + ' ' + str(e)) else: self.entry_foundName.set_text(_("Coordinates were not given."))
def column_latitude(self, data): if not data[4]: return '' value = conv_lat_lon(data[4], '0', format='DEG')[0] if not value: return _("Error in format") return ("\u202d" + value + "\u202e") if glocale.rtl_locale else value
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 add_event_ref(self, event_ref, spouse=None, name=""): """ Add an event to the model. """ self.callman.register_handles({'event': [event_ref.ref]}) event = self.dbstate.db.get_event_from_handle(event_ref.ref) event_date = get_date(event) event_sort = '%012d' % event.get_date_object().get_sort_value() place_name = place_displayer.display_event(self.dbstate.db, event) place_handle = event.get_place_handle() place_id = latitude = longitude = "" if place_handle: plc = self.dbstate.db.get_place_from_handle(place_handle) if plc: place_id = plc.get_gramps_id() latitude = plc.get_latitude() longitude = plc.get_longitude() latitude, longitude = conv_lat_lon(latitude, longitude, "D.D8") description = event.get_description() if description == "": description = name self.model.add((event.get_handle(), str(event.get_type()), description, event_date, event_sort, place_name, place_id, latitude, longitude ))
def sort_latitude(self, data): if not data[4]: return '' value = conv_lat_lon(data[4], '0', format='ISO-DMS') if data[4] else '' if not value: return _("Error in format") return value
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]) for place in self.dbstate.db.iter_places(): latn = place.get_latitude() lonn = place.get_longitude() if latn and lonn: latn, lonn = conv_lat_lon(latn, lonn, "D.D8") 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 column_latitude(self, data): if not data[4]: return '' value = conv_lat_lon(data[4], '0', format='DEG')[0] if not value: return _("Error in format") return value
def column_longitude(self, data): if not data[3]: return '' value = conv_lat_lon('0', data[3], format='DEG')[1] if not value: return _("Error in format") return value
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]) for place in self.dbstate.db.iter_places(): latn = place.get_latitude() lonn = place.get_longitude() if latn and lonn: latn, lonn = conv_lat_lon(latn, lonn, "D.D8") 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 _place(self, place, dateobj, level): """ PLACE_STRUCTURE:= n PLAC <PLACE_NAME> {1:1} +1 FORM <PLACE_HIERARCHY> {0:1} +1 FONE <PLACE_PHONETIC_VARIATION> {0:M} # not used +2 TYPE <PHONETIC_TYPE> {1:1} +1 ROMN <PLACE_ROMANIZED_VARIATION> {0:M} # not used +2 TYPE <ROMANIZED_TYPE> {1:1} +1 MAP {0:1} +2 LATI <PLACE_LATITUDE> {1:1} +2 LONG <PLACE_LONGITUDE> {1:1} +1 <<NOTE_STRUCTURE>> {0:M} """ if place is None: return place_name = _pd.display(self.dbase, place, dateobj) self._writeln(level, "PLAC", place_name.replace('\r', ' '), limit=120) longitude = place.get_longitude() latitude = place.get_latitude() if longitude and latitude: (latitude, longitude) = conv_lat_lon(latitude, longitude, "GEDCOM") if longitude and latitude: self._writeln(level + 1, "MAP") self._writeln(level + 2, 'LATI', latitude) self._writeln(level + 2, 'LONG', longitude) # The Gedcom standard shows that an optional address structure can # be written out in the event detail. # http://homepages.rootsweb.com/~pmcbride/gedcom/55gcch2.htm#EVENT_DETAIL location = get_main_location(self.dbase, place) street = location.get(PlaceType.STREET) locality = location.get(PlaceType.LOCALITY) city = location.get(PlaceType.CITY) state = location.get(PlaceType.STATE) country = location.get(PlaceType.COUNTRY) postal_code = place.get_code() if street or locality or city or state or postal_code or country: self._writeln(level, "ADDR", street) if street: self._writeln(level + 1, 'ADR1', street) if locality: self._writeln(level + 1, 'ADR2', locality) if city: self._writeln(level + 1, 'CITY', city) if state: self._writeln(level + 1, 'STAE', state) if postal_code: self._writeln(level + 1, 'POST', postal_code) if country: self._writeln(level + 1, 'CTRY', country) if self.placenote: LOG.debug("PLACENOTE") self._note_references(place.get_note_list(), level) else: LOG.debug(" PAS PLACENOTE") self._note_references(place.get_note_list(), level + 1)
def test_RT90_conversion(self): """A given lat/lon is converted to RT90 and back""" x, y = conv_lat_lon('59:40:9.09', '12:58:57.74', 'RT90') lat, lon = conv_SWED_RT90_WGS84(float(x), float(y)) expetced_lat = 59.0 + 40.0/60. + 9.09/3600.0 expetced_lon = 12.0 + 58.0/60.0 + 57.74/3600.0 self.assertAlmostEqual(lat, expetced_lat, places=3) self.assertAlmostEqual(lon, expetced_lon, places=3)
def test_RT90_conversion(self): """A given lat/lon is converted to RT90 and back""" x, y = conv_lat_lon('59:40:9.09', '12:58:57.74', 'RT90') lat, lon = conv_SWED_RT90_WGS84(float(x), float(y)) expetced_lat = 59.0 + 40.0 / 60. + 9.09 / 3600.0 expetced_lon = 12.0 + 58.0 / 60.0 + 57.74 / 3600.0 self.assertAlmostEqual(lat, expetced_lat, places=3) self.assertAlmostEqual(lon, expetced_lon, places=3)
def find_place_lat_lon(self, event): """ # Use the most recent occupation residence. # """ lat = " " lon = " " place_handle = event.get_place_handle() if place_handle: place = self.__db.get_place_from_handle(place_handle) if place: # lat, lon = conv_lat_lon(place.get_latitude(), place.get_longitude(), format="D.D8") lat, lon = conv_lat_lon(place.get_latitude(), place.get_longitude(), format="DEG") return(lat, lon)
def __output_place(self, ldatec, tbody, first_place, pname, place_handle, letter, bucket_link): place = self.r_db.get_place_from_handle(place_handle) if place: if place.get_change_time() > ldatec: ldatec = place.get_change_time() plc_title = pname main_location = get_main_location(self.r_db, place) if not plc_title or plc_title == " ": letter = " " trow = Html("tr") tbody += trow tcell = Html("td", class_="ColumnLetter", inline=True) trow += tcell if first_place: # or primary_difference(letter, prev_letter, self.rlocale): first_place = False # prev_letter = letter trow.attr = 'class = "BeginLetter"' ttle = self._("Places beginning " "with letter %s") % letter tcell += Html("a", letter, name=letter, title=ttle, id_=bucket_link) else: tcell += " " trow += Html("td", self.place_link(place.get_handle(), plc_title, place.get_gramps_id()), class_="ColumnName") trow.extend( Html("td", data or " ", class_=colclass, inline=True) for (colclass, data) in [[ "ColumnState", main_location.get(PlaceType.STATE, '') ], ["ColumnCountry", main_location.get(PlaceType.COUNTRY, '')]]) if self.display_coordinates: tcell1 = Html("td", class_="ColumnLatitude", inline=True) tcell2 = Html("td", class_="ColumnLongitude", inline=True) trow += tcell1, tcell2 if place.lat and place.long: latitude, longitude = conv_lat_lon(place.lat, place.long, "DEG") tcell1 += latitude tcell2 += longitude else: tcell1 += ' ' tcell2 += ' ' return (ldatec, first_place)
def find_place_lat_lon(self, event): """ # Use the most recent occupation residence. # """ lat = " " lon = " " place_handle = event.get_place_handle() if place_handle: place = self.__db.get_place_from_handle(place_handle) if place: # lat, lon = conv_lat_lon(place.get_latitude(), place.get_longitude(), format="D.D8") lat, lon = conv_lat_lon(place.get_latitude(), place.get_longitude(), format="DEG") return (lat, lon)
def places(self): """ For all places in the database, if the name contains leading or trailing spaces. """ for place_handle in self.db.get_place_handles(): self.progress.step() place = self.db.get_place_from_handle(place_handle) place_name = place.get_name() pname = place_name.get_value() found = False self.tooltip = "" if pname != pname.strip(): self.add_text_to_tip(0, _("leading and/or trailing spaces")) found = True plat = place.get_latitude() plon = place.get_longitude() lat, lon = conv_lat_lon(plat, plon, "D.D8") self.f_lat = self.f_lon = False if not lat: self.add_text_to_tip(1, _("invalid format")) found = True if plat != plat.strip(): self.add_text_to_tip(1, _("leading and/or trailing spaces")) found = True if plat.find(',') != -1: self.add_text_to_tip(1, _("comma instead of dot")) found = True if validate_lat_lon(plat): self.add_text_to_tip(1, _("invalid char instead of '-'")) found = True if not lon: self.add_text_to_tip(2, _("invalid format")) found = True if plon != plon.strip(): self.add_text_to_tip(2, _("leading and/or trailing spaces")) found = True if plon.find(',') != -1: self.add_text_to_tip(2, _("comma instead of dot")) found = True if validate_lat_lon(plat): self.add_text_to_tip(1, _("invalid char instead of '-'")) found = True if found: value = (place_handle, pname, plat, plon, self.tooltip) self.model_2.append(value) return True
def display_place(self, place): """ Display details of the active place. """ self.load_place_image(place) self.title.set_text(place.get_title()) self.clear_table() self.display_location(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 get_place_profile_for_object( db_handle: DbReadBase, place: Place, locale: GrampsLocale = glocale, parent_places: bool = True, ) -> Dict[str, Any]: """Get place profile given a Place.""" latitude, longitude = conv_lat_lon(place.lat, place.long, format="D.D8") profile = { "gramps_id": place.gramps_id, "type": _format_place_type(place.get_type(), locale=locale), "name": place.get_name().value, "alternate_names": [place_name.value for place_name in place.get_alternative_names()], "lat": float(latitude) if (latitude and longitude) else None, "long": float(longitude) if (latitude and longitude) else None, } if parent_places: parent_places_handles = [] _place = place handle = None while True: for placeref in _place.get_placeref_list(): handle = placeref.ref break if handle is None or handle in parent_places_handles: break _place = db_handle.get_place_from_handle(handle) if _place is None: break parent_places_handles.append(handle) profile["parent_places"] = [ get_place_profile_for_object( db_handle=db_handle, place=db_handle.get_place_from_handle(parent_place), locale=locale, parent_places=False, ) for parent_place in parent_places_handles ] return profile
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()) 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 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 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_markup("<span size='large' weight='bold'>%s</span>" % markup_escape_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 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_table() #parser = FormatStringParser(self._place_keys) place_dict = self.generate_place_dictionary(place) parser = FormatStringParser(place_dict) addr1 = parser.parse(place_dict, self._address_format[0]) addr2 = parser.parse(place_dict, self._address_format[1]) city = parser.parse(place_dict, self._address_format[2]) state = parser.parse(place_dict, self._address_format[3]) country = parser.parse(place_dict, self._address_format[4]) code = parser.parse(place_dict, self._address_format[5]) self.add_row(_("Address 1"), addr1) self.add_row(_("Address 2"), addr2) self.add_row(_("City"), city) self.add_row(_("State"), state) self.add_row(_("Country"), country) self.add_row(_("Postal Code"), code) self.add_row(_("Version"), "0.1") #self.add_row(_('Name'), place.get_name()) #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')
def placelistpage(self, report, title, place_handles): """ Create a place index @param: report -- The instance of the main report class for this report @param: title -- Is the title of the web page @param: place_handles -- The handle for the place to add """ BasePage.__init__(self, report, title) output_file, sio = self.report.create_file("places") placelistpage, head, body = self.write_header(self._("Places")) ldatec = 0 prev_letter = " " # begin places division with Html("div", class_="content", id="Places") as placelist: body += placelist # place list page message msg = self._("This page contains an index of all the places in the " "database, sorted by their title. " "Clicking on a place’s " "title will take you to that place’s page.") placelist += Html("p", msg, id="description") # begin alphabet navigation index_list = get_first_letters(self.r_db, place_handles, _KEYPLACE, rlocale=self.rlocale) alpha_nav = alphabet_navigation(index_list, self.rlocale) if alpha_nav is not None: placelist += alpha_nav # begin places table and table head with Html("table", class_="infolist primobjlist placelist") as table: placelist += table # begin table head thead = Html("thead") table += thead trow = Html("tr") thead += trow if self.display_coordinates: trow.extend( Html("th", label, class_=colclass, inline=True) for (label, colclass) in [ [self._("Letter"), "ColumnLetter"], [self._("Place Name | Name"), "ColumnName"], [self._("State/ Province"), "ColumnState"], [self._("Country"), "ColumnCountry"], [self._("Latitude"), "ColumnLatitude"], [self._("Longitude"), "ColumnLongitude"] ] ) else: trow.extend( Html("th", label, class_=colclass, inline=True) for (label, colclass) in [ [self._("Letter"), "ColumnLetter"], [self._("Place Name | Name"), "ColumnName"], [self._("State/ Province"), "ColumnState"], [self._("Country"), "ColumnCountry"] ] ) # bug 9495 : incomplete display of place hierarchy labels def sort_by_place_name(obj): """ sort by lower case place name. """ name = self.report.obj_dict[Place][obj][1] return name.lower() handle_list = sorted(place_handles, key=lambda x: sort_by_place_name(x)) first = True # begin table body tbody = Html("tbody") table += tbody for place_handle in handle_list: place = self.r_db.get_place_from_handle(place_handle) if place: if place.get_change_time() > ldatec: ldatec = place.get_change_time() plc_title = self.report.obj_dict[Place][place_handle][1] main_location = get_main_location(self.r_db, place) if plc_title and plc_title != " ": letter = get_index_letter(first_letter(plc_title), index_list, self.rlocale) else: letter = ' ' trow = Html("tr") tbody += trow tcell = Html("td", class_="ColumnLetter", inline=True) trow += tcell if first or primary_difference(letter, prev_letter, self.rlocale): first = False prev_letter = letter trow.attr = 'class = "BeginLetter"' ttle = self._("Places beginning " "with letter %s") % letter tcell += Html("a", letter, name=letter, title=ttle) else: tcell += " " trow += Html("td", self.place_link( place.get_handle(), plc_title, place.get_gramps_id()), class_="ColumnName") trow.extend( Html("td", data or " ", class_=colclass, inline=True) for (colclass, data) in [ ["ColumnState", main_location.get(PlaceType.STATE, '')], ["ColumnCountry", main_location.get(PlaceType.COUNTRY, '')] ] ) if self.display_coordinates: tcell1 = Html("td", class_="ColumnLatitude", inline=True) tcell2 = Html("td", class_="ColumnLongitude", inline=True) trow += (tcell1, tcell2) if place.lat and place.long: latitude, longitude = conv_lat_lon(place.lat, place.long, "DEG") tcell1 += latitude tcell2 += longitude else: tcell1 += ' ' tcell2 += ' ' # add clearline for proper styling # add footer section footer = self.write_footer(ldatec) body += (FULLCLEAR, footer) # send page out for processing # and close the file self.xhtml_writer(placelistpage, output_file, sio, ldatec)
def placepage(self, report, title, place_handle): """ Create a place page @param: report -- The instance of the main report class for this report @param: title -- Is the title of the web page @param: place_handle -- The handle for the place to add """ place = report.database.get_place_from_handle(place_handle) if not place: return None BasePage.__init__(self, report, title, place.get_gramps_id()) self.bibli = Bibliography() place_name = self.report.obj_dict[Place][place_handle][1] ldatec = place.get_change_time() output_file, sio = self.report.create_file(place_handle, "plc") self.uplink = True self.page_title = place_name placepage, head, body = self.write_header(_("Places")) self.placemappages = self.report.options['placemappages'] self.mapservice = self.report.options['mapservice'] self.googlemapkey = self.report.options['googlemapkey'] # begin PlaceDetail Division with Html("div", class_="content", id="PlaceDetail") as placedetail: body += placedetail if self.create_media: media_list = place.get_media_list() thumbnail = self.disp_first_img_as_thumbnail(media_list, place) if thumbnail is not None: placedetail += thumbnail # add section title placedetail += Html("h3", html_escape(place_name), inline=True) # begin summaryarea division and places table with Html("div", id='summaryarea') as summaryarea: placedetail += summaryarea with Html("table", class_="infolist place") as table: summaryarea += table # list the place fields self.dump_place(place, table) # place gallery if self.create_media: placegallery = self.disp_add_img_as_gallery(media_list, place) if placegallery is not None: placedetail += placegallery # place notes notelist = self.display_note_list(place.get_note_list()) if notelist is not None: placedetail += notelist # place urls urllinks = self.display_url_list(place.get_url_list()) if urllinks is not None: placedetail += urllinks # add place map here # Link to Gramps marker fname = "/".join(['images', 'marker.png']) marker_path = self.report.build_url_image("marker.png", "images", self.uplink) if self.placemappages: if place and (place.lat and place.long): latitude, longitude = conv_lat_lon(place.get_latitude(), place.get_longitude(), "D.D8") placetitle = place_name # add narrative-maps CSS... fname = "/".join(["css", "narrative-maps.css"]) url = self.report.build_url_fname(fname, None, self.uplink) head += Html("link", href=url, type="text/css", media="screen", rel="stylesheet") # add MapService specific javascript code src_js = GOOGLE_MAPS + "api/js?sensor=false" if self.mapservice == "Google": if self.googlemapkey: src_js += "&key=" + self.googlemapkey head += Html("script", type="text/javascript", src=src_js, inline=True) else: url = self.secure_mode url += ("maxcdn.bootstrapcdn.com/bootstrap/3.3.7/" "css/bootstrap.min.css") head += Html("link", href=url, type="text/javascript", rel="stylesheet") src_js = self.secure_mode src_js += ("ajax.googleapis.com/ajax/libs/jquery/1.9.1/" "jquery.min.js") head += Html("script", type="text/javascript", src=src_js, inline=True) src_js = self.secure_mode src_js += "openlayers.org/en/v3.17.1/build/ol.js" head += Html("script", type="text/javascript", src=src_js, inline=True) url = self.secure_mode url += "openlayers.org/en/v3.17.1/css/ol.css" head += Html("link", href=url, type="text/javascript", rel="stylesheet") src_js = self.secure_mode src_js += ("maxcdn.bootstrapcdn.com/bootstrap/3.3.7/" "js/bootstrap.min.js") head += Html("script", type="text/javascript", src=src_js, inline=True) # section title placedetail += Html("h4", self._("Place Map"), inline=True) # begin map_canvas division with Html("div", id="map_canvas", inline=True) as canvas: placedetail += canvas # Begin inline javascript code because jsc is a # docstring, it does NOT have to be properly indented if self.mapservice == "Google": with Html("script", type="text/javascript", indent=False) as jsc: head += jsc # Google adds Latitude/ Longitude to its maps... plce = placetitle.replace("'", "\\'") jsc += MARKER_PATH % marker_path jsc += MARKERS % ([[plce, latitude, longitude, 1]], latitude, longitude, 10) else: # OpenStreetMap (OSM) adds Longitude/ Latitude # to its maps, and needs a country code in # lowercase letters... with Html("script", type="text/javascript") as jsc: canvas += jsc #param1 = xml_lang()[3:5].lower() jsc += MARKER_PATH % marker_path jsc += OSM_MARKERS % ([[float(longitude), float(latitude), placetitle]], longitude, latitude, 10) # add javascript function call to body element body.attr += ' onload = "initialize();" ' # add div for popups. with Html("div", id="popup", inline=True) as popup: placedetail += popup # source references srcrefs = self.display_ind_sources(place) if srcrefs is not None: placedetail += srcrefs # References list ref_list = self.display_bkref_list(Place, place_handle) if ref_list is not None: placedetail += ref_list # add clearline for proper styling # add footer section footer = self.write_footer(ldatec) body += (FULLCLEAR, footer) # send page out for processing # and close the file self.xhtml_writer(placepage, output_file, sio, ldatec)
def _test_formats_fail(self, lat, lon): res1, res2 = conv_lat_lon(lat, lon) self.assertIsNone(res1, 'Expected failure for %s %s' % (lat, lon)) self.assertIsNone(res2, 'Expected failure for %s %s' % (lat, lon))
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 _createmap(self, place_x): """ Create all markers for each people's event in the database which has a lat/lon. """ dbstate = self.dbstate self.place_list = [] self.places_found = [] self.place_without_coordinates = [] self.minlat = 0.0 self.maxlat = 0.0 self.minlon = 0.0 self.maxlon = 0.0 self.minyear = 9999 self.maxyear = 0 self.without = 0 latitude = "" longitude = "" self.nbmarkers = 0 self.nbplaces = 0 self.message_layer.clear_messages() self.message_layer.clear_font_attributes() self.no_show_places_in_status_bar = False # base "villes de france" : 38101 places : # createmap : 8'50"; create_markers : 1'23" # base "villes de france" : 38101 places : # createmap : 8'50"; create_markers : 0'07" with pixbuf optimization # base "villes de france" : 38101 places : # gramps 3.4 python 2.7 (draw_markers are estimated when moving the map) # 38101 places: createmap: 04'32"; # create_markers: 0'04"; draw markers: N/A :: 0'03" # 65598 places: createmap: 10'03"; # create_markers: 0'07"; draw markers: N/A :: 0'05" # gramps 3.5 python 2.7 new marker layer # 38101 places: createmap: 03'09"; # create_markers: 0'01"; draw markers: 0'04" # 65598 places: createmap: 08'48"; # create_markers: 0'01"; draw markers: 0'07" _LOG.debug("%s", time.strftime("start createmap : " "%a %d %b %Y %H:%M:%S", time.gmtime())) if self.show_all: self.show_all = False try: places_handle = dbstate.db.get_place_handles() except: return progress = ProgressMeter(self.window_name, can_cancel=False, parent=self.uistate.window) length = len(places_handle) progress.set_pass(_('Selecting all places'), length) for place_hdl in places_handle: place = dbstate.db.get_place_from_handle(place_hdl) self._create_one_place(place) progress.step() progress.close() elif self.generic_filter: place_list = self.generic_filter.apply(dbstate.db) progress = ProgressMeter(self.window_name, can_cancel=False, parent=self.uistate.window) length = len(place_list) progress.set_pass(_('Selecting all places'), length) for place_handle in place_list: place = dbstate.db.get_place_from_handle(place_handle) self._create_one_place(place) progress.step() progress.close() elif place_x != None: place = dbstate.db.get_place_from_handle(place_x) self._create_one_place(place) self.message_layer.add_message( _("Right click on the map and select 'show all places'" " to show all known places with coordinates. " "You can use filtering.")) if place.get_latitude() != "" and place.get_longitude() != "": latitude, longitude = conv_lat_lon(place.get_latitude(), place.get_longitude(), "D.D8") self.osm.set_center_and_zoom(float(latitude), float(longitude), int(config.get( "geography.zoom_when_center"))) else: self.message_layer.add_message( _("Right click on the map and select 'show all places'" " to show all known places with coordinates. " " You can use the history to navigate on the map. " "You can use filtering.")) _LOG.debug(" stop createmap.") _LOG.debug("%s", time.strftime("begin sort : " "%a %d %b %Y %H:%M:%S", time.gmtime())) self.sort = sorted(self.place_list, key=operator.itemgetter(0) ) _LOG.debug("%s", time.strftime(" end sort : " "%a %d %b %Y %H:%M:%S", time.gmtime())) if self.nbmarkers > 500: # performance issue. Is it the good value ? self.message_layer.add_message( _("The place name in the status bar is disabled.")) self.no_show_places_in_status_bar = True if self.nbplaces >= self._config.get("geography.max_places"): self.message_layer.set_font_attributes(None, None, "red") self.message_layer.add_message( _("The maximum number of places is reached (%d).") % self._config.get("geography.max_places")) self.message_layer.add_message( _("Some information are missing.")) self.message_layer.add_message( _("Please, use filtering to reduce this number.")) self.message_layer.add_message( _("You can modify this value in the geography option.")) self.message_layer.add_message( _("In this case, it may take time to show all markers.")) self._create_markers()
def placepage(self, report, title, place_handle): """ Create a place page @param: report -- The instance of the main report class for this report @param: title -- Is the title of the web page @param: place_handle -- The handle for the place to add """ place = report.database.get_place_from_handle(place_handle) if not place: return BasePage.__init__(self, report, title, place.get_gramps_id()) self.bibli = Bibliography() place_name = self.report.obj_dict[Place][place_handle][1] ldatec = place.get_change_time() output_file, sio = self.report.create_file(place_handle, "plc") self.uplink = True self.page_title = place_name placepage, head, body, outerwrapper = self.write_header(_("Places")) self.placemappages = self.report.options['placemappages'] self.mapservice = self.report.options['mapservice'] self.googlemapkey = self.report.options['googlemapkey'] # begin PlaceDetail Division with Html("div", class_="content", id="PlaceDetail") as placedetail: outerwrapper += placedetail if self.create_media: media_list = place.get_media_list() thumbnail = self.disp_first_img_as_thumbnail(media_list, place) if thumbnail is not None: placedetail += thumbnail # add section title placedetail += Html("h3", html_escape(place_name), inline=True) # begin summaryarea division and places table with Html("div", id='summaryarea') as summaryarea: placedetail += summaryarea with Html("table", class_="infolist place") as table: summaryarea += table # list the place fields self.dump_place(place, table) # place gallery if self.create_media: placegallery = self.disp_add_img_as_gallery(media_list, place) if placegallery is not None: placedetail += placegallery # place notes notelist = self.display_note_list(place.get_note_list()) if notelist is not None: placedetail += notelist # place urls urllinks = self.display_url_list(place.get_url_list()) if urllinks is not None: placedetail += urllinks # add place map here # Link to Gramps marker fname = "/".join(['images', 'marker.png']) marker_path = self.report.build_url_image("marker.png", "images", self.uplink) if self.placemappages: if place and (place.lat and place.long): latitude, longitude = conv_lat_lon(place.get_latitude(), place.get_longitude(), "D.D8") placetitle = place_name # add narrative-maps CSS... fname = "/".join(["css", "narrative-maps.css"]) url = self.report.build_url_fname(fname, None, self.uplink) head += Html("link", href=url, type="text/css", media="screen", rel="stylesheet") # add MapService specific javascript code src_js = GOOGLE_MAPS + "api/js?sensor=false" if self.mapservice == "Google": if self.googlemapkey: src_js += "&key=" + self.googlemapkey head += Html("script", type="text/javascript", src=src_js, inline=True) else: url = self.secure_mode url += ("maxcdn.bootstrapcdn.com/bootstrap/3.3.7/" "css/bootstrap.min.css") head += Html("link", href=url, type="text/javascript", rel="stylesheet") src_js = self.secure_mode src_js += ( "ajax.googleapis.com/ajax/libs/jquery/1.9.1/" "jquery.min.js") head += Html("script", type="text/javascript", src=src_js, inline=True) src_js = self.secure_mode src_js += "openlayers.org/en/latest/build/ol.js" head += Html("script", type="text/javascript", src=src_js, inline=True) url = self.secure_mode url += "openlayers.org/en/latest/css/ol.css" head += Html("link", href=url, type="text/javascript", rel="stylesheet") src_js = self.secure_mode src_js += ("maxcdn.bootstrapcdn.com/bootstrap/3.3.7/" "js/bootstrap.min.js") head += Html("script", type="text/javascript", src=src_js, inline=True) # section title placedetail += Html("h4", self._("Place Map"), inline=True) # begin map_canvas division with Html("div", id="map_canvas", inline=True) as canvas: placedetail += canvas # Begin inline javascript code because jsc is a # docstring, it does NOT have to be properly indented if self.mapservice == "Google": with Html("script", type="text/javascript", indent=False) as jsc: head += jsc # Google adds Latitude/ Longitude to its maps... plce = placetitle.replace("'", "\\'") jsc += MARKER_PATH % marker_path jsc += MARKERS % ([[ plce, latitude, longitude, 1 ]], latitude, longitude, 10) else: # OpenStreetMap (OSM) adds Longitude/ Latitude # to its maps, and needs a country code in # lowercase letters... with Html("script", type="text/javascript") as jsc: canvas += jsc #param1 = xml_lang()[3:5].lower() jsc += MARKER_PATH % marker_path jsc += OSM_MARKERS % ([[ float(longitude), float(latitude), placetitle ]], longitude, latitude, 10) # add javascript function call to body element body.attr += ' onload = "initialize();" ' # add div for popups. with Html("div", id="popup", inline=True) as popup: placedetail += popup # source references srcrefs = self.display_ind_sources(place) if srcrefs is not None: placedetail += srcrefs # References list ref_list = self.display_bkref_list(Place, place_handle) if ref_list is not None: placedetail += ref_list # add clearline for proper styling # add footer section footer = self.write_footer(ldatec) outerwrapper += (FULLCLEAR, footer) # send page out for processing # and close the file self.xhtml_writer(placepage, output_file, sio, ldatec)
def placelistpage(self, report, title, place_handles): """ Create a place index @param: report -- The instance of the main report class for this report @param: title -- Is the title of the web page @param: place_handles -- The handle for the place to add """ BasePage.__init__(self, report, title) output_file, sio = self.report.create_file("places") result = self.write_header(self._("Places")) placelistpage, dummy_head, dummy_body, outerwrapper = result ldatec = 0 prev_letter = " " # begin places division with Html("div", class_="content", id="Places") as placelist: outerwrapper += placelist # place list page message msg = self._( "This page contains an index of all the places in the " "database, sorted by their title. " "Clicking on a place’s " "title will take you to that place’s page.") placelist += Html("p", msg, id="description") # begin alphabet navigation index_list = get_first_letters(self.r_db, place_handles, _KEYPLACE, rlocale=self.rlocale) alpha_nav = alphabet_navigation(index_list, self.rlocale) if alpha_nav is not None: placelist += alpha_nav # begin places table and table head with Html("table", class_="infolist primobjlist placelist") as table: placelist += table # begin table head thead = Html("thead") table += thead trow = Html("tr") thead += trow if self.display_coordinates: trow.extend( Html("th", label, class_=colclass, inline=True) for (label, colclass ) in [[self._("Letter"), "ColumnLetter"], [self._("Place Name | Name"), "ColumnName"], [self._("State/ Province"), "ColumnState"], [self._("Country"), "ColumnCountry"], [self._("Latitude"), "ColumnLatitude"], [self._("Longitude"), "ColumnLongitude"]]) else: trow.extend( Html("th", label, class_=colclass, inline=True) for (label, colclass ) in [[self._("Letter"), "ColumnLetter"], [self._("Place Name | Name"), "ColumnName"], [self._("State/ Province"), "ColumnState"], [self._("Country"), "ColumnCountry"]]) # bug 9495 : incomplete display of place hierarchy labels def sort_by_place_name(obj): """ sort by lower case place name. """ name = self.report.obj_dict[Place][obj][1] return name.lower() handle_list = sorted(place_handles, key=lambda x: sort_by_place_name(x)) first = True # begin table body tbody = Html("tbody") table += tbody for place_handle in handle_list: place = self.r_db.get_place_from_handle(place_handle) if place: if place.get_change_time() > ldatec: ldatec = place.get_change_time() plc_title = self.report.obj_dict[Place][place_handle][ 1] main_location = get_main_location(self.r_db, place) if plc_title and plc_title != " ": letter = get_index_letter(first_letter(plc_title), index_list, self.rlocale) else: letter = ' ' trow = Html("tr") tbody += trow tcell = Html("td", class_="ColumnLetter", inline=True) trow += tcell if first or primary_difference(letter, prev_letter, self.rlocale): first = False prev_letter = letter trow.attr = 'class = "BeginLetter"' ttle = self._("Places beginning " "with letter %s") % letter tcell += Html("a", letter, name=letter, title=ttle) else: tcell += " " trow += Html("td", self.place_link(place.get_handle(), plc_title, place.get_gramps_id()), class_="ColumnName") trow.extend( Html("td", data or " ", class_=colclass, inline=True) for (colclass, data) in [[ "ColumnState", main_location.get(PlaceType.STATE, '') ], [ "ColumnCountry", main_location.get(PlaceType.COUNTRY, '') ]]) if self.display_coordinates: tcell1 = Html("td", class_="ColumnLatitude", inline=True) tcell2 = Html("td", class_="ColumnLongitude", inline=True) trow += (tcell1, tcell2) if place.lat and place.long: latitude, longitude = conv_lat_lon( place.lat, place.long, "DEG") tcell1 += latitude tcell2 += longitude else: tcell1 += ' ' tcell2 += ' ' # add clearline for proper styling # add footer section footer = self.write_footer(ldatec) outerwrapper += (FULLCLEAR, footer) # send page out for processing # and close the file self.xhtml_writer(placelistpage, output_file, sio, ldatec)
def _createmap_for_one_person(self, person, color, place_list, reference): """ Create all markers for each people's event in the database which has a lat/lon. """ self.place_list = [] dbstate = self.dbstate 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 _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 _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 _lat_lon(self, place, format="D.D8"): """return the lat, lon value of place in the requested format None, None if invalid """ return conv_lat_lon(place.get_latitude(), place.get_longitude(), format)
def _createmap(self, place_x): """ Create all markers for each people's event in the database which has a lat/lon. """ dbstate = self.dbstate self.place_list = [] self.places_found = [] self.place_without_coordinates = [] self.minlat = 0.0 self.maxlat = 0.0 self.minlon = 0.0 self.maxlon = 0.0 self.minyear = 9999 self.maxyear = 0 self.without = 0 latitude = "" longitude = "" self.nbmarkers = 0 self.nbplaces = 0 self.remove_all_markers() self.message_layer.clear_messages() self.message_layer.clear_font_attributes() self.kml_layer.clear() self.no_show_places_in_status_bar = False _col = self._config.get self.plc_color = [ (PlaceType.UNKNOWN, _col('geography.color.unknown')), (PlaceType.CUSTOM, _col('geography.color.custom')), (PlaceType.COUNTRY, _col('geography.color.country')), (PlaceType.STATE, _col('geography.color.state')), (PlaceType.COUNTY, _col('geography.color.county')), (PlaceType.CITY, _col('geography.color.city')), (PlaceType.PARISH, _col('geography.color.parish')), (PlaceType.LOCALITY, _col('geography.color.locality')), (PlaceType.STREET, _col('geography.color.street')), (PlaceType.PROVINCE, _col('geography.color.province')), (PlaceType.REGION, _col('geography.color.region')), (PlaceType.DEPARTMENT, _col('geography.color.department')), (PlaceType.NEIGHBORHOOD, _col('geography.color.neighborhood')), (PlaceType.DISTRICT, _col('geography.color.district')), (PlaceType.BOROUGH, _col('geography.color.borough')), (PlaceType.MUNICIPALITY, _col('geography.color.municipality')), (PlaceType.TOWN, _col('geography.color.town')), (PlaceType.VILLAGE, _col('geography.color.village')), (PlaceType.HAMLET, _col('geography.color.hamlet')), (PlaceType.FARM, _col('geography.color.farm')), (PlaceType.BUILDING, _col('geography.color.building')), (PlaceType.NUMBER, _col('geography.color.number')) ] # base "villes de france" : 38101 places : # createmap : 8'50"; create_markers : 1'23" # base "villes de france" : 38101 places : # createmap : 8'50"; create_markers : 0'07" with pixbuf optimization # base "villes de france" : 38101 places : # gramps 3.4 python 2.7 (draw_markers are estimated when moving the map) # 38101 places: createmap: 04'32"; # create_markers: 0'04"; draw markers: N/A :: 0'03" # 65598 places: createmap: 10'03"; # create_markers: 0'07"; draw markers: N/A :: 0'05" # gramps 3.5 python 2.7 new marker layer # 38101 places: createmap: 03'09"; # create_markers: 0'01"; draw markers: 0'04" # 65598 places: createmap: 08'48"; # create_markers: 0'01"; draw markers: 0'07" _LOG.debug( "%s", time.strftime("start createmap : " "%a %d %b %Y %H:%M:%S", time.gmtime())) self.custom_places() if self.show_all: self.show_all = False try: places_handle = dbstate.db.get_place_handles() except: return progress = ProgressMeter(self.window_name, can_cancel=False, parent=self.uistate.window) length = len(places_handle) progress.set_pass(_('Selecting all places'), length) for place_hdl in places_handle: place = dbstate.db.get_place_from_handle(place_hdl) self._create_one_place(place) progress.step() progress.close() elif self.generic_filter: user = self.uistate.viewmanager.user place_list = self.generic_filter.apply(dbstate.db, user=user) progress = ProgressMeter(self.window_name, can_cancel=False, parent=self.uistate.window) length = len(place_list) progress.set_pass(_('Selecting all places'), length) for place_handle in place_list: place = dbstate.db.get_place_from_handle(place_handle) self._create_one_place(place) progress.step() progress.close() # reset completely the filter. It will be recreated next time. self.generic_filter = None elif place_x != None: place = dbstate.db.get_place_from_handle(place_x) self._create_one_place(place) self.message_layer.add_message( _("Right click on the map and select 'show all places'" " to show all known places with coordinates. " "You can change the markers color depending on place type. " "You can use filtering.")) if place.get_latitude() != "" and place.get_longitude() != "": latitude, longitude = conv_lat_lon(place.get_latitude(), place.get_longitude(), "D.D8") if latitude and longitude: self.osm.set_center_and_zoom( float(latitude), float(longitude), int(config.get("geography.zoom_when_center"))) else: self.message_layer.add_message( _("Right click on the map and select 'show all places'" " to show all known places with coordinates. " "You can use the history to navigate on the map. " "You can change the markers color depending on place type. " "You can use filtering.")) _LOG.debug(" stop createmap.") _LOG.debug( "%s", time.strftime("begin sort : " "%a %d %b %Y %H:%M:%S", time.gmtime())) self.sort = sorted(self.place_list, key=operator.itemgetter(0)) _LOG.debug( "%s", time.strftime(" end sort : " "%a %d %b %Y %H:%M:%S", time.gmtime())) if self.nbmarkers > 500: # performance issue. Is it the good value ? self.message_layer.add_message( _("The place name in the status bar is disabled.")) self.no_show_places_in_status_bar = True if self.nbplaces >= self._config.get("geography.max_places"): self.message_layer.set_font_attributes(None, None, "red") self.message_layer.add_message( _("The maximum number of places is reached (%d).") % self._config.get("geography.max_places")) self.message_layer.add_message(_("Some information are missing.")) self.message_layer.add_message( _("Please, use filtering to reduce this number.")) self.message_layer.add_message( _("You can modify this value in the geography option.")) self.message_layer.add_message( _("In this case, it may take time to show all markers.")) self._create_markers()
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 _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.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, place_x): """ Create all markers for each people's event in the database which has a lat/lon. """ dbstate = self.dbstate self.place_list = [] self.places_found = [] self.place_without_coordinates = [] self.minlat = 0.0 self.maxlat = 0.0 self.minlon = 0.0 self.maxlon = 0.0 self.minyear = 9999 self.maxyear = 0 self.without = 0 latitude = "" longitude = "" self.nbmarkers = 0 self.nbplaces = 0 self.remove_all_markers() self.message_layer.clear_messages() self.message_layer.clear_font_attributes() self.kml_layer.clear() self.no_show_places_in_status_bar = False _col = self._config.get self.plc_color = [ (PlaceType.UNKNOWN, _col('geography.color.unknown')), (PlaceType.CUSTOM, _col('geography.color.custom')), (PlaceType.COUNTRY, _col('geography.color.country')), (PlaceType.STATE, _col('geography.color.state')), (PlaceType.COUNTY, _col('geography.color.county')), (PlaceType.CITY, _col('geography.color.city')), (PlaceType.PARISH, _col('geography.color.parish')), (PlaceType.LOCALITY, _col('geography.color.locality')), (PlaceType.STREET, _col('geography.color.street')), (PlaceType.PROVINCE, _col('geography.color.province')), (PlaceType.REGION, _col('geography.color.region')), (PlaceType.DEPARTMENT, _col('geography.color.department')), (PlaceType.NEIGHBORHOOD, _col('geography.color.neighborhood')), (PlaceType.DISTRICT, _col('geography.color.district')), (PlaceType.BOROUGH, _col('geography.color.borough')), (PlaceType.MUNICIPALITY, _col('geography.color.municipality')), (PlaceType.TOWN, _col('geography.color.town')), (PlaceType.VILLAGE, _col('geography.color.village')), (PlaceType.HAMLET, _col('geography.color.hamlet')), (PlaceType.FARM, _col('geography.color.farm')), (PlaceType.BUILDING, _col('geography.color.building')), (PlaceType.NUMBER, _col('geography.color.number')) ] # base "villes de france" : 38101 places : # createmap : 8'50"; create_markers : 1'23" # base "villes de france" : 38101 places : # createmap : 8'50"; create_markers : 0'07" with pixbuf optimization # base "villes de france" : 38101 places : # gramps 3.4 python 2.7 (draw_markers are estimated when moving the map) # 38101 places: createmap: 04'32"; # create_markers: 0'04"; draw markers: N/A :: 0'03" # 65598 places: createmap: 10'03"; # create_markers: 0'07"; draw markers: N/A :: 0'05" # gramps 3.5 python 2.7 new marker layer # 38101 places: createmap: 03'09"; # create_markers: 0'01"; draw markers: 0'04" # 65598 places: createmap: 08'48"; # create_markers: 0'01"; draw markers: 0'07" _LOG.debug("%s", time.strftime("start createmap : " "%a %d %b %Y %H:%M:%S", time.gmtime())) if self.show_all: self.show_all = False try: places_handle = dbstate.db.get_place_handles() except: return progress = ProgressMeter(self.window_name, can_cancel=False, parent=self.uistate.window) length = len(places_handle) progress.set_pass(_('Selecting all places'), length) for place_hdl in places_handle: place = dbstate.db.get_place_from_handle(place_hdl) self._create_one_place(place) progress.step() progress.close() elif self.generic_filter: user=self.uistate.viewmanager.user place_list = self.generic_filter.apply(dbstate.db, user=user) progress = ProgressMeter(self.window_name, can_cancel=False, parent=self.uistate.window) length = len(place_list) progress.set_pass(_('Selecting all places'), length) for place_handle in place_list: place = dbstate.db.get_place_from_handle(place_handle) self._create_one_place(place) progress.step() progress.close() # reset completely the filter. It will be recreated next time. self.generic_filter = None elif place_x != None: place = dbstate.db.get_place_from_handle(place_x) self._create_one_place(place) self.message_layer.add_message( _("Right click on the map and select 'show all places'" " to show all known places with coordinates. " "You can change the markers color depending on place type. " "You can use filtering.")) if place.get_latitude() != "" and place.get_longitude() != "": latitude, longitude = conv_lat_lon(place.get_latitude(), place.get_longitude(), "D.D8") self.osm.set_center_and_zoom(float(latitude), float(longitude), int(config.get( "geography.zoom_when_center"))) else: self.message_layer.add_message( _("Right click on the map and select 'show all places'" " to show all known places with coordinates. " "You can use the history to navigate on the map. " "You can change the markers color depending on place type. " "You can use filtering.")) _LOG.debug(" stop createmap.") _LOG.debug("%s", time.strftime("begin sort : " "%a %d %b %Y %H:%M:%S", time.gmtime())) self.sort = sorted(self.place_list, key=operator.itemgetter(0) ) _LOG.debug("%s", time.strftime(" end sort : " "%a %d %b %Y %H:%M:%S", time.gmtime())) if self.nbmarkers > 500: # performance issue. Is it the good value ? self.message_layer.add_message( _("The place name in the status bar is disabled.")) self.no_show_places_in_status_bar = True if self.nbplaces >= self._config.get("geography.max_places"): self.message_layer.set_font_attributes(None, None, "red") self.message_layer.add_message( _("The maximum number of places is reached (%d).") % self._config.get("geography.max_places")) self.message_layer.add_message( _("Some information are missing.")) self.message_layer.add_message( _("Please, use filtering to reduce this number.")) self.message_layer.add_message( _("You can modify this value in the geography option.")) self.message_layer.add_message( _("In this case, it may take time to show all markers.")) self._create_markers()