Merge pull request #1463 from Esri/Ting/FeatureEditorToolbar

yo1995 · web-flow · commit 4cd7ba15bd6a · 2026-06-12T12:09:54.000-07:00
fe: Add `FeatureEditorToolbar`
diff --git a/Sources/ArcGISToolkit/Components/FeatureEditor/FeatureEditorModel.swift b/Sources/ArcGISToolkit/Components/FeatureEditor/FeatureEditorModel.swift
@@ -0,0 +1,29 @@
+// Copyright 2026 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
+//
+//   https://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.
+
+import ArcGIS
+import Observation
+
+/// The data model for the feature editor.
+@MainActor
+@Observable
+final class FeatureEditorModel {
+    let feature: ArcGISFeature
+    let geometryEditor: GeometryEditor
+    
+    init(feature: ArcGISFeature, geometryEditor: GeometryEditor) {
+        self.feature = feature
+        self.geometryEditor = geometryEditor
+    }
+}
diff --git a/Sources/ArcGISToolkit/Components/FeatureEditor/FeatureEditorToolbar.swift b/Sources/ArcGISToolkit/Components/FeatureEditor/FeatureEditorToolbar.swift
@@ -0,0 +1,85 @@
+// Copyright 2026 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
+//
+//   https://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.
+
+import SwiftUI
+
+/// The `FeatureEditorToolbar` component allows users to edit geometries in the
+/// feature editor.
+///
+/// **Features**
+///
+/// - Displays controls for performing common geometry editing actions:
+///     - Changing the tool.
+///     - Deleting the selected element.
+///     - Undoing the last action on the geometry.
+///     - Redoing the last undone action.
+///     - Configuring snap settings.
+/// - Supports styled vertical and horizontal layouts, or no built-in layout or styling.
+///
+/// **Behavior**
+///
+/// The toolbar is shown only while the feature editor is editing a geometry.
+///
+/// By default, the toolbar is displayed in a vertical layout. Pass `nil` for `style` to display
+/// the toolbar without built-in layout or styling, so you can show it in a system toolbar or apply
+/// your own layout and styling to the controls.
+///
+/// The settings button is only shown when the geometry editor has snap settings with non-empty
+/// source settings.
+///
+/// **Associated Types**
+///
+/// - ``Style``
+public struct FeatureEditorToolbar: View {
+    /// The style to apply to the toolbar's controls.
+    private let style: Style?
+    /// The model for the parent feature editor.
+    @Environment(FeatureEditorModel.self) private var featureEditorModel
+    
+    /// Creates a feature editor toolbar.
+    /// - Parameter style: The style that determines the toolbar's appearance and layout.
+    /// A `nil` value displays the toolbar's controls without built-in layout or styling.
+    public init(style: Style? = .vertical) {
+        self.style = style
+    }
+    
+    public var body: some View {
+        GeometryEditorToolbar(
+            geometryEditor: featureEditorModel.geometryEditor,
+            style: GeometryEditorToolbar.Style(featureEditorToolbarStyle: style)
+        )
+        // Only shows snap settings for features in layers.
+        .snapSources(.layers)
+    }
+}
+
+extension FeatureEditorToolbar {
+    /// A style that determines the appearance and layout of a feature editor toolbar.
+    public enum Style {
+        /// Displays the toolbar in a styled horizontal layout.
+        case horizontal
+        /// Displays the toolbar in a styled vertical layout.
+        case vertical
+    }
+}
+
+private extension GeometryEditorToolbar.Style {
+    init?(featureEditorToolbarStyle: FeatureEditorToolbar.Style?) {
+        switch featureEditorToolbarStyle {
+        case .horizontal: self = .horizontal
+        case .vertical: self = .vertical
+        default: return nil
+        }
+    }
+}
diff --git a/Sources/ArcGISToolkit/Components/GeometryEditorToolbar/GeometryEditorToolbar.swift b/Sources/ArcGISToolkit/Components/GeometryEditorToolbar/GeometryEditorToolbar.swift
@@ -17,36 +17,13 @@ import SwiftUI
 
 /// The `GeometryEditorToolbar` component allows users to perform common actions on a
 /// `GeometryEditor`.
