Snap geometry edits

<?xml version="1.0" encoding="utf-8" ?>
<ContentPage x:Class="ArcGIS.Samples.SnapGeometryEdits.SnapGeometryEdits"
             xmlns="http://schemas.microsoft.com/dotnet/2021/maui"
             xmlns:x="http://schemas.microsoft.com/winfx/2009/xaml"
             xmlns:esriUI="clr-namespace:Esri.ArcGISRuntime.Maui;assembly=Esri.ArcGISRuntime.Maui"
             xmlns:local="clr-namespace:ArcGIS.Samples.SnapGeometryEdits">
    <ContentPage.Resources>
        <DataTemplate x:Key="SnapSettingTemplate" x:DataType="local:SnapSourceSettingsVM">
            <Grid ColumnSpacing="3">
                <Grid.ColumnDefinitions>
                    <ColumnDefinition Width="auto" />
                    <ColumnDefinition Width="*" />
                </Grid.ColumnDefinitions>
                <Label Grid.Column="0"
                       Text="{Binding Path=Name}"
                       VerticalOptions="Center"
                       WidthRequest="160" />
                <Switch Grid.Column="1"
                        HorizontalOptions="End"
                        IsToggled="{Binding Path=IsEnabled, Mode=TwoWay}"
                        VerticalOptions="Center" />
            </Grid>
        </DataTemplate>

        <Style x:Key="IconStyle" TargetType="Button">
            <Style.Setters>
                <Setter Property="FontFamily" Value="CalciteUIIconsMediumFontFamily" />
                <Setter Property="FontSize" Value="24" />
            </Style.Setters>
        </Style>
    </ContentPage.Resources>

    <Grid>
        <esriUI:MapView x:Name="MyMapView" />
        <Grid x:Name="CreateEditGeometriesPanel"
              Margin="10"
              ColumnDefinitions="110,110"
              ColumnSpacing="5"
              HorizontalOptions="End"
              IsVisible="False"
              RowDefinitions="auto,auto,auto,auto,auto,auto"
              RowSpacing="5"
              VerticalOptions="Start">
            <Button x:Name="ShowSnapSettingsButton"
                    Grid.Row="0"
                    Grid.ColumnSpan="2"
                    Clicked="ShowSnapSettingsButton_Clicked"
                    Text="Show snap settings" />
            <Border Grid.Row="1"
                    Grid.ColumnSpan="2"
                    BackgroundColor="{AppThemeBinding Dark=#3C3C3C,
                                                      Light=White}"
                    HeightRequest="40">
                <Border.StrokeShape>
                    <RoundRectangle CornerRadius="5" />
                </Border.StrokeShape>
                <Grid>
                    <Grid.ColumnDefinitions>
                        <ColumnDefinition Width="auto" />
                        <ColumnDefinition Width="*" />
                    </Grid.ColumnDefinitions>
                    <Label Grid.Column="0"
                           Margin="10,0"
                           Text="Reticle vertex tool"
                           VerticalOptions="Center" />
                    <Switch x:Name="ReticleVertexToolSwitch"
                            Grid.Column="1"
                            HorizontalOptions="End"
                            Toggled="ReticleVertexToolSwitch_Toggled"
                            VerticalOptions="Center" />
                </Grid>
            </Border>
            <Button x:Name="PointButton"
                    Grid.Row="2"
                    Grid.Column="0"
                    Clicked="PointButton_Click"
                    Style="{StaticResource IconStyle}"
                    Text="{StaticResource CalciteUIIcons_Glyph_Point}"
                    ToolTipProperties.Text="Point" />
            <Button x:Name="MultipointButton"
                    Grid.Row="2"
                    Grid.Column="1"
                    Clicked="MultipointButton_Click"
                    FontFamily="CalciteUIIconsSmallFontFamily"
                    FontSize="16"
                    Style="{StaticResource IconStyle}"
                    Text="&#xe9f9; &#xe9f9;"
                    ToolTipProperties.Text="Multipoint" />
            <Button x:Name="PolylineButton"
                    Grid.Row="3"
                    Grid.Column="0"
                    Clicked="PolylineButton_Click"
                    Style="{StaticResource IconStyle}"
                    Text="{StaticResource CalciteUIIcons_Glyph_Line}"
                    ToolTipProperties.Text="Polyline / no shape fill" />
            <Button x:Name="PolygonButton"
                    Grid.Row="3"
                    Grid.Column="1"
                    Clicked="PolygonButton_Click"
                    Style="{StaticResource IconStyle}"
                    Text="{StaticResource CalciteUIIcons_Glyph_PolygonVertices}"
                    ToolTipProperties.Text="Polygon / shape fill" />
            <Button Grid.Row="4"
                    Grid.Column="0"
                    Clicked="DeleteButton_Click"
                    IsEnabled="{Binding GeometryEditor.SelectedElement.CanDelete, Source={x:Reference MyMapView}, FallbackValue=False, x:DataType=esriUI:MapView}"
                    Style="{StaticResource IconStyle}"
                    Text="{StaticResource CalciteUIIcons_Glyph_Erase}"
                    ToolTipProperties.Text="Delete selected" />
            <Button Grid.Row="4"
                    Grid.Column="1"
                    Clicked="UndoButton_Click"
                    IsEnabled="{Binding GeometryEditor.CanUndo, Source={x:Reference MyMapView}, x:DataType=esriUI:MapView}"
                    Style="{StaticResource IconStyle}"
                    Text="{StaticResource CalciteUIIcons_Glyph_Undo}"
                    ToolTipProperties.Text="Undo" />
            <Button Grid.Row="5"
                    Grid.Column="0"
                    Clicked="DiscardButton_Click"
                    IsEnabled="{Binding GeometryEditor.IsStarted, Source={x:Reference MyMapView}, x:DataType=esriUI:MapView}"
                    Style="{StaticResource IconStyle}"
                    Text="{StaticResource CalciteUIIcons_Glyph_CircleDisallowed}"
                    ToolTipProperties.Text="Discard edits" />
            <Button Grid.Row="5"
                    Grid.Column="1"
                    Clicked="SaveButton_Click"
                    IsEnabled="{Binding GeometryEditor.CanUndo, Source={x:Reference MyMapView}, x:DataType=esriUI:MapView}"
                    Style="{StaticResource IconStyle}"
                    Text="{StaticResource CalciteUIIcons_Glyph_CheckCircle}"
                    ToolTipProperties.Text="Save edits" />
        </Grid>

        <Grid x:Name="SnappingSettingsPopup"
              Grid.ColumnSpan="2"
              Padding="10"
              Background="#AA333333"
              IsVisible="False">
            <Border x:Name="SnapSettingsContainer"
                    Margin="10"
                    Background="{AppThemeBinding Dark=Black,
                                                 Light=White}"
                    HorizontalOptions="Center"
                    MaximumHeightRequest="450"
                    MaximumWidthRequest="300"
                    StrokeShape="RoundRectangle 10"
                    VerticalOptions="Center">
                <ScrollView>
                    <VerticalStackLayout Margin="10">
                        <Grid ColumnDefinitions="auto,*">
                            <Label Padding="0,5"
                                   FontAttributes="Bold"
                                   FontSize="14"
                                   Text="Snap settings" />
                            <Button Grid.Column="1"
                                    Margin="20,0"
                                    Clicked="EnableAllSnapSettingsButton_Click"
                                    HorizontalOptions="End"
                                    Text="Enable all"
                                    VerticalOptions="Center" />
                        </Grid>
                        <VerticalStackLayout HeightRequest="130">
                            <Grid ColumnSpacing="3">
                                <Grid.ColumnDefinitions>
                                    <ColumnDefinition Width="auto" />
                                    <ColumnDefinition Width="*" />
                                </Grid.ColumnDefinitions>
                                <Label Grid.Column="0"
                                       Text="Snapping"
                                       VerticalOptions="Center"
                                       WidthRequest="160" />
                                <Switch Grid.Column="1"
                                        HorizontalOptions="End"
                                        IsToggled="{Binding GeometryEditor.SnapSettings.IsEnabled, Source={x:Reference MyMapView}, x:DataType=esriUI:MapView}"
                                        VerticalOptions="Center" />
                            </Grid>
                            <Grid ColumnSpacing="3">
                                <Grid.ColumnDefinitions>
                                    <ColumnDefinition Width="auto" />
                                    <ColumnDefinition Width="*" />
                                </Grid.ColumnDefinitions>
                                <Label Grid.Column="0"
                                       Text="Geometry guides"
                                       VerticalOptions="Center"
                                       WidthRequest="160" />
                                <Switch Grid.Column="1"
                                        HorizontalOptions="End"
                                        IsEnabled="{Binding GeometryEditor.SnapSettings.IsEnabled, Source={x:Reference MyMapView}, x:DataType=esriUI:MapView}"
                                        IsToggled="{Binding GeometryEditor.SnapSettings.IsGeometryGuidesEnabled, Source={x:Reference MyMapView}, x:DataType=esriUI:MapView}"
                                        VerticalOptions="Center" />
                            </Grid>
                            <Grid ColumnSpacing="3">
                                <Grid.ColumnDefinitions>
                                    <ColumnDefinition Width="auto" />
                                    <ColumnDefinition Width="*" />
                                </Grid.ColumnDefinitions>
                                <Label Grid.Column="0"
                                       Text="Feature snapping"
                                       VerticalOptions="Center"
                                       WidthRequest="160" />
                                <Switch Grid.Column="1"
                                        HorizontalOptions="End"
                                        IsEnabled="{Binding GeometryEditor.SnapSettings.IsEnabled, Source={x:Reference MyMapView}, x:DataType=esriUI:MapView}"
                                        IsToggled="{Binding GeometryEditor.SnapSettings.IsFeatureSnappingEnabled, Source={x:Reference MyMapView}, x:DataType=esriUI:MapView}"
                                        VerticalOptions="Center" />
                            </Grid>
                        </VerticalStackLayout>
                        <BoxView Margin="0,0,0,5"
                                 HeightRequest="1"
                                 Color="White" />
                        <Label Padding="0,5"
                               FontAttributes="Bold"
                               FontSize="14"
                               Text="Snap sources" />
                        <Grid ColumnDefinitions="auto,*">
                            <Label Grid.Column="0"
                                   Text="Point layers:"
                                   VerticalOptions="Center" />
                            <Button Grid.Column="1"
                                    Margin="20,0"
                                    Clicked="EnableAllPointSnapSourceButton_Click"
                                    HorizontalOptions="End"
                                    Text="Enable all"
                                    VerticalOptions="Center" />
                        </Grid>
                        <CollectionView x:Name="PointSnapSettingsList"
                                        HeightRequest="150"
                                        ItemTemplate="{StaticResource SnapSettingTemplate}"
                                        WidthRequest="250" />
                        <Grid Margin="0,10,0,0" ColumnDefinitions="0.5*,auto">
                            <Label Grid.Column="0"
                                   Text="Polyline layers:"
                                   VerticalOptions="Center" />
                            <Button Grid.Column="1"
                                    Margin="20,0"
                                    Clicked="EnableAllPolylineSnapSourceButton_Click"
                                    HorizontalOptions="End"
                                    Text="Enable all"
                                    VerticalOptions="Center" />
                        </Grid>
                        <CollectionView x:Name="PolylineSnapSettingsList"
                                        HeightRequest="90"
                                        ItemTemplate="{StaticResource SnapSettingTemplate}"
                                        WidthRequest="250" />
                        <Grid Margin="0,10,0,0">
                            <Label Text="Graphics overlays:" VerticalOptions="Center" />
                        </Grid>
                        <CollectionView x:Name="GraphicsOverlaySnapSettingsList"
                                        HeightRequest="60"
                                        ItemTemplate="{StaticResource SnapSettingTemplate}"
                                        WidthRequest="250" />
                    </VerticalStackLayout>
                </ScrollView>
            </Border>
        </Grid>
    </Grid>
