Riorganizza verticalmente il pannello layer

LMEMappeCatastaliApp.csproj

@@ -28,8 +28,8 @@
         <ApplicationId>com.companyname.lmemappecatastaliapp</ApplicationId>
 
         <!-- Versions -->
-        <ApplicationDisplayVersion>0.2.2</ApplicationDisplayVersion>
-        <ApplicationVersion>6</ApplicationVersion>
+        <ApplicationDisplayVersion>0.2.26</ApplicationDisplayVersion>
+        <ApplicationVersion>30</ApplicationVersion>
 
         <!-- To develop, package, and publish an app to the Microsoft Store, see: https://aka.ms/MauiTemplateUnpackaged -->
         <WindowsPackageType>None</WindowsPackageType>
@@ -44,7 +44,7 @@
 
     <ItemGroup>
         <!-- App Icon -->
-        <MauiIcon Include="Resources\AppIcon\appicon.svg" ForegroundFile="Resources\AppIcon\appiconfg.svg" Color="#512BD4" />
+        <MauiIcon Include="Resources\AppIcon\appicon.svg" ForegroundFile="Resources\AppIcon\appiconfg.svg" Color="#075E54" />
 
         <!-- Splash Screen -->
         <MauiSplashScreen Include="Resources\Splash\splash.svg" Color="#512BD4" BaseSize="128,128" />

MauiProgram.cs

@@ -20,6 +20,10 @@ public static class MauiProgram
         builder.Services.AddSingleton<CadastralCatalogService>();
         builder.Services.AddSingleton<OfficialCadastreService>();
         builder.Services.AddSingleton<LocationSearchService>();
+        builder.Services.AddSingleton<NetworkLocationService>();
+        builder.Services.AddSingleton<AzureMapsService>();
+        builder.Services.AddSingleton<ProjectStorageService>();
+        builder.Services.AddSingleton<MapExportService>();
 
 #if DEBUG
         builder.Services.AddBlazorWebViewDeveloperTools();

README.md

@@ -4,26 +4,41 @@ App .NET MAUI Blazor Hybrid per Android, iOS, Mac Catalyst e Windows, pensata pe
 
 ## Funzioni gia implementate
 
-- Mappa interattiva Leaflet con sfondi Esri, OpenStreetMap, OpenTopoMap, CARTO Voyager e Google Maps configurabile tramite API key.
+- Mappa interattiva Leaflet con sfondi Esri, OpenStreetMap, OpenTopoMap, CARTO Voyager, Google Maps e Azure Maps configurabili tramite chiave.
 - Layer WMS ufficiale Agenzia delle Entrate: particelle, numeri particella, fogli, fabbricati, strade e acque.
 - Trasparenza configurabile del layer catastale.
 - Interrogazione WMS con click/tap sulla mappa.
 - Import di file KML, KMZ, GeoJSON e JSON.
+- Import GeoJSON compatibile con BOM, geometrie singole, array, FeatureCollection e coordinate Web Mercator EPSG:3857.
+- Filtro KML/KMZ `solo particelle` attivo per impostazione predefinita, con separazione dei MultiPolygon ed esclusione di GroundOverlay e perimetri del foglio; il layer foglio resta importabile e puo essere mostrato o nascosto separatamente.
+- Migrazione automatica dei vecchi progetti: i GroundOverlay `DOC_...` salvati in precedenza insieme alle particelle vengono riconosciuti, separati e nascosti in tempo reale dal relativo check.
 - Inquadramento e pulizia dei layer importati.
 - Disegno di marker, linee, poligoni e rettangoli.
+- Area, Distanza e Cerchio disponibili nella barra Leaflet laterale, nascosta all'avvio e controllata dal pulsante nel tab Dati insieme agli altri strumenti.
+- Misure permanenti attivabili anche sui layer importati da KML, KMZ e GeoJSON.
 - Toolbar di disegno completa di icone, modifica, eliminazione singola e pulizia di tutti i disegni/POI.
-- POI/progetti salvabili in locale con `localStorage`.
+- Archivio multiprogetto nella cartella privata dell'app, con nome, selezione da elenco, sovrascrittura ed eliminazione.
+- Tab distinti `Progetti` e `Salvataggio`: il primo gestisce archivio e opzioni live di visualizzazione, il secondo esporta selettivamente l'intera mappa in GeoJSON, KML o KMZ.
+- Ogni progetto salva file GIS, POI, disegni, traccia, inquadratura e tutte le opzioni di visualizzazione: sfondo, layer catastali, trasparenza, misure, foglio importato, barra strumenti e preferenze GPS.
 - GPS nativo MAUI ad alta precisione con permessi Android/iOS.
+- Centratura automatica una tantum all'apertura: prima tramite posizione approssimativa della connessione Internet, poi tramite singola lettura GPS se la rete non restituisce una posizione; nessun punto o cerchio viene mostrato e il tracking continuo non viene avviato.
+- Punto e cerchio di precisione del GPS live possono essere mostrati o nascosti dalle impostazioni senza fermare il rilevamento.
 - Marker posizione, cerchio accuratezza in metri, tracciamento percorso.
 - Controllo se la posizione GPS cade dentro un poligono importato o disegnato.
 - Interrogazione WFS ufficiale Agenzia delle Entrate attorno alla posizione GPS per evidenziare la particella catastale corrente quando il servizio restituisce la geometria.
-- Mappa a tutto schermo con tab Catasto, Progetti e Impostazioni, adattabile agli schermi pieghevoli.
+- Mappa a tutto schermo con tab separati Catasto, Dati, Salvataggio e Impostazioni, adattabile agli schermi pieghevoli.
 - Ingrandimento oltre lo zoom satellitare nativo senza tessere "Map data not yet available".
 - Tendine concatenate Regione, Comune, Foglio e Particella.
 - Ricerca di localita e indirizzi eseguita nativamente con fallback Esri e OpenStreetMap, senza richieste CORS dalla WebView.
 - Catalogo dei Comuni incluso nell'APK e cataloghi regionali OnData scaricati in cache solo quando servono.
 - Ricerca catastale eseguita dal codice .NET nativo, senza DuckDB WebAssembly nella WebView Android.
