Persist project display options and toggle map tools

Components/Pages/Home.razor

@@ -4,6 +4,7 @@
 @inject CadastralCatalogService CatalogService
 @inject OfficialCadastreService OfficialCadastreService
 @inject LocationSearchService LocationSearchService
+@inject NetworkLocationService NetworkLocationService
 @inject AzureMapsService AzureMapsService
 @inject ProjectStorageService ProjectStorageService
 @implements IAsyncDisposable
@@ -11,7 +12,7 @@
 <PageTitle>LME Mappe Catastali</PageTitle>
 
 <div class="map-app">
-    <section class="map-stage">
+    <section class="map-stage @(ActiveTab == "search" ? "search-active" : null)">
         <div id="map"></div>
 
         <header class="map-toolbar">
@@ -149,28 +150,66 @@
                         </div>
                     </section>
                 }
-                else if (ActiveTab == "projects")
+                else if (ActiveTab == "data")
                 {
                     <section class="panel-content">
+                        <section class="panel-section">
                             <h2>File GIS</h2>
                             <label class="file-picker">
                                 <span>Carica KML, KMZ o GeoJSON</span>
                                 <input id="gisFileInput" type="file" accept=".kml,.kmz,.geojson,.json,application/vnd.google-earth.kml+xml,application/vnd.google-earth.kmz,application/geo+json" />
                             </label>
                             <label class="toggle-line project-save-option">
-                            <input type="checkbox" checked="@ImportParcelsOnly" @onchange="ToggleImportParcelsOnly" />
+                                <input type="checkbox" checked="@IncludeKmlSheetLayer" @onchange="ToggleKmlSheetLayer" />
-                            <span>KML/KMZ: importa solo le particelle</span>
+                                <span>KML/KMZ: includi anche il layer del foglio</span>
                             </label>
+                            <small class="field-help">
+                                @(IncludeKmlSheetLayer
+                                    ? "Attivato: importa foglio, particelle e altri elementi KML/KMZ."
+                                    : "Disattivato: importa solo i poligoni delle particelle riconosciute.")
+                            </small>
+                            <label class="toggle-line project-save-option">
+                                <input type="checkbox" checked="@ShowImportedSheetLayer" @onchange="ToggleImportedSheetLayer" />
+                                <span>Mostra cornice/layer del foglio importato</span>
+                            </label>
+                            <small class="field-help">La cornice grande resta separata dalle particelle e puo essere nascosta anche nei progetti salvati.</small>
                             <label class="toggle-line project-save-option">
                                 <input type="checkbox" checked="@ShowImportedMeasurements" @onchange="ToggleImportedMeasurements" />
                                 <span>Mostra misure dei file caricati</span>
                             </label>
                             <div class="button-row">
-                            <button @onclick="FitImportedLayers">Inquadra</button>
+                                <button @onclick="FitImportedLayers">Inquadra dati</button>
-                            <button class="secondary-command" @onclick="ClearImportedLayers">Pulisci</button>
+                                <button class="secondary-command" @onclick="ClearImportedLayers">Rimuovi dati</button>
                             </div>
+                        </section>
 
-                        <h2>Archivio progetti</h2>
+                        <section class="panel-section">
+                            <h2>Disegni e misure</h2>
+                            <label class="toggle-line project-save-option">
+                                <input type="checkbox" checked="@ShowDrawingMeasurements" @onchange="ToggleDrawingMeasurements" />
+                                <span>Mostra superficie, perimetro e lati</span>
+                            </label>
+                            <button class="secondary-command" aria-pressed="@DrawToolsVisible" @onclick="ToggleDrawTools">
+                                @(DrawToolsVisible ? "Nascondi strumenti sulla mappa" : "Mostra strumenti sulla mappa")
+                            </button>
+                            <button class="danger-command" @onclick="ClearDrawings">Elimina disegni e POI</button>
+                        </section>
+
+                        <section class="panel-section">
+                            <h2>Punti di interesse</h2>
+                            <label>
+                                Nome POI
+                                <input @bind="PoiName" @bind:event="oninput" placeholder="Nome del punto" />
+                            </label>
+                            <button class="primary-command" @onclick="AddProjectMarker">Aggiungi POI al centro mappa</button>
+                        </section>
+                    </section>
+                }
+                else if (ActiveTab == "projects")
+                {
+                    <section class="panel-content">
+                        <section class="panel-section">
+                            <h2>Salva progetto</h2>
                             <label>
                                 Nome progetto
                                 <input @bind="NewProjectName" @bind:event="oninput" placeholder="Es. Rilievo San Nicola" maxlength="80" />
@@ -180,7 +219,10 @@
                                 <span>Includi le particelle catastali rosse</span>
                             </label>
                             <button class="primary-command" @onclick="SaveProject" disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(NewProjectName))">Salva progetto</button>
+                        </section>
 
+                        <section class="panel-section">
+                            <h2>Apri progetto</h2>
                             <label>
                                 Progetto salvato
                                 <select value="@SelectedProjectId" @onchange="SelectProject" disabled="@(Projects.Count == 0 || ProjectBusy)">
@@ -192,38 +234,18 @@
                                 </select>
                             </label>
                             <div class="button-row">
-                            <button @onclick="LoadProject" disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(SelectedProjectId))">Carica</button>
+                                <button @onclick="LoadProject" disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(SelectedProjectId))">Apri</button>
                                 <button class="danger-command" @onclick="DeleteProject" disabled="@(ProjectBusy || string.IsNullOrWhiteSpace(SelectedProjectId))">Elimina</button>
                             </div>
                             <div class="project-archive-state">@ProjectArchiveMessage</div>