</ContentPage>

// Copyright 2024 Esri.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
// You may obtain a copy of the License at: http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
// language governing permissions and limitations under the License.

using Esri.ArcGISRuntime.Data;
using Esri.ArcGISRuntime.Geometry;
using Esri.ArcGISRuntime.Mapping;
using Esri.ArcGISRuntime.Maui;
using Esri.ArcGISRuntime.Toolkit.Maui;
using Esri.ArcGISRuntime.UI;
using Esri.ArcGISRuntime.UI.Editing;
using Microsoft.Maui.ApplicationModel;
using System.ComponentModel;
using System.Runtime.CompilerServices;
using Map = Esri.ArcGISRuntime.Mapping.Map;

namespace ArcGIS.Samples.SnapGeometryEdits
{
    [ArcGIS.Samples.Shared.Attributes.Sample(
        name: "Snap geometry edits",
        category: "Geometry",
        description: "Use the Geometry Editor to edit a geometry and align it to existing geometries on a map.",
        instructions: "To create a geometry, press the create button to choose the geometry type you want to create (i.e. points, multipoints, polyline, or polygon) and interactively tap and drag on the map view to create the geometry.",
        tags: new[] { "edit", "feature", "geometry editor", "graphics", "layers", "map", "snapping" })]
    public partial class SnapGeometryEdits : ContentPage
    {
        // Hold references for use in event handlers.
        private GeometryEditor _geometryEditor;
        private GraphicsOverlay _graphicsOverlay;
        private Graphic _selectedGraphic;
        private List<Button> _geometryEditorToolButtons;