-- La registrazione della traccia GPS e' disattivata all'avvio; la toolbar di disegno puo' essere mostrata o nascosta dal tab Progetti.
+- La registrazione della traccia GPS e' disattivata all'avvio; la toolbar di disegno completa puo' essere mostrata o nascosta dal tab Dati.
+- Pannello `Layer` accessibile direttamente dalla mappa, con checkbox sincronizzati per confini, numeri particella, fogli, fabbricati, strade e acque.
+- Le particelle cercate possono essere aggiunte una dopo l'altra, mantenendo contemporaneamente sulla mappa tutti i confini selezionati.
+- Comandi separati per rimuovere le particelle selezionate o pulire importazioni, disegni, POI e traccia GPS.
+- Anteprima WMS ufficiale mostrata dentro l'app senza aprire una nuova finestra Android.
+- Confini delle particelle selezionate e della particella GPS sovrapposti anche all'anteprima WMS corrente.
+- Richieste WMS catastali in EPSG:4258 compatibili con il servizio AdE; i numeri particella sono visibili alle scale di dettaglio consentite dal servizio (circa zoom 17 o superiore).
 - Collegamenti separati al Geoportale pubblico e all'Area riservata AdE per CAPTCHA, SPID/CIE e download ufficiali.
 
 ## Limite ufficiale AdE da considerare
@@ -38,6 +53,21 @@ Questo passaggio e' implementato nel tab `Catasto`. Regione e Comune sono dispon
 
 I layer cartografici pubblici WMS/WFS sono open data e non richiedono CAPTCHA. Il CAPTCHA o l'autenticazione SPID/CIE appartengono ai servizi web di consultazione e download documentale: l'app li apre nel sito ufficiale dell'Agenzia e non tenta di aggirarli.
 
+## Azure Maps Gen2
+
+Nel tab `Impostazioni` sono disponibili gli sfondi `Strade - Azure Maps` e `Satellite - Azure Maps`. Per usarli:
+
+1. crea una risorsa Azure Maps con piano Gen2 nel portale Azure;
+2. copia una delle chiavi di sottoscrizione della risorsa;
+3. inseriscila in `Chiave sottoscrizione Azure Maps Gen2` e premi `Salva chiave Azure Maps`.
+
+La chiave viene validata prima del salvataggio e rimane nel `SecureStorage` del dispositivo; non e' inclusa nel codice o nell'APK. Lasciando vuoto il campo e premendo il pulsante, la chiave viene rimossa.
+
+La quota gratuita mensile Gen2 indicata da Microsoft comprende 5.000 transazioni per le mappe di base e 1.000 per le immagini satellitari. Una transazione raggruppa fino a 15 richieste di tessere. Oltre la quota si applicano le condizioni economiche della sottoscrizione Azure, quindi e' opportuno configurare budget e avvisi nel portale.
+
+- Creazione account e autenticazione: https://learn.microsoft.com/azure/azure-maps/how-to-manage-account-keys
+- Prezzi e quota gratuita: https://azure.microsoft.com/pricing/details/azure-maps/
+
 ## Aprire in Visual Studio
 
 Apri `LMEMappeCatastaliApp.csproj` con Visual Studio 2022/2026 e seleziona:

Resources/AppIcon/appicon.svg

@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg width="456" height="456" viewBox="0 0 456 456" version="1.1" xmlns="http://www.w3.org/2000/svg">
-    <rect x="0" y="0" width="456" height="456" fill="#512BD4" />
-</svg>
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="456" height="456" viewBox="0 0 456 456" xmlns="http://www.w3.org/2000/svg">
+    <rect width="456" height="456" fill="#075E54" />
+</svg>

Resources/AppIcon/appiconfg.svg

@@ -1,8 +1,13 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">
-<svg width="456" height="456" viewBox="0 0 456 456" version="1.1" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" xml:space="preserve" xmlns:serif="http://www.serif.com/" style="fill-rule:evenodd;clip-rule:evenodd;stroke-linejoin:round;stroke-miterlimit:2;">
-    <path d="m 105.50037,281.60863 c -2.70293,0 -5.00091,-0.90042 -6.893127,-2.70209 -1.892214,-1.84778 -2.837901,-4.04181 -2.837901,-6.58209 0,-2.58722 0.945687,-4.80389 2.837901,-6.65167 1.892217,-1.84778 4.190197,-2.77167 6.893127,-2.77167 2.74819,0 5.06798,0.92389 6.96019,2.77167 1.93749,1.84778 2.90581,4.06445 2.90581,6.65167 0,2.54028 -0.96832,4.73431 -2.90581,6.58209 -1.89221,1.80167 -4.212,2.70209 -6.96019,2.70209 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
-    <path d="M 213.56111,280.08446 H 195.99044 L 149.69953,207.0544 c -1.17121,-1.84778 -2.14037,-3.76515 -2.90581,-5.75126 h -0.40578 c 0.36051,2.12528 0.54076,6.67515 0.54076,13.6496 v 65.13172 h -15.54349 v -99.36009 h 18.71925 l 44.7374,71.29798 c 1.89222,2.95695 3.1087,4.98917 3.64945,6.09751 h 0.26996 c -0.45021,-2.6325 -0.67573,-7.09015 -0.67573,-13.37293 v -64.02256 h 15.47557 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
-    <path d="m 289.25134,280.08446 h -54.40052 v -99.36009 h 52.23835 v 13.99669 h -36.15411 v 28.13085 h 33.31621 v 13.9271 h -33.31621 v 29.37835 h 38.31628 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
-    <path d="M 366.56466,194.72106 H 338.7222 v 85.3634 h -16.08423 v -85.3634 h -27.77455 v -13.99669 h 71.70124 z" style="fill:#ffffff;fill-rule:nonzero;stroke-width:0.838376" />
-</svg>
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="456" height="456" viewBox="0 0 456 456" xmlns="http://www.w3.org/2000/svg">
+    <g stroke-linecap="round" stroke-linejoin="round">
+        <path d="M105 150L183 119L273 151L351 120V307L273 338L183 306L105 337Z"
+              fill="#F7FAF5" stroke="#E1ECE5" stroke-width="10" />
+        <path d="M183 119V306M273 151V338" fill="none" stroke="#83B6A5" stroke-width="10" />
+        <path d="M125 190L162 175M124 274L160 260M293 196L330 181M295 282L330 268"
+              fill="none" stroke="#A9CDBE" stroke-width="9" />
+        <path d="M228 104C188 104 157 135 157 175C157 225 228 294 228 294C228 294 299 225 299 175C299 135 268 104 228 104Z"
+              fill="#F97316" stroke="#FFFFFF" stroke-width="12" />
+        <circle cx="228" cy="175" r="24" fill="#FFFFFF" />
+    </g>
+</svg>