-
+                        </section>
-                        <h2>Misura e disegna</h2>
-                        <div class="measurement-mode-grid" aria-label="Strumenti di misura">
-                            <button @onclick='() => StartMeasurementDrawing("area")'>Area</button>
-                            <button @onclick='() => StartMeasurementDrawing("distance")'>Distanza</button>
-                            <button @onclick='() => StartMeasurementDrawing("circle")'>Cerchio</button>
-                        </div>
-                        <label class="toggle-line project-save-option">
-                            <input type="checkbox" checked="@ShowDrawingMeasurements" @onchange="ToggleDrawingMeasurements" />
-                            <span>Mostra superficie, perimetro e lati</span>
-                        </label>
-                        <button class="secondary-command" aria-pressed="@DrawToolsVisible" @onclick="ToggleDrawTools">
-                            @(DrawToolsVisible ? "Nascondi strumenti completi" : "Mostra strumenti completi")
-                        </button>
-
-                        <h2>POI</h2>
-                        <label>
-                            Nome POI
-                            <input @bind="PoiName" @bind:event="oninput" placeholder="Nome del punto" />
-                        </label>
-                        <button class="primary-command" @onclick="AddProjectMarker">Aggiungi POI al centro mappa</button>
-                        <button class="danger-command" @onclick="ClearDrawings">Elimina disegni e POI</button>
                     </section>
                 }
                 else if (ActiveTab == "settings")
                 {
                     <section class="panel-content">
-                        <h2>Visualizzazione</h2>
+                        <section class="panel-section">
+                            <h2>Mappa e sfondo</h2>
                             <label>
                                 Sfondo
                                 <select value="@SelectedBaseLayer" @onchange="ChangeBaseLayer">
@@ -239,6 +261,14 @@
                                     <option value="google-roadmap">Strade - Google Maps</option>
                                 </select>
                             </label>
+                            <label>
+                                Trasparenza catasto
+                                <input type="range" min="0" max="1" step="0.05" value="@CadastralOpacity.ToString(System.Globalization.CultureInfo.InvariantCulture)" @onchange="ChangeCadastreOpacity" />
+                            </label>
+                        </section>
+
+                        <section class="panel-section">
+                            <h2>Servizi mappa con chiave</h2>
                             <label>
                                 Chiave Google Maps Platform
                                 <input type="password" @bind="GoogleMapsApiKey" placeholder="API key" autocomplete="off" />
@@ -253,16 +283,21 @@
                                 <strong>Quota gratuita Azure Maps Gen2</strong>
                                 <p>Include ogni mese 5.000 transazioni per le mappe stradali e 1.000 per le immagini satellitari. Ogni transazione comprende fino a 15 tessere.</p>
                             </div>
-                        <label>
+                        </section>
-                            Trasparenza catasto
-                            <input type="range" min="0" max="1" step="0.05" value="0.75" @onchange="ChangeCadastreOpacity" />
-                        </label>
-                        <h2>GPS e percorso</h2>
-                        <label class="toggle-line">
-                            <input type="checkbox" checked="@TrailEnabled" @onchange="ToggleTrail" />
-                            Registra la traccia mentre cammini
-                        </label>
 
+                        <section class="panel-section">
+                            <h2>GPS e percorso</h2>
+                            <label class="toggle-line project-save-option">
+                                <input type="checkbox" checked="@ShowGpsPosition" @onchange="ToggleGpsPosition" />
+                                <span>Mostra punto e cerchio GPS</span>
+                            </label>
+                            <label class="toggle-line project-save-option">
+                                <input type="checkbox" checked="@TrailEnabled" @onchange="ToggleTrail" />
+                                <span>Registra la traccia mentre cammini</span>
+                            </label>
+                        </section>
+
+                        <section class="panel-section">
                             <h2>Servizi Agenzia delle Entrate</h2>
                             <div class="service-note protected-service">
                                 <strong>Download documenti e fogli ufficiali</strong>
@@ -270,10 +305,10 @@
                                 <button class="primary-command" @onclick="OpenOfficialGeoportal">Apri Geoportale catastale</button>
                                 <button class="secondary-command" @onclick="OpenOfficialReservedArea">Apri Area riservata per download</button>
                             </div>
-
                             <button class="secondary-command" @onclick="ExportCadastralImage">Mostra vista WMS corrente</button>
                             <footer>Dati catastali: Agenzia delle Entrate, licenza CC BY 4.0. App indipendente.</footer>
                         </section>
+                    </section>
                 }
             </aside>
         }
@@ -302,6 +337,7 @@
         <nav class="bottom-tabs" aria-label="Sezioni principali">
             <button class="@(ActiveTab == "map" || ActiveTab == "search" ? "active" : null)" @onclick='() => SelectTab("map")'>Mappa</button>
             <button class="@(ActiveTab == "cadastre" ? "active" : null)" @onclick='() => SelectTab("cadastre")'>Catasto</button>
+            <button class="@(ActiveTab == "data" ? "active" : null)" @onclick='() => SelectTab("data")'>Dati</button>
             <button class="@(ActiveTab == "projects" ? "active" : null)" @onclick='() => SelectTab("projects")'>Progetti</button>
             <button class="@(ActiveTab == "settings" ? "active" : null)" @onclick='() => SelectTab("settings")'>Impostazioni</button>
         </nav>
@@ -325,13 +361,16 @@
     private string SelectedParcelNumber { get; set; } = string.Empty;
     private string CatalogMessage { get; set; } = string.Empty;
     private double? CatalogFraction { get; set; }
+    private double CadastralOpacity { get; set; } = 0.75;
     private bool CatalogBusy { get; set; }
     private bool GpsActive { get; set; }
+    private bool ShowGpsPosition { get; set; } = true;
     private bool DrawToolsVisible { get; set; }
     private bool TrailEnabled { get; set; }
     private bool LayerPanelOpen { get; set; }
     private bool IncludeCadastralParcels { get; set; } = true;
-    private bool ImportParcelsOnly { get; set; } = true;
+    private bool IncludeKmlSheetLayer { get; set; }
+    private bool ShowImportedSheetLayer { get; set; }
     private bool ShowImportedMeasurements { get; set; }
     private bool ShowDrawingMeasurements { get; set; } = true;
     private bool ProjectBusy { get; set; }
@@ -355,7 +394,8 @@
     private string PanelTitle => ActiveTab switch
     {
         "cadastre" => "Ricerca catastale",
-        "projects" => "Progetti e dati",
+        "data" => "Dati e disegni",
+        "projects" => "Archivio progetti",
         "settings" => "Impostazioni",
         _ => string.Empty
     };
@@ -363,7 +403,8 @@
     private string PanelEyebrow => ActiveTab switch
     {
         "cadastre" => "Regione, Comune, Foglio, Particella",
-        "projects" => "KML, KMZ, GeoJSON e POI",
+        "data" => "File GIS, misure e POI",
+        "projects" => "Salva e apri i tuoi lavori",
         "settings" => "Mappa, GPS e servizi ufficiali",
         _ => string.Empty
     };
@@ -415,10 +456,100 @@
         if (firstRender)
         {
             await JS.InvokeVoidAsync("lmeMap.init");
+            await CenterOnInitialLocationAsync();
             await MigrateLegacyProjectAsync();
         }
     }
 
+    private async Task ConfigureProjectMapProviderAsync(string snapshot)
+    {
+        string? baseLayer = null;
+        try
+        {
+            using var document = System.Text.Json.JsonDocument.Parse(snapshot);
+            if (document.RootElement.TryGetProperty("displayOptions", out var displayOptions)
+                && displayOptions.TryGetProperty("baseLayer", out var baseLayerProperty))
+            {
+                baseLayer = baseLayerProperty.GetString();
+            }
+        }
+        catch
+        {
+            return;
+        }
+
+        try
+        {
+            if (baseLayer?.StartsWith("google-", StringComparison.Ordinal) == true
+                && !string.IsNullOrWhiteSpace(GoogleMapsApiKey))
+            {
+                await JS.InvokeVoidAsync("lmeMap.configureGoogleMaps", GoogleMapsApiKey.Trim());
+            }
+
+            if (baseLayer?.StartsWith("azure-", StringComparison.Ordinal) == true
+                && !string.IsNullOrWhiteSpace(AzureMapsSubscriptionKey))
+            {
+                await JS.InvokeVoidAsync("lmeMap.configureAzureMaps", AzureMapsSubscriptionKey.Trim());
+            }
+        }
+        catch
+        {
+            // Loading continues with the default map if the saved provider is unavailable.
+        }
+    }
+
+    private async Task CenterOnInitialLocationAsync()
+    {
+        NetworkLocationSnapshot? networkLocation = null;
+        try
+        {
+            using var networkTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(8));
+            networkLocation = await NetworkLocationService.GetApproximateLocationAsync(networkTimeout.Token);
+        }
+        catch
+        {
+            // An unavailable IP service must not prevent the GPS fallback.
+        }
+
+        if (networkLocation is not null)
+        {
+            await JS.InvokeVoidAsync(
+                "lmeMap.showInitialPosition",
+                networkLocation.Latitude,
+                networkLocation.Longitude,
+                true,
+                networkLocation.Label);
+            return;
+        }
+
+        try
+        {
+            using var gpsTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(18));
+            var location = await LocationService.GetCurrentLocationAsync(gpsTimeout.Token);
+            if (location is not null)
+            {
+                await JS.InvokeVoidAsync(
+                    "lmeMap.showInitialPosition",
+                    location.Latitude,
+                    location.Longitude,
+                    false,
+                    string.Empty);
+            }
+            else
+            {
+                await JS.InvokeVoidAsync("lmeMap.showInfo", "Posizione iniziale non disponibile. La mappa resta utilizzabile normalmente.");
+            }
+        }
+        catch (OperationCanceledException)
+        {
+            await JS.InvokeVoidAsync("lmeMap.showInfo", "Posizione iniziale non disponibile. Usa Avvia GPS per riprovare.");
+        }
+        catch (Exception error)
+        {
+            await JS.InvokeVoidAsync("lmeMap.showInfo", $"Posizione iniziale non disponibile: {error.GetBaseException().Message}");
+        }
+    }
+
     private async Task MigrateLegacyProjectAsync()
     {
         try
@@ -642,6 +773,12 @@
         }
     }
 