        public SnapGeometryEdits()
        {
            InitializeComponent();
            _ = Initialize();
        }

        private async Task Initialize()
        {
            // Create a map using a Uri.
            var myMap = new Map(new Uri("https://www.arcgis.com/home/item.html?id=b95fe18073bc4f7788f0375af2bb445e"));

            // Set the map load setting feature tiling mode.
            // Enabled with full resolution when supported is used to ensure that snapping to geometries occurs in full resolution.
            // Snapping in full resolution improves snapping accuracy.
            myMap.LoadSettings.FeatureTilingMode = FeatureTilingMode.EnabledWithFullResolutionWhenSupported;

            // Set the initial viewpoint.
            myMap.InitialViewpoint = new Viewpoint(new MapPoint(-9812798, 5126406, SpatialReferences.WebMercator), 2000);

            // Create a graphics overlay and add it to the map view.
            _graphicsOverlay = new GraphicsOverlay();
            MyMapView.GraphicsOverlays.Add(_graphicsOverlay);

            // Add the map to the map view.
            MyMapView.Map = myMap;

            // Create and add a geometry editor to the map view.
            _geometryEditor = new GeometryEditor();
            MyMapView.GeometryEditor = _geometryEditor;

            // Load the map.
            await myMap.LoadAsync();

            // Ensure all layers are loaded before setting the snap settings.
            // If this is not awaited there is a risk that operational layers may not have loaded and therefore would not have been included in the snap sources.
            await Task.WhenAll(MyMapView.Map.OperationalLayers.ToList().Select(layer => layer.LoadAsync()).ToList());

            // Set the snap source settings.
            SetSnapSettings();

            // Show the create and edit geometries UI.
            CreateEditGeometriesPanel.IsVisible = true;

            // Store a reference to the geometry editor tool buttons to update their background color when selected.
            _geometryEditorToolButtons = new List<Button>()
            {
                PointButton,
                PolylineButton,
                PolygonButton,
                MultipointButton
            };

            // Hide the popup when user taps screen.
            SnappingSettingsPopup.GestureRecognizers.Add(new TapGestureRecognizer
            {
                Command = new Command(() =>
                {
                    SnappingSettingsPopup.IsVisible = false;
                })
            });

            // Add an event handler to detect geoview tapped events.
            MyMapView.GeoViewTapped += MyMapView_GeoViewTapped;
        }