-///
-/// **Features**
-///
-/// - Displays controls for performing common geometry editor actions:
-///     - Changing the tool.
-///     - Deleting the selected element.
-///     - Undoing the last action on the geometry.
-///     - Redoing the last undone action.
-///     - Configuring snap settings.
-/// - Supports styled vertical and horizontal layouts, or no built-in layout or styling.
-///
-/// **Behavior**
-///
-/// The toolbar is shown only while the geometry editor is started.
-///
-/// By default, the toolbar is displayed in a vertical layout. Pass `nil` for `style` to display
-/// the toolbar without built-in layout or styling, so you can show it in a system toolbar or apply
-/// your own layout and styling to the controls.
-///
-/// The settings button is only shown when the geometry editor has snap settings with non-empty
-/// source settings.
-///
-/// **Associated Types**
-///
-/// - ``Style``
 struct GeometryEditorToolbar: View {
     /// The geometry editor that this toolbar controls.
     private let geometryEditor: GeometryEditor
     /// The style to apply to the toolbar's controls.
     private let style: Style?
+    /// The allowed snap source types for snap settings UI.
+    private var snapSources: SnapSources
     
     /// The spacing to apply between the controls in the stacks.
     /// This is hardcoded to match the system styling for toolbar groups on iOS.
@@ -68,6 +45,7 @@ struct GeometryEditorToolbar: View {
         geometryEditor.snapSettings.isEnabled = true
         self.geometryEditor = geometryEditor
         self.style = style
+        self.snapSources = .all
         
         let model = GeometryEditorToolbarModel(geometryEditor: geometryEditor)
         self._model = .init(wrappedValue: model)
@@ -109,7 +87,19 @@ struct GeometryEditorToolbar: View {
         DeleteButton()
         UndoButton()
         RedoButton()
-        SnapSettingsButton()
+        SnapSettingsButton(snapSources: snapSources)
+    }
+}
+
+extension GeometryEditorToolbar {
+    /// Limits the snap source types available in the snap settings UI.
+    /// Disallowed snap sources are hidden in the UI and disabled in the underlying `SnapSettings`.
+    /// - Parameter snapSources: The allowed snap source types.
+    /// - Returns: A toolbar with snap settings restricted to `snapSources`.
+    func snapSources(_ snapSources: SnapSources) -> Self {
+        var copy = self
+        copy.snapSources = snapSources
+        return copy
     }
 }
 
@@ -154,6 +144,53 @@ extension GeometryEditorToolbar {
         /// Displays the toolbar in a styled vertical layout.
         case vertical
     }
+    
+    /// A set of `SnapSource` types allowed in the snap settings UI.
+    struct SnapSources: OptionSet {
+        let rawValue: Int
+        
+        /// Allows `FeatureLayer` snap sources.
+        static let featureLayer = SnapSources(rawValue: 1 << 0)
+        /// Allows `GraphicsOverlay` snap sources.
+        static let graphicsOverlay = SnapSources(rawValue: 1 << 1)
+        /// Allows `SubtypeFeatureLayer` snap sources.
+        static let subtypeFeatureLayer = SnapSources(rawValue: 1 << 2)
+        /// Allows `SubtypeSublayer` snap sources.
+        static let subtypeSublayer = SnapSources(rawValue: 1 << 3)
+        
+        /// Allows all supported `SnapSource` types.
+        static let all: SnapSources = [
+            .featureLayer,
+            .graphicsOverlay,
+            .subtypeFeatureLayer,
+            .subtypeSublayer
+        ]
+        /// Allows `SnapSource` types that are layers.
+        static let layers: SnapSources = [
+            .featureLayer,
+            .subtypeFeatureLayer,
+            .subtypeSublayer
+        ]
+        
+        /// Returns a Boolean value indicating whether a snap source type is
+        /// allowed by the set.
+        /// - Parameter source: A snap source to check for allowance by the set.
+        /// - Returns: `true` if the snap source type is in the set, otherwise `false`.
+        func contains(source: some SnapSource) -> Bool {
+            switch source {
+            case is FeatureLayer:
+                contains(.featureLayer)
+            case is GraphicsOverlay:
+                contains(.graphicsOverlay)
+            case is SubtypeFeatureLayer:
+                contains(.subtypeFeatureLayer)
+            case is SubtypeSublayer:
+                contains(.subtypeSublayer)
+            default:
+                false
+            }
+        }
+    }
 }
 
 // MARK: - Controls