+    private async Task ToggleGpsPosition(ChangeEventArgs args)
+    {
+        ShowGpsPosition = (bool?)args.Value == true;
+        await JS.InvokeVoidAsync("lmeMap.setGpsPositionVisible", ShowGpsPosition);
+    }
+
     private async Task StartGps()
     {
         GpsActive = true;
@@ -748,13 +885,25 @@
     }
 
     private Task FitImportedLayers() => JS.InvokeVoidAsync("lmeMap.fitImported").AsTask();
-    private Task ClearImportedLayers() => JS.InvokeVoidAsync("lmeMap.clearImported").AsTask();
+    private async Task ClearImportedLayers()
+    {
+        ShowImportedSheetLayer = false;
+        await JS.InvokeVoidAsync("lmeMap.clearImported");
+    }
     private Task AddProjectMarker() => JS.InvokeVoidAsync("lmeMap.addProjectMarker", PoiName).AsTask();
 
-    private async Task ToggleImportParcelsOnly(ChangeEventArgs args)
+    private async Task ToggleKmlSheetLayer(ChangeEventArgs args)
     {
-        ImportParcelsOnly = (bool?)args.Value == true;
+        IncludeKmlSheetLayer = (bool?)args.Value == true;
-        await JS.InvokeVoidAsync("lmeMap.setImportParcelOnly", ImportParcelsOnly);
+        ShowImportedSheetLayer = IncludeKmlSheetLayer;
+        await JS.InvokeVoidAsync("lmeMap.setIncludeKmlSheetLayer", IncludeKmlSheetLayer);
+        await JS.InvokeVoidAsync("lmeMap.setImportedSheetLayerVisible", ShowImportedSheetLayer);
+    }
+
+    private async Task ToggleImportedSheetLayer(ChangeEventArgs args)
+    {
+        ShowImportedSheetLayer = (bool?)args.Value == true;
+        await JS.InvokeVoidAsync("lmeMap.setImportedSheetLayerVisible", ShowImportedSheetLayer);
     }
 
     private async Task ToggleImportedMeasurements(ChangeEventArgs args)
@@ -769,17 +918,6 @@
         await JS.InvokeVoidAsync("lmeMap.setDrawingMeasurementsVisible", ShowDrawingMeasurements);
     }
 
-    private async Task StartMeasurementDrawing(string mode)
-    {
-        DrawToolsVisible = false;
-        await JS.InvokeVoidAsync("lmeMap.setDrawToolsVisible", false);
-        ActiveTab = "map";
-        LayerPanelOpen = false;
-        await Task.Delay(30);
-        await JS.InvokeVoidAsync("lmeMap.resize");
-        await JS.InvokeVoidAsync("lmeMap.startMeasurementDrawing", mode);
-    }
-
     private async Task ToggleDrawTools()
     {
         DrawToolsVisible = !DrawToolsVisible;
@@ -876,7 +1014,9 @@
         try
         {
             var snapshot = await ProjectStorageService.LoadAsync(project.Id);
-            await JS.InvokeVoidAsync("lmeMap.loadProjectSnapshot", snapshot, project.Name);
+            await ConfigureProjectMapProviderAsync(snapshot);
+            var displayOptions = await JS.InvokeAsync<ProjectDisplayOptions>("lmeMap.loadProjectSnapshot", snapshot, project.Name);
+            ApplyProjectDisplayOptions(displayOptions);
             NewProjectName = project.Name;
             IncludeCadastralParcels = project.IncludesCadastralParcels;
             ActiveTab = "map";
@@ -893,6 +1033,25 @@
         }
     }
 
+    private void ApplyProjectDisplayOptions(ProjectDisplayOptions options)
+    {
+        SelectedBaseLayer = options.BaseLayer;
+        CadastralOpacity = options.CadastreOpacity;
+        IncludeKmlSheetLayer = options.IncludeKmlSheetLayer;
+        ShowImportedSheetLayer = options.ImportedSheetsVisible;
+        ShowImportedMeasurements = options.ShowImportedMeasurements;
+        ShowDrawingMeasurements = options.ShowDrawingMeasurements;
+        DrawToolsVisible = options.DrawToolsVisible;
+        ShowGpsPosition = options.GpsPositionVisible;
+        TrailEnabled = options.TrailEnabled;
+
+        var activeLayers = (options.CadastreLayers ?? []).ToHashSet(StringComparer.Ordinal);
+        foreach (var layer in CadastralLayers)
+        {
+            layer.Enabled = activeLayers.Contains(layer.Key);
+        }
+    }
+
     private async Task DeleteProject()
     {
         var project = Projects.FirstOrDefault(item => item.Id == SelectedProjectId);
@@ -1014,7 +1173,18 @@
             await JS.InvokeVoidAsync("lmeMap.showInfo", $"Chiave Azure Maps non salvata: {error.GetBaseException().Message}");
         }
     }
-    private Task ChangeCadastreOpacity(ChangeEventArgs args) => JS.InvokeVoidAsync("lmeMap.setCadastreOpacity", args.Value?.ToString()).AsTask();
+    private async Task ChangeCadastreOpacity(ChangeEventArgs args)
+    {
+        var text = args.Value?.ToString();
+        if (!double.TryParse(text, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out var value)
+            && !double.TryParse(text, out value))
+        {
+            return;
+        }
+
+        CadastralOpacity = Math.Clamp(value, 0, 1);
+        await JS.InvokeVoidAsync("lmeMap.setCadastreOpacity", CadastralOpacity);
+    }
 
     private async Task ToggleCadastreLayer(CadastralLayer layer, ChangeEventArgs args)
     {
@@ -1049,6 +1219,20 @@
         public string Detail { get; } = detail;
     }
 