        private void SetSnapSettings()
        {
            // Synchronize the snap source collection with the map's operational layers.
            // Note that layers that have not been loaded will not synchronize.
            _geometryEditor.SnapSettings.SyncSourceSettings();

            // Enable snapping on the geometry layer.
            _geometryEditor.SnapSettings.IsEnabled = true;

            // Create a list of snap source settings with snapping disabled.
            List<SnapSourceSettingsVM> snapSourceSettingsVMs = _geometryEditor.SnapSettings.SourceSettings.Select(sourceSettings => new SnapSourceSettingsVM(sourceSettings) { IsEnabled = false }).ToList();

            // Populate lists of snap source settings for point and polyline layers.
            PointSnapSettingsList.ItemsSource = snapSourceSettingsVMs.Where(snapSourceSettingVM => snapSourceSettingVM.GeometryType == GeometryType.Point).ToList();
            PolylineSnapSettingsList.ItemsSource = snapSourceSettingsVMs.Where(snapSourceSettingVM => snapSourceSettingVM.GeometryType == GeometryType.Polyline).ToList();

            // Populate a list of snap source settings for graphics overlays.
            GraphicsOverlaySnapSettingsList.ItemsSource = snapSourceSettingsVMs.Where(snapSourceSettingsVMs => snapSourceSettingsVMs.SnapSourceSettings.Source is GraphicsOverlay).ToList();
        }