Services/AzureMapsService.cs

@@ -0,0 +1,53 @@
+using System.Text.Json;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class AzureMapsService
+{
+    private const string TilesetEndpoint = "https://atlas.microsoft.com/map/tileset";
+    private readonly HttpClient _httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(20)
+    };
+    private string? _validatedKey;
+
+    public AzureMapsService()
+    {
+        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2.22");
+        _httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/json");
+    }
+
+    public async Task ValidateKeyAsync(string subscriptionKey, CancellationToken cancellationToken = default)
+    {
+        var key = subscriptionKey.Trim();
+        if (string.IsNullOrWhiteSpace(key))
+        {
+            throw new ArgumentException("Chiave Azure Maps mancante.", nameof(subscriptionKey));
+        }
+
+        if (string.Equals(_validatedKey, key, StringComparison.Ordinal))
+        {
+            return;
+        }
+
+        var url = $"{TilesetEndpoint}?api-version=2024-04-01&tilesetId=microsoft.base.road";
+        using var request = new HttpRequestMessage(HttpMethod.Get, url);
+        request.Headers.Add("subscription-key", key);
+        using var response = await _httpClient.SendAsync(request, cancellationToken);
+        if (!response.IsSuccessStatusCode)
+        {
+            throw new InvalidOperationException(response.StatusCode is System.Net.HttpStatusCode.Unauthorized or System.Net.HttpStatusCode.Forbidden
+                ? "Chiave Azure Maps non valida o priva dei permessi Render."
+                : $"Azure Maps ha risposto {((int)response.StatusCode)}.");
+        }
+
+        await using var content = await response.Content.ReadAsStreamAsync(cancellationToken);
+        using var payload = await JsonDocument.ParseAsync(content, cancellationToken: cancellationToken);
+        if (!payload.RootElement.TryGetProperty("tiles", out _))
+        {
+            throw new InvalidDataException("Azure Maps ha restituito una configurazione non valida.");
+        }
+
+        _validatedKey = key;
+    }
+}

Services/MapExportService.cs