+    private sealed class ProjectDisplayOptions
+    {
+        public string BaseLayer { get; init; } = "satellite";
+        public double CadastreOpacity { get; init; } = 0.75;
+        public string[] CadastreLayers { get; init; } = [];
+        public bool IncludeKmlSheetLayer { get; init; }
+        public bool ImportedSheetsVisible { get; init; }
+        public bool ShowImportedMeasurements { get; init; }
+        public bool ShowDrawingMeasurements { get; init; } = true;
+        public bool DrawToolsVisible { get; init; }
+        public bool GpsPositionVisible { get; init; } = true;
+        public bool TrailEnabled { get; init; }
+    }
+
     public ValueTask DisposeAsync()
     {
         CancelCatalogWork();

LMEMappeCatastaliApp.csproj

@@ -28,8 +28,8 @@
         <ApplicationId>com.companyname.lmemappecatastaliapp</ApplicationId>
 
         <!-- Versions -->
-        <ApplicationDisplayVersion>0.2.8</ApplicationDisplayVersion>
+        <ApplicationDisplayVersion>0.2.12</ApplicationDisplayVersion>
-        <ApplicationVersion>12</ApplicationVersion>
+        <ApplicationVersion>16</ApplicationVersion>
 
         <!-- To develop, package, and publish an app to the Microsoft Store, see: https://aka.ms/MauiTemplateUnpackaged -->
         <WindowsPackageType>None</WindowsPackageType>

MauiProgram.cs

@@ -20,6 +20,7 @@ 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>();
 

README.md

@@ -10,25 +10,27 @@ App .NET MAUI Blazor Hybrid per Android, iOS, Mac Catalyst e Windows, pensata pe
 - 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 esclusione di GroundOverlay e perimetri del foglio.
+- 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.
 - Inquadramento e pulizia dei layer importati.
 - Disegno di marker, linee, poligoni e rettangoli.
-- Modalita rapide Area, Distanza e Cerchio con superficie, perimetro, raggio, circonferenza e lunghezza dei singoli lati.
+- 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.
 - Archivio multiprogetto nella cartella privata dell'app, con nome, selezione da elenco, sovrascrittura ed eliminazione.
-- Ogni progetto salva file GIS, POI, disegni, traccia e inquadratura; l'inclusione delle particelle catastali rosse e' opzionale.
+- 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, Progetti 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.

Services/AzureMapsService.cs

@@ -13,7 +13,7 @@ public sealed class AzureMapsService
 
     public AzureMapsService()
     {
-        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2.8");
+        _httpClient.DefaultRequestHeaders.UserAgent.ParseAdd("LMEMappeCatastali/0.2.12");
         _httpClient.DefaultRequestHeaders.Accept.ParseAdd("application/json");
     }
 

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.12");
+    }
+
+    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(
+                        await onLocation(ToSnapshot(location));
-                            location.Latitude,
-                            location.Longitude,
-                            location.Accuracy,
-                            location.Altitude,
-                            location.Course,
-                            location.Speed,
-                            location.Timestamp));
                     }
                 }
                 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(

wwwroot/css/app.css

@@ -292,6 +292,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;
@@ -358,6 +372,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;
@@ -637,7 +674,7 @@ label {
     left: 0;
     z-index: 1200;
     display: grid;
-    grid-template-columns: repeat(4, minmax(0, 1fr));
+    grid-template-columns: repeat(5, minmax(0, 1fr));
     height: var(--nav-height);
     padding-bottom: env(safe-area-inset-bottom);
     border-top: 1px solid #bcc7cd;
@@ -738,6 +775,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;

wwwroot/js/lme-map.js

@@ -7,18 +7,23 @@ const lmeState = {
     cadastreLayers: ["CP.CadastralParcel", "codice_plla", "CP.CadastralZoning", "fabbricati"],
     cadastreOpacity: 0.75,
     imported: null,
+    importedSheets: null,
+    importedSheetsVisible: false,
     importedMeasurements: null,
     drawings: null,
     drawingMeasurements: null,
     drawControl: null,
     activeDrawHandler: null,
     drawEventsBound: false,
-    importParcelOnly: true,
+    includeKmlSheetLayer: false,
     showImportedMeasurements: false,
     showDrawingMeasurements: true,
     measurementRefreshTimer: null,
     gpsMarker: null,
     gpsAccuracy: null,
+    gpsPositionVisible: true,
+    hasLiveGpsFix: false,
+    lastAccuracy: 0,
     gpsTrail: null,
     selectedParcelsLayer: null,
     gpsParcelLayer: null,
@@ -40,6 +45,7 @@ const cadastreCrs = L.extend({}, L.CRS.EPSG4326, { code: "EPSG:4258" });
 window.lmeMap = {
     init,
     showSearchResult,
+    showInitialPosition,
     displayOfficialParcel,
     exportCadastreView,
     closeCadastrePreview,
@@ -47,7 +53,8 @@ window.lmeMap = {
     clearMapElements,
     fitImported,
     clearImported,
-    setImportParcelOnly,
+    setIncludeKmlSheetLayer,
+    setImportedSheetLayerVisible,
     setImportedMeasurementsVisible,
     setDrawingMeasurementsVisible,
     addProjectMarker,
@@ -69,6 +76,7 @@ window.lmeMap = {
     centerOnGps,
     toggleTrail,
     setNativeGpsPosition,
+    setGpsPositionVisible,
     setGpsError,
     resize,
     showInfo: setInfo
@@ -124,6 +132,7 @@ function init() {
 
     lmeState.currentBase = lmeState.baseLayers.satellite.addTo(lmeState.map);
     lmeState.imported = L.featureGroup().addTo(lmeState.map);
+    lmeState.importedSheets = L.featureGroup();
     lmeState.drawings = L.featureGroup().addTo(lmeState.map);
     lmeState.importedMeasurements = L.layerGroup().addTo(lmeState.map);
     lmeState.drawingMeasurements = L.layerGroup().addTo(lmeState.map);
@@ -133,6 +142,7 @@ function init() {
 
     refreshCadastreLayer();
     bindFileImport();
+    bindDrawingEvents();
 
     if (!lmeState.resizeBound) {
         window.addEventListener("resize", resize);
@@ -178,6 +188,29 @@ function showSearchResult(latitude, longitude, label) {
     setInfo(label || `${lat.toFixed(6)}, ${lon.toFixed(6)}`);
 }
 
+function showInitialPosition(latitudeValue, longitudeValue, approximate, label) {
+    const latitude = Number(latitudeValue);
+    const longitude = Number(longitudeValue);
+    if (!Number.isFinite(latitude) || !Number.isFinite(longitude)) {
+        return;
+    }
+
+    const latlng = [latitude, longitude];
+    if (!approximate) {
+        lmeState.lastPosition = latlng;
+    }
+    lmeState.map.setView(latlng, approximate ? 13 : 19);
+    setText("gpsState", approximate
+        ? "Posizione approssimativa dalla connessione - GPS non attivo"
+        : "Posizione iniziale acquisita - GPS non attivo");
+    setInfo(approximate
+        ? `Mappa centrata in modo approssimativo su ${label || "questa zona"}.`
+        : "Mappa centrata sulla posizione attuale. GPS continuo non attivo.");
+    if (!approximate) {
+        updateGpsInsideState();
+    }
+}
+
 function displayOfficialParcel(xmlText, latitude, longitude, parcel, label, shouldFit) {
     const lat = Number(latitude);
     const lon = Number(longitude);
@@ -435,7 +468,7 @@ function bindFileImport() {
         try {
             const result = await readGisFile(file);
             const geojson = result.geojson;
-            const layer = L.geoJSON(geojson, {
+            const parcelLayer = L.geoJSON(geojson, {
                 style: { color: "#22c55e", weight: 3, opacity: 0.95, fillOpacity: 0.18 },
                 pointToLayer: (feature, latlng) => L.circleMarker(latlng, { radius: 7, color: "#22c55e", fillColor: "#ffffff", fillOpacity: 0.9 }),
                 onEachFeature: (feature, layer) => {
@@ -443,14 +476,28 @@ function bindFileImport() {
                     layer.bindPopup(`<strong>${escapeHtml(name)}</strong>`);
                 }
             }).addTo(lmeState.imported);
-            fitLayer(layer);
+            const sheetGeojson = result.sheetGeojson || emptyFeatureCollection();
+            const sheetLayer = L.geoJSON(sheetGeojson, {
+                style: { color: "#15803d", weight: 3, opacity: 0.85, fillOpacity: 0.04, dashArray: "9 7" },
+                pointToLayer: (feature, latlng) => L.circleMarker(latlng, { radius: 6, color: "#15803d", fillOpacity: 0.25 }),
+                onEachFeature: (feature, layer) => {
+                    const name = feature?.properties?.name || "Foglio catastale importato";
+                    layer.bindPopup(`<strong>${escapeHtml(name)}</strong>`);
+                }
+            }).addTo(lmeState.importedSheets);
+            applyImportedSheetVisibility();
+            fitLayer(geojson.features.length ? parcelLayer : sheetLayer);
             refreshImportedMeasurements();
             const featureCount = geojson.features.length;
+            const sheetCount = sheetGeojson.features.length;
             const ignored = result.ignoredCount
-                ? `; esclusi ${result.ignoredCount} elementi non particella`
+                ? `; esclusi ${result.ignoredCount} elementi del foglio o non particella`
+                : "";
+            const includedSheets = sheetCount
+                ? `; ${sheetCount} elementi foglio ${lmeState.importedSheetsVisible ? "visibili" : "nascosti"}`
                 : "";
             const reprojected = result.reprojected ? "; coordinate Web Mercator convertite" : "";
-            setInfo(`Caricato ${file.name}: ${featureCount} elementi${ignored}${reprojected}.`);
+            setInfo(`Caricato ${file.name}: ${featureCount} particelle/elementi${includedSheets}${ignored}${reprojected}.`);
             updateGpsInsideState();
         } catch (error) {
             setInfo(`File non leggibile: ${error.message}`);
@@ -575,7 +622,12 @@ function normalizeGeoJson(value, fileName) {
     }
 
     delete root.crs;
-    return { geojson: root, ignoredCount: 0, reprojected: webMercator };
+    return {
+        geojson: root,
+        sheetGeojson: emptyFeatureCollection(),
+        ignoredCount: 0,
+        reprojected: webMercator
+    };
 }
 
 function isGeoJsonGeometry(value) {
@@ -652,13 +704,22 @@ function normalizeKmlFiles(files) {
         throw new Error("KML senza geometrie utilizzabili");
     }
 
-    const selected = lmeState.importParcelOnly ? filterKmlParcelFeatures(features) : features;
+    const polygonParts = splitKmlPolygonFeatures(features);
-    if (!selected.length) {
+    const parcels = filterKmlParcelFeatures(polygonParts);
-        throw new Error("nessuna particella trovata; disattiva 'solo particelle' per importare tutti gli elementi");
+    const parcelSet = new Set(parcels);
+    const sheetParts = polygonParts.filter(feature => !parcelSet.has(feature));
+    const nonPolygonFeatures = features.filter(feature => geometryPolygons(feature.geometry).length === 0);
+    const optionalFeatures = [...sheetParts, ...nonPolygonFeatures];
+    if (!parcels.length && !(lmeState.includeKmlSheetLayer && optionalFeatures.length)) {
+        throw new Error("nessuna particella trovata; attiva 'includi layer del foglio' per importare gli altri elementi");
     }
     return {
-        geojson: { type: "FeatureCollection", features: selected },
+        geojson: { type: "FeatureCollection", features: parcels },
-        ignoredCount: features.length - selected.length,
+        sheetGeojson: {
+            type: "FeatureCollection",
+            features: lmeState.includeKmlSheetLayer ? optionalFeatures : []
+        },
+        ignoredCount: lmeState.includeKmlSheetLayer ? 0 : optionalFeatures.length,
         reprojected: false
     };
 }
@@ -690,10 +751,7 @@ function kmlTextToGeoJson(text, sourceName) {
 }
 
 function filterKmlParcelFeatures(features) {
-    const polygons = features
+    const filtered = features.filter(feature => {
-        .map(feature => ({ ...feature, geometry: polygonOnlyGeometry(feature.geometry) }))
-        .filter(feature => feature.geometry);
-    const filtered = polygons.filter(feature => {
         const properties = feature.properties || {};
         if (properties["@geometry-type"] === "groundoverlay") {
             return false;
@@ -704,47 +762,83 @@ function filterKmlParcelFeatures(features) {
             .join(" ")
             .toLowerCase();
         const folder = String(properties._lmeFolder || "").toLowerCase();
-        const isParcel = /particell|mappal|parcel/.test(`${identity} ${folder}`)
+        const context = `${identity} ${folder}`;
-            || /^[a-z]?\s*\d+[a-z]?(?:[\/. -]\d+[a-z]?)?$/i.test(name);
+        const hasParcelNumber = /^[a-z]?\s*\d+[a-z]?(?:[\/. -]\d+[a-z]?)?$/i.test(name);
-        const isSheet = /\bfoglio\b|\bsheet\b|quadro[ _-]?d[' ]?unione|perimetro[ _-]?foglio/.test(identity);
+        const isSheet = /\bfoglio\b|\bsheet\b|quadro[ _-]?d[' ]?unione|(?:perimetro|bordo|limite|contorno)[ _-]?(?:del[ _-]?)?foglio|sheet[ _-]?boundary/.test(context);
-        return isParcel || !isSheet;
+        return !isSheet || hasParcelNumber;
     });
-    return removeLikelySheetOutline(filtered);
+    return removeLikelySheetOutlines(filtered);
 }
 
-function polygonOnlyGeometry(geometry) {
+function splitKmlPolygonFeatures(features) {
+    const result = [];
+    const addGeometry = (feature, geometry, partIndex) => {
         if (!geometry) {
-        return null;
+            return;
         }
-    if (geometry.type === "Polygon" || geometry.type === "MultiPolygon") {
+        if (geometry.type === "Polygon") {
-        return geometry;
+            result.push({
+                ...feature,
+                properties: { ...(feature.properties || {}), _lmePart: partIndex },
+                geometry
+            });
+            return;
+        }
+        if (geometry.type === "MultiPolygon") {
+            (geometry.coordinates || []).forEach((coordinates, index) => addGeometry(
+                feature,
+                { type: "Polygon", coordinates },
+                `${partIndex}.${index}`));
+            return;
         }
         if (geometry.type === "GeometryCollection") {
-        const geometries = (geometry.geometries || []).filter(item =>
+            (geometry.geometries || []).forEach((item, index) => addGeometry(feature, item, `${partIndex}.${index}`));
-            item.type === "Polygon" || item.type === "MultiPolygon");
-        return geometries.length ? { type: "GeometryCollection", geometries } : null;
         }
-    return null;
+    };
+    features.forEach((feature, index) => addGeometry(feature, feature.geometry, index));
+    return result;
 }
 
-function removeLikelySheetOutline(features) {
+function removeLikelySheetOutlines(features) {
-    if (features.length < 3) {
+    let remaining = [...features];
-        return features;
+    while (remaining.length >= 2) {
+        const candidates = remaining
+            .map(feature => ({ feature, bounds: geoJsonBounds(feature.geometry) }))
+            .filter(item => item.bounds);
+        if (candidates.length < 2) {
+            break;
         }
-    const candidates = features.map(feature => ({ feature, bounds: geoJsonBounds(feature.geometry) }));
+
-    const valid = candidates.filter(item => item.bounds);
+        const largest = candidates.reduce((current, item) =>
-    if (valid.length < 3) {
-        return features;
-    }
-    const areas = valid.map(item => boundsArea(item.bounds)).sort((a, b) => a - b);
-    const median = areas[Math.floor(areas.length / 2)];
-    const largest = valid.reduce((current, item) =>
             boundsArea(item.bounds) > boundsArea(current.bounds) ? item : current);
-    const others = valid.filter(item => item !== largest);
+        if (isStrongParcelFeature(largest.feature)) {
+            break;
+        }
+        const others = candidates.filter(item => item !== largest);
+        const comparisonAreas = others.map(item => boundsArea(item.bounds)).sort((a, b) => a - b);
+        const referenceArea = comparisonAreas[Math.floor(comparisonAreas.length / 2)];
         const contained = others.filter(item => boundsContains(largest.bounds, boundsCenter(item.bounds))).length;
-    const looksLikeSheet = boundsArea(largest.bounds) > median * 8
+        const minimumContained = candidates.length === 2 ? 1 : Math.ceil(others.length * 0.6);
-        && contained >= Math.ceil(others.length * 0.75);
+        const areaFactor = 2.5;
-    return looksLikeSheet ? features.filter(feature => feature !== largest.feature) : features;
+        const looksLikeSheet = referenceArea > 0
+            && boundsArea(largest.bounds) > referenceArea * areaFactor
+            && contained >= minimumContained;
+        if (!looksLikeSheet) {
+            break;
+        }
+        remaining = remaining.filter(feature => feature !== largest.feature);
+    }
+    return remaining;
+}
+
+function isStrongParcelFeature(feature) {
+    const properties = feature?.properties || {};
+    const name = String(properties.name || properties.Name || properties.LABEL || "").trim();
+    const context = [name, properties.layer, properties.Layer, properties.type, properties.Tipo, properties._lmeFolder]
+        .filter(Boolean)
+        .join(" ");
+    return /particell|mappal|parcel/i.test(context)
+        || /^[a-z]?\s*\d+[a-z]?(?:[\/. -]\d+[a-z]?)?$/i.test(name);
 }
 
 function geoJsonBounds(geometry) {
@@ -774,11 +868,37 @@ function boundsContains(bounds, point) {
         && point[1] >= bounds.south && point[1] <= bounds.north;
 }
 
-function setImportParcelOnly(enabled) {
+function setIncludeKmlSheetLayer(enabled) {
-    lmeState.importParcelOnly = Boolean(enabled);
+    lmeState.includeKmlSheetLayer = Boolean(enabled);
-    setInfo(lmeState.importParcelOnly
+    setInfo(lmeState.includeKmlSheetLayer
-        ? "Importazione KML/KMZ: verranno caricate solo le particelle."
+        ? "Importazione KML/KMZ: verranno inclusi anche foglio e altri elementi."
-        : "Importazione KML/KMZ: verranno caricati tutti gli elementi.");
+        : "Importazione KML/KMZ: verranno caricate solo le particelle riconosciute.");
+}
+
+function setImportedSheetLayerVisible(enabled) {
+    lmeState.importedSheetsVisible = Boolean(enabled);
+    applyImportedSheetVisibility();
+    const count = lmeState.importedSheets?.toGeoJSON()?.features?.length || 0;
+    setInfo(lmeState.importedSheetsVisible
+        ? (count ? `Layer del foglio importato visibile (${count} elementi).` : "Il layer del foglio sara visibile quando verra importato.")
+        : "Layer del foglio importato nascosto; le particelle restano visibili.");
+}
+
+function applyImportedSheetVisibility() {
+    if (!lmeState.map || !lmeState.importedSheets) {
+        return;
+    }
+    if (lmeState.importedSheetsVisible) {
+        if (!lmeState.map.hasLayer(lmeState.importedSheets)) {
+            lmeState.importedSheets.addTo(lmeState.map);
+        }
+        lmeState.importedSheets.bringToBack();
+        lmeState.imported.bringToFront();
+        return;
+    }
+    if (lmeState.map.hasLayer(lmeState.importedSheets)) {
+        lmeState.map.removeLayer(lmeState.importedSheets);
+    }
 }
 
 function setImportedMeasurementsVisible(enabled) {
@@ -798,11 +918,18 @@ function setDrawingMeasurementsVisible(enabled) {
 }
 
 function fitImported() {
-    fitLayer(lmeState.imported);
+    const layers = [lmeState.imported];
+    if (lmeState.importedSheetsVisible) {
+        layers.push(lmeState.importedSheets);
+    }
+    fitLayer(L.featureGroup(layers));
 }
 
 function clearImported() {
     lmeState.imported.clearLayers();
+    lmeState.importedSheets.clearLayers();
+    lmeState.importedSheetsVisible = false;
+    applyImportedSheetVisibility();
     lmeState.importedMeasurements.clearLayers();
     setInfo("File GIS rimossi.");
     updateGpsInsideState();
@@ -821,26 +948,27 @@ function addProjectMarker(name) {
     setInfo(`POI aggiunto: ${label}`);
 }
 
-function enableDrawTools() {
+function configureDrawLabels() {
-    if (lmeState.drawControl) {
+    L.drawLocal.draw.toolbar.buttons.polygon = "Misura area";
-        setInfo("Strumenti di disegno gia attivi.");
+    L.drawLocal.draw.toolbar.buttons.polyline = "Misura distanza";
+    L.drawLocal.draw.toolbar.buttons.circle = "Misura cerchio";
+    L.drawLocal.draw.toolbar.buttons.rectangle = "Disegna rettangolo";
+    L.drawLocal.draw.toolbar.buttons.marker = "Aggiungi POI";
+    L.drawLocal.edit.toolbar.buttons.edit = "Modifica disegni";
+    L.drawLocal.edit.toolbar.buttons.remove = "Elimina disegni";
+    L.drawLocal.draw.handlers.polygon.tooltip.start = "Tocca il primo vertice dell'area.";
+    L.drawLocal.draw.handlers.polygon.tooltip.cont = "Tocca per aggiungere un vertice.";
+    L.drawLocal.draw.handlers.polygon.tooltip.end = "Tocca il primo punto per chiudere l'area.";
+    L.drawLocal.draw.handlers.polyline.tooltip.start = "Tocca il primo punto della distanza.";
+    L.drawLocal.draw.handlers.polyline.tooltip.cont = "Tocca per aggiungere un tratto.";
+    L.drawLocal.draw.handlers.polyline.tooltip.end = "Tocca l'ultimo punto per terminare.";
+    L.drawLocal.draw.handlers.circle.tooltip.start = "Tocca il centro e trascina per il raggio.";
+}
+
+function bindDrawingEvents() {
+    if (!lmeState.map || lmeState.drawEventsBound) {
         return;
     }
-
-    lmeState.drawControl = new L.Control.Draw({
-        position: "topright",
-        edit: { featureGroup: lmeState.drawings },
-        draw: {
-            circle: { metric: true, feet: false },
-            circlemarker: false,
-            marker: true,
-            polygon: { metric: true, feet: false, showArea: true, allowIntersection: false },
-            polyline: { metric: true, feet: false, showLength: true },
-            rectangle: true
-        }
-    });
-    lmeState.map.addControl(lmeState.drawControl);
-    if (!lmeState.drawEventsBound) {
     lmeState.map.on(L.Draw.Event.CREATED, event => {
         annotateDrawingLayer(event.layer, event.layerType);
         lmeState.drawings.addLayer(event.layer);
@@ -868,18 +996,49 @@ function enableDrawTools() {
         lmeState.activeDrawHandler = null;
     });
     lmeState.drawEventsBound = true;
+}
+
+function enableDrawTools() {
+    if (lmeState.drawControl) {
+        setInfo("Strumenti di disegno gia attivi.");
+        return;
     }
-    setInfo("Disegno attivo: crea POI, linee e aree sulla mappa.");
+
+    configureDrawLabels();
+    const orangeArea = { color: "#f97316", weight: 4, fillColor: "#fb923c", fillOpacity: 0.2 };
+    lmeState.drawControl = new L.Control.Draw({
+        position: "topright",
+        edit: { featureGroup: lmeState.drawings },
+        draw: {
+            circle: { metric: true, feet: false, showRadius: true, shapeOptions: orangeArea },
+            circlemarker: false,
+            marker: true,
+            polygon: {
+                metric: true,
+                feet: false,
+                showArea: true,
+                allowIntersection: false,
+                shapeOptions: orangeArea
+            },
+            polyline: {
+                metric: true,
+                feet: false,
+                showLength: true,
+                shapeOptions: { color: "#f97316", weight: 4, opacity: 0.95 }
+            },
+            rectangle: { metric: true, shapeOptions: orangeArea }
+        }
+    });
+    lmeState.map.addControl(lmeState.drawControl);
+    bindDrawingEvents();
+    setInfo("Barra strumenti attiva: misure, disegni, POI, modifica e cancellazione.");
 }
 
 function startMeasurementDrawing(mode) {
     if (!lmeState.map) {
         return;
     }
-    if (!lmeState.drawEventsBound) {
+    bindDrawingEvents();
-        enableDrawTools();
-        setDrawToolsVisible(false);
-    }
     if (lmeState.activeDrawHandler) {
         lmeState.activeDrawHandler.disable();
     }
@@ -1199,7 +1358,7 @@ function formatNumber(value, digits) {
 function createProjectSnapshot(includeCadastralParcels) {
     const center = lmeState.map.getCenter();
     return JSON.stringify({
-        schemaVersion: 1,
+        schemaVersion: 3,
         view: {
             latitude: center.lat,
             longitude: center.lng,
@@ -1207,6 +1366,9 @@ function createProjectSnapshot(includeCadastralParcels) {
         },
         drawings: lmeState.drawings.toGeoJSON(),
         imported: lmeState.imported.toGeoJSON(),
+        importedSheets: lmeState.importedSheets.toGeoJSON(),
+        importedSheetsVisible: lmeState.importedSheetsVisible,
+        displayOptions: captureDisplayOptions(),
         selectedParcels: includeCadastralParcels
             ? lmeState.selectedParcelsLayer.toGeoJSON()
             : { type: "FeatureCollection", features: [] },
@@ -1234,6 +1396,7 @@ function loadProjectSnapshot(raw, projectName) {
 
         lmeState.drawings.clearLayers();
         lmeState.imported.clearLayers();
+        lmeState.importedSheets.clearLayers();
         lmeState.drawingMeasurements.clearLayers();
         lmeState.importedMeasurements.clearLayers();
         lmeState.selectedParcelsLayer.clearLayers();
@@ -1257,7 +1420,10 @@ function loadProjectSnapshot(raw, projectName) {
             onEachFeature: bindStoredFeaturePopup
         });
         restoredDrawings.eachLayer(layer => lmeState.drawings.addLayer(layer));
-        L.geoJSON(data.imported || emptyFeatureCollection(), {
+        const importedParts = partitionStoredImportedFeatures(
+            data.imported || emptyFeatureCollection(),
+            data.importedSheets || emptyFeatureCollection());
+        L.geoJSON(importedParts.parcels, {
             style: { color: "#22c55e", weight: 3, opacity: 0.95, fillOpacity: 0.18 },
             pointToLayer: (feature, latlng) => L.circleMarker(latlng, {
                 radius: 7,
@@ -1267,6 +1433,22 @@ function loadProjectSnapshot(raw, projectName) {
             }),
             onEachFeature: bindStoredFeaturePopup
         }).addTo(lmeState.imported);
+        L.geoJSON(importedParts.sheets, {
+            style: { color: "#15803d", weight: 3, opacity: 0.85, fillOpacity: 0.04, dashArray: "9 7" },
+            pointToLayer: (feature, latlng) => L.circleMarker(latlng, {
+                radius: 6,
+                color: "#15803d",
+                fillOpacity: 0.25
+            }),
+            onEachFeature: bindStoredFeaturePopup
+        }).addTo(lmeState.importedSheets);
+        const projectDisplayOptions = data.schemaVersion >= 3 && data.displayOptions
+            ? data.displayOptions
+            : null;
+        lmeState.importedSheetsVisible = projectDisplayOptions
+            ? Boolean(projectDisplayOptions.importedSheetsVisible)
+            : data.schemaVersion >= 2 && Boolean(data.importedSheetsVisible);
+        applyImportedSheetVisibility();
         L.geoJSON(data.selectedParcels || emptyFeatureCollection(), {
             style: { color: "#ef4444", weight: 4, opacity: 1, fillColor: "#fbbf24", fillOpacity: 0.26 },
             onEachFeature: (feature, layer) => {
@@ -1282,15 +1464,22 @@ function loadProjectSnapshot(raw, projectName) {
 
         lmeState.gpsTrailPoints = Array.isArray(data.trail) ? data.trail : [];
         lmeState.gpsTrail.setLatLngs(lmeState.gpsTrailPoints);
+        if (projectDisplayOptions) {
+            applyProjectDisplayOptions(projectDisplayOptions);
+        }
         refreshImportedMeasurements();
         refreshDrawingMeasurements();
 
-        const projectLayers = L.featureGroup([
+        const projectLayerList = [
             lmeState.drawings,
             lmeState.imported,
             lmeState.selectedParcelsLayer,
             lmeState.gpsTrail
-        ]);
+        ];
+        if (lmeState.importedSheetsVisible) {
+            projectLayerList.push(lmeState.importedSheets);
+        }
+        const projectLayers = L.featureGroup(projectLayerList);
         if (projectLayers.getBounds().isValid()) {
             fitLayer(projectLayers);
         } else if (Number.isFinite(data.view?.latitude)
@@ -1304,13 +1493,95 @@ function loadProjectSnapshot(raw, projectName) {
             ? `${parcelCount} particelle del progetto`
             : "Nessuna particella selezionata");
         updateGpsInsideState();
-        setInfo(`Progetto caricato: ${projectName || "senza nome"}.`);
+        const hiddenSheets = importedParts.sheets.features.length && !lmeState.importedSheetsVisible
+            ? ` ${importedParts.sheets.features.length} elementi del foglio sono nascosti.`
+            : "";
+        setInfo(`Progetto caricato: ${projectName || "senza nome"}.${hiddenSheets}`);
+        return captureDisplayOptions();
     } catch (error) {
         setInfo(`Progetto non leggibile: ${error.message}`);
         throw error;
     }
 }
 
+function captureDisplayOptions() {
+    return {
+        baseLayer: lmeState.currentBaseName,
+        cadastreOpacity: lmeState.cadastreOpacity,
+        cadastreLayers: [...lmeState.cadastreLayers],
+        includeKmlSheetLayer: lmeState.includeKmlSheetLayer,
+        importedSheetsVisible: lmeState.importedSheetsVisible,
+        showImportedMeasurements: lmeState.showImportedMeasurements,
+        showDrawingMeasurements: lmeState.showDrawingMeasurements,
+        drawToolsVisible: Boolean(lmeState.drawControl),
+        gpsPositionVisible: lmeState.gpsPositionVisible,
+        trailEnabled: lmeState.gpsTrailEnabled
+    };
+}
+
+function applyProjectDisplayOptions(options) {
+    const supportedCadastreLayers = new Set([
+        "CP.CadastralParcel",
+        "codice_plla",
+        "CP.CadastralZoning",
+        "fabbricati",
+        "strade",
+        "acque"
+    ]);
+    if (Array.isArray(options.cadastreLayers)) {
+        lmeState.cadastreLayers = options.cadastreLayers.filter(layer => supportedCadastreLayers.has(layer));
+    }
+
+    const opacity = Number(options.cadastreOpacity);
+    if (Number.isFinite(opacity)) {
+        lmeState.cadastreOpacity = Math.max(0, Math.min(1, opacity));
+    }
+    lmeState.includeKmlSheetLayer = Boolean(options.includeKmlSheetLayer);
+    lmeState.importedSheetsVisible = Boolean(options.importedSheetsVisible);
+    lmeState.showImportedMeasurements = Boolean(options.showImportedMeasurements);
+    lmeState.showDrawingMeasurements = options.showDrawingMeasurements !== false;
+    applyImportedSheetVisibility();
+    refreshCadastreLayer();
+
+    if (typeof options.baseLayer === "string") {
+        setBaseLayer(options.baseLayer);
+    }
+    setGpsPositionVisible(options.gpsPositionVisible !== false);
+    toggleTrail(Boolean(options.trailEnabled));
+    setDrawToolsVisible(Boolean(options.drawToolsVisible));
+}
+
+function partitionStoredImportedFeatures(imported, storedSheets) {
+    const parcelFeatures = [];
+    const sheetFeatures = [...(storedSheets?.features || [])];
+    const sourceGroups = new Map();
+
+    (imported?.features || []).forEach(feature => {
+        const source = String(feature?.properties?._lmeSource || "");
+        if (!/\.(kml|kmz)$/i.test(source)) {
+            parcelFeatures.push(feature);
+            return;
+        }
+        const group = sourceGroups.get(source) || [];
+        group.push(feature);
+        sourceGroups.set(source, group);
+    });
+
+    sourceGroups.forEach(features => {
+        const polygonParts = splitKmlPolygonFeatures(features);
+        const parcels = filterKmlParcelFeatures(polygonParts);
+        const parcelSet = new Set(parcels);
+        parcelFeatures.push(...parcels);
+        sheetFeatures.push(...polygonParts.filter(feature => !parcelSet.has(feature)));
+        sheetFeatures.push(...features.filter(feature => geometryPolygons(feature.geometry).length === 0));
+    });
+
+    return {
+        parcels: { type: "FeatureCollection", features: parcelFeatures },
+        sheets: { type: "FeatureCollection", features: sheetFeatures }
+    };
+}
+
 function emptyFeatureCollection() {
     return { type: "FeatureCollection", features: [] };
 }
@@ -1514,7 +1785,11 @@ function htmlToText(value) {
 }
 
 function setCadastreOpacity(value) {
-    lmeState.cadastreOpacity = Number(value || 0.75);
+    const opacity = Number(value);
+    if (!Number.isFinite(opacity)) {
+        return;
+    }
+    lmeState.cadastreOpacity = Math.max(0, Math.min(1, opacity));
     if (lmeState.cadastre) {
         lmeState.cadastre.setOpacity(lmeState.cadastreOpacity);
     }
@@ -1605,6 +1880,7 @@ function clearMapElements() {
     const count = lmeState.selectedParcelsLayer.getLayers().length
         + lmeState.gpsParcelLayer.getLayers().length
         + lmeState.imported.getLayers().length
+        + lmeState.importedSheets.getLayers().length
         + lmeState.drawings.getLayers().length
         + lmeState.gpsTrailPoints.length;
     if (!count) {
@@ -1618,6 +1894,7 @@ function clearMapElements() {
     lmeState.selectedParcelsLayer.clearLayers();
     lmeState.gpsParcelLayer.clearLayers();
     lmeState.imported.clearLayers();
+    lmeState.importedSheets.clearLayers();
     lmeState.drawings.clearLayers();
     lmeState.importedMeasurements.clearLayers();
     lmeState.drawingMeasurements.clearLayers();
@@ -1671,6 +1948,25 @@ function setNativeGpsPosition(location) {
     });
 }
 
+function setGpsPositionVisible(enabled) {
+    lmeState.gpsPositionVisible = Boolean(enabled);
+    if (!lmeState.gpsPositionVisible) {
+        if (lmeState.gpsMarker && lmeState.map.hasLayer(lmeState.gpsMarker)) {
+            lmeState.map.removeLayer(lmeState.gpsMarker);
+        }
+        if (lmeState.gpsAccuracy && lmeState.map.hasLayer(lmeState.gpsAccuracy)) {
+            lmeState.map.removeLayer(lmeState.gpsAccuracy);
+        }
+        setInfo("Punto e cerchio GPS nascosti. Il rilevamento continua.");
+        return;
+    }
+
+    if (lmeState.hasLiveGpsFix && lmeState.lastPosition) {
+        updateGpsPositionLayers(lmeState.lastPosition, lmeState.lastAccuracy);
+    }
+    setInfo("Punto e cerchio GPS visibili.");
+}
+
 function setGpsError(error) {
     setText("gpsState", "GPS non disponibile");
     setInfo(error || "Errore GPS.");
@@ -1695,14 +1991,12 @@ function onGpsPosition(position) {
     const { latitude, longitude, accuracy } = position.coords;
     const latlng = [latitude, longitude];
     lmeState.lastPosition = latlng;
-
+    lmeState.lastAccuracy = Math.max(0, Number(accuracy) || 0);
-    if (!lmeState.gpsMarker) {
+    const firstLiveFix = !lmeState.hasLiveGpsFix;
-        lmeState.gpsMarker = L.marker(latlng, { title: "La tua posizione" }).addTo(lmeState.map);
+    lmeState.hasLiveGpsFix = true;
-        lmeState.gpsAccuracy = L.circle(latlng, { radius: accuracy, color: "#2563eb", weight: 2, fillColor: "#60a5fa", fillOpacity: 0.16 }).addTo(lmeState.map);
+    updateGpsPositionLayers(latlng, lmeState.lastAccuracy);
+    if (firstLiveFix) {
         lmeState.map.setView(latlng, 19);
-    } else {
-        lmeState.gpsMarker.setLatLng(latlng);
-        lmeState.gpsAccuracy.setLatLng(latlng).setRadius(accuracy);
     }
 
     if (lmeState.gpsTrailEnabled) {
@@ -1710,10 +2004,35 @@ function onGpsPosition(position) {
         lmeState.gpsTrail.setLatLngs(lmeState.gpsTrailPoints);
     }
 
-    setText("gpsState", `${latitude.toFixed(6)}, ${longitude.toFixed(6)} - precisione ${Math.round(accuracy)} m`);
+    setText("gpsState", `${latitude.toFixed(6)}, ${longitude.toFixed(6)} - precisione ${Math.round(lmeState.lastAccuracy)} m`);
     updateGpsInsideState();
 }
 
+function updateGpsPositionLayers(latlng, accuracy) {
+    if (!lmeState.gpsPositionVisible) {
+        return;
+    }
+    if (!lmeState.gpsMarker) {
+        lmeState.gpsMarker = L.marker(latlng, { title: "La tua posizione" });
+        lmeState.gpsAccuracy = L.circle(latlng, {
+            radius: accuracy,
+            color: "#2563eb",
+            weight: 2,
+            fillColor: "#60a5fa",
+            fillOpacity: 0.16
+        });
+    } else {
+        lmeState.gpsMarker.setLatLng(latlng);
+        lmeState.gpsAccuracy.setLatLng(latlng).setRadius(accuracy);
+    }
+    if (!lmeState.map.hasLayer(lmeState.gpsMarker)) {
+        lmeState.gpsMarker.addTo(lmeState.map);
+    }
+    if (!lmeState.map.hasLayer(lmeState.gpsAccuracy)) {
+        lmeState.gpsAccuracy.addTo(lmeState.map);
+    }
+}
+
 function onGpsError(error) {
     setText("gpsState", "GPS non autorizzato o non disponibile");
     setInfo(error.message || "Errore GPS.");