@@ -249,6 +286,8 @@ private struct UndoButton: View {
 private struct SnapSettingsButton: View {
     /// The model for the parent geometry editor toolbar.
     @Environment(GeometryEditorToolbarModel.self) private var model
+    /// The allowed snap source types shown in settings.
+    let snapSources: GeometryEditorToolbar.SnapSources
     
     /// A Boolean value indicating whether the settings view is presented.
     @State private var isShowingSettings = false
@@ -269,9 +308,12 @@ private struct SnapSettingsButton: View {
                 }
             }
             .sheet(isPresented: $isShowingSettings) {
-                SnapSettingsView(settings: model.geometryEditor.snapSettings)
+                SnapSettingsView(
+                    settings: model.geometryEditor.snapSettings,
+                    snapSources: snapSources
+                )
                 // Needed to override the font set in toolbarStackStyle.
-                    .font(nil)
+                .font(nil)
             }
         }
     }
diff --git a/Sources/ArcGISToolkit/Components/GeometryEditorToolbar/SnapSettingsView.swift b/Sources/ArcGISToolkit/Components/GeometryEditorToolbar/SnapSettingsView.swift
@@ -19,6 +19,8 @@ import SwiftUI
 struct SnapSettingsView: View {
     /// The snap settings to configure.
     let settings: SnapSettings
+    /// The allowed snap source types shown in the source settings list.
+    let snapSources: GeometryEditorToolbar.SnapSources
     
     /// The view models for the root `SnapSourceSettingsToggle` views in the outline group.
     @State private var rootSourceSettingsModels: [SnapSourceSettingsToggle.Model] = []
@@ -47,7 +49,7 @@ struct SnapSettingsView: View {
                 
                 Toggle(isOn: $snapsToFeatures.animation()) {
                     Text(
-                        "Snap to Features and Graphics",
+                        "Snap to Features",
                         bundle: .toolkitModule,
                         comment: """
                                 A label for a toggle that enables snapping to features and graphics,
@@ -60,7 +62,7 @@ struct SnapSettingsView: View {
                     settings.snapsToFeatures = snapsToFeatures
                 }
                 
-                if snapsToFeatures {
+                if snapsToFeatures, !rootSourceSettingsModels.isEmpty {
                     Section {
                         OutlineGroup(rootSourceSettingsModels, children: \.children) { model in
                             SnapSourceSettingsToggle(model: model)
@@ -78,10 +80,22 @@ struct SnapSettingsView: View {
                 }
             }
             .onChange(of: ObjectIdentifier(settings), initial: true) {
+                // Only allows certain snap sources.
+                rootSourceSettingsModels = settings.sourceSettings
+                    .compactMap { settings in
+                        guard snapSources.contains(source: settings.source) else { return nil }
+                        return SnapSourceSettingsToggle.Model(settings: settings)
+                    }
+                
+                // Disable snapping on other snap sources that aren't exposed
+                // in the UI to avoid confusion.
+                for sourceSettings in settings.sourceSettings {
+                    if !snapSources.contains(source: sourceSettings.source) {
+                        sourceSettings.isEnabled = false
+                    }
+                }
+                
                 // Sets up view's state properties using settings' property values.
-                rootSourceSettingsModels = settings.sourceSettings.map(
-                    SnapSourceSettingsToggle.Model.init(settings:)
-                )
                 snapsToFeatures = settings.snapsToFeatures
                 snapsToGeometryGuides = settings.snapsToGeometryGuides
             }
@@ -212,5 +226,5 @@ private extension SnapSourceSettingsToggle {
 }
 
 #Preview {
-    SnapSettingsView(settings: SnapSettings())
+    SnapSettingsView(settings: SnapSettings(), snapSources: .all)
 }