@@ -0,0 +1,257 @@
+using System.Globalization;
+using System.IO.Compression;
+using System.Text;
+using System.Text.Json;
+using System.Xml.Linq;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class MapExportService
+{
+    private static readonly XNamespace Kml = "http://www.opengis.net/kml/2.2";
+
+    public async Task<MapExportFile> CreateAsync(
+        string requestedName,
+        string requestedFormat,
+        string geoJson,
+        CancellationToken cancellationToken = default)
+    {
+        using var document = JsonDocument.Parse(geoJson);
+        var root = document.RootElement;
+        if (!root.TryGetProperty("type", out var type) || type.GetString() != "FeatureCollection"
+            || !root.TryGetProperty("features", out var features)
+            || features.ValueKind != JsonValueKind.Array)
+        {
+            throw new InvalidDataException("I dati raccolti dalla mappa non sono validi.");
+        }
+
+        var featureCount = features.GetArrayLength();
+        if (featureCount == 0)
+        {
+            throw new InvalidOperationException("Nessun oggetto selezionato e disponibile da esportare.");
+        }
+
+        var format = requestedFormat.Trim().ToLowerInvariant() switch
+        {
+            "kml" => "kml",
+            "kmz" => "kmz",
+            _ => "geojson"
+        };
+        var baseName = NormalizeFileName(requestedName);
+        var exportDirectory = Path.Combine(FileSystem.CacheDirectory, "Exports");
+        Directory.CreateDirectory(exportDirectory);
+        var path = Path.Combine(exportDirectory, $"{baseName}.{format}");
+
+        if (format == "geojson")
+        {
+            using var output = File.Create(path);
+            await JsonSerializer.SerializeAsync(output, root, new JsonSerializerOptions { WriteIndented = true }, cancellationToken);
+            return new(path, "application/geo+json", featureCount, Path.GetFileName(path));
+        }
+
+        var kml = BuildKml(features, baseName);
+        if (format == "kml")
+        {
+            await File.WriteAllTextAsync(path, kml, new UTF8Encoding(false), cancellationToken);
+            return new(path, "application/vnd.google-earth.kml+xml", featureCount, Path.GetFileName(path));
+        }
+
+        await using (var output = File.Create(path))
+        using (var archive = new ZipArchive(output, ZipArchiveMode.Create))
+        {
+            var entry = archive.CreateEntry("doc.kml", CompressionLevel.Optimal);
+            await using var entryStream = entry.Open();
+            await using var writer = new StreamWriter(entryStream, new UTF8Encoding(false));
+            await writer.WriteAsync(kml.AsMemory(), cancellationToken);
+        }
+        return new(path, "application/vnd.google-earth.kmz", featureCount, Path.GetFileName(path));
+    }
+
+    private static string BuildKml(JsonElement features, string documentName)
+    {
+        var document = new XElement(Kml + "Document",
+            new XElement(Kml + "name", documentName),
+            BuildStyle("imported", "ff2ecc71", "402ecc71"),
+            BuildStyle("imported-sheet", "ff22803d", "1022803d"),
+            BuildStyle("cadastral", "ff4444ef", "4224bffb"),
+            BuildStyle("cadastral-gps", "ffff7a00", "337aff00"),
+            BuildStyle("drawing", "ff1679f9", "333c92fb"),
+            BuildStyle("poi", "ffff7a00", "33ff7a00"),
+            BuildStyle("gps-trail", "ff00a5ff", "2200a5ff"));
+        var categoryFolders = new Dictionary<string, XElement>(StringComparer.Ordinal);
+        var groupFolders = new Dictionary<(string Category, string Group), XElement>();
+
+        foreach (var feature in features.EnumerateArray())
+        {
+            if (!feature.TryGetProperty("geometry", out var geometry)
+                || geometry.ValueKind is JsonValueKind.Null or JsonValueKind.Undefined)
+            {
+                continue;
+            }
+
+            var properties = feature.TryGetProperty("properties", out var propertyElement)
+                && propertyElement.ValueKind == JsonValueKind.Object
+                ? propertyElement
+                : default;
+            var category = GetString(properties, "_lmeCategory") ?? "drawing";
+            var placemark = new XElement(Kml + "Placemark",
+                new XElement(Kml + "name", FeatureName(properties, category)),
+                new XElement(Kml + "styleUrl", $"#{NormalizeStyleId(category)}"));
+
+            var extendedData = BuildExtendedData(properties);
+            if (extendedData is not null)
+            {
+                placemark.Add(extendedData);
+            }
+            placemark.Add(BuildGeometry(geometry));
+            var categoryName = GetString(properties, "_lmeCategoryName")?.Trim();
+            var groupName = GetString(properties, "_lmeGroupName")?.Trim();
+            var parent = document;
+            if (!string.IsNullOrWhiteSpace(categoryName))
+            {
+                if (!categoryFolders.TryGetValue(categoryName, out var categoryFolder))
+                {
+                    categoryFolder = new XElement(Kml + "Folder", new XElement(Kml + "name", categoryName));
+                    categoryFolders[categoryName] = categoryFolder;
+                    document.Add(categoryFolder);
+                }
+                parent = categoryFolder;
+            }
+            if (!string.IsNullOrWhiteSpace(groupName))
+            {
+                var key = (categoryName ?? string.Empty, groupName);
+                if (!groupFolders.TryGetValue(key, out var groupFolder))
+                {
+                    groupFolder = new XElement(Kml + "Folder", new XElement(Kml + "name", groupName));
+                    groupFolders[key] = groupFolder;
+                    parent.Add(groupFolder);
+                }
+                parent = groupFolder;
+            }
+            parent.Add(placemark);
+        }
+
+        return new XDocument(new XDeclaration("1.0", "utf-8", null), new XElement(Kml + "kml", document)).ToString();
+    }
+
+    private static XElement BuildStyle(string id, string lineColor, string fillColor) =>
+        new(Kml + "Style",
+            new XAttribute("id", id),
+            new XElement(Kml + "LineStyle",
+                new XElement(Kml + "color", lineColor),
+                new XElement(Kml + "width", 3)),
+            new XElement(Kml + "PolyStyle", new XElement(Kml + "color", fillColor)));
+
+    private static XElement? BuildExtendedData(JsonElement properties)
+    {
+        if (properties.ValueKind != JsonValueKind.Object)
+        {
+            return null;
+        }
+
+        var data = properties.EnumerateObject()
+            .Where(item => item.Name != "_lmeCategory"
+                && item.Value.ValueKind is JsonValueKind.String or JsonValueKind.Number or JsonValueKind.True or JsonValueKind.False)
+            .Select(item => new XElement(Kml + "Data",
+                new XAttribute("name", item.Name),
+                new XElement(Kml + "value", ScalarText(item.Value))))
+            .ToArray();
+        return data.Length == 0 ? null : new XElement(Kml + "ExtendedData", data);
+    }
+
+    private static XElement BuildGeometry(JsonElement geometry)
+    {
+        var type = geometry.GetProperty("type").GetString();
+        if (type == "GeometryCollection")
+        {
+            return new XElement(Kml + "MultiGeometry",
+                geometry.GetProperty("geometries").EnumerateArray().Select(BuildGeometry));
+        }
+
+        var coordinates = geometry.GetProperty("coordinates");
+        return type switch
+        {
+            "Point" => new XElement(Kml + "Point", CoordinatesElement([coordinates])),
+            "LineString" => new XElement(Kml + "LineString", CoordinatesElement(coordinates.EnumerateArray())),
+            "Polygon" => BuildPolygon(coordinates),
+            "MultiPoint" => new XElement(Kml + "MultiGeometry",
+                coordinates.EnumerateArray().Select(point => new XElement(Kml + "Point", CoordinatesElement([point])))),
+            "MultiLineString" => new XElement(Kml + "MultiGeometry",
+                coordinates.EnumerateArray().Select(line => new XElement(Kml + "LineString", CoordinatesElement(line.EnumerateArray())))),
+            "MultiPolygon" => new XElement(Kml + "MultiGeometry", coordinates.EnumerateArray().Select(BuildPolygon)),
+            _ => throw new InvalidDataException($"Geometria GeoJSON non supportata: {type}.")
+        };
+    }
+
+    private static XElement BuildPolygon(JsonElement rings)
+    {
+        var ringList = rings.EnumerateArray().ToArray();
+        var polygon = new XElement(Kml + "Polygon");
+        if (ringList.Length > 0)
+        {
+            polygon.Add(new XElement(Kml + "outerBoundaryIs",
+                new XElement(Kml + "LinearRing", CoordinatesElement(ringList[0].EnumerateArray()))));
+        }
+        foreach (var ring in ringList.Skip(1))
+        {
+            polygon.Add(new XElement(Kml + "innerBoundaryIs",
+                new XElement(Kml + "LinearRing", CoordinatesElement(ring.EnumerateArray()))));
+        }
+        return polygon;
+    }
+
+    private static XElement CoordinatesElement(IEnumerable<JsonElement> points) =>
+        new(Kml + "coordinates", string.Join(" ", points.Select(FormatCoordinate)));
+
+    private static string FormatCoordinate(JsonElement coordinate)
+    {
+        var values = coordinate.EnumerateArray().Take(3)
+            .Select(value => value.GetDouble().ToString("G17", CultureInfo.InvariantCulture));
+        return string.Join(",", values);
+    }
+
+    private static string FeatureName(JsonElement properties, string category) =>
+        GetString(properties, "name")
+        ?? GetString(properties, "Name")
+        ?? GetString(properties, "LABEL")
+        ?? GetString(properties, "NATIONALCADASTRALREFERENCE")
+        ?? category switch
+        {
+            "imported-sheet" => "Cornice o foglio importato",
+            "cadastral" => "Particella catastale",
+            "cadastral-gps" => "Particella GPS",
+            "poi" => "Punto di interesse",
+            "gps-trail" => "Traccia GPS",
+            _ => "Oggetto mappa"
+        };
+
+    private static string? GetString(JsonElement element, string name) =>
+        element.ValueKind == JsonValueKind.Object
+        && element.TryGetProperty(name, out var value)
+        && value.ValueKind == JsonValueKind.String
+            ? value.GetString()
+            : null;
+
+    private static string ScalarText(JsonElement value) => value.ValueKind == JsonValueKind.String
+        ? value.GetString() ?? string.Empty
+        : value.GetRawText();
+
+    private static string NormalizeStyleId(string category) => category switch
+    {
+        "imported" or "imported-sheet" or "cadastral" or "cadastral-gps" or "drawing" or "poi" or "gps-trail" => category,
+        _ => "drawing"
+    };
+
+    private static string NormalizeFileName(string requestedName)
+    {
+        var name = string.IsNullOrWhiteSpace(requestedName) ? "Mappa" : requestedName.Trim();
+        foreach (var invalid in Path.GetInvalidFileNameChars())
+        {
+            name = name.Replace(invalid, '_');
+        }
+        name = Path.GetFileNameWithoutExtension(name).Trim().TrimEnd('.');
+        return string.IsNullOrWhiteSpace(name) ? "Mappa" : name[..Math.Min(name.Length, 80)];
+    }
+}
+
+public sealed record MapExportFile(string Path, string MimeType, int FeatureCount, string FileName);