        private void CreateNewGraphic()
        {
            // Get the new geometry from the geometry editor.
            Geometry geometry = _geometryEditor.Stop();

            // Create a graphic.
            var graphic = new Graphic(geometry);

            // Create a geometry editor style to get symbols for the new graphic.
            var geometryEditorStyle = new GeometryEditorStyle();

            switch (geometry.GeometryType)
            {
                case GeometryType.Point:
                    graphic.Symbol = geometryEditorStyle.VertexSymbol;
                    break;
                case GeometryType.Envelope:
                    graphic.Symbol = geometryEditorStyle.LineSymbol;
                    break;
                case GeometryType.Polyline:
                    graphic.Symbol = geometryEditorStyle.LineSymbol;
                    break;
                case GeometryType.Polygon:
                    graphic.Symbol = geometryEditorStyle.FillSymbol;
                    break;
                case GeometryType.Multipoint:
                    graphic.Symbol = geometryEditorStyle.VertexSymbol;
                    break;
            }

            // Add the graphic to the GraphicsOverlay and unselect it.
            _graphicsOverlay.Graphics.Add(graphic);
            graphic.IsSelected = false;
        }

        private async void MyMapView_GeoViewTapped(object sender, GeoViewInputEventArgs e)
        {
            // If the geometry editor is active then stop.
            if (_geometryEditor.IsStarted) return;

            try
            {
                // Get the list of identified graphics overlay results based on tap position.
                IReadOnlyList<IdentifyGraphicsOverlayResult> results = await MyMapView.IdentifyGraphicsOverlaysAsync(e.Position, 10, false);

                // If a graphics overlay result has been tapped and contains a corresponding graphic,
                // set the selected graphic and start the geometry editor.
                if (results.Any() && results[0].Graphics.Any())
                {
                    _selectedGraphic = results[0].Graphics[0];
                    _selectedGraphic.IsSelected = true;
                }
                else
                {
                    // No results have been found, update the selected graphic.
                    _selectedGraphic = null;
                }
            }
            catch (Exception ex)
            {
                await Application.Current.Windows[0].Page.DisplayAlert("Error editing", ex.Message, "OK");

                // Reset the UI.
                ResetFromEditingSession();
                return;
            }

            if (_selectedGraphic == null) return;

            // Hide the selected graphic and start an editing session with a copy of it.
            _geometryEditor.Start(_selectedGraphic.Geometry);
            _selectedGraphic.IsVisible = false;
        }

        // Reset the UI after the editor stops.
        private void ResetFromEditingSession()
        {
            // Reset the selected graphic.
            if (_selectedGraphic != null)
            {
                _selectedGraphic.IsSelected = false;
                _selectedGraphic.IsVisible = true;
            }

            // Reset the geometry tool button colors.
            foreach (var button in _geometryEditorToolButtons)
            {
                switch (Application.Current.RequestedTheme)
                {
                    case AppTheme.Dark:
                        button.BackgroundColor = Color.FromArgb("#3C3C3C");
                        break;
                    default:
                        button.BackgroundColor = Colors.White;
                        break;
                }
            }

            // Update the selected graphic.
            _selectedGraphic = null;
        }

        #region Enable Snapping Button Handlers
        // Enable all point layer snap sources.
        private void EnableAllSnapSettingsButton_Click(object sender, EventArgs e)
        {
            _geometryEditor.SnapSettings.IsEnabled = true;
            _geometryEditor.SnapSettings.IsGeometryGuidesEnabled = true;
            _geometryEditor.SnapSettings.IsFeatureSnappingEnabled = true;
        }

        // Enable all point layer snap sources.
        private void EnableAllPointSnapSourceButton_Click(object sender, EventArgs e)
        {
            foreach (var item in PointSnapSettingsList.ItemsSource)
            {
                if (item is SnapSourceSettingsVM snapSourceSettingsVM)
                {
                    snapSourceSettingsVM.IsEnabled = true;
                }
            }
        }

        // Enable all polyline layer snap sources.
        private void EnableAllPolylineSnapSourceButton_Click(object sender, EventArgs e)
        {
            foreach (var item in PolylineSnapSettingsList.ItemsSource)
            {
                if (item is SnapSourceSettingsVM snapSourceSettingsVM)
                {
                    snapSourceSettingsVM.IsEnabled = true;
                }
            }
        }
        #endregion

        #region Geometry Management Button Handlers
        private void DeleteButton_Click(object sender, EventArgs e)
        {
            _geometryEditor.DeleteSelectedElement();
        }

