Add municipality and coordinate search, and a map target selector

Puts the controls that change what the map is looking at over the map itself, where they act, and gives them something to search. Search is one field, not two. A string either parses as coordinates or it does not, and the answer is obvious from the text, so making the user declare up front which kind of thing they are looking for would be asking them to do the program's job. Coordinates accept decimal and degrees-minutes-seconds, comma or space separated, with hemisphere letters — including the Italian O for ovest, because someone reading an Italian map will type it and silently reading it as east would put them the wrong side of Greenwich. The 1180 Piedmont municipalities are bundled rather than geocoded online. The app is region-scoped, so a list of one region's towns is small enough to ship (100 KB) and beats a geocoder on every axis that matters: instant, offline, no API key, no rate limit, and it cannot return a result somewhere the app has no radar for. Matching folds accents, so "aglie" finds "Agliè", and prefix matches outrank substring ones — typing "tor" should surface Torino, not the first alphabetical name that happens to contain those letters. tool/generate_places.py derives the list from Istat boundary shapefiles (CC BY 4.0). Two properties of that file cost time and are now written down: the geometry is UTM 32N rather than degrees, and the DBF is UTF-8 despite one bilingual Friulian record that makes strict cp1252 fail. A terminal renders utf-8 and latin-1 output identically, so the encoding cannot be settled by looking at printed text — it took dumping codepoints. A guard in the generator and a test against the shipped asset both check for mojibake now, and the guard caught a real mistake the moment it was written. The target selector switches between following the device, a saved place, and the whole region, and the selection doubles as what the app reopens on: "the place I marked" and "what I see when I open the app" are one idea to the person using it. Dragging the map while it is following stops the camera chasing them but leaves that preference alone, because looking somewhere else now is not the same as changing their mind about next launch. The position marker and the following are MapLibre's own, driven by onCameraTrackingDismissed, so there is no second location stream to keep in step with the map. A test asserts that all 1180 municipalities fall inside the region bounds, which is what actually validates the UTM-to-degrees conversion end to end. Verified on the emulator: the dropdown lists follow, region and both saved places; "aglie" finds Agliè; "44.3841 7.5426" offers the coordinate jump and lands on Cuneo at town-reading zoom; selecting follow moves the map to the device position with the blue dot on it and changes the recentre button to match. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-10 21:47:20 +02:00
parent 06ab816ebe
commit b4b8d089e6
21 changed files with 2062 additions and 210 deletions
@@ -0,0 +1,211 @@
+import 'package:flutter/material.dart';
+import 'package:flutter_riverpod/flutter_riverpod.dart';
+
+import '../../core/region/region_config.dart';
+import '../../l10n/app_localizations.dart';
+import '../places/map_target.dart';
+import '../places/saved_place.dart';
+import '../places/saved_places.dart';
+
+/// Identifies an entry in the target menu.
+///
+/// A sealed value rather than a raw string so a typo cannot silently become a
+/// menu entry that does nothing.
+sealed class _TargetChoice {
+  const _TargetChoice();
+}
+
+class _ChooseFollow extends _TargetChoice {
+  const _ChooseFollow();
+}
+
+class _ChooseRegion extends _TargetChoice {
+  const _ChooseRegion();
+}
+
+class _ChoosePlace extends _TargetChoice {
+  const _ChoosePlace(this.place);
+  final SavedPlace place;
+}
+
+class _ChooseSearch extends _TargetChoice {
+  const _ChooseSearch();
+}
+
+class _ChooseManage extends _TargetChoice {
+  const _ChooseManage();
+}
+
+/// The target selector that sits over the top of the map.
+///
+/// Over the map rather than in the app bar because it is a map control: it
+/// changes what the map is looking at, and belongs next to the thing it acts on.
+class TargetSelector extends ConsumerWidget {
+  const TargetSelector({
+    required this.region,
+    required this.onFollowRequested,
+    required this.onSearch,
+    required this.onManagePlaces,
+    super.key,
+  });
+
+  final RegionConfig region;
+
+  /// Following needs location permission, and asking for it — with the
+  /// disclosure that has to come first — is not a menu's job. The screen that
+  /// owns the map handles it and only then changes the target.
+  final VoidCallback onFollowRequested;
+
+  final VoidCallback onSearch;
+  final VoidCallback onManagePlaces;
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final l10n = AppLocalizations.of(context);
+    final theme = Theme.of(context);
+    final target = ref.watch(mapTargetProvider);
+    final places = ref.watch(savedPlacesProvider).value ?? const <SavedPlace>[];
+
+    final label = switch (target) {
+      FollowUser() => l10n.targetFollowMe,
+      PlaceTarget(:final place) => place.name,
+      FreeTarget() => l10n.targetWholeRegion(region.displayName),
+    };
+
+    final icon = switch (target) {
+      FollowUser() => Icons.my_location,
+      PlaceTarget() => Icons.place,
+      FreeTarget() => Icons.map_outlined,
+    };
+
+    return Material(
+      elevation: 3,
+      borderRadius: BorderRadius.circular(24),
+      color: theme.colorScheme.surface,
+      child: PopupMenuButton<_TargetChoice>(
+        tooltip: l10n.targetChoose,
+        position: PopupMenuPosition.under,
+        onSelected: (choice) async {
+          switch (choice) {
+            case _ChooseFollow():
+              onFollowRequested();
+            case _ChooseRegion():
+              await ref
+                  .read(mapTargetProvider.notifier)
+                  .select(const FreeTarget());
+            case _ChoosePlace(:final place):
+              await ref
+                  .read(mapTargetProvider.notifier)
+                  .select(PlaceTarget(place));
+            case _ChooseSearch():
+              onSearch();
+            case _ChooseManage():
+              onManagePlaces();
+          }
+        },
+        itemBuilder: (context) => <PopupMenuEntry<_TargetChoice>>[
+          CheckedPopupMenuItem<_TargetChoice>(
+            value: const _ChooseFollow(),
+            checked: target is FollowUser,
+            child: Text(l10n.targetFollowMe),
+          ),
+          CheckedPopupMenuItem<_TargetChoice>(
+            value: const _ChooseRegion(),
+            checked: target is FreeTarget,
+            child: Text(l10n.targetWholeRegion(region.displayName)),
+          ),
+          if (places.isNotEmpty) const PopupMenuDivider(),
+          for (final place in places)
+            CheckedPopupMenuItem<_TargetChoice>(
+              value: _ChoosePlace(place),
+              checked: target is PlaceTarget && target.place.id == place.id,
+              child: Text(place.name, overflow: TextOverflow.ellipsis),
+            ),
+          const PopupMenuDivider(),
+          PopupMenuItem<_TargetChoice>(
+            value: const _ChooseSearch(),
+            child: ListTile(
+              dense: true,
+              contentPadding: EdgeInsets.zero,
+              leading: const Icon(Icons.search),
+              title: Text(l10n.searchTitle),
+            ),
+          ),
+          PopupMenuItem<_TargetChoice>(
+            value: const _ChooseManage(),
+            child: ListTile(
+              dense: true,
+              contentPadding: EdgeInsets.zero,
+              leading: const Icon(Icons.place_outlined),
+              title: Text(l10n.placesTitle),
+            ),
+          ),
+        ],
+        child: Padding(
+          padding: const EdgeInsets.symmetric(horizontal: 14, vertical: 10),
+          child: Row(
+            mainAxisSize: MainAxisSize.min,
+            children: [
+              Icon(icon, size: 18, color: theme.colorScheme.primary),
+              const SizedBox(width: 8),
+              Flexible(
+                child: Text(
+                  label,
+                  overflow: TextOverflow.ellipsis,
+                  style: theme.textTheme.titleSmall,
+                ),
+              ),
+              const SizedBox(width: 4),
+              const Icon(Icons.arrow_drop_down, size: 20),
+            ],
+          ),
+        ),
+      ),
+    );
+  }
+}
+
+/// Search and recentre, stacked over the right edge of the map.
+class MapActionButtons extends ConsumerWidget {
+  const MapActionButtons({
+    required this.onSearch,
+    required this.onRecentre,
+    super.key,
+  });
+
+  final VoidCallback onSearch;
+  final VoidCallback onRecentre;
+
+  @override
+  Widget build(BuildContext context, WidgetRef ref) {
+    final l10n = AppLocalizations.of(context);
+    final target = ref.watch(mapTargetProvider);
+
+    // The recentre button says what it will do. Following but panned away is
+    // the case that matters: the icon has to promise the blue dot, not a place.
+    final recentreIcon = switch (target) {
+      FollowUser() => Icons.my_location,
+      PlaceTarget() => Icons.place,
+      FreeTarget() => Icons.zoom_out_map,
+    };
+
+    return Column(
+      mainAxisSize: MainAxisSize.min,
+      children: [
+        FloatingActionButton.small(
+          heroTag: 'nuvolari-search',
+          tooltip: l10n.searchOpen,
+          onPressed: onSearch,
+          child: const Icon(Icons.search),
+        ),
+        const SizedBox(height: 10),
+        FloatingActionButton.small(
+          heroTag: 'nuvolari-recentre',
+          tooltip: l10n.mapCentreOnTarget,
+          onPressed: onRecentre,
+          child: Icon(recentreIcon),
+        ),
+      ],
+    );
+  }
+}