Services/NetworkLocationService.cs

@@ -0,0 +1,74 @@
+using System.Net.Http.Json;
+using System.Text.Json.Serialization;
+using Microsoft.Maui.Networking;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class NetworkLocationService
+{
+    private readonly HttpClient httpClient = new()
+    {
+        Timeout = TimeSpan.FromSeconds(6)
+    };
+
+    public NetworkLocationService()
+    {
+        httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2.22");
+    }
+
+    public async Task<NetworkLocationSnapshot?> GetApproximateLocationAsync(
+        CancellationToken cancellationToken = default)
+    {
+        if (Connectivity.Current.NetworkAccess != NetworkAccess.Internet)
+        {
+            return null;
+        }
+
+        using var response = await httpClient.GetAsync("https://ipapi.co/json/", cancellationToken);
+        if (!response.IsSuccessStatusCode)
+        {
+            return null;
+        }
+
+        var result = await response.Content.ReadFromJsonAsync<IpLocationResponse>(cancellationToken);
+        if (result is null
+            || result.Error == true
+            || !result.Latitude.HasValue
+            || !result.Longitude.HasValue
+            || Math.Abs(result.Latitude.Value) > 90
+            || Math.Abs(result.Longitude.Value) > 180)
+        {
+            return null;
+        }
+
+        var labelParts = new[] { result.City, result.Region, result.CountryName }
+            .Where(value => !string.IsNullOrWhiteSpace(value));
+        return new NetworkLocationSnapshot(
+            result.Latitude.Value,
+            result.Longitude.Value,
+            string.Join(", ", labelParts));
+    }
+
+    private sealed class IpLocationResponse
+    {
+        [JsonPropertyName("latitude")]
+        public double? Latitude { get; init; }
+
+        [JsonPropertyName("longitude")]
+        public double? Longitude { get; init; }
+
+        [JsonPropertyName("city")]
+        public string? City { get; init; }
+
+        [JsonPropertyName("region")]
+        public string? Region { get; init; }
+
+        [JsonPropertyName("country_name")]
+        public string? CountryName { get; init; }
+
+        [JsonPropertyName("error")]
+        public bool? Error { get; init; }
+    }
+}
+
+public sealed record NetworkLocationSnapshot(double Latitude, double Longitude, string Label);

Services/PreciseLocationService.cs

@@ -20,6 +20,37 @@ public sealed class PreciseLocationService : IAsyncDisposable
         return status;
     }
 
+    public async Task<LocationSnapshot?> GetCurrentLocationAsync(CancellationToken cancellationToken = default)
+    {
+        var permission = await EnsurePermissionAsync();
+        if (permission != PermissionStatus.Granted)
+        {
+            return null;
+        }
+
+        Location? location = null;
+        try
+        {
+            var request = new GeolocationRequest(GeolocationAccuracy.Best, TimeSpan.FromSeconds(8));
+            location = await Geolocation.Default.GetLocationAsync(request, cancellationToken);
+        }
+        catch (FeatureNotSupportedException)
+        {
+            return null;
+        }
+
+        if (location is null)
+        {
+            var lastKnown = await Geolocation.Default.GetLastKnownLocationAsync();
+            if (lastKnown is not null && lastKnown.Timestamp >= DateTimeOffset.UtcNow.AddMinutes(-15))
+            {
+                location = lastKnown;
+            }
+        }
+
+        return location is null ? null : ToSnapshot(location);
+    }
+
     public async Task StartTrackingAsync(Func<LocationSnapshot, Task> onLocation, Func<string, Task> onError)
     {
         if (trackingCancellation is not null)
@@ -47,14 +78,7 @@ public sealed class PreciseLocationService : IAsyncDisposable
                     var location = await Geolocation.Default.GetLocationAsync(request, token);
                     if (location is not null)
                     {
-                        await onLocation(new LocationSnapshot(
-                            location.Latitude,
-                            location.Longitude,
-                            location.Accuracy,
-                            location.Altitude,
-                            location.Course,
-                            location.Speed,
-                            location.Timestamp));
+                        await onLocation(ToSnapshot(location));
                     }
                 }
                 catch (OperationCanceledException)
@@ -84,6 +108,15 @@ public sealed class PreciseLocationService : IAsyncDisposable
         StopTracking();
         return ValueTask.CompletedTask;
     }
