diff --git a/PRIVACY_POLICY.md b/PRIVACY_POLICY.md index 1f9d0ffe..acd3fae7 100644 --- a/PRIVACY_POLICY.md +++ b/PRIVACY_POLICY.md @@ -117,10 +117,12 @@ OpenSAK does not log, cache on any server, or share any data returned from the G ### 5.1 Map tiles -The in-application map uses OpenStreetMap tiles to display the map background. When you view the map, your device fetches map tile images from OpenStreetMap servers. This is a standard web request and may include your IP address, as with any web browsing. OpenStreetMap's privacy policy is available at: +The in-application map uses OpenStreetMap tiles to display the map background by default. When you view the map, your device fetches map tile images from OpenStreetMap servers. This is a standard web request and may include your IP address, as with any web browsing. OpenStreetMap's privacy policy is available at: https://wiki.osmfoundation.org/wiki/Privacy_Policy -Map tiles you have viewed are kept in a cache on your own computer (in the OpenSAK data folder, up to the size set in **Settings → Map → Map tile cache**), so areas you viewed recently still show without an internet connection. Only tiles you actually viewed are stored; OpenSAK never downloads map areas in advance. The cache stays on your computer and is not sent anywhere. +Under **Settings → Map → Base maps** you can switch on other base maps. Tiles of a map you switch on and view are fetched in the same way from that map's provider: OpenTopoMap, OpenStreetMap France (CyclOSM, OSM Humanitarian), national mapping agencies (swisstopo, basemap.at, IGN France, PDOK, basemap.de, USGS), or, only if you enter your own API key for them, Esri, MapTiler or Thunderforest. Requests to a provider that needs a key include your key. Each provider's own privacy policy applies. API keys you enter are stored only in the OpenSAK settings file on your computer. + +Map tiles you have viewed are kept in a cache on your own computer (in the OpenSAK data folder, up to the size set in **Settings → Map → Map tile cache**), so areas you viewed recently still show without an internet connection. Only tiles you actually viewed are stored, and only for as long as each provider allows; tiles of providers that do not allow storing them (Esri) are never written to disk. OpenSAK never downloads map areas in advance. The cache stays on your computer and is not sent anywhere. You can optionally configure OpenSAK to open cache locations in Google Maps or OpenStreetMap in your browser. This is triggered only by your explicit action and is subject to those services' own privacy policies. diff --git a/README.md b/README.md index 6fa4ec69..1a6b9d0f 100644 --- a/README.md +++ b/README.md @@ -216,6 +216,7 @@ MIT License — see [LICENSE](LICENSE) for details. ## Acknowledgements - [OpenStreetMap](https://www.openstreetmap.org) for map tiles +- [OpenTopoMap](https://opentopomap.org), [OpenStreetMap France](https://www.openstreetmap.fr) (CyclOSM, OSM Humanitarian), [swisstopo](https://www.swisstopo.admin.ch), [basemap.at](https://basemap.at), [IGN](https://www.ign.fr), [PDOK](https://www.pdok.nl), [basemap.de](https://basemap.de) and the [USGS](https://www.usgs.gov) for the optional base maps - [Leaflet.js](https://leafletjs.com) for the map library, with [Leaflet.markercluster](https://github.com/Leaflet/Leaflet.markercluster) and [Leaflet-Geoman](https://geoman.io) (bundled; see [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)) diff --git a/src/opensak/gui/dialogs/settings_dialog.py b/src/opensak/gui/dialogs/settings_dialog.py index df14b511..7d545903 100644 --- a/src/opensak/gui/dialogs/settings_dialog.py +++ b/src/opensak/gui/dialogs/settings_dialog.py @@ -570,6 +570,7 @@ def _build_map_tab(self) -> QWidget: group_layout.addWidget(tile_cache_note) layout.addWidget(group) + layout.addWidget(self._build_map_layers_group()) layout.addStretch() # Same fix as General/Advanced (see #811 comment on __init__ for @@ -583,6 +584,91 @@ def _build_map_tab(self) -> QWidget: scroll.setFrameShape(QScrollArea.Shape.NoFrame) return scroll + def _build_map_layers_group(self) -> QGroupBox: + """#747: switch each base map on or off, and enter API keys for the + providers that need one (gui/map_layers.py).""" + from opensak.gui.map_layers import KEY_PROVIDERS, LAYERS + + group = QGroupBox(tr("settings_group_map_layers")) + group_layout = QVBoxLayout(group) + + note = QLabel(tr("settings_map_layers_note")) + note.setWordWrap(True) + note.setStyleSheet(hint_style()) + group_layout.addWidget(note) + + self._map_layers_list = QListWidget() + # Long entries wrap instead of disappearing behind a sideways scroll + self._map_layers_list.setWordWrap(True) + self._map_layers_list.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff) + for layer in LAYERS: + text = layer.label + hints = [] + if layer.key_provider: + # One key per provider, which may unlock several maps + hints.append(tr("settings_map_layer_needs_key", + provider=KEY_PROVIDERS[layer.key_provider][0])) + if not layer.offline: + hints.append(tr("settings_map_layer_no_offline")) + if hints: + text += " — " + ", ".join(hints) + item = QListWidgetItem(text) + item.setData(Qt.ItemDataRole.UserRole, layer.id) + item.setFlags(item.flags() | Qt.ItemFlag.ItemIsUserCheckable) + item.setCheckState(Qt.CheckState.Unchecked) + self._map_layers_list.addItem(item) + self._map_layers_list.setMinimumHeight(220) + group_layout.addWidget(self._map_layers_list) + + group_layout.addWidget(QLabel(tr("settings_map_api_keys_label"))) + keys_form = QFormLayout() + self._map_api_key_edits: dict[str, QLineEdit] = {} + for provider_id, (provider_name, signup_url) in KEY_PROVIDERS.items(): + maps = ", ".join(layer.provider for layer in LAYERS + if layer.key_provider == provider_id) + edit = QLineEdit() + edit.setPlaceholderText(tr("settings_map_api_key_for", maps=maps)) + self._map_api_key_edits[provider_id] = edit + get_key = QLabel(f'{tr("settings_map_api_key_get")}') + get_key.setOpenExternalLinks(True) + get_key.setToolTip(signup_url) + row = QHBoxLayout() + row.addWidget(edit, 1) + row.addWidget(get_key) + keys_form.addRow(provider_name + ":", row) + group_layout.addLayout(keys_form) + + keys_note = QLabel(tr("settings_map_api_keys_note")) + keys_note.setWordWrap(True) + keys_note.setStyleSheet(hint_style()) + group_layout.addWidget(keys_note) + return group + + def _load_map_layers(self) -> None: + s = get_settings() + enabled = set(s.map_base_layers) + for row in range(self._map_layers_list.count()): + item = self._map_layers_list.item(row) + if item is None: + continue + on = item.data(Qt.ItemDataRole.UserRole) in enabled + item.setCheckState(Qt.CheckState.Checked if on else Qt.CheckState.Unchecked) + keys = s.map_api_keys + for provider_id, edit in self._map_api_key_edits.items(): + edit.setText(keys.get(provider_id, "")) + + def _save_map_layers(self) -> None: + s = get_settings() + enabled = [] + for row in range(self._map_layers_list.count()): + item = self._map_layers_list.item(row) + if item is not None and item.checkState() == Qt.CheckState.Checked: + enabled.append(item.data(Qt.ItemDataRole.UserRole)) + s.map_base_layers = enabled + s.map_api_keys = { + provider_id: edit.text() for provider_id, edit in self._map_api_key_edits.items() + } + # ── Fane: Avanceret ─────────────────────────────────────────────────────── def _build_advanced_tab(self) -> QWidget: @@ -1843,6 +1929,7 @@ def _load(self) -> None: self._map_enabled_cb.setChecked(s.map_enabled) self._map_max_caches.setValue(s.map_max_caches) self._map_tile_cache.setValue(s.map_tile_cache_mb) + self._load_map_layers() idx = self._map_cluster_radius.findData(s.map_cluster_radius) self._map_cluster_radius.setCurrentIndex(max(idx, 0)) idx = self._map_labels.findData(s.map_labels) @@ -1976,6 +2063,7 @@ def _save(self) -> None: s.map_enabled = self._map_enabled_cb.isChecked() s.map_max_caches = self._map_max_caches.value() s.map_tile_cache_mb = self._map_tile_cache.value() + self._save_map_layers() s.map_cluster_radius = self._map_cluster_radius.currentData() s.map_labels = self._map_labels.currentData() separation_val = self._map_separation_radius.value() diff --git a/src/opensak/gui/map_layers.py b/src/opensak/gui/map_layers.py new file mode 100644 index 00000000..6bd7163b --- /dev/null +++ b/src/opensak/gui/map_layers.py @@ -0,0 +1,293 @@ +""" +map_layers.py — The base maps the map can show (#747). + +Each MapLayer is one tile source. Settings → Map lets the user switch every +layer on or off; the map offers the switched-on ones in Leaflet's layer +switcher and remembers the one last chosen. + +Only sources whose terms allow use in an app like OpenSAK are listed: + +* Keyless: OpenStreetMap and OSM-based community maps (fair use, attribution) + and national open-government-data services (open licences, attribution). +* With the user's own API key (Esri, MapTiler, Thunderforest): the user holds + the agreement with the provider. A keyed layer is offered only once its key + is entered. + +Google and Bing tiles are deliberately absent — their terms forbid direct +tile access outside their own SDKs/APIs. + +Offline (#1111): tiles normally go through the shared map profile's disk +HTTP cache (map_profile.py), which follows each provider's own cache headers. +A layer with offline=False comes from a provider whose terms do not allow +keeping tiles on the device (Esri: caching only while connected). Its tiles +are fetched through opensak://tiles//z/x/y (web_assets.py) instead — +Chromium keeps custom-scheme responses out of its HTTP cache, so they never +reach the disk. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import Optional + +from opensak.lang import tr + +# Kinds, shown after the provider name ("swisstopo – Aerial imagery"). +KIND_MAP = "map" +KIND_TOPO = "topo" +KIND_AERIAL = "aerial" + +_KIND_KEYS = { + KIND_MAP: "settings_tab_map", # "Map" — same word as the settings tab + KIND_TOPO: "map_layer_kind_topo", + KIND_AERIAL: "map_layer_kind_aerial", +} + +# Providers whose layers need the user's own API key, with the page where a +# key is obtained (shown in Settings → Map). +KEY_PROVIDERS: dict[str, tuple[str, str]] = { + # id: (display name, sign-up URL) + "esri": ("Esri ArcGIS", "https://location.arcgis.com/"), + "maptiler": ("MapTiler", "https://cloud.maptiler.com/"), + "thunderforest": ("Thunderforest", "https://manage.thunderforest.com/"), +} + +DEFAULT_LAYER = "osm" +# Switched on for a new installation; everything else is opt-in. +DEFAULT_ENABLED = ("osm", "opentopomap") + +_OSM_ATTR = '© OpenStreetMap contributors' + +# (south, west, north, east) — Leaflet requests no tiles outside these. +_BOUNDS_CH = (45.4, 5.4, 48.3, 11.0) +_BOUNDS_AT = (46.3, 9.4, 49.1, 17.3) +_BOUNDS_FR = (41.2, -5.6, 51.2, 9.8) +_BOUNDS_NL = (50.6, 3.0, 53.8, 7.4) +_BOUNDS_DE = (47.2, 5.8, 55.1, 15.1) +_BOUNDS_US = (18.0, -180.0, 72.0, -64.0) + + +@dataclass(frozen=True) +class MapLayer: + """One tile source. + + *url* is a Leaflet URL template ({z}/{x}/{y}, optional {s}); "{key}" is + replaced by the user's API key for *key_provider*. *max_native_zoom* is + the deepest zoom the server has tiles for — the map zooms on to 19 (20 + for some aerial layers) by enlarging them.""" + + id: str + provider: str + kind: str + url: str + attribution: str + max_native_zoom: int + max_zoom: int = 19 + subdomains: str = "" + region: str = "" # ISO country code for national services, "" = worldwide + bounds: Optional[tuple[float, float, float, float]] = None + key_provider: Optional[str] = None + offline: bool = True + + @property + def name(self) -> str: + """Localised display name, e.g. "swisstopo – Aerial imagery".""" + kind = tr(_KIND_KEYS[self.kind]) + return f"{self.provider} – {kind}" + + @property + def label(self) -> str: + """name plus the region code, e.g. "swisstopo – Aerial imagery (CH)".""" + return f"{self.name} ({self.region})" if self.region else self.name + + def tile_url(self, api_key: str = "") -> str: + """The URL template the page loads tiles from.""" + if not self.offline: + # Fetched through web_assets.TileProxy, never cached on disk. + from opensak.gui.web_assets import TILE_BASE + return f"{TILE_BASE}{self.id}/{{z}}/{{x}}/{{y}}" + return self.url.replace("{key}", api_key) + + def upstream_url(self, z: int, x: int, y: int, api_key: str = "") -> str: + """The provider's URL of one tile (used by the tile proxy).""" + url = self.url.replace("{key}", api_key) + url = url.replace("{z}", str(z)).replace("{x}", str(x)).replace("{y}", str(y)) + if "{s}" in url: + subs = self.subdomains or "a" + url = url.replace("{s}", subs[(x + y) % len(subs)]) + return url + + +def _wmts_ign(layer: str, fmt: str) -> str: + return ( + "https://data.geopf.fr/wmts?SERVICE=WMTS&REQUEST=GetTile&VERSION=1.0.0" + f"&LAYER={layer}&STYLE=normal&FORMAT={fmt}&TILEMATRIXSET=PM" + "&TILEMATRIX={z}&TILEROW={y}&TILECOL={x}" + ) + + +LAYERS: tuple[MapLayer, ...] = ( + # ── Worldwide, no key ──────────────────────────────────────────────── + MapLayer( + "osm", "OpenStreetMap", KIND_MAP, + "https://tile.openstreetmap.org/{z}/{x}/{y}.png", + _OSM_ATTR, max_native_zoom=19, + ), + MapLayer( + "opentopomap", "OpenTopoMap", KIND_TOPO, + "https://{s}.tile.opentopomap.org/{z}/{x}/{y}.png", + _OSM_ATTR + ', SRTM | © OpenTopoMap (CC-BY-SA)', + max_native_zoom=17, subdomains="abc", + ), + MapLayer( + "cyclosm", "CyclOSM", KIND_MAP, + "https://{s}.tile-cyclosm.openstreetmap.fr/cyclosm/{z}/{x}/{y}.png", + _OSM_ATTR + ' | CyclOSM, hosted by OpenStreetMap France', + max_native_zoom=19, subdomains="abc", + ), + MapLayer( + "osm_hot", "OSM Humanitarian", KIND_MAP, + "https://{s}.tile.openstreetmap.fr/hot/{z}/{x}/{y}.png", + _OSM_ATTR + ' | Humanitarian OpenStreetMap Team, hosted by OpenStreetMap France', + max_native_zoom=19, subdomains="abc", + ), + # ── National open-data services, no key ────────────────────────────── + MapLayer( + "swisstopo_map", "swisstopo", KIND_MAP, + "https://wmts.geo.admin.ch/1.0.0/ch.swisstopo.pixelkarte-farbe/default/current/3857/{z}/{x}/{y}.jpeg", + '© swisstopo', + max_native_zoom=19, region="CH", bounds=_BOUNDS_CH, + ), + MapLayer( + "swisstopo_aerial", "swisstopo", KIND_AERIAL, + "https://wmts.geo.admin.ch/1.0.0/ch.swisstopo.swissimage/default/current/3857/{z}/{x}/{y}.jpeg", + '© swisstopo SWISSIMAGE', + max_native_zoom=20, max_zoom=20, region="CH", bounds=_BOUNDS_CH, + ), + MapLayer( + "basemap_at_map", "basemap.at", KIND_MAP, + "https://mapsneu.wien.gv.at/basemap/geolandbasemap/normal/google3857/{z}/{y}/{x}.png", + 'basemap.at (CC BY 4.0)', + max_native_zoom=19, region="AT", bounds=_BOUNDS_AT, + ), + MapLayer( + "basemap_at_aerial", "basemap.at", KIND_AERIAL, + "https://mapsneu.wien.gv.at/basemap/bmaporthofoto30cm/normal/google3857/{z}/{y}/{x}.jpeg", + 'basemap.at (CC BY 4.0)', + max_native_zoom=19, region="AT", bounds=_BOUNDS_AT, + ), + MapLayer( + "ign_map", "IGN Plan", KIND_MAP, + _wmts_ign("GEOGRAPHICALGRIDSYSTEMS.PLANIGNV2", "image/png"), + '© IGN – Géoplateforme', + max_native_zoom=19, region="FR", bounds=_BOUNDS_FR, + ), + MapLayer( + "ign_aerial", "IGN", KIND_AERIAL, + _wmts_ign("ORTHOIMAGERY.ORTHOPHOTOS", "image/jpeg"), + '© IGN – Géoplateforme', + max_native_zoom=19, region="FR", bounds=_BOUNDS_FR, + ), + MapLayer( + "pdok_map", "PDOK BRT", KIND_MAP, + "https://service.pdok.nl/brt/achtergrondkaart/wmts/v2_0/standaard/EPSG:3857/{z}/{x}/{y}.png", + 'Kadaster / PDOK (CC BY 4.0)', + max_native_zoom=19, region="NL", bounds=_BOUNDS_NL, + ), + MapLayer( + "pdok_aerial", "PDOK", KIND_AERIAL, + "https://service.pdok.nl/hwh/luchtfotorgb/wmts/v1_0/Actueel_orthoHR/EPSG:3857/{z}/{x}/{y}.jpeg", + 'Beeldmateriaal Nederland / PDOK', + max_native_zoom=19, region="NL", bounds=_BOUNDS_NL, + ), + MapLayer( + "basemap_de", "basemap.de", KIND_MAP, + "https://sgx.geodatenzentrum.de/wmts_basemapde/tile/1.0.0/de_basemapde_web_raster_farbe/default/GLOBAL_WEBMERCATOR/{z}/{y}/{x}.png", + '© basemap.de / BKG (CC BY 4.0)', + max_native_zoom=18, region="DE", bounds=_BOUNDS_DE, + ), + MapLayer( + "usgs_topo", "USGS", KIND_TOPO, + "https://basemap.nationalmap.gov/arcgis/rest/services/USGSTopo/MapServer/tile/{z}/{y}/{x}", + 'Tiles courtesy of the U.S. Geological Survey', + max_native_zoom=16, region="US", bounds=_BOUNDS_US, + ), + MapLayer( + "usgs_aerial", "USGS", KIND_AERIAL, + "https://basemap.nationalmap.gov/arcgis/rest/services/USGSImageryOnly/MapServer/tile/{z}/{y}/{x}", + 'Tiles courtesy of the U.S. Geological Survey', + max_native_zoom=16, region="US", bounds=_BOUNDS_US, + ), + # ── Worldwide, user's own API key ──────────────────────────────────── + MapLayer( + "esri_aerial", "Esri World Imagery", KIND_AERIAL, + "https://ibasemaps-api.arcgis.com/arcgis/rest/services/World_Imagery/MapServer/tile/{z}/{y}/{x}?token={key}", + 'Powered by Esri | Esri, Maxar, Earthstar Geographics, and the GIS User Community', + max_native_zoom=19, key_provider="esri", + # Esri allows caching tiles only while connected — never on disk. + offline=False, + ), + MapLayer( + "maptiler_aerial", "MapTiler Satellite", KIND_AERIAL, + "https://api.maptiler.com/tiles/satellite-v2/{z}/{x}/{y}.jpg?key={key}", + '© MapTiler ' + _OSM_ATTR, + max_native_zoom=20, max_zoom=20, key_provider="maptiler", + ), + MapLayer( + "maptiler_outdoor", "MapTiler Outdoor", KIND_TOPO, + "https://api.maptiler.com/maps/outdoor-v2/256/{z}/{x}/{y}.png?key={key}", + '© MapTiler ' + _OSM_ATTR, + max_native_zoom=19, key_provider="maptiler", + ), + MapLayer( + "thunderforest_outdoors", "Thunderforest Outdoors", KIND_TOPO, + "https://tile.thunderforest.com/outdoors/{z}/{x}/{y}.png?apikey={key}", + 'Maps © Thunderforest, Data ' + _OSM_ATTR, + max_native_zoom=19, key_provider="thunderforest", + ), + MapLayer( + "thunderforest_cycle", "OpenCycleMap", KIND_MAP, + "https://tile.thunderforest.com/cycle/{z}/{x}/{y}.png?apikey={key}", + 'Maps © Thunderforest, Data ' + _OSM_ATTR, + max_native_zoom=19, key_provider="thunderforest", + ), +) + +_BY_ID = {layer.id: layer for layer in LAYERS} + + +def get_layer(layer_id: str) -> Optional[MapLayer]: + return _BY_ID.get(layer_id) + + +def available_layers(enabled_ids, api_keys: dict[str, str]) -> list[MapLayer]: + """The layers the map offers: switched on in the settings and, for a + keyed layer, with its key entered. Never empty — with nothing usable + left, OpenStreetMap is offered so the map still has a background.""" + enabled = set(enabled_ids) + out = [ + layer for layer in LAYERS + if layer.id in enabled + and (layer.key_provider is None or api_keys.get(layer.key_provider, "").strip()) + ] + return out or [_BY_ID[DEFAULT_LAYER]] + + +def layer_js_defs(layers: list[MapLayer], api_keys: dict[str, str]) -> list[dict]: + """The layer definitions the map page builds its tile layers from.""" + defs = [] + for layer in layers: + key = api_keys.get(layer.key_provider, "").strip() if layer.key_provider else "" + options: dict = { + "attribution": layer.attribution, + "maxZoom": layer.max_zoom, + "maxNativeZoom": layer.max_native_zoom, + } + if layer.subdomains: + options["subdomains"] = layer.subdomains + if layer.bounds: + s, w, n, e = layer.bounds + options["bounds"] = [[s, w], [n, e]] + defs.append({"id": layer.id, "name": layer.label, + "url": layer.tile_url(key), "options": options}) + return defs diff --git a/src/opensak/gui/map_profile.py b/src/opensak/gui/map_profile.py index e61d2122..43fa4c4e 100644 --- a/src/opensak/gui/map_profile.py +++ b/src/opensak/gui/map_profile.py @@ -9,6 +9,11 @@ was last loaded. Only tiles the user actually viewed are cached — no prefetching, as the OSM tile usage policy requires. +#747: the other base maps (map_layers.py) share this cache, each for as long +as its provider's cache headers allow. Layers whose provider does not allow +tiles on the device are fetched through opensak://tiles/ (web_assets.py), +which Chromium never writes to this cache. + Why one shared profile: two profiles with the same storage name in one process hang QtWebEngine (both open the same on-disk cache), and the main map, the split-screen map, the pop-out and the draw dialog can all be open diff --git a/src/opensak/gui/map_widget.py b/src/opensak/gui/map_widget.py index ac95e36d..b9d2603a 100644 --- a/src/opensak/gui/map_widget.py +++ b/src/opensak/gui/map_widget.py @@ -1,5 +1,5 @@ """ -src/opensak/gui/map_widget.py — Interaktivt OSM kort via Leaflet.js + QtWebEngine. +src/opensak/gui/map_widget.py — Interaktivt kort via Leaflet.js + QtWebEngine. Viser cache pins med farvekodet ikoner efter type. Kommunikerer med Python via QWebChannel. @@ -105,6 +105,8 @@ class MapBridge(QObject): shape_changed = Signal(str) # Clustering switched on/off with the map button (#1087) clustering_toggled = Signal(bool) + # Another base map chosen in the layer switcher (#747): layer id + base_layer_changed = Signal(str) # Separation circles switched on/off with the map button (#1087) separation_toggled = Signal(bool) @@ -148,6 +150,11 @@ def on_separation_toggled(self, on: bool) -> None: """Called from JavaScript when the separation circles button is clicked.""" self.separation_toggled.emit(on) + @Slot(str) + def on_base_layer_changed(self, layer_id: str) -> None: + """Called from JavaScript when another base map is chosen (#747).""" + self.base_layer_changed.emit(layer_id) + # ── HTML template med Leaflet.js ────────────────────────────────────────────── @@ -299,11 +306,11 @@ def on_separation_toggled(self, on: bool) -> None: zoomControl: true }); -var tileLayer = L.tileLayer('https://tile.openstreetmap.org/{z}/{x}/{y}.png', { - attribution: '© OpenStreetMap', - maxZoom: 19, - crossOrigin: true -}).addTo(map); +// #747: the base maps switched on in Settings → Map (gui/map_layers.py). +// With more than one, Leaflet's layer switcher offers them; the choice is +// reported to Python and becomes the base map next time. +var BASE_LAYERS = MAP_BASE_LAYERS; +var ACTIVE_BASE_LAYER = MAP_ACTIVE_BASE_LAYER; // #1111: tiles that are neither online nor in the tile cache fail to load — // say so instead of leaving grey squares unexplained. Pins, clustering and @@ -317,16 +324,42 @@ def on_separation_toggled(self, on: bool) -> None: } }); var tilesOfflineNotice = null; -tileLayer.on('tileerror', function() { - if (!tilesOfflineNotice) { - tilesOfflineNotice = new TilesOffline().addTo(map); - } -}); -tileLayer.on('tileload', function() { +function hideTilesOffline() { if (tilesOfflineNotice) { map.removeControl(tilesOfflineNotice); tilesOfflineNotice = null; } +} + +var tileLayer = null; +var baseLayerControl = {}; +BASE_LAYERS.forEach(function(def) { + var opts = Object.assign({}, def.options); + var layer = L.tileLayer(def.url, opts); + layer.opensakId = def.id; + layer.on('tileerror', function() { + if (layer === tileLayer && !tilesOfflineNotice) { + tilesOfflineNotice = new TilesOffline().addTo(map); + } + }); + layer.on('tileload', function() { + if (layer === tileLayer) hideTilesOffline(); + }); + baseLayerControl[def.name] = layer; + if (def.id === ACTIVE_BASE_LAYER) tileLayer = layer; +}); +// The last chosen map may have been switched off since: use the first one. +if (tileLayer === null) { + tileLayer = baseLayerControl[BASE_LAYERS[0].name]; +} +tileLayer.addTo(map); +if (BASE_LAYERS.length > 1) { + L.control.layers(baseLayerControl, null, { position: 'topright' }).addTo(map); +} +map.on('baselayerchange', function(e) { + tileLayer = e.layer; + hideTilesOffline(); + if (bridge) bridge.on_base_layer_changed(e.layer.opensakId); }); // ── Marker cluster gruppe ───────────────────────────────────────────────────── @@ -1252,6 +1285,7 @@ def _setup_ui(self) -> None: self._bridge.shape_changed.connect(self._on_shape_changed) self._bridge.clustering_toggled.connect(self._on_clustering_toggled) self._bridge.separation_toggled.connect(self._on_separation_toggled) + self._bridge.base_layer_changed.connect(self._on_base_layer_changed) self._ready = False layout.addWidget(QLabel("Map disabled (headless test mode)")) # i18n: ignore — tests only return @@ -1279,6 +1313,7 @@ def _setup_ui(self) -> None: self._bridge.shape_changed.connect(self._on_shape_changed) self._bridge.clustering_toggled.connect(self._on_clustering_toggled) self._bridge.separation_toggled.connect(self._on_separation_toggled) + self._bridge.base_layer_changed.connect(self._on_base_layer_changed) self._channel.registerObject("bridge", self._bridge) self._page.setWebChannel(self._channel) @@ -1358,18 +1393,33 @@ def _html_options(self) -> dict: # after Settings → OK (reload_map) applies them to the open map. from opensak.gui.settings import get_settings s = get_settings() + # #747: the base maps too — Settings → OK switches them on/off. + from opensak.gui.map_layers import available_layers, layer_js_defs + keys = s.map_api_keys + layers = layer_js_defs(available_layers(s.map_base_layers, keys), keys) return {"map_actions": self._map_actions, "draw_button": self._draw_button, "auto_fit_caches": self._auto_fit_caches, "clustering": s.map_clustering, "cluster_radius": s.map_cluster_radius, - "label_mode": s.map_labels} + "label_mode": s.map_labels, + "base_layers": layers, "active_base_layer": s.map_base_layer} @staticmethod def _render_map_html(lat: float, lon: float, *, map_actions: bool = True, draw_button: bool = False, auto_fit_caches: bool = True, clustering: bool = True, cluster_radius: int = 40, - label_mode: str = "off") -> str: - """Render MAP_HTML template with dynamic values and localized tooltips.""" + label_mode: str = "off", + base_layers: Optional[list[dict]] = None, + active_base_layer: str = "") -> str: + """Render MAP_HTML template with dynamic values and localized tooltips. + + *base_layers* are map_layers.layer_js_defs() entries (default: + OpenStreetMap only); *active_base_layer* is the id shown first.""" import opensak.utils.flags as flags + from opensak.gui import map_layers + if not base_layers: + base_layers = map_layers.layer_js_defs( + map_layers.available_layers([map_layers.DEFAULT_LAYER], {}), {} + ) html = MAP_HTML.replace("INIT_LAT", str(lat)) html = html.replace("INIT_LON", str(lon)) html = html.replace("INIT_ZOOM", "12") @@ -1407,6 +1457,9 @@ def _render_map_html(lat: float, lon: float, *, map_actions: bool = True, html = html.replace( "MAP_TIP_SEPARATION", _js_inline_arg(tr("map_separation_tooltip")) ) + # #747: layer names hold translated text too — substituted last. + html = html.replace("MAP_ACTIVE_BASE_LAYER", _js_inline_arg(active_base_layer)) + html = html.replace("MAP_BASE_LAYERS", _js_inline_arg(base_layers)) return html def _run_js(self, js: str) -> None: @@ -1712,6 +1765,15 @@ def set_view(self, lat: float, lon: float, zoom: int = 13) -> None: if self._ready: self._run_js(f"setView({lat}, {lon}, {int(zoom)})") + def _on_base_layer_changed(self, layer_id: str) -> None: + """#747: remember the base map chosen in the layer switcher; every + map (main, split-screen, pop-out) opens with it next time.""" + from opensak.gui.map_layers import get_layer + if get_layer(layer_id) is None: + return + from opensak.gui.settings import get_settings + get_settings().map_base_layer = layer_id + def _on_clustering_toggled(self, on: bool) -> None: """The map button already regrouped the pins; remember the choice for the next map load (#1087).""" diff --git a/src/opensak/gui/settings.py b/src/opensak/gui/settings.py index 112d8018..8f10dbb6 100644 --- a/src/opensak/gui/settings.py +++ b/src/opensak/gui/settings.py @@ -438,6 +438,49 @@ def map_tile_cache_mb(self) -> int: def map_tile_cache_mb(self, value: int) -> None: get_store().set("display.map_tile_cache_mb", max(0, int(value))) + @property + def map_base_layers(self) -> list[str]: + """#747: ids of the base maps switched on in Settings → Map (see + gui/map_layers.py). Unknown ids (a layer removed in a later + version) are dropped. Global, like map_enabled.""" + from opensak.gui.map_layers import DEFAULT_ENABLED, get_layer + val = get_store().get("display.map_base_layers", None) + if not isinstance(val, list): + return list(DEFAULT_ENABLED) + return [v for v in val if isinstance(v, str) and get_layer(v) is not None] + + @map_base_layers.setter + def map_base_layers(self, value: list[str]) -> None: + get_store().set("display.map_base_layers", [str(v) for v in value]) + + @property + def map_base_layer(self) -> str: + """#747: id of the base map last chosen in the map's layer switcher.""" + from opensak.gui.map_layers import DEFAULT_LAYER + val = get_store().get("display.map_base_layer", DEFAULT_LAYER) + return val if isinstance(val, str) else DEFAULT_LAYER + + @map_base_layer.setter + def map_base_layer(self, value: str) -> None: + get_store().set("display.map_base_layer", str(value)) + + @property + def map_api_keys(self) -> dict[str, str]: + """#747: the user's own API keys for keyed tile providers, by + provider id (map_layers.KEY_PROVIDERS). Empty keys are left out.""" + val = get_store().get("display.map_api_keys", {}) + if not isinstance(val, dict): + return {} + return {str(k): str(v).strip() for k, v in val.items() + if isinstance(v, str) and v.strip()} + + @map_api_keys.setter + def map_api_keys(self, value: dict[str, str]) -> None: + get_store().set( + "display.map_api_keys", + {str(k): str(v).strip() for k, v in value.items() if str(v).strip()}, + ) + @property def map_cluster_radius(self) -> int: """Issue #1087: Leaflet.markercluster's maxClusterRadius in pixels, diff --git a/src/opensak/gui/web_assets.py b/src/opensak/gui/web_assets.py index 05b7df19..deecb994 100644 --- a/src/opensak/gui/web_assets.py +++ b/src/opensak/gui/web_assets.py @@ -15,13 +15,23 @@ The scheme must be registered before the QApplication is created (register_scheme(), called from app.main()); the handler is installed on the shared map profile (install_handler(), called from map_profile.py). + +#747: the same scheme also proxies the tiles of map layers whose provider +does not allow keeping tiles on the device (MapLayer.offline is False): + + opensak://tiles/esri_aerial/12/2145/1434 → the provider's tile URL + +Chromium never writes custom-scheme responses to its HTTP cache, and the +QNetworkAccessManager used here has no cache, so these tiles stay off the +disk. The API key is added here, so it never appears in the page. """ from __future__ import annotations from pathlib import Path -from PySide6.QtCore import QBuffer, QCoreApplication, QIODevice, QObject +from PySide6.QtCore import QBuffer, QCoreApplication, QIODevice, QObject, QUrl +from PySide6.QtNetwork import QNetworkAccessManager, QNetworkReply, QNetworkRequest from PySide6.QtWebEngineCore import ( QWebEngineProfile, QWebEngineUrlRequestJob, @@ -33,6 +43,9 @@ ASSETS_HOST = "assets" # Prefix for asset URLs in the map HTML, e.g. ASSET_BASE + "leaflet/leaflet.js". ASSET_BASE = "opensak://assets/" +TILES_HOST = "tiles" +# Prefix for proxied tile URLs (#747), e.g. TILE_BASE + "esri_aerial/{z}/{x}/{y}". +TILE_BASE = "opensak://tiles/" WEB_DIR = Path(__file__).parent.parent / "assets" / "web" @@ -80,14 +93,48 @@ def resolve_asset(host: str, path: str) -> Path | None: return target +def resolve_tile(path: str) -> str | None: + """Map an opensak://tiles/ path ("////") to the + provider's tile URL, or None. + + Only layers with offline=False are proxied — every other layer loads + straight from its provider (and may use the disk cache). A keyed layer + without a key resolves to None.""" + from opensak.gui.map_layers import get_layer + parts = path.strip("/").split("/") + if len(parts) != 4 or not all(p.isdigit() for p in parts[1:]): + return None + layer = get_layer(parts[0]) + if layer is None or layer.offline: + return None + z, x, y = (int(p) for p in parts[1:]) + if z > 30 or x >= 2 ** z or y >= 2 ** z: + return None + key = "" + if layer.key_provider: + from opensak.gui.settings import get_settings + key = get_settings().map_api_keys.get(layer.key_provider, "") + if not key: + return None + return layer.upstream_url(z, x, y, key) + + class AssetSchemeHandler(QWebEngineUrlSchemeHandler): - """Answers opensak://assets/... requests from WEB_DIR.""" + """Answers opensak://assets/... requests from WEB_DIR, and proxies + opensak://tiles/... requests (#747).""" + + def __init__(self, parent: QObject | None = None) -> None: + super().__init__(parent) + self._nam: QNetworkAccessManager | None = None def requestStarted(self, job: QWebEngineUrlRequestJob) -> None: url = job.requestUrl() if job.requestMethod().data() != b"GET": job.fail(QWebEngineUrlRequestJob.Error.RequestDenied) return + if url.host() == TILES_HOST: + self._proxy_tile(job, url.path()) + return target = resolve_asset(url.host(), url.path()) if target is None: job.fail(QWebEngineUrlRequestJob.Error.UrlNotFound) @@ -103,6 +150,51 @@ def requestStarted(self, job: QWebEngineUrlRequestJob) -> None: buf.open(QIODevice.OpenModeFlag.ReadOnly) job.reply(_MIME_TYPES[target.suffix.lower()], buf) + def _proxy_tile(self, job: QWebEngineUrlRequestJob, path: str) -> None: + upstream = resolve_tile(path) + if upstream is None: + job.fail(QWebEngineUrlRequestJob.Error.UrlNotFound) + return + if self._nam is None: + # No cache set on the manager: nothing it fetches is stored. + self._nam = QNetworkAccessManager(self) + request = QNetworkRequest(QUrl(upstream)) + request.setHeader(QNetworkRequest.KnownHeaders.UserAgentHeader, _user_agent()) + reply = self._nam.get(request) + # The page may cancel the tile (panned away) before the reply ends: + # the job is then deleted, and the reply is aborted with it. + state = {"job_alive": True} + + def on_job_gone() -> None: + state["job_alive"] = False + if reply.isRunning(): + reply.abort() + + job.destroyed.connect(on_job_gone) + + def on_finished() -> None: + reply.deleteLater() + if not state["job_alive"]: + return + job.destroyed.disconnect(on_job_gone) + status = reply.attribute(QNetworkRequest.Attribute.HttpStatusCodeAttribute) + if reply.error() != QNetworkReply.NetworkError.NoError or status != 200: + job.fail(QWebEngineUrlRequestJob.Error.RequestFailed) + return + content_type = reply.header(QNetworkRequest.KnownHeaders.ContentTypeHeader) + mime = str(content_type or "image/png").split(";")[0].strip().encode() + buf = QBuffer(job) + buf.setData(reply.readAll()) + buf.open(QIODevice.OpenModeFlag.ReadOnly) + job.reply(mime, buf) + + reply.finished.connect(on_finished) + + +def _user_agent() -> str: + from opensak import __version__ + return f"OpenSAK/{__version__} (+https://github.com/OpenSAK-Org/OpenSAK)" + def install_handler(profile: QWebEngineProfile, parent: QObject | None = None) -> AssetSchemeHandler: """Install an AssetSchemeHandler on *profile* and return it. diff --git a/src/opensak/lang/cs.py b/src/opensak/lang/cs.py index d2ca9622..7120eca9 100644 --- a/src/opensak/lang/cs.py +++ b/src/opensak/lang/cs.py @@ -637,6 +637,14 @@ "settings_map_tile_cache_clear": "Vymazat mezipaměť", "settings_map_tile_cache_cleared": "Mezipaměť dlaždic mapy byla vymazána ({size} MB).", "settings_map_tile_cache_note": "Zobrazené dlaždice mapy se ukládají v tomto počítači, takže se podklad mapy zobrazí i bez připojení k internetu — přibližně týden od chvíle, kdy jste oblast naposledy zobrazili online. Projeví se po restartu.", + "settings_group_map_layers": "Podkladové mapy", + "settings_map_layers_note": "Vyberte, které podkladové mapy nabízí přepínač vrstev na mapě (vpravo nahoře). Národní mapy pokrývají jen svou zemi. Zobrazené dlaždice se ukládají do mezipaměti dlaždic výše tak dlouho, jak to poskytovatel dovolí.", + "settings_map_layer_needs_key": "vyžaduje klíč API {provider}", + "settings_map_layer_no_offline": "není dostupné offline", + "settings_map_api_keys_label": "Klíče API:", + "settings_map_api_key_for": "Klíč pro: {maps}", + "settings_map_api_key_get": "Získat klíč", + "settings_map_api_keys_note": "Jeden bezplatný klíč API na poskytovatele odemkne všechny jeho mapy (odkaz vedle každého pole). Mapy také zapněte výše. Klíče se ukládají do souboru nastavení OpenSAK.", "settings_map_separation_label": "Poloměr kruhů odstupu:", "settings_map_separation_off": "Vypnuto", "settings_map_separation_note": "Nakreslí na mapě kruh s tímto poloměrem kolem každé fyzické kešky a jejích fyzických stage a finálky, např. pro plánování nového úkrytu. 0,161 km (0,1 mi) je minimální vzdálenost mezi keškami podle geocaching.com. Kruhy zapnete a vypnete tlačítkem ◯ na mapě; vykreslí se po přiblížení. Vypnuto skryje tlačítko.", @@ -1570,6 +1578,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — opravené souřadnice nastaveny: {coords}", "map_draw_tooltip": "Nakreslit tvar pro filtr čára/polygon", "map_tiles_offline": "Offline – dlaždice mapy nejsou k dispozici", + "map_layer_kind_topo": "Topografická mapa", + "map_layer_kind_aerial": "Letecký snímek", "map_clustering_tooltip": "Shlukování zap./vyp.", "map_separation_tooltip": "Kruhy odstupu zap/vyp (zobrazí se po přiblížení)", "map_draw_polygon": "Nakreslit polygon", diff --git a/src/opensak/lang/da.py b/src/opensak/lang/da.py index 2d02da6c..58553dda 100644 --- a/src/opensak/lang/da.py +++ b/src/opensak/lang/da.py @@ -638,6 +638,14 @@ "settings_map_tile_cache_clear": "Ryd cache", "settings_map_tile_cache_cleared": "Kortfliser-cachen blev ryddet ({size} MB).", "settings_map_tile_cache_note": "Kortfliser, du har set, gemmes på denne computer, så kortbaggrunden også vises uden internetforbindelse — i omkring en uge efter, du sidst så området online. Træder i kraft efter genstart.", + "settings_group_map_layers": "Baggrundskort", + "settings_map_layers_note": "Vælg hvilke baggrundskort lagvælgeren på kortet (øverst til højre) tilbyder. Nationale kort dækker kun deres eget land. Kortfliser, du ser, gemmes i kortfliser-cachen ovenfor, så længe udbyderen tillader det.", + "settings_map_layer_needs_key": "kræver en {provider}-API-nøgle", + "settings_map_layer_no_offline": "ikke tilgængeligt offline", + "settings_map_api_keys_label": "API-nøgler:", + "settings_map_api_key_for": "Nøgle til: {maps}", + "settings_map_api_key_get": "Hent en nøgle", + "settings_map_api_keys_note": "Én gratis API-nøgle pr. udbyder låser alle udbyderens kort op (brug linket ved hvert felt). Slå også kortene til ovenfor. Nøglerne gemmes i OpenSAKs indstillingsfil.", "settings_map_separation_label": "Radius for afstandscirkler:", "settings_map_separation_off": "Fra", "settings_map_separation_note": "Tegner en cirkel med denne radius om hver fysisk cache og dens fysiske stages og final på kortet, fx til at planlægge et nyt gemmested. 0,161 km (0,1 mi) er geocaching.com's mindsteafstand mellem caches. Slå cirklerne til og fra med ◯-knappen på kortet; de tegnes, når du zoomer ind. Fra skjuler knappen.", @@ -1569,6 +1577,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — korrigerede koordinater sat: {coords}", "map_draw_tooltip": "Tegn en form til linje/polygon-filteret", "map_tiles_offline": "Offline – kortfliser er ikke tilgængelige", + "map_layer_kind_topo": "Topografisk kort", + "map_layer_kind_aerial": "Luftfoto", "map_clustering_tooltip": "Klynger til/fra", "map_separation_tooltip": "Afstandscirkler til/fra (vises når der er zoomet ind)", "map_draw_polygon": "Tegn polygon", diff --git a/src/opensak/lang/de.py b/src/opensak/lang/de.py index b48419a6..8ef44d2c 100644 --- a/src/opensak/lang/de.py +++ b/src/opensak/lang/de.py @@ -637,6 +637,14 @@ "settings_map_tile_cache_clear": "Cache leeren", "settings_map_tile_cache_cleared": "Der Kartenkachel-Cache wurde geleert ({size} MB).", "settings_map_tile_cache_note": "Angesehene Kartenkacheln werden auf diesem Computer gespeichert, sodass der Kartenhintergrund auch ohne Internetverbindung angezeigt wird — etwa eine Woche lang, nachdem Sie den Bereich zuletzt online angesehen haben. Wird nach einem Neustart wirksam.", + "settings_group_map_layers": "Hintergrundkarten", + "settings_map_layers_note": "Wählen Sie, welche Hintergrundkarten die Ebenenauswahl auf der Karte (oben rechts) anbietet. Nationale Karten decken nur ihr eigenes Land ab. Angesehene Kacheln kommen in den Kartenkachel-Cache oben, so lange der Anbieter es erlaubt.", + "settings_map_layer_needs_key": "benötigt einen {provider}-API-Schlüssel", + "settings_map_layer_no_offline": "offline nicht verfügbar", + "settings_map_api_keys_label": "API-Schlüssel:", + "settings_map_api_key_for": "Schlüssel für: {maps}", + "settings_map_api_key_get": "Schlüssel holen", + "settings_map_api_keys_note": "Ein kostenloser API-Schlüssel pro Anbieter schaltet alle seine Karten frei (Link neben dem jeweiligen Feld). Schalten Sie die Karten zusätzlich oben ein. Die Schlüssel werden in der OpenSAK-Einstellungsdatei gespeichert.", "settings_map_separation_label": "Radius der Abstandskreise:", "settings_map_separation_off": "Aus", "settings_map_separation_note": "Zeichnet auf der Karte einen Kreis mit diesem Radius um jeden physischen Cache und seine physischen Stationen und das Final, z. B. zur Planung eines neuen Verstecks. 0,161 km (0,1 mi) ist der Mindestabstand zwischen Caches bei geocaching.com. Die Kreise werden mit der ◯-Schaltfläche auf der Karte ein- und ausgeschaltet und erscheinen, sobald hineingezoomt wird. Aus blendet die Schaltfläche aus.", @@ -1570,6 +1578,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — Korrigierte Koordinaten gesetzt: {coords}", "map_draw_tooltip": "Eine Form für den Linien-/Polygonfilter zeichnen", "map_tiles_offline": "Offline – Kartenkacheln nicht verfügbar", + "map_layer_kind_topo": "Topografische Karte", + "map_layer_kind_aerial": "Luftbild", "map_clustering_tooltip": "Cluster ein/aus", "map_separation_tooltip": "Abstandskreise ein/aus (sichtbar beim Hineinzoomen)", "map_draw_polygon": "Polygon zeichnen", diff --git a/src/opensak/lang/de_CH.py b/src/opensak/lang/de_CH.py index 414a0805..d79641d4 100644 --- a/src/opensak/lang/de_CH.py +++ b/src/opensak/lang/de_CH.py @@ -638,6 +638,14 @@ "settings_map_tile_cache_clear": "Cache leeren", "settings_map_tile_cache_cleared": "Der Kartenkachel-Cache wurde geleert ({size} MB).", "settings_map_tile_cache_note": "Angesehene Kartenkacheln werden auf diesem Computer gespeichert, sodass der Kartenhintergrund auch ohne Internetverbindung angezeigt wird — etwa eine Woche lang, nachdem Sie den Bereich zuletzt online angesehen haben. Wird nach einem Neustart wirksam.", + "settings_group_map_layers": "Hintergrundkarten", + "settings_map_layers_note": "Wählen Sie, welche Hintergrundkarten die Ebenenauswahl auf der Karte (oben rechts) anbietet. Nationale Karten decken nur ihr eigenes Land ab. Angesehene Kacheln kommen in den Kartenkachel-Cache oben, so lange der Anbieter es erlaubt.", + "settings_map_layer_needs_key": "benötigt einen {provider}-API-Schlüssel", + "settings_map_layer_no_offline": "offline nicht verfügbar", + "settings_map_api_keys_label": "API-Schlüssel:", + "settings_map_api_key_for": "Schlüssel für: {maps}", + "settings_map_api_key_get": "Schlüssel holen", + "settings_map_api_keys_note": "Ein kostenloser API-Schlüssel pro Anbieter schaltet alle seine Karten frei (Link neben dem jeweiligen Feld). Schalten Sie die Karten zusätzlich oben ein. Die Schlüssel werden in der OpenSAK-Einstellungsdatei gespeichert.", "settings_map_separation_label": "Radius der Abstandskreise:", "settings_map_separation_off": "Aus", "settings_map_separation_note": "Zeichnet auf der Karte einen Kreis mit diesem Radius um jeden physischen Cache und seine physischen Stationen und das Final, z. B. zur Planung eines neuen Verstecks. 0,161 km (0,1 mi) ist der Mindestabstand zwischen Caches bei geocaching.com. Die Kreise werden mit der ◯-Schaltfläche auf der Karte ein- und ausgeschaltet und erscheinen, sobald hineingezoomt wird. Aus blendet die Schaltfläche aus.", @@ -1571,6 +1579,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — Korrigierte Koordinaten gesetzt: {coords}", "map_draw_tooltip": "Eine Form für den Linien-/Polygonfilter zeichnen", "map_tiles_offline": "Offline – Kartenkacheln nicht verfügbar", + "map_layer_kind_topo": "Topografische Karte", + "map_layer_kind_aerial": "Luftbild", "map_clustering_tooltip": "Cluster ein/aus", "map_separation_tooltip": "Abstandskreise ein/aus (sichtbar beim Hineinzoomen)", "map_draw_polygon": "Polygon zeichnen", diff --git a/src/opensak/lang/en.py b/src/opensak/lang/en.py index 815eee48..cb3d70a1 100644 --- a/src/opensak/lang/en.py +++ b/src/opensak/lang/en.py @@ -637,6 +637,14 @@ "settings_map_tile_cache_clear": "Clear cache", "settings_map_tile_cache_cleared": "The map tile cache was cleared ({size} MB).", "settings_map_tile_cache_note": "Map tiles you have viewed are kept on this computer, so the map background still shows without an internet connection — for about a week after you last viewed that area online. Takes effect after a restart.", + "settings_group_map_layers": "Base maps", + "settings_map_layers_note": "Choose which base maps the layer switcher on the map (top right) offers. National maps cover only their own country. Tiles you view go into the map tile cache above for as long as the provider allows.", + "settings_map_layer_needs_key": "needs a {provider} API key", + "settings_map_layer_no_offline": "not available offline", + "settings_map_api_keys_label": "API keys:", + "settings_map_api_key_for": "Key for: {maps}", + "settings_map_api_key_get": "Get a key", + "settings_map_api_keys_note": "One free API key per provider unlocks all of its maps (use the link next to each field). Switch the maps on above as well. Keys are stored in the OpenSAK settings file.", "settings_map_separation_label": "Separation circle radius:", "settings_map_separation_off": "Off", "settings_map_separation_note": "Draws a circle of this radius around each physical cache and its physical stages and final on the map, for example to plan a new hide. 0.161 km (0.1 mi) is the geocaching.com minimum distance between caches. Turn the circles on and off with the ◯ button on the map; they are drawn once you zoom in. Off hides the button.", @@ -1568,6 +1576,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — corrected coordinates set: {coords}", "map_draw_tooltip": "Draw a shape for the Line/Polygon filter", "map_tiles_offline": "Offline – map tiles unavailable", + "map_layer_kind_topo": "Topographic map", + "map_layer_kind_aerial": "Aerial imagery", "map_clustering_tooltip": "Clustering on/off", "map_separation_tooltip": "Separation circles on/off (shown when zoomed in)", "map_draw_polygon": "Draw polygon", diff --git a/src/opensak/lang/es.py b/src/opensak/lang/es.py index 29d4a26c..5833732f 100644 --- a/src/opensak/lang/es.py +++ b/src/opensak/lang/es.py @@ -639,6 +639,14 @@ "settings_map_tile_cache_clear": "Vaciar caché", "settings_map_tile_cache_cleared": "Se ha vaciado la caché de teselas del mapa ({size} MB).", "settings_map_tile_cache_note": "Las teselas del mapa que ha visto se guardan en este equipo, de modo que el fondo del mapa se sigue mostrando sin conexión a internet — durante aproximadamente una semana desde la última vez que vio esa zona en línea. Se aplica tras reiniciar.", + "settings_group_map_layers": "Mapas base", + "settings_map_layers_note": "Elija qué mapas base ofrece el selector de capas del mapa (arriba a la derecha). Los mapas nacionales solo cubren su propio país. Las teselas que vea se guardan en la caché de teselas de arriba mientras el proveedor lo permita.", + "settings_map_layer_needs_key": "requiere una clave API de {provider}", + "settings_map_layer_no_offline": "no disponible sin conexión", + "settings_map_api_keys_label": "Claves API:", + "settings_map_api_key_for": "Clave para: {maps}", + "settings_map_api_key_get": "Obtener una clave", + "settings_map_api_keys_note": "Una clave API gratuita por proveedor desbloquea todos sus mapas (enlace junto a cada campo). Active también los mapas arriba. Las claves se guardan en el archivo de configuración de OpenSAK.", "settings_map_separation_label": "Radio de los círculos de separación:", "settings_map_separation_off": "Desactivado", "settings_map_separation_note": "Dibuja en el mapa un círculo de este radio alrededor de cada caché física y de sus etapas físicas y final, por ejemplo para planificar un nuevo escondite. 0,161 km (0,1 mi) es la distancia mínima entre cachés de geocaching.com. Activa y desactiva los círculos con el botón ◯ del mapa; se dibujan al acercar el zoom. Desactivado oculta el botón.", @@ -1570,6 +1578,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — coordenadas corregidas establecidas: {coords}", "map_draw_tooltip": "Dibujar una forma para el filtro de línea/polígono", "map_tiles_offline": "Sin conexión – teselas del mapa no disponibles", + "map_layer_kind_topo": "Mapa topográfico", + "map_layer_kind_aerial": "Imagen aérea", "map_clustering_tooltip": "Agrupación sí/no", "map_separation_tooltip": "Círculos de separación sí/no (visibles al acercar el zoom)", "map_draw_polygon": "Dibujar polígono", diff --git a/src/opensak/lang/fr.py b/src/opensak/lang/fr.py index 94dd43ad..ccde03c0 100644 --- a/src/opensak/lang/fr.py +++ b/src/opensak/lang/fr.py @@ -637,6 +637,14 @@ "settings_map_tile_cache_clear": "Vider le cache", "settings_map_tile_cache_cleared": "Le cache des tuiles de carte a été vidé ({size} Mo).", "settings_map_tile_cache_note": "Les tuiles de carte que vous avez consultées sont conservées sur cet ordinateur, afin que le fond de carte s'affiche aussi sans connexion internet — pendant environ une semaine après la dernière consultation de la zone en ligne. Prend effet après un redémarrage.", + "settings_group_map_layers": "Fonds de carte", + "settings_map_layers_note": "Choisissez les fonds de carte proposés par le sélecteur de couches de la carte (en haut à droite). Les cartes nationales ne couvrent que leur propre pays. Les tuiles affichées sont conservées dans le cache de tuiles ci-dessus aussi longtemps que le fournisseur l’autorise.", + "settings_map_layer_needs_key": "nécessite une clé API {provider}", + "settings_map_layer_no_offline": "non disponible hors ligne", + "settings_map_api_keys_label": "Clés API :", + "settings_map_api_key_for": "Clé pour : {maps}", + "settings_map_api_key_get": "Obtenir une clé", + "settings_map_api_keys_note": "Une clé API gratuite par fournisseur débloque toutes ses cartes (lien à côté de chaque champ). Activez aussi les cartes ci-dessus. Les clés sont enregistrées dans le fichier de paramètres d’OpenSAK.", "settings_map_separation_label": "Rayon des cercles de distance :", "settings_map_separation_off": "Désactivé", "settings_map_separation_note": "Dessine sur la carte un cercle de ce rayon autour de chaque cache physique et de ses étapes physiques et de sa finale, par exemple pour préparer une nouvelle cache. 0,161 km (0,1 mi) est la distance minimale entre caches de geocaching.com. Activez ou désactivez les cercles avec le bouton ◯ de la carte ; ils s'affichent une fois zoomé. Désactivé masque le bouton.", @@ -1570,6 +1578,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — coordonnées corrigées définies : {coords}", "map_draw_tooltip": "Dessiner une forme pour le filtre ligne/polygone", "map_tiles_offline": "Hors ligne – tuiles de carte indisponibles", + "map_layer_kind_topo": "Carte topographique", + "map_layer_kind_aerial": "Photo aérienne", "map_clustering_tooltip": "Regroupement activé/désactivé", "map_separation_tooltip": "Cercles de distance oui/non (visibles en zoomant)", "map_draw_polygon": "Dessiner un polygone", diff --git a/src/opensak/lang/nl.py b/src/opensak/lang/nl.py index 6f629247..86ae1a40 100644 --- a/src/opensak/lang/nl.py +++ b/src/opensak/lang/nl.py @@ -640,6 +640,14 @@ "settings_map_tile_cache_clear": "Cache wissen", "settings_map_tile_cache_cleared": "De cache voor kaarttegels is gewist ({size} MB).", "settings_map_tile_cache_note": "Kaarttegels die u hebt bekeken, worden op deze computer bewaard, zodat de kaartachtergrond ook zonder internetverbinding zichtbaar is — ongeveer een week nadat u het gebied voor het laatst online hebt bekeken. Wordt actief na een herstart.", + "settings_group_map_layers": "Achtergrondkaarten", + "settings_map_layers_note": "Kies welke achtergrondkaarten de laagkiezer op de kaart (rechtsboven) aanbiedt. Nationale kaarten dekken alleen hun eigen land. Bekeken tegels komen in de kaarttegelcache hierboven, zo lang als de aanbieder dat toestaat.", + "settings_map_layer_needs_key": "vereist een {provider}-API-sleutel", + "settings_map_layer_no_offline": "niet offline beschikbaar", + "settings_map_api_keys_label": "API-sleutels:", + "settings_map_api_key_for": "Sleutel voor: {maps}", + "settings_map_api_key_get": "Sleutel aanvragen", + "settings_map_api_keys_note": "Eén gratis API-sleutel per aanbieder ontgrendelt al diens kaarten (link naast elk veld). Zet de kaarten hierboven ook aan. De sleutels worden opgeslagen in het instellingenbestand van OpenSAK.", "settings_map_separation_label": "Straal van afstandscirkels:", "settings_map_separation_off": "Uit", "settings_map_separation_note": "Tekent op de kaart een cirkel met deze straal rond elke fysieke cache en de fysieke stages en final ervan, bijvoorbeeld om een nieuwe verstopplek te plannen. 0,161 km (0,1 mi) is de minimale afstand tussen caches volgens geocaching.com. Zet de cirkels aan en uit met de ◯-knop op de kaart; ze worden getekend zodra je inzoomt. Uit verbergt de knop.", @@ -1571,6 +1579,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — gecorrigeerde coördinaten ingesteld: {coords}", "map_draw_tooltip": "Een vorm tekenen voor het lijn-/polygoonfilter", "map_tiles_offline": "Offline – kaarttegels niet beschikbaar", + "map_layer_kind_topo": "Topografische kaart", + "map_layer_kind_aerial": "Luchtfoto", "map_clustering_tooltip": "Clusteren aan/uit", "map_separation_tooltip": "Afstandscirkels aan/uit (zichtbaar bij inzoomen)", "map_draw_polygon": "Polygoon tekenen", diff --git a/src/opensak/lang/pl.py b/src/opensak/lang/pl.py index d797e5a5..70599822 100644 --- a/src/opensak/lang/pl.py +++ b/src/opensak/lang/pl.py @@ -639,6 +639,14 @@ "settings_map_tile_cache_clear": "Wyczyść pamięć", "settings_map_tile_cache_cleared": "Pamięć podręczna kafelków mapy została wyczyszczona ({size} MB).", "settings_map_tile_cache_note": "Oglądane kafelki mapy są przechowywane na tym komputerze, dzięki czemu tło mapy jest widoczne także bez połączenia z internetem — przez około tydzień od ostatniego wyświetlenia obszaru online. Zmiana zadziała po ponownym uruchomieniu.", + "settings_group_map_layers": "Mapy podkładowe", + "settings_map_layers_note": "Wybierz, które mapy podkładowe oferuje przełącznik warstw na mapie (prawy górny róg). Mapy krajowe obejmują tylko swój kraj. Oglądane kafelki trafiają do pamięci podręcznej kafelków powyżej na tak długo, jak pozwala dostawca.", + "settings_map_layer_needs_key": "wymaga klucza API {provider}", + "settings_map_layer_no_offline": "niedostępna offline", + "settings_map_api_keys_label": "Klucze API:", + "settings_map_api_key_for": "Klucz dla: {maps}", + "settings_map_api_key_get": "Uzyskaj klucz", + "settings_map_api_keys_note": "Jeden bezpłatny klucz API na dostawcę odblokowuje wszystkie jego mapy (link obok każdego pola). Włącz też mapy powyżej. Klucze są zapisywane w pliku ustawień OpenSAK.", "settings_map_separation_label": "Promień okręgów odstępu:", "settings_map_separation_off": "Wył.", "settings_map_separation_note": "Rysuje na mapie okrąg o tym promieniu wokół każdej fizycznej skrytki oraz jej fizycznych etapów i finału, np. do planowania nowej skrytki. 0,161 km (0,1 mi) to minimalna odległość między skrytkami według geocaching.com. Okręgi włącza się i wyłącza przyciskiem ◯ na mapie; pojawiają się po przybliżeniu. Wył. ukrywa przycisk.", @@ -1570,6 +1578,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — ustawiono poprawione współrzędne: {coords}", "map_draw_tooltip": "Narysuj kształt dla filtra linia/wielokąt", "map_tiles_offline": "Offline – kafelki mapy niedostępne", + "map_layer_kind_topo": "Mapa topograficzna", + "map_layer_kind_aerial": "Zdjęcie lotnicze", "map_clustering_tooltip": "Grupowanie wł./wył.", "map_separation_tooltip": "Okręgi odstępu wł./wył. (widoczne po przybliżeniu)", "map_draw_polygon": "Rysuj wielokąt", diff --git a/src/opensak/lang/pt.py b/src/opensak/lang/pt.py index 83337881..89c7c972 100644 --- a/src/opensak/lang/pt.py +++ b/src/opensak/lang/pt.py @@ -637,6 +637,14 @@ "settings_map_tile_cache_clear": "Limpar cache", "settings_map_tile_cache_cleared": "A cache de mosaicos do mapa foi limpa ({size} MB).", "settings_map_tile_cache_note": "Os mosaicos do mapa que viu são guardados neste computador, para que o fundo do mapa continue visível sem ligação à internet — durante cerca de uma semana depois de ter visto essa zona online pela última vez. Aplica-se após reiniciar.", + "settings_group_map_layers": "Mapas de fundo", + "settings_map_layers_note": "Escolha os mapas de fundo que o seletor de camadas do mapa (canto superior direito) oferece. Os mapas nacionais cobrem apenas o seu próprio país. Os mosaicos que vê ficam na cache de mosaicos acima durante o tempo que o fornecedor permitir.", + "settings_map_layer_needs_key": "requer uma chave API {provider}", + "settings_map_layer_no_offline": "não disponível offline", + "settings_map_api_keys_label": "Chaves API:", + "settings_map_api_key_for": "Chave para: {maps}", + "settings_map_api_key_get": "Obter uma chave", + "settings_map_api_keys_note": "Uma chave API gratuita por fornecedor desbloqueia todos os seus mapas (ligação ao lado de cada campo). Ative também os mapas acima. As chaves são guardadas no ficheiro de definições do OpenSAK.", "settings_map_separation_label": "Raio dos círculos de separação:", "settings_map_separation_off": "Desligado", "settings_map_separation_note": "Desenha no mapa um círculo com este raio à volta de cada cache física e das suas etapas físicas e final, por exemplo para planear um novo esconderijo. 0,161 km (0,1 mi) é a distância mínima entre caches do geocaching.com. Ligue e desligue os círculos com o botão ◯ no mapa; são desenhados quando aproxima o zoom. Desligado oculta o botão.", @@ -1570,6 +1578,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — coordenadas corrigidas definidas: {coords}", "map_draw_tooltip": "Desenhar uma forma para o filtro de linha/polígono", "map_tiles_offline": "Offline – mosaicos do mapa indisponíveis", + "map_layer_kind_topo": "Mapa topográfico", + "map_layer_kind_aerial": "Imagem aérea", "map_clustering_tooltip": "Agrupamento ligado/desligado", "map_separation_tooltip": "Círculos de separação ligar/desligar (visíveis com zoom)", "map_draw_polygon": "Desenhar polígono", diff --git a/src/opensak/lang/se.py b/src/opensak/lang/se.py index 63247692..4a559e47 100644 --- a/src/opensak/lang/se.py +++ b/src/opensak/lang/se.py @@ -637,6 +637,14 @@ "settings_map_tile_cache_clear": "Rensa cache", "settings_map_tile_cache_cleared": "Cachen för kartplattor har rensats ({size} MB).", "settings_map_tile_cache_note": "Kartplattor som du har visat sparas på den här datorn, så att kartbakgrunden visas även utan internetanslutning — i ungefär en vecka efter att du senast visade området online. Gäller efter omstart.", + "settings_group_map_layers": "Bakgrundskartor", + "settings_map_layers_note": "Välj vilka bakgrundskartor lagerväljaren på kartan (uppe till höger) erbjuder. Nationella kartor täcker bara sitt eget land. Kartplattor som du visar sparas i cachen för kartplattor ovan så länge leverantören tillåter det.", + "settings_map_layer_needs_key": "kräver en API-nyckel från {provider}", + "settings_map_layer_no_offline": "inte tillgänglig offline", + "settings_map_api_keys_label": "API-nycklar:", + "settings_map_api_key_for": "Nyckel för: {maps}", + "settings_map_api_key_get": "Skaffa en nyckel", + "settings_map_api_keys_note": "En gratis API-nyckel per leverantör låser upp alla dess kartor (länk bredvid varje fält). Slå också på kartorna ovan. Nycklarna sparas i OpenSAKs inställningsfil.", "settings_map_separation_label": "Radie för avståndscirklar:", "settings_map_separation_off": "Av", "settings_map_separation_note": "Ritar en cirkel med denna radie runt varje fysisk cache och dess fysiska etapper och final på kartan, t.ex. för att planera ett nytt gömställe. 0,161 km (0,1 mi) är geocaching.com:s minsta avstånd mellan cacher. Slå på och av cirklarna med ◯-knappen på kartan; de ritas när du zoomar in. Av döljer knappen.", @@ -1569,6 +1577,8 @@ "map_ctx_corrected_set": "✓ {gc_code} — korrigerade koordinater angivna: {coords}", "map_draw_tooltip": "Rita en form för linje-/polygonfiltret", "map_tiles_offline": "Offline – kartplattor är inte tillgängliga", + "map_layer_kind_topo": "Topografisk karta", + "map_layer_kind_aerial": "Flygfoto", "map_clustering_tooltip": "Kluster på/av", "map_separation_tooltip": "Avståndscirklar på/av (visas vid inzoomning)", "map_draw_polygon": "Rita polygon", diff --git a/tests/unit-tests/test_map_draw.py b/tests/unit-tests/test_map_draw.py index 5ba9147c..b942b71a 100644 --- a/tests/unit-tests/test_map_draw.py +++ b/tests/unit-tests/test_map_draw.py @@ -37,7 +37,9 @@ def fake_settings(monkeypatch): use_miles=False, map_draw_dialog_geometry=None, map_clustering=True, map_cluster_radius=40, map_labels="off", - map_separation_radius_km=0.161, map_separation_circles=False) + map_separation_radius_km=0.161, map_separation_circles=False, + map_base_layers=["osm"], map_base_layer="osm", + map_api_keys={}) monkeypatch.setattr("opensak.gui.settings.get_settings", lambda: s) monkeypatch.setattr("opensak.gui.dialogs.map_draw_dialog.get_settings", lambda: s) return s diff --git a/tests/unit-tests/test_map_layers_747.py b/tests/unit-tests/test_map_layers_747.py new file mode 100644 index 00000000..2ded8415 --- /dev/null +++ b/tests/unit-tests/test_map_layers_747.py @@ -0,0 +1,215 @@ +# tests/unit-tests/test_map_layers_747.py — #747: more base maps. Every map +# can be switched on/off in Settings → Map, keyed maps appear only with the +# user's API key, the map offers the switched-on ones in a layer switcher and +# remembers the choice, and maps whose provider forbids keeping tiles on the +# device are fetched through opensak://tiles/ (never the disk cache). + +from __future__ import annotations + +import json +import re + +import pytest + +pytest.importorskip("pytestqt") + +from opensak.gui import map_layers +from opensak.gui.map_layers import LAYERS, available_layers, get_layer, layer_js_defs +from opensak.gui.map_widget import MapWidget +from opensak.gui.settings import get_settings +from opensak.gui.web_assets import TILE_BASE, resolve_tile +from opensak.lang import tr +from opensak.settings_store import get_store + + +def _layers_in_html(html: str) -> list[dict]: + m = re.search(r"var BASE_LAYERS = (.*);\n", html) + assert m, "BASE_LAYERS not substituted" + return json.loads(m.group(1).replace("<\\/", "