        private void UndoButton_Click(object sender, EventArgs e)
        {
            _geometryEditor.Undo();
        }

        private void SaveButton_Click(object sender, EventArgs e)
        {
            if (_selectedGraphic?.Geometry != null)
            {
                _selectedGraphic.Geometry = _geometryEditor.Stop();
                _selectedGraphic.IsSelected = false;
            }
            else if (_geometryEditor.IsStarted)
            {
                CreateNewGraphic();
            }

            ResetFromEditingSession();
        }

        private void DiscardButton_Click(object sender, EventArgs e)
        {
            _geometryEditor.Stop();

            ResetFromEditingSession();
        }
        #endregion

        #region Geometry Tool Buttons Handlers
        private void ReticleVertexToolSwitch_Toggled(object sender, ToggledEventArgs e)
        {
            if (ReticleVertexToolSwitch.IsToggled)
            {
                _geometryEditor.Tool = new ReticleVertexTool();
            }
            else
            {
                _geometryEditor.Tool = new VertexTool();
            }
        }

        private void PointButton_Click(object sender, EventArgs e)
        {
            if (_geometryEditor.IsStarted)
            {
                _geometryEditor.Stop();
            }

            ResetFromEditingSession();

            PointButton.BackgroundColor = Application.Current.RequestedTheme == AppTheme.Dark ? Colors.Gray : Colors.LightGray;
            _geometryEditor.Start(GeometryType.Point);
        }

        private void MultipointButton_Click(object sender, EventArgs e)
        {
            if (_geometryEditor.IsStarted)
            {
                _geometryEditor.Stop();
            }

            ResetFromEditingSession();

            MultipointButton.BackgroundColor = Application.Current.RequestedTheme == AppTheme.Dark ? Colors.Gray : Colors.LightGray;
            _geometryEditor.Start(GeometryType.Multipoint);
        }

        private void PolylineButton_Click(object sender, EventArgs e)
        {
            if (_geometryEditor.IsStarted)
            {
                _geometryEditor.Stop();
            }

            ResetFromEditingSession();

            PolylineButton.BackgroundColor = Application.Current.RequestedTheme == AppTheme.Dark ? Colors.Gray : Colors.LightGray;
            _geometryEditor.Start(GeometryType.Polyline);
        }
        private void PolygonButton_Click(object sender, EventArgs e)
        {
            if (_geometryEditor.IsStarted)
            {
                _geometryEditor.Stop();
            }

            ResetFromEditingSession();

            PolygonButton.BackgroundColor = Application.Current.RequestedTheme == AppTheme.Dark ? Colors.Gray : Colors.LightGray;
            _geometryEditor.Start(GeometryType.Polygon);
        }
        #endregion

        #region Snap Settings Visibility Button Handlers
        private void ShowSnapSettingsButton_Clicked(object sender, EventArgs e)
        {
            SnappingSettingsPopup.IsVisible = true;
        }
        #endregion
    }

    public class SnapSourceSettingsVM : INotifyPropertyChanged
    {
        public SnapSourceSettings SnapSourceSettings { get; set; }

        // Wrap the snap source settings in a view model to expose them to the UI.
        public SnapSourceSettingsVM(SnapSourceSettings snapSourceSettings)
        {
            SnapSourceSettings = snapSourceSettings;

            if (snapSourceSettings.Source is FeatureLayer featureLayer)
            {
                Name = featureLayer.Name;

                if (featureLayer.FeatureTable != null)
                {
                    GeometryType = featureLayer.FeatureTable.GeometryType;
                }
            }
            else if (snapSourceSettings.Source is GraphicsOverlay graphicsOverlay)
            {
                Name = "Editor graphics overlay";
            }

            IsEnabled = snapSourceSettings.IsEnabled;
        }

        private string _name;
        public string Name
        {
            get
            {
                return _name;
            }
            set
            {
                _name = value;
                OnPropertyChanged();
            }
        }

        private bool _isEnabled;
        public bool IsEnabled
        {
            get
            {
                return _isEnabled;
            }
            set
            {
                _isEnabled = value;
                SnapSourceSettings.IsEnabled = value;
                OnPropertyChanged();
            }
        }

        public GeometryType GeometryType { get; set; }

        public event PropertyChangedEventHandler PropertyChanged;

        protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
        {
            var handler = PropertyChanged;
            if (handler != null) handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}