+
+    private static LocationSnapshot ToSnapshot(Location location) => new(
+        location.Latitude,
+        location.Longitude,
+        location.Accuracy,
+        location.Altitude,
+        location.Course,
+        location.Speed,
+        location.Timestamp);
 }
 
 public sealed record LocationSnapshot(

Services/ProjectStorageService.cs

@@ -0,0 +1,202 @@
+using System.Text;
+using System.Text.Json;
+
+namespace LMEMappeCatastaliApp.Services;
+
+public sealed class ProjectStorageService
+{
+    private const string ProjectExtension = ".lmeproject.json";
+    private readonly SemaphoreSlim _gate = new(1, 1);
+    private readonly JsonSerializerOptions _jsonOptions = new(JsonSerializerDefaults.Web)
+    {
+        WriteIndented = true
+    };
+
+    private string ProjectsDirectory => Path.Combine(FileSystem.AppDataDirectory, "Projects");
+
+    public async Task<IReadOnlyList<MapProjectSummary>> GetProjectsAsync()
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            var files = await ReadProjectFilesAsync();
+            return files
+                .Select(item => item.Document.ToSummary())
+                .OrderByDescending(item => item.UpdatedAt)
+                .ThenBy(item => item.Name, StringComparer.CurrentCultureIgnoreCase)
+                .ToArray();
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+
+    public async Task<MapProjectSummary> SaveAsync(
+        string name,
+        string snapshotJson,
+        bool includesCadastralParcels,
+        string? projectId = null)
+    {
+        var normalizedName = NormalizeName(name);
+        using var snapshotDocument = JsonDocument.Parse(snapshotJson);
+        if (snapshotDocument.RootElement.ValueKind != JsonValueKind.Object)
+        {
+            throw new InvalidDataException("I dati della mappa non sono validi.");
+        }
+
+        await _gate.WaitAsync();
+        try
+        {
+            Directory.CreateDirectory(ProjectsDirectory);
+            var files = await ReadProjectFilesAsync();
+            var existing = files.FirstOrDefault(item =>
+                (!string.IsNullOrWhiteSpace(projectId) && item.Document.Id == projectId)
+                || string.Equals(item.Document.Name, normalizedName, StringComparison.CurrentCultureIgnoreCase));
+
+            var now = DateTimeOffset.UtcNow;
+            var id = existing?.Document.Id ?? Guid.NewGuid().ToString("N");
+            var document = new MapProjectDocument
+            {
+                SchemaVersion = 1,
+                Id = id,
+                Name = normalizedName,
+                CreatedAt = existing?.Document.CreatedAt ?? now,
+                UpdatedAt = now,
+                IncludesCadastralParcels = includesCadastralParcels,
+                Map = snapshotDocument.RootElement.Clone()
+            };
+
+            var path = existing?.Path ?? Path.Combine(ProjectsDirectory, BuildFileName(normalizedName, id));
+            var temporaryPath = path + ".tmp";
+            try
+            {
+                await File.WriteAllTextAsync(
+                    temporaryPath,
+                    JsonSerializer.Serialize(document, _jsonOptions),
+                    new UTF8Encoding(false));
+                File.Move(temporaryPath, path, true);
+            }
+            finally
+            {
+                if (File.Exists(temporaryPath))
+                {
+                    File.Delete(temporaryPath);
+                }
+            }
+
+            return document.ToSummary();
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+
+    public async Task<string> LoadAsync(string projectId)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            var project = (await ReadProjectFilesAsync())
+                .FirstOrDefault(item => item.Document.Id == projectId)
+                ?? throw new FileNotFoundException("Il progetto selezionato non esiste piu'.");
+            return project.Document.Map.GetRawText();
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+
+    public async Task DeleteAsync(string projectId)
+    {
+        await _gate.WaitAsync();
+        try
+        {
+            var project = (await ReadProjectFilesAsync())
+                .FirstOrDefault(item => item.Document.Id == projectId)
+                ?? throw new FileNotFoundException("Il progetto selezionato non esiste piu'.");
+            File.Delete(project.Path);
+        }
+        finally
+        {
+            _gate.Release();
+        }
+    }
+
+    private async Task<IReadOnlyList<ProjectFileEntry>> ReadProjectFilesAsync()
+    {
+        Directory.CreateDirectory(ProjectsDirectory);
+        var projects = new List<ProjectFileEntry>();
+        foreach (var path in Directory.EnumerateFiles(ProjectsDirectory, $"*{ProjectExtension}"))
+        {
+            try
+            {
+                await using var stream = File.OpenRead(path);
+                var document = await JsonSerializer.DeserializeAsync<MapProjectDocument>(stream, _jsonOptions);
+                if (document is not null
+                    && !string.IsNullOrWhiteSpace(document.Id)
+                    && !string.IsNullOrWhiteSpace(document.Name)
+                    && document.Map.ValueKind == JsonValueKind.Object)
+                {
+                    projects.Add(new ProjectFileEntry(path, document));
+                }
+            }
+            catch (JsonException)
+            {
+                // A damaged project is ignored so the remaining archive stays usable.
+            }
+            catch (IOException)
+            {
+            }
+        }
+
+        return projects;
+    }
+
+    private static string NormalizeName(string name)
+    {
+        var normalized = string.Join(' ', (name ?? string.Empty).Split(
+            [' ', '\t', '\r', '\n'],
+            StringSplitOptions.RemoveEmptyEntries));
+        if (string.IsNullOrWhiteSpace(normalized))
+        {
+            throw new ArgumentException("Inserisci il nome del progetto.");
+        }
+
+        return normalized.Length <= 80 ? normalized : normalized[..80];
+    }
+
+    private static string BuildFileName(string name, string id)
+    {
+        var invalid = Path.GetInvalidFileNameChars().ToHashSet();
+        var safeName = new string(name
+            .Select(character => invalid.Contains(character) ? '-' : character)
+            .ToArray())
+            .Trim(' ', '.');
+        safeName = string.IsNullOrWhiteSpace(safeName) ? "Progetto" : safeName;
+        return $"{safeName}--{id[..8]}{ProjectExtension}";
+    }
+
+    private sealed record ProjectFileEntry(string Path, MapProjectDocument Document);
+
+    private sealed class MapProjectDocument
+    {
+        public int SchemaVersion { get; init; }
+        public string Id { get; init; } = string.Empty;
+        public string Name { get; init; } = string.Empty;
+        public DateTimeOffset CreatedAt { get; init; }
+        public DateTimeOffset UpdatedAt { get; init; }
+        public bool IncludesCadastralParcels { get; init; }
+        public JsonElement Map { get; init; }
+
+        public MapProjectSummary ToSummary() => new(Id, Name, UpdatedAt, IncludesCadastralParcels);
+    }
+}
+
+public sealed record MapProjectSummary(
+    string Id,
+    string Name,
+    DateTimeOffset UpdatedAt,
+    bool IncludesCadastralParcels);

wwwroot/css/app.css

@@ -124,6 +124,28 @@ input[type="checkbox"] {
     color: var(--ink);
 }
 
+.toolbar-actions,
+.layer-button {
+    display: flex;
+    align-items: center;
+    gap: 7px;
+}
+
+.toolbar-actions {
+    flex: 0 0 auto;
+}
+
+.layer-button.is-active {
+    background: #ccebe3;
+    color: var(--accent-strong);
+}
+
+.layer-symbol {
+    width: 20px;
+    height: 20px;
+    background: url("../lib/leaflet/images/layers.png") center / contain no-repeat;
+}
+
 .map-search {
     position: absolute;
     top: 72px;
@@ -150,6 +172,278 @@ input[type="checkbox"] {
     transform: translateY(0);
 }
 
+.map-layer-panel {
+    position: absolute;
+    top: 72px;
+    right: 12px;
+    bottom: calc(var(--nav-height) + 8px);
+    z-index: 940;
+    display: grid;
+    box-sizing: border-box;
+    width: min(480px, 50vw);
+    overflow-y: auto;
+    border: 1px solid var(--line);
+    border-radius: 8px;
+    padding: 9px;
+    background: rgba(255, 255, 255, 0.98);
+    box-shadow: 0 3px 14px rgba(0, 0, 0, 0.22);
+}
+
+.map-layer-panel > header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 10px;
+    padding: 0 0 7px 4px;
+    border-bottom: 1px solid var(--line);
+}
+
+.layer-panel-close {
+    width: 36px;
+    min-width: 36px;
+    min-height: 34px;
+    padding: 0;
+    background: #e9eef0;
+    color: var(--ink);
+    font-size: 23px;
+}
+
+.map-layer-option {
+    display: flex;
+    align-items: center;
+    gap: 9px;
+    min-height: 45px;
+    padding: 6px 4px;
+    border-bottom: 1px solid #e5eaed;
+}
+
+.map-layer-option input {
+    flex: 0 0 auto;
+    width: 19px;
+    height: 19px;
+}
+
+.map-layer-option span {
+    display: grid;
+    gap: 2px;
+}
+
+.map-layer-option small {
+    color: var(--muted);
+    font-size: 10px;
+    font-weight: 600;
+}
+
+.layer-panel-actions {
+    display: grid;
+    gap: 7px;
+    padding-top: 9px;
+}
+
+.layer-tree-section {
+    display: grid;
+    gap: 6px;
+    padding-top: 9px;
+}
+
+.layer-tree-section > header {
+    display: grid;
+    gap: 2px;
+    padding: 0 4px;
+}
+
+.layer-tree-section > header small {
+    color: var(--muted);
+    font-size: 10px;
+}
+
+.layer-manager-tree,
+.layer-manager-children {
+    display: grid;
+    gap: 4px;
+}
+
+.layer-manager-group,
+.layer-manager-block,
+.layer-manager-object {
+    border: 1px solid #dce3e6;
+    border-radius: 6px;
+    background: #fff;
+}
+
+.layer-manager-group > summary,
+.layer-manager-block > summary,
+.layer-manager-object > summary {
+    display: grid;
+    grid-template-columns: 28px minmax(0, 1fr) 24px;
+    grid-template-areas:
+        "handle title count"
+        ". visibility moves"
+        ". actions moves";
+    align-items: start;
+    gap: 6px;
+    min-height: 38px;
+    padding: 4px 6px;
+    cursor: pointer;
+    list-style: none;
+}
+
+.layer-manager-group > summary::-webkit-details-marker,
+.layer-manager-block > summary::-webkit-details-marker,
+.layer-manager-object > summary::-webkit-details-marker {
+    display: none;
+}
+
+.layer-drag-handle {
+    grid-area: handle;
+    width: 28px;
+    height: 28px;
+    border: 0;
+    border-radius: 4px;
+    background: #e9eef0;
+    color: var(--ink);
+    font-size: 18px;
+    line-height: 1;
+    touch-action: none;
+    cursor: grab;
+}
+
+.layer-row-actions {
+    grid-area: actions;
+    display: grid;
+    grid-template-columns: minmax(0, 1fr);
+    width: min(130px, 100%);
+    gap: 4px;
+}
+
+.layer-manager-group > summary > input,
+.layer-manager-block > summary > input,
+.layer-manager-object > summary > input {
+    grid-area: visibility;
+    justify-self: start;
+    width: 20px;
+    height: 20px;
+    margin: 1px 0;
+}
+
+.layer-rename-button,
+.layer-remove-button {
+    width: 100%;
+    min-height: 28px;
+    min-width: 0;
+    padding: 4px;
+    border: 1px solid #bfd4cd;
+    border-radius: 4px;
+    background: #eef8f5;
+    color: var(--accent-strong);
+    font-size: 10px;
+    font-weight: 800;
+    line-height: 1.15;
+    overflow-wrap: anywhere;
+}
+
+.layer-rename-button:active {
+    background: #d9eee7;
+}
+
+.layer-remove-button {
+    border-color: #fecaca;
+    background: #fff1f2;
+    color: #b42318;
+}
+
+.layer-remove-button:active {
+    background: #ffe4e6;
+}
+
+.layer-move-buttons {
+    grid-area: moves;
+    display: inline-grid;
+    grid-template-columns: 24px;
+    gap: 2px;
+}
+
+.layer-move-buttons button {
+    width: 24px;
+    height: 28px;
+    padding: 0;
+    border: 1px solid #cbd5da;
+    border-radius: 4px;
+    background: #f6f8f9;
+    color: var(--ink);
+    font-size: 16px;
+    font-weight: 800;
+    line-height: 1;
+}
+
+.layer-move-buttons button:active {
+    background: #dce8ec;
+}
+
+.layer-manager-title {
+    grid-area: title;
+    min-width: 0;
+    overflow-wrap: anywhere;
+    font-size: 12px;
+    font-weight: 700;
+}
+
+.layer-manager-count {
+    grid-area: count;
+    justify-self: end;
+    color: var(--muted);
+    font-size: 10px;
+}
+
+.layer-manager-children {
+    padding: 0 4px 5px 6px;
+}
+
+.layer-manager-details {
+    display: grid;
+    gap: 2px;
+    padding: 0 6px 7px 12px;
+    color: var(--muted);
+    font-size: 10px;
+}
+
+.layer-manager-suboption {
+    display: grid;
+    grid-template-columns: 18px minmax(0, 1fr);
+    align-items: center;
+    gap: 6px;
+    min-height: 30px;
+    color: var(--ink);
+    font-size: 11px;
+    font-weight: 700;
+}
+
+.layer-manager-suboption input {
+    margin: 0;
+}
+
+.layer-manager-info {
+    display: grid;
+    gap: 2px;
+    padding: 3px 0 0 24px;
+}
+
+.layer-manager-dragging {
+    opacity: 0.55;
+    outline: 2px solid #2563eb;
+}
+
+.layer-manager-object-selected > summary {
+    background: #fff0fb;
+    box-shadow: inset 3px 0 #ff00d4;
+}
+
+.layer-manager-parent-highlighted > summary,
+.layer-manager-parent-selected > summary {
+    background: #fff0fb;
+    box-shadow: inset 3px 0 #ff00d4;
+}
+
 .gps-overlay {
     position: absolute;
     top: 72px;
@@ -203,6 +497,20 @@ input[type="checkbox"] {
     color: var(--ink);
 }
 
+.leaflet-top.leaflet-right {
+    top: 68px;
+    right: 2px;
+}
+
+.map-stage.search-active .leaflet-top.leaflet-right {
+    top: 136px;
+}
+
+.leaflet-touch .leaflet-draw-toolbar a {
+    width: 38px;
+    height: 38px;
+}
+
 .tool-sheet {
     position: absolute;
     top: 0;
@@ -269,6 +577,29 @@ h2 {
     padding: 15px 16px 24px;
 }
 
+.panel-section {
+    display: grid;
+    gap: 12px;
+    padding: 0 0 16px;
+    border-bottom: 1px solid var(--line);
+}
+
+.panel-section:last-child {
+    padding-bottom: 0;
+    border-bottom: 0;
+}
+
+.panel-section h2 {
+    margin-top: 0;
+}
+
+.field-help {
+    margin-top: -7px;
+    color: var(--muted);
+    font-size: 10px;
+    line-height: 1.35;
+}
+
 label {
     display: grid;
     gap: 5px;
@@ -370,6 +701,69 @@ label {
     height: 18px;
 }
 
+.project-save-option {
+    padding: 10px 11px;
+    border: 1px solid var(--line);
+    border-radius: 6px;
+    background: #fff;
+}
+
+.project-archive-state {
+    color: var(--muted);
+    font-size: 11px;
+    line-height: 1.35;
+}
+
+.measurement-mode-grid {
+    display: grid;
+    grid-template-columns: repeat(3, minmax(0, 1fr));
+    gap: 7px;
+}
+
+.measurement-mode-grid button {
+    min-width: 0;
+    padding: 0 8px;
+}
+
+.lme-measure-label {
+    width: 0 !important;
+    height: 0 !important;
+    border: 0 !important;
+    background: transparent !important;
+    pointer-events: none !important;
+}
+
+.lme-measure-label span {
+    position: absolute;
+    transform: translate(-50%, -50%);
+    border: 1px solid rgba(23, 33, 43, 0.35);
+    border-radius: 4px;
+    padding: 2px 5px;
+    background: rgba(255, 255, 255, 0.92);
+    box-shadow: 0 1px 3px rgba(0, 0, 0, 0.24);
+    color: #17212b;
+    font-size: 10px;
+    font-weight: 800;
+    line-height: 1.25;
+    white-space: nowrap;
+}
+
+.lme-measure-label.imported span {
+    border-color: #15806a;
+    color: #0c5749;
+}
+
+.lme-measure-label.drawing span {
+    border-color: #d35d0b;
+    color: #7c2d12;
+}
+
+.lme-measure-label.side span {
+    padding: 1px 4px;
+    font-size: 9px;
+    font-weight: 700;
+}
+
 .map-info {
     position: absolute;
     left: 12px;
@@ -384,6 +778,100 @@ label {
     pointer-events: none;
 }
 
+.wms-preview[hidden] {
+    display: none;
+}
+
+.wms-preview {
+    position: absolute;
+    inset: 0;
+    z-index: 1400;
+    display: grid;
+    place-items: center;
+    padding: 16px;
+    background: rgba(15, 22, 27, 0.72);
+}
+
+.wms-preview-dialog {
+    display: grid;
+    grid-template-rows: auto minmax(0, 1fr);
+    width: min(980px, 100%);
+    height: min(820px, 100%);
+    overflow: hidden;
+    border-radius: 8px;
+    background: #fff;
+    box-shadow: 0 10px 34px rgba(0, 0, 0, 0.34);
+}
+
+.wms-preview-dialog > header {
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    gap: 12px;
+    padding: 11px 12px;
+    border-bottom: 1px solid var(--line);
+}
+
+.wms-preview-dialog > header div {
+    display: grid;
+    gap: 2px;
+}
+
+.wms-preview-dialog > header small {
+    color: var(--muted);
+    font-size: 10px;
+}
+
+.wms-preview-body {
+    display: grid;
+    min-height: 0;
+    place-items: center;
+    overflow: auto;
+    padding: 12px;
+    background: #eef2f3;
+    color: var(--muted);
+}
+
+.wms-preview-map {
+    position: relative;
+    flex: 0 0 auto;
+    overflow: hidden;
+    background: #fff;
+}
+
+.wms-preview-map[hidden] {
+    display: none;
+}
+
+.wms-preview-map img,
+.wms-preview-map svg {
+    display: block;
+    width: 100%;
+    height: 100%;
+}
+
+.wms-preview-map svg {
+    position: absolute;
+    inset: 0;
+    pointer-events: none;
+}
+
+.wms-preview-parcel {
+    fill: rgba(251, 191, 36, 0.28);
+    fill-rule: evenodd;
+    stroke: #ef4444;
+    stroke-width: 4px;
+    vector-effect: non-scaling-stroke;
+}
+
+.wms-preview-gps-parcel {
+    fill: rgba(56, 189, 248, 0.24);
+    fill-rule: evenodd;
+    stroke: #1d4ed8;
+    stroke-width: 4px;
+    vector-effect: non-scaling-stroke;
+}
+
 .bottom-tabs {
     position: absolute;
     right: 0;
@@ -391,7 +879,7 @@ label {
     left: 0;
     z-index: 1200;
     display: grid;
-    grid-template-columns: repeat(4, minmax(0, 1fr));
+    grid-template-columns: repeat(6, minmax(0, 1fr));
     height: var(--nav-height);
     padding-bottom: env(safe-area-inset-bottom);
     border-top: 1px solid #bcc7cd;
@@ -462,6 +950,13 @@ footer {
         right: 8px;
     }
 
+    .map-layer-panel {
+        top: 68px;
+        right: 8px;
+        bottom: calc(var(--nav-height) + 8px);
+        width: 50vw;
+    }
+
     .tool-sheet {
         top: 10%;
         bottom: var(--nav-height);
@@ -485,6 +980,15 @@ footer {
         top: 136px;
     }
 
+    .leaflet-top.leaflet-right {
+        top: 122px;
+        right: 0;
+    }
+
+    .map-stage.search-active .leaflet-top.leaflet-right {
+        top: 190px;
+    }
+
     .gps-main,
     .gps-center {
         padding: 0 8px;
@@ -502,7 +1006,12 @@ footer {
     }
 
     .bottom-tabs button {
-        font-size: 11px;
+        padding: 0 2px;
+        font-size: 10px;
+    }
+
+    .wms-preview {
+        padding: 8px;
     }
 }
 
@@ -520,6 +1029,6 @@ footer {
     }
 
     .bottom-tabs button {
-        font-size: 10px;
+        font-size: 9px;
     }
 }