# https://developer.apple.com/documentation/swiftui/ Framework # SwiftUI Declare the user interface and behavior for your app on every platform. ## Overview SwiftUI provides views, controls, and layout structures for declaring your app’s user interface. The framework provides event handlers for delivering taps, gestures, and other types of input to your app, and tools to manage the flow of data from your app’s models down to the views and controls that users see and interact with. Define your app structure using the `App` protocol, and populate it with scenes that contain the views that make up your app’s user interface. Create your own custom views that conform to the `View` protocol, and compose them with SwiftUI views for displaying text, images, and custom shapes using stacks, lists, and more. Apply powerful modifiers to built-in views and your own views to customize their rendering and interactivity. Share code between apps on multiple platforms with views and controls that adapt to their context and presentation. You can integrate SwiftUI views with objects from the UIKit, AppKit, and WatchKit frameworks to take further advantage of platform-specific functionality. You can also customize accessibility support in SwiftUI, and localize your app’s interface for different languages, countries, or cultural regions. ### Featured samples     ## Topics ### Essentials Adopting Liquid Glass Find out how to bring the new material to your app. Learning SwiftUI Discover tips and techniques for building multiplatform apps with this set of conceptual articles and sample code. Exploring SwiftUI Sample Apps Explore these SwiftUI samples using Swift Playgrounds on iPad or in Xcode to learn about defining user interfaces, responding to user interactions, and managing data flow. SwiftUI updates Learn about important changes to SwiftUI. Landmarks: Building an app with Liquid Glass Enhance your app experience with system-provided and custom Liquid Glass. ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. ### Data and storage Manage the data that your app uses to drive its interface. Share data throughout a view hierarchy using the environment. Indicate configuration preferences from views to their container views. Store data for use across sessions of your app. ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. ### View layout Arrange views inside built-in layout containers like stacks and grids. Make fine adjustments to alignment, spacing, padding, and other layout parameters. Place views in custom arrangements and create animated transitions between layout types. Display a structured, scrollable column of information. Display selectable, sortable data arranged in rows and columns. Present views in different kinds of purpose-driven containers, like forms or control groups. Enable people to scroll to content that doesn’t fit in the current display. ### Event handling Define interactions from taps, clicks, and swipes to fine-grained gestures. Respond to input from a hardware device, like a keyboard or a Touch Bar. Enable people to move or duplicate items by issuing Copy and Paste commands. Enable people to move or duplicate items by dragging them from one location to another. Identify and control which visible object responds to user interaction. React to system events, like opening a URL. ### Accessibility Make your SwiftUI apps accessible to everyone, including people with disabilities. Enhance the legibility of content in your app’s interface. Improve access to actions that your app can undertake. Describe interface elements to help people understand what they represent. Enable users to navigate to specific user interface elements using rotors. ### Framework integration Add AppKit views to your SwiftUI app, or use SwiftUI views in your AppKit app. Add UIKit views to your SwiftUI app, or use SwiftUI views in your UIKit app. Add WatchKit views to your SwiftUI app, or use SwiftUI views in your WatchKit app. Use SwiftUI views that other Apple frameworks provide. ### Tool support Generate dynamic, interactive previews of your custom views. Expose custom views and modifiers in the Xcode library. Measure and improve your app’s responsiveness. --- # https://developer.apple.com/documentation/swiftui Framework # SwiftUI Declare the user interface and behavior for your app on every platform. ## Overview SwiftUI provides views, controls, and layout structures for declaring your app’s user interface. The framework provides event handlers for delivering taps, gestures, and other types of input to your app, and tools to manage the flow of data from your app’s models down to the views and controls that users see and interact with. Define your app structure using the `App` protocol, and populate it with scenes that contain the views that make up your app’s user interface. Create your own custom views that conform to the `View` protocol, and compose them with SwiftUI views for displaying text, images, and custom shapes using stacks, lists, and more. Apply powerful modifiers to built-in views and your own views to customize their rendering and interactivity. Share code between apps on multiple platforms with views and controls that adapt to their context and presentation. You can integrate SwiftUI views with objects from the UIKit, AppKit, and WatchKit frameworks to take further advantage of platform-specific functionality. You can also customize accessibility support in SwiftUI, and localize your app’s interface for different languages, countries, or cultural regions. ### Featured samples     ## Topics ### Essentials Adopting Liquid Glass Find out how to bring the new material to your app. Learning SwiftUI Discover tips and techniques for building multiplatform apps with this set of conceptual articles and sample code. Exploring SwiftUI Sample Apps Explore these SwiftUI samples using Swift Playgrounds on iPad or in Xcode to learn about defining user interfaces, responding to user interactions, and managing data flow. SwiftUI updates Learn about important changes to SwiftUI. Landmarks: Building an app with Liquid Glass Enhance your app experience with system-provided and custom Liquid Glass. ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. ### Data and storage Manage the data that your app uses to drive its interface. Share data throughout a view hierarchy using the environment. Indicate configuration preferences from views to their container views. Store data for use across sessions of your app. ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. ### View layout Arrange views inside built-in layout containers like stacks and grids. Make fine adjustments to alignment, spacing, padding, and other layout parameters. Place views in custom arrangements and create animated transitions between layout types. Display a structured, scrollable column of information. Display selectable, sortable data arranged in rows and columns. Present views in different kinds of purpose-driven containers, like forms or control groups. Enable people to scroll to content that doesn’t fit in the current display. ### Event handling Define interactions from taps, clicks, and swipes to fine-grained gestures. Respond to input from a hardware device, like a keyboard or a Touch Bar. Enable people to move or duplicate items by issuing Copy and Paste commands. Enable people to move or duplicate items by dragging them from one location to another. Identify and control which visible object responds to user interaction. React to system events, like opening a URL. ### Accessibility Make your SwiftUI apps accessible to everyone, including people with disabilities. Enhance the legibility of content in your app’s interface. Improve access to actions that your app can undertake. Describe interface elements to help people understand what they represent. Enable users to navigate to specific user interface elements using rotors. ### Framework integration Add AppKit views to your SwiftUI app, or use SwiftUI views in your AppKit app. Add UIKit views to your SwiftUI app, or use SwiftUI views in your UIKit app. Add WatchKit views to your SwiftUI app, or use SwiftUI views in your WatchKit app. Use SwiftUI views that other Apple frameworks provide. ### Tool support Generate dynamic, interactive previews of your custom views. Expose custom views and modifiers in the Xcode library. Measure and improve your app’s responsiveness. --- # https://developer.apple.com/documentation/swiftui/app - SwiftUI - App Protocol # App A type that represents the structure and behavior of an app. @MainActor @preconcurrency protocol App ## Mentioned in Migrating to the SwiftUI life cycle ## Overview Create an app by declaring a structure that conforms to the `App` protocol. Implement the required `body` computed property to define the app’s content: @main struct MyApp: App { var body: some Scene { WindowGroup { Text("Hello, world!") } } } Precede the structure’s declaration with the @main attribute to indicate that your custom `App` protocol conformer provides the entry point into your app. The protocol provides a default implementation of the `main()` method that the system calls to launch your app. You can have exactly one entry point among all of your app’s files. Compose the app’s body from instances that conform to the `Scene` protocol. Each scene contains the root view of a view hierarchy and has a life cycle managed by the system. SwiftUI provides some concrete scene types to handle common scenarios, like for displaying documents or settings. You can also create custom scenes. @main struct Mail: App { var body: some Scene { WindowGroup { MailViewer() } Settings { SettingsView() } } } You can declare state in your app to share across all of its scenes. For example, you can use the `StateObject` attribute to initialize a data model, and then provide that model on a view input as an `ObservedObject` or through the environment as an `EnvironmentObject` to scenes in the app: @main struct Mail: App { @StateObject private var model = MailModel() var body: some Scene { WindowGroup { MailViewer() .environmentObject(model) // Passed through the environment. } Settings { SettingsView(model: model) // Passed as an observed object. } } } A type conforming to this protocol inherits `@preconcurrency @MainActor` isolation from the protocol if the conformance is included in the type’s base declaration: struct MyCustomType: Transition { // `@preconcurrency @MainActor` isolation by default } Isolation to the main actor is the default, but it’s not required. Declare the conformance in an extension to opt out of main actor isolation: extension MyCustomType: Transition { // `nonisolated` by default } ## Topics ### Implementing an app `var body: Self.Body` The content and behavior of the app. **Required** `associatedtype Body : Scene` The type of scene representing the content of the app. ### Running an app `init()` Creates an instance of the app using the body that you define for its content. `static func main()` Initializes and runs the app. ## See Also ### Creating an app Destination Video Leverage SwiftUI to build an immersive media experience in a multiplatform app. Hello World Use windows, volumes, and immersive spaces to teach people about the Earth. Backyard Birds: Building an app with SwiftData and widgets Create an app with persistent data, interactive widgets, and an all new in-app purchase experience. Food Truck: Building a SwiftUI multiplatform app Create a single codebase and app target for Mac, iPad, and iPhone. Fruta: Building a Feature-Rich App with SwiftUI Create a shared codebase to build a multiplatform app that offers widgets and an App Clip. Use a scene-based life cycle in SwiftUI while keeping your existing codebase. --- # https://developer.apple.com/documentation/swiftui/view - SwiftUI - View Protocol # View A type that represents part of your app’s user interface and provides modifiers that you use to configure views. @MainActor @preconcurrency protocol View ## Mentioned in Declaring a custom view Configuring views Reducing view modifier maintenance Migrating to the SwiftUI life cycle Displaying data in lists ## Overview You create custom views by declaring types that conform to the `View` protocol. Implement the required `body` computed property to provide the content for your custom view. struct MyView: View { var body: some View { Text("Hello, World!") } } Assemble the view’s body by combining one or more of the built-in views provided by SwiftUI, like the `Text` instance in the example above, plus other custom views that you define, into a hierarchy of views. For more information about creating custom views, see Declaring a custom view. The `View` protocol provides a set of modifiers — protocol methods with default implementations — that you use to configure views in the layout of your app. Modifiers work by wrapping the view instance on which you call them in another view with the specified characteristics, as described in Configuring views. For example, adding the `opacity(_:)` modifier to a text view returns a new view with some amount of transparency: Text("Hello, World!") .opacity(0.5) // Display partially transparent text. The complete list of default modifiers provides a large set of controls for managing views. For example, you can fine tune Layout modifiers, add Accessibility modifiers information, and respond to Input and event modifiers. You can also collect groups of default modifiers into new, custom view modifiers for easy reuse. A type conforming to this protocol inherits `@preconcurrency @MainActor` isolation from the protocol if the conformance is declared in its original declaration. Isolation to the main actor is the default, but it’s not required. Declare the conformance in an extension to opt-out the isolation. ## Topics ### Implementing a custom view `var body: Self.Body` The content and behavior of the view. **Required** Default implementations provided. `associatedtype Body : View` The type of view representing the body of this view. **Required** Applies a modifier to a view and returns a new view. Generate dynamic, interactive previews of your custom views. ### Configuring view elements Make your SwiftUI apps accessible to everyone, including people with disabilities. Configure a view’s foreground and background styles, controls, and visibility. Manage the rendering, selection, and entry of text in your view. Add and configure supporting views, like toolbars and context menus. Configure charts that you declare with Swift Charts. ### Drawing views Apply built-in styles to different types of views. Tell a view how to arrange itself within a view hierarchy by adjusting its size, position, alignment, padding, and so on. Affect the way the system draws a view, for example by scaling or masking a view, or by applying graphical effects. ### Providing interactivity Supply actions for a view to perform in response to user input and system events. Enable people to search for content in your app. Define additional views for the view to present under specified conditions. Access storage and provide child views with configuration data. ### Deprecated modifiers Review unsupported modifiers and their replacements. ### Instance Methods Adds multiple accessibility actions to the view with a specific category. Actions allow assistive technologies, such as VoiceOver, to interact with the view by invoking the action and are grouped by their category. When multiple action modifiers with an equal category are applied to the view, the actions are combined together. Defines a region in which default accessibility focus is evaluated by assigning a value to a given accessibility focus state binding. Beta `func accessibilityScrollStatus(_:isEnabled:)` Changes the announcement provided by accessibility technologies when a user scrolls a scroll view within this view. The view modifier that can be applied to `AccessoryWidgetGroup` to specify the shape the three content views will be masked with. The value of `style` is set to `.automatic`, which is `.circular` by default. Sets the button’s style. Sets the style to be used by the button. (see `PKAddPassButtonStyle`). Configures gestures in this view hierarchy to handle events that activate the containing window. Constrains this view’s dimensions to the specified 3D aspect ratio. Configures the view’s icon for purposes of navigation. `func attributedTextFormattingDefinition(_:)` Apply a text formatting definition to all nested editor views. Presents a modal view that enables users to add devices to their organization. Adds the background extension effect to the view. The view will be duplicated into mirrored copies which will be placed around the view on any edge with available safe area. Additionally, a blur effect will be applied on top to blur out the copies. Ensures that the view is always visible to the user, even when other content is occluding it, like 3D models. Displays a certificate sheet using the provided certificate trust. `func chart3DPose(_:)` Beta Sets the visibility of the z axis. Configures the z-axis for 3D charts in the view. `func chartZAxisLabel(_:position:alignment:spacing:)` Adds z axis label for charts in the view. It effects 3D charts only. Modally present UI which allows the user to select which contacts your app has access to. Sets a particular container value of a view. `func contentToolbar(for:content:)` Populates the toolbar of the specified content view type with the views you provide. A `continuityDevicePicker` should be used to discover and connect nearby continuity device through a button interface or other form of activation. On tvOS, this presents a fullscreen continuity device picker experience when selected. The modal view covers as much the screen of `self` as possible when a given condition is true. `func controlWidgetActionHint(_:)` The action hint of the control described by the modified label. `func controlWidgetStatus(_:)` The status of the control described by the modified label. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Whether the alert or confirmation dialog prevents the app from being quit/terminated by the system or app termination menu item. Adds to a `DocumentLaunchView` actions that accept a list of selected files as their parameter. Configures a drag session. A container with draggable views. The drag payload is based on the current selection. `func dragContainer(for:id:in:selection:_:)` A container with single item selection and draggable views. The drag payload is based on the current selection and provided identifiers. A container with draggable views. The drag payload is identifiable. To form the payload, use the identifier of the dragged view inside the container. `func dragContainer(for:in:selection:_:)` A container with multiple selection and draggable views. The drag payload is identifiable and is based on the current selection. Describes the way dragged previews are visually composed. Activates this view as the source of a drag and drop operation. A view can be dragged separately, or as an element of a drag container. Inside a drag container, activates this view as the source of a drag and drop operation. Supports lazy drag containers. Activates this view as the source of a drag-and-drop operation. Configures a drop session. Defines the destination of a drag and drop operation that provides a drop operation proposal and handles the dropped content with a closure that you specify. Describes the way previews for a drop are composed. Sets the style for forms in a view hierarchy. Presents a modal view while the game synced directory loads. Fills the view’s background with a custom glass background effect and container-relative rounded rectangle shape. Fills the view’s background with a custom glass background effect and a shape that you specify. Applies the Liquid Glass effect to a view. Associates an identity value to Liquid Glass effects defined within this view. Associates a glass effect transition with any glass effects defined within this view. Associates any Liquid Glass effects defined within this view to a union with the provided identifier. Specifies how a view should be associated with the current SharePlay group activity. Assigns a hand gesture shortcut to the modified control. Sets the behavior of the hand pointer while the user is interacting with the view. Specifies the game controllers events which should be delivered through the GameController framework when the view, or one of its descendants has focus. Specifies the game controllers events which should be delivered through the GameController framework when the view or one of its descendants has focus. Asynchronously requests permission to read a data type that requires per-object authorization (such as vision prescriptions). Requests permission to read the specified HealthKit data types. Requests permission to save and read the specified HealthKit data types. Sets the generation style for an image playground. Policy determining whether to support the usage of people in the playground or not. Presents the system sheet to create images from the specified input. Add menu items to open immersive spaces from a media player’s environment picker. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Presents a visual picker interface that contains events and images that a person can select to retrieve more information. Set the spacing between the icon and title in labels. Set the width reserved for icons in labels. Sets a style for labeled content. Controls the visibility of labels of any controls contained within this view. A modifier for the default line height in the view hierarchy. Sets the insets of rows in a list on the specified edges. Changes the visibility of the list section index. Set the section margins for the specific edges. Applies a managed content style to the view. Allows this view to be manipulated using common hand gestures. Applies the given 3D affine transform to the view and allows it to be manipulated using common hand gestures. Allows the view to be manipulated using a manipulation gesture attached to a different view. Adds a manipulation gesture to this view without allowing this view to be manipulable itself. Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. Configures all Map controls in the environment to have the specified visibility Configures all `Map` views in the associated environment to have standard size and position controls Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Specifies which map features should have selection disabled. Presents a map item detail popover. Presents a map item detail sheet. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies the map style to be used. Identifies this view as the source of a navigation transition, such as a zoom transition. Sets an explicit active appearance for materials in this view. A modifier for the default text alignment strategy in the view hierarchy. Configures whether navigation links show a disclosure indicator. Sets the navigation transition style for this view. Registers a handler to invoke in response to the specified app intent that your app receives. Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. `func onCameraCaptureEvent(isEnabled:defaultSoundDisabled:action:)` Used to register an action triggered by system capture events. `func onCameraCaptureEvent(isEnabled:defaultSoundDisabled:primaryAction:secondaryAction:)` Used to register actions triggered by system capture events. Specifies an action to perform on each update of an ongoing dragging operation activated by `draggable(_:)` or other drag modifiers. Specifies an action to perform on each update of an ongoing drop operation activated by `dropDestination(_:)` or other drop modifiers. `func onGeometryChange3D(for:of:action:)` Returns a new view that arranges to call `action(value)` whenever the value computed by `transform(proxy)` changes, where `proxy` provides access to the view’s 3D geometry properties. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Sets an `OpenURLAction` that prefers opening URL with an in-app browser. It’s equivalent to calling `.onOpenURL(_:)` `func onWorldRecenter(action:)` Adds an action to perform when recentering the view with the digital crown. Sets the action on the PayLaterView. See `PKPayLaterAction`. Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. Sets the features that should be allowed to show on the payment buttons. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Presents a popover tip on the modified view. `func postToPhotosSharedAlbumSheet(isPresented:items:photoLibrary:defaultAlbumIdentifier:completion:)` Presents an “Add to Shared Album” sheet that allows the user to post the given items to a shared album. Selects a subscription offer to apply to a purchase that a customer makes from a subscription store view, a store view, or a product view. `func preferredWindowClippingMargins(_:_:)` Requests additional margins for drawing beyond the bounds of the window. Changes the way the enclosing presentation breaks through content occluding it. Whether a presentation prevents the app from being terminated/quit by the system or app termination menu item. Configure the visibility of labels displaying an in-app purchase product description within the view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Adds gestures that control the position and direction of a virtual camera. Controls the frame sizing and content alignment behavior for `RealityView` Rotates a view with impacts to its frame in a containing layout `func rotation3DLayout(_:axis:)` `func safeAreaBar(edge:alignment:spacing:content:)` Renders the provided content appropriately to be displayed as a custom bar. Scales this view to fill its parent. Scales this view to fit its parent. Disables any scroll edge effects for scroll views within this hierarchy. Configures the scroll edge effect style for scroll views within this hierarchy. Enables or disables scrolling in scrollable views when using particular inputs. Configures the behavior for search in the toolbar. `func sectionIndexLabel(_:)` Sets the label that is used in a section index to point to this section, typically only a single character long. Sets the style used for displaying the control (see `SignInWithAppleButton.Style`). Adds secondary views within the 3D bounds of this view. Uses the specified preference value from the view to produce another view occupying the same 3D space of the first view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. Declares the view as dependent on a collection of In-App Purchase products and returns a modified view. Selects the introductory offer eligibility preference to apply to a purchase a customer makes from a subscription store view. Selects a promotional offer to apply to a purchase a customer makes from a subscription store view. Deprecated Declares the view as dependent on the status of an auto-renewable subscription group, and returns a modified view. Configures subscription store view instances within a view to use the provided button label. `func subscriptionStoreControlBackground(_:)` Set a standard effect to use for the background of subscription store view controls within the view. Sets a view to use to decorate individual subscription options within a subscription store view. Sets the control style for subscription store views within a view. Sets the control style and control placement for subscription store views within a view. Sets the style subscription store views within this view use to display groups of subscription options. Sets the background style for picker items of the subscription store view instances within a view. Sets the background shape and style for subscription store view picker items within a view. Configures a view as the destination for a policy button action in subscription store views. Configures a URL as the destination for a policy button action in subscription store views. Sets the style for the and buttons within a subscription store view. Sets the primary and secondary style for the and buttons within a subscription store view. Adds an action to perform when a person uses the sign-in button on a subscription store view within a view. Sets the color rendering mode for symbol images. Sets the variable value mode mode for symbol images within this view. Sets the behavior for tab bar minimization. Adds a tabletop game to a view. Supplies a closure which returns a new interaction whenever needed. `func textContentType(_:)` Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on macOS. Define which system text formatting controls are available. Returns a new view such that any text views within it will use `renderer` to draw themselves. Sets the direction of a selection or cursor relative to a text character. Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. Sets the corner radius for an inline tip view. Sets the size for a tip’s image. Sets the style for a tip’s image. Sets the given style for TipView within the view hierarchy. Hides an individual view within a control group toolbar item. Presents a picker that selects a collection of transactions. Provides a task to perform before this view appears Presents a translation popover when a given condition is true. Adds a task to perform before this view appears or when the translation configuration changes. Adds a task to perform before this view appears or when the specified source or target languages change. Sets the style to be used by the button. (see `PKIdentityButtonStyle`). Determines whether horizontal swipe gestures trigger backward and forward page navigation. Specifies the visibility of the webpage’s natural background color within this view. Adds an item-based context menu to a WebView, replacing the default set of context menu items. Determines whether a web view can display content full screen. Determines whether pressing a link displays a preview of the destination for the link. Determines whether magnify gestures change the view’s magnification. Adds an action to be performed when a value, created from a scroll geometry, changes. Enables or disables scrolling in web views when using particular inputs. Associates a binding to a scroll position with the web view. Determines whether to allow people to select or otherwise interact with text. Sets the window anchor point used when the size of the view changes such that the window must resize. Configures the visibility of the window toolbar when the window enters full screen mode. Presents a preview of the workout contents as a modal sheet A modifier for the default text writing direction strategy in the view hierarchy. Specifies whether the system should show the Writing Tools affordance for text input views affected by the environment. Specifies the Writing Tools behavior for text and text input in the environment. ## Relationships ### Inherited By - `DynamicViewContent` - `InsettableShape` - `NSViewControllerRepresentable` - `NSViewRepresentable` - `Shape` - `ShapeView` - `UIViewControllerRepresentable` - `UIViewRepresentable` - `WKInterfaceObjectRepresentable` ### Conforming Types - `AngularGradient` - `AnyShape` - `AnyView` - `AsyncImage` - `Button` - `ButtonBorderShape` - `ButtonStyleConfiguration.Label` - `Canvas` Conforms when `Symbols` conforms to `View`. - `Capsule` - `Circle` - `Color` - `ColorPicker` - `ContainerRelativeShape` - `ContentUnavailableView` - `ControlGroup` - `ControlGroupStyleConfiguration.Content` - `ControlGroupStyleConfiguration.Label` - `DatePicker` - `DatePickerStyleConfiguration.Label` - `DebugReplaceableView` - `DefaultButtonLabel` - `DefaultDateProgressLabel` - `DefaultDocumentGroupLaunchActions` - `DefaultSettingsLinkLabel` - `DefaultShareLinkLabel` - `DefaultTabLabel` - `DefaultWindowVisibilityToggleLabel` - `DisclosureGroup` - `DisclosureGroupStyleConfiguration.Content` - `DisclosureGroupStyleConfiguration.Label` - `Divider` - `DocumentLaunchView` - `EditButton` - `EditableCollectionContent` Conforms when `Content` conforms to `View`, `Data` conforms to `Copyable`, and `Data` conforms to `Escapable`. - `Ellipse` - `EllipticalGradient` - `EmptyView` - `EquatableView` - `FillShapeView` - `ForEach` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, and `Content` conforms to `View`. - `Form` - `FormStyleConfiguration.Content` - `Gauge` - `GaugeStyleConfiguration.CurrentValueLabel` - `GaugeStyleConfiguration.Label` - `GaugeStyleConfiguration.MarkedValueLabel` - `GaugeStyleConfiguration.MaximumValueLabel` - `GaugeStyleConfiguration.MinimumValueLabel` - `GeometryReader` - `GeometryReader3D` - `GlassBackgroundEffectConfiguration.Content` - `GlassEffectContainer` - `Grid` Conforms when `Content` conforms to `View`. - `GridRow` Conforms when `Content` conforms to `View`. - `Group` Conforms when `Content` conforms to `View`. - `GroupBox` - `GroupBoxStyleConfiguration.Content` - `GroupBoxStyleConfiguration.Label` - `GroupElementsOfContent` - `GroupSectionsOfContent` - `HSplitView` - `HStack` - `HelpLink` - `Image` - `KeyframeAnimator` - `Label` - `LabelStyleConfiguration.Icon` - `LabelStyleConfiguration.Title` - `LabeledContent` Conforms when `Label` conforms to `View` and `Content` conforms to `View`. - `LabeledContentStyleConfiguration.Content` - `LabeledContentStyleConfiguration.Label` - `LabeledControlGroupContent` - `LabeledToolbarItemGroupContent` - `LazyHGrid` - `LazyHStack` - `LazyVGrid` - `LazyVStack` - `LinearGradient` - `Link` - `List` - `Menu` - `MenuButton` - `MenuStyleConfiguration.Content` - `MenuStyleConfiguration.Label` - `MeshGradient` - `ModifiedContent` Conforms when `Content` conforms to `View` and `Modifier` conforms to `ViewModifier`. - `MultiDatePicker` - `NavigationLink` - `NavigationSplitView` - `NavigationStack` - `NavigationView` - `NewDocumentButton` - `OffsetShape` - `OutlineGroup` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, `Parent` conforms to `View`, `Leaf` conforms to `View`, and `Subgroup` conforms to `View`. - `OutlineSubgroupChildren` - `PasteButton` - `Path` - `PhaseAnimator` - `Picker` - `PlaceholderContentView` - `PresentedWindowContent` - `PreviewModifierContent` - `PrimitiveButtonStyleConfiguration.Label` - `ProgressView` - `ProgressViewStyleConfiguration.CurrentValueLabel` - `ProgressViewStyleConfiguration.Label` - `RadialGradient` - `Rectangle` - `RenameButton` - `RotatedShape` - `RoundedRectangle` - `ScaledShape` - `ScrollView` - `ScrollViewReader` - `SearchUnavailableContent.Actions` - `SearchUnavailableContent.Description` - `SearchUnavailableContent.Label` - `Section` Conforms when `Parent` conforms to `View`, `Content` conforms to `View`, and `Footer` conforms to `View`. - `SectionConfiguration.Actions` - `SecureField` - `SettingsLink` - `ShareLink` - `Slider` - `Spacer` - `Stepper` - `StrokeBorderShapeView` - `StrokeShapeView` - `SubscriptionView` - `Subview` - `SubviewsCollection` - `SubviewsCollectionSlice` - `TabContentBuilder.Content` - `TabView` - `Table` - `Text` - `TextEditor` - `TextField` - `TextFieldLink` - `TimelineView` Conforms when `Schedule` conforms to `TimelineSchedule` and `Content` conforms to `View`. - `Toggle` - `ToggleStyleConfiguration.Label` - `TransformedShape` - `TupleView` - `UnevenRoundedRectangle` - `VSplitView` - `VStack` - `ViewThatFits` - `WindowVisibilityToggle` - `ZStack` - `ZStackContent3D` Conforms when `Content` conforms to `View`. ## See Also ### Creating a view Define views and assemble them into a view hierarchy. `struct ViewBuilder` A custom parameter attribute that constructs views from closures. --- # https://developer.apple.com/documentation/swiftui/landmarks-building-an-app-with-liquid-glass - SwiftUI - Landmarks: Building an app with Liquid Glass Beta Sample Code # Landmarks: Building an app with Liquid Glass Enhance your app experience with system-provided and custom Liquid Glass. Download Xcode 26.0+Beta ## Overview Landmarks is a SwifUI app that demonstrates how to use the new dynamic and expressive design feature, Liquid Glass. The Landmarks app lets people explore interesting sites around the world. Whether it’s a national park near their home or a far-flung location on a different continent, the app provides a way for people to organize and mark their adventures and receive custom activity badges along the way. Landmarks runs on iPad, iPhone, and Mac. Landmarks uses a `NavigationSplitView` to organize and navigate to content in the app, and demonstrates several key concepts to optimize the use of Liquid Glass: - Stretching content behind the sidebar and inspector with the background extension effect. - Extending horizontal scroll views under a sidebar or inspector. - Leveraging the system-provided glass effect in toolbars. - Applying Liquid Glass effects to custom interface elements and animations. - Building a new app icon with Icon Composer. The sample also demonstrates several techniques to use when changing window sizes, and for adding global search. ## Apply a background extension effect The sample applies a background extension effect to the featured landmark header in the top view, and the main image in the landmark detail view. This effect extends and blurs the image under the sidebar and inspector when they’re open, creating a full edge-to-edge experience. To achieve this effect, the sample creates and configures an `Image` that extends to both the leading and trailing edges of the containing view, and applies the `backgroundExtensionEffect()` modifier to the image. For the featured image, the sample adds an overlay with a headline and button after the modifier, so that only the image extends under the sidebar and inspector. For more information, see Landmarks: Applying a background extension effect. ## Extend horizontal scrolling under the sidebar Within each continent section in `LandmarksView`, an instance of `LandmarkHorizontalListView` shows a horizontally scrolling list of landmark views. When open, the landmark views can scroll underneath the sidebar or inspector. To achieve this effect, the app aligns the scroll views next to the leading and trailing edges of the containing view. For more information, see Landmarks: Extending horizontal scrolling under a sidebar or inspector. ## Refine the Liquid Glass in the toolbar In `LandmarkDetailView`, the sample adds toolbar items for: - sharing a landmark - adding or removing a landmark from a list of Favorites - adding or removing a landmark from Collections - showing or hiding the inspector The system applies Liquid Glass to toolbar items automatically: The sample also organizes the toolbar into related groups, instead of having all the buttons in one group. For more information, see Landmarks: Refining the system provided Liquid Glass effect in toolbars. ## Display badges with Liquid Glass Badges provide people with a visual indicator of the activities they’ve recorded in the Landmarks app. When a person completes all four activities for a landmark, they earn that landmark’s badge. The sample uses custom Liquid Glass elements with badges, and shows how to coordinate animations with Liquid Glass. To create a custom Liquid Glass badge, Landmarks uses a view with an `Image` to display a system symbol image for the badge. The badge has a background hexagon `Image` filled with a custom color. The badge view uses the `glassEffect(_:in:isEnabled:)` modifier to apply Liquid Glass to the badge. To demonstrate the morphing effect that the system provides with Liquid Glass animations, the sample organizes the badges and the toggle button into a `GlassEffectContainer`, and assigns each badge a unique `glassEffectID(_:in:)`. For more information, see Landmarks: Displaying custom activity badges. For information about building custom views with Liquid Glass, see Applying Liquid Glass to custom views. ## Create the app icon with Icon Composer Landmarks includes a dynamic and expressive app icon composed in Icon Composer. You build app icons with four layers that the system uses to produce specular highlights when a person moves their device, so that the icon responds as if light was reflecting off the glass. The Settings app allows people to personalize the icon by selecting light, dark, clear, or tinted variants of your app icon as well. For more information on creating a new app icon, see Creating your app icon using Icon Composer. ## Topics ### App features Landmarks: Applying a background extension effect Configure an image to blur and extend under a sidebar or inspector panel. Landmarks: Extending horizontal scrolling under a sidebar or inspector Improve your horizontal scrollbar’s appearance by extending it under a sidebar or inspector. Landmarks: Refining the system provided Liquid Glass effect in toolbars Organize toolbars into related groupings to improve their appearance and utility. Landmarks: Displaying custom activity badges Provide people with a way to mark their adventures by displaying animated custom activity badges. ## See Also ### Essentials Adopting Liquid Glass Find out how to bring the new material to your app. Learning SwiftUI Discover tips and techniques for building multiplatform apps with this set of conceptual articles and sample code. Exploring SwiftUI Sample Apps Explore these SwiftUI samples using Swift Playgrounds on iPad or in Xcode to learn about defining user interfaces, responding to user interactions, and managing data flow. SwiftUI updates Learn about important changes to SwiftUI. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/app-organization Collection - SwiftUI - App organization API Collection # App organization Define the entry point and top-level structure of your app. ## Overview Describe your app’s structure declaratively, much like you declare a view’s appearance. Create a type that conforms to the `App` protocol and use it to enumerate the Scenes that represent aspects of your app’s user interface. SwiftUI enables you to write code that works across all of Apple’s platforms. However, it also enables you to tailor your app to the specific capabilities of each platform. For example, if you need to respond to the callbacks that the system traditionally makes on a UIKit, AppKit, or WatchKit app’s delegate, define a delegate object and instantiate it in your app structure using an appropriate delegate adaptor property wrapper, like `UIApplicationDelegateAdaptor`. For platform-specific design guidance, see Getting started in the Human Interface Guidelines. ## Topics ### Creating an app Destination Video Leverage SwiftUI to build an immersive media experience in a multiplatform app. Hello World Use windows, volumes, and immersive spaces to teach people about the Earth. Backyard Birds: Building an app with SwiftData and widgets Create an app with persistent data, interactive widgets, and an all new in-app purchase experience. Food Truck: Building a SwiftUI multiplatform app Create a single codebase and app target for Mac, iPad, and iPhone. Fruta: Building a Feature-Rich App with SwiftUI Create a shared codebase to build a multiplatform app that offers widgets and an App Clip. Migrating to the SwiftUI life cycle Use a scene-based life cycle in SwiftUI while keeping your existing codebase. `protocol App` A type that represents the structure and behavior of an app. ### Targeting iOS and iPadOS `UILaunchScreen` The user interface to show while an app launches. `UILaunchScreens` The user interfaces to show while an app launches in response to different URL schemes. `struct UIApplicationDelegateAdaptor` A property wrapper type that you use to create a UIKit app delegate. ### Targeting macOS `struct NSApplicationDelegateAdaptor` A property wrapper type that you use to create an AppKit app delegate. ### Targeting watchOS `struct WKApplicationDelegateAdaptor` A property wrapper that is used in `App` to provide a delegate from WatchKit. `struct WKExtensionDelegateAdaptor` A property wrapper type that you use to create a WatchKit extension delegate. ### Targeting tvOS Creating a tvOS media catalog app in SwiftUI Build standard content lockups and rows of content shelves for your tvOS app. ### Handling system recenter events `enum WorldRecenterPhase` A type that represents information associated with a phase of a system recenter event. Values of this type are passed to the closure specified in View.onWorldRecenter(action:). Beta ## See Also ### App structure Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. --- # https://developer.apple.com/documentation/swiftui/scenes Collection - SwiftUI - Scenes API Collection # Scenes Declare the user interface groupings that make up the parts of your app. ## Overview A scene represents a part of your app’s user interface that has a life cycle that the system manages. An `App` instance presents the scenes it contains, while each `Scene` acts as the root element of a `View` hierarchy. The system presents scenes in different ways depending on the type of scene, the platform, and the context. A scene might fill the entire display, part of the display, a window, a tab in a window, or something else. In some cases, your app might also be able to display more than one instance of the scene at a time, like when a user simultaneously opens multiple windows based on a single `WindowGroup` declaration in your app. For more information about the primary built-in scene types, see Windows and Documents. You configure scenes using modifiers, similar to how you configure views. For example, you can adjust the appearance of the window that contains a scene — if the scene happens to appear in a window — using the `windowStyle(_:)` modifier. Similarly, you can add menu commands that become available when the scene is in the foreground on certain platforms using the `commands(content:)` modifier. ## Topics ### Creating scenes `protocol Scene` A part of an app’s user interface with a life cycle managed by the system. `struct SceneBuilder` A result builder for composing a collection of scenes into a single composite scene. ### Monitoring scene life cycle `var scenePhase: ScenePhase` The current phase of the scene. `enum ScenePhase` An indication of a scene’s operational state. ### Managing a settings window `struct Settings` A scene that presents an interface for viewing and modifying an app’s settings. `struct SettingsLink` A view that opens the Settings scene defined by an app. `struct OpenSettingsAction` An action that presents the settings scene for an app. `var openSettings: OpenSettingsAction` A Settings presentation action stored in a view’s environment. ### Building a menu bar Building and customizing the menu bar with SwiftUI Provide a seamless, cross-platform user experience by building a native menu bar for iPadOS and macOS. ### Creating a menu bar extra `struct MenuBarExtra` A scene that renders itself as a persistent control in the system menu bar. Sets the style for menu bar extra created by this scene. `protocol MenuBarExtraStyle` A specification for the appearance and behavior of a menu bar extra scene. ### Creating watch notifications `struct WKNotificationScene` A scene which appears in response to receiving the specified category of remote or local notifications. ## See Also ### App structure Define the entry point and top-level structure of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. --- # https://developer.apple.com/documentation/swiftui/windows Collection - SwiftUI - Windows API Collection # Windows Display user interface content in a window or a collection of windows. ## Overview The most common way to present a view hierarchy in your app’s interface is with a `WindowGroup`, which produces a platform-specific behavior and appearance. On platforms that support it, people can open multiple windows from the group simultaneously. Each window relies on the same root view definition, but retains its own view state. On some platforms, you can also supplement your app’s user interface with a single-instance window using the `Window` scene type. Configure windows using scene modifiers that you add to the window declaration, like `windowStyle(_:)` or `defaultPosition(_:)`. You can also indicate how to configure new windows that you present from a view hierarchy by adding the `presentedWindowStyle(_:)` view modifier to a view in the hierarchy. For design guidance, see Windows in the Human Interface Guidelines. ## Topics ### Essentials Customizing window styles and state-restoration behavior in macOS Configure how your app’s windows look and function in macOS to provide an engaging and more coherent experience. Bringing multiple windows to your SwiftUI app Compose rich views by reacting to state changes and customize your app’s scene presentation and behavior on iPadOS and macOS. ### Creating windows `struct WindowGroup` A scene that presents a group of identically structured windows. `struct Window` A scene that presents its content in a single, unique window. `struct UtilityWindow` A specialized window scene that provides secondary utility to the content of the main scenes of an application. `protocol WindowStyle` A specification for the appearance and interaction of a window. Sets the style for windows created by this scene. ### Styling the associated toolbar Sets the style for the toolbar defined within this scene. Sets the label style of items in a toolbar and enables user customization. Sets the label style of items in a toolbar. `protocol WindowToolbarStyle` A specification for the appearance and behavior of a window’s toolbar. ### Opening windows Presenting windows and spaces Open and close the scenes that make up your app’s interface. `var supportsMultipleWindows: Bool` A Boolean value that indicates whether the current platform supports opening multiple windows. `var openWindow: OpenWindowAction` A window presentation action stored in a view’s environment. `struct OpenWindowAction` An action that presents a window. `struct PushWindowAction` An action that opens the requested window in place of the window the action is called from. ### Closing windows `var dismissWindow: DismissWindowAction` A window dismissal action stored in a view’s environment. `struct DismissWindowAction` An action that dismisses a window associated to a particular scene. `var dismiss: DismissAction` An action that dismisses the current presentation. `struct DismissAction` An action that dismisses a presentation. `struct DismissBehavior` Programmatic window dismissal behaviors. ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. `func defaultSize(_:)` Sets a default size for a window. Sets a default width and height for a window. Sets a default size for a volumetric window. Sets the kind of resizability to use for a window. `struct WindowResizability` The resizability of a window. Specifies how windows derived form this scene should determine their size when zooming. `struct WindowIdealSize` A type which defines the size a window should use when zooming. ### Positioning a window Sets a default position for a window. `struct WindowLevel` The level of a window. Sets the window level of this scene. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. `struct WindowPlacement` A type which represents a preferred size and position for a window. Defines a function used for determining the default placement of windows. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct WindowProxy` The proxy for an open window in the app. `struct DisplayProxy` A type which provides information about display hardware. ### Configuring window visibility `struct WindowVisibilityToggle` A specialized button for toggling the visibility of a window. Sets the default launch behavior for this scene. Sets the restoration behavior for this scene. `struct SceneLaunchBehavior` The launch behavior for a scene. `struct SceneRestorationBehavior` The restoration behavior for a scene. Sets the preferred visibility of the non-transient system views overlaying the app. Configures the visibility of the window toolbar when the window enters full screen mode. `struct WindowToolbarFullScreenVisibility` The visibility of the window toolbar with respect to full screen mode. ### Managing window behavior `struct WindowManagerRole` Options for defining how a scene’s windows behave when used within a managed window context, such as full screen mode and Stage Manager. Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. `struct WindowInteractionBehavior` Options for enabling and disabling window interaction behaviors. Configures the dismiss functionality for the window enclosing `self`. Configures the full screen functionality for the window enclosing `self`. Configures the minimize functionality for the window enclosing `self`. Configures the resize functionality for the window enclosing `self`. Configures the behavior of dragging a window by its background. ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta ### Deprecated Types `enum ControlActiveState` The active appearance expected of controls in a window. Deprecated ## See Also ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. --- # https://developer.apple.com/documentation/swiftui/immersive-spaces Collection - SwiftUI - Immersive spaces API Collection # Immersive spaces Display unbounded content in a person’s surroundings. ## Overview Use an immersive space in visionOS to present SwiftUI views outside of any containers. You can include any views in a space, although you typically use a `RealityView` to present RealityKit content. You can request one of three styles of spaces with the `immersionStyle(selection:in:)` scene modifier: - The `mixed` style blends your content with passthrough. This enables you to place virtual objects in a person’s surroundings. - The `full` style displays only your content, with passthrough turned off. This enables you to completely control the visual experience, like when you want to transport people to a new world. - The `progressive` style completely replaces passthrough in a portion of the display. You might use this style to keep people grounded in the real world while displaying a view into another world. When you open an immersive space, the system continues to display all of your app’s windows, but hides windows from other apps. The system supports displaying only one space at a time across all apps, so your app can only open a space if one isn’t already open. ## Topics ### Creating an immersive space `struct ImmersiveSpace` A scene that presents its content in an unbounded space. `struct ImmersiveSpaceContentBuilder` A result builder for composing a collection of immersive space elements. Sets the style for an immersive space. `protocol ImmersionStyle` The styles that an immersive space can have. `var immersiveSpaceDisplacement: Pose3D` The displacement that the system applies to the immersive space when moving the space away from its default position, in meters. `struct ImmersiveEnvironmentBehavior` The behavior of the system-provided immersive environments when a scene is opened by your app. Beta `struct ProgressiveImmersionAspectRatio` Beta ### Opening an immersive space `var openImmersiveSpace: OpenImmersiveSpaceAction` An action that presents an immersive space. `struct OpenImmersiveSpaceAction` ### Closing the immersive space `var dismissImmersiveSpace: DismissImmersiveSpaceAction` An immersive space dismissal action stored in a view’s environment. `struct DismissImmersiveSpaceAction` An action that dismisses an immersive space. ### Hiding upper limbs during immersion Sets the preferred visibility of the user’s upper limbs, while an `ImmersiveSpace` scene is presented. ### Adjusting content brightness Sets the content brightness of an immersive space. `struct ImmersiveContentBrightness` The content brightness of an immersive space. ### Responding to immersion changes Performs an action when the immersion state of your app changes. `struct ImmersionChangeContext` A structure that represents a state of immersion of your app. ### Adding menu items to an immersive space Add menu items to open immersive spaces from a media player’s environment picker. ### Handling remote immersive spaces `struct RemoteImmersiveSpace` A scene that presents its content in an unbounded space on a remote device. `struct RemoteDeviceIdentifier` An opaque type that identifies a remote device displaying scene content in a `RemoteImmersiveSpace`. ## See Also ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. --- # https://developer.apple.com/documentation/swiftui/documents Collection - SwiftUI - Documents API Collection # Documents Enable people to open and manage documents. ## Overview Create a user interface for opening and editing documents using the `DocumentGroup` scene type. You initialize the scene with a model that describes the organization of the document’s data, and a view hierarchy that SwiftUI uses to display the document’s contents to the user. You can use either a value type model, which you typically store as a structure, that conforms to the `FileDocument` protocol, or a reference type model you store in a class instance that conforms to the `ReferenceFileDocument` protocol. You can also use SwiftData-backed documents using an initializer like `init(editing:contentType:editor:prepareDocument:)`. SwiftUI supports standard behaviors that users expect from a document-based app, appropriate for each platform, like multiwindow support, open and save panels, drag and drop, and so on. For related design guidance, see Patterns in the Human Interface Guidelines. ## Topics ### Creating a document Building a document-based app with SwiftUI Create, save, and open documents in a multiplatform app. Building a document-based app using SwiftData Code along with the WWDC presenter to transform an app with SwiftData. `struct DocumentGroup` A scene that enables support for opening, creating, and saving documents. ### Storing document data in a structure instance `protocol FileDocument` A type that you use to serialize documents to and from file. `struct FileDocumentConfiguration` The properties of an open file document. ### Storing document data in a class instance `protocol ReferenceFileDocument` A type that you use to serialize reference type documents to and from file. `struct ReferenceFileDocumentConfiguration` The properties of an open reference file document. `var undoManager: UndoManager?` The undo manager used to register a view’s undo operations. ### Accessing document configuration `var documentConfiguration: DocumentConfiguration?` The configuration of a document in a `DocumentGroup`. `struct DocumentConfiguration` ### Reading and writing documents `struct FileDocumentReadConfiguration` The configuration for reading file contents. `struct FileDocumentWriteConfiguration` The configuration for serializing file contents. ### Opening a document programmatically `var newDocument: NewDocumentAction` An action in the environment that presents a new document. `struct NewDocumentAction` An action that presents a new document. `var openDocument: OpenDocumentAction` An action in the environment that presents an existing document. `struct OpenDocumentAction` An action that presents an existing document. ### Configuring the document launch experience `struct DocumentGroupLaunchScene` A launch scene for document-based applications. `struct DocumentLaunchView` A view to present when launching document-related user experience. `struct DocumentLaunchGeometryProxy` A proxy for access to the frame of the scene and its title view. `struct DefaultDocumentGroupLaunchActions` The default actions for the document group launch scene and the document launch view. `struct NewDocumentButton` A button that creates and opens new documents. `protocol DocumentBaseBox` A Box that allows setting its Document base not requiring the caller to know the exact types of the box and its base. ### Renaming a document `struct RenameButton` A button that triggers a standard rename action. `func renameAction(_:)` Sets a closure to run for the rename action. `var rename: RenameAction?` An action that activates the standard rename interaction. `struct RenameAction` An action that activates a standard rename interaction. ## See Also ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. --- # https://developer.apple.com/documentation/swiftui/navigation Collection - SwiftUI - Navigation API Collection # Navigation Enable people to move between different parts of your app’s view hierarchy within a scene. ## Overview Use navigation containers to provide structure to your app’s user interface, enabling people to easily move among the parts of your app. For example, people can move forward and backward through a stack of views using a `NavigationStack`, or choose which view to display from a tab bar using a `TabView`. Configure navigation containers by adding view modifiers like `navigationSplitViewStyle(_:)` to the container. Use other modifiers on the views inside the container to affect the container’s behavior when showing that view. For example, you can use `navigationTitle(_:)` on a view to provide a toolbar title to display when showing that view. ## Topics ### Essentials Understanding the navigation stack Learn about the navigation stack, links, and how to manage navigation types in your app’s structure. ### Presenting views in columns Bringing robust navigation structure to your SwiftUI app Use navigation links, stacks, destinations, and paths to provide a streamlined experience for all platforms, as well as behaviors such as deep linking and state restoration. Migrating to new navigation types Improve navigation behavior in your app by replacing navigation views with navigation stacks and navigation split views. `struct NavigationSplitView` A view that presents views in two or three columns, where selections in leading columns control presentations in subsequent columns. Sets the style for navigation split views within this view. Sets a fixed, preferred width for the column containing this view. Sets a flexible, preferred width for the column containing this view. `struct NavigationSplitViewVisibility` The visibility of the leading columns in a navigation split view. `struct NavigationLink` A view that controls a navigation presentation. ### Stacking views in one column `struct NavigationStack` A view that displays a root view and enables you to present additional views over the root view. `struct NavigationPath` A type-erased list of data representing the content of a navigation stack. Associates a destination view with a presented data type for use within a navigation stack. Associates a destination view with a binding that can be used to push the view onto a `NavigationStack`. `func navigationDestination(item: Binding>, destination: (D) -> C) -> some View` Associates a destination view with a bound value for use within a navigation stack or navigation split view ### Managing column collapse `struct NavigationSplitViewColumn` A view that represents a column in a navigation split view. ### Setting titles for navigation content `func navigationTitle(_:)` Configures the view’s title for purposes of navigation, using a string binding. `func navigationSubtitle(_:)` Configures the view’s subtitle for purposes of navigation. `func navigationDocument(_:)` Configures the view’s document for purposes of navigation. `func navigationDocument(_:preview:)` ### Configuring the navigation bar Hides the navigation bar back button for the view. Configures the title display mode for this view. `struct NavigationBarItem` A configuration for a navigation bar that represents a view at the top of a navigation stack. ### Configuring the sidebar `var sidebarRowSize: SidebarRowSize` The current size of sidebar rows. `enum SidebarRowSize` The standard sizes of sidebar rows. ### Presenting views in tabs Enhancing your app’s content with tab navigation Keep your app content front and center while providing quick access to navigation using the tab bar. `struct TabView` A view that switches between multiple child views using interactive user interface elements. `struct Tab` The content for a tab and the tab’s associated tab item in a tab view. `struct TabRole` A value that defines the purpose of the tab. `struct TabSection` A container that you can use to add hierarchy within a tab view. Sets the style for the tab view within the current environment. ### Configuring a tab bar Adds a custom header to the sidebar of a tab view. Adds a custom footer to the sidebar of a tab view. Adds a custom bottom bar to the sidebar of a tab view. `struct AdaptableTabBarPlacement` A placement for tabs in a tab view using the adaptable sidebar style. `var tabBarPlacement: TabBarPlacement?` The current placement of the tab bar. `struct TabBarPlacement` A placement for tabs in a tab view. `var isTabBarShowingSections: Bool` A Boolean value that determines whether a tab view shows the expanded contents of a tab section. `struct TabBarMinimizeBehavior` Beta `enum TabViewBottomAccessoryPlacement` A placement of the bottom accessory in a tab view. You can use this to adjust the content of the accessory view based on the placement. Beta ### Configuring a tab Adds custom actions to a section. `struct TabPlacement` A place that a tab can appear. `struct TabContentBuilder` A result builder that constructs tabs for a tab view that supports programmatic selection. This builder requires that all tabs in the tab view have the same selection type. `protocol TabContent` A type that provides content for programmatically selectable tabs in a tab view. `struct AnyTabContent` Type erased tab content. ### Enabling tab customization Specifies the customizations to apply to the sidebar representation of the tab view. `struct TabViewCustomization` The customizations a person makes to an adaptable sidebar tab view. `struct TabCustomizationBehavior` The customization behavior of customizable tab view content. ### Displaying views in multiple panes `struct HSplitView` A layout container that arranges its children in a horizontal line and allows the user to resize them using dividers placed between them. `struct VSplitView` A layout container that arranges its children in a vertical line and allows the user to resize them using dividers placed between them. ### Deprecated Types `struct NavigationView` A view for presenting a stack of views that represents a visible path in a navigation hierarchy. Deprecated Sets the tab bar item associated with this view. ## See Also ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. --- # https://developer.apple.com/documentation/swiftui/modal-presentations Collection - SwiftUI - Modal presentations API Collection # Modal presentations Present content in a separate view that offers focused interaction. ## Overview To draw attention to an important, narrowly scoped task, you display a modal presentation, like an alert, popover, sheet, or confirmation dialog. In SwiftUI, you create a modal presentation using a view modifier that defines how the presentation looks and the condition under which SwiftUI presents it. SwiftUI detects when the condition changes and makes the presentation for you. Because you provide a `Binding` to the condition that initiates the presentation, SwiftUI can reset the underlying value when the user dismisses the presentation. For design guidance, see Modality in the Human Interface Guidelines. ## Topics ### Configuring a dialog `struct DialogSeverity` The severity of an alert or confirmation dialog. ### Showing a sheet, cover, or popover Presents a sheet when a binding to a Boolean value that you provide is true. Presents a sheet using the given item as a data source for the sheet’s content. Presents a modal view that covers as much of the screen as possible when binding to a Boolean value you provide is true. Presents a modal view that covers as much of the screen as possible using the binding you provide as a data source for the sheet’s content. Presents a popover using the given item as a data source for the popover’s content. Presents a popover when a given condition is true. `enum PopoverAttachmentAnchor` An attachment anchor for a popover. ### Adapting a presentation size Specifies how to adapt a presentation to horizontally and vertically compact size classes. Specifies how to adapt a presentation to compact size classes. `struct PresentationAdaptation` Strategies for adapting a presentation to a different size class. Sets the sizing of the containing presentation. `protocol PresentationSizing` A type that defines the size of the presentation content and how the presentation size adjusts to its content’s size changing. `struct PresentationSizingRoot` A proxy to a view provided to the presentation with a defined presentation size. `struct PresentationSizingContext` Contextual information about a presentation. ### Configuring a sheet’s height Sets the available detents for the enclosing sheet. Sets the available detents for the enclosing sheet, giving you programmatic control of the currently selected detent. Configures the behavior of swipe gestures on a presentation. Sets the visibility of the drag indicator on top of a sheet. `struct PresentationDetent` A type that represents a height where a sheet naturally rests. `protocol CustomPresentationDetent` The definition of a custom detent with a calculated height. `struct PresentationContentInteraction` A behavior that you can use to influence how a presentation responds to swipe gestures. ### Styling a sheet and its background Requests that the presentation have a specific corner radius. Sets the presentation background of the enclosing sheet using a shape style. Sets the presentation background of the enclosing sheet to a custom view. Controls whether people can interact with the view behind a presentation. `struct PresentationBackgroundInteraction` The kinds of interaction available to views behind a presentation. ### Presenting an alert `struct AlertScene` A scene that renders itself as a standalone alert dialog. `func alert(_:isPresented:actions:)` Presents an alert when a given condition is true, using a text view for the title. `func alert(_:isPresented:presenting:actions:)` Presents an alert using the given data to produce the alert’s content and a text view as a title. Presents an alert when an error is present. `func alert(_:isPresented:actions:message:)` Presents an alert with a message when a given condition is true using a text view as a title. `func alert(_:isPresented:presenting:actions:message:)` Presents an alert with a message using the given data to produce the alert’s content and a text view for a title. Presents an alert with a message when an error is present. ### Getting confirmation for an action `func confirmationDialog(_:isPresented:titleVisibility:actions:)` Presents a confirmation dialog when a given condition is true, using a text view for the title. `func confirmationDialog(_:isPresented:titleVisibility:presenting:actions:)` Presents a confirmation dialog using data to produce the dialog’s content and a text view for the title. `func dismissalConfirmationDialog(_:shouldPresent:actions:)` Presents a confirmation dialog when a dismiss action has been triggered. ### Showing a confirmation dialog with a message `func confirmationDialog(_:isPresented:titleVisibility:actions:message:)` Presents a confirmation dialog with a message when a given condition is true, using a text view for the title. `func confirmationDialog(_:isPresented:titleVisibility:presenting:actions:message:)` Presents a confirmation dialog with a message using data to produce the dialog’s content and a text view for the message. `func dismissalConfirmationDialog(_:shouldPresent:actions:message:)` ### Configuring a dialog Configures the icon used by dialogs within this view. Configures the icon used by alerts. Sets the severity for alerts. Enables user suppression of dialogs and alerts presented within `self`, with a default suppression message on macOS. Unused on other platforms. Enables user suppression of an alert with a custom suppression message. `func dialogSuppressionToggle(_:isSuppressed:)` Enables user suppression of dialogs and alerts presented within `self`, with a custom suppression message on macOS. Unused on other platforms. ### Exporting to file `func fileExporter(isPresented:document:contentType:defaultFilename:onCompletion:)` Presents a system interface for exporting a document that’s stored in a value type, like a structure, to a file on disk. `func fileExporter(isPresented:documents:contentType:onCompletion:)` Presents a system interface for exporting a collection of value type documents to files on disk. `func fileExporter(isPresented:document:contentTypes:defaultFilename:onCompletion:onCancellation:)` Presents a system interface for allowing the user to export a `FileDocument` to a file on disk. `func fileExporter(isPresented:documents:contentTypes:onCompletion:onCancellation:)` Presents a system dialog for allowing the user to export a collection of documents that conform to `FileDocument` to files on disk. Presents a system interface allowing the user to export a `Transferable` item to file on disk. Presents a system interface allowing the user to export a collection of items to files on disk. `func fileExporterFilenameLabel(_:)` On macOS, configures the `fileExporter` with a label for the file name field. ### Importing from file Presents a system interface for allowing the user to import multiple files. Presents a system interface for allowing the user to import an existing file. Presents a system dialog for allowing the user to import multiple files. ### Moving a file Presents a system interface for allowing the user to move an existing file to a new location. Presents a system interface for allowing the user to move a collection of existing files to a new location. Presents a system dialog for allowing the user to move an existing file to a new location. Presents a system dialog for allowing the user to move a collection of existing files to a new location. ### Configuring a file dialog On macOS, configures the `fileExporter`, `fileImporter`, or `fileMover` to provide a refined URL search experience: include or exclude hidden files, allow searching by tag, etc. `func fileDialogConfirmationLabel(_:)` On macOS, configures the the `fileExporter`, `fileImporter`, or `fileMover` with a custom confirmation button label. On macOS, configures the `fileExporter`, `fileImporter`, or `fileMover` to persist and restore the file dialog configuration. Configures the `fileExporter`, `fileImporter`, or `fileMover` to open with the specified default directory. On macOS, configures the `fileExporter`, `fileImporter`, or `fileMover` behavior when a user chooses an alias. `func fileDialogMessage(_:)` On macOS, configures the the `fileExporter`, `fileImporter`, or `fileMover` with a custom text that is presented to the user, similar to a title. On macOS, configures the the `fileImporter` or `fileMover` to conditionally disable presented URLs. `struct FileDialogBrowserOptions` The way that file dialogs present the file system. ### Presenting an inspector Inserts an inspector at the applied position in the view hierarchy. Sets a fixed, preferred width for the inspector containing this view when presented as a trailing column. Sets a flexible, preferred width for the inspector in a trailing-column presentation. ### Dismissing a presentation `var isPresented: Bool` A Boolean value that indicates whether the view associated with this environment is currently presented. `var dismiss: DismissAction` An action that dismisses the current presentation. `struct DismissAction` An action that dismisses a presentation. Conditionally prevents interactive dismissal of presentations like popovers, sheets, and inspectors. ### Deprecated modal presentations `struct Alert` A representation of an alert presentation. Deprecated `struct ActionSheet` A representation of an action sheet presentation. ## See Also ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. --- # https://developer.apple.com/documentation/swiftui/toolbars Collection - SwiftUI - Toolbars API Collection # Toolbars Provide immediate access to frequently used commands and controls. ## Overview The system might present toolbars above or below your app’s content, depending on the platform and the context. Add items to a toolbar by applying the `toolbar(content:)` view modifier to a view in your app. You can also configure the toolbar using view modifiers. For example, you can set the visibility of a toolbar with the `toolbar(_:for:)` modifier. For design guidance, see Toolbars in the Human Interface Guidelines. ## Topics ### Populating a toolbar `func toolbar(content:)` Populates the toolbar or navigation bar with the specified items. `struct ToolbarItem` A model that represents an item which can be placed in the toolbar or navigation bar. `struct ToolbarItemGroup` A model that represents a group of `ToolbarItem` s which can be placed in the toolbar or navigation bar. `struct ToolbarItemPlacement` A structure that defines the placement of a toolbar item. `protocol ToolbarContent` Conforming types represent items that can be placed in various locations in a toolbar. `struct ToolbarContentBuilder` Constructs a toolbar item set from multi-expression closures. `struct ToolbarSpacer` A standard space item in toolbars. Beta `struct DefaultToolbarItem` A toolbar item that represents a system component. ### Populating a customizable toolbar Populates the toolbar or navigation bar with the specified items, allowing for user customization. `protocol CustomizableToolbarContent` Conforming types represent items that can be placed in various locations in a customizable toolbar. `struct ToolbarCustomizationBehavior` The customization behavior of customizable toolbar content. `struct ToolbarCustomizationOptions` Options that influence the default customization behavior of customizable toolbar content. `struct SearchToolbarBehavior` The behavior of a search field in a toolbar. ### Removing default items Remove a toolbar item present by default `struct ToolbarDefaultItemKind` A kind of toolbar item a `View` adds by default. ### Setting toolbar visibility Specifies the visibility of a bar managed by SwiftUI. Specifies the preferred visibility of backgrounds on a bar managed by SwiftUI. `struct ToolbarPlacement` The placement of a toolbar. `struct ContentToolbarPlacement` ### Specifying the role of toolbar content Configures the semantic role for the content populating the toolbar. `struct ToolbarRole` The purpose of content that populates the toolbar. ### Styling a toolbar `func toolbarBackground(_:for:)` Specifies the preferred shape style of the background of a bar managed by SwiftUI. Specifies the preferred color scheme of a bar managed by SwiftUI. Specifies the preferred foreground style of bars managed by SwiftUI. Sets the style for the toolbar defined within this scene. `protocol WindowToolbarStyle` A specification for the appearance and behavior of a window’s toolbar. `var toolbarLabelStyle: ToolbarLabelStyle?` The label style to apply to controls within a toolbar. `struct ToolbarLabelStyle` The label style of a toolbar. `struct SpacerSizing` A type which defines how spacers should size themselves. ### Configuring the toolbar title display mode Configures the toolbar title display mode for this view. `struct ToolbarTitleDisplayMode` A type that defines the behavior of title of a toolbar. ### Setting the toolbar title menu Configure the title menu of a toolbar. `struct ToolbarTitleMenu` The title menu of a toolbar. ### Creating an ornament `func ornament(visibility:attachmentAnchor:contentAlignment:ornament:)` Presents an ornament. `struct OrnamentAttachmentAnchor` An attachment anchor for an ornament. ## See Also ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Enable people to search for text or other content within your app. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. --- # https://developer.apple.com/documentation/swiftui/search Collection - SwiftUI - Search API Collection # Search Enable people to search for text or other content within your app. ## Overview To present a search field in your app, create and manage storage for search text and optionally for discrete search terms known as _tokens_. Then bind the storage to the search field by applying the searchable view modifier to a view in your app. As people interact with the field, they implicitly modify the underlying storage and, thereby, the search parameters. Your app correspondingly updates other parts of its interface. To enhance the search interaction, you can also: - Offer suggestions during search, for both text and tokens. - Implement search scopes that help people to narrow the search space. - Detect when people activate the search field, and programmatically dismiss the search field using environment values. For design guidance, see Searching in the Human Interface Guidelines. ## Topics ### Searching your app’s data model Adding a search interface to your app Present an interface that people can use to search for content in your app. Performing a search operation Update search results based on search text and optional tokens that you store. `func searchable(text:placement:prompt:)` Marks this view as searchable, which configures the display of a search field. `func searchable(text:tokens:placement:prompt:token:)` Marks this view as searchable with text and tokens. `func searchable(text:editableTokens:placement:prompt:token:)` `struct SearchFieldPlacement` The placement of a search field in a view hierarchy. ### Making search suggestions Suggesting search terms Provide suggestions to people searching for content in your app. Configures the search suggestions for this view. Configures how to display search suggestions within this view. `func searchCompletion(_:)` Associates a fully formed string with the value of this view when used as a search suggestion. `func searchable(text:tokens:suggestedTokens:placement:prompt:token:)` Marks this view as searchable with text, tokens, and suggestions. `struct SearchSuggestionsPlacement` The ways that SwiftUI displays search suggestions. ### Limiting search scope Scoping a search operation Divide the search space into a few broad categories. Configures the search scopes for this view. Configures the search scopes for this view with the specified activation strategy. `struct SearchScopeActivation` The ways that searchable modifiers can show or hide search scopes. ### Detecting, activating, and dismissing search Managing search interface activation Programmatically detect and dismiss a search field. `var isSearching: Bool` A Boolean value that indicates when the user is searching. `var dismissSearch: DismissSearchAction` An action that ends the current search interaction. `struct DismissSearchAction` An action that can end a search interaction. `func searchable(text:isPresented:placement:prompt:)` Marks this view as searchable with programmatic presentation of the search field. `func searchable(text:tokens:isPresented:placement:prompt:token:)` Marks this view as searchable with text and tokens, as well as programmatic presentation. `func searchable(text:editableTokens:isPresented:placement:prompt:token:)` `func searchable(text:tokens:suggestedTokens:isPresented:placement:prompt:token:)` Marks this view as searchable with text, tokens, and suggestions, as well as programmatic presentation. ### Displaying toolbar content during search Configures the search toolbar presentation behavior for any searchable modifiers within this view. `struct SearchPresentationToolbarBehavior` A type that defines how the toolbar behaves when presenting search. ### Searching for text in a view Programmatically presents the find and replace interface for text editor views. Prevents find and replace operations in a text editor. Prevents replace operations in a text editor. `struct FindContext` The status of the find navigator for views which support text editing. Beta ## See Also ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Extend your app’s basic functionality to other parts of the system, like by adding a Widget. --- # https://developer.apple.com/documentation/swiftui/app-extensions Collection - SwiftUI - App extensions API Collection # App extensions Extend your app’s basic functionality to other parts of the system, like by adding a Widget. ## Overview Use SwiftUI along with WidgetKit to add widgets to your app. Widgets provide quick access to relevant content from your app. Define a structure that conforms to the `Widget` protocol, and declare a view hierarchy for the widget. Configure the views inside the widget as you do other SwiftUI views, using view modifiers, including a few widget-specific modifiers. For design guidance, see Widgets in the Human Interface Guidelines. ## Topics ### Creating widgets Building Widgets Using WidgetKit and SwiftUI Create widgets to show your app’s content on the Home screen, with custom intents for user-customizable settings. Creating a widget extension Display your app’s content in a convenient, informative widget on various devices. Keeping a widget up to date Plan your widget’s timeline to show timely, relevant information using dynamic views, and update the timeline when things change. Making a configurable widget Give people the option to customize their widgets by adding a custom app intent to your project. `protocol Widget` The configuration and content of a widget to display on the Home screen or in Notification Center. `protocol WidgetBundle` A container used to expose multiple widgets from a single widget extension. `struct LimitedAvailabilityConfiguration` A type-erased widget configuration. `protocol WidgetConfiguration` A type that describes a widget’s content. `struct EmptyWidgetConfiguration` An empty widget configuration. ### Composing control widgets `protocol ControlWidget` The configuration and content of a control widget to display in system spaces such as Control Center, the Lock Screen, and the Action Button. `protocol ControlWidgetConfiguration` A type that describes a control widget’s content. `struct EmptyControlWidgetConfiguration` An empty control widget configuration. `struct ControlWidgetConfigurationBuilder` A custom attribute that constructs a control widget’s body. `protocol ControlWidgetTemplate` `struct EmptyControlWidgetTemplate` An empty control widget template. `struct ControlWidgetTemplateBuilder` A custom attribute that constructs a control widget template’s body. `func controlWidgetActionHint(_:)` The action hint of the control described by the modified label. `func controlWidgetStatus(_:)` The status of the control described by the modified label. ### Labeling a widget `func widgetLabel(_:)` Returns a localized text label that displays additional content outside the accessory family widget’s main SwiftUI view. Creates a label for displaying additional content outside an accessory family widget’s main SwiftUI view. ### Styling a widget group The view modifier that can be applied to `AccessoryWidgetGroup` to specify the shape the three content views will be masked with. The value of `style` is set to `.automatic`, which is `.circular` by default. ### Controlling the accented group Adds the view and all of its subviews to the accented group. ### Managing placement in the Dynamic Island Specifies the vertical placement for a view of an expanded Live Activity that appears in the Dynamic Island. ## See Also ### App structure Define the entry point and top-level structure of your app. Declare the user interface groupings that make up the parts of your app. Display user interface content in a window or a collection of windows. Display unbounded content in a person’s surroundings. Enable people to open and manage documents. Enable people to move between different parts of your app’s view hierarchy within a scene. Present content in a separate view that offers focused interaction. Provide immediate access to frequently used commands and controls. Enable people to search for text or other content within your app. --- # https://developer.apple.com/documentation/swiftui/model-data Collection - SwiftUI - Model data API Collection # Model data Manage the data that your app uses to drive its interface. ## Overview SwiftUI offers a declarative approach to user interface design. As you compose a hierarchy of views, you also indicate data dependencies for the views. When the data changes, either due to an external event or because of an action that the user performs, SwiftUI automatically updates the affected parts of the interface. As a result, the framework automatically performs most of the work that view controllers traditionally do. The framework provides tools, like state variables and bindings, for connecting your app’s data to the user interface. These tools help you maintain a single source of truth for every piece of data in your app, in part by reducing the amount of glue logic you write. Select the tool that best suits the task you need to perform: - Manage transient UI state locally within a view by wrapping value types as `State` properties. - Share a reference to a source of truth, like local state, using the `Binding` property wrapper. - Connect to and observe reference model data in views by applying the `Observable()` macro to the model data type. Instantiate an observable model data type directly in a view using a `State` property. Share the observable model data with other views in the hierarchy without passing a reference using the `Environment` property wrapper. ### Leveraging property wrappers SwiftUI implements many data management types, like `State` and `Binding`, as Swift property wrappers. Apply a property wrapper by adding an attribute with the wrapper’s name to a property’s declaration. @State private var isVisible = true // Declares isVisible as a state variable. The property gains the behavior that the wrapper specifies. The state and data flow property wrappers in SwiftUI watch for changes in your data, and automatically update affected views as necessary. When you refer directly to the property in your code, you access the wrapped value, which for the `isVisible` state property in the example above is the stored Boolean. if isVisible == true { Text("Hello") // Only renders when isVisible is true. } Alternatively, you can access a property wrapper’s projected value by prefixing the property name with the dollar sign ( `$`). SwiftUI state and data flow property wrappers project a `Binding`, which is a two-way connection to the wrapped value, allowing another view to access and mutate a single source of truth. Toggle("Visible", isOn: $isVisible) // The toggle can update the stored value. For more information about property wrappers, see Property Wrappers in The Swift Programming Language. ## Topics ### Creating and sharing view state Managing user interface state Encapsulate view-specific data within your app’s view hierarchy to make your views reusable. `struct State` A property wrapper type that can read and write a value managed by SwiftUI. `struct Bindable` A property wrapper type that supports creating bindings to the mutable properties of observable objects. `struct Binding` A property wrapper type that can read and write a value owned by a source of truth. ### Creating model data Managing model data in your app Create connections between your app’s data model and views. Migrating from the Observable Object protocol to the Observable macro Update your existing app to leverage the benefits of Observation in Swift. `@attached(member, names: named(_$observationRegistrar), named(access), named(withMutation), named(shouldNotifyObservers)) @attached(memberAttribute) @attached(extension, conformances: Observable) macro Observable()` Defines and implements conformance of the Observable protocol. Monitoring data changes in your app Show changes to data in your app’s user interface by using observable objects. `struct StateObject` A property wrapper type that instantiates an observable object. `struct ObservedObject` A property wrapper type that subscribes to an observable object and invalidates a view whenever the observable object changes. `protocol ObservableObject : AnyObject` A type of object with a publisher that emits before the object has changed. ### Responding to data changes `func onChange(of:initial:_:)` Adds a modifier for this view that fires an action when a specific value changes. Adds an action to perform when this view detects data emitted by the given publisher. ### Distributing model data throughout your app Supplies an observable object to a view’s hierarchy. Supplies an `ObservableObject` to a view subhierarchy. `struct EnvironmentObject` A property wrapper type for an observable object that a parent or ancestor view supplies. ### Managing dynamic data `protocol DynamicProperty` An interface for a stored variable that updates an external property of a view. ## See Also ### Data and storage Share data throughout a view hierarchy using the environment. Indicate configuration preferences from views to their container views. Store data for use across sessions of your app. --- # https://developer.apple.com/documentation/swiftui/environment-values Collection - SwiftUI - Environment values API Collection # Environment values Share data throughout a view hierarchy using the environment. ## Overview Views in SwiftUI can react to configuration information that they read from the environment using an `Environment` property wrapper. A view inherits its environment from its container view, subject to explicit changes from an `environment(_:_:)` view modifier, or by implicit changes from one of the many modifiers that operate on environment values. As a result, you can configure a entire hierarchy of views by modifying the environment of the group’s container. You can find many built-in environment values in the `EnvironmentValues` structure. You can also create a custom `EnvironmentValues` property by defining a new property in an extension to the environment values structure and applying the `Entry()` macro to the variable declaration. ## Topics ### Accessing environment values `struct Environment` A property wrapper that reads a value from a view’s environment. `struct EnvironmentValues` A collection of environment values propagated through a view hierarchy. ### Creating custom environment values `macro Entry()` Creates an environment values, transaction, container values, or focused values entry. `protocol EnvironmentKey` A key for accessing values in the environment. ### Modifying the environment of a view Places an observable object in the view’s environment. Sets the environment value of the specified key path to the given value. Transforms the environment value of the specified key path with the given function. ### Modifying the environment of a scene Places an observable object in the scene’s environment. ## See Also ### Data and storage Manage the data that your app uses to drive its interface. Indicate configuration preferences from views to their container views. Store data for use across sessions of your app. --- # https://developer.apple.com/documentation/swiftui/preferences Collection - SwiftUI - Preferences API Collection # Preferences Indicate configuration preferences from views to their container views. ## Overview Whereas you use the environment to configure the subviews of a view, you use preferences to send configuration information from subviews toward their container. However, unlike configuration information that flows down a view hierarchy from one container to many subviews, a single container needs to reconcile potentially conflicting preferences flowing up from its many subviews. When you use the `PreferenceKey` protocol to define a custom preference, you indicate how to merge preferences from multiple subviews. You can then set a value for the preference on a view using the `preference(key:value:)` view modifier. Many built-in modifiers, like `navigationTitle(_:)`, rely on preferences to send configuration information to their container. ## Topics ### Setting preferences Sets a value for the given preference. Applies a transformation to a preference value. ### Creating custom preferences `protocol PreferenceKey` A named value produced by a view. ### Setting preferences based on geometry Sets a value for the specified preference key, the value is a function of a geometry value tied to the current coordinate space, allowing readers of the value to convert the geometry to their local coordinates. Sets a value for the specified preference key, the value is a function of the key’s current value and a geometry value tied to the current coordinate space, allowing readers of the value to convert the geometry to their local coordinates. ### Responding to changes in preferences Adds an action to perform when the specified preference key’s value changes. ### Generating backgrounds and overlays from preferences Reads the specified preference value from the view, using it to produce a second view that is applied as the background of the original view. Reads the specified preference value from the view, using it to produce a second view that is applied as an overlay to the original view. ## See Also ### Data and storage Manage the data that your app uses to drive its interface. Share data throughout a view hierarchy using the environment. Store data for use across sessions of your app. --- # https://developer.apple.com/documentation/swiftui/persistent-storage Collection - SwiftUI - Persistent storage API Collection # Persistent storage Store data for use across sessions of your app. ## Overview The operating system provides ways to store data when your app closes, so that when people open your app again later, they can continue working without interruption. The mechanism that you use depends on factors like what and how much you need to store, whether you need serialized or random access to the data, and so on. You use the same kinds of storage in a SwiftUI app that you use in any other app. For example, you can access files on disk using the `FileManager` interface. However, SwiftUI also provides conveniences that make it easier to use certain kinds of persistent storage in a declarative environment. For example, you can use `FetchRequest` and `FetchedResults` to interact with a Core Data model. ## Topics ### Saving state across app launches Restoring Your App’s State with SwiftUI Provide app continuity for users by preserving their current activities. The default store used by `AppStorage` contained within the view. `struct AppStorage` A property wrapper type that reflects a value from `UserDefaults` and invalidates a view on a change in value in that user default. `struct SceneStorage` A property wrapper type that reads and writes to persisted, per-scene storage. ### Accessing Core Data Loading and Displaying a Large Data Feed Consume data in the background, and lower memory use by batching imports and preventing duplicate records. `var managedObjectContext: NSManagedObjectContext` `struct FetchRequest` A property wrapper type that retrieves entities from a Core Data persistent store. `struct FetchedResults` A collection of results retrieved from a Core Data store. `struct SectionedFetchRequest` A property wrapper type that retrieves entities, grouped into sections, from a Core Data persistent store. `struct SectionedFetchResults` A collection of results retrieved from a Core Data persistent store, grouped into sections. ## See Also ### Data and storage Manage the data that your app uses to drive its interface. Share data throughout a view hierarchy using the environment. Indicate configuration preferences from views to their container views. --- # https://developer.apple.com/documentation/swiftui/view-fundamentals Collection - SwiftUI - View fundamentals API Collection # View fundamentals Define the visual elements of your app using a hierarchy of views. ## Overview Views are the building blocks that you use to declare your app’s user interface. Each view contains a description of what to display for a given state. Every bit of your app that’s visible to the user derives from the description in a view, and any type that conforms to the `View` protocol can act as a view in your app. Compose a custom view by combining built-in views that SwiftUI provides with other custom views that you create in your view’s `body` computed property. Configure views using the view modifiers that SwiftUI provides, or by defining your own view modifiers using the `ViewModifier` protocol and the `modifier(_:)` method. ## Topics ### Creating a view Declaring a custom view Define views and assemble them into a view hierarchy. `protocol View` A type that represents part of your app’s user interface and provides modifiers that you use to configure views. `struct ViewBuilder` A custom parameter attribute that constructs views from closures. ### Modifying a view Configuring views Adjust the characteristics of a view by applying view modifiers. Reducing view modifier maintenance Bundle view modifiers that you regularly reuse into a custom view modifier. Applies a modifier to a view and returns a new view. `protocol ViewModifier` A modifier that you apply to a view or another view modifier, producing a different version of the original value. `struct EmptyModifier` An empty, or identity, modifier, used during development to switch modifiers at compile time. `struct ModifiedContent` A value with a modifier applied to it. `protocol EnvironmentalModifier` A modifier that must resolve to a concrete modifier in an environment before use. `struct ManipulableModifier` Beta `struct ManipulableResponderModifier` Beta `struct ManipulableTransformBindingModifier` Beta `struct ManipulationGeometryModifier` Beta `struct ManipulationGestureModifier` Beta `struct ManipulationUsingGestureStateModifier` Beta `enum Manipulable` A namespace for various manipulable related types. Beta ### Responding to view life cycle updates Adds an action to perform before this view appears. Adds an action to perform after this view disappears. Adds an asynchronous task to perform before this view appears. Adds a task to perform before this view appears or when a specified value changes. ### Managing the view hierarchy Binds a view’s identity to the given proxy value. Sets the unique tag value of this view. Prevents the view from updating its child view when its new value is the same as its old value. ### Supporting view types `struct AnyView` A type-erased view. `struct EmptyView` A view that doesn’t contain any content. `struct EquatableView` A view type that compares itself against its previous value and prevents its child updating if its new value is the same as its old value. `struct SubscriptionView` A view that subscribes to a publisher with an action. `struct TupleView` A View created from a swift tuple of View values. ## See Also ### Views Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. --- # https://developer.apple.com/documentation/swiftui/view-configuration Collection - SwiftUI - View configuration API Collection # View configuration Adjust the characteristics of views in a hierarchy. ## Overview SwiftUI enables you to tune the appearance and behavior of views using view modifiers. Many modifiers apply to specific kinds of views or behaviors, but some apply more generally. For example, you can conditionally hide any view by dynamically setting its opacity, display contextual help when people hover over a view, or request the light or dark appearance for a view. ## Topics ### Hiding views Sets the transparency of this view. Hides this view unconditionally. ### Hiding system elements Hides the labels of any controls contained within this view. Controls the visibility of labels of any controls contained within this view. `var labelsVisibility: Visibility` The labels visibility set by `labelsVisibility(_:)`. Sets the menu indicator visibility for controls within this view. Sets the visibility of the status bar. Sets the preferred visibility of the non-transient system views overlaying the app. `enum Visibility` The visibility of a UI element, chosen automatically based on the platform, current context, and other factors. ### Managing view interaction Adds a condition that controls whether users can interact with this view. `var isEnabled: Bool` A Boolean value that indicates whether the view associated with this environment allows user interaction. Sets a tag that you use for tracking interactivity. Mark the receiver as their content might be invalidated. ### Providing contextual help `func help(_:)` Adds help text to a view using a text view that you provide. ### Detecting and requesting the light or dark appearance Sets the preferred color scheme for this presentation. `var colorScheme: ColorScheme` The color scheme of this environment. `enum ColorScheme` The possible color schemes, corresponding to the light and dark appearances. ### Getting the color scheme contrast `var colorSchemeContrast: ColorSchemeContrast` The contrast associated with the color scheme of this environment. `enum ColorSchemeContrast` The contrast between the app’s foreground and background colors. ### Configuring passthrough Applies an effect to passthrough video. `struct SurroundingsEffect` Effects that the system can apply to passthrough video. `struct BreakthroughEffect` Beta ### Redacting private content Designing your app for the Always On state Customize your watchOS app’s user interface for continuous display. Marks the view as containing sensitive, private user data. Adds a reason to apply a redaction to this view hierarchy. Removes any reason to apply a redaction to this view hierarchy. `var redactionReasons: RedactionReasons` The current redaction reasons applied to the view hierarchy. `var isSceneCaptured: Bool` The current capture state. `struct RedactionReasons` The reasons to apply a redaction to data displayed on screen. ## See Also ### Views Define the visual elements of your app using a hierarchy of views. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. --- # https://developer.apple.com/documentation/swiftui/view-styles Collection - SwiftUI - View styles API Collection # View styles Apply built-in and custom appearances and behaviors to different types of views. ## Overview SwiftUI defines built-in styles for certain kinds of views and automatically selects the appropriate style for a particular presentation context. For example, a `Label` might appear as an icon, a string title, or both, depending on factors like the platform, whether the view appears in a toolbar, and so on. You can override the automatic style by using one of the style view modifiers. These modifiers typically propagate throughout a container view, so that you can wrap a view hierarchy in a style modifier to affect all the views of the given type within the hierarchy. Any of the style protocols that define a `makeBody(configuration:)` method, like `ToggleStyle`, also enable you to define custom styles. Create a type that conforms to the corresponding style protocol and implement its `makeBody(configuration:)` method. Then apply the new style using a style view modifier exactly like a built-in style. ## Topics ### Styling views with Liquid Glass Applying Liquid Glass to custom views Configure, combine, and morph views using Liquid Glass effects. Landmarks: Building an app with Liquid Glass Enhance your app experience with system-provided and custom Liquid Glass. Applies the Liquid Glass effect to a view. Beta Returns a copy of the structure configured to be interactive. `struct GlassEffectContainer` A view that combines multiple Liquid Glass shapes into a single shape that can morph individual shapes into one another. `struct GlassEffectTransition` A structure that describes changes to apply when a glass effect is added or removed from the view hierarchy. `struct GlassButtonStyle` A button style that applies glass border artwork based on the button’s context. ### Styling buttons `func buttonStyle(_:)` Sets the style for buttons within this view to a button style with a custom appearance and standard interaction behavior. `protocol ButtonStyle` A type that applies standard interaction behavior and a custom appearance to all buttons within a view hierarchy. `struct ButtonStyleConfiguration` The properties of a button. `protocol PrimitiveButtonStyle` A type that applies custom interaction behavior and a custom appearance to all buttons within a view hierarchy. `struct PrimitiveButtonStyleConfiguration` Sets the style used for displaying the control (see `SignInWithAppleButton.Style`). ### Styling pickers Sets the style for pickers within this view. `protocol PickerStyle` A type that specifies the appearance and interaction of all pickers within a view hierarchy. Sets the style for date pickers within this view. `protocol DatePickerStyle` A type that specifies the appearance and interaction of all date pickers within a view hierarchy. ### Styling menus Sets the style for menus within this view. `protocol MenuStyle` A type that applies standard interaction behavior and a custom appearance to all menus within a view hierarchy. `struct MenuStyleConfiguration` A configuration of a menu. ### Styling toggles Sets the style for toggles in a view hierarchy. `protocol ToggleStyle` The appearance and behavior of a toggle. `struct ToggleStyleConfiguration` The properties of a toggle instance. ### Styling indicators Sets the style for gauges within this view. `protocol GaugeStyle` Defines the implementation of all gauge instances within a view hierarchy. `struct GaugeStyleConfiguration` The properties of a gauge instance. Sets the style for progress views in this view. `protocol ProgressViewStyle` A type that applies standard interaction behavior to all progress views within a view hierarchy. `struct ProgressViewStyleConfiguration` The properties of a progress view instance. ### Styling views that display text Sets the style for labels within this view. `protocol LabelStyle` A type that applies a custom appearance to all labels within a view. `struct LabelStyleConfiguration` The properties of a label. Sets the style for text fields within this view. `protocol TextFieldStyle` A specification for the appearance and interaction of a text field. Sets the style for text editors within this view. `protocol TextEditorStyle` A specification for the appearance and interaction of a text editor. `struct TextEditorStyleConfiguration` The properties of a text editor. ### Styling collection views Sets the style for lists within this view. `protocol ListStyle` A protocol that describes the behavior and appearance of a list. Sets the style for tables within this view. `protocol TableStyle` A type that applies a custom appearance to all tables within a view. `struct TableStyleConfiguration` The properties of a table. Sets the style for disclosure groups within this view. `protocol DisclosureGroupStyle` A type that specifies the appearance and interaction of disclosure groups within a view hierarchy. ### Styling navigation views Sets the style for navigation split views within this view. `protocol NavigationSplitViewStyle` A type that specifies the appearance and interaction of navigation split views within a view hierarchy. Sets the style for the tab view within the current environment. `protocol TabViewStyle` A specification for the appearance and interaction of a tab view. ### Styling groups Sets the style for control groups within this view. `protocol ControlGroupStyle` Defines the implementation of all control groups within a view hierarchy. `struct ControlGroupStyleConfiguration` The properties of a control group. Sets the style for forms in a view hierarchy. `protocol FormStyle` The appearance and behavior of a form. `struct FormStyleConfiguration` The properties of a form instance. Sets the style for group boxes within this view. `protocol GroupBoxStyle` A type that specifies the appearance and interaction of all group boxes within a view hierarchy. `struct GroupBoxStyleConfiguration` The properties of a group box instance. Sets the style for the index view within the current environment. `protocol IndexViewStyle` Defines the implementation of all `IndexView` instances within a view hierarchy. Sets a style for labeled content. `protocol LabeledContentStyle` The appearance and behavior of a labeled content instance.. `struct LabeledContentStyleConfiguration` The properties of a labeled content instance. ### Styling windows from a view inside the window Sets the style for windows created by interacting with this view. Sets the style for the toolbar in windows created by interacting with this view. ### Adding a glass background on views in visionOS Fills the view’s background with an automatic glass background effect and container-relative rounded rectangle shape. Fills the view’s background with an automatic glass background effect and a shape that you specify. `enum GlassBackgroundDisplayMode` The display mode of a glass background. `protocol GlassBackgroundEffect` A specification for the appearance of a glass background. `struct AutomaticGlassBackgroundEffect` The automatic glass background effect. `struct GlassBackgroundEffectConfiguration` A configuration used to build a custom effect. `struct FeatheredGlassBackgroundEffect` The feathered glass background effect. `struct PlateGlassBackgroundEffect` The plate glass background effect. ## See Also ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. --- # https://developer.apple.com/documentation/swiftui/animations Collection - SwiftUI - Animations API Collection # Animations Create smooth visual updates in response to state changes. ## Overview You tell SwiftUI how to draw your app’s user interface for different states, and then rely on SwiftUI to make interface updates when the state changes. To avoid abrupt visual transitions when the state changes, add animation in one of the following ways: - Animate all of the visual changes for a state change by changing the state inside a call to the `withAnimation(_:_:)` global function. - Add animation to a particular view when a specific value changes by applying the `animation(_:value:)` view modifier to the view. - Animate changes to a `Binding` by using the binding’s `animation(_:)` method. SwiftUI animates the effects that many built-in view modifiers produce, like those that set a scale or opacity value. You can animate other values by making your custom views conform to the `Animatable` protocol, and telling SwiftUI about the value you want to animate. When an animated state change results in adding or removing a view to or from the view hierarchy, you can tell SwiftUI how to transition the view into or out of place using built-in transitions that `AnyTransition` defines, like `slide` or `scale`. You can also create custom transitions. For design guidance, see Motion in the Human Interface Guidelines. ## Topics ### Adding state-based animation to an action Returns the result of recomputing the view’s body with the provided animation. Returns the result of recomputing the view’s body with the provided animation, and runs the completion when all animations are complete. `struct AnimationCompletionCriteria` The criteria that determines when an animation is considered finished. `struct Animation` The way a view changes over time to create a smooth visual transition from one state to another. ### Adding state-based animation to a view `func animation(_:)` Applies the given animation to this view when this view changes. Applies the given animation to this view when the specified value changes. Applies the given animation to all animatable values within the `body` closure. ### Creating phase-based animation Controlling the timing and movements of your animations Build sophisticated animations that you control using phase and keyframe animators. Animates effects that you apply to a view over a sequence of phases that change continuously. Animates effects that you apply to a view over a sequence of phases that change based on a trigger. `struct PhaseAnimator` A container that animates its content by automatically cycling through a collection of phases that you provide, each defining a discrete step within an animation. ### Creating keyframe-based animation Loops the given keyframes continuously, updating the view using the modifiers you apply in `body`. Plays the given keyframes when the given trigger value changes, updating the view using the modifiers you apply in `body`. `struct KeyframeAnimator` A container that animates its content with keyframes. `protocol Keyframes` A type that defines changes to a value over time. `struct KeyframeTimeline` A description of how a value changes over time, modeled using keyframes. `struct KeyframeTrack` A sequence of keyframes animating a single property of a root type. `struct KeyframeTrackContentBuilder` The builder that creates keyframe track content from the keyframes that you define within a closure. `struct KeyframesBuilder` A builder that combines keyframe content values into a single value. `protocol KeyframeTrackContent` A group of keyframes that define an interpolation curve of an animatable value. `struct CubicKeyframe` A keyframe that uses a cubic curve to smoothly interpolate between values. `struct LinearKeyframe` A keyframe that uses simple linear interpolation. `struct MoveKeyframe` A keyframe that immediately moves to the given value without interpolating. `struct SpringKeyframe` A keyframe that uses a spring function to interpolate to the given value. ### Creating custom animations `protocol CustomAnimation` A type that defines how an animatable value changes over time. `struct AnimationContext` Contextual values that a custom animation can use to manage state and access a view’s environment. `struct AnimationState` A container that stores the state for a custom animation. `protocol AnimationStateKey` A key for accessing animation state values. `struct UnitCurve` A function defined by a two-dimensional curve that maps an input progress in the range \[0,1\] to an output progress that is also in the range \[0,1\]. By changing the shape of the curve, the effective speed of an animation or other interpolation can be changed. `struct Spring` A representation of a spring’s motion. ### Making data animatable `protocol Animatable` A type that describes how to animate a property of a view. `struct AnimatableValues` Beta `struct AnimatablePair` A pair of animatable values, which is itself animatable. `protocol VectorArithmetic` A type that can serve as the animatable data of an animatable type. `struct EmptyAnimatableData` An empty type for animatable data. ### Updating a view on a schedule Updating watchOS apps with timelines Seamlessly schedule updates to your user interface, even while it’s inactive. `struct TimelineView` A view that updates according to a schedule that you provide. `protocol TimelineSchedule` A type that provides a sequence of dates for use as a schedule. `typealias TimelineViewDefaultContext` Information passed to a timeline view’s content callback. ### Synchronizing geometries Defines a group of views with synchronized geometry using an identifier and namespace that you provide. `struct MatchedGeometryProperties` A set of view properties that may be synchronized between views using the `View.matchedGeometryEffect()` function. `protocol GeometryEffect` An effect that changes the visual appearance of a view, largely without changing its ancestors or descendants. `struct Namespace` A dynamic property type that allows access to a namespace defined by the persistent identity of the object containing the property (e.g. a view). Isolates the geometry (e.g. position and size) of the view from its parent view. ### Defining transitions `func transition(_:)` Associates a transition with the view. `protocol Transition` A description of view changes to apply when a view is added to and removed from the view hierarchy. `struct TransitionProperties` The properties a `Transition` can have. `enum TransitionPhase` An indication of which the current stage of a transition. `struct AsymmetricTransition` A composite `Transition` that uses a different transition for insertion versus removal. `struct AnyTransition` A type-erased transition. Modifies the view to use a given transition as its method of animating changes to the contents of its views. `var contentTransition: ContentTransition` The current method of animating the contents of views. `var contentTransitionAddsDrawingGroup: Bool` A Boolean value that controls whether views that render content transitions use GPU-accelerated rendering. `struct ContentTransition` A kind of transition that applies to the content within a single view, rather than to the insertion or removal of a view. `struct PlaceholderContentView` A placeholder used to construct an inline modifier, transition, or other helper type. Sets the navigation transition style for this view. `protocol NavigationTransition` A type that defines the transition to use when navigating to a view. Identifies this view as the source of a navigation transition, such as a zoom transition. `protocol MatchedTransitionSourceConfiguration` A configuration that defines the appearance of a matched transition source. `struct EmptyMatchedTransitionSourceConfiguration` An unstyled matched transition source configuration. ### Moving an animation to another view Executes a closure with the specified transaction and returns the result. Executes a closure with the specified transaction key path and value and returns the result. Applies the given transaction mutation function to all animations used within the view. Applies the given transaction mutation function to all animations used within the `body` closure. `struct Transaction` The context of the current state-processing update. `macro Entry()` Creates an environment values, transaction, container values, or focused values entry. `protocol TransactionKey` A key for accessing values in a transaction. ### Deprecated types `protocol AnimatableModifier` A modifier that can create another modifier with animation. Deprecated ## See Also ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. --- # https://developer.apple.com/documentation/swiftui/text-input-and-output Collection - SwiftUI - Text input and output API Collection # Text input and output Display formatted text and get text input from the user. ## Overview To display read-only text, or read-only text paired with an image, use the built-in `Text` or `Label` views, respectively. When you need to collect text input from the user, use an appropriate text input view, like `TextField` or `TextEditor`. You add view modifiers to control the text’s font, selectability, alignment, layout direction, and so on. These modifiers also affect other views that display text, like the labels on controls, even if you don’t define an explicit `Text` view. For design guidance, see Typography in the Human Interface Guidelines. ## Topics ### Displaying text `struct Text` A view that displays one or more lines of read-only text. `struct Label` A standard label for user interface items, consisting of an icon with a title. Sets the style for labels within this view. ### Getting text input Building rich SwiftUI text experiences Build an editor for formatted text using SwiftUI text editor views and attributed strings. `struct TextField` A control that displays an editable text interface. Sets the style for text fields within this view. `struct SecureField` A control into which people securely enter private text. `struct TextEditor` A view that can display and edit long-form text. ### Selecting text Controls whether people can select text within this view. `protocol TextSelectability` A type that describes the ability to select text. `struct TextSelection` Represents a selection of text. Sets the direction of a selection or cursor relative to a text character. `var textSelectionAffinity: TextSelectionAffinity` A representation of the direction or association of a selection or cursor relative to a text character. This concept becomes much more prominent when dealing with bidirectional text (text that contains both LTR and RTL scripts, like English and Arabic combined). `enum TextSelectionAffinity` `struct AttributedTextSelection` Represents a selection of attributed text. Beta ### Setting a font Applying custom fonts to text Add and use a font in your app that scales with Dynamic Type. Sets the default font for text in this view. Sets the font design of the text in this view. Sets the font weight of the text in this view. Sets the font width of the text in this view. `var font: Font?` The default font of this environment. `struct Font` An environment-dependent font. ### Adjusting text size Applies a text scale to text in the view. `func dynamicTypeSize(_:)` Sets the Dynamic Type size within the view to the given value. `var dynamicTypeSize: DynamicTypeSize` The current Dynamic Type size. `enum DynamicTypeSize` A Dynamic Type size, which specifies how large scalable content should be. `struct ScaledMetric` A dynamic property that scales a numeric value. `protocol TextVariantPreference` A protocol for controlling the size variant of text views. `struct FixedTextVariant` The default text variant preference that chooses the largest available variant. `struct SizeDependentTextVariant` The size dependent variant preference allows the text to take the available space into account when choosing the variant to display. ### Controlling text style Applies a bold font weight to the text in this view. Applies italics to the text in this view. Applies an underline to the text in this view. Applies a strikethrough to the text in this view. Sets a transform for the case of the text contained in this view when displayed. `var textCase: Text.Case?` A stylistic override to transform the case of `Text` when displayed, using the environment’s locale. Modifies the fonts of all child views to use the fixed-width variant of the current font, if possible. Modifies the fonts of all child views to use fixed-width digits, if possible, while leaving other characters proportionally spaced. `protocol AttributedTextFormattingDefinition` A protocol for defining how text can be styled in a certain context, e.g. a `TextEditor`. `protocol AttributedTextValueConstraint` A protocol for defining a constraint on the value of a certain attribute. `enum AttributedTextFormatting` A namespace for types related to attributed text formatting definitions. ### Managing text layout Sets the truncation mode for lines of text that are too long to fit in the available space. `var truncationMode: Text.TruncationMode` A value that indicates how the layout truncates the last line of text to fit into the available space. Sets whether text in this view can compress the space between characters when necessary to fit text in a line. `var allowsTightening: Bool` A Boolean value that indicates whether inter-character spacing should tighten to fit the text into the available space. Sets the minimum amount that text in this view scales down to fit in the available space. `var minimumScaleFactor: CGFloat` The minimum permissible proportion to shrink the font size to fit the text into the available space. Sets the vertical offset for the text relative to its baseline in this view. Sets the spacing, or kerning, between characters for the text in this view. Sets the tracking for the text in this view. Sets whether this view mirrors its contents horizontally when the layout direction is right-to-left. `enum TextAlignment` An alignment position for text along the horizontal axis. ### Rendering text Creating visual effects with SwiftUI Add scroll effects, rich color treatments, custom transitions, and advanced effects using shaders and a text renderer. `protocol TextAttribute` A value that you can attach to text views and that text renderers can query. Returns a new view such that any text views within it will use `renderer` to draw themselves. `protocol TextRenderer` A value that can replace the default text view rendering behavior. `struct TextProxy` A proxy for a text view that custom text renderers use. ### Limiting line count for multiline text `func lineLimit(_:)` Sets to a closed range the number of lines that text can occupy in this view. Sets a limit for the number of lines text can occupy in this view. `var lineLimit: Int?` The maximum number of lines that text can occupy in a view. ### Formatting multiline text Sets the amount of space between lines of text in this view. `var lineSpacing: CGFloat` The distance in points between the bottom of one line fragment and the top of the next. Sets the alignment of a text view that contains multiple lines of text. `var multilineTextAlignment: TextAlignment` An environment value that indicates how a text view aligns its lines when the content wraps or contains newlines. ### Formatting date and time `enum SystemFormatStyle` A namespace for format styles that implement designs used across Apple’s platformes. `struct TimeDataSource` A source of time related data. ### Managing text entry Sets whether to disable autocorrection for this view. `var autocorrectionDisabled: Bool` A Boolean value that determines whether the view hierarchy has auto-correction enabled. Sets the keyboard type for this view. Configures the behavior in which scrollable content interacts with the software keyboard. `func textContentType(_:)` Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on macOS. Sets how often the shift key in the keyboard is automatically enabled. `struct TextInputAutocapitalization` The kind of autocapitalization behavior applied during text input. Associates a fully formed string with the value of this view when used as a text input suggestion Configures the text input suggestions for this view. Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on a watchOS device. Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on an iOS or tvOS device. `struct TextInputFormattingControlPlacement` A structure defining the system text formatting controls available on each platform. ### Dictating text Configures the dictation behavior for any search fields configured by the searchable modifier. `struct TextInputDictationActivation` `struct TextInputDictationBehavior` ### Configuring the Writing Tools behavior Specifies the Writing Tools behavior for text and text input in the environment. `struct WritingToolsBehavior` The Writing Tools editing experience for text and text input. ### Specifying text equivalents `func typeSelectEquivalent(_:)` Sets an explicit type select equivalent text in a collection, such as a list or table. ### Localizing text Preparing views for localization Specify hints and add strings to localize your SwiftUI views. `struct LocalizedStringKey` The key used to look up an entry in a strings file or strings dictionary file. `var locale: Locale` The current locale that views should use. `func typesettingLanguage(_:isEnabled:)` Specifies the language for typesetting. `struct TypesettingLanguage` Defines how typesetting language is determined for text. ### Deprecated types `enum ContentSizeCategory` The sizes that you can specify for content. Deprecated ## See Also ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Add images and symbols to your app’s user interface. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. --- # https://developer.apple.com/documentation/swiftui/images Collection - SwiftUI - Images API Collection # Images Add images and symbols to your app’s user interface. ## Overview Display images, including SF Symbols, images that you store in an asset catalog, and images that you store on disk, using an `Image` view. For images that take time to retrieve — for example, when you load an image from a network endpoint — load the image asynchronously using `AsyncImage`. You can instruct that view to display a placeholder during the load operation. For design guidance, see Images in the Human Interface Guidelines. ## Topics ### Creating an image `struct Image` A view that displays an image. ### Configuring an image Fitting images into available space Adjust the size and shape of images in your app’s user interface by applying view modifiers. Scales images within the view according to one of the relative sizes available including small, medium, and large images sizes. `var imageScale: Image.Scale` The image scale for this environment. `enum Scale` A scale to apply to vector images relative to text. `enum Orientation` The orientation of an image. `enum ResizingMode` The modes that SwiftUI uses to resize an image to fit within its containing view. ### Loading images asynchronously `struct AsyncImage` A view that asynchronously loads and displays an image. `enum AsyncImagePhase` The current phase of the asynchronous image loading operation. ### Setting a symbol variant Makes symbols within the view show a particular variant. `var symbolVariants: SymbolVariants` The symbol variant to use in this environment. `struct SymbolVariants` A variant of a symbol. ### Managing symbol effects Returns a new view with a symbol effect added to it. Returns a new view with its inherited symbol image effects either removed or left unchanged. `struct SymbolEffectTransition` Creates a transition that applies the Appear, Disappear, DrawOn or DrawOff symbol animation to symbol images within the inserted or removed view hierarchy. ### Setting symbol rendering modes Sets the rendering mode for symbol images within this view. `var symbolRenderingMode: SymbolRenderingMode?` The current symbol rendering mode, or `nil` denoting that the mode is picked automatically using the current image and foreground style as parameters. `struct SymbolRenderingMode` A symbol rendering mode. `struct SymbolColorRenderingMode` A method of filling a layer in a symbol image. Beta `struct SymbolVariableValueMode` A method of rendering the variable value of a symbol image. ### Rendering images from views `class ImageRenderer` An object that creates images from SwiftUI views. ## See Also ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. --- # https://developer.apple.com/documentation/swiftui/controls-and-indicators Collection - SwiftUI - Controls and indicators API Collection # Controls and indicators Display values and get user selections. ## Overview SwiftUI provides controls that enable user interaction specific to each platform and context. For example, people can initiate events with buttons and links, or choose among a set of discrete values with different kinds of pickers. You can also display information to the user with indicators like progress views and gauges. Use these built-in controls and indicators when composing custom views, and style them to match the needs of your app’s user interface. For design guidance, see Menus and actions, Selection and input, and Status in the Human Interface Guidelines. ## Topics ### Creating buttons `struct Button` A control that initiates an action. `func buttonStyle(_:)` Sets the style for buttons within this view to a button style with a custom appearance and standard interaction behavior. Sets the border shape for buttons in this view. Sets whether buttons in this view should repeatedly trigger their actions on prolonged interactions. `var buttonRepeatBehavior: ButtonRepeatBehavior` Whether buttons with this associated environment should repeatedly trigger their actions on prolonged interactions. `struct ButtonBorderShape` A shape used to draw a button’s border. `struct ButtonRole` A value that describes the purpose of a button. `struct ButtonRepeatBehavior` The options for controlling the repeatability of button actions. `struct ButtonSizing` Beta ### Creating special-purpose buttons `struct EditButton` A button that toggles the edit mode environment value. `struct PasteButton` A system button that reads items from the pasteboard and delivers it to a closure. `struct RenameButton` A button that triggers a standard rename action. ### Linking to other content `struct Link` A control for navigating to a URL. `struct ShareLink` A view that controls a sharing presentation. `struct SharePreview` A representation of a type to display in a share preview. `struct TextFieldLink` A control that requests text input from the user when pressed. `struct HelpLink` A button with a standard appearance that opens app-specific help documentation. ### Getting numeric inputs `struct Slider` A control for selecting a value from a bounded linear range of values. `struct Stepper` A control that performs increment and decrement actions. `struct Toggle` A control that toggles between on and off states. Sets the style for toggles in a view hierarchy. ### Choosing from a set of options `struct Picker` A control for selecting from a set of mutually exclusive values. Sets the style for pickers within this view. Sets the style for radio group style pickers within this view to be horizontally positioned with the radio buttons inside the layout. Sets the default wheel-style picker item height. `var defaultWheelPickerItemHeight: CGFloat` The default height of an item in a wheel-style picker, such as a date picker. Specifies the selection effect to apply to a palette item. `struct PaletteSelectionEffect` The selection effect to apply to a palette item. ### Choosing dates `struct DatePicker` A control for selecting an absolute date. Sets the style for date pickers within this view. `struct MultiDatePicker` A control for picking multiple dates. `var calendar: Calendar` The current calendar that views should use when handling dates. `var timeZone: TimeZone` The current time zone that views should use when handling dates. ### Choosing a color `struct ColorPicker` A control used to select a color from the system color picker UI. ### Indicating a value `struct Gauge` A view that shows a value within a range. Sets the style for gauges within this view. `struct ProgressView` A view that shows the progress toward completion of a task. Sets the style for progress views in this view. `struct DefaultDateProgressLabel` The default type of the current value label when used by a date-relative progress view. `struct DefaultButtonLabel` The default label to use for a button. Beta ### Indicating missing content `struct ContentUnavailableView` An interface, consisting of a label and additional content, that you display when the content of your app is unavailable to users. ### Providing haptic feedback Plays the specified `feedback` when the provided `trigger` value changes. `func sensoryFeedback(trigger:_:)` Plays feedback when returned from the `feedback` closure after the provided `trigger` value changes. Plays the specified `feedback` when the provided `trigger` value changes and the `condition` closure returns `true`. `struct SensoryFeedback` Represents a type of haptic and/or audio feedback that can be played. ### Sizing controls `func controlSize(_:)` Sets the size for controls within this view. `enum ControlSize` The size classes, like regular or small, that you can apply to controls within a view. ## See Also ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. --- # https://developer.apple.com/documentation/swiftui/menus-and-commands Collection - SwiftUI - Menus and commands API Collection # Menus and commands Provide space-efficient, context-dependent access to commands and controls. ## Overview Use a menu to provide people with easy access to common commands. You can add items to a macOS or iPadOS app’s menu bar using the `commands(content:)` scene modifier, or create context menus that people reveal near their current task using the `contextMenu(menuItems:)` view modifier. Create submenus by nesting `Menu` instances inside others. Use a `Divider` view to create a separator between menu elements. For design guidance, see Menus in the Human Interface Guidelines. ## Topics ### Building a menu bar Building and customizing the menu bar with SwiftUI Provide a seamless, cross-platform user experience by building a native menu bar for iPadOS and macOS. ### Creating a menu Populating SwiftUI menus with adaptive controls Improve your app by populating menus with controls and organizing your content intuitively. `struct Menu` A control for presenting a menu of actions. Sets the style for menus within this view. ### Creating context menus Adds a context menu to a view. Adds a context menu with a custom preview to a view. Adds an item-based context menu to a view. ### Defining commands Adds commands to the scene. Removes all commands defined by the modified scene. Replaces all commands defined by the modified scene with the commands from the builder. `protocol Commands` Conforming types represent a group of related commands that can be exposed to the user via the main menu on macOS and key commands on iOS. `struct CommandMenu` Command menus are stand-alone, top-level containers for controls that perform related, app-specific commands. `struct CommandGroup` Groups of controls that you can add to existing command menus. `struct CommandsBuilder` Constructs command sets from multi-expression closures. Like `ViewBuilder`, it supports up to ten expressions in the closure body. `struct CommandGroupPlacement` The standard locations that you can place new command groups relative to. ### Getting built-in command groups `struct SidebarCommands` A built-in set of commands for manipulating window sidebars. `struct TextEditingCommands` A built-in group of commands for searching, editing, and transforming selections of text. `struct TextFormattingCommands` A built-in set of commands for transforming the styles applied to selections of text. `struct ToolbarCommands` A built-in set of commands for manipulating window toolbars. `struct ImportFromDevicesCommands` A built-in set of commands that enables importing content from nearby devices. `struct InspectorCommands` A built-in set of commands for manipulating inspectors. `struct EmptyCommands` An empty group of commands. ### Showing a menu indicator Sets the menu indicator visibility for controls within this view. `var menuIndicatorVisibility: Visibility` The menu indicator visibility to apply to controls within a view. ### Configuring menu dismissal Tells a menu whether to dismiss after performing an action. `struct MenuActionDismissBehavior` The set of menu dismissal behavior options. ### Setting a preferred order Sets the preferred order of items for menus presented from this view. `var menuOrder: MenuOrder` The preferred order of items for menus presented from this view. `struct MenuOrder` The order in which a menu presents its content. ### Deprecated types `struct MenuButton` A button that displays a menu containing a list of choices when pressed. Deprecated `typealias PullDownButton` Deprecated `struct ContextMenu` A container for views that you present as menu items in a context menu. ## See Also ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Display values and get user selections. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. Enhance your views with graphical effects and customized drawings. --- # https://developer.apple.com/documentation/swiftui/shapes Collection - SwiftUI - Shapes API Collection # Shapes Trace and fill built-in and custom shapes with a color, gradient, or other pattern. ## Overview Draw shapes like circles and rectangles, as well as custom paths that define shapes of your own design. Apply styles that include environment-aware colors, rich gradients, and material effects to the foreground, background, and outline of your shapes. If you need the efficiency or flexibility of immediate mode drawing — for example, to create particle effects — use a `Canvas` view instead. ## Topics ### Creating rectangular shapes `struct Rectangle` A rectangular shape aligned inside the frame of the view containing it. `struct RoundedRectangle` A rectangular shape with rounded corners, aligned inside the frame of the view containing it. `enum RoundedCornerStyle` Defines the shape of a rounded rectangle’s corners. `struct UnevenRoundedRectangle` A rectangular shape with rounded corners with different values, aligned inside the frame of the view containing it. `struct RectangleCornerRadii` Describes the corner radius values of a rounded rectangle with uneven corners. ### Creating circular shapes `struct Circle` A circle centered on the frame of the view containing it. `struct Ellipse` An ellipse aligned inside the frame of the view containing it. `struct Capsule` A capsule shape aligned inside the frame of the view containing it. ### Drawing custom shapes `struct Path` The outline of a 2D shape. ### Defining shape behavior `protocol ShapeView` A view that provides a shape that you can use for drawing operations. `protocol Shape` A 2D shape that you can use when drawing a view. `struct AnyShape` A type-erased shape value. `enum ShapeRole` Ways of styling a shape. `struct StrokeStyle` The characteristics of a stroke that traces a path. `struct StrokeShapeView` A shape provider that strokes its shape. `struct StrokeBorderShapeView` A shape provider that strokes the border of its shape. `struct FillStyle` A style for rasterizing vector shapes. `struct FillShapeView` A shape provider that fills its shape. ### Transforming a shape `struct ScaledShape` A shape with a scale transform applied to it. `struct RotatedShape` A shape with a rotation transform applied to it. `struct OffsetShape` A shape with a translation offset transform applied to it. `struct TransformedShape` A shape with an affine transform applied to it. ### Setting a container shape Sets the container shape to use for any container relative shape within this view. `protocol InsettableShape` A shape type that is able to inset itself to produce another shape. `struct ContainerRelativeShape` A shape that is replaced by an inset version of the current container shape. If no container shape was defined, is replaced by a rectangle. ## See Also ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Enhance your views with graphical effects and customized drawings. --- # https://developer.apple.com/documentation/swiftui/drawing-and-graphics Collection - SwiftUI - Drawing and graphics API Collection # Drawing and graphics Enhance your views with graphical effects and customized drawings. ## Overview You create rich, dynamic user interfaces with the built-in views and Shapes that SwiftUI provides. To enhance any view, you can apply many of the graphical effects typically associated with a graphics context, like setting colors, adding masks, and creating composites. When you need the flexibility of immediate mode drawing in a graphics context, use a `Canvas` view. This can be particularly helpful when you want to draw an extremely large number of dynamic shapes — for example, to create particle effects. For design guidance, see Materials and Color in the Human Interface Guidelines. ## Topics ### Immediate mode drawing Add Rich Graphics to Your SwiftUI App Make your apps stand out by adding background materials, vibrancy, custom graphics, and animations. `struct Canvas` A view type that supports immediate mode drawing. `struct GraphicsContext` An immediate mode drawing destination, and its current state. ### Setting a color `func tint(_:)` Sets the tint color within this view. `struct Color` A representation of a color that adapts to a given context. ### Styling content Adds a border to this view with the specified style and width. Sets a view’s foreground elements to use a given style. Sets the primary and secondary levels of the foreground style in the child view. Sets the primary, secondary, and tertiary levels of the foreground style. Sets the specified style to render backgrounds within the view. `var backgroundStyle: AnyShapeStyle?` An optional style that overrides the default system background style when set. `protocol ShapeStyle` A color or pattern to use when rendering a shape. `struct AnyShapeStyle` A type-erased ShapeStyle value. `struct Gradient` A color gradient represented as an array of color stops, each having a parametric location value. `struct MeshGradient` A two-dimensional gradient defined by a 2D grid of positioned colors. `struct AnyGradient` A color gradient. `struct ShadowStyle` A style to use when rendering shadows. `struct Glass` A structure that defines the configuration of the Liquid Glass material. Beta ### Transforming colors Brightens this view by the specified amount. Sets the contrast and separation between similar colors in this view. Inverts the colors in this view. Adds a color multiplication effect to this view. Adjusts the color saturation of this view. Adds a grayscale effect to this view. Applies a hue rotation effect to this view. Adds a luminance to alpha effect to this view. Sets an explicit active appearance for materials in this view. `var materialActiveAppearance: MaterialActiveAppearance` The behavior materials should use for their active state, defaulting to `automatic`. `struct MaterialActiveAppearance` The behavior for how materials appear active and inactive. ### Scaling, rotating, or transforming a view Scales this view to fill its parent. Scales this view to fit its parent. `func scaleEffect(_:anchor:)` Scales this view’s rendered output by the given amount in both the horizontal and vertical directions, relative to an anchor point. Scales this view’s rendered output by the given horizontal and vertical amounts, relative to an anchor point. Scales this view by the specified horizontal, vertical, and depth factors, relative to an anchor point. `func aspectRatio(_:contentMode:)` Constrains this view’s dimensions to the specified aspect ratio. Rotates a view’s rendered output in two dimensions around the specified point. Renders a view’s content as if it’s rotated in three dimensions around the specified axis. Rotates the view’s content by the specified 3D rotation value. `func rotation3DEffect(_:axis:anchor:)` Rotates the view’s content by an angle about an axis that you specify as a tuple of elements. Applies an affine transformation to this view’s rendered output. Applies a 3D transformation to this view’s rendered output. Applies a projection transformation to this view’s rendered output. `struct ProjectionTransform` `enum ContentMode` Constants that define how a view’s content fills the available space. ### Masking and clipping Masks this view using the alpha channel of the given view. Clips this view to its bounding rectangular frame. Sets a clipping shape for this view. ### Applying blur and shadows Applies a Gaussian blur to this view. Adds a shadow to this view. `struct ColorMatrix` A matrix to use in an RGBA color transformation. ### Applying effects based on geometry Applies effects to this view, while providing access to layout information through a geometry proxy. Applies effects to this view, while providing access to layout information through a 3D geometry proxy. `protocol VisualEffect` Visual Effects change the visual appearance of a view without changing its ancestors or descendents. `struct EmptyVisualEffect` The base visual effect that you apply additional effect to. ### Compositing views Sets the blend mode for compositing this view with overlapping views. Wraps this view in a compositing group. Composites this view’s contents into an offscreen image before final display. `enum BlendMode` Modes for compositing a view with overlapping content. `enum ColorRenderingMode` The set of possible working color spaces for color-compositing operations. `protocol CompositorContent` Beta `struct CompositorContentBuilder` A result builder for composing a collection of `CompositorContent` elements. ### Measuring a view `struct GeometryReader` A container view that defines its content as a function of its own size and coordinate space. `struct GeometryReader3D` `struct GeometryProxy` A proxy for access to the size and coordinate space (for anchor resolution) of the container view. `struct GeometryProxy3D` A proxy for access to the size and coordinate space of the container view. Assigns a name to the view’s coordinate space, so other code can operate on dimensions like points and sizes relative to the named space. `enum CoordinateSpace` A resolved coordinate space created by the coordinate space protocol. `protocol CoordinateSpaceProtocol` A frame of reference within the layout system. `struct PhysicalMetric` Provides access to a value in points that corresponds to the specified physical measurement. `struct PhysicalMetricsConverter` A physical metrics converter provides conversion between point values and their extent in 3D space, in the form of physical length measurements. ### Responding to a geometry change `func onGeometryChange(for:of:action:)` Adds an action to be performed when a value, created from a geometry proxy, changes. ### Accessing Metal shaders Returns a new view that applies `shader` to `self` as a filter effect on the color of each pixel. Returns a new view that applies `shader` to `self` as a geometric distortion effect on the location of each pixel. Returns a new view that applies `shader` to `self` as a filter on the raster layer created from `self`. `struct Shader` A reference to a function in a Metal shader library, along with its bound uniform argument values. `struct ShaderFunction` A reference to a function in a Metal shader library. `struct ShaderLibrary` A Metal shader library. ### Accessing geometric constructs `enum Axis` The horizontal or vertical dimension in a 2D coordinate system. `struct Angle` A geometric angle whose value you access in either radians or degrees. `struct UnitPoint` A normalized 2D point in a view’s coordinate space. `struct UnitPoint3D` A normalized 3D point in a view’s coordinate space. `struct Anchor` An opaque value derived from an anchor source and a particular view. `protocol DepthAlignmentID` `struct Alignment3D` An alignment in all three axes. `struct GeometryProxyCoordinateSpace3D` A representation of a `GeometryProxy3D` which can be used for `CoordinateSpace3D` based conversions. ## See Also ### Views Define the visual elements of your app using a hierarchy of views. Adjust the characteristics of views in a hierarchy. Apply built-in and custom appearances and behaviors to different types of views. Create smooth visual updates in response to state changes. Display formatted text and get text input from the user. Add images and symbols to your app’s user interface. Display values and get user selections. Provide space-efficient, context-dependent access to commands and controls. Trace and fill built-in and custom shapes with a color, gradient, or other pattern. --- # https://developer.apple.com/documentation/swiftui/layout-fundamentals Collection - SwiftUI - Layout fundamentals API Collection # Layout fundamentals Arrange views inside built-in layout containers like stacks and grids. ## Overview Use layout containers to arrange the elements of your user interface. Stacks and grids update and adjust the positions of the subviews they contain in response to changes in content or interface dimensions. You can nest layout containers inside other layout containers to any depth to achieve complex layout effects. To finetune the position, alignment, and other elements of a layout that you build with layout container views, see Layout adjustments. To define custom layout containers, see Custom layout. For design guidance, see Layout in the Human Interface Guidelines. ## Topics ### Choosing a layout Picking container views for your content Build flexible user interfaces by using stacks, grids, lists, and forms. ### Statically arranging views in one dimension Building layouts with stack views Compose complex layouts from primitive container views. `struct HStack` A view that arranges its subviews in a horizontal line. `struct VStack` A view that arranges its subviews in a vertical line. ### Dynamically arranging views in one dimension Grouping data with lazy stack views Split content into logical sections inside lazy stack views. Creating performant scrollable stacks Display large numbers of repeated views efficiently with scroll views, stack views, and lazy stacks. `struct LazyHStack` A view that arranges its children in a line that grows horizontally, creating items only as needed. `struct LazyVStack` A view that arranges its children in a line that grows vertically, creating items only as needed. `struct PinnedScrollableViews` A set of view types that may be pinned to the bounds of a scroll view. ### Statically arranging views in two dimensions `struct Grid` A container view that arranges other views in a two dimensional layout. `struct GridRow` A horizontal row in a two dimensional grid container. Tells a view that acts as a cell in a grid to span the specified number of columns. Specifies a custom alignment anchor for a view that acts as a grid cell. Asks grid layouts not to offer the view extra size in the specified axes. Overrides the default horizontal alignment of the grid column that the view appears in. ### Dynamically arranging views in two dimensions `struct LazyHGrid` A container view that arranges its child views in a grid that grows horizontally, creating items only as needed. `struct LazyVGrid` A container view that arranges its child views in a grid that grows vertically, creating items only as needed. `struct GridItem` A description of a row or a column in a lazy grid. ### Layering views Adding a background to your view Compose a background behind your view and extend it beyond the safe area insets. `struct ZStack` A view that overlays its subviews, aligning them in both axes. Controls the display order of overlapping views. Layers the views that you specify behind this view. Sets the view’s background to a style. Sets the view’s background to the default background style. `func background(_:in:fillStyle:)` Sets the view’s background to an insettable shape filled with a style. `func background(in:fillStyle:)` Sets the view’s background to an insettable shape filled with the default background style. Layers the views that you specify in front of this view. Layers the specified style in front of this view. Layers a shape that you specify in front of this view. `var backgroundMaterial: Material?` The material underneath the current view. Sets the container background of the enclosing container using a view. `struct ContainerBackgroundPlacement` The placement of a container background. ### Automatically choosing the layout that fits `struct ViewThatFits` A view that adapts to the available space by providing the first child view that fits. ### Separators `struct Spacer` A flexible space that expands along the major axis of its containing stack layout, or on both axes if not contained in a stack. `struct Divider` A visual element that can be used to separate other content. ## See Also ### View layout Make fine adjustments to alignment, spacing, padding, and other layout parameters. Place views in custom arrangements and create animated transitions between layout types. Display a structured, scrollable column of information. Display selectable, sortable data arranged in rows and columns. Present views in different kinds of purpose-driven containers, like forms or control groups. Enable people to scroll to content that doesn’t fit in the current display. --- # https://developer.apple.com/documentation/swiftui/layout-adjustments Collection - SwiftUI - Layout adjustments API Collection # Layout adjustments Make fine adjustments to alignment, spacing, padding, and other layout parameters. ## Overview Layout containers like stacks and grids provide a great starting point for arranging views in your app’s user interface. When you need to make fine adjustments, use layout view modifiers. You can adjust or constrain the size, position, and alignment of a view. You can also add padding around a view, and indicate how the view interacts with system-defined safe areas. To get started with a basic layout, see Layout fundamentals. For design guidance, see Layout in the Human Interface Guidelines. ## Topics ### Finetuning a layout Laying out a simple view Create a view layout by adjusting the size of views. Inspecting view layout Determine the position and extent of a view using Xcode previews or by adding temporary borders. ### Adding padding around a view `func padding(_:)` Adds a different padding amount to each edge of this view. Adds an equal padding amount to specific edges of this view. `func padding3D(_:)` Pads this view using the edge insets you specify. Adds padding to the specified edges of this view using an amount that’s appropriate for the current scene. Adds a specified kind of padding to the specified edges of this view using an amount that’s appropriate for the current scene. `struct ScenePadding` The padding used to space a view from its containing scene. ### Influencing a view’s size Positions this view within an invisible frame with the specified size. Positions this view within an invisible frame with the specified depth. Positions this view within an invisible frame having the specified size constraints. Positions this view within an invisible frame having the specified depth constraints. Positions this view within an invisible frame with a size relative to the nearest container. Fixes this view at its ideal size. Fixes this view at its ideal size in the specified dimensions. Sets the priority by which a parent layout should apportion space to this child. ### Adjusting a view’s position Making fine adjustments to a view’s position Shift the position of a view by applying the offset or position modifier. Positions the center of this view at the specified point in its parent’s coordinate space. Positions the center of this view at the specified coordinates in its parent’s coordinate space. Offset this view by the horizontal and vertical amount specified in the offset parameter. Offset this view by the specified horizontal and vertical distances. Brings a view forward in Z by the provided distance in points. ### Aligning views Aligning views within a stack Position views inside a stack using alignment guides. Aligning views across stacks Create a custom alignment and use it to align views across multiple stacks. `func alignmentGuide(_:computeValue:)` Sets the view’s horizontal alignment. `struct Alignment` An alignment in both axes. `struct HorizontalAlignment` An alignment position along the horizontal axis. `struct VerticalAlignment` An alignment position along the vertical axis. `struct DepthAlignment` An alignment position along the depth axis. `protocol AlignmentID` A type that you use to create custom alignment guides. `struct ViewDimensions` A view’s size and alignment guides in its own coordinate space. `struct ViewDimensions3D` A view’s 3D size and alignment guides in its own coordinate space. `struct SpatialContainer` A layout container that aligns overlapping content in 3D space. Beta ### Setting margins Configures the content margin for a provided placement. `func contentMargins(_:_:for:)` `struct ContentMarginPlacement` The placement of margins. ### Staying in the safe areas Expands the safe area of a view. `func safeAreaInset(edge:alignment:spacing:content:)` Shows the specified content beside the modified view. `func safeAreaPadding(_:)` Adds the provided insets into the safe area of this view. `struct SafeAreaRegions` A set of symbolic safe area regions. ### Setting a layout direction Sets the behavior of this view for different layout directions. `enum LayoutDirectionBehavior` A description of what should happen when the layout direction changes. `var layoutDirection: LayoutDirection` The layout direction associated with the current environment. `enum LayoutDirection` A direction in which SwiftUI can lay out content. `struct LayoutRotationUnaryLayout` Beta ### Reacting to interface characteristics `var isLuminanceReduced: Bool` A Boolean value that indicates whether the display or environment currently requires reduced luminance. `var displayScale: CGFloat` The display scale of this environment. `var pixelLength: CGFloat` The size of a pixel on the screen. `var horizontalSizeClass: UserInterfaceSizeClass?` The horizontal size class of this environment. `var verticalSizeClass: UserInterfaceSizeClass?` The vertical size class of this environment. `enum UserInterfaceSizeClass` A set of values that indicate the visual size available to the view. ### Accessing edges, regions, and layouts `enum Edge` An enumeration to indicate one edge of a rectangle. `enum Edge3D` An edge or face of a 3D volume. `enum HorizontalEdge` An edge on the horizontal axis. `enum VerticalEdge` An edge on the vertical axis. `struct EdgeInsets` The inset distances for the sides of a rectangle. `struct EdgeInsets3D` The inset distances for the faces of a 3D volume. ## See Also ### View layout Arrange views inside built-in layout containers like stacks and grids. Place views in custom arrangements and create animated transitions between layout types. Display a structured, scrollable column of information. Display selectable, sortable data arranged in rows and columns. Present views in different kinds of purpose-driven containers, like forms or control groups. Enable people to scroll to content that doesn’t fit in the current display. --- # https://developer.apple.com/documentation/swiftui/custom-layout Collection - SwiftUI - Custom layout API Collection # Custom layout Place views in custom arrangements and create animated transitions between layout types. ## Overview You can create complex view layouts using the built-in layout containers and layout view modifiers that SwiftUI provides. However, if you need behavior that you can’t achieve with the built-in layout tools, create a custom layout container type using the `Layout` protocol. A container that you define asks for the sizes of all its subviews, and then indicates where to place the subviews within its own bounds. You can also create animated transitions among layout types that conform to the `Layout` procotol, including both built-in and custom layouts. For design guidance, see Layout in the Human Interface Guidelines. ## Topics ### Creating a custom layout container Composing custom layouts with SwiftUI Arrange views in your app’s interface using layout tools that SwiftUI provides. `protocol Layout` A type that defines the geometry of a collection of views. `struct LayoutSubview` A proxy that represents one subview of a layout. `struct LayoutSubviews` A collection of proxy values that represent the subviews of a layout view. ### Configuring a custom layout `struct LayoutProperties` Layout-specific properties of a layout container. `struct ProposedViewSize` A proposal for the size of a view. `struct ViewSpacing` A collection of the geometric spacing preferences of a view. ### Associating values with views in a custom layout Associates a value with a custom layout property. `protocol LayoutValueKey` A key for accessing a layout value of a layout container’s subviews. ### Transitioning between layout types `struct AnyLayout` A type-erased instance of the layout protocol. `struct HStackLayout` A horizontal container that you can use in conditional layouts. `struct VStackLayout` A vertical container that you can use in conditional layouts. `struct ZStackLayout` An overlaying container that you can use in conditional layouts. `struct GridLayout` A grid that you can use in conditional layouts. ## See Also ### View layout Arrange views inside built-in layout containers like stacks and grids. Make fine adjustments to alignment, spacing, padding, and other layout parameters. Display a structured, scrollable column of information. Display selectable, sortable data arranged in rows and columns. Present views in different kinds of purpose-driven containers, like forms or control groups. Enable people to scroll to content that doesn’t fit in the current display. --- # https://developer.apple.com/documentation/swiftui/lists Collection - SwiftUI - Lists API Collection # Lists Display a structured, scrollable column of information. ## Overview Use a list to display a one-dimensional vertical collection of views. The list is a complex container type that automatically provides scrolling when it grows too large for the current display. You build a list by providing it with individual views for the rows in the list, or by using a `ForEach` to enumerate a group of rows. You can also mix these strategies, blending any number of individual views and `ForEach` constructs. Use view modifiers to configure the appearance and behavior of a list and its rows, headers, sections, and separators. For example, you can apply a style to the list, add swipe gestures to individual rows, or make the list refreshable with a pull-down gesture. You can also use the configuration associated with Scroll views to control the list’s implicit scrolling behavior. For design guidance, see Lists and tables in the Human Interface Guidelines. ## Topics ### Creating a list Displaying data in lists Visualize collections of data with platform-appropriate appearance. `struct List` A container that presents rows of data arranged in a single column, optionally providing the ability to select one or more members. Sets the style for lists within this view. ### Disclosing information progressively `struct OutlineGroup` A structure that computes views and disclosure groups on demand from an underlying collection of tree-structured, identified data. `struct DisclosureGroup` A view that shows or hides another content view, based on the state of a disclosure control. Sets the style for disclosure groups within this view. ### Configuring rows Applies an inset to the rows in a list. Requests that the containing list row use the provided hover effect. Requests that the containing list row have its hover effect disabled. `func listItemTint(_:)` Sets a fixed tint color for content in a list. `struct ListItemTint` A tint effect configuration that you can apply to content in a list. `var defaultMinListRowHeight: CGFloat` The default minimum height of a row in a list. ### Configuring separators Sets the tint color associated with a row. Sets the tint color associated with a section. Sets the display mode for the separator associated with this specific row. Sets whether to hide the separator associated with a list section. ### Configuring headers Sets the header prominence for this view. `var headerProminence: Prominence` The prominence to apply to section headers within a view. `enum Prominence` A type indicating the prominence of a view hierarchy. `var defaultMinListHeaderHeight: CGFloat?` The default minimum height of a header in a list. ### Configuring spacing Sets the vertical spacing between two adjacent rows in a List. `func listSectionSpacing(_:)` Sets the spacing between adjacent sections in a `List` to a custom value. `struct ListSectionSpacing` The spacing options between two adjacent sections in a list. ### Configuring backgrounds Places a custom background view behind a list row item. Overrides whether lists and tables in this view have alternating row backgrounds. `struct AlternatingRowBackgroundBehavior` The styling of views with respect to alternating row backgrounds. `var backgroundProminence: BackgroundProminence` The prominence of the background underneath views associated with this environment. `struct BackgroundProminence` The prominence of backgrounds underneath other views. ### Displaying a badge on a list item `func badge(_:)` Generates a badge for the view from an integer value. Specifies the prominence of badges created by this view. `var badgeProminence: BadgeProminence` The prominence to apply to badges associated with this environment. `struct BadgeProminence` The visual prominence of a badge. ### Configuring interaction Adds custom swipe actions to a row in a list. Adds a condition that controls whether users can select this view. ### Refreshing a list’s content Marks this view as refreshable. `var refresh: RefreshAction?` A refresh action stored in a view’s environment. `struct RefreshAction` An action that initiates a refresh operation. ### Editing a list Adds a condition for whether the view’s view hierarchy is movable. Adds a condition for whether the view’s view hierarchy is deletable. An indication of whether the user can edit the contents of a view associated with this environment. `enum EditMode` A mode that indicates whether the user can edit a view’s content. `struct EditActions` A set of edit actions on a collection of data that a view can offer to a user. `struct EditableCollectionContent` An opaque wrapper view that adds editing capabilities to a row in a list. `struct IndexedIdentifierCollection` A collection wrapper that iterates over the indices and identifiers of a collection together. ## See Also ### View layout Arrange views inside built-in layout containers like stacks and grids. Make fine adjustments to alignment, spacing, padding, and other layout parameters. Place views in custom arrangements and create animated transitions between layout types. Display selectable, sortable data arranged in rows and columns. Present views in different kinds of purpose-driven containers, like forms or control groups. Enable people to scroll to content that doesn’t fit in the current display. --- # https://developer.apple.com/documentation/swiftui/tables Collection - SwiftUI - Tables API Collection # Tables Display selectable, sortable data arranged in rows and columns. ## Overview Use a table to display multiple values across a collection of elements. Each element in the collection appears in a different row of the table, while each value for a given element appears in a different column. Narrow displays may adapt to show only the first column of the table. When you create a table, you provide a collection of elements, and then tell the table how to find the needed value for each column. In simple cases, SwiftUI infers the element for each row, but you can also specify the row elements explicitly in more complex scenarios. With a small amount of additional configuration, you can also make the items in the table selectable, and the columns sortable. Like a `List`, a table includes implicit vertical scrolling that you can configure using the view modifiers described in Scroll views. For design guidance, see Lists and tables in the Human Interface Guidelines. ## Topics ### Creating a table Building a Great Mac App with SwiftUI Create engaging SwiftUI Mac apps by incorporating side bars, tables, toolbars, and several other popular user interface elements. `struct Table` A container that presents rows of data arranged in one or more columns, optionally providing the ability to select one or more members. Sets the style for tables within this view. ### Creating columns `struct TableColumn` A column that displays a view for each row in a table. `protocol TableColumnContent` A type used to represent columns within a table. `struct TableColumnAlignment` Describes the alignment of the content of a table column. `struct TableColumnBuilder` A result builder that creates table column content from closures. `struct TableColumnForEach` A structure that computes columns on demand from an underlying collection of identified data. ### Customizing columns Controls the visibility of a `Table`’s column header views. `struct TableColumnCustomization` A representation of the state of the columns in a table. `struct TableColumnCustomizationBehavior` A set of customization behaviors of a column that a table can offer to a user. ### Creating rows `struct TableRow` A row that represents a data value in a table. `protocol TableRowContent` A type used to represent table rows. `struct TableHeaderRowContent` A table row that displays a single view instead of columned content. `struct TupleTableRowContent` A type of table column content that creates table rows created from a Swift tuple of table rows. `struct TableForEachContent` A type of table row content that creates table rows created by iterating over a collection. `struct EmptyTableRowContent` A table row content that doesn’t produce any rows. `protocol DynamicTableRowContent` A type of table row content that generates table rows from an underlying collection of data. `struct TableRowBuilder` A result builder that creates table row content from closures. ### Adding progressive disclosure `struct DisclosureTableRow` A kind of table row that shows or hides additional rows based on the state of a disclosure control. `struct TableOutlineGroupContent` An opaque table row type created by a table’s hierarchical initializers. ## See Also ### View layout Arrange views inside built-in layout containers like stacks and grids. Make fine adjustments to alignment, spacing, padding, and other layout parameters. Place views in custom arrangements and create animated transitions between layout types. Display a structured, scrollable column of information. Present views in different kinds of purpose-driven containers, like forms or control groups. Enable people to scroll to content that doesn’t fit in the current display. --- # https://developer.apple.com/documentation/swiftui/view-groupings Collection - SwiftUI - View groupings API Collection # View groupings Present views in different kinds of purpose-driven containers, like forms or control groups. ## Overview You can create groups of views that serve different purposes. For example, a `Group` construct treats the specified views as a unit without imposing any additional layout or appearance characteristics. A `Form` presents a group of elements with a platform-specific appearance that’s suitable for gathering input from people. For design guidance, see Layout in the Human Interface Guidelines. ## Topics ### Grouping views into a container Creating custom container views Access individual subviews to compose flexible container views. `struct Group` A type that collects multiple instances of a content type — like views, scenes, or commands — into a single unit. `struct GroupElementsOfContent` Transforms the subviews of a given view into a resulting content view. `struct GroupSectionsOfContent` Transforms the sections of a given view into a resulting content view. ### Organizing views into sections `struct Section` A container view that you can use to add hierarchy within certain views. `struct SectionCollection` An opaque collection representing the sections of view. `struct SectionConfiguration` Specifies the contents of a section. ### Iterating over dynamic data `struct ForEach` A structure that computes views on demand from an underlying collection of identified data. `struct ForEachSectionCollection` A collection which allows a view to be treated as a collection of its sections in a for each loop. `struct ForEachSubviewCollection` A collection which allows a view to be treated as a collection of its subviews in a for each loop. `protocol DynamicViewContent` A type of view that generates views from an underlying collection of data. ### Accessing a container’s subviews `struct Subview` An opaque value representing a subview of another view. `struct SubviewsCollection` An opaque collection representing the subviews of view. `struct SubviewsCollectionSlice` A slice of a SubviewsCollection. Sets a particular container value of a view. `struct ContainerValues` A collection of container values associated with a given view. `protocol ContainerValueKey` A key for accessing container values. ### Grouping views into a box `struct GroupBox` A stylized view, with an optional label, that visually collects a logical grouping of content. Sets the style for group boxes within this view. ### Grouping inputs `struct Form` A container for grouping controls used for data entry, such as in settings or inspectors. Sets the style for forms in a view hierarchy. `struct LabeledContent` A container for attaching a label to a value-bearing view. Sets a style for labeled content. ### Presenting a group of controls `struct ControlGroup` A container view that displays semantically-related controls in a visually-appropriate manner for the context Sets the style for control groups within this view. ## See Also ### View layout Arrange views inside built-in layout containers like stacks and grids. Make fine adjustments to alignment, spacing, padding, and other layout parameters. Place views in custom arrangements and create animated transitions between layout types. Display a structured, scrollable column of information. Display selectable, sortable data arranged in rows and columns. Enable people to scroll to content that doesn’t fit in the current display. --- # https://developer.apple.com/documentation/swiftui/scroll-views Collection - SwiftUI - Scroll views API Collection # Scroll views Enable people to scroll to content that doesn’t fit in the current display. ## Overview When the content of a view doesn’t fit in the display, you can wrap the view in a `ScrollView` to enable people to scroll on one or more axes. Configure the scroll view using view modifiers. For example, you can set the visibility of the scroll indicators or the availability of scrolling in a given dimension. You can put any view type in a scroll view, but you most often use a scroll view for a layout container with too many elements to fit in the display. For some container views that you put in a scroll view, like lazy stacks, the container doesn’t load views until they are visible or almost visible. For others, like regular stacks and grids, the container loads the content all at once, regardless of the state of scrolling. Lists and Tables implicitly include a scroll view, so you don’t need to add scrolling to those container types. However, you can configure their implicit scroll views with the same view modifiers that apply to explicit scroll views. For design guidance, see Scroll views in the Human Interface Guidelines. ## Topics ### Creating a scroll view `struct ScrollView` A scrollable view. `struct ScrollViewReader` A view that provides programmatic scrolling, by working with a proxy to scroll to known child views. `struct ScrollViewProxy` A proxy value that supports programmatic scrolling of the scrollable views within a view hierarchy. ### Managing scroll position Associates a binding to a scroll position with a scroll view within this view. Associates a binding to be updated when a scroll view within this view scrolls. Associates an anchor to control which part of the scroll view’s content should be rendered by default. Associates an anchor to control the position of a scroll view in a particular circumstance. `struct ScrollAnchorRole` A type defining the role of a scroll anchor. `struct ScrollPosition` A type that defines the semantic position of where a scroll view is scrolled within its content. ### Defining scroll targets Sets the scroll behavior of views scrollable in the provided axes. Configures the outermost layout as a scroll target layout. `struct ScrollTarget` A type defining the target in which a scroll view should try and scroll to. `protocol ScrollTargetBehavior` A type that defines the scroll behavior of a scrollable view. `struct ScrollTargetBehaviorContext` The context in which a scroll target behavior updates its scroll target. `struct PagingScrollTargetBehavior` The scroll behavior that aligns scroll targets to container-based geometry. `struct ViewAlignedScrollTargetBehavior` The scroll behavior that aligns scroll targets to view-based geometry. `struct AnyScrollTargetBehavior` A type-erased scroll target behavior. `struct ScrollTargetBehaviorProperties` Properties influencing the scroll view a scroll target behavior applies to. `struct ScrollTargetBehaviorPropertiesContext` The context in which a scroll target behavior can decide its properties. ### Animating scroll transitions Applies the given transition, animating between the phases of the transition as this view appears and disappears within the visible region of the containing scroll view. `enum ScrollTransitionPhase` The phases that a view transitions between when it scrolls among other views. `struct ScrollTransitionConfiguration` The configuration of a scroll transition that controls how a transition is applied as a view is scrolled through the visible region of a containing scroll view or other container. ### Responding to scroll view changes Adds an action to be performed when a value, created from a scroll geometry, changes. Adds an action to be called with information about what views would be considered visible. Adds an action to be called when the view crosses the threshold to be considered on/off screen. `func onScrollPhaseChange(_:)` Adds an action to perform when the scroll phase of the first scroll view in the hierarchy changes. `struct ScrollGeometry` A type that defines the geometry of a scroll view. `enum ScrollPhase` A type that describes the state of a scroll gesture of a scrollable view like a scroll view. `struct ScrollPhaseChangeContext` A type that provides you with more content when the phase of a scroll view changes. ### Showing scroll indicators Flashes the scroll indicators of a scrollable view when it appears. Flashes the scroll indicators of scrollable views when a value changes. Sets the visibility of scroll indicators within this view. `var horizontalScrollIndicatorVisibility: ScrollIndicatorVisibility` The visibility to apply to scroll indicators of any horizontally scrollable content. `var verticalScrollIndicatorVisibility: ScrollIndicatorVisibility` The visiblity to apply to scroll indicators of any vertically scrollable content. `struct ScrollIndicatorVisibility` The visibility of scroll indicators of a UI element. ### Managing content visibility Specifies the visibility of the background for scrollable views within this view. Sets whether a scroll view clips its content to its bounds. `struct ScrollContentOffsetAdjustmentBehavior` A type that defines the different kinds of content offset adjusting behaviors a scroll view can have. ### Disabling scrolling Disables or enables scrolling in scrollable views. `var isScrollEnabled: Bool` A Boolean value that indicates whether any scroll views associated with this environment allow scrolling to occur. ### Configuring scroll bounce behavior Configures the bounce behavior of scrollable views along the specified axis. `var horizontalScrollBounceBehavior: ScrollBounceBehavior` The scroll bounce mode for the horizontal axis of scrollable views. `var verticalScrollBounceBehavior: ScrollBounceBehavior` The scroll bounce mode for the vertical axis of scrollable views. `struct ScrollBounceBehavior` The ways that a scrollable view can bounce when it reaches the end of its content. ### Configuring scroll edge effects Configures the scroll edge effect style for scroll views within this hierarchy. Beta Disables any scroll edge effects for scroll views within this hierarchy. `struct ScrollEdgeEffectStyle` A structure that defines the style of pocket a scroll view will have. `func safeAreaBar(edge:alignment:spacing:content:)` Renders the provided content appropriately to be displayed as a custom bar. ### Interacting with a software keyboard Configures the behavior in which scrollable content interacts with the software keyboard. `var scrollDismissesKeyboardMode: ScrollDismissesKeyboardMode` The way that scrollable content interacts with the software keyboard. `struct ScrollDismissesKeyboardMode` The ways that scrollable content can interact with the software keyboard. ### Managing scrolling for different inputs Enables or disables scrolling in scrollable views when using particular inputs. `struct ScrollInputKind` Inputs used to scroll views. `struct ScrollInputBehavior` A type that defines whether input should scroll a view. ## See Also ### View layout Arrange views inside built-in layout containers like stacks and grids. Make fine adjustments to alignment, spacing, padding, and other layout parameters. Place views in custom arrangements and create animated transitions between layout types. Display a structured, scrollable column of information. Display selectable, sortable data arranged in rows and columns. Present views in different kinds of purpose-driven containers, like forms or control groups. --- # https://developer.apple.com/documentation/swiftui/gestures Collection - SwiftUI - Gestures API Collection # Gestures Define interactions from taps, clicks, and swipes to fine-grained gestures. ## Overview Respond to gestures by adding gesture modifiers to your views. You can listen for taps, drags, pinches, and other standard gestures. You can also compose custom gestures from individual gestures using the `simultaneously(with:)`, `sequenced(before:)`, or `exclusively(before:)` modifiers, or combine gestures with keyboard modifiers using the `modifiers(_:)` modifier. For design guidance, see Gestures in the Human Interface Guidelines. ## Topics ### Essentials Adding interactivity with gestures Use gesture modifiers to add interactivity to your app. ### Recognizing tap gestures Adds an action to perform when this view recognizes a tap gesture. `func onTapGesture(count:coordinateSpace:perform:)` Adds an action to perform when this view recognizes a tap gesture, and provides the action with the location of the interaction. `struct TapGesture` A gesture that recognizes one or more taps. `struct SpatialTapGesture` A gesture that recognizes one or more taps and reports their location. ### Recognizing long press gestures Adds an action to perform when this view recognizes a long press gesture. Adds an action to perform when this view recognizes a remote long touch gesture. A long touch gesture is when the finger is on the remote touch surface without actually pressing. `struct LongPressGesture` A gesture that succeeds when the user performs a long press. ### Recognizing spatial events `struct SpatialEventGesture` A gesture that provides information about ongoing spatial events like clicks and touches. `struct SpatialEventCollection` A collection of spatial input events that target a specific view. `enum Chirality` The chirality, or handedness, of a pose. ### Recognizing gestures that change over time `func gesture(_:)` Attaches an `NSGestureRecognizerRepresentable` to the view. Beta Attaches a gesture to the view with a lower precedence than gestures defined by the view. `struct DragGesture` A dragging motion that invokes an action as the drag-event sequence changes. `struct WindowDragGesture` A gesture that recognizes the motion of and handles dragging a window. `struct MagnifyGesture` A gesture that recognizes a magnification motion and tracks the amount of magnification. `struct RotateGesture` A gesture that recognizes a rotation motion and tracks the angle of the rotation. `struct RotateGesture3D` A gesture that recognizes 3D rotation motion and tracks the angle and axis of the rotation. `struct GestureMask` Options that control how adding a gesture to a view affects other gestures recognized by the view and its subviews. ### Recognizing Apple Pencil gestures Adds an action to perform after the user double-taps their Apple Pencil. Adds an action to perform when the user squeezes their Apple Pencil. `var preferredPencilDoubleTapAction: PencilPreferredAction` The action that the user prefers to perform after double-tapping their Apple Pencil, as selected in the Settings app. `var preferredPencilSqueezeAction: PencilPreferredAction` The action that the user prefers to perform when squeezing their Apple Pencil, as selected in the Settings app. `struct PencilPreferredAction` An action that the user prefers to perform after double-tapping their Apple Pencil. `struct PencilDoubleTapGestureValue` Describes the value of an Apple Pencil double-tap gesture. `struct PencilSqueezeGestureValue` Describes the value of an Apple Pencil squeeze gesture. `enum PencilSqueezeGesturePhase` Describes the phase and value of an Apple Pencil squeeze gesture. `struct PencilHoverPose` A value describing the location and distance of an Apple Pencil hovering in the area above a view’s bounds. ### Combining gestures Composing SwiftUI gestures Combine gestures to create complex interactions. Attaches a gesture to the view to process simultaneously with gestures defined by the view. `struct SequenceGesture` A gesture that’s a sequence of two gestures. `struct SimultaneousGesture` A gesture containing two gestures that can happen at the same time with neither of them preceding the other. `struct ExclusiveGesture` A gesture that consists of two gestures where only one of them can succeed. ### Defining custom gestures Attaches a gesture to the view with a higher precedence than gestures defined by the view. Assigns a hand gesture shortcut to the modified control. Sets the screen edge from which you want your gesture to take precedence over the system gesture. `protocol Gesture` An instance that matches a sequence of events to a gesture, and returns a stream of values for each of its states. `struct AnyGesture` A type-erased gesture. `struct HandActivationBehavior` An activation behavior specific to hand-driven input. `struct HandGestureShortcut` Hand gesture shortcuts describe finger and wrist movements that the user can perform in order to activate a button or toggle. ### Managing gesture state `struct GestureState` A property wrapper type that updates a property while the user performs a gesture and resets the property A gesture that updates the state provided by a gesture’s updating callback. ### Handling activation events Configures whether gestures in this view hierarchy can handle events that activate the containing window. ### Deprecated gestures `struct MagnificationGesture` Deprecated `struct RotationGesture` ## See Also ### Event handling Respond to input from a hardware device, like a keyboard or a Touch Bar. Enable people to move or duplicate items by issuing Copy and Paste commands. Enable people to move or duplicate items by dragging them from one location to another. Identify and control which visible object responds to user interaction. React to system events, like opening a URL. --- # https://developer.apple.com/documentation/swiftui/input-events Collection - SwiftUI - Input events API Collection # Input events Respond to input from a hardware device, like a keyboard or a Touch Bar. ## Overview SwiftUI provides view modifiers that enable your app to listen for and react to various kinds of user input. For example, you can create keyboard shortcuts, respond to a form submission, or take input from the digital crown of an Apple Watch. For design guidance, see Inputs in the Human Interface Guidelines. ## Topics ### Responding to keyboard input Performs an action if the user presses a key on a hardware keyboard while the view has focus. Performs an action if the user presses any key on a hardware keyboard while the view has focus. Performs an action if the user presses one or more keys on a hardware keyboard while the view has focus. `struct KeyPress` ### Creating keyboard shortcuts `func keyboardShortcut(_:)` Assigns a keyboard shortcut to the modified control. Defines a keyboard shortcut and assigns it to the modified control. `var keyboardShortcut: KeyboardShortcut?` The keyboard shortcut that buttons in this environment will be triggered with. `struct KeyboardShortcut` Keyboard shortcuts describe combinations of keys on a keyboard that the user can press in order to activate a button or toggle. `struct KeyEquivalent` Key equivalents consist of a letter, punctuation, or function key that can be combined with an optional set of modifier keys to specify a keyboard shortcut. `struct EventModifiers` A set of key modifiers that you can add to a gesture. ### Responding to modifier keys Performs an action whenever the user presses or releases a hardware modifier key. Builds a view to use in place of the modified view when the user presses the modifier key(s) indicated by the given set. ### Responding to hover events Adds an action to perform when the user moves the pointer over or away from the view’s frame. `func onContinuousHover(coordinateSpace:perform:)` Adds an action to perform when the pointer enters, moves within, and exits the view’s bounds. `func hoverEffect(_:isEnabled:)` Applies a hover effect to this view. Adds a condition that controls whether this view can display hover effects. `func defaultHoverEffect(_:)` Sets the default hover effect to use for views within this view. `var isHoverEffectEnabled: Bool` A Boolean value that indicates whether the view associated with this environment allows hover effects to be displayed. `enum HoverPhase` The current hovering state and value of the pointer. `struct HoverEffectPhaseOverride` Options for overriding a hover effect’s current phase. Beta `struct OrnamentHoverContentEffect` Presents an ornament on hover using a custom effect. `struct OrnamentHoverEffect` Presents an ornament on hover. ### Modifying pointer appearance Sets the pointer style to display when the pointer is over the view. `struct PointerStyle` A style describing the appearance of the pointer (also called a cursor) when it’s hovered over a view. Sets the visibility of the pointer when it’s over the view. ### Changing view appearance for hover events `struct HoverEffect` An effect applied when the pointer hovers over a view. Applies a hover effect to this view, optionally adding it to a `HoverEffectGroup`. Applies a hover effect to this view described by the given closure. `protocol CustomHoverEffect` A type that represents how a view should change when a pointer hovers over a view, or when someone looks at the view. `struct ContentHoverEffect` A `CustomHoverEffect` that applies effects to a view on hover using a closure. `struct HoverEffectGroup` Describes a grouping of effects that activate together. Adds an implicit `HoverEffectGroup` to all effects defined on descendant views, so that all effects added to subviews activate as a group whenever this view or any descendant views are hovered. Adds a `HoverEffectGroup` to all effects defined on descendant views, and activates the group whenever this view or any descendant views are hovered. `struct GroupHoverEffect` A `CustomHoverEffect` that activates a named group of effects. `protocol HoverEffectContent` A type that describes the effects of a view for a particular hover effect phase. `struct EmptyHoverEffectContent` An empty base effect that you use to build other effects. Sets the behavior of the hand pointer while the user is interacting with the view. `struct HandPointerBehavior` A behavior that can be applied to the hand pointer while the user is interacting with a view. ### Responding to submission events Adds an action to perform when the user submits a value to this view. Prevents submission triggers originating from this view to invoke a submission action configured by a submission modifier higher up in the view hierarchy. `struct SubmitTriggers` A type that defines various triggers that result in the firing of a submission action. ### Labeling a submission event Sets the submit label for this view. `struct SubmitLabel` A semantic label describing the label of submission within a view hierarchy. ### Responding to commands Adds an action to perform in response to a move command, like when the user presses an arrow key on a Mac keyboard, or taps the edge of the Siri Remote when controlling an Apple TV. Adds an action to perform in response to the system’s Delete command, or pressing either the ⌫ (backspace) or ⌦ (forward delete) keys while the view has focus. Steps a value through a range in response to page up or page down commands. Sets up an action that triggers in response to receiving the exit command while the view has focus. Adds an action to perform in response to the system’s Play/Pause command. Adds an action to perform in response to the given selector. `enum MoveCommandDirection` Specifies the direction of an arrow key movement. ### Controlling hit testing Sets whether text in this view can compress the space between characters when necessary to fit text in a line. Defines the content shape for hit testing. Sets the content shape for this view. `struct ContentShapeKinds` A kind for the content shape of a view. ### Interacting with the Digital Crown Specifies the visibility of Digital Crown accessory Views on Apple Watch. Places an accessory View next to the Digital Crown on Apple Watch. Tracks Digital Crown rotations by updating the specified binding. `func digitalCrownRotation(detent:from:through:by:sensitivity:isContinuous:isHapticFeedbackEnabled:onChange:onIdle:)` `struct DigitalCrownEvent` An event emitted when the user rotates the Digital Crown. `enum DigitalCrownRotationalSensitivity` The amount of Digital Crown rotation needed to move between two integer numbers. ### Managing Touch Bar input Sets the content that the Touch Bar displays. Sets the Touch Bar content to be shown in the Touch Bar when applicable. Sets principal views that have special significance to this Touch Bar. Sets a user-visible string that identifies the view’s functionality. Sets the behavior of the user-customized view. `struct TouchBar` A container for a view that you can show in the Touch Bar. `enum TouchBarItemPresence` Options that affect user customization of the Touch Bar. ### Responding to capture events Used to register an action triggered by system capture events. Used to register actions triggered by system capture events. ## See Also ### Event handling Define interactions from taps, clicks, and swipes to fine-grained gestures. Enable people to move or duplicate items by issuing Copy and Paste commands. Enable people to move or duplicate items by dragging them from one location to another. Identify and control which visible object responds to user interaction. React to system events, like opening a URL. --- # https://developer.apple.com/documentation/swiftui/clipboard Collection - SwiftUI - Clipboard API Collection # Clipboard Enable people to move or duplicate items by issuing Copy and Paste commands. ## Overview When people issue standard Copy and Cut commands, they expect to move items to the system’s Clipboard, from which they can paste the items into another place in the same app or into another app. Your app can participate in this activity if you add view modifiers that indicate how to respond to the standard commands. In your copy and paste modifiers, provide or accept types that conform to the `Transferable` protocol, or that inherit from the `NSItemProvider` class. When possible, prefer using transferable items. ## Topics ### Copying transferable items Specifies a list of items to copy in response to the system’s Copy command. Specifies an action that moves items to the Clipboard in response to the system’s Cut command. Specifies an action that adds validated items to a view in response to the system’s Paste command. ### Copying items using item providers Adds an action to perform in response to the system’s Copy command. Adds an action to perform in response to the system’s Cut command. `func onPasteCommand(of:perform:)` Adds an action to perform in response to the system’s Paste command. `func onPasteCommand(of:validator:perform:)` Adds an action to perform in response to the system’s Paste command with items that you validate. ## See Also ### Event handling Define interactions from taps, clicks, and swipes to fine-grained gestures. Respond to input from a hardware device, like a keyboard or a Touch Bar. Enable people to move or duplicate items by dragging them from one location to another. Identify and control which visible object responds to user interaction. React to system events, like opening a URL. --- # https://developer.apple.com/documentation/swiftui/drag-and-drop Collection - SwiftUI - Drag and drop API Collection # Drag and drop Enable people to move or duplicate items by dragging them from one location to another. ## Overview Drag and drop offers people a convenient way to move content from one part of your app to another, or from one app to another, using an intuitive dragging gesture. Support this feature in your app by adding view modifiers to potential source and destination views within your app’s interface. In your modifiers, provide or accept types that conform to the `Transferable` protocol, or that inherit from the `NSItemProvider` class. When possible, prefer using transferable items. For design guidance, see Drag and drop in the Human Interface Guidelines. ## Topics ### Essentials Adopting drag and drop using SwiftUI Enable drag-and-drop interactions in lists, tables and custom views. Making a view into a drag source Adopt draggable API to provide items for drag-and-drop operations. ### Configuring drag and drop behavior `struct DragConfiguration` The behavior of the drag, proposed by the dragging source. Beta `struct DropConfiguration` Describes the behavior of the drop. ### Moving items `struct DragSession` Describes the ongoing dragging session. `struct DropSession` Beta ### Moving transferable items Activates this view as the source of a drag and drop operation. Defines the destination of a drag and drop operation that handles the dropped content with a closure that you specify. ### Moving items using item providers Provides a closure that vends the drag representation to be used for a particular data element. `func onDrop(of:isTargeted:perform:)` Defines the destination of a drag-and-drop operation that handles the dropped content with a closure that you specify. `func onDrop(of:delegate:)` Defines the destination of a drag and drop operation using behavior controlled by the delegate that you provide. `protocol DropDelegate` An interface that you implement to interact with a drop operation in a view modified to accept drops. `struct DropProposal` The behavior of a drop. `enum DropOperation` Operation types that determine how a drag and drop session resolves when the user drops a drag item. `struct DropInfo` The current state of a drop. ### Describing preview formations `struct DragDropPreviewsFormation` On macOS, describes the way the dragged previews are visually composed. Both drag sources and drop destination can specify their desired preview formation. ### Configuring spring loading Sets the spring loading behavior this view. `var springLoadingBehavior: SpringLoadingBehavior` The behavior of spring loaded interactions for the views associated with this environment. `struct SpringLoadingBehavior` The options for controlling the spring loading behavior of views. ## See Also ### Event handling Define interactions from taps, clicks, and swipes to fine-grained gestures. Respond to input from a hardware device, like a keyboard or a Touch Bar. Enable people to move or duplicate items by issuing Copy and Paste commands. Identify and control which visible object responds to user interaction. React to system events, like opening a URL. --- # https://developer.apple.com/documentation/swiftui/focus Collection - SwiftUI - Focus API Collection # Focus Identify and control which visible object responds to user interaction. ## Overview Focus indicates which element in the display receives the next input. Use view modifiers to indicate which views can receive focus, to detect which view has focus, and to programmatically control focus state. For design guidance, see Focus and selection in the Human Interface Guidelines. ## Topics ### Essentials Focus Cookbook: Supporting and enhancing focus-driven interactions in your SwiftUI app Create custom focusable views with key-press handlers that accelerate keyboard input and support movement, and control focus programmatically. ### Indicating that a view can receive focus Specifies if the view is focusable. Specifies if the view is focusable, and if so, what focus-driven interactions it supports. `struct FocusInteractions` Values describe different focus interactions that a view can support. ### Managing focus state Modifies this view by binding its focus state to the given state value. Modifies this view by binding its focus state to the given Boolean state value. `var isFocused: Bool` Returns whether the nearest focusable ancestor has focus. `struct FocusState` A property wrapper type that can read and write a value that SwiftUI updates as the placement of focus within the scene changes. `struct FocusedValue` A property wrapper for observing values from the focused view or one of its ancestors. `macro Entry()` Creates an environment values, transaction, container values, or focused values entry. `protocol FocusedValueKey` A protocol for identifier types used when publishing and observing focused values. `struct FocusedBinding` A convenience property wrapper for observing and automatically unwrapping state bindings from the focused view or one of its ancestors. Modifies this view by binding the focus state of the search field associated with the nearest searchable modifier to the given Boolean value. Modifies this view by binding the focus state of the search field associated with the nearest searchable modifier to the given value. ### Exposing value types to focused views Sets the focused value for the given object type. `func focusedValue(_:_:)` Modifies this view by injecting a value that you provide for use by other views whose state depends on the focused view hierarchy. Sets the focused value for the given object type at a scene-wide scope. `func focusedSceneValue(_:_:)` Modifies this view by injecting a value that you provide for use by other views whose state depends on the focused scene. `struct FocusedValues` A collection of state exported by the focused view and its ancestors. ### Exposing reference types to focused views `func focusedObject(_:)` Creates a new view that exposes the provided object to other views whose whose state depends on the focused view hierarchy. `func focusedSceneObject(_:)` Creates a new view that exposes the provided object to other views whose whose state depends on the active scene. `struct FocusedObject` A property wrapper type for an observable object supplied by the focused view or one of its ancestors. ### Setting focus scope Creates a focus scope that SwiftUI uses to limit default focus preferences. Indicates that the view’s frame and cohort of focusable descendants should be used to guide focus movement. ### Controlling default focus Indicates that the view should receive focus by default for a given namespace. Defines a region of the window in which default focus is evaluated by assigning a value to a given focus state binding. `struct DefaultFocusEvaluationPriority` Prioritizations for default focus preferences when evaluating where to move focus in different circumstances. ### Resetting focus `var resetFocus: ResetFocusAction` An action that requests the focus system to reevaluate default focus. `struct ResetFocusAction` An environment value that provides the ability to reevaluate default focus. ### Configuring effects Adds a condition that controls whether this view can display focus effects, such as a default focus ring or hover effect. `var isFocusEffectEnabled: Bool` A Boolean value that indicates whether the view associated with this environment allows focus effects to be displayed. ## See Also ### Event handling Define interactions from taps, clicks, and swipes to fine-grained gestures. Respond to input from a hardware device, like a keyboard or a Touch Bar. Enable people to move or duplicate items by issuing Copy and Paste commands. Enable people to move or duplicate items by dragging them from one location to another. React to system events, like opening a URL. --- # https://developer.apple.com/documentation/swiftui/system-events Collection - SwiftUI - System events API Collection # System events React to system events, like opening a URL. ## Overview Specify view and scene modifiers to indicate how your app responds to certain system events. For example, you can use the `onOpenURL(perform:)` view modifier to define an action to take when your app receives a universal link, or use the `backgroundTask(_:action:)` scene modifier to specify an asynchronous task to carry out in response to a background task event, like the completion of a background URL session. ## Topics ### Sending and receiving user activities Restoring Your App’s State with SwiftUI Provide app continuity for users by preserving their current activities. Advertises a user activity type. Registers a handler to invoke in response to a user activity that your app receives. ### Sending and receiving URLs `var openURL: OpenURLAction` An action that opens a URL. `struct OpenURLAction` Registers a handler to invoke in response to a URL that your app receives. ### Handling external events Specifies the external events for which SwiftUI opens a new instance of the modified scene. Specifies the external events that the view’s scene handles if the scene is already open. ### Handling background tasks Runs the specified action when the system provides a background task. `struct BackgroundTask` The kinds of background tasks that your app or extension can handle. `struct SnapshotData` The associated data of a snapshot background task. `struct SnapshotResponse` Your appplication’s response to a snapshot background task. ### Importing and exporting transferable items Enables importing items from services, such as Continuity Camera on macOS. Exports items for consumption by shortcuts, quick actions, and services. Exports read-write items for consumption by shortcuts, quick actions, and services. ### Importing and exporting using item providers Enables importing item providers from services, such as Continuity Camera on macOS. Exports a read-only item provider for consumption by shortcuts, quick actions, and services. Exports a read-write item provider for consumption by shortcuts, quick actions, and services. ## See Also ### Event handling Define interactions from taps, clicks, and swipes to fine-grained gestures. Respond to input from a hardware device, like a keyboard or a Touch Bar. Enable people to move or duplicate items by issuing Copy and Paste commands. Enable people to move or duplicate items by dragging them from one location to another. Identify and control which visible object responds to user interaction. --- # https://developer.apple.com/documentation/swiftui/accessibility-fundamentals Collection - SwiftUI - Accessibility fundamentals API Collection # Accessibility fundamentals Make your SwiftUI apps accessible to everyone, including people with disabilities. ## Overview Like all Apple UI frameworks, SwiftUI comes with built-in accessibility support. The framework introspects common elements like navigation views, lists, text fields, sliders, buttons, and so on, and provides basic accessibility labels and values by default. You don’t have to do any extra work to enable these standard accessibility features. SwiftUI also provides tools to help you enhance the accessibility of your app. To find out what enhancements you need, try using your app with accessibility features like VoiceOver, Voice Control, and Switch Control, or get feedback from users of your app that regularly use these features. Then use the accessibility view modifiers that SwiftUI provides to improve the experience. For example, you can explicitly add accessibility labels to elements in your UI using the `accessibilityLabel(_:)` or the `accessibilityValue(_:)` view modifier. Customize your use of accessibility modifiers for all the platforms that your app runs on. For example, you may need to adjust the accessibility elements for a companion Apple Watch app that shares a common code base with an iOS app. If you integrate AppKit or UIKit controls in SwiftUI, expose any accessibility labels and make them accessible from your `NSViewRepresentable` or `UIViewRepresentable` views, or provide custom accessibility information if the underlying accessibility labels aren’t available. For design guidance, see Accessibility in the Human Interface Guidelines. ## Topics ### Essentials Creating Accessible Views Make your app accessible to everyone by applying accessibility modifiers to your SwiftUI views. ### Creating accessible elements Creates a new accessibility element, or modifies the `AccessibilityChildBehavior` of the existing accessibility element. Replaces the existing accessibility element’s children with one or more new synthetic accessibility elements. Replaces one or more accessibility elements for this view with new accessibility elements. `struct AccessibilityChildBehavior` Defines the behavior for the child elements of the new parent element. ### Identifying elements Uses the string you specify to identify the view. ### Hiding elements Specifies whether to hide this view from system accessibility features. ### Supporting types `struct AccessibilityTechnologies` Accessibility technologies available to the system. `struct AccessibilityAttachmentModifier` A view modifier that adds accessibility properties to the view ## See Also ### Accessibility Enhance the legibility of content in your app’s interface. Improve access to actions that your app can undertake. Describe interface elements to help people understand what they represent. Enable users to navigate to specific user interface elements using rotors. --- # https://developer.apple.com/documentation/swiftui/accessible-appearance Collection - SwiftUI - Accessible appearance API Collection # Accessible appearance Enhance the legibility of content in your app’s interface. ## Overview Make content easier for people to see by making it larger, giving it greater contrast, or reducing the amount of distracting motion. For design guidance, see Accessibility in the Accessibility section of the Human Interface Guidelines. ## Topics ### Managing color Sets whether this view should ignore the system Smart Invert setting. `var accessibilityInvertColors: Bool` Whether the system preference for Invert Colors is enabled. `var accessibilityDifferentiateWithoutColor: Bool` Whether the system preference for Differentiate without Color is enabled. ### Enlarging content Adds a default large content view to be shown by the large content viewer. Adds a custom large content view to be shown by the large content viewer. `var accessibilityLargeContentViewerEnabled: Bool` Whether the Large Content Viewer is enabled. ### Improving legibility `var accessibilityShowButtonShapes: Bool` Whether the system preference for Show Button Shapes is enabled. `var accessibilityReduceTransparency: Bool` Whether the system preference for Reduce Transparency is enabled. `var legibilityWeight: LegibilityWeight?` The font weight to apply to text. `enum LegibilityWeight` The Accessibility Bold Text user setting options. ### Minimizing motion `var accessibilityDimFlashingLights: Bool` Whether the setting to reduce flashing or strobing lights in video content is on. This setting can also be used to determine if UI in playback controls should be shown to indicate upcoming content that includes flashing or strobing lights. `var accessibilityPlayAnimatedImages: Bool` Whether the setting for playing animations in an animated image is on. When this value is false, any presented image that contains animation should not play automatically. `var accessibilityReduceMotion: Bool` Whether the system preference for Reduce Motion is enabled. ### Using assistive access `var accessibilityAssistiveAccessEnabled: Bool` A Boolean value that indicates whether Assistive Access is in use. `struct AssistiveAccess` A scene that presents an interface appropriate for Assistive Access on iOS and iPadOS. On other platforms, this scene is unused. Beta ## See Also ### Accessibility Make your SwiftUI apps accessible to everyone, including people with disabilities. Improve access to actions that your app can undertake. Describe interface elements to help people understand what they represent. Enable users to navigate to specific user interface elements using rotors. --- # https://developer.apple.com/documentation/swiftui/accessible-controls Collection - SwiftUI - Accessible controls API Collection # Accessible controls Improve access to actions that your app can undertake. ## Overview Help people using assistive technologies to gain access to controls in your app. For design guidance, see Accessibility in the Accessibility section of the Human Interface Guidelines. ## Topics ### Adding actions to views Adds an accessibility action to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. Adds multiple accessibility actions to the view. `func accessibilityAction(named:_:)` Adds an accessibility action labeled by the contents of `label` to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. When the action is performed, the `intent` will be invoked. Adds an accessibility action representing `actionKind` to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. When the action is performed, the `intent` will be invoked. `func accessibilityAction(named:intent:)` Adds an accessibility action labeled `name` to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. When the action is performed, the `intent` will be invoked. Adds an accessibility adjustable action to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. Adds an accessibility scroll action to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. Adds multiple accessibility actions to the view with a specific category. Actions allow assistive technologies, such as VoiceOver, to interact with the view by invoking the action and are grouped by their category. When multiple action modifiers with an equal category are applied to the view, the actions are combined together. `struct AccessibilityActionKind` The structure that defines the kinds of available accessibility actions. `enum AccessibilityAdjustmentDirection` A directional indicator you use when making an accessibility adjustment. `struct AccessibilityActionCategory` Designates an accessibility action category that is provided and named by the system. ### Offering Quick Actions to people Adds a quick action to be shown by the system when active. `protocol AccessibilityQuickActionStyle` A type that describes the presentation style of an accessibility quick action. ### Making gestures accessible `func accessibilityActivationPoint(_:)` The activation point for an element is the location assistive technologies use to initiate gestures. `func accessibilityActivationPoint(_:isEnabled:)` `func accessibilityDragPoint(_:description:)` The point an assistive technology should use to begin a drag interaction. `func accessibilityDragPoint(_:description:isEnabled:)` `func accessibilityDropPoint(_:description:)` The point an assistive technology should use to end a drag interaction. `func accessibilityDropPoint(_:description:isEnabled:)` Explicitly set whether this accessibility element is a direct touch area. Direct touch areas passthrough touch events to the app rather than being handled through an assistive technology, such as VoiceOver. The modifier accepts an optional `AccessibilityDirectTouchOptions` option set to customize the functionality of the direct touch area. Adds an accessibility zoom action to the view. Actions allow assistive technologies, such as VoiceOver, to interact with the view by invoking the action. `struct AccessibilityDirectTouchOptions` An option set that defines the functionality of a view’s direct touch area. `struct AccessibilityZoomGestureAction` Position and direction information of a zoom gesture that someone performs with an assistive technology like VoiceOver. ### Controlling focus Modifies this view by binding its accessibility element’s focus state to the given boolean state value. Modifies this view by binding its accessibility element’s focus state to the given state value. `struct AccessibilityFocusState` A property wrapper type that can read and write a value that SwiftUI updates as the focus of any active accessibility technology, such as VoiceOver, changes. ### Managing interactivity Explicitly set whether this Accessibility element responds to user interaction and would thus be interacted with by technologies such as Switch Control, Voice Control or Full Keyboard Access. ## See Also ### Accessibility Make your SwiftUI apps accessible to everyone, including people with disabilities. Enhance the legibility of content in your app’s interface. Describe interface elements to help people understand what they represent. Enable users to navigate to specific user interface elements using rotors. --- # https://developer.apple.com/documentation/swiftui/accessible-descriptions Collection - SwiftUI - Accessible descriptions API Collection # Accessible descriptions Describe interface elements to help people understand what they represent. ## Overview SwiftUI can often infer some information about your user interface elements, but you can use accessibility modifiers to provide even more information for users that need it. For design guidance, see Accessibility in the Accessibility section of the Human Interface Guidelines. ## Topics ### Applying labels `func accessibilityLabel(_:)` Adds a label to the view that describes its contents. `func accessibilityLabel(_:isEnabled:)` `func accessibilityInputLabels(_:)` Sets alternate input labels with which users identify a view. `func accessibilityInputLabels(_:isEnabled:)` Pairs an accessibility element representing a label with the element for the matching content. `enum AccessibilityLabeledPairRole` The role of an accessibility element in a label / content pair. ### Describing values `func accessibilityValue(_:)` Adds a textual description of the value that the view contains. `func accessibilityValue(_:isEnabled:)` ### Describing content Sets an accessibility text content type. Sets the accessibility level of this heading. `enum AccessibilityHeadingLevel` The hierarchy of a heading in relation other headings. `struct AccessibilityTextContentType` Textual context that assistive technologies can use to improve the presentation of spoken text. ### Describing charts Adds a descriptor to a View that represents a chart to make the chart’s contents accessible to all users. `protocol AXChartDescriptorRepresentable` A type to generate an `AXChartDescriptor` object that you use to provide information about a chart and its data for an accessible experience in VoiceOver or other assistive technologies. ### Adding custom descriptions `func accessibilityCustomContent(_:_:importance:)` Add additional accessibility information to the view. `struct AccessibilityCustomContentKey` Key used to specify the identifier and label associated with an entry of additional accessibility information. ### Assigning traits to content Adds the given traits to the view. Removes the given traits from this view. `struct AccessibilityTraits` A set of accessibility traits that describe how an element behaves. ### Offering hints `func accessibilityHint(_:)` Communicates to the user what happens after performing the view’s action. `func accessibilityHint(_:isEnabled:)` ### Configuring VoiceOver Raises or lowers the pitch of spoken text. Sets whether VoiceOver should always speak all punctuation in the text view. Controls whether to queue pending announcements behind existing speech rather than interrupting speech in progress. Sets whether VoiceOver should speak the contents of the text view character by character. ## See Also ### Accessibility Make your SwiftUI apps accessible to everyone, including people with disabilities. Enhance the legibility of content in your app’s interface. Improve access to actions that your app can undertake. Enable users to navigate to specific user interface elements using rotors. --- # https://developer.apple.com/documentation/swiftui/accessible-navigation Collection - SwiftUI - Accessible navigation API Collection # Accessible navigation Enable users to navigate to specific user interface elements using rotors. ## Overview An accessibility rotor is a shortcut that enables users to quickly navigate to specific elements of the user interface, and, optionally, to specific ranges of text within those elements. The system automatically provides rotors for many navigable elements, but you can supply additional rotors for specific purposes, or replace system rotors when they don’t automatically pick up off-screen elements, like those far down in a `LazyVStack` or a `List`. For design guidance, see Accessibility in the Accessibility section of the Human Interface Guidelines. ## Topics ### Working with rotors `func accessibilityRotor(_:entries:)` Create an Accessibility Rotor with the specified user-visible label, and entries generated from the content closure. `func accessibilityRotor(_:entries:entryID:entryLabel:)` Create an Accessibility Rotor with the specified user-visible label and entries. `func accessibilityRotor(_:entries:entryLabel:)` `func accessibilityRotor(_:textRanges:)` Create an Accessibility Rotor with the specified user-visible label and entries for each of the specified ranges. The Rotor will be attached to the current Accessibility element, and each entry will go the specified range of that element. ### Creating rotors `protocol AccessibilityRotorContent` Content within an accessibility rotor. `struct AccessibilityRotorContentBuilder` Result builder you use to generate rotor entry content. `struct AccessibilityRotorEntry` A struct representing an entry in an Accessibility Rotor. ### Replacing system rotors `struct AccessibilitySystemRotor` Designates a Rotor that replaces one of the automatic, system-provided Rotors with a developer-provided Rotor. ### Configuring rotors Defines an explicit identifier tying an Accessibility element for this view to an entry in an Accessibility Rotor. Links multiple accessibility elements so that the user can quickly navigate from one element to another, even when the elements are not near each other in the accessibility hierarchy. Sets the sort priority order for this view’s accessibility element, relative to other elements at the same level. ## See Also ### Accessibility Make your SwiftUI apps accessible to everyone, including people with disabilities. Enhance the legibility of content in your app’s interface. Improve access to actions that your app can undertake. Describe interface elements to help people understand what they represent. --- # https://developer.apple.com/documentation/swiftui/appkit-integration Collection - SwiftUI - AppKit integration API Collection # AppKit integration Add AppKit views to your SwiftUI app, or use SwiftUI views in your AppKit app. ## Overview Integrate SwiftUI with your app’s existing content using hosting controllers to add SwiftUI views into AppKit interfaces. A hosting controller wraps a set of SwiftUI views in a form that you can then add to your storyboard-based app. You can also add AppKit views and view controllers to your SwiftUI interfaces. A representable object wraps the designated view or view controller, and facilitates communication between the wrapped object and your SwiftUI views. For design guidance, see Designing for macOS in the Human Interface Guidelines. ## Topics ### Displaying SwiftUI views in AppKit Unifying your app’s animations Create a consistent UI animation experience across SwiftUI, UIKit, and AppKit. `class NSHostingController` An AppKit view controller that hosts SwiftUI view hierarchy. `class NSHostingView` An AppKit view that hosts a SwiftUI view hierarchy. `class NSHostingMenu` An AppKit menu with menu items that are defined by a SwiftUI View. `struct NSHostingSizingOptions` Options for how hosting views and controllers reflect their content’s size into Auto Layout constraints. `class NSHostingSceneRepresentation` An AppKit type that hosts and can present SwiftUI scenes Beta `struct NSHostingSceneBridgingOptions` Options for how hosting views and controllers manage aspects of the associated window. ### Adding AppKit views to SwiftUI view hierarchies `protocol NSViewRepresentable` A wrapper that you use to integrate an AppKit view into your SwiftUI view hierarchy. `struct NSViewRepresentableContext` Contextual information about the state of the system that you use to create and update your AppKit view. `protocol NSViewControllerRepresentable` A wrapper that you use to integrate an AppKit view controller into your SwiftUI interface. `struct NSViewControllerRepresentableContext` Contextual information about the state of the system that you use to create and update your AppKit view controller. ### Adding AppKit gesture recognizers into SwiftUI view hierarchies `protocol NSGestureRecognizerRepresentable` A wrapper for an `NSGestureRecognizer` that you use to integrate that gesture recognizer into your SwiftUI hierarchy. `struct NSGestureRecognizerRepresentableContext` Contextual information about the state of the system that you use to create and update a represented gesture recognizer. `struct NSGestureRecognizerRepresentableCoordinateSpaceConverter` A structure used to convert locations to and from coordinate spaces in the hierarchy of the SwiftUI view associated with an `NSGestureRecognizerRepresentable`. ## See Also ### Framework integration Add UIKit views to your SwiftUI app, or use SwiftUI views in your UIKit app. Add WatchKit views to your SwiftUI app, or use SwiftUI views in your WatchKit app. Use SwiftUI views that other Apple frameworks provide. --- # https://developer.apple.com/documentation/swiftui/uikit-integration Collection - SwiftUI - UIKit integration API Collection # UIKit integration Add UIKit views to your SwiftUI app, or use SwiftUI views in your UIKit app. ## Overview Integrate SwiftUI with your app’s existing content using hosting controllers to add SwiftUI views into UIKit interfaces. A hosting controller wraps a set of SwiftUI views in a form that you can then add to your storyboard-based app. You can also add UIKit views and view controllers to your SwiftUI interfaces. A representable object wraps the designated view or view controller, and facilitates communication between the wrapped object and your SwiftUI views. For design guidance, see the following sections in the Human Interface Guidelines: - Designing for iOS - Designing for iPadOS - Designing for tvOS ## Topics ### Displaying SwiftUI views in UIKit Using SwiftUI with UIKit Learn how to incorporate SwiftUI views into a UIKit app. Unifying your app’s animations Create a consistent UI animation experience across SwiftUI, UIKit, and AppKit. `class UIHostingController` A UIKit view controller that manages a SwiftUI view hierarchy. `struct UIHostingControllerSizingOptions` Options for how a hosting controller tracks its content’s size. `struct UIHostingConfiguration` A content configuration suitable for hosting a hierarchy of SwiftUI views. `protocol UIHostingSceneDelegate` Extends `UIKit/UISceneDelegate` to bridge SwiftUI scenes. Beta ### Adding UIKit views to SwiftUI view hierarchies `protocol UIViewRepresentable` A wrapper for a UIKit view that you use to integrate that view into your SwiftUI view hierarchy. `struct UIViewRepresentableContext` Contextual information about the state of the system that you use to create and update your UIKit view. `protocol UIViewControllerRepresentable` A view that represents a UIKit view controller. `struct UIViewControllerRepresentableContext` Contextual information about the state of the system that you use to create and update your UIKit view controller. ### Adding UIKit gesture recognizers into SwiftUI view hierarchies `protocol UIGestureRecognizerRepresentable` A wrapper for a `UIGestureRecognizer` that you use to integrate that gesture recognizer into your SwiftUI hierarchy. `struct UIGestureRecognizerRepresentableContext` Contextual information about the state of the system that you use to create and update a represented gesture recognizer. `struct UIGestureRecognizerRepresentableCoordinateSpaceConverter` A proxy structure used to convert locations to/from coordinate spaces in the hierarchy of the SwiftUI view associated with a `UIGestureRecognizerRepresentable`. ### Sharing configuration information `typealias UITraitBridgedEnvironmentKey` ### Hosting an ornament in UIKit `class UIHostingOrnament` A model that represents an ornament suitable for being hosted in UIKit. `class UIOrnament` The abstract base class that represents an ornament. ## See Also ### Framework integration Add AppKit views to your SwiftUI app, or use SwiftUI views in your AppKit app. Add WatchKit views to your SwiftUI app, or use SwiftUI views in your WatchKit app. Use SwiftUI views that other Apple frameworks provide. --- # https://developer.apple.com/documentation/swiftui/watchkit-integration Collection - SwiftUI - WatchKit integration API Collection # WatchKit integration Add WatchKit views to your SwiftUI app, or use SwiftUI views in your WatchKit app. ## Overview Integrate SwiftUI with your app’s existing content using hosting controllers to add SwiftUI views into WatchKit interfaces. A hosting controller wraps a set of SwiftUI views in a form that you can then add to your storyboard-based app. You can also add WatchKit views and view controllers to your SwiftUI interfaces. A representable object wraps the designated view or view controller, and facilitates communication between the wrapped object and your SwiftUI views. For design guidance, see Designing for watchOS in the Human Interface Guidelines. ## Topics ### Displaying SwiftUI views in WatchKit `class WKHostingController` A WatchKit interface controller that hosts a SwiftUI view hierarchy. `class WKUserNotificationHostingController` A WatchKit user notification interface controller that hosts a SwiftUI view hierarchy. ### Adding WatchKit views to SwiftUI view hierarchies `protocol WKInterfaceObjectRepresentable` A view that represents a WatchKit interface object. `struct WKInterfaceObjectRepresentableContext` Contextual information about the state of the system that you use to create and update your WatchKit interface object. ## See Also ### Framework integration Add AppKit views to your SwiftUI app, or use SwiftUI views in your AppKit app. Add UIKit views to your SwiftUI app, or use SwiftUI views in your UIKit app. Use SwiftUI views that other Apple frameworks provide. --- # https://developer.apple.com/documentation/swiftui/technology-specific-views Collection - SwiftUI - Technology-specific views API Collection # Technology-specific views Use SwiftUI views that other Apple frameworks provide. ## Overview To access SwiftUI views that another framework defines, import both SwiftUI and the other framework into the file where you use the view. You can find the framework to import by looking at the availability information on the view’s documentation page. For example, to use the `Map` view in your app, import both SwiftUI and MapKit. import SwiftUI import MapKit struct MyMapView: View { // Center the map on Joshua Tree National Park. var region = MKCoordinateRegion( center: CLLocationCoordinate2D(latitude: 34.011_286, longitude: -116.166_868), span: MKCoordinateSpan(latitudeDelta: 0.2, longitudeDelta: 0.2) ) var body: some View { Map(initialPosition: .region(region)) } } For design guidance, see Technologies in the Human Interface Guidelines. ## Topics ### Accessing Apple Pay and Wallet A view that displays a button for identity verification. Sets the button’s style. Sets the style to be used by the button. (see `PKAddPassButtonStyle`). Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. Sets the action on the PayLaterView. See `PKPayLaterAction`. Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Sets the style to be used by the button. (see `PKIdentityButtonStyle`). Provides a task to perform before this view appears ### Authorizing and authenticating A SwiftUI view that displays an authentication interface. `@MainActor @preconcurrency struct SignInWithAppleButton` The view that creates the Sign in with Apple button for display. Sets the style used for displaying the control (see `SignInWithAppleButton.Style`). `var authorizationController: AuthorizationController` A value provided in the SwiftUI environment that views can use to perform authorization requests. `var webAuthenticationSession: WebAuthenticationSession` A value provided in the SwiftUI environment that views can use to authenticate a user through a web service. ### Configuring Family Sharing `@MainActor @preconcurrency struct FamilyActivityPicker` A view in which users specify applications, web domains, and categories without revealing their choices to the app. Presents an activity picker view as a sheet. ### Reporting on device activity `@MainActor @preconcurrency struct DeviceActivityReport` A view that reports the user’s application, category, and web domain activity in a privacy-preserving way. ### Working with managed devices Applies a managed content style to the view. Presents a modal view that enables users to add devices to their organization. ### Creating graphics A SwiftUI view that displays a chart. `@MainActor @preconcurrency struct SceneView` A SwiftUI view for displaying 3D SceneKit content. Deprecated `@MainActor @preconcurrency struct SpriteView` A SwiftUI view that renders a SpriteKit scene. ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. Presents a map item detail sheet. ### Displaying media `@MainActor @preconcurrency struct CameraView` A SwiftUI view into which a video stream or an image snapshot is rendered. `@MainActor @preconcurrency struct NowPlayingView` A view that displays the system’s Now Playing interface so that the user can control audio. A view that displays content from a player and a native user interface to control playback. A `continuityDevicePicker` should be used to discover and connect nearby continuity device through a button interface or other form of activation. On tvOS, this presents a fullscreen continuity device picker experience when selected. The modal view covers as much the screen of `self` as possible when a given condition is true. Specifies the view that should act as the virtual camera for Apple Vision Pro 2D Persona stream. ### Selecting photos A view that displays a Photos picker for choosing assets from the photo library. Presents a Photos picker that selects a `PhotosPickerItem`. Presents a Photos picker that selects a `PhotosPickerItem` from a given photo library. Presents a Photos picker that selects a collection of `PhotosPickerItem`. Presents a Photos picker that selects a collection of `PhotosPickerItem` from a given photo library. Sets the accessory visibility of the Photos picker. Accessories include anything between the content and the edge, like the navigation bar or the sidebar. Disables capabilities of the Photos picker. Sets the mode of the Photos picker. ### Previewing content Presents a Quick Look preview of the contents of a single URL. Presents a Quick Look preview of the URLs you provide. ### Interacting with networked devices A SwiftUI view that displays other devices on the network, and creates an encrypted connection to a copy of your app running on that device. `var devicePickerSupports: DevicePickerSupportedAction` Checks for support to present a DevicePicker. ### Configuring a Live Activity The text color for the auxiliary action button that the system shows next to a Live Activity on the Lock Screen. Sets the tint color for the background of a Live Activity that appears on the Lock Screen. `var isActivityFullscreen: Bool` A Boolean value that indicates whether the Live Activity appears in a full-screen presentation. `var activityFamily: ActivityFamily` The size family of the current Live Activity. ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. Declares the view as dependent on a collection of In-App Purchase products and returns a modified view. Declares the view as dependent on the status of an auto-renewable subscription group, and returns a modified view. Configures subscription store view instances within a view to use the provided button label. Sets a view to use to decorate individual subscription options within a subscription store view. Sets the control style for subscription store views within a view. Sets the control style and control placement for subscription store views within a view. Sets the style subscription store views within this view use to display groups of subscription options. Sets the background style for picker items of the subscription store view instances within a view. Sets the background shape and style for subscription store view picker items within a view. Configures a view as the destination for a policy button action in subscription store views. Configures a URL as the destination for a policy button action in subscription store views. Sets the style for the and buttons within a subscription store view. Sets the primary and secondary style for the and buttons within a subscription store view. Adds an action to perform when a person uses the sign-in button on a subscription store view within a view. `func subscriptionStoreControlBackground(_:)` Set a standard effect to use for the background of subscription store view controls within the view. Selects a promotional offer to apply to a purchase a customer makes from a subscription store view. Selects a subscription offer to apply to a purchase that a customer makes from a subscription store view, a store view, or a product view. ### Accessing health data Asynchronously requests permission to read a data type that requires per-object authorization (such as vision prescriptions). Requests permission to read the specified HealthKit data types. Requests permission to save and read the specified HealthKit data types. Presents a preview of the workout contents as a modal sheet ### Providing tips Presents a popover tip on the modified view. Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. Sets the corner radius for an inline tip view. Sets the size for a tip’s image. Sets the given style for TipView within the view hierarchy. Sets the style for a tip’s image. ### Showing a translation Presents a translation popover when a given condition is true. Adds a task to perform before this view appears or when the translation configuration changes. Adds a task to perform before this view appears or when the specified source or target languages change. ### Presenting journaling suggestions Presents a visual picker interface that contains events and images that a person can select to retrieve more information. ### Managing contact access Modally present UI which allows the user to select which contacts your app has access to. ### Handling game controller events Specifies the game controllers events which should be delivered through the GameController framework when the view, or one of its descendants has focus. ### Creating a tabletop game Adds a tabletop game to a view. Supplies a closure which returns a new interaction whenever needed. ### Configuring camera controls `var realityViewCameraControls: CameraControls` The camera controls for the reality view. Adds gestures that control the position and direction of a virtual camera. ### Interacting with transactions Presents a picker that selects a collection of transactions. ## See Also ### Framework integration Add AppKit views to your SwiftUI app, or use SwiftUI views in your AppKit app. Add UIKit views to your SwiftUI app, or use SwiftUI views in your UIKit app. Add WatchKit views to your SwiftUI app, or use SwiftUI views in your WatchKit app. --- # https://developer.apple.com/documentation/swiftui/previews-in-xcode Collection - SwiftUI - Previews in Xcode API Collection # Previews in Xcode Generate dynamic, interactive previews of your custom views. ## Overview When you create a custom `View` with SwiftUI, Xcode can display a preview of the view’s content that stays up-to-date as you make changes to the view’s code. You use one of the preview macros — like `Preview(_:body:)` — to tell Xcode what to display. Xcode shows the preview in a canvas beside your code. Different preview macros enable different kinds of configuration. For example, you can add traits that affect the preview’s appearance using the `Preview(_:traits:_:body:)` macro or add custom viewpoints for the preview using the `Preview(_:traits:body:cameras:)` macro. You can also check how your view behaves inside a specific scene type. For example, in visionOS you can use the `Preview(_:immersionStyle:traits:body:)` macro to preview your view inside an `ImmersiveSpace`. You typically rely on preview macros to create previews in your code. However, if you can’t get the behavior you need using a preview macro, you can use the `PreviewProvider` protocol and its associated supporting types to define and configure a preview. ## Topics ### Essentials Previewing your app’s interface in Xcode Iterate designs quickly and preview your apps’ displays across different Apple devices. ### Creating a preview Creates a preview of a SwiftUI view. Creates a preview of a SwiftUI view using the specified traits. Creates a preview of a SwiftUI view using the specified traits and custom viewpoints. ### Creating a preview in the context of a scene Creates a preview of a SwiftUI view in an immersive space. Creates a preview of a SwiftUI view in an immersive space with custom viewpoints. Creates a preview of a SwiftUI view in a window. Creates a preview of a SwiftUI view in a window with custom viewpoints. ### Defining a preview `macro Previewable()` Tag allowing a dynamic property to appear inline in a preview. `protocol PreviewProvider` A type that produces view previews in Xcode. `enum PreviewPlatform` Platforms that can run the preview. Sets a user visible name to show in the canvas for a preview. `protocol PreviewModifier` A type that defines an environment in which previews can appear. `struct PreviewModifierContent` The type-erased content of a preview. ### Customizing a preview Overrides the device for a preview. `struct PreviewDevice` A simulator device that runs a preview. Overrides the size of the container for the preview. Overrides the orientation of the preview. `struct InterfaceOrientation` The orientation of the interface from the user’s perspective. ### Setting a context Declares a context for the preview. `protocol PreviewContext` A context type for use with a preview. `protocol PreviewContextKey` A key type for a preview context. ### Building in debug mode `struct DebugReplaceableView` Erases view opaque result types in debug builds. Beta ## See Also ### Tool support Expose custom views and modifiers in the Xcode library. Measure and improve your app’s responsiveness. --- # https://developer.apple.com/documentation/swiftui/xcode-library-customization Collection - SwiftUI - Xcode library customization # Xcode library customization Expose custom views and modifiers in the Xcode library. ## Overview You can add your custom SwiftUI views and view modifiers to Xcode’s library. This allows anyone developing your app or adopting your framework to access them by clicking the Library button (+) in Xcode’s toolbar. You can select and drag the custom library items into code, just like you would for system-provided items. To add items to the library, create a structure that conforms to the `LibraryContentProvider` protocol and encapsulate any items you want to add as `LibraryItem` instances. Implement the doc://com.apple.documentation/documentation/DeveloperToolsSupport/LibraryContentProvider/views-25pdm computed property to add library items containing views. Implement the doc://com.apple.documentation/documentation/DeveloperToolsSupport/LibraryContentProvider/modifiers(base:)-4svii method to add items containing view modifiers. Xcode harvests items from all of the library content providers in your project as you work, and makes them available to you in its library. ## Topics ### Creating library items `protocol LibraryContentProvider` A source of Xcode library and code completion content. `struct LibraryItem` A single item to add to the Xcode library. ## See Also ### Tool support Generate dynamic, interactive previews of your custom views. Measure and improve your app’s responsiveness. --- # https://developer.apple.com/documentation/swiftui/performance-analysis Collection - SwiftUI - Performance analysis # Performance analysis Measure and improve your app’s responsiveness. ## Overview Use Instruments to detect hangs and hitches in your app, and to analyze long view body updates and frequently occurring SwiftUI updates that can contribute to hangs and hitches. ## Topics ### Essentials Understanding user interface responsiveness Make your app more responsive by examining the event-handling and rendering loop. Understanding hangs in your app Determine the cause for delays in user interactions by examining the main thread and the main run loop. Understanding hitches in your app Determine the cause of interruptions in motion by examining the render loop. ### Analyzing SwiftUI performance Understanding and improving SwiftUI performance Identify and address long-running view updates, and reduce the frequency of updates. ## See Also ### Tool support Generate dynamic, interactive previews of your custom views. Expose custom views and modifiers in the Xcode library. --- # https://developer.apple.com/documentation/swiftui/app) --- # https://developer.apple.com/documentation/swiftui/view) --- # https://developer.apple.com/documentation/swiftui/landmarks-building-an-app-with-liquid-glass) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/building-a-document-based-app-with-swiftui) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/app-organization) --- # https://developer.apple.com/documentation/swiftui/scenes) --- # https://developer.apple.com/documentation/swiftui/windows) --- # https://developer.apple.com/documentation/swiftui/immersive-spaces) --- # https://developer.apple.com/documentation/swiftui/documents) --- # https://developer.apple.com/documentation/swiftui/navigation) --- # https://developer.apple.com/documentation/swiftui/modal-presentations) --- # https://developer.apple.com/documentation/swiftui/toolbars) --- # https://developer.apple.com/documentation/swiftui/search) --- # https://developer.apple.com/documentation/swiftui/app-extensions) --- # https://developer.apple.com/documentation/swiftui/model-data) --- # https://developer.apple.com/documentation/swiftui/environment-values) --- # https://developer.apple.com/documentation/swiftui/preferences) --- # https://developer.apple.com/documentation/swiftui/persistent-storage) --- # https://developer.apple.com/documentation/swiftui/view-fundamentals) --- # https://developer.apple.com/documentation/swiftui/view-configuration) --- # https://developer.apple.com/documentation/swiftui/view-styles) --- # https://developer.apple.com/documentation/swiftui/animations) --- # https://developer.apple.com/documentation/swiftui/text-input-and-output) --- # https://developer.apple.com/documentation/swiftui/images) --- # https://developer.apple.com/documentation/swiftui/controls-and-indicators) --- # https://developer.apple.com/documentation/swiftui/menus-and-commands) --- # https://developer.apple.com/documentation/swiftui/shapes) --- # https://developer.apple.com/documentation/swiftui/drawing-and-graphics) --- # https://developer.apple.com/documentation/swiftui/layout-fundamentals) --- # https://developer.apple.com/documentation/swiftui/layout-adjustments) --- # https://developer.apple.com/documentation/swiftui/custom-layout) --- # https://developer.apple.com/documentation/swiftui/lists) --- # https://developer.apple.com/documentation/swiftui/tables) --- # https://developer.apple.com/documentation/swiftui/view-groupings) --- # https://developer.apple.com/documentation/swiftui/scroll-views) --- # https://developer.apple.com/documentation/swiftui/gestures) --- # https://developer.apple.com/documentation/swiftui/input-events) --- # https://developer.apple.com/documentation/swiftui/clipboard) --- # https://developer.apple.com/documentation/swiftui/drag-and-drop) --- # https://developer.apple.com/documentation/swiftui/focus) --- # https://developer.apple.com/documentation/swiftui/system-events) --- # https://developer.apple.com/documentation/swiftui/accessibility-fundamentals) --- # https://developer.apple.com/documentation/swiftui/accessible-appearance) --- # https://developer.apple.com/documentation/swiftui/accessible-controls) --- # https://developer.apple.com/documentation/swiftui/accessible-descriptions) --- # https://developer.apple.com/documentation/swiftui/accessible-navigation) --- # https://developer.apple.com/documentation/swiftui/appkit-integration) --- # https://developer.apple.com/documentation/swiftui/uikit-integration) --- # https://developer.apple.com/documentation/swiftui/watchkit-integration) --- # https://developer.apple.com/documentation/swiftui/technology-specific-views) --- # https://developer.apple.com/documentation/swiftui/previews-in-xcode) --- # https://developer.apple.com/documentation/swiftui/xcode-library-customization) --- # https://developer.apple.com/documentation/swiftui/performance-analysis) --- # https://developer.apple.com/documentation/swiftui/documentgroup - SwiftUI - DocumentGroup Structure # DocumentGroup A scene that enables support for opening, creating, and saving documents. ## Mentioned in Building and customizing the menu bar with SwiftUI ## Overview Use a `DocumentGroup` scene to tell SwiftUI what kinds of documents your app can open when you declare your app using the `App` protocol. Initialize a document group scene by passing in the document model and a view capable of displaying the document type. The document types you supply to `DocumentGroup` must conform to `FileDocument` or `ReferenceFileDocument`. SwiftUI uses the model to add document support to your app. In macOS this includes document-based menu support, including the ability to open multiple documents. On iOS this includes a document browser that can navigate to the documents stored on the file system and multiwindow support: @main struct MyApp: App { var body: some Scene { DocumentGroup(newDocument: TextFile()) { configuration in ContentView(document: configuration.$document) } } } Any time the configuration changes, SwiftUI updates the contents with that new configuration, similar to other parameterized builders. ### Viewing documents If your app only needs to display but not modify a specific document type, you can use the file viewer document group scene. You supply the file type of the document, and a view that displays the document type that you provide: @main struct MyApp: App { var body: some Scene { DocumentGroup(viewing: MyImageFormatDocument.self) { MyImageFormatViewer(image: $0.document) } } } ### Supporting multiple document types Your app can support multiple document types by adding additional document group scenes: @main struct MyApp: App { var body: some Scene { DocumentGroup(newDocument: TextFile()) { group in ContentView(document: group.$document) } DocumentGroup(viewing: MyImageFormatDocument.self) { group in MyImageFormatViewer(image: group.document) } } } ### Accessing the document’s URL If your app needs to know the document’s URL, you can read it from the `editor` closure’s `configuration` parameter, along with the binding to the document. When you create a new document, the configuration’s `fileURL` property is `nil`. Every time it changes, it is passed over to the `DocumentGroup` builder in the updated `configuration`. This ensures that the view you define in the closure always knows the URL of the document it hosts. @main struct MyApp: App { var body: some Scene { DocumentGroup(newDocument: TextFile()) { configuration in ContentView( document: configuration.$document, fileURL: configuration.fileURL ) } } } The URL can be used, for example, to present the file path of the file name in the user interface. Don’t access the document’s contents or metadata using the URL because that can conflict with the management of the file that SwiftUI performs. Instead, use the methods that `FileDocument` and `ReferenceFileDocument` provide to perform read and write operations. ## Topics ### Creating a document group `init(newDocument:editor:)` Creates a document group for creating and editing file documents. `init(viewing:viewer:)` Creates a document group capable of viewing file documents. ### Editing a document backed by a persistent store `init(editing:contentType:editor:prepareDocument:)` Instantiates a document group for creating and editing documents that store a specific model type. Instantiates a document group for creating and editing documents described by the last `Schema` in the migration plan. ### Viewing a document backed by a persistent store `init(viewing:contentType:viewer:)` Instantiates a document group for viewing documents that store a specific model type. Instantiates a document group for viewing documents described by the last `Schema` in the migration plan. ## Relationships ### Conforms To - `Scene` ## See Also ### Creating a document Building a document-based app with SwiftUI Create, save, and open documents in a multiplatform app. Building a document-based app using SwiftData Code along with the WWDC presenter to transform an app with SwiftData. --- # https://developer.apple.com/documentation/swiftui/filedocument - SwiftUI - FileDocument Protocol # FileDocument A type that you use to serialize documents to and from file. @preconcurrency protocol FileDocument : Sendable ## Overview To store a document as a value type — like a structure — create a type that conforms to the `FileDocument` protocol and implement the required methods and properties. Your implementation: - Provides a list of the content types that the document can read from and write to by defining `readableContentTypes`. If the list of content types that the document can write to is different from those that it reads from, you can optionally also define `writableContentTypes`. - Loads documents from file in the `init(configuration:)` initializer. - Stores documents to file by serializing their content in the `fileWrapper(configuration:)` method. Ensure that types that conform to this protocol are `Sendable`. In particular, SwiftUI calls the protocol’s methods from different isolation domains. Don’t perform serialization and deserialization on `MainActor`. ## Topics ### Reading a document `init(configuration: Self.ReadConfiguration) throws` Creates a document and initializes it with the contents of a file. **Required** [`static var readableContentTypes: [UTType]`](https://developer.apple.com/documentation/swiftui/filedocument/readablecontenttypes) The file and data types that the document reads from. `typealias ReadConfiguration` The configuration for reading document contents. ### Writing a document Serializes a document snapshot to a file wrapper. [`static var writableContentTypes: [UTType]`](https://developer.apple.com/documentation/swiftui/filedocument/writablecontenttypes) The file types that the document supports saving or exporting to. **Required** Default implementation provided. `typealias WriteConfiguration` The configuration for writing document contents. ## Relationships ### Inherits From - `Sendable` - `SendableMetatype` ## See Also ### Storing document data in a structure instance `struct FileDocumentConfiguration` The properties of an open file document. --- # https://developer.apple.com/documentation/swiftui/referencefiledocument - SwiftUI - ReferenceFileDocument Protocol # ReferenceFileDocument A type that you use to serialize reference type documents to and from file. @preconcurrency protocol ReferenceFileDocument : ObservableObject, Sendable ## Overview To store a document as a reference type — like a class — create a type that conforms to the `ReferenceFileDocument` protocol and implement the required methods and properties. Your implementation: - Provides a list of the content types that the document can read from and write to by defining `readableContentTypes`. If the list of content types that the document can write to is different from those that it reads from, you can optionally also define `writableContentTypes`. - Loads documents from file in the `init(configuration:)` initializer. - Stores documents to file by providing a snapshot of the document’s content in the `snapshot(contentType:)` method, and then serializing that content in the `fileWrapper(snapshot:configuration:)` method. Ensure that types that conform to this protocol are `Sendable`. In particular, SwiftUI calls the protocol’s methods from different isolation domains. Don’t perform serialization and deserialization on `MainActor`. final class PDFDocument: ReferenceFileDocument { struct Storage { var contents: Data } static let readableContentTypes: [UTType] = [.pdf] guard let data = configuration.file.regularFileContents else { throw CocoaError(.fileReadCorruptFile) } self.storage = .init(.init(contents: data)) } storage.withLock { $0.contents } } return FileWrapper(regularFileWithContents: snapshot) } } ## Topics ### Reading a document `init(configuration: Self.ReadConfiguration) throws` Creates a document and initializes it with the contents of a file. **Required** [`static var readableContentTypes: [UTType]`](https://developer.apple.com/documentation/swiftui/referencefiledocument/readablecontenttypes) The file and data types that the document reads from. `typealias ReadConfiguration` The configuration for reading document contents. ### Getting a snapshot Creates a snapshot that represents the current state of the document. `associatedtype Snapshot` A type that represents the document’s stored content. ### Writing a document Serializes a document snapshot to a file wrapper. [`static var writableContentTypes: [UTType]`](https://developer.apple.com/documentation/swiftui/referencefiledocument/writablecontenttypes) The file types that the document supports saving or exporting to. **Required** Default implementation provided. `typealias WriteConfiguration` The configuration for writing document contents. ## Relationships ### Inherits From - `ObservableObject` - `Sendable` - `SendableMetatype` ## See Also ### Storing document data in a class instance `struct ReferenceFileDocumentConfiguration` The properties of an open reference file document. `var undoManager: UndoManager?` The undo manager used to register a view’s undo operations. --- # https://developer.apple.com/documentation/swiftui/documentgroup/init(editing:contenttype:editor:preparedocument:) #app-main) - SwiftUI - DocumentGroup - init(editing:contentType:editor:prepareDocument:) Initializer # init(editing:contentType:editor:prepareDocument:) Instantiates a document group for creating and editing documents that store a specific model type. SwiftDataSwiftUI init( editing modelType: any PersistentModel.Type, contentType: UTType, ) Available when `Document` is `ModelDocument` and `Content` conforms to `View`. Show all declarations ## Parameters `modelType` The model type defining the schema used for each document. `contentType` The content type of the document. It should conform to `UTType.package`. `editor` The editing UI for the provided document. `prepareDocument` The optional closure that accepts `ModelContext` associated with the new document. Use this closure to set the document’s initial contents before it is displayed: insert preconfigured models in the provided `ModelContext`. ## Discussion @main struct Todo: App { var body: some Scene { DocumentGroup(editing: TodoItem.self, contentType: .todoItem) { ContentView() } } } struct ContentView: View { @Query var items: [TodoItem] var body: some View { List { ForEach(items) { item in @Bindable var item = item Toggle(item.text, isOn: $item.isDone) } } } } @Model final class TodoItem { var created: Date var text: String var isDone = false } extension UTType { static var todoItem = UTType(exportedAs: "com.myApp.todoItem") } ## See Also ### Editing a document backed by a persistent store Instantiates a document group for creating and editing documents described by the last `Schema` in the migration plan. --- # https://developer.apple.com/documentation/swiftui/building-a-document-based-app-with-swiftui - SwiftUI - Documents - Building a document-based app with SwiftUI Sample Code # Building a document-based app with SwiftUI Create, save, and open documents in a multiplatform app. Download Xcode 16.0+ ## Overview The Writing App sample builds a document-based app for iOS, iPadOS, and macOS. In the app definition, it has a `DocumentGroup` scene, and its document type conforms to the `FileDocument` protocol. People can create a writing app document, modify the title and contents of the document, and read the story in focus mode. ## Configure the sample code project To build and run this sample on your device, select your development team for the project’s target using these steps: 1. Open the sample with the latest version of Xcode. 2. Select the top-level project. 3. For the project’s target, choose your team from the Team pop-up menu in the Signing & Capabilities pane to let Xcode automatically manage your provisioning profile. ## Define the app’s scene A document-based SwiftUI app returns a `DocumentGroup` scene from its `body` property. The `newDocument` parameter that an app supplies to the document group’s `init(newDocument:editor:)` initializer conforms to either `FileDocument` or `ReferenceFileDocument`. In this sample, the document type conforms to `FileDocument`. The trailing closure of the initializer returns a view that renders the document’s contents: @main struct WritingApp: App { var body: some Scene { DocumentGroup(newDocument: WritingAppDocument()) { file in StoryView(document: file.$document) } } } ## Customize the iOS and iPadOS launch experience You can update the default launch experience on iOS and iPadOS with a custom title, action buttons, and screen background. To add an action button with a custom label, use `NewDocumentButton` to replace the default label. You can customize the background in many ways such as adding a view or a `backgroundStyle` with an initializer, for example `init(_:backgroundStyle:_:backgroundAccessoryView:overlayAccessoryView:)`. This sample customizes the background of the title view, using the `init(_:_:background:)` initializer: DocumentGroupLaunchScene("Writing App") { NewDocumentButton("Start Writing") } background: { Image(.pinkJungle) .resizable() .scaledToFill() .ignoresSafeArea() } You can also add accessories to the scene using initializers such as `init(_:_:background:backgroundAccessoryView:)` and `init(_:_:background:overlayAccessoryView:)` depending on the positioning. overlayAccessoryView: { _ in AccessoryView() } This sample contains two accessories in the overlay position that it defines in `AccessoryView`. It customizes the accessories by applying modifiers, including `offset(x:y:)` and `frame(width:height:alignment:)`. ZStack { Image(.robot) .resizable() .offset(x: size.width / 2 - 450, y: size.height / 2 - 300) .scaledToFit() .frame(width: 200) .opacity(horizontal == .compact ? 0 : 1) Image(.plant) .resizable() .offset(x: size.width / 2 + 250, y: size.height / 2 - 225) .scaledToFit() .frame(width: 200) .opacity(horizontal == .compact ? 0 : 1) } To add both background and overlay accessories, use an initializer, such as `init(_:_:background:backgroundAccessoryView:overlayAccessoryView:)`. If you don’t provide any accessories, the system displays two faded sheets below the title view by default. In macOS, this sample displays the default system document browser on launch. You may wish to add an additional experience on launch. ## Create the data model This sample has a data model that defines a story as a `String`, it initializes `story` with an empty string: var story: String init(text: String = "") { self.story = text } ## Adopt the file document protocol The `WritingAppDocument` structure adopts the `FileDocument` protocol to serialize documents to and from files. The `readableContentTypes` property defines the types that the sample can read and write, specifically, the `.writingAppDocument` type: static var readableContentTypes: [UTType] { [.writingAppDocument] } The `init(configuration:)` initializer loads documents from a file. After reading the file’s data using the `file` property of the `configuration` input, it deserializes the data and stores it in the document’s data model: init(configuration: ReadConfiguration) throws { guard let data = configuration.file.regularFileContents, let string = String(data: data, encoding: .utf8) else { throw CocoaError(.fileReadCorruptFile) } story = string } When a person writes a document, SwiftUI calls the `fileWrapper(configuration:)` function to serialize the data model into a `FileWrapper` value that represents the data in the file system: let data = Data(story.utf8) return .init(regularFileWithContents: data) } Because the document type conforms to `FileDocument`, this sample handles undo actions automatically. ## Export a custom document type The app defines and exports a custom content type for the documents it creates. It declares this custom type in the project’s `Information Property List` file under the `UTExportedTypeDeclarations` key. This sample uses `com.example.writingAppDocument` as the identifier in the `Info.plist` file: For convenience, you can also define the content type in code. For example: extension UTType { static var writingapp: UTType { UTType(exportedAs: "com.example.writingAppDocument") } } To make sure that the operating system knows that your application can open files with the format described in the `Info.plist`, it defines the file extension `story` for the content type. For more information about custom file and data types, see Defining file and data types for your app. ## See Also #### Related samples Building a document-based app using SwiftData Code along with the WWDC presenter to transform an app with SwiftData. #### Related articles Defining file and data types for your app Declare uniform type identifiers to support your app’s proprietary data formats. Customizing a document-based app’s launch experience Add unique elements to your app’s document launch scene. #### Related videos  --- # https://developer.apple.com/documentation/swiftui/building-a-document-based-app-using-swiftdata - SwiftUI - Documents - Building a document-based app using SwiftData Sample Code # Building a document-based app using SwiftData Code along with the WWDC presenter to transform an app with SwiftData. Download Xcode 15.0+ ## Overview Learn how to use `@Query`, `@Bindable`, `.modelContainer`, the `.modelContext` environment variable, and `DocumentGroup` to integrate with the `SwiftData` framework. ## See Also ### Creating a document Building a document-based app with SwiftUI Create, save, and open documents in a multiplatform app. `struct DocumentGroup` A scene that enables support for opening, creating, and saving documents. --- # https://developer.apple.com/documentation/swiftui/filedocumentconfiguration - SwiftUI - FileDocumentConfiguration Structure # FileDocumentConfiguration The properties of an open file document. ## Overview You receive an instance of this structure when you create a `DocumentGroup` with a value file type. Use it to access the document in your viewer or editor. ## Topics ### Getting and setting the document `var document: Document` The current document model. ### Getting document properties `var fileURL: URL?` The URL of the open file document. `var isEditable: Bool` A Boolean that indicates whether you can edit the document. ## See Also ### Storing document data in a structure instance `protocol FileDocument` A type that you use to serialize documents to and from file. --- # https://developer.apple.com/documentation/swiftui/referencefiledocumentconfiguration - SwiftUI - ReferenceFileDocumentConfiguration Structure # ReferenceFileDocumentConfiguration The properties of an open reference file document. @MainActor @preconcurrency ## Overview You receive an instance of this structure when you create a `DocumentGroup` with a reference file type. Use it to access the document in your viewer or editor. ## Topics ### Getting and setting the document `var document: Document` The current document model. ### Getting document properties `var fileURL: URL?` The URL of the open file document. `var isEditable: Bool` A Boolean that indicates whether you can edit the document. ## See Also ### Storing document data in a class instance `protocol ReferenceFileDocument` A type that you use to serialize reference type documents to and from file. `var undoManager: UndoManager?` The undo manager used to register a view’s undo operations. --- # https://developer.apple.com/documentation/swiftui/environmentvalues/undomanager - SwiftUI - EnvironmentValues - undoManager Instance Property # undoManager The undo manager used to register a view’s undo operations. var undoManager: UndoManager? { get } ## Discussion This value is `nil` when the environment represents a context that doesn’t support undo and redo operations. You can skip registration of an undo operation when this value is `nil`. ## See Also ### Storing document data in a class instance `protocol ReferenceFileDocument` A type that you use to serialize reference type documents to and from file. `struct ReferenceFileDocumentConfiguration` The properties of an open reference file document. --- # https://developer.apple.com/documentation/swiftui/environmentvalues/documentconfiguration - SwiftUI - EnvironmentValues - documentConfiguration Instance Property # documentConfiguration The configuration of a document in a `DocumentGroup`. var documentConfiguration: DocumentConfiguration? { get } ## Discussion The value is `nil` for views that are not enclosed in a `DocumentGroup`. For example, if the app shows the document path in the footer of each document, it can get the URL from the environment: struct ContentView: View { @Binding var document: TextDocument @Environment(\.documentConfiguration) private var configuration: DocumentConfiguration? var body: some View { … Label( configuration?.fileURL?.path ?? "", systemImage: "folder.circle" ) } } ## See Also ### Accessing document configuration `struct DocumentConfiguration` --- # https://developer.apple.com/documentation/swiftui/documentconfiguration - SwiftUI - DocumentConfiguration Structure # DocumentConfiguration struct DocumentConfiguration ## Topics ### Getting configuration values `var fileURL: URL?` A URL of an open document. `var isEditable: Bool` A Boolean value that indicates whether you can edit the document. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Accessing document configuration `var documentConfiguration: DocumentConfiguration?` The configuration of a document in a `DocumentGroup`. --- # https://developer.apple.com/documentation/swiftui/filedocumentreadconfiguration - SwiftUI - FileDocumentReadConfiguration Structure # FileDocumentReadConfiguration The configuration for reading file contents. struct FileDocumentReadConfiguration ## Topics ### Reading the content `let contentType: UTType` The expected uniform type of the file contents. `let file: FileWrapper` The file wrapper containing the document content. ## See Also ### Reading and writing documents `struct FileDocumentWriteConfiguration` The configuration for serializing file contents. --- # https://developer.apple.com/documentation/swiftui/filedocumentwriteconfiguration - SwiftUI - FileDocumentWriteConfiguration Structure # FileDocumentWriteConfiguration The configuration for serializing file contents. struct FileDocumentWriteConfiguration ## Topics ### Writing the content `let contentType: UTType` The expected uniform type of the file contents. `let existingFile: FileWrapper?` The file wrapper containing the current document content. `nil` if the document is unsaved. ## See Also ### Reading and writing documents `struct FileDocumentReadConfiguration` The configuration for reading file contents. --- # https://developer.apple.com/documentation/swiftui/environmentvalues/newdocument - SwiftUI - EnvironmentValues - newDocument Instance Property # newDocument An action in the environment that presents a new document. var newDocument: NewDocumentAction { get } ## Discussion Use the `newDocument` environment value to get the instance of the `NewDocumentAction` structure for a given `Environment`. Then call the instance to present a new document. You call the instance directly because it defines a `callAsFunction(_:)` method that Swift calls when you call the instance. For example, you can define a button that creates a new document from the selected text: struct NewDocumentFromSelection: View { @FocusedBinding(\.selectedText) private var selectedText: String? @Environment(\.newDocument) private var newDocument var body: some View { Button("New Document With Selection") { newDocument(TextDocument(text: selectedText)) } .disabled(selectedText?.isEmpty != false) } } The above example assumes that you define a `TextDocument` that conforms to the `FileDocument` or `ReferenceFileDocument` protocol, and a `DocumentGroup` that handles the associated file type. ## See Also ### Opening a document programmatically `struct NewDocumentAction` An action that presents a new document. `var openDocument: OpenDocumentAction` An action in the environment that presents an existing document. `struct OpenDocumentAction` An action that presents an existing document. --- # https://developer.apple.com/documentation/swiftui/newdocumentaction - SwiftUI - NewDocumentAction Structure # NewDocumentAction An action that presents a new document. @MainActor @preconcurrency struct NewDocumentAction ## Overview Use the `newDocument` environment value to get the instance of this structure for a given `Environment`. Then call the instance to present a new document. You call the instance directly because it defines a `callAsFunction(_:)` method that Swift calls when you call the instance. For example, you can define a button that creates a new document from the selected text: struct NewDocumentFromSelection: View { @FocusedBinding(\.selectedText) private var selectedText: String? @Environment(\.newDocument) private var newDocument var body: some View { Button("New Document With Selection") { newDocument(TextDocument(text: selectedText)) } .disabled(selectedText?.isEmpty != false) } } The above example assumes that you define a `TextDocument` that conforms to the `FileDocument` or `ReferenceFileDocument` protocol, and a `DocumentGroup` that handles the associated file type. ## Topics ### Calling the action `func callAsFunction(_:)` Presents a new document window. `func callAsFunction(contentType: UTType)` Presents a new document window with preset contents. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Opening a document programmatically `var newDocument: NewDocumentAction` An action in the environment that presents a new document. `var openDocument: OpenDocumentAction` An action in the environment that presents an existing document. `struct OpenDocumentAction` An action that presents an existing document. --- # https://developer.apple.com/documentation/swiftui/environmentvalues/opendocument - SwiftUI - EnvironmentValues - openDocument Instance Property # openDocument An action in the environment that presents an existing document. var openDocument: OpenDocumentAction { get } ## Discussion Use the `openDocument` environment value to get the instance of the `OpenDocumentAction` structure for a given `Environment`. Then call the instance to present an existing document. You call the instance directly because it defines a `callAsFunction(at:)` method that Swift calls when you call the instance. For example, you can create a button that opens the document at the specified URL: struct OpenDocumentButton: View { var url: URL @Environment(\.openDocument) private var openDocument var body: some View { Button(url.deletingPathExtension().lastPathComponent) { Task { do { try await openDocument(at: url) } catch { // Handle error } } } } } The above example uses a `do-catch` statement to handle any errors that the open document action might throw. It also places the action inside a task and awaits the result because the action operates asynchronously. To present an existing document, your app must define a `DocumentGroup` that handles the content type of the specified file. For a document that’s already open, the system brings the existing window to the front. Otherwise, the system opens a new window. ## See Also ### Opening a document programmatically `var newDocument: NewDocumentAction` An action in the environment that presents a new document. `struct NewDocumentAction` An action that presents a new document. `struct OpenDocumentAction` An action that presents an existing document. --- # https://developer.apple.com/documentation/swiftui/opendocumentaction - SwiftUI - OpenDocumentAction Structure # OpenDocumentAction An action that presents an existing document. @MainActor struct OpenDocumentAction ## Overview Use the `openDocument` environment value to get the instance of this structure for a given `Environment`. Then call the instance to present an existing document. You call the instance directly because it defines a `callAsFunction(at:)` method that Swift calls when you call the instance. For example, you can create a button that opens the document at the specified URL: struct OpenDocumentButton: View { var url: URL @Environment(\.openDocument) private var openDocument var body: some View { Button(url.deletingPathExtension().lastPathComponent) { Task { do { try await openDocument(at: url) } catch { // Handle error } } } } } The above example uses a `do-catch` statement to handle any errors that the open document action might throw. It also places the action inside a task and awaits the result because the action operates asynchronously. To present an existing document, your app must define a `DocumentGroup` that handles the content type of the specified file. For a document that’s already open, the system brings the existing window to the front. Otherwise, the system opens a new window. ## Topics ### Calling the action `func callAsFunction(at: URL) async throws` Opens the document at the specified file URL. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Opening a document programmatically `var newDocument: NewDocumentAction` An action in the environment that presents a new document. `struct NewDocumentAction` An action that presents a new document. `var openDocument: OpenDocumentAction` An action in the environment that presents an existing document. --- # https://developer.apple.com/documentation/swiftui/documentgrouplaunchscene - SwiftUI - DocumentGroupLaunchScene Structure # DocumentGroupLaunchScene A launch scene for document-based applications. ## Overview You can use this launch scene alongside `DocumentGroup` scenes. If you don’t implement a `DocumentGroup` in the app declaration, you can get the same design by implementing a `DocumentLaunchView`. If you don’t provide the title of the scene, it displays the application name. If you don’t provide the actions builder, the scene has the default “Create Document” action that creates new documents. To customize the document launch experience, you can replace the standard screen background and title, add decorative views, and add custom actions. A `DocumentGroupLaunchScene` configures the document browser on the bottom sheet to open content types from all the document groups in the app definition. A `DocumentGroupLaunchScene` also configures the document groups to create documents of the first content type that your application can create and write. For more information, see `FileDocument.writableContentTypes` and `ReferenceFileDocument.writableContentTypes`. ## Topics ### Initializers `init(_:_:background:)` Creates a launch scene for document-based applications with a title, a set of actions, and a background. `init(_:_:background:backgroundAccessoryView:)` Creates a launch scene for document-based applications with a title, a set of actions, a background, and a background accessory view. `init(_:_:background:backgroundAccessoryView:overlayAccessoryView:)` `init(_:_:background:overlayAccessoryView:)` Creates a launch scene for document-based applications with a title, a set of actions, a background, and an overlay accessory view. `init(_:backgroundStyle:_:)` Creates a launch scene for document-based applications with a title, a background style, and a set of actions. `init(_:backgroundStyle:_:backgroundAccessoryView:)` Creates a launch scene for document-based applications with a title, a background style, a set of actions, and a background accessory view. `init(_:backgroundStyle:_:backgroundAccessoryView:overlayAccessoryView:)` Creates a launch scene for document-based applications with a title, a background style, a set of actions, and background and overlay accessory views. `init(_:backgroundStyle:_:overlayAccessoryView:)` Creates a launch scene for document-based applications with a title, a background style, a set of actions, and an overlay accessory view. ## Relationships ### Conforms To - `Scene` ## See Also ### Configuring the document launch experience `struct DocumentLaunchView` A view to present when launching document-related user experience. `struct DocumentLaunchGeometryProxy` A proxy for access to the frame of the scene and its title view. `struct DefaultDocumentGroupLaunchActions` The default actions for the document group launch scene and the document launch view. `struct NewDocumentButton` A button that creates and opens new documents. `protocol DocumentBaseBox` A Box that allows setting its Document base not requiring the caller to know the exact types of the box and its base. --- # https://developer.apple.com/documentation/swiftui/documentlaunchview - SwiftUI - DocumentLaunchView Structure # DocumentLaunchView A view to present when launching document-related user experience. ## Overview Configure `DocumentLaunchView` to open and display files and trigger custom actions. For example, an application that offers writing books can present the `DocumentLaunchView` as its launch view: public import UniformTypeIdentifiers struct BookEditorLaunchView: View { var body: some View { DocumentLaunchView(for: [.book]) { NewDocumentButton("Start New Book") } onDocumentOpen: { url in BookEditor(url) } } } struct BookEditor: View { init(_ url: URL) { } } extension UTType { static var book = UTType(exportedAs: "com.example.bookEditor") } ## Topics ### Initializers `init(_:for:_:onDocumentOpen:)` Creates a view to present when launching document-related user experiences using a localized title and custom actions. `init(_:for:_:onDocumentOpen:background:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, and a background view. `init(_:for:_:onDocumentOpen:background:backgroundAccessoryView:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, a background view, and a background accessory view. `init(_:for:_:onDocumentOpen:background:backgroundAccessoryView:overlayAccessoryView:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, a background view, and accessory views. `init(_:for:_:onDocumentOpen:background:overlayAccessoryView:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, a background view, and an overlay accessory view. `init(_:for:_:onDocumentOpen:backgroundAccessoryView:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, and a background accessory view. `init(_:for:_:onDocumentOpen:backgroundAccessoryView:overlayAccessoryView:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, and accessory views. `init(_:for:_:onDocumentOpen:overlayAccessoryView:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, and an overlay accessory view. `init(_:for:backgroundStyle:_:onDocumentOpen:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, and a background style. `init(_:for:backgroundStyle:_:onDocumentOpen:backgroundAccessoryView:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, a background style, and a background accessory view. `init(_:for:backgroundStyle:_:onDocumentOpen:backgroundAccessoryView:overlayAccessoryView:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, a background style, and accessory views. `init(_:for:backgroundStyle:_:onDocumentOpen:overlayAccessoryView:)` Creates a view to present when launching document-related user experiences using a localized title, custom actions, a background style, and an overlay accessory view. ### Instance Properties `var body: some View` The body of the view. ## Relationships ### Conforms To - `View` ## See Also ### Configuring the document launch experience `struct DocumentGroupLaunchScene` A launch scene for document-based applications. `struct DocumentLaunchGeometryProxy` A proxy for access to the frame of the scene and its title view. `struct DefaultDocumentGroupLaunchActions` The default actions for the document group launch scene and the document launch view. `struct NewDocumentButton` A button that creates and opens new documents. `protocol DocumentBaseBox` A Box that allows setting its Document base not requiring the caller to know the exact types of the box and its base. --- # https://developer.apple.com/documentation/swiftui/documentlaunchgeometryproxy - SwiftUI - DocumentLaunchGeometryProxy Structure # DocumentLaunchGeometryProxy A proxy for access to the frame of the scene and its title view. struct DocumentLaunchGeometryProxy ## Topics ### Instance Properties `var frame: CGRect` Frame of the document launch interface. `var titleViewFrame: CGRect` Frame of the title view within the interface. ## See Also ### Configuring the document launch experience `struct DocumentGroupLaunchScene` A launch scene for document-based applications. `struct DocumentLaunchView` A view to present when launching document-related user experience. `struct DefaultDocumentGroupLaunchActions` The default actions for the document group launch scene and the document launch view. `struct NewDocumentButton` A button that creates and opens new documents. `protocol DocumentBaseBox` A Box that allows setting its Document base not requiring the caller to know the exact types of the box and its base. --- # https://developer.apple.com/documentation/swiftui/defaultdocumentgrouplaunchactions - SwiftUI - DefaultDocumentGroupLaunchActions Structure # DefaultDocumentGroupLaunchActions The default actions for the document group launch scene and the document launch view. struct DefaultDocumentGroupLaunchActions ## Overview This `View` populates `DocumentGroupLaunchScene` and `DocumentLaunchView` with the default actions. ## Topics ### Initializers `init()` ## Relationships ### Conforms To - `View` ## See Also ### Configuring the document launch experience `struct DocumentGroupLaunchScene` A launch scene for document-based applications. `struct DocumentLaunchView` A view to present when launching document-related user experience. `struct DocumentLaunchGeometryProxy` A proxy for access to the frame of the scene and its title view. `struct NewDocumentButton` A button that creates and opens new documents. `protocol DocumentBaseBox` A Box that allows setting its Document base not requiring the caller to know the exact types of the box and its base. --- # https://developer.apple.com/documentation/swiftui/newdocumentbutton - SwiftUI - NewDocumentButton Structure # NewDocumentButton A button that creates and opens new documents. ## Overview Use a new document button to give people the option to create documents in your app. In the following example, there are two new document buttons, both support `Text` labels. When the user taps or clicks the first button, the system creates a new document in the directory currently open in the document browser. The second button creates a new document from a template. @State private var isTemplatePickerPresented = false @State private var documentCreationContinuation: var body: some Scene { DocumentGroupLaunchScene("My Documents") { NewDocumentButton("Start Writing…") NewDocumentButton("Choose a Template", for: MyDocument.self) { try await withCheckedThrowingContinuation { continuation in documentCreationContinuation = continuation isTemplatePickerPresented = true } } .fullScreenCover(isPresented: $isTemplatePickerPresented) { TemplatePicker(continuation: $documentCreationContinuation) } } } If you don’t provide a custom label, the system provides a button with the default “Create Document” label. ## Topics ### Initializers `init(_:contentType:)` Creates and opens new documents. `init(_:contentType:prepareDocumentURL:)` `init(_:for:contentType:prepareDocument:)` ## Relationships ### Conforms To - `View` ## See Also ### Configuring the document launch experience `struct DocumentGroupLaunchScene` A launch scene for document-based applications. `struct DocumentLaunchView` A view to present when launching document-related user experience. `struct DocumentLaunchGeometryProxy` A proxy for access to the frame of the scene and its title view. `struct DefaultDocumentGroupLaunchActions` The default actions for the document group launch scene and the document launch view. `protocol DocumentBaseBox` A Box that allows setting its Document base not requiring the caller to know the exact types of the box and its base. --- # https://developer.apple.com/documentation/swiftui/documentbasebox - SwiftUI - DocumentBaseBox Protocol # DocumentBaseBox A Box that allows setting its Document base not requiring the caller to know the exact types of the box and its base. ## Topics ### Associated Types `associatedtype Document` The underlying document type. **Required** ### Instance Properties `var base: Self.Document?` Updates the underlying document to a new value. ## See Also ### Configuring the document launch experience `struct DocumentGroupLaunchScene` A launch scene for document-based applications. `struct DocumentLaunchView` A view to present when launching document-related user experience. `struct DocumentLaunchGeometryProxy` A proxy for access to the frame of the scene and its title view. `struct DefaultDocumentGroupLaunchActions` The default actions for the document group launch scene and the document launch view. `struct NewDocumentButton` A button that creates and opens new documents. --- # https://developer.apple.com/documentation/swiftui/renamebutton - SwiftUI - RenameButton Structure # RenameButton A button that triggers a standard rename action. ## Overview A rename button receives its action from the environment. Use the `renameAction(_:)` modifier to set the action. The system disables the button if you don’t define an action. struct RowView: View { @State private var text = "" @FocusState private var isFocused: Bool var body: some View { TextField(text: $item.name) { Text("Prompt") } .focused($isFocused) .contextMenu { RenameButton() // ... your own custom actions } .renameAction { $isFocused = true } } When someone taps the rename button in the context menu, the rename action focuses the text field by setting the `isFocused` property to true. You can use this button inside of a navigation title menu and the navigation title modifier automatically configures the environment with the appropriate rename action. ContentView() .navigationTitle($contentTitle) { // ... your own custom actions RenameButton() } ## Topics ### Creating an rename button `init()` Creates a rename button. ## Relationships ### Conforms To - `View` ## See Also ### Creating special-purpose buttons `struct EditButton` A button that toggles the edit mode environment value. `struct PasteButton` A system button that reads items from the pasteboard and delivers it to a closure. --- # https://developer.apple.com/documentation/swiftui/view/renameaction(_:) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/rename - SwiftUI - EnvironmentValues - rename Instance Property # rename An action that activates the standard rename interaction. var rename: RenameAction? { get } ## Discussion Use the `renameAction(_:)` modifier to configure the rename action in the environment. ## See Also ### Renaming a document `struct RenameButton` A button that triggers a standard rename action. `func renameAction(_:)` Sets a closure to run for the rename action. `struct RenameAction` An action that activates a standard rename interaction. --- # https://developer.apple.com/documentation/swiftui/renameaction - SwiftUI - RenameAction Structure # RenameAction An action that activates a standard rename interaction. struct RenameAction ## Overview Use the `renameAction(_:)` modifier to configure the rename action in the environment. ## Topics ### Calling the action `func callAsFunction()` Triggers the standard rename action provided through the environment. ## See Also ### Renaming a document `struct RenameButton` A button that triggers a standard rename action. `func renameAction(_:)` Sets a closure to run for the rename action. `var rename: RenameAction?` An action that activates the standard rename interaction. --- # https://developer.apple.com/documentation/swiftui/documentgroup) --- # https://developer.apple.com/documentation/swiftui/filedocument) --- # https://developer.apple.com/documentation/swiftui/referencefiledocument) --- # https://developer.apple.com/documentation/swiftui/documentgroup/init(editing:contenttype:editor:preparedocument:)). ).#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/building-a-document-based-app-using-swiftdata) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/filedocumentconfiguration) --- # https://developer.apple.com/documentation/swiftui/referencefiledocumentconfiguration) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/undomanager) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/documentconfiguration) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/documentgroup). --- # https://developer.apple.com/documentation/swiftui/documentconfiguration) --- # https://developer.apple.com/documentation/swiftui/filedocumentreadconfiguration) --- # https://developer.apple.com/documentation/swiftui/filedocumentwriteconfiguration) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/newdocument) --- # https://developer.apple.com/documentation/swiftui/newdocumentaction) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/opendocument) --- # https://developer.apple.com/documentation/swiftui/opendocumentaction) --- # https://developer.apple.com/documentation/swiftui/documentgrouplaunchscene) --- # https://developer.apple.com/documentation/swiftui/documentlaunchview) --- # https://developer.apple.com/documentation/swiftui/documentlaunchgeometryproxy) --- # https://developer.apple.com/documentation/swiftui/defaultdocumentgrouplaunchactions) --- # https://developer.apple.com/documentation/swiftui/newdocumentbutton) --- # https://developer.apple.com/documentation/swiftui/documentbasebox) --- # https://developer.apple.com/documentation/swiftui/renamebutton) --- # https://developer.apple.com/documentation/swiftui/view/renameaction(_:)) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/rename) --- # https://developer.apple.com/documentation/swiftui/renameaction) --- # https://developer.apple.com/documentation/swiftui/windowgroup - SwiftUI - WindowGroup Structure # WindowGroup A scene that presents a group of identically structured windows. ## Mentioned in Building and customizing the menu bar with SwiftUI ## Overview Use a `WindowGroup` as a container for a view hierarchy that your app presents. The hierarchy that you declare as the group’s content serves as a template for each window that the app creates from that group: @main struct Mail: App { var body: some Scene { WindowGroup { MailViewer() // Define a view hierarchy for the window. } } } SwiftUI takes care of certain platform-specific behaviors. For example, on platforms that support it, like macOS and iPadOS, people can open more than one window from the group simultaneously. In macOS, people can gather open windows together in a tabbed interface. Also in macOS, window groups automatically provide commands for standard window management. Every window in the group maintains independent state. For example, the system allocates new storage for any `State` or `StateObject` variables instantiated by the scene’s view hierarchy for each window that it creates. For document-based apps, use `DocumentGroup` to define windows instead. ### Open windows programmatically If you initialize a window group with an identifier, a presentation type, or both, you can programmatically open a window from the group. For example, you can give the mail viewer scene from the previous example an identifier: WindowGroup(id: "mail-viewer") { // Identify the window group. MailViewer() } Elsewhere in your code, you can use the `openWindow` action from the environment to create a new window from the group: struct NewViewerButton: View { @Environment(\.openWindow) private var openWindow var body: some View { Button("Open new mail viewer") { openWindow(id: "mail-viewer") // Match the group's identifier. } } } Be sure to use unique strings for identifiers that you apply to window groups in your app. ### Present data in a window If you initialize a window group with a presentation type, you can pass data of that type to the window when you open it. For example, you can define a second window group for the Mail app that displays a specified message: @main struct Mail: App { var body: some Scene { WindowGroup { MailViewer(id: "mail-viewer") } // A window group that displays messages. WindowGroup(for: Message.ID.self) { $messageID in MessageDetail(messageID: messageID) } } } When you call the `openWindow` action with a value, SwiftUI finds the window group with the matching type and passes a binding to the value into the window group’s content closure. For example, you can define a button that opens a message by passing the message’s identifier: struct NewMessageButton: View { var message: Message @Environment(\.openWindow) private var openWindow var body: some View { Button("Open message") { openWindow(value: message.id) } } } Be sure that the type you present conforms to both the `Hashable` and `Codable` protocols. Also, prefer lightweight data for the presentation value. For model values that conform to the `Identifiable` protocol, the value’s identifier works well as a presentation type, as the above example demonstrates. WindowGroup(for: Message.ID.self) { $messageID in MessageDetail(messageID: messageID) } defaultValue: { model.makeNewMessage().id // A new message that your model stores. } SwiftUI persists the value of the binding for the purposes of state restoration, and reapplies the same value when restoring the window. If the restoration process results in an error, SwiftUI sets the binding to the default value if you provide one, or `nil` otherwise. ### Title your app’s windows To help people distinguish among windows from different groups, include a title as the first parameter in the group’s initializer: WindowGroup("Message", for: Message.ID.self) { $messageID in MessageDetail(messageID: messageID) } SwiftUI uses this title when referring to the window in: - The window’s title bar. - The list of open windows that the Window menu displays. If you don’t provide a title for a window, the system refers to the window using the app’s name instead. ### Distinguish windows that present like data To programmatically distinguish between windows that present the same type of data, like when you use a `UUID` as the identifier for more than one model type, add the `id` parameter to the group’s initializer to provide a unique string identifier: WindowGroup("Message", id: "message", for: UUID.self) { $uuid in MessageDetail(uuid: uuid) } WindowGroup("Account", id: "account-info", for: UUID.self) { $uuid in AccountDetail(uuid: uuid) } Then use both the identifer and a value to open the window: struct ActionButtons: View { var messageID: UUID var accountID: UUID @Environment(\.openWindow) private var openWindow var body: some View { HStack { Button("Open message") { openWindow(id: "message", value: messageID) } Button("Edit account information") { openWindow(id: "account-info", value: accountID) } } } } ### Dismiss a window programmatically The system provides people with platform-appropriate controls to dismiss a window. You can also dismiss windows programmatically by calling the `dismiss` action from within the window’s view hierarchy. For example, you can include a button in the account detail view from the previous example that dismisses the view: struct AccountDetail: View { var uuid: UUID? @Environment(\.dismiss) private var dismiss var body: some View { VStack { // ... Button("Dismiss") { dismiss() } } } } The dismiss action doesn’t close the window if you call it from a modal — like a sheet or a popover — that you present from the window. In that case, the action dismisses the modal presentation instead. ## Topics ### Creating a window group Creates a window group. Deprecated `init(_:content:)` Creates a window group with a text view title. ### Identifying a window group Creates a window group with an identifier. `init(_:id:content:)` Creates a window group with a text view title and an identifier. ### Creating a data-driven window group Creates a data-presenting window group. `init(_:for:content:)` Creates a data-presenting window group with a text view title. ### Providing default data to a window group Creates a data-presenting window group with a default value. `init(_:for:content:defaultValue:)` Creates a data-presenting window group with a text view title and a default value. ### Identifying a data-driven window group Creates a data-presenting window group with an identifier. `init(_:id:for:content:)` Creates a data-presenting window group with a text view title and an identifier. ### Identifying a window group that has default data Creates a data-presenting window group with an identifier and a default value. `init(_:id:for:content:defaultValue:)` Creates a data-presenting window group with a text view title, an identifier, and a default value. ### Supporting types `struct PresentedWindowContent` A view that represents the content of a presented window. ### Initializers `init(_:id:makeContent:)` `init(_:makeContent:)` ## Relationships ### Conforms To - `Scene` ## See Also ### Creating windows `struct Window` A scene that presents its content in a single, unique window. `struct UtilityWindow` A specialized window scene that provides secondary utility to the content of the main scenes of an application. `protocol WindowStyle` A specification for the appearance and interaction of a window. Sets the style for windows created by this scene. --- # https://developer.apple.com/documentation/swiftui/window - SwiftUI - Window Structure # Window A scene that presents its content in a single, unique window. ## Overview Use a `Window` scene to augment the main interface of your app with a window that gives people access to supplemental functionality. For example, you can create a secondary window in a mail reader app that enables people to view the status of their account connections: @main struct Mail: App { var body: some Scene { WindowGroup { MailViewer() } Window("Connection Doctor", id: "connection-doctor") { ConnectionDoctor() } } } Provide a title as the first argument to the window’s intializer. The system uses the title to identify the window to people using your app in the window’s title bar or in the list of available singleton windows that the Windows menu displays automatically. ### Open a window programmatically People open the window by selecting it in the Windows menu, but you can also open the window programmatically using the `openWindow` action that you read from the environment. Use the `id` parameter that you initialize the window with to indicate which window to open. For example, you can create a button to open the window from the previous example: struct OpenConnectionDoctorButton: View { @Environment(\.openWindow) private var openWindow var body: some View { Button("Connection doctor") { openWindow(id: "connection-doctor") // Match the window's identifier. } } } If the window is already open when you call this action, the action brings the open window to the front. Be sure to use unique identifiers across all of the `Window` and `WindowGroup` instances that you define. ### Dismiss a window programmatically The system provides people with controls to close windows, but you can also close a window programmatically using the `dismiss` action from within the window’s view hierarchy. For example, you can include a button in the connection doctor view that dismisses the view: struct ConnectionDoctor: View { @Environment(\.dismiss) private var dismiss var body: some View { VStack { // ... Button("Dismiss") { dismiss() } } } } The dismiss action doesn’t close the window if you call it from a modal — like a sheet or a popover — that you present from within the window. In that case, the action dismisses the modal presentation instead. ### Use a window as the main scene You can use a window as the main scene of your app when multi-window functionality isn’t appropriate. For example, it might not make sense to display more than one window for a video call app that relies on a hardware resource, like a camera: @main struct VideoCall: App { var body: some Scene { Window("VideoCall", id: "main") { CameraView() } } } If your app uses a single window as its primary scene, the app quits when the window closes. This behavior differs from an app that uses a `WindowGroup` as its primary scene, where the app continues to run even after closing all of its windows. ## Topics ### Creating a window `init(_:id:content:)` Creates a window with a title and an identifier. ## Relationships ### Conforms To - `Scene` ## See Also ### Creating windows `struct WindowGroup` A scene that presents a group of identically structured windows. `struct UtilityWindow` A specialized window scene that provides secondary utility to the content of the main scenes of an application. `protocol WindowStyle` A specification for the appearance and interaction of a window. Sets the style for windows created by this scene. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/scene/windowstyle(_:) #app-main) - SwiftUI - Scene - windowStyle(\_:) Instance Method # windowStyle(\_:) Sets the style for windows created by this scene. nonisolated ## See Also ### Creating windows `struct WindowGroup` A scene that presents a group of identically structured windows. `struct Window` A scene that presents its content in a single, unique window. `struct UtilityWindow` A specialized window scene that provides secondary utility to the content of the main scenes of an application. `protocol WindowStyle` A specification for the appearance and interaction of a window. --- # https://developer.apple.com/documentation/swiftui/scene/defaultposition(_:) #app-main) - SwiftUI - Scene - defaultPosition(\_:) Instance Method # defaultPosition(\_:) Sets a default position for a window. nonisolated ## Parameters `position` A `UnitPoint` that specifies where to place a newly opened window relative to the screen bounds. ## Return Value A scene that uses a default position for new windows. ## Discussion The first time your app opens a window from a particular scene declaration, the system places the window at the center of the screen by default. For scene types that support multiple simultaneous windows, the system offsets each additional window by a small amount to avoid completely obscuring existing windows. You can override the default placement of the first window by applying a scene modifier that indicates where to place the window relative to the screen bounds. For example, you can request that the system place a new window in the bottom trailing corner of the screen: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } .defaultPosition(.bottomTrailing) } } The system aligns the point in the window that corresponds to the specified `UnitPoint` with the point in the screen that corresponds to the same unit point. You typically use one of the predefined unit points — like `bottomTrailing` in the above example — but you can also use a custom unit point. For example, the following modifier aligns the point that’s one quarter of the way from the leading edge of the window with the point that’s one quarter of the way from the leading edge of the screen, while centering the window in the y-dimension: WindowGroup { ContentView() } .defaultPosition(UnitPoint(x: 0.25, y: 0.5)) The modifier affects any scene type that creates windows in macOS, namely: - `WindowGroup` - `Window` - `DocumentGroup` - `Settings` The value that you provide acts only as an initial default. During state restoration, the system restores the window to the position that it last occupied. ## See Also ### Positioning a window `struct WindowLevel` The level of a window. Sets the window level of this scene. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. `struct WindowPlacement` A type which represents a preferred size and position for a window. Defines a function used for determining the default placement of windows. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct WindowProxy` The proxy for an open window in the app. `struct DisplayProxy` A type which provides information about display hardware. --- # https://developer.apple.com/documentation/swiftui/view/presentedwindowstyle(_:) #app-main) - SwiftUI - View - presentedWindowStyle(\_:) Instance Method # presentedWindowStyle(\_:) Sets the style for windows created by interacting with this view. nonisolated ## See Also ### Styling windows from a view inside the window Sets the style for the toolbar in windows created by interacting with this view. --- # https://developer.apple.com/documentation/swiftui/customizing-window-styles-and-state-restoration-behavior-in-macos - SwiftUI - Windows - Customizing window styles and state-restoration behavior in macOS Sample Code # Customizing window styles and state-restoration behavior in macOS Configure how your app’s windows look and function in macOS to provide an engaging and more coherent experience. Download (1.2 GB) ## Overview The macOS target of Destination Video demonstrates how you can leverage the window and scene customization APIs (available in macOS 15 and later) to tailor an app’s experience in macOS. This includes changing a toolbar’s appearance and visibility, extending a window’s drag region, participating in a window’s zoom action, and modifying a window’s state restoration behavior. ## Remove the title and background from the window’s toolbar Destination Video uses a tab view as its main user interface component, and in macOS, this appears similar to a two-column navigation split view. In this configuration, each tab appears as an entry in the sidebar and participates in the app’s navigation. Because the sidebar provides a visual indication of where you are in that navigation hierarchy, and the app’s content doesn’t require any additional toolbar items, a toolbar isn’t necessary. Removing the toolbar can elevate the underlying content by letting it extend right up to the window’s edge. To remove the toolbar’s background, `ContentView` calls the `toolbarBackgroundVisibility(_:for:)` view method: .toolbarBackgroundVisibility(.hidden, for: .windowToolbar) And then removes the toolbar’s title: .toolbar(removing: .title) In this instance, the app still requires the window control buttons to close or minimize the window or enter full-screen mode, so it uses individual view methods to remove only the title and bar background. To remove the toolbar entirely, use the `toolbarVisibility(_:for:)` view method instead. It’s important to note that these are visual changes only. The system continues to provide the window’s title to accessibility tools such as screen readers, and the app’s Window menu continues to show the title while the window is open. ## Extend the window’s drag region To move a window in macOS, you typically drag that window’s toolbar. However, if you choose to remove the background from a toolbar, or hide the toolbar completely, use `WindowDragGesture` to extend that window’s drag region and make sure the window is still draggable. Destination Video’s `PlayerView` adds this gesture to a transparent overlay and inserts the overlay between the video content and the playback controls. This enables you to safely drag the window and not interfere with the system playback UI that AVKit provides. .gesture(WindowDragGesture()) The player also uses the `allowsWindowActivationEvents(_:)` view method to enable the installed window drag gesture to receive events that activate the window — for example, if the window is in the background and you click it and immediately drag. .allowsWindowActivationEvents(true) ## Customize the window’s zoom behavior By default, a window’s toolbar provides buttons that close the window, minimize the window, and enter full-screen mode. If you press and hold the Option key and click the green button, the window zooms instead of going full screen. Typically, a window zooms to either its defined maximum size, or as large as the display permits. However, you can use the `windowIdealPlacement(_:)` scene method to override this behavior and provide a size and position that’s more appropriate for the window’s contents. The app uses this method to provide a maximum size for the video player that maintains the video’s aspect ratio to prevent black bars appearing above and below it. .windowIdealPlacement { proxy, context in let displayBounds = context.defaultDisplay.visibleRect let idealSize = proxy.sizeThatFits(.unspecified) // Calculate the content's aspect ratio. let aspectRatio = aspectRatio(of: idealSize) // Determine the deltas between the display's size and the content's size. let deltas = deltas(of: displayBounds.size, idealSize) // Calculate the window's zoomed size while maintaining the aspect ratio // of the content. let size = calculateZoomedSize( of: idealSize, inBounds: displayBounds, withAspectRatio: aspectRatio, andDeltas: deltas ) // Position the window in the center of the display and return the // corresponding window placement. let position = position(of: size, centeredIn: displayBounds) return WindowPlacement(position, size: size) } This implementation also ensures the zoomed window appears in the center of the display while zooming. ## Modify how the window participates in state restoration In macOS, state restoration is optional and a person enables (or disables) it systemwide in System Settings. By default, your SwiftUI app respects this setting, but you can choose to override it and specify the preferred restoration behavior for each of your app’s windows. For example, you may want to opt out of state restoration for a window that represents a transient activity, or where it’s difficult or expensive to restore the underlying state from a previous session. When running in macOS, Destination Video uses the `SceneRestorationBehavior` view modifier to disable state restoration for the video player view. .restorationBehavior(.disabled) As the app’s videos are brief, and a person’s interactions with them are short-lived, it doesn’t make sense to restore the video player on the next launch. ## See Also #### Related samples  #### Related videos  ### Essentials Bringing multiple windows to your SwiftUI app Compose rich views by reacting to state changes and customize your app’s scene presentation and behavior on iPadOS and macOS. --- # https://developer.apple.com/documentation/swiftui/bringing_multiple_windows_to_your_swiftui_app - SwiftUI - Bringing multiple windows to your SwiftUI app Sample Code # Bringing multiple windows to your SwiftUI app Compose rich views by reacting to state changes and customize your app’s scene presentation and behavior on iPadOS and macOS. Download Xcode 14.2+ ## Overview ### Configure the sample code project Before you run the sample code project in Xcode: - To run the sample on an iOS device or Mac, make sure you select your team in the Signing & Capabilities tab in each target’s settings. --- # https://developer.apple.com/documentation/swiftui/utilitywindow - SwiftUI - UtilityWindow Structure # UtilityWindow A specialized window scene that provides secondary utility to the content of the main scenes of an application. ## Overview Utility windows are typically used to display controls, settings, or information associated the main content of an application, sometimes referred to as tool palettes or inspector windows. Because of this role, they have specialized behavior compared to all other windows: - They receive `FocusedValues` from the focused main scene in an application, similar to commands in the main menu, which can be used to display information on the active content as the user focuses on different scenes. - They have a default window level of `.floating` so they remain visible when moving focus between the main scenes. - They hide when the window is no longer active. - They only become focused when explicitly needed, such as clicking in the titlebar or on a focusable view. - When focused, they can be dismissed with the Escape key. - They are not minimizable by default. @main struct PhotoBrowser: App { var body: some Scene { WindowGroup { PhotoGallery() } UtilityWindow("Photo Info", id: "photo-info") { PhotoInfoViewer() } } } struct PhotoInfoViewer: View { // Automatically updates to the photo selection from whichever // photo gallery window is focused. @FocusedValue(PhotoSelection.self) private var selectedPhotos var body: some View { Text("\(selectedPhotos.count) photos selected") } `UtilityWindow` will automatically add a menu item to show/hide itself in the “View” menu. This can be removed by applying `commandsRemoved()` to the utility window, and manually placing a `WindowVisibilityToggle` elsewhere in an app’s commands. Utility windows can also be programmatically presented with `openWindow` and dismissed using `dismiss`. ## Topics ### Initializers `init(_:id:content:)` Creates a utility window with a title and identifier. ## Relationships ### Conforms To - `Scene` ## See Also ### Creating windows `struct WindowGroup` A scene that presents a group of identically structured windows. `struct Window` A scene that presents its content in a single, unique window. `protocol WindowStyle` A specification for the appearance and interaction of a window. Sets the style for windows created by this scene. --- # https://developer.apple.com/documentation/swiftui/windowstyle - SwiftUI - WindowStyle Protocol # WindowStyle A specification for the appearance and interaction of a window. protocol WindowStyle ## Topics ### Getting built-in window styles `static var automatic: DefaultWindowStyle` The default window style. `static var hiddenTitleBar: HiddenTitleBarWindowStyle` A window style which hides both the window’s title and the backing of the titlebar area, allowing more of the window’s content to show. `static var plain: PlainWindowStyle` The plain window style. `static var titleBar: TitleBarWindowStyle` A window style which displays the title bar section of the window. `static var volumetric: VolumetricWindowStyle` A window style that creates a 3D volumetric window. ### Supporting types `struct DefaultWindowStyle` `struct HiddenTitleBarWindowStyle` `struct PlainWindowStyle` `struct TitleBarWindowStyle` `struct VolumetricWindowStyle` ## Relationships ### Conforming Types - `DefaultWindowStyle` - `HiddenTitleBarWindowStyle` - `PlainWindowStyle` - `TitleBarWindowStyle` - `VolumetricWindowStyle` ## See Also ### Creating windows `struct WindowGroup` A scene that presents a group of identically structured windows. `struct Window` A scene that presents its content in a single, unique window. `struct UtilityWindow` A specialized window scene that provides secondary utility to the content of the main scenes of an application. Sets the style for windows created by this scene. --- # https://developer.apple.com/documentation/swiftui/scene/windowtoolbarstyle(_:) #app-main) - SwiftUI - Scene - windowToolbarStyle(\_:) Instance Method # windowToolbarStyle(\_:) Sets the style for the toolbar defined within this scene. nonisolated ## See Also ### Styling a toolbar `func toolbarBackground(_:for:)` Specifies the preferred shape style of the background of a bar managed by SwiftUI. Specifies the preferred color scheme of a bar managed by SwiftUI. Specifies the preferred foreground style of bars managed by SwiftUI. `protocol WindowToolbarStyle` A specification for the appearance and behavior of a window’s toolbar. `var toolbarLabelStyle: ToolbarLabelStyle?` The label style to apply to controls within a toolbar. `struct ToolbarLabelStyle` The label style of a toolbar. `struct SpacerSizing` A type which defines how spacers should size themselves. Beta --- # https://developer.apple.com/documentation/swiftui/scene/windowtoolbarlabelstyle(_:) #app-main) - SwiftUI - Scene - windowToolbarLabelStyle(\_:) Instance Method # windowToolbarLabelStyle(\_:) Sets the label style of items in a toolbar and enables user customization. nonisolated ## Parameters `toolbarLabelStyle` The label style to apply. ## Discussion Use this modifier to bind a `ToolbarLabelStyle` to `AppStorage`. The toolbar will default to the label style specified but will also be user configurable. @main struct MyApp: App { @AppStorage("ToolbarLabelStyle") private var labelStyle: ToolbarLabelStyle = .iconOnly var body: some Scene { WindowGroup { ContentView() .toolbar(id: "browserToolbar") { ... } } .windowToolbarLabelStyle($labelStyle) } } ## See Also ### Styling the associated toolbar Sets the style for the toolbar defined within this scene. Sets the label style of items in a toolbar. `protocol WindowToolbarStyle` A specification for the appearance and behavior of a window’s toolbar. --- # https://developer.apple.com/documentation/swiftui/scene/windowtoolbarlabelstyle(fixed:) #app-main) - SwiftUI - Scene - windowToolbarLabelStyle(fixed:) Instance Method # windowToolbarLabelStyle(fixed:) Sets the label style of items in a toolbar. nonisolated ## Discussion Use this modifier to set a static `ToolbarLabelStyle` the toolbar should use. The style will not be configurable by the user. @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() .toolbar(id: "browserToolbar") { ... } } .windowToolbarLabelStyle(fixed: .iconOnly) } } ## See Also ### Styling the associated toolbar Sets the style for the toolbar defined within this scene. Sets the label style of items in a toolbar and enables user customization. `protocol WindowToolbarStyle` A specification for the appearance and behavior of a window’s toolbar. --- # https://developer.apple.com/documentation/swiftui/windowtoolbarstyle - SwiftUI - WindowToolbarStyle Protocol # WindowToolbarStyle A specification for the appearance and behavior of a window’s toolbar. protocol WindowToolbarStyle ## Topics ### Getting built-in window toolbar styles `static var automatic: DefaultWindowToolbarStyle` The automatic window toolbar style. `static var expanded: ExpandedWindowToolbarStyle` A window toolbar style which displays its title bar area above the toolbar. `static var unified: UnifiedWindowToolbarStyle` A window toolbar style which displays its toolbar and title bar inline. `static var unifiedCompact: UnifiedCompactWindowToolbarStyle` A window toolbar style similar to `unified`, but with a more compact vertical sizing. ### Supporting types `struct DefaultWindowToolbarStyle` The default window toolbar style. `struct ExpandedWindowToolbarStyle` `struct UnifiedWindowToolbarStyle` `struct UnifiedCompactWindowToolbarStyle` ## Relationships ### Conforming Types - `DefaultWindowToolbarStyle` - `ExpandedWindowToolbarStyle` - `UnifiedCompactWindowToolbarStyle` - `UnifiedWindowToolbarStyle` ## See Also ### Styling a toolbar `func toolbarBackground(_:for:)` Specifies the preferred shape style of the background of a bar managed by SwiftUI. Specifies the preferred color scheme of a bar managed by SwiftUI. Specifies the preferred foreground style of bars managed by SwiftUI. Sets the style for the toolbar defined within this scene. `var toolbarLabelStyle: ToolbarLabelStyle?` The label style to apply to controls within a toolbar. `struct ToolbarLabelStyle` The label style of a toolbar. `struct SpacerSizing` A type which defines how spacers should size themselves. Beta --- # https://developer.apple.com/documentation/swiftui/environmentvalues/supportsmultiplewindows - SwiftUI - EnvironmentValues - supportsMultipleWindows Instance Property # supportsMultipleWindows A Boolean value that indicates whether the current platform supports opening multiple windows. var supportsMultipleWindows: Bool { get } ## Discussion Read this property from the environment to determine if your app can use the `openWindow` action to open new windows: struct NewMailViewerButton: View { @Environment(\.supportsMultipleWindows) private var supportsMultipleWindows @Environment(\.openWindow) private var openWindow var body: some View { Button("Open New Window") { openWindow(id: "mail-viewer") } .disabled(!supportsMultipleWindows) } } The reported value depends on both the platform and how you configure your app: - In macOS, this property returns `true` for any app that uses the SwiftUI app lifecycle. - In iPadOS, this property returns `true` for any app that uses the SwiftUI app lifecycle and has the Information Property List key `UIApplicationSupportsMultipleScenes` set to `true`. - For all other platforms and configurations, the value returns `false`. If the value is false and you try to open a window, SwiftUI ignores the action and logs a runtime error. ## See Also ### Opening windows Presenting windows and spaces Open and close the scenes that make up your app’s interface. `var openWindow: OpenWindowAction` A window presentation action stored in a view’s environment. `struct OpenWindowAction` An action that presents a window. `struct PushWindowAction` An action that opens the requested window in place of the window the action is called from. --- # https://developer.apple.com/documentation/swiftui/environmentvalues/openwindow - SwiftUI - EnvironmentValues - openWindow Instance Property # openWindow A window presentation action stored in a view’s environment. var openWindow: OpenWindowAction { get } ## Discussion Use the `openWindow` environment value to get an `OpenWindowAction` instance for a given `Environment`. Then call the instance to open a window. You call the instance directly because it defines a `callAsFunction(id:)` method that Swift calls when you call the instance. For example, you can define a button that opens a new mail viewer window: @main struct Mail: App { var body: some Scene { WindowGroup(id: "mail-viewer") { MailViewer() } } } struct NewViewerButton: View { @Environment(\.openWindow) private var openWindow var body: some View { Button("Open new mail viewer") { openWindow(id: "mail-viewer") } } } You indicate which scene to open by providing one of the following: - A string identifier that you pass through the `id` parameter, as in the above example. - A `value` parameter that has a type that matches the type that you specify in the scene’s initializer. - Both an identifier and a value. This enables you to define multiple window groups that take input values of the same type like a `UUID`. Use the first option to target either a `WindowGroup` or a `Window` scene in your app that has a matching identifier. For a `WindowGroup`, the system creates a new window for the group. If the window group presents data, the system provides the default value or `nil` to the window’s root view. If the targeted scene is a `Window`, the system orders it to the front. Use the other two options to target a `WindowGroup` and provide a value to present. If the interface already has a window from the group that’s presenting the specified value, the system brings the window to the front. Otherwise, the system creates a new window and passes a binding to the specified value. ## See Also ### Opening windows Presenting windows and spaces Open and close the scenes that make up your app’s interface. `var supportsMultipleWindows: Bool` A Boolean value that indicates whether the current platform supports opening multiple windows. `struct OpenWindowAction` An action that presents a window. `struct PushWindowAction` An action that opens the requested window in place of the window the action is called from. --- # https://developer.apple.com/documentation/swiftui/openwindowaction - SwiftUI - OpenWindowAction Structure # OpenWindowAction An action that presents a window. @MainActor @preconcurrency struct OpenWindowAction ## Overview Use the `openWindow` environment value to get the instance of this structure for a given `Environment`. Then call the instance to open a window. You call the instance directly because it defines a `callAsFunction(id:)` method that Swift calls when you call the instance. For example, you can define a button that opens a new mail viewer window: @main struct Mail: App { var body: some Scene { WindowGroup(id: "mail-viewer") { MailViewer() } } } struct NewViewerButton: View { @Environment(\.openWindow) private var openWindow var body: some View { Button("Open new mail viewer") { openWindow(id: "mail-viewer") } } } You indicate which scene to open by providing one of the following: - A string identifier that you pass through the `id` parameter, as in the above example. - A `value` parameter that has a type that matches the type that you specify in the scene’s initializer. - Both an identifier and a value. This enables you to define multiple window groups that take input values of the same type, like a `UUID`. Use the first option to target either a `WindowGroup` or a `Window` scene in your app that has a matching identifier. For a `WindowGroup`, the system creates a new window for the group. If the window group presents data, the system provides the default value or `nil` to the window’s root view. If the targeted scene is a `Window`, the system orders it to the front. Use the other two options to target a `WindowGroup` and provide a value to present. If the interface already has a window from the group that’s presenting the specified value, the system brings the window to the front. Otherwise, the system creates a new window and passes a binding to the specified value. ## Topics ### Calling the action `func callAsFunction(id: String)` Opens a window that’s associated with the specified identifier. Opens a window defined by the window group that presents the specified value type and that’s associated with the specified identifier. Opens a window defined by a window group that presents the type of the specified value. ### Structures `struct SharingBehavior` ### Instance Methods `func callAsFunction(id: String, sharingBehavior: OpenWindowAction.SharingBehavior) async throws` Opens a window that’s associated with the specified identifier, using the specified sharing sharingBehavior.. Opens a window defined by the window group that presents the specified value type and that’s associated with the specified identifier, using the specified sharingBehavior. Opens a window defined by a window group that presents the type of the specified value, using the specified sharingBehavior. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Opening windows Presenting windows and spaces Open and close the scenes that make up your app’s interface. `var supportsMultipleWindows: Bool` A Boolean value that indicates whether the current platform supports opening multiple windows. `var openWindow: OpenWindowAction` A window presentation action stored in a view’s environment. `struct PushWindowAction` An action that opens the requested window in place of the window the action is called from. --- # https://developer.apple.com/documentation/swiftui/pushwindowaction - SwiftUI - PushWindowAction Structure # PushWindowAction An action that opens the requested window in place of the window the action is called from. @MainActor struct PushWindowAction ## Overview The scene this action is called from will be backgrounded. The requested scene will be center-aligned with the backgrounded scene. The requested scene will have a default size that matches the size of the backgrounded scene. Closing the requested window will result in the backgrounded scene reappearing. Call `dismissWindow` from the pushed window to dismiss the pushed window and show the backgrounded window. Calling this action from a pushed window is not allowed. Use the `pushWindow` environment value to get the instance of this structure for a given `Environment`. Then call the instance to push a window. You call the instance directly because it defines a `callAsFunction(id:)` method that Swift calls when you call the instance. For example, you can define a button that pushes a video preview from an editor window: @main struct VideoEditor: App { var body: some Scene { WindowGroup(id: "editor") { EditorView() } WindowGroup(id: "viewer") { VideoView() } } } struct EditorView: View { @Environment(\.pushWindow) private var pushWindow var body: some View { Button("Play", systemImage: "play.fill") { pushWindow(id: "viewer") } } } You indicate which scene to push by providing one of the following: - A string identifier that you pass through the `id` parameter, as in the above example. - A `value` parameter that has a type that matches the type that you specify in the scene’s initializer. - Both an identifier and a value. This enables you to define multiple window groups that take input values of the same type, like a `UUID`. Use the first option to target either a `WindowGroup` or a `Window` scene in your app that has a matching identifier. For a `WindowGroup`, the system creates a new window for the group. If the window group presents data, the system provides the default value or `nil` to the window’s root view. If the targeted scene is a `Window`, the system orders it to the front. Use the other two options to target a `WindowGroup` and provide a value to present. If the interface already has a window from the group that is presenting the specified value, the system brings the window to the front. Otherwise, the system creates a new window and passes a binding to the specified value. ## Topics ### Instance Methods `func callAsFunction(id: String)` Pushes a window that is associated with the specified identifier. Pushes a window defined by the window group that presents the specified value type and that is associated with the specified identifier. Pushes a window defined by a window group that presents the type of the specified value. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Opening windows Presenting windows and spaces Open and close the scenes that make up your app’s interface. `var supportsMultipleWindows: Bool` A Boolean value that indicates whether the current platform supports opening multiple windows. `var openWindow: OpenWindowAction` A window presentation action stored in a view’s environment. `struct OpenWindowAction` An action that presents a window. --- # https://developer.apple.com/documentation/swiftui/environmentvalues/dismisswindow - SwiftUI - EnvironmentValues - dismissWindow Instance Property # dismissWindow A window dismissal action stored in a view’s environment. var dismissWindow: DismissWindowAction { get } ## Discussion Use the `dismissWindow` environment value to get an `DismissWindowAction` instance for a given `Environment`. Then call the instance to dismiss a window. You call the instance directly because it defines a `callAsFunction(id:)` method that Swift calls when you call the instance. For example, you can define a button that dismisses an auxiliary window: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } #if os(macOS) Window("Auxiliary", id: "auxiliary") { AuxiliaryContentView() } #endif } } struct DismissWindowButton: View { @Environment(\.dismissWindow) private var dismissWindow var body: some View { Button("Close Auxiliary Window") { dismissWindow(id: "auxiliary") } } } If the window was opened with `pushWindow`, the presenting window will reappear when this action is performed. ## See Also ### Closing windows `struct DismissWindowAction` An action that dismisses a window associated to a particular scene. `var dismiss: DismissAction` An action that dismisses the current presentation. `struct DismissAction` An action that dismisses a presentation. `struct DismissBehavior` Programmatic window dismissal behaviors. --- # https://developer.apple.com/documentation/swiftui/dismisswindowaction - SwiftUI - DismissWindowAction Structure # DismissWindowAction An action that dismisses a window associated to a particular scene. @MainActor @preconcurrency struct DismissWindowAction ## Overview Use the `dismissWindow` environment value to get the instance of this structure for a given `Environment`. Then call the instance to dismiss a window. You call the instance directly because it defines a `callAsFunction(id:)` method that Swift calls when you call the instance. For example, you can define a button that closes an auxiliary window: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } #if os(macOS) Window("Auxiliary", id: "auxiliary") { AuxiliaryContentView() } #endif } } struct DismissWindowButton: View { @Environment(\.dismissWindow) private var dismissWindow var body: some View { Button("Close Auxiliary Window") { dismissWindow(id: "auxiliary") } } } If the window was opened with `pushWindow`, the original presenting will reappear when this action is performed. ## Topics ### Calling the action `func callAsFunction()` Dismisses the current window. `func callAsFunction(id: String)` Dismisses the window that’s associated with the specified identifier. Dismisses the window defined by the window group that is presenting the specified value type and that’s associated with the specified identifier. Dismisses the window defined by the window group that is presenting the specified value type. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Closing windows `var dismissWindow: DismissWindowAction` A window dismissal action stored in a view’s environment. `var dismiss: DismissAction` An action that dismisses the current presentation. `struct DismissAction` An action that dismisses a presentation. `struct DismissBehavior` Programmatic window dismissal behaviors. --- # https://developer.apple.com/documentation/swiftui/environmentvalues/dismiss - SwiftUI - EnvironmentValues - dismiss Instance Property # dismiss An action that dismisses the current presentation. var dismiss: DismissAction { get } ## Mentioned in Managing search interface activation ## Discussion Use this environment value to get the `DismissAction` instance for the current `Environment`. Then call the instance to perform the dismissal. You call the instance directly because it defines a `callAsFunction()` method that Swift calls when you call the instance. You can use this action to: - Dismiss a modal presentation, like a sheet or a popover. - Pop the current view from a `NavigationStack`. On apps targetting iOS 18 and aligned releases, you also use the dismiss action to pop the implicit stack of a collapsed `NavigationSplitView`, or clear the equivalent state in an expanded split view. The specific behavior of the action depends on where you call it from. For example, you can create a button that calls the `DismissAction` inside a view that acts as a sheet: private struct SheetContents: View { @Environment(\.dismiss) private var dismiss var body: some View { Button("Done") { dismiss() } } } When you present the `SheetContents` view, someone can dismiss the sheet by tapping or clicking the sheet’s button: private struct DetailView: View { @State private var isSheetPresented = false var body: some View { Button("Show Sheet") { isSheetPresented = true } .sheet(isPresented: $isSheetPresented) { SheetContents() } } } Be sure that you define the action in the appropriate environment. For example, don’t reorganize the `DetailView` in the example above so that it creates the `dismiss` property and calls it from the `sheet(item:onDismiss:content:)` view modifier’s `content` closure: private struct DetailView: View { @State private var isSheetPresented = false @Environment(\.dismiss) private var dismiss // Applies to DetailView. var body: some View { Button("Show Sheet") { isSheetPresented = true } .sheet(isPresented: $isSheetPresented) { Button("Done") { dismiss() // Fails to dismiss the sheet. } } } } If you do this, the sheet fails to dismiss because the action applies to the environment where you declared it, which is that of the detail view, rather than the sheet. In fact, in macOS and iPadOS, if the `DetailView` is the root view of a window, the dismiss action closes the window instead. The dismiss action has no effect on a view that isn’t currently presented. If you need to query whether SwiftUI is currently presenting a view, read the `isPresented` environment value. ## See Also ### Dismissing a presentation `var isPresented: Bool` A Boolean value that indicates whether the view associated with this environment is currently presented. `struct DismissAction` An action that dismisses a presentation. Conditionally prevents interactive dismissal of presentations like popovers, sheets, and inspectors. --- # https://developer.apple.com/documentation/swiftui/dismissaction - SwiftUI - DismissAction Structure # DismissAction An action that dismisses a presentation. @MainActor @preconcurrency struct DismissAction ## Overview Use the `dismiss` environment value to get the instance of this structure for a given `Environment`. Then call the instance to perform the dismissal. You call the instance directly because it defines a `callAsFunction()` method that Swift calls when you call the instance. You can use this action to: - Dismiss a modal presentation, like a sheet or a popover. - Pop the current view from a `NavigationStack`. On apps targeting iOS 18 and aligned releases, you also use the dismiss action to pop the implicit stack of a collapsed `NavigationSplitView`, or clear the equivalent state in an expanded split view. The specific behavior of the action depends on where you call it from. For example, you can create a button that calls the `DismissAction` inside a view that acts as a sheet: private struct SheetContents: View { @Environment(\.dismiss) private var dismiss var body: some View { Button("Done") { dismiss() } } } When you present the `SheetContents` view, someone can dismiss the sheet by tapping or clicking the sheet’s button: private struct DetailView: View { @State private var isSheetPresented = false var body: some View { Button("Show Sheet") { isSheetPresented = true } .sheet(isPresented: $isSheetPresented) { SheetContents() } } } Be sure that you define the action in the appropriate environment. For example, don’t reorganize the `DetailView` in the example above so that it creates the `dismiss` property and calls it from the `sheet(item:onDismiss:content:)` view modifier’s `content` closure: private struct DetailView: View { @State private var isSheetPresented = false @Environment(\.dismiss) private var dismiss // Applies to DetailView. var body: some View { Button("Show Sheet") { isSheetPresented = true } .sheet(isPresented: $isSheetPresented) { Button("Done") { dismiss() // Fails to dismiss the sheet. } } } } If you do this, the sheet fails to dismiss because the action applies to the environment where you declared it, which is that of the detail view, rather than the sheet. In fact, in macOS and iPadOS, if the `DetailView` is the root view of a window, the dismiss action closes the window instead. The dismiss action has no effect on a view that isn’t currently presented. If you need to query whether SwiftUI is currently presenting a view, read the `isPresented` environment value. ## Topics ### Calling the action `func callAsFunction()` Dismisses the view if it is currently presented. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Dismissing a presentation `var isPresented: Bool` A Boolean value that indicates whether the view associated with this environment is currently presented. `var dismiss: DismissAction` An action that dismisses the current presentation. Conditionally prevents interactive dismissal of presentations like popovers, sheets, and inspectors. --- # https://developer.apple.com/documentation/swiftui/dismissbehavior - SwiftUI - DismissBehavior Structure # DismissBehavior Programmatic window dismissal behaviors. struct DismissBehavior ## Overview Use values of this type to control window dismissal during the current transaction. For example, to dismiss windows showing a modal presentation that would otherwise prohibit dismissal, use the `destructive` behavior: struct DismissWindowButton: View { @Environment(\.dismissWindow) private var dismissWindow var body: some View { Button("Close Auxiliary Window") { withTransaction(\.dismissBehavior, .destructive) { dismissWindow(id: "auxiliary") } } } } ## Topics ### Getting behaviors `static let destructive: DismissBehavior` The destructive dismiss behavior. `static let interactive: DismissBehavior` The interactive dismiss behavior. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Closing windows `var dismissWindow: DismissWindowAction` A window dismissal action stored in a view’s environment. `struct DismissWindowAction` An action that dismisses a window associated to a particular scene. `var dismiss: DismissAction` An action that dismisses the current presentation. `struct DismissAction` An action that dismisses a presentation. --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(_:) #app-main) - SwiftUI - Scene - defaultSize(\_:) Instance Method # defaultSize(\_:) Sets a default size for a window. nonisolated Show all declarations ## Parameters `size` The default size for new windows created from a scene. ## Return Value A scene that uses a default size for new windows. ## Discussion Use this scene modifier to indicate a default initial size for a new window that the system creates from a `Scene` declaration. For example, you can request that new windows that a `WindowGroup` generates occupy 600 points in the x-dimension and 400 points in the y-dimension: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } .defaultSize(CGSize(width: 600, height: 400)) } } The size that you specify acts only as a default for when the window first appears. People can later resize the window using interface controls that the system provides. Also, during state restoration, the system restores windows to their most recent size rather than the default size. If you specify a default size that’s outside the range of the window’s inherent resizability in one or both dimensions, the system clamps the affected dimension to keep it in range. You can configure the resizability of a scene using the `windowResizability(_:)` modifier. The default size modifier affects any scene type that creates windows in macOS, namely: - `WindowGroup` - `Window` - `DocumentGroup` - `Settings` If you want to specify the input directly in terms of width and height, use `defaultSize(width:height:)` instead. ## See Also ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. Sets a default width and height for a window. Sets a default size for a volumetric window. Sets the kind of resizability to use for a window. `struct WindowResizability` The resizability of a window. Specifies how windows derived form this scene should determine their size when zooming. `struct WindowIdealSize` A type which defines the size a window should use when zooming. --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(width:height:) #app-main) - SwiftUI - Scene - defaultSize(width:height:) Instance Method # defaultSize(width:height:) Sets a default width and height for a window. nonisolated func defaultSize( width: CGFloat, height: CGFloat ## Parameters `width` The default width for windows created from a scene. `height` The default height for windows created from a scene. ## Return Value A scene that uses a default size for new windows. ## Discussion Use this scene modifier to indicate a default initial size for a new window that the system creates from a `Scene` declaration. For example, you can request that new windows that a `WindowGroup` generates occupy 600 points in the x-dimension and 400 points in the y-dimension: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } .defaultSize(width: 600, height: 400) } } The size that you specify acts only as a default for when the window first appears. People can later resize the window using interface controls that the system provides. Also, during state restoration, the system restores windows to their most recent size rather than the default size. If you specify a default size that’s outside the range of the window’s inherent resizability in one or both dimensions, the system clamps the affected dimension to keep it in range. You can configure the resizability of a scene using the `windowResizability(_:)` modifier. The default size modifier affects any scene type that creates windows in macOS, namely: - `WindowGroup` - `Window` - `DocumentGroup` - `Settings` If you want to specify the size input in terms of size instance, use `defaultSize(_:)` instead. ## See Also ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. `func defaultSize(_:)` Sets a default size for a window. Sets a default size for a volumetric window. Sets the kind of resizability to use for a window. `struct WindowResizability` The resizability of a window. Specifies how windows derived form this scene should determine their size when zooming. `struct WindowIdealSize` A type which defines the size a window should use when zooming. --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(width:height:depth:) #app-main) - SwiftUI - Scene - defaultSize(width:height:depth:) Instance Method # defaultSize(width:height:depth:) Sets a default size for a volumetric window. nonisolated func defaultSize( width: CGFloat, height: CGFloat, depth: CGFloat ## Parameters `width` The default width for the created window. `height` The default height for the created window. `depth` The default depth for the created volumetric window. ## Return Value A scene that uses a default size for new windows. ## Discussion Use this modifier to indicate the default initial size for a new 3D window created from a `Scene` using `VolumetricWindowStyle`: WindowGroup { ContentView() } .windowStyle(.volumetric) .defaultSize(width: 600, height: 400, depth: 600) Each parameter is specified in points. The size of a volumetric scene is immutable after creation. This modifier affects only windows that have the volumetric style in visionOS. ## See Also ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. `func defaultSize(_:)` Sets a default size for a window. Sets a default width and height for a window. Sets the kind of resizability to use for a window. `struct WindowResizability` The resizability of a window. Specifies how windows derived form this scene should determine their size when zooming. `struct WindowIdealSize` A type which defines the size a window should use when zooming. --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(_:in:) #app-main) - SwiftUI - Scene - defaultSize(\_:in:) Instance Method # defaultSize(\_:in:) Sets a default size for a volumetric window. nonisolated func defaultSize( _ size: Size3D, in unit: UnitLength ## Parameters `unit` The unit of length the dimensions of the window are specified in. ## Return Value A scene that uses a default size for new windows. ## Discussion Use this modifier to indicate the default initial size for a new 3D window created from a `Scene` using `VolumetricWindowStyle`: WindowGroup { ContentView() } .windowStyle(.volumetric) .defaultSize(Size3D(width: 1, height: 1, depth: 0.5), in: .meters) Each parameter is specified in the unit you provide. The size of a volumetric scene is immutable after creation. This modifier affects only windows that have the volumetric style in visionOS. ## See Also ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. `func defaultSize(_:)` Sets a default size for a window. Sets a default width and height for a window. Sets the kind of resizability to use for a window. `struct WindowResizability` The resizability of a window. Specifies how windows derived form this scene should determine their size when zooming. `struct WindowIdealSize` A type which defines the size a window should use when zooming. --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(width:height:depth:in:) #app-main) - SwiftUI - Scene - defaultSize(width:height:depth:in:) Instance Method # defaultSize(width:height:depth:in:) Sets a default size for a volumetric window. nonisolated func defaultSize( width: CGFloat, height: CGFloat, depth: CGFloat, in unit: UnitLength ## Parameters `width` The default width for the created window. `height` The default height for the created window. `depth` The default depth for the created volumetric window. `unit` The unit of length the dimensions of the window are specified in. ## Return Value A scene that uses a default size for new windows. ## Discussion Use this modifier to indicate the default initial size for a new 3D window created from a `Scene` using `VolumetricWindowStyle`: WindowGroup { ContentView() } .windowStyle(.volumetric) .defaultSize(width: 1, height: 1, depth: 0.5, in: .meters) Each parameter is specified in the unit you provide. The size of a volumetric scene is immutable after creation. This modifier affects only windows that have the volumetric style in visionOS. ## See Also ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. `func defaultSize(_:)` Sets a default size for a window. Sets a default width and height for a window. Sets the kind of resizability to use for a window. `struct WindowResizability` The resizability of a window. Specifies how windows derived form this scene should determine their size when zooming. `struct WindowIdealSize` A type which defines the size a window should use when zooming. --- # https://developer.apple.com/documentation/swiftui/scene/windowresizability(_:) #app-main) - SwiftUI - Scene - windowResizability(\_:) Instance Method # windowResizability(\_:) Sets the kind of resizability to use for a window. nonisolated ## Parameters `resizability` The resizability to use for windows created by this scene. ## Return Value A scene that uses the specified resizability strategy. ## Discussion Use this scene modifier to apply a value of type `WindowResizability` to a `Scene` that you define in your `App` declaration. The value that you specify indicates the strategy the system uses to place minimum and maximum size restrictions on windows that it creates from that scene. For example, you can create a window group that people can resize to between 100 and 400 points in both dimensions by applying both a frame with those constraints to the scene’s content, and the `contentSize` resizability to the scene: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() .frame( minWidth: 100, maxWidth: 400, minHeight: 100, maxHeight: 400) } .windowResizability(.contentSize) } } The default value for all scenes if you don’t apply the modifier is `automatic`. With that strategy, `Settings` windows use the `contentSize` strategy, while all others use `contentMinSize`. ## See Also ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. `func defaultSize(_:)` Sets a default size for a window. Sets a default width and height for a window. Sets a default size for a volumetric window. `struct WindowResizability` The resizability of a window. Specifies how windows derived form this scene should determine their size when zooming. `struct WindowIdealSize` A type which defines the size a window should use when zooming. --- # https://developer.apple.com/documentation/swiftui/windowresizability - SwiftUI - WindowResizability Structure # WindowResizability The resizability of a window. struct WindowResizability ## Overview Use the `windowResizability(_:)` scene modifier to apply a value of this type to a `Scene` that you define in your `App` declaration. The value that you specify indicates the strategy the system uses to place minimum and maximum size restrictions on windows that it creates from that scene. For example, you can create a window group that people can resize to between 100 and 400 points in both dimensions by applying both a frame with those constraints to the scene’s content, and the `contentSize` resizability to the scene: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() .frame( minWidth: 100, maxWidth: 400, minHeight: 100, maxHeight: 400) } .windowResizability(.contentSize) } } The default value for all scenes if you don’t apply the modifier is `automatic`. With that strategy, `Settings` windows use the `contentSize` strategy, while all others use `contentMinSize`. Windows on visionOS with a window style of `volumetric` also use the `contentSize` strategy. ## Topics ### Getting the resizability `static var automatic: WindowResizability` The automatic window resizability. `static var contentMinSize: WindowResizability` A window resizability that’s partially derived from the window’s content. `static var contentSize: WindowResizability` A window resizability that’s derived from the window’s content. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. `func defaultSize(_:)` Sets a default size for a window. Sets a default width and height for a window. Sets a default size for a volumetric window. Sets the kind of resizability to use for a window. Specifies how windows derived form this scene should determine their size when zooming. `struct WindowIdealSize` A type which defines the size a window should use when zooming. --- # https://developer.apple.com/documentation/swiftui/scene/windowidealsize(_:) #app-main) - SwiftUI - Scene - windowIdealSize(\_:) Instance Method # windowIdealSize(\_:) Specifies how windows derived form this scene should determine their size when zooming. nonisolated ## Parameters `idealSize` A value which determines how windows derived from this scene should size themselves when zooming. ## Discussion The default behavior will size the window to its maximum size, or the bounds of the display, whichever is smaller. By overriding this behavior, you can provide a size that is appropriate for the contents of your window. For example, you can define a window group where the window has an ideal width of 800 points and an ideal height of 600 points: struct MyApp: App { var body: some Scene { WindowGroup { ContentView() .frame(idealWidth: 800, idealHeight: 600) } .windowIdealSize(.fitToContent) } } ## See Also ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. `func defaultSize(_:)` Sets a default size for a window. Sets a default width and height for a window. Sets a default size for a volumetric window. Sets the kind of resizability to use for a window. `struct WindowResizability` The resizability of a window. `struct WindowIdealSize` A type which defines the size a window should use when zooming. --- # https://developer.apple.com/documentation/swiftui/windowidealsize - SwiftUI - WindowIdealSize Structure # WindowIdealSize A type which defines the size a window should use when zooming. struct WindowIdealSize ## Overview Use this type in conjunction with the `Scene.windowIdealSize(_:)` modifier to override the default behavior for how windows behave when performing a zoom. For example, you can define a window group where the window has an ideal width of 800 points and an ideal height of 600 points: struct MyApp: App { var body: some Scene { WindowGroup { ContentView() .frame(idealWidth: 800, idealHeight: 600) } .windowIdealSize(.fitToContent) } } ## Topics ### Type Properties `static let automatic: WindowIdealSize` The automatic window ideal size. Windows will use the system behavior when determining the size to use when zooming. `static let fitToContent: WindowIdealSize` A window ideal size which uses the ideal size of the window’s contents. `static let maximum: WindowIdealSize` A window ideal size which uses the maximum size of the window’s contents. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Sizing a window Positioning and sizing windows Influence the initial geometry of windows that your app presents. `func defaultSize(_:)` Sets a default size for a window. Sets a default width and height for a window. Sets a default size for a volumetric window. Sets the kind of resizability to use for a window. `struct WindowResizability` The resizability of a window. Specifies how windows derived form this scene should determine their size when zooming. --- # https://developer.apple.com/documentation/swiftui/windowlevel - SwiftUI - WindowLevel Structure # WindowLevel The level of a window. struct WindowLevel ## Overview Use this in conjunction with the `.windowLevel(_:)` modifier to control window levels. ## Topics ### Type Properties `static var automatic: WindowLevel` Automatic window level. `static var desktop: WindowLevel` Desktop window level. `static var floating: WindowLevel` Floating window level. `static var normal: WindowLevel` Normal window level. ## Relationships ### Conforms To - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Positioning a window Sets a default position for a window. Sets the window level of this scene. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. `struct WindowPlacement` A type which represents a preferred size and position for a window. Defines a function used for determining the default placement of windows. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct WindowProxy` The proxy for an open window in the app. `struct DisplayProxy` A type which provides information about display hardware. --- # https://developer.apple.com/documentation/swiftui/scene/windowlevel(_:) #app-main) - SwiftUI - Scene - windowLevel(\_:) Instance Method # windowLevel(\_:) Sets the window level of this scene. nonisolated ## Parameters `level` The desired window level ## Discussion Window("Utility Window", id: "...") { UtilityContent() } .windowLevel(.floating) ## See Also ### Positioning a window Sets a default position for a window. `struct WindowLevel` The level of a window. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. `struct WindowPlacement` A type which represents a preferred size and position for a window. Defines a function used for determining the default placement of windows. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct WindowProxy` The proxy for an open window in the app. `struct DisplayProxy` A type which provides information about display hardware. --- # https://developer.apple.com/documentation/swiftui/windowlayoutroot - SwiftUI - WindowLayoutRoot Structure # WindowLayoutRoot A proxy which represents the root contents of a window. struct WindowLayoutRoot ## Overview This type acts like a proxy for the contents of the window defined by a SwiftUI `Scene`. The `Scene.defaultWindowPlacement(_:)` modifier receives an instance of this type, representing the contents of the window being created. Use this proxy to get information about the window’s contents, like it’s size. ## Topics ### Instance Methods Asks the window’s content for its size. ## See Also ### Positioning a window Sets a default position for a window. `struct WindowLevel` The level of a window. Sets the window level of this scene. `struct WindowPlacement` A type which represents a preferred size and position for a window. Defines a function used for determining the default placement of windows. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct WindowProxy` The proxy for an open window in the app. `struct DisplayProxy` A type which provides information about display hardware. --- # https://developer.apple.com/documentation/swiftui/windowplacement - SwiftUI - WindowPlacement Structure # WindowPlacement A type which represents a preferred size and position for a window. struct WindowPlacement ## Overview When using the `Scene.defaultWindowPlacement(_:)` modifier, you return an instance of a `WindowPlacement` in the closure you provide. When constructing a window placement, many initial parameters are optional. Any value not specified will fall ### Structures `struct Position` A semantic or positional value for the location of a window. ### Initializers `init(WindowPlacement.Position?)` Creates a new window placement with an optional position. `init(WindowPlacement.Position?, size3D: Size3D?)` Creates a new window placement with an optional position and 3D size. Depth is ignored on scenes that don’t support it. `init(_:size:)` Creates a new window placement with an absolute position and optional size. `init(UnitPoint, width: CGFloat?, height: CGFloat?)` Creates a new window placement with a display-relative position, with an optional width and height. `init(WindowPlacement.Position?, width: CGFloat?, height: CGFloat?, depth: CGFloat?)` Creates a new window placement with an optional position and 3D size. Depth is ignored on scenes or platforms that don’t support it. `init(x: CGFloat?, y: CGFloat?, width: CGFloat?, height: CGFloat?)` Creates a new window placement with an optional position and size. ## Relationships ### Conforms To - `Equatable` ## See Also ### Positioning a window Sets a default position for a window. `struct WindowLevel` The level of a window. Sets the window level of this scene. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. Defines a function used for determining the default placement of windows. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct WindowProxy` The proxy for an open window in the app. `struct DisplayProxy` A type which provides information about display hardware. --- # https://developer.apple.com/documentation/swiftui/scene/defaultwindowplacement(_:) #app-main) - SwiftUI - Scene - defaultWindowPlacement(\_:) Instance Method # defaultWindowPlacement(\_:) Defines a function used for determining the default placement of windows. nonisolated ## Parameters `makePlacement` A closure to generate the default window placement. ## Discussion Use this scene modifier to indicate a default initial size and position for a new window that the system creates from a `Scene` declaration. On macOS, you can use the screen’s bounds to place the window. For example, you can specify that the window is always placed 140 points from the bottom of the screen: struct MyApp: App { var body: some Scene { ... Window("Status", id: "status") { StatusView() } .windowResizability(.contentSize) .defaultWindowPlacement { content, context in let displayBounds = context.defaultDisplay.visibleRect let size = content.sizeThatFits(.unspecified) let position = CGPoint( x: displayBounds.midX - (size.width / 2), y: displayBounds.maxY - size.height - 140) return WindowPlacement(position: position, size: size) } } } On visionOS, the system always places the first window relative to where the person is looking. The system ignores calls to `defaultWindowPlacement(_:)`. You can place any subsequent windows relative to existing ones by returning one of the methods defined by `WindowPlacement.Position` with the existing window. For example, you can align the new window with the trailing edge of the `Content` window: struct MyApp: App { @Environment(\.openWindow) private var openWindow var body: some Scene { WindowGroup("Content", id: "content") { Button("Open status window") { openWindow(id: "status") } } WindowGroup("Status", id: "status") { StatusView() } .windowResizability(.contentSize) .defaultWindowPlacement { content, context in if let contentWindow = context.windows.first( where: { $0.id == "content" }) { WindowPlacement(.trailing(contentWindow)) } else { WindowPlacement() } } } } The placement that your function returns acts as a default for when the window first appears. People can later resize and move the window using interface controls that the system provides. Also, during state restoration, the system restores the window to it’s most recent size and position, rather than the default placement. For more information on configuring how scenes behave with state restoration, see `Scene.stateRestoration(_:)`. ## See Also ### Positioning a window Sets a default position for a window. `struct WindowLevel` The level of a window. Sets the window level of this scene. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. `struct WindowPlacement` A type which represents a preferred size and position for a window. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct WindowProxy` The proxy for an open window in the app. `struct DisplayProxy` A type which provides information about display hardware. --- # https://developer.apple.com/documentation/swiftui/scene/windowidealplacement(_:) #app-main) - SwiftUI - Scene - windowIdealPlacement(\_:) Instance Method # windowIdealPlacement(\_:) Provides a function which determines a placement to use when windows of a scene zoom. nonisolated ## Parameters `makePlacement` A closure which returns the ideal placement for a window derived from this scene. ## Discussion The default behavior will size the window to its maximum size, or the bounds of the display, whichever is smaller. By overriding this behavior, you can provide a size that is appropriate for the contents of your window. For example, you can provide a placement with a height equal to the display bounds, and a width based on your content’s ideal width: struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } .windowIdealPlacement { content, context in let displayBounds = context.defaultDisplay.visibleRect let proposal = ProposedViewSize( width: nil, height: displayBounds.height) let contentSize = content.sizeThatFits(proposal) return .init( width: contentSize.width, height: contentSize.height) } } } ## See Also ### Positioning a window Sets a default position for a window. `struct WindowLevel` The level of a window. Sets the window level of this scene. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. `struct WindowPlacement` A type which represents a preferred size and position for a window. Defines a function used for determining the default placement of windows. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct WindowProxy` The proxy for an open window in the app. `struct DisplayProxy` A type which provides information about display hardware. --- # https://developer.apple.com/documentation/swiftui/windowplacementcontext - SwiftUI - WindowPlacementContext Structure # WindowPlacementContext A type which represents contextual information used for sizing and positioning windows. struct WindowPlacementContext ## Overview The placement context provides information to be used when providing a new placement via the closure provided to the `defaultWindowPlacement(_:)` modifier. ## Topics ### Instance Properties `var defaultDisplay: DisplayProxy` The display on which new windows will be presented by default. [`var windows: [WindowProxy]`](https://developer.apple.com/documentation/swiftui/windowplacementcontext/windows) The list of current active scenes ## See Also ### Positioning a window Sets a default position for a window. `struct WindowLevel` The level of a window. Sets the window level of this scene. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. `struct WindowPlacement` A type which represents a preferred size and position for a window. Defines a function used for determining the default placement of windows. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowProxy` The proxy for an open window in the app. `struct DisplayProxy` A type which provides information about display hardware. --- # https://developer.apple.com/documentation/swiftui/windowproxy - SwiftUI - WindowProxy Structure # WindowProxy The proxy for an open window in the app. struct WindowProxy ## Topics ### Instance Properties `var id: String?` The ID for the window, if one was provided. `var phase: ScenePhase` The window’s current `ScenePhase`. ## See Also ### Positioning a window Sets a default position for a window. `struct WindowLevel` The level of a window. Sets the window level of this scene. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. `struct WindowPlacement` A type which represents a preferred size and position for a window. Defines a function used for determining the default placement of windows. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct DisplayProxy` A type which provides information about display hardware. --- # https://developer.apple.com/documentation/swiftui/displayproxy - SwiftUI - DisplayProxy Structure # DisplayProxy A type which provides information about display hardware. struct DisplayProxy ## Overview You can use this type with your custom window layouts to size and position windows relative to a display’s bounds. For example, your custom window layout can position a window 140 points from the bottom of the screen’s visible area: Window("Status", id: "status") { StatusView() } .windowResizability(.contentSize) .defaultWindowPlacement { content, context in let displayBounds = context.defaultDisplay.visibleRect let size = content.sizeThatFits(.unspecified) let position = CGPoint( x: displayBounds.midX - (size.width / 2), y: displayBounds.maxY - size.height - 140) return WindowPlacement(position: position, size: size) } ## Topics ### Instance Properties `let bounds: CGRect` The full dimensions of the display, including any space occupied by system interface elements. `let safeAreaInsets: EdgeInsets` The safe area inset of this display. `let visibleRect: CGRect` The portion of the display where it is safe to place windows. ## Relationships ### Conforms To - `Equatable` ## See Also ### Positioning a window Sets a default position for a window. `struct WindowLevel` The level of a window. Sets the window level of this scene. `struct WindowLayoutRoot` A proxy which represents the root contents of a window. `struct WindowPlacement` A type which represents a preferred size and position for a window. Defines a function used for determining the default placement of windows. Provides a function which determines a placement to use when windows of a scene zoom. `struct WindowPlacementContext` A type which represents contextual information used for sizing and positioning windows. `struct WindowProxy` The proxy for an open window in the app. --- # https://developer.apple.com/documentation/swiftui/windowvisibilitytoggle - SwiftUI - WindowVisibilityToggle Structure # WindowVisibilityToggle A specialized button for toggling the visibility of a window. ## Overview This is most commonly used in the main menu, where it can toggle the visibility of `Window` and `UtilityWindow` windows. The default label uses the title of the window in the format of “Show ” and “Hide ” depending on the current visibility of the window. A keyboard shortcut can be assigned to this button. The below example demonstrates how a main menu can be constructed with visibility buttons, replacing the default commands added by `Window` and `Utility Window`: struct PhotoEditor: App { var body: some Scene { WindowGroup { PhotoEditor() } .commands { CommandGroup(before: .textFormatting) { Section { WindowVisibilityToggle(windowID: "formatting") .keyboardShortcut("t", modifiers: [.command, .shift]) // other custom/image formatting controls } } CommandGroup(before: .sidebar) { Section { WindowVisibilityToggle(windowID: "photo-library") // other controls for showing/hiding UI } } } UtilityWindow("Formatting Style", id: "formatting") { TextAndImageFormatForm() } .commandsRemoved() Window("Photo Library", id: "photo-library") { PhotoInfoViewer() } .commandsRemoved() } } ## Topics ### Creating a window visibility toggle `init(windowID: String)` Create a window visibility toggle to alter the visibility of a specific window. ### Supporting types `struct DefaultWindowVisibilityToggleLabel` The default label of a window visibility toggle. ## Relationships ### Conforms To - `View` ## See Also ### Configuring window visibility Sets the default launch behavior for this scene. Sets the restoration behavior for this scene. `struct SceneLaunchBehavior` The launch behavior for a scene. `struct SceneRestorationBehavior` The restoration behavior for a scene. Sets the preferred visibility of the non-transient system views overlaying the app. Configures the visibility of the window toolbar when the window enters full screen mode. `struct WindowToolbarFullScreenVisibility` The visibility of the window toolbar with respect to full screen mode. --- # https://developer.apple.com/documentation/swiftui/scene/defaultlaunchbehavior(_:) #app-main) - SwiftUI - Scene - defaultLaunchBehavior(\_:) Instance Method # defaultLaunchBehavior(\_:) Sets the default launch behavior for this scene. nonisolated ## Discussion This behavior can be used to define if a scene is shown on application launch in the absence of any previously saved state. On platforms that do not support multiple windows, this value is ignored. On platforms other than macOS, there must be at least one scene that presents itself. If no scenes are defined to present, the first scene will be presented, regardless of the value provided to this modifier. On macOS, this behavior will also be used to determine which scene is presented when clicking on the icon of a running application with no visible windows. On visionOS, the system may background the last dismissed scene instead of closing it. Thus, the suppressed behavior additionally specifies that the scene should not be presented when tapping on the application icon with no visible windows. For example, you may wish to present a welcome window on launch of your app when there are no previous document windows being restored: @main struct MyApp: App { var body: some Scene { DocumentGroup(newDocument: MyDocument()) { configuration in DocumentEditor(configuration.$document) } Window("Welcome to My App", id: "welcome") { WelcomeView() } .defaultLaunchBehavior(.presented) } } The default value for all scenes if you do not apply this modifier is `automatic`. With that strategy, a scene will only present itself if it is the first scene defined by the app, and no other scenes have presented themselves. ## See Also ### Configuring window visibility `struct WindowVisibilityToggle` A specialized button for toggling the visibility of a window. Sets the restoration behavior for this scene. `struct SceneLaunchBehavior` The launch behavior for a scene. `struct SceneRestorationBehavior` The restoration behavior for a scene. Sets the preferred visibility of the non-transient system views overlaying the app. Configures the visibility of the window toolbar when the window enters full screen mode. `struct WindowToolbarFullScreenVisibility` The visibility of the window toolbar with respect to full screen mode. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/scene/restorationbehavior(_:) #app-main) - SwiftUI - Scene - restorationBehavior(\_:) Instance Method # restorationBehavior(\_:) Sets the restoration behavior for this scene. nonisolated ## Discussion Use this scene modifier to apply a value of this type to a `Scene` you define in your `App` declaration. The value you specify determines how the system will restore windows from a previous run of your application. For example, you may have a scene that you do not wish to be restored on launch: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } Window(id: "network-test", "Network Connection Test") { NetworkTestView() } .restorationBehavior(.disabled) } } The default value for all scenes if you do not apply the modifier is `automatic`. With that strategy, scenes will restore themselves depending on the default behavior for the platform. ## See Also ### Configuring window visibility `struct WindowVisibilityToggle` A specialized button for toggling the visibility of a window. Sets the default launch behavior for this scene. `struct SceneLaunchBehavior` The launch behavior for a scene. `struct SceneRestorationBehavior` The restoration behavior for a scene. Sets the preferred visibility of the non-transient system views overlaying the app. Configures the visibility of the window toolbar when the window enters full screen mode. `struct WindowToolbarFullScreenVisibility` The visibility of the window toolbar with respect to full screen mode. --- # https://developer.apple.com/documentation/swiftui/scenelaunchbehavior - SwiftUI - SceneLaunchBehavior Structure # SceneLaunchBehavior The launch behavior for a scene. struct SceneLaunchBehavior ## Overview Use the `defaultLaunchBehavior(_:)` modifier to apply a value of this type to a `Scene` you specify in your `App`. The value you specify determines how the system will present the scene in the absense of any previously restored scenes on launch of your application. For example, you may wish to present a welcome window on launch of your app when there are no previous document windows being restored: @main struct MyApp: App { var body: some Scene { DocumentGroup(newDocument: MyDocument()) { configuration in DocumentEditor(configuration.$document) } Window("Welcome to My App", id: "welcome") { WelcomeView() } .defaultLaunchBehavior(.presented) } } ## Topics ### Type Properties `static let automatic: SceneLaunchBehavior` The automatic behavior. `static let presented: SceneLaunchBehavior` The presented behavior. The scene will present itself in the absence of any previously restored scenes. `static let suppressed: SceneLaunchBehavior` The suppressed behavior. The scene will not present itself in the absence of any previously restored scenes. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Configuring window visibility `struct WindowVisibilityToggle` A specialized button for toggling the visibility of a window. Sets the default launch behavior for this scene. Sets the restoration behavior for this scene. `struct SceneRestorationBehavior` The restoration behavior for a scene. Sets the preferred visibility of the non-transient system views overlaying the app. Configures the visibility of the window toolbar when the window enters full screen mode. `struct WindowToolbarFullScreenVisibility` The visibility of the window toolbar with respect to full screen mode. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/scenerestorationbehavior - SwiftUI - SceneRestorationBehavior Structure # SceneRestorationBehavior The restoration behavior for a scene. struct SceneRestorationBehavior ## Overview Use the `restorationBehavior(_:)` scene modifier to apply a value of this type to a `Scene` you define in your `App` declaration. The value you specify determines how the system will restore windows from a previous run of your application. For example, you may have a scene that you do not wish to be restored on launch: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } Window(id: "network-test", "Network Connection Test") { NetworkTestView() } .restorationBehavior(.disabled) } } ## Topics ### Type Properties `static let automatic: SceneRestorationBehavior` The automatic behavior. The scene’s windows will be restored as defined by the underlying platform. `static let disabled: SceneRestorationBehavior` The disabled behavior. The scene’s windows will not be restored. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Configuring window visibility `struct WindowVisibilityToggle` A specialized button for toggling the visibility of a window. Sets the default launch behavior for this scene. Sets the restoration behavior for this scene. `struct SceneLaunchBehavior` The launch behavior for a scene. Sets the preferred visibility of the non-transient system views overlaying the app. Configures the visibility of the window toolbar when the window enters full screen mode. `struct WindowToolbarFullScreenVisibility` The visibility of the window toolbar with respect to full screen mode. --- # https://developer.apple.com/documentation/swiftui/scene/persistentsystemoverlays(_:) #app-main) - SwiftUI - Scene - persistentSystemOverlays(\_:) Instance Method # persistentSystemOverlays(\_:) Sets the preferred visibility of the non-transient system views overlaying the app. nonisolated ## Discussion Use this modifier to influence the appearance of system overlays in your app. The behavior varies by platform. In iOS, the following example hides every persistent system overlay. In visionOS 2 and later, the SharePlay Indicator hides if the scene is shared through SharePlay, or not shared at all. During screen sharing, the indicator always remains visible. The Home indicator doesn’t appear without specific user intent when you set visibility to `hidden`. For a `WindowGroup`, the modifier affects the visibility of the window chrome. For an `ImmersiveSpace`, it affects the Home indicator. struct ImmersiveView: View { var body: some View { Text("Maximum immersion") .persistentSystemOverlays(.hidden) } } Affected non-transient system views can include, but are not limited to: - The Home indicator. - The SharePlay indicator. - The Multitasking Controls button and Picture in Picture on iPad. ## See Also ### Configuring window visibility `struct WindowVisibilityToggle` A specialized button for toggling the visibility of a window. Sets the default launch behavior for this scene. Sets the restoration behavior for this scene. `struct SceneLaunchBehavior` The launch behavior for a scene. `struct SceneRestorationBehavior` The restoration behavior for a scene. Configures the visibility of the window toolbar when the window enters full screen mode. `struct WindowToolbarFullScreenVisibility` The visibility of the window toolbar with respect to full screen mode. --- # https://developer.apple.com/documentation/swiftui/view/windowtoolbarfullscreenvisibility(_:) #app-main) - SwiftUI - View - windowToolbarFullScreenVisibility(\_:) Instance Method # windowToolbarFullScreenVisibility(\_:) Configures the visibility of the window toolbar when the window enters full screen mode. nonisolated ## Parameters `visibility` The visibility to use for the window toolbar in full screen mode. ## Discussion By default, the window toolbar will show at the top of the display, above the window’s contents. You can use this modifier to override the default behavior. For example, you can specify that the window toolbar should be hidden by default, and only show once the mouse moves into the area occupied by the menu bar: struct RootView: View { var body: some View { ContentView() .toolbar { ... } .windowToolbarFullScreenVisibility(.onHover) } } ## See Also ### Configuring window visibility `struct WindowVisibilityToggle` A specialized button for toggling the visibility of a window. Sets the default launch behavior for this scene. Sets the restoration behavior for this scene. `struct SceneLaunchBehavior` The launch behavior for a scene. `struct SceneRestorationBehavior` The restoration behavior for a scene. Sets the preferred visibility of the non-transient system views overlaying the app. `struct WindowToolbarFullScreenVisibility` The visibility of the window toolbar with respect to full screen mode. --- # https://developer.apple.com/documentation/swiftui/windowtoolbarfullscreenvisibility - SwiftUI - WindowToolbarFullScreenVisibility Structure # WindowToolbarFullScreenVisibility The visibility of the window toolbar with respect to full screen mode. struct WindowToolbarFullScreenVisibility ## Overview Use values of this type in conjunction with the `windowToolbarFullScreenVisibility(_:)` modifier to configure how the window toolbar displays itself when the window enters full screen mode. For example, you can specify that the window toolbar should be hidden by default, and only show when the mouse moves into the area occupied by the menu bar: struct RootView: View { var body: some View { ContentView() .toolbar { ... } .windowToolbarFullScreenVisibility(.onHover) } } ## Topics ### Type Properties `static let automatic: WindowToolbarFullScreenVisibility` The window toolbar visibility will be defined by the system default behavior. `static let onHover: WindowToolbarFullScreenVisibility` Hide the window toolbar in full screen mode by default. It will reveal itself when the mouse moves into the area occupied by the menu bar. `static let visible: WindowToolbarFullScreenVisibility` Prefer to show window toolbar when the window is in full screen mode. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Configuring window visibility `struct WindowVisibilityToggle` A specialized button for toggling the visibility of a window. Sets the default launch behavior for this scene. Sets the restoration behavior for this scene. `struct SceneLaunchBehavior` The launch behavior for a scene. `struct SceneRestorationBehavior` The restoration behavior for a scene. Sets the preferred visibility of the non-transient system views overlaying the app. Configures the visibility of the window toolbar when the window enters full screen mode. --- # https://developer.apple.com/documentation/swiftui/windowmanagerrole - SwiftUI - WindowManagerRole Structure # WindowManagerRole Options for defining how a scene’s windows behave when used within a managed window context, such as full screen mode and Stage Manager. struct WindowManagerRole ## Overview Use values of this type in conjunction with the `windowManagerRole(_:)` modifier to override the default system behavior. For example, you can specify that a secondary `Window` scene should use the principal role for full screen and Stage Manager: struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } Window("Organizer", id: "organizer") { OrganizerView() } .windowManagerRole(.principal) } } ## Topics ### Type Properties `static let associated: WindowManagerRole` The associated role. Windows derived from this scene can be shown alongside windows with a `.principal` role in either full screen or Stage Manager, but do not participate in those modes on their own. `static let automatic: WindowManagerRole` The automatic role. The type and configuration of the scene will be used to determine how its windows behave in full screen and Stage Manager. `static let principal: WindowManagerRole` The principal role. Windows derived from this scene will show in full screen, if enabled, or in Stage Manager. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Managing window behavior Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. `struct WindowInteractionBehavior` Options for enabling and disabling window interaction behaviors. Configures the dismiss functionality for the window enclosing `self`. Configures the full screen functionality for the window enclosing `self`. Configures the minimize functionality for the window enclosing `self`. Configures the resize functionality for the window enclosing `self`. Configures the behavior of dragging a window by its background. --- # https://developer.apple.com/documentation/swiftui/scene/windowmanagerrole(_:) #app-main) - SwiftUI - Scene - windowManagerRole(\_:) Instance Method # windowManagerRole(\_:) Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. nonisolated ## Discussion By default, the type of `Scene` and its placement within the app’s definition will determine the behavior of its windows within a window management context. You can use this modifier to override the default behaivor. For example, you can specify that a secondary `Window` scene should use the principal behavior for full screen and Stage Manager: struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } Window("Organizer", id: "organizer") { OrganizerView() } .windowManagerRole(.principal) } } ## See Also ### Managing window behavior `struct WindowManagerRole` Options for defining how a scene’s windows behave when used within a managed window context, such as full screen mode and Stage Manager. `struct WindowInteractionBehavior` Options for enabling and disabling window interaction behaviors. Configures the dismiss functionality for the window enclosing `self`. Configures the full screen functionality for the window enclosing `self`. Configures the minimize functionality for the window enclosing `self`. Configures the resize functionality for the window enclosing `self`. Configures the behavior of dragging a window by its background. --- # https://developer.apple.com/documentation/swiftui/windowinteractionbehavior - SwiftUI - WindowInteractionBehavior Structure # WindowInteractionBehavior Options for enabling and disabling window interaction behaviors. struct WindowInteractionBehavior ## Overview Use values of this type in conjunction with the following view and scene modifiers to adjust the supported functionality for the window: - `windowDismissBehavior(_:)` - `windowMinimizeBehavior(_:)` - `windowFullScreenBehavior(_:)` - `windowResizeBehavior(_:)` - `windowBackgroundDragBehavior(_:)` For example, you can create a custom “About” window which only allows for dismissal: struct MyApp: App { var body: some Scene { ... Window("About MyApp", id: "about") { AboutView() .windowMinimizeBehavior(.disabled) .windowResizeBehavior(.disabled) } .windowResizability(.contentSize) } } ## Topics ### Type Properties `static let automatic: WindowInteractionBehavior` The automatic behavior. The associated window behavior will be enabled or disabled depending on the configuration of the enclosing `Scene`. `static let disabled: WindowInteractionBehavior` The disabled behavior. The associated window interaction behavior will be disabled. `static let enabled: WindowInteractionBehavior` The enabled behavior. The associated window interaction behavior will be enabled. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Managing window behavior `struct WindowManagerRole` Options for defining how a scene’s windows behave when used within a managed window context, such as full screen mode and Stage Manager. Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. Configures the dismiss functionality for the window enclosing `self`. Configures the full screen functionality for the window enclosing `self`. Configures the minimize functionality for the window enclosing `self`. Configures the resize functionality for the window enclosing `self`. Configures the behavior of dragging a window by its background. --- # https://developer.apple.com/documentation/swiftui/view/windowdismissbehavior(_:) #app-main) - SwiftUI - View - windowDismissBehavior(\_:) Instance Method # windowDismissBehavior(\_:) Configures the dismiss functionality for the window enclosing `self`. nonisolated ## Parameters `behavior` The dismiss behavior. ## Discussion By default, the window dismiss functionality is determined by the scene, as well as any modifiers applied to it. You can use this modifier to override the default behavior. For example, you can create a welcome workflow window which disables the dismiss functionality: struct MyApp: App { var body: some Scene { ... Window("Welcome", id: "welcome") { WelcomeView() .windowDismissBehavior(.disabled) } } } ## See Also ### Managing window behavior `struct WindowManagerRole` Options for defining how a scene’s windows behave when used within a managed window context, such as full screen mode and Stage Manager. Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. `struct WindowInteractionBehavior` Options for enabling and disabling window interaction behaviors. Configures the full screen functionality for the window enclosing `self`. Configures the minimize functionality for the window enclosing `self`. Configures the resize functionality for the window enclosing `self`. Configures the behavior of dragging a window by its background. --- # https://developer.apple.com/documentation/swiftui/view/windowfullscreenbehavior(_:) #app-main) - SwiftUI - View - windowFullScreenBehavior(\_:) Instance Method # windowFullScreenBehavior(\_:) Configures the full screen functionality for the window enclosing `self`. nonisolated ## Parameters `behavior` The full screen behavior. ## Discussion By default, the window full screen functionality is determined by the scene, as well as any modifiers applied to it. Additionally, when using the `windowResizability(_:)` modifier, the maximum size of the window’s contents will also determine whether a window can be made full screen. You can use this modifier to override the default behavior. For example, you can specify that a window cannot enter full screen mode: struct MyApp: App { var body: some Scene { WindowGroup { ContentView() .windowFullScreenBehavior(.disabled) } } } ## See Also ### Managing window behavior `struct WindowManagerRole` Options for defining how a scene’s windows behave when used within a managed window context, such as full screen mode and Stage Manager. Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. `struct WindowInteractionBehavior` Options for enabling and disabling window interaction behaviors. Configures the dismiss functionality for the window enclosing `self`. Configures the minimize functionality for the window enclosing `self`. Configures the resize functionality for the window enclosing `self`. Configures the behavior of dragging a window by its background. --- # https://developer.apple.com/documentation/swiftui/view/windowminimizebehavior(_:) #app-main) - SwiftUI - View - windowMinimizeBehavior(\_:) Instance Method # windowMinimizeBehavior(\_:) Configures the minimize functionality for the window enclosing `self`. nonisolated ## Parameters `behavior` The resize behavior. ## Discussion On macOS, windows which support being minimized will move into the Dock when the minimize button is clicked, or the corresponding menu item is selected. By default, the window minimize functionality is determined by the scene, as well as any modifiers applied to it. You can use this modifier to override the default behavior. For example, you can create a custom “About” window which disables the minimize functionality: struct MyApp: App { var body: some Scene { ... Window("About MyApp", id: "about") { AboutView() .windowResizeBehavior(.disabled) .windowMinimizeBehavior(.disabled) } .windowResizability(.contentSize) } } ## See Also ### Managing window behavior `struct WindowManagerRole` Options for defining how a scene’s windows behave when used within a managed window context, such as full screen mode and Stage Manager. Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. `struct WindowInteractionBehavior` Options for enabling and disabling window interaction behaviors. Configures the dismiss functionality for the window enclosing `self`. Configures the full screen functionality for the window enclosing `self`. Configures the resize functionality for the window enclosing `self`. Configures the behavior of dragging a window by its background. --- # https://developer.apple.com/documentation/swiftui/view/windowresizebehavior(_:) #app-main) - SwiftUI - View - windowResizeBehavior(\_:) Instance Method # windowResizeBehavior(\_:) Configures the resize functionality for the window enclosing `self`. nonisolated ## Parameters `behavior` The resize behavior. ## Discussion By default, the window resizability functionality is determined by the scene, as well as any modifiers applied to it. Additionally, when using the `windowResizability(_:)` modifier, the minimum and maximum size of the window’s contents will also determine the resizability behavior. You can use this modifier to override the default behavior. For example, you can create a custom “About” window which only allows for dismissal: struct MyApp: App { var body: some Scene { ... Window("About MyApp", id: "about") { AboutView() .windowResizeBehavior(.disabled) .windowMinimizeBehavior(.disabled) } .windowResizability(.contentSize) } } ## See Also ### Managing window behavior `struct WindowManagerRole` Options for defining how a scene’s windows behave when used within a managed window context, such as full screen mode and Stage Manager. Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. `struct WindowInteractionBehavior` Options for enabling and disabling window interaction behaviors. Configures the dismiss functionality for the window enclosing `self`. Configures the full screen functionality for the window enclosing `self`. Configures the minimize functionality for the window enclosing `self`. Configures the behavior of dragging a window by its background. --- # https://developer.apple.com/documentation/swiftui/scene/windowbackgrounddragbehavior(_:) #app-main) - SwiftUI - Scene - windowBackgroundDragBehavior(\_:) Instance Method # windowBackgroundDragBehavior(\_:) Configures the behavior of dragging a window by its background. nonisolated ## Parameters `behavior` The behavior of dragging the modified window by its background. ## Return Value A scene configured with the specified behavior of dragging it by its background background. ## Discussion By default, or when you apply the `automatic` behavior, the system will determine the best suitable behavior based on the configuration of the modified scene. You can use this modifier to override the default behavior. For example, to always enable dragging a window by its background: struct MyApp: App { var body: some Scene { Window("About MyApp", id: "about") { AboutView() } .windowBackgroundDragBehavior(.enabled) } } If you want to let your users drag your window by a specific view instead of (or in addition to) letting them drag it by its background, use `WindowDragGesture`. Applying the `enabled` behavior is equivalent to adding a `WindowDragGesture` to the window’s background view. ## See Also ### Managing window behavior `struct WindowManagerRole` Options for defining how a scene’s windows behave when used within a managed window context, such as full screen mode and Stage Manager. Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. `struct WindowInteractionBehavior` Options for enabling and disabling window interaction behaviors. Configures the dismiss functionality for the window enclosing `self`. Configures the full screen functionality for the window enclosing `self`. Configures the minimize functionality for the window enclosing `self`. Configures the resize functionality for the window enclosing `self`. --- # https://developer.apple.com/documentation/swiftui/view/onvolumeviewpointchange(updatestrategy:initial:_:) #app-main) - SwiftUI - View - onVolumeViewpointChange(updateStrategy:initial:\_:) Instance Method # onVolumeViewpointChange(updateStrategy:initial:\_:) Adds an action to perform when the viewpoint of the volume changes. @MainActor @preconcurrency func onVolumeViewpointChange( updateStrategy: VolumeViewpointUpdateStrategy = .supported, initial: Bool = true, ## Parameters `updateStrategy` Whether the action should be run for all viewpoint changes or only for supported viewpoint changes. `initial` Whether the action should be run when this view initially appears. `action` A closure to run when the viewpoint changes. The closure is also run when the volume is first opened if `initial` is `true`. ## Discussion Use the provided `Viewpoint3D` to update the content of the volume: struct RobotContentView: View { @State var robotRotation: Rotation3D = .identity var body: some View { Model3D(named: "robot") .onVolumeViewpointChange { _, newValue in robotRotation = Rotation3D.slerp( from: robotRotation, to: newValue.squareAzimuth.orientation, t: 1.0, along: .shortest ) } .rotation3DEffect(robotRotation) .animation(.easeInOut, value: robotRotation) } } By default, the action will only be run when the new viewpoint is equivalent to one of the values provided through `supportedVolumeViewpoints(_:)`. The viewpoint will be equivalent to where the window bar and ornaments are presented for a volume. Providing `.all` for the `updateStrategy` argument will result in the action being called without regard to the supported viewpoints. To determine if the volume is being viewed from an unsupported viewpoint, provide `.all` for the `updateStrategy` argument and check if the viewpoint is not within the supported viewpoints: struct ContentView: View { @State var showingMoveToFrontSign = false @State var moveToFrontSignViewpoint: Viewpoint3D = .standard let supportedViewpoints = [SquareAzimuth.front] var body: some View { MoveToFrontSignView(viewpoint: moveToFrontSignViewpoint) .opacity(showingMoveToFrontSign ? 1.0 : 0.0) .animation(.easeInOut, value: showingMoveToFrontSign) .onVolumeViewpointChange(updateStrategy: .all) { _, newValue in moveToFrontSignViewpoint = newViewpoint let isSupported = supportedViewpoints.contains( newViewpoint.squareAzimuth) showingMoveToFrontSign = !isSupported } .supportedVolumeViewpoints(supportedViewpoints) } } The old and new `Viewpoint3D` provided to the action are relative to the center of the volume. Reading this value is only valid inside a `View` that inherits the environment of a `Scene` created with a `VolumetricWindowStyle`. ## See Also ### Interacting with volumes Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/view/supportedvolumeviewpoints(_:) #app-main) - SwiftUI - View - supportedVolumeViewpoints(\_:) Instance Method # supportedVolumeViewpoints(\_:) Specifies which viewpoints are supported for the window bar and ornaments in a volume. nonisolated ## Discussion This defaults to all viewpoints and determines which viewpoints the window bar and ornaments will ‘follow’ the user to as they move around the volume. ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/volumeviewpointupdatestrategy - SwiftUI - VolumeViewpointUpdateStrategy Structure # VolumeViewpointUpdateStrategy A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. struct VolumeViewpointUpdateStrategy ## Topics ### Type Properties `static let all: VolumeViewpointUpdateStrategy` The action should be run for all viewpoint changes. `static let supported: VolumeViewpointUpdateStrategy` The action should only be run when the new viewpoint is equivalent to one of the values provided through `supportedVolumeViewpoints(_:)`. ## Relationships ### Conforms To - `Equatable` - `Sendable` - `SendableMetatype` ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/viewpoint3d - SwiftUI - Viewpoint3D Structure # Viewpoint3D A type describing what direction something is being viewed from. struct Viewpoint3D ## Topics ### Instance Properties `var squareAzimuth: SquareAzimuth` A value describing what direction something is being viewed from along the horizontal plane. ### Type Properties `static let standard: Viewpoint3D` A value that represents being viewed from the front middle. ## Relationships ### Conforms To - `CustomDebugStringConvertible` - `Equatable` - `Sendable` - `SendableMetatype` ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/squareazimuth - SwiftUI - SquareAzimuth Enumeration # SquareAzimuth A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. @frozen enum SquareAzimuth ## Topics ### Structures `struct Set` ### Enumeration Cases `case back` Has an orientation with an horizontal angle equal to `180°` `case front` Has an orientation with an horizontal angle equal to `0°`. `case left` Has an orientation with an horizontal angle equal to `270°`. `case right` Has an orientation with an horizontal angle equal to `90°`. ### Initializers `init(closestToAzimuth: Angle)` Creates a `SquareAzimuth` case with an orientation that has a horizontal angle closest to the provided azimuth. ### Instance Properties `var orientation: Rotation3D` A 3D rotation that is snapped to the center of one of the four sides. ## Relationships ### Conforms To - `BitwiseCopyable` - `CaseIterable` - `Copyable` - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/worldalignmentbehavior - SwiftUI - WorldAlignmentBehavior Structure # WorldAlignmentBehavior A type representing the world alignment behavior for a scene. struct WorldAlignmentBehavior ## Overview A value of this type can be provided to the `volumeWorldAlignment(_:)` scene modifier to control the world alignment volumes should maintain as they are repositioned. The default value is `automatic`. ## Topics ### Type Properties `static var adaptive: WorldAlignmentBehavior` When lifted above eye level, the volume will tilt so the front remains fully visible. `static var automatic: WorldAlignmentBehavior` The world alignment behavior that is standard for the system. `static var gravityAligned: WorldAlignmentBehavior` The volume will not tilt so as to remain aligned with gravity. ## Relationships ### Conforms To - `Equatable` - `Sendable` - `SendableMetatype` ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/scene/volumeworldalignment(_:) #app-main) - SwiftUI - Scene - volumeWorldAlignment(\_:) Instance Method # volumeWorldAlignment(\_:) Specifies how a volume should be aligned when moved in the world. nonisolated ## Discussion For example, you can create a volume that remains parallel to the floor even when lifted up high above eye level by applying a `gravityAligned` alignment to the scene: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } .windowStyle(.volumetric) .volumeWorldAlignment(.gravityAligned) } } The default value if you don’t apply the modifier is `automatic`. With that strategy, volumes will tilt themselves so the front remains fully visible while being repositioned. ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/worldscalingbehavior - SwiftUI - WorldScalingBehavior Structure # WorldScalingBehavior Specifies the scaling behavior a window should have within the world. struct WorldScalingBehavior ## Overview By default, a regular `WindowGroup` uses a scaling behavior of `dynamic`, and a window with `volumetric` has a fixed scale. Dynamic scale means the window will scale larger as it moves further away, maintaining the same angular size. Fixed scale means the window will keep its physical size in the world. For further information, see Spatial layout in the Human Interface Guidelines. ## Topics ### Type Properties `static var automatic: WorldScalingBehavior` The scaling behavior that is standard for the window’s style. `static var dynamic: WorldScalingBehavior` The window will scale up as it moves further away, maintaining the same angular size. ## Relationships ### Conforms To - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/scene/defaultworldscaling(_:) #app-main) - SwiftUI - Scene - defaultWorldScaling(\_:) Instance Method # defaultWorldScaling(\_:) Specify the world scaling behavior for the window. nonisolated ## Discussion By default, regular windows increase their physical size as they move further away, ensuring they remain at the same angular size. This preserves legibility and ease of use for text and controls. Volumes render with a fixed physical size, because they are most commonly used for 3D content which is meant to behave with greater physical accuracy. This modifier overrides the physical scaling behavior for volumes, so they scale like windows while still maintaining other volumetric behaviors. This modifier has no effect on immersive spaces or windows without a window style of `volumetric`. @main struct SampleApp: App { var body: some Scene { WindowGroup { ContentView() } .windowStyle(.volumetric) .defaultWorldScaling(.dynamic) } } For further information, see Spatial layout in the Human Interface Guidelines. ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/worldscalingcompensation - SwiftUI - WorldScalingCompensation Structure # WorldScalingCompensation Indicates whether returned metrics will take dynamic scaling into account. struct WorldScalingCompensation ## Overview On visionOS, a window scene or a volume scene with the `defaultWorldScaling(_:)` modifier may scale dynamically when the user repositions it. In those cases, the metrics returned by a `PhysicalMetric` or `PhysicalMetricsConverter` value may or may not correspond to the units of a `RealityView`. World scale compensation lets you specify if this scaling is taken into account. If the values are `unscaled`, they will correspond to the physical metrics of the user’s surroundings, regardless of dynamic scale. If `scaled`, they will be scaled appropriately for the scene, which means they will match the default coordinate system of a `RealityView` in that scene. ## Topics ### Type Properties `static let scaled: WorldScalingCompensation` Returns metrics that are scaled appropriately to match the coordinate system of their scene, including any world scaling behavior. `static let unscaled: WorldScalingCompensation` Returns metrics that match the scale of the user’s surroundings, regardless of the world scaling behavior of their scene. ## Relationships ### Conforms To - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta --- # https://developer.apple.com/documentation/swiftui/environmentvalues/worldtrackinglimitations - SwiftUI - EnvironmentValues - worldTrackingLimitations Instance Property # worldTrackingLimitations The current limitations of the device tracking the user’s surroundings. ## Discussion Read this environment value from within a view to obtain the current limitations of the device tracking the user’s surroundings. The device’s capabilities may be limited due to physical circumstances such as the lighting. If any of the limitations occur due to changing circumstances, the set is updated accordingly. For example, the following `Text` view automatically updates when the world tracking limitations change: @Environment(\.worldTrackingLimitations) private var worldTrackingLimitations var body: some View { Text("Can track translation?" + worldTrackingLimitations .contains(.translation) ? "No" : "Yes") } When the device’s world tracking capabilities are limited, don’t prevent the user from experiencing your app entirely. Instead, try to adapt the user experience to the current circumstances in order to provide a meaningful experience at all times. ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/worldtrackinglimitation - SwiftUI - WorldTrackingLimitation Structure # WorldTrackingLimitation A structure to represent limitations of tracking the user’s surroundings. struct WorldTrackingLimitation ## Overview You receive a set of world tracking limitations when you read the `worldTrackingLimitations` environment value. The value tells you which limitations the device currently is facing. If any of the limitations occur due to changing circumstances, e.g., the lighting, the set is updated accordingly. For example, the following `Text` view automatically updates when the world tracking limitations change: @Environment(\.worldTrackingLimitations) private var worldTrackingLimitations var body: some View { Text("Can track translation?" + worldTrackingLimitations .contains(.translation) ? "No" : "Yes") } ## Topics ### Type Properties `static let orientation: WorldTrackingLimitation` The device capabilities of tracking orientation changes in all dimensions are currently limited. `static let translation: WorldTrackingLimitation` The device capabilities of tracking translation changes in all dimensions are currently limited. ## Relationships ### Conforms To - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct SurfaceSnappingInfo` A type representing information about the window scenes snap state. Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/surfacesnappinginfo - SwiftUI - SurfaceSnappingInfo Beta Structure # SurfaceSnappingInfo A type representing information about the window scenes snap state. struct SurfaceSnappingInfo ## Overview Use the provided `SurfaceSnappingInfo` to modify the contents of your view. struct LightFixtureView: View { @Environment(\.surfaceSnappingInfo) var snappingInfo: SurfaceSnappingInfo var body: some View { if snappingInfo.isSnapped { switch SurfaceSnappingInfo.authorizationStatus { case .authorized: switch snappingInfo.classification { case .table: LampView() case .floor: FloorLampView() default: DefaultLampView() } default: DefaultLampView() } } else { FloatingOrbLampView() } } } The bottom of volumes may snap to horizontal surfaces and the back of windows may snap to vertical surfaces. ## Topics ### Instance Properties `var classification: SurfaceClassification?` A type that provides information about the surface classification the scene is snapped to. This property only has a value if the scene is snapped and `authorizationStatus` is `.authorized`. `var isSnapped: Bool` A value that represents whether the scene is currently snapped to a physical surface or not. ### Type Properties `static var authorizationStatus: SurfaceSnappingInfo.AuthorizationStatus` A value that represents whether the user has authorized providing more detailed information about the surface scenes are snapped to. To request this detailed surface information, in your `Info.plist` file, set `UIWantsDetailedSurfaceInfo` to `YES` and set `NSWorldSensingUsageDescription` to provide a description of why your app is requesting this information. ### Enumerations `enum AuthorizationStatus` A type representing whether the user has granted permissions to provide more detailed information about the surface a scene is snapped to. ## Relationships ### Conforms To - `CustomDebugStringConvertible` - `Equatable` - `Sendable` - `SendableMetatype` ## See Also ### Interacting with volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. `struct VolumeViewpointUpdateStrategy` A type describing when the action provided to `onVolumeViewpointChange(updateStrategy:initial:_:)` should be called. `struct Viewpoint3D` A type describing what direction something is being viewed from. `enum SquareAzimuth` A type describing what direction something is being viewed from along the horizontal plane and snapped to 4 directions. `struct WorldAlignmentBehavior` A type representing the world alignment behavior for a scene. Specifies how a volume should be aligned when moved in the world. `struct WorldScalingBehavior` Specifies the scaling behavior a window should have within the world. Specify the world scaling behavior for the window. `struct WorldScalingCompensation` Indicates whether returned metrics will take dynamic scaling into account. The current limitations of the device tracking the user’s surroundings. `struct WorldTrackingLimitation` A structure to represent limitations of tracking the user’s surroundings. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/controlactivestate - SwiftUI - ControlActiveState Deprecated Enumeration # ControlActiveState The active appearance expected of controls in a window. macOS 10.15–26.0Deprecated enum ControlActiveState ## Overview `ControlActiveState` and `EnvironmentValues.controlActiveState` are deprecated, use `EnvironmentValues.appearsActive` instead. ## Topics ### Getting control active states `case key` `case active` `case inactive` ## Relationships ### Conforms To - `CaseIterable` - `Copyable` - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` --- # https://developer.apple.com/documentation/swiftui/windowgroup), --- # https://developer.apple.com/documentation/swiftui/window) --- # https://developer.apple.com/documentation/swiftui/scene/windowstyle(_:)) --- # https://developer.apple.com/documentation/swiftui/scene/defaultposition(_:)). --- # https://developer.apple.com/documentation/swiftui/view/presentedwindowstyle(_:)) --- # https://developer.apple.com/documentation/swiftui/customizing-window-styles-and-state-restoration-behavior-in-macos) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/bringing_multiple_windows_to_your_swiftui_app) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/windowgroup) --- # https://developer.apple.com/documentation/swiftui/utilitywindow) --- # https://developer.apple.com/documentation/swiftui/windowstyle) --- # https://developer.apple.com/documentation/swiftui/scene/windowtoolbarstyle(_:)) --- # https://developer.apple.com/documentation/swiftui/scene/windowtoolbarlabelstyle(_:)) --- # https://developer.apple.com/documentation/swiftui/scene/windowtoolbarlabelstyle(fixed:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/windowtoolbarstyle) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/supportsmultiplewindows) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/environmentvalues/openwindow) --- # https://developer.apple.com/documentation/swiftui/openwindowaction) --- # https://developer.apple.com/documentation/swiftui/pushwindowaction) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/dismisswindow) --- # https://developer.apple.com/documentation/swiftui/dismisswindowaction) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/dismiss) --- # https://developer.apple.com/documentation/swiftui/dismissaction) --- # https://developer.apple.com/documentation/swiftui/dismissbehavior) --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(_:)) --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(width:height:)) --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(width:height:depth:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(_:in:)) --- # https://developer.apple.com/documentation/swiftui/scene/defaultsize(width:height:depth:in:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/scene/windowresizability(_:)) --- # https://developer.apple.com/documentation/swiftui/windowresizability) --- # https://developer.apple.com/documentation/swiftui/scene/windowidealsize(_:)) --- # https://developer.apple.com/documentation/swiftui/windowidealsize) --- # https://developer.apple.com/documentation/swiftui/scene/defaultposition(_:)) --- # https://developer.apple.com/documentation/swiftui/windowlevel) --- # https://developer.apple.com/documentation/swiftui/scene/windowlevel(_:)) --- # https://developer.apple.com/documentation/swiftui/windowlayoutroot) --- # https://developer.apple.com/documentation/swiftui/windowplacement) --- # https://developer.apple.com/documentation/swiftui/scene/defaultwindowplacement(_:)) --- # https://developer.apple.com/documentation/swiftui/scene/windowidealplacement(_:)) --- # https://developer.apple.com/documentation/swiftui/windowplacementcontext) --- # https://developer.apple.com/documentation/swiftui/windowproxy) --- # https://developer.apple.com/documentation/swiftui/displayproxy) --- # https://developer.apple.com/documentation/swiftui/windowvisibilitytoggle) --- # https://developer.apple.com/documentation/swiftui/scene/defaultlaunchbehavior(_:)) --- # https://developer.apple.com/documentation/swiftui/scene/restorationbehavior(_:)) --- # https://developer.apple.com/documentation/swiftui/scenelaunchbehavior) --- # https://developer.apple.com/documentation/swiftui/scenerestorationbehavior) --- # https://developer.apple.com/documentation/swiftui/scene/persistentsystemoverlays(_:)) --- # https://developer.apple.com/documentation/swiftui/view/windowtoolbarfullscreenvisibility(_:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/windowtoolbarfullscreenvisibility) --- # https://developer.apple.com/documentation/swiftui/windowmanagerrole) --- # https://developer.apple.com/documentation/swiftui/scene/windowmanagerrole(_:)) --- # https://developer.apple.com/documentation/swiftui/windowinteractionbehavior) --- # https://developer.apple.com/documentation/swiftui/view/windowdismissbehavior(_:)) --- # https://developer.apple.com/documentation/swiftui/view/windowfullscreenbehavior(_:)) --- # https://developer.apple.com/documentation/swiftui/view/windowminimizebehavior(_:)) --- # https://developer.apple.com/documentation/swiftui/view/windowresizebehavior(_:)) --- # https://developer.apple.com/documentation/swiftui/scene/windowbackgrounddragbehavior(_:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/view/onvolumeviewpointchange(updatestrategy:initial:_:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/view/supportedvolumeviewpoints(_:)) --- # https://developer.apple.com/documentation/swiftui/volumeviewpointupdatestrategy) --- # https://developer.apple.com/documentation/swiftui/viewpoint3d) --- # https://developer.apple.com/documentation/swiftui/squareazimuth) --- # https://developer.apple.com/documentation/swiftui/worldalignmentbehavior) --- # https://developer.apple.com/documentation/swiftui/scene/volumeworldalignment(_:)) --- # https://developer.apple.com/documentation/swiftui/worldscalingbehavior) --- # https://developer.apple.com/documentation/swiftui/scene/defaultworldscaling(_:)) --- # https://developer.apple.com/documentation/swiftui/worldscalingcompensation) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/worldtrackinglimitations) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/worldtrackinglimitation) --- # https://developer.apple.com/documentation/swiftui/surfacesnappinginfo) --- # https://developer.apple.com/documentation/swiftui/controlactivestate) --- # https://developer.apple.com/documentation/swiftui/navigationsplitview - SwiftUI - NavigationSplitView Structure # NavigationSplitView A view that presents views in two or three columns, where selections in leading columns control presentations in subsequent columns. ## Mentioned in Migrating to new navigation types Adding a search interface to your app ## Overview You create a navigation split view with two or three columns, and typically use it as the root view in a `Scene`. People choose one or more items in a leading column to display details about those items in subsequent columns. To create a two-column navigation split view, use the `init(sidebar:detail:)` initializer: var body: some View { NavigationSplitView { List(model.employees, selection: $employeeIds) { employee in Text(employee.name) } } detail: { EmployeeDetails(for: employeeIds) } } In the above example, the navigation split view coordinates with the `List` in its first column, so that when people make a selection, the detail view updates accordingly. Programmatic changes that you make to the selection property also affect both the list appearance and the presented detail view. To create a three-column view, use the `init(sidebar:content:detail:)` initializer. The selection in the first column affects the second, and the selection in the second column affects the third. For example, you can show a list of departments, the list of employees in the selected department, and the details about all of the selected employees: @State private var departmentId: Department.ID? // Single selection. var body: some View { NavigationSplitView { List(model.departments, selection: $departmentId) { department in Text(department.name) } } content: { if let department = model.department(id: departmentId) { List(department.employees, selection: $employeeIds) { employee in Text(employee.name) } } else { Text("Select a department") } } detail: { EmployeeDetails(for: employeeIds) } } You can also embed a `NavigationStack` in a column. Tapping or clicking a `NavigationLink` that appears in an earlier column sets the view that the stack displays over its root view. Activating a link in the same column adds a view to the stack. Either way, the link must present a data type for which the stack has a corresponding `navigationDestination(for:destination:)` modifier. On watchOS and tvOS, and with narrow sizes like on iPhone or on iPad in Slide Over, the navigation split view collapses all of its columns into a stack, and shows the last column that displays useful information. For example, the three-column example above shows the list of departments to start, the employees in the department after someone selects a department, and the employee details when someone selects an employee. For rows in a list that have `NavigationLink` instances, the list draws disclosure chevrons while in the collapsed state. ### Control column visibility You can programmatically control the visibility of navigation split view columns by creating a `State` value of type `NavigationSplitViewVisibility`. Then pass a `Binding` to that state to the appropriate initializer — such as `init(columnVisibility:sidebar:detail:)` for two columns, or the `init(columnVisibility:sidebar:content:detail:)` for three columns. The following code updates the first example above to always hide the first column when the view appears: @State private var columnVisibility = NavigationSplitViewVisibility.detailOnly var body: some View { NavigationSplitView(columnVisibility: $columnVisibility) { List(model.employees, selection: $employeeIds) { employee in Text(employee.name) } } detail: { EmployeeDetails(for: employeeIds) } } The split view ignores the visibility control when it collapses its columns into a stack. ### Collapsed split views At narrow size classes, such as on iPhone or Apple Watch, a navigation split view collapses into a single stack. Typically SwiftUI automatically chooses the view to show on top of this single stack, based on the content of the split view’s columns. For custom navigation experiences, you can provide more information to help SwiftUI choose the right column. Create a `State` value of type `NavigationSplitViewColumn`. Then pass a `Binding` to that state to the appropriate initializer, such as `init(preferredCompactColumn:sidebar:detail:)` or `init(preferredCompactColumn:sidebar:content:detail:)`. The following code shows the blue detail view when run on iPhone. When the person using the app taps the back button, they’ll see the yellow view. The value of `preferredPreferredCompactColumn` will change from `.detail` to `.sidebar`: @State private var preferredColumn = NavigationSplitViewColumn.detail var body: some View { NavigationSplitView(preferredCompactColumn: $preferredColumn) { Color.yellow } detail: { Color.blue } } ### Customize a split view To specify a preferred column width in a navigation split view, use the `navigationSplitViewColumnWidth(_:)` modifier. To set minimum, maximum, and ideal sizes for a column, use `navigationSplitViewColumnWidth(min:ideal:max:)`. You can specify a different modifier in each column. The navigation split view does its best to accommodate the preferences that you specify, but might make adjustments based on other constraints. To specify how columns in a navigation split view interact, use the `navigationSplitViewStyle(_:)` modifier with a `NavigationSplitViewStyle` value. For example, you can specify whether to emphasize the detail column or to give all of the columns equal prominence. On some platforms, `NavigationSplitView` adds a `sidebarToggle` toolbar item. Use the `toolbar(removing:)` modifier to remove the default item. ## Topics ### Creating a navigation split view Creates a two-column navigation split view. Creates a three-column navigation split view. ### Hiding columns in a navigation split view Creates a two-column navigation split view that enables programmatic control of the sidebar’s visibility. Creates a three-column navigation split view that enables programmatic control of leading columns’ visibility. ### Specifying a preferred compact column Creates a two-column navigation split view that enables programmatic control over which column appears on top when the view collapses into a single column in narrow sizes. Creates a three-column navigation split view that enables programmatic control over which column appears on top when the view collapses into a single column in narrow sizes. ### Specifying a preferred compact column and column visibility Creates a two-column navigation split view that enables programmatic control of the sidebar’s visibility in regular sizes and which column appears on top when the view collapses into a single column in narrow sizes. Creates a three-column navigation split view that enables programmatic control of leading columns’ visibility in regular sizes and which column appears on top when the view collapses into a single column in narrow sizes. ## Relationships ### Conforms To - `View` ## See Also ### Presenting views in columns Bringing robust navigation structure to your SwiftUI app Use navigation links, stacks, destinations, and paths to provide a streamlined experience for all platforms, as well as behaviors such as deep linking and state restoration. Improve navigation behavior in your app by replacing navigation views with navigation stacks and navigation split views. Sets the style for navigation split views within this view. Sets a fixed, preferred width for the column containing this view. Sets a flexible, preferred width for the column containing this view. `struct NavigationSplitViewVisibility` The visibility of the leading columns in a navigation split view. `struct NavigationLink` A view that controls a navigation presentation. --- # https://developer.apple.com/documentation/swiftui/image --- # https://developer.apple.com/documentation/swiftui/view/backgroundextensioneffect() --- # https://developer.apple.com/documentation/swiftui/landmarks-applying-a-background-extension-effect --- # https://developer.apple.com/documentation/swiftui/landmarks-extending-horizontal-scrolling-under-a-sidebar-or-inspector - SwiftUI - Landmarks: Building an app with Liquid Glass - Landmarks: Extending horizontal scrolling under a sidebar or inspector Beta Sample Code # Landmarks: Extending horizontal scrolling under a sidebar or inspector Improve your horizontal scrollbar’s appearance by extending it under a sidebar or inspector. Download Xcode 26.0+Beta ## Overview The Landmarks app lets people explore interesting sites around the world. Whether it’s a national park near their home or a far-flung location on a different continent, the app provides a way for people to organize and mark their adventures and receive custom activity badges along the way. This sample demonstrates how to extend horizontal scrolling under a sidebar or inspector. Within each continent section in `LandmarksView`, an instance of `LandmarkHorizontalListView` shows a horizontally scrolling list of landmark views. When open, the landmark views can scroll underneath the sidebar or inspector. ## Configure the scroll view To achieve this effect, the sample configures the `LandmarkHorizontalListView` so it touches the leading and trailing edges. When a scroll view touches the sidebar or inspector, the system automatically adjusts it to scroll under the sidebar or inspector and then off the edge of the screen. The sample adds a `Spacer` at the beginning of the `ScrollView` to inset the content so it aligns with the title padding: ScrollView(.horizontal, showsIndicators: false) { LazyHStack(spacing: Constants.standardPadding) { Spacer() .frame(width: Constants.standardPadding) ForEach(landmarkList) { landmark in //... } } } ## See Also ### App features Landmarks: Applying a background extension effect Configure an image to blur and extend under a sidebar or inspector panel. Landmarks: Refining the system provided Liquid Glass effect in toolbars Organize toolbars into related groupings to improve their appearance and utility. Landmarks: Displaying custom activity badges Provide people with a way to mark their adventures by displaying animated custom activity badges. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/landmarks-refining-the-system-provided-glass-effect-in-toolbars - SwiftUI - Landmarks: Building an app with Liquid Glass - Landmarks: Refining the system provided Liquid Glass effect in toolbars Beta Sample Code # Landmarks: Refining the system provided Liquid Glass effect in toolbars Organize toolbars into related groupings to improve their appearance and utility. Download Xcode 26.0+Beta ## Overview The Landmarks app lets people explore interesting sites around the world. Whether it’s a national park near their home or a far-flung location on a different continent, the app provides a way for people to organize and mark their adventures and receive custom activity badges along the way. This sample demonstrates how to refine the system provided glass effect in toolbars. In `LandmarkDetailView`, the sample adds toolbar items for: - sharing a landmark - adding or removing a landmark from a list of Favorites - adding or removing a landmark from Collections - showing or hiding the inspector The system applies Liquid Glass to the toolbar items automatically. ## Organize the toolbar items into logical groupings To organize the toolbar items into logical groupings, the sample adds `ToolbarSpacer` items and passes `fixed` as the `sizing` parameter to divide the toolbar into sections: .toolbar { ToolbarSpacer(.flexible) ToolbarItem { ShareLink(item: landmark, preview: landmark.sharePreview) } ToolbarSpacer(.fixed) ToolbarItemGroup { LandmarkFavoriteButton(landmark: landmark) LandmarkCollectionsMenu(landmark: landmark) } ToolbarItem { Button("Info", systemImage: "info") { modelData.selectedLandmark = landmark modelData.isLandmarkInspectorPresented.toggle() } } } ## See Also ### App features Landmarks: Applying a background extension effect Configure an image to blur and extend under a sidebar or inspector panel. Landmarks: Extending horizontal scrolling under a sidebar or inspector Improve your horizontal scrollbar’s appearance by extending it under a sidebar or inspector. Landmarks: Displaying custom activity badges Provide people with a way to mark their adventures by displaying animated custom activity badges. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/glasseffect(_:in:isenabled:) #app-main) - SwiftUI - View - glassEffect(\_:in:isEnabled:) Beta Instance Method # glassEffect(\_:in:isEnabled:) Applies the Liquid Glass effect to a view. nonisolated func glassEffect( _ glass: Glass = .regular, in shape: some Shape = .capsule, isEnabled: Bool = true ## Mentioned in Applying Liquid Glass to custom views ## Discussion When you use this effect, the system: - Renders a shape anchored behind a view with the Liquid Glass material. - Applies the foreground effects of Liquid Glass over a view. For example, to add this effect to a `Text`: Text("Hello, World!") .font(.title) .padding() .glassEffect() SwiftUI uses the `regular` variant by default along with a `Capsule` shape. SwiftUI anchors the Liquid Glass to a view’s bounds. For the example above, the material fills the entirety of the `Text` frame, which includes the padding. You typically use this modifier with a `GlassEffectContainer` to combine multiple Liquid Glass shapes into a single shape that can morph into one another. ## See Also ### Styling views with Liquid Glass Configure, combine, and morph views using Liquid Glass effects. Landmarks: Building an app with Liquid Glass Enhance your app experience with system-provided and custom Liquid Glass. Returns a copy of the structure configured to be interactive. Beta `struct GlassEffectContainer` A view that combines multiple Liquid Glass shapes into a single shape that can morph individual shapes into one another. `struct GlassEffectTransition` A structure that describes changes to apply when a glass effect is added or removed from the view hierarchy. `struct GlassButtonStyle` A button style that applies glass border artwork based on the button’s context. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/glasseffectcontainer --- # https://developer.apple.com/documentation/swiftui/view/glasseffectid(_:in:) #app-main) - SwiftUI - View - glassEffectID(\_:in:) Beta Instance Method # glassEffectID(\_:in:) Associates an identity value to Liquid Glass effects defined within this view. nonisolated func glassEffectID( _ id: (some Hashable & Sendable)?, in namespace: Namespace.ID ## Mentioned in Applying Liquid Glass to custom views ## Discussion You use this modifier with the `glassEffect(_:in:isEnabled:)` view modifier and a `GlassEffectContainer` view. When used together, SwiftUI uses the identifier to animate shapes to and from each other during transitions. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/landmarks-displaying-custom-activity-badges --- # https://developer.apple.com/documentation/swiftui/applying-liquid-glass-to-custom-views - SwiftUI - View styles - Applying Liquid Glass to custom views Article # Applying Liquid Glass to custom views Configure, combine, and morph views using Liquid Glass effects. ## Overview Interfaces across Apple platforms feature a new dynamic material called Liquid Glass, which combines the optical properties of glass with a sense of fluidity. Liquid Glass is a material that blurs content behind it, reflects color and light of surrounding content, and reacts to touch and pointer interactions in real time. Standard components in SwiftUI use Liquid Glass. Adopt Liquid Glass on custom components to move, combine, and morph them into one another with unique animations and transitions. To learn about Liquid Glass and more, see Landmarks: Building an app with Liquid Glass. ## Apply and configure Liquid Glass effects Use the `glassEffect(_:in:isEnabled:)` modifier to add Liquid Glass effects to a view. By default, the modifier uses the `regular` variant of `Glass` and applies the given effect within a `Capsule` shape behind the view’s content. Configure the effect to customize your components in a variety of ways: - Use different shapes to have a consistent look and feel across custom components in your app. For example, use a rounded rectangle if you’re applying the effect to larger components that would look odd as a `Capsule` or `Circle`. - Define a tint color to suggest prominence. - Add `interactive(_:)` to custom components to make them react to touch and pointer interactions. This applies the same responsive and fluid reactions that `glass` provides to standard buttons. In the examples below, observe how to apply Liquid Glass effects to a view, use an alternate shape with a specific corner radius, and create a tinted view that responds to interactivity: Video with custom controls. Content description: A video showing examples including a Text view with Liquid Glass effects applied, a Text view with a custom shape, corner radius effect, and Liquid Glass effects applied, and a Text view with an orange tint color effect that responds to interactivity, with Liquid Glass effects applied. Play Text("Hello, World!") .font(.title) .padding() .glassEffect() Text("Hello, World!") .font(.title) .padding() .glassEffect(in: .rect(cornerRadius: 16.0)) Text("Hello, World!") .font(.title) .padding() .glassEffect(.regular.tint(.orange).interactive()) ## Combine multiple views with Liquid Glass containers Use `GlassEffectContainer` when applying Liquid Glass effects on multiple views to achieve the best rendering performance. A container also allows views with Liquid Glass effects to blend their shapes together and to morph in and out of each other during transitions. Inside a container, each view with the `glassEffect(_:in:isEnabled:)` modifier renders with the effects behind it. Customize the spacing on the container to set layout spacing between views and to affect how the Liquid Glass effects behind views interact with one another. Views close to one another merge their effects into a single shape. The farther views are from each other, the sooner the shapes merge into each other. The `.glassEffect()` modifier captures the content to send to the container to render. Apply the `.glassEffect()` modifier after other modifiers that will affect the appearance of the view. In the example below, two images are placed close to each other and the Liquid Glass effects begin to blend their shapes together. This creates a fluid animation as components move around each other within a container: GlassEffectContainer(spacing: 40.0) { HStack(spacing: 40.0) { Image(systemName: "scribble.variable") .frame(width: 80.0, height: 80.0) .font(.system(size: 36)) .glassEffect() Image(systemName: "eraser.fill") .frame(width: 80.0, height: 80.0) .font(.system(size: 36)) .glassEffect() // An `offset` shows how Liquid Glass effects react to each other in a container. // Use animations and components appearing and disappearing to obtain effects that look purposeful. .offset(x: -40.0, y: 0.0) } } In some cases, you want the geometries of multiple views to contribute to a single Liquid Glass effect capsule, even when your content is at rest. Use the `glassEffectUnion(id:namespace:)` modifier to specify that a view contributes to a united effect with a particular ID. This combines all effects with a similar shape, Liquid Glass effect, and ID into a single shape with the applied Liquid Glass material. This is especially useful when creating views dynamically, or with views that live outside of an `HStack` or `VStack`. let symbolSet: [String] = ["cloud.bolt.rain.fill", "sun.rain.fill", "moon.stars.fill", "moon.fill"] GlassEffectContainer(spacing: 20.0) { HStack(spacing: 20.0) { ForEach(symbolSet.indices, id: \.self) { item in Image(systemName: symbolSet[item]) .frame(width: 80.0, height: 80.0) .font(.system(size: 36)) .glassEffect() .glassEffectUnion(id: item < 2 ? "1" : "2", namespace: namespace) } } } ## Morph Liquid Glass effects during transitions Morphing effects occur during transitions between views with Liquid Glass effects. Add these transitions to views with effects in a container by using the `glassEffectID(_:in:)` modifier. Associate each Liquid Glass effect with a unique identifier within a namespace the `Namespace` property wrapper provides. These IDs ensure SwiftUI animates the same shapes correctly when a shape appears or disappears due to view hierarchy changes. SwiftUI uses the spacing provided to the effect container along with the geometry of the shapes themselves to determine appropriate shapes to morph into and out of. In the example below, the eraser image transitions into and out of the pencil image when the `isExpanded` variable changes. The `GlassEffectContainer` has a spacing value of `40.0`, and the `HStack` within it has a spacing of `40.0`. This morphs the eraser image into the pencil image when the eraser’s nearest edge is less than or equal to the container’s spacing. Content description: A video which shows two views, a scribble symbol on the left and a eraser symbol on the right, with Liquid Glass effects morphing in and out of each other as a button below them is pressed. @State private var isExpanded: Bool = false @Namespace private var namespace var body: some View { GlassEffectContainer(spacing: 40.0) { HStack(spacing: 40.0) { Image(systemName: "scribble.variable") .frame(width: 80.0, height: 80.0) .font(.system(size: 36)) .glassEffect() .glassEffectID("pencil", in: namespace) if isExpanded { Image(systemName: "eraser.fill") .frame(width: 80.0, height: 80.0) .font(.system(size: 36)) .glassEffect() .glassEffectID("eraser", in: namespace) } } } Button("Toggle") { withAnimation { isExpanded.toggle() } } .buttonStyle(.glass) } ## See Also ### Styling views with Liquid Glass Landmarks: Building an app with Liquid Glass Enhance your app experience with system-provided and custom Liquid Glass. Applies the Liquid Glass effect to a view. Beta Returns a copy of the structure configured to be interactive. `struct GlassEffectContainer` A view that combines multiple Liquid Glass shapes into a single shape that can morph individual shapes into one another. `struct GlassEffectTransition` A structure that describes changes to apply when a glass effect is added or removed from the view hierarchy. `struct GlassButtonStyle` A button style that applies glass border artwork based on the button’s context. --- # https://developer.apple.com/documentation/swiftui/navigationsplitview) --- # https://developer.apple.com/documentation/swiftui/image) --- # https://developer.apple.com/documentation/swiftui/view/backgroundextensioneffect()) --- # https://developer.apple.com/documentation/swiftui/landmarks-applying-a-background-extension-effect). --- # https://developer.apple.com/documentation/swiftui/landmarks-extending-horizontal-scrolling-under-a-sidebar-or-inspector). .#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/landmarks-refining-the-system-provided-glass-effect-in-toolbars). .#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/view/glasseffect(_:in:isenabled:)) --- # https://developer.apple.com/documentation/swiftui/glasseffectcontainer), --- # https://developer.apple.com/documentation/swiftui/view/glasseffectid(_:in:)). --- # https://developer.apple.com/documentation/swiftui/landmarks-displaying-custom-activity-badges). --- # https://developer.apple.com/documentation/swiftui/applying-liquid-glass-to-custom-views). .#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/landmarks-applying-a-background-extension-effect) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/landmarks-extending-horizontal-scrolling-under-a-sidebar-or-inspector) --- # https://developer.apple.com/documentation/swiftui/landmarks-refining-the-system-provided-glass-effect-in-toolbars) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/landmarks-displaying-custom-activity-badges) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/uiapplicationdelegateadaptor - SwiftUI - UIApplicationDelegateAdaptor Structure # UIApplicationDelegateAdaptor A property wrapper type that you use to create a UIKit app delegate. @MainActor @preconcurrency @propertyWrapper ## Mentioned in Migrating to the SwiftUI life cycle ## Overview To handle app delegate callbacks in an app that uses the SwiftUI life cycle, define a type that conforms to the `UIApplicationDelegate` protocol, and implement the delegate methods that you need. For example, you can implement the `application(_:didRegisterForRemoteNotificationsWithDeviceToken:)` method to handle remote notification registration: class MyAppDelegate: NSObject, UIApplicationDelegate, ObservableObject { func application( _ application: UIApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data ) { // Record the device token. } } Then use the `UIApplicationDelegateAdaptor` property wrapper inside your `App` declaration to tell SwiftUI about the delegate type: @main struct MyApp: App { @UIApplicationDelegateAdaptor private var appDelegate: MyAppDelegate var body: some Scene { ... } } SwiftUI instantiates the delegate and calls the delegate’s methods in response to life cycle events. Define the delegate adaptor only in your `App` declaration, and only once for a given app. If you declare it more than once, SwiftUI generates a runtime error. If your app delegate conforms to the `ObservableObject` protocol, as in the example above, then SwiftUI puts the delegate it creates into the `Environment`. You can access the delegate from any scene or view in your app using the `EnvironmentObject` property wrapper: @EnvironmentObject private var appDelegate: MyAppDelegate This enables you to use the dollar sign ( `$`) prefix to get a binding to published properties that you declare in the delegate. For more information, see `projectedValue`. ### Scene delegates Some iOS apps define a `UIWindowSceneDelegate` to handle scene-based events, like app shortcuts: class MySceneDelegate: NSObject, UIWindowSceneDelegate, ObservableObject { func windowScene( _ windowScene: UIWindowScene, performActionFor shortcutItem: UIApplicationShortcutItem // Do something with the shortcut... return true } } You can provide this kind of delegate to a SwiftUI app by returning the scene delegate’s type from the `application(_:configurationForConnecting:options:)` method inside your app delegate: extension MyAppDelegate { func application( _ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions let configuration = UISceneConfiguration( name: nil, sessionRole: connectingSceneSession.role) if connectingSceneSession.role == .windowApplication { configuration.delegateClass = MySceneDelegate.self } return configuration } } When you configure the `UISceneConfiguration` instance, you only need to indicate the delegate class, and not a scene class or storyboard. SwiftUI creates and manages the delegate instance, and sends it any relevant delegate callbacks. As with the app delegate, if you make your scene delegate an observable object, SwiftUI automatically puts it in the `Environment`, from where you can access it with the `EnvironmentObject` property wrapper, and create bindings to its published properties. ## Topics ### Creating a delegate adaptor `init(_:)` Creates a UIKit app delegate adaptor using an observable delegate. ### Getting the delegate adaptor A projection of the observed object that provides bindings to its properties. `var wrappedValue: DelegateType` The underlying app delegate. ## Relationships ### Conforms To - `DynamicProperty` - `Sendable` - `SendableMetatype` ## See Also ### Targeting iOS and iPadOS `UILaunchScreen` The user interface to show while an app launches. `UILaunchScreens` The user interfaces to show while an app launches in response to different URL schemes. --- # https://developer.apple.com/documentation/swiftui/backyard-birds-sample - SwiftUI - App organization - Backyard Birds: Building an app with SwiftData and widgets Sample Code # Backyard Birds: Building an app with SwiftData and widgets Create an app with persistent data, interactive widgets, and an all new in-app purchase experience. Download Xcode 15.1+ ## Overview Backyard Birds offers a rich environment in which you can watch the birds that visit your backyard garden. You can monitor their water and food supply to ensure they always have fresh water and plenty to eat, or upgrade the game using an in-app purchase to provide tastier food for the birds to eat. The sample implements its data model using SwiftData for persistence, and integrates seamlessly with SwiftUI using the `Observable` protocol. The game’s widgets implement App Intents for interactive and configurable widgets. The in-app purchase experience uses the `ProductView` and `SubscriptionStoreView` from StoreKit. You can access the source code for this sample on GitHub. ### Configure the sample code project To configure the Backyard Birds app to run on your devices, follow these steps: 1. Open the project in Xcode 15 or later. 2. Edit the multiplatform target’s scheme, and on the Options tab, choose the `Store.storekit` file for StoreKit configuration. 3. Repeat the previous step for the watchOS target’s scheme. 4. Select the top-level Backyard Birds project. 5. For all targets, choose your team from the Team menu in the Signing & Capabilities pane so Xcode can automatically manage your provisioning profile. ### Create a data-driven app The app defines its data model by conforming the model objects to `PersistentModel` using the `Model` macro. Using the `Attribute` macro with the `unique` option ensures that the `id` property is unique. @Model public class BirdSpecies { @Attribute(.unique) public var id: String public var naturalScale: Double public var isEarlyAccess: Bool public var parts: [BirdPart] @Relationship(deleteRule: .cascade, inverse: \Bird.species) public var birds: [Bird] = [] public var info: BirdSpeciesInfo { BirdSpeciesInfo(rawValue: id) } public init(info: BirdSpeciesInfo, naturalScale: Double = 1, isEarlyAccess: Bool = false, parts: [BirdPart]) { self.id = info.rawValue self.naturalScale = naturalScale self.isEarlyAccess = isEarlyAccess self.parts = parts } } ### Construct interactive widgets Backyard Birds displays interactive widgets by presenting a `Button` to refill a backyard’s supplies when the water and food are running low. The app does this by placing a `Button` in the widget’s view, and passing a `ResupplyBackyardIntent` instance to the `init(intent:label:)` initializer: Button(intent: ResupplyBackyardIntent(backyard: BackyardEntity(from: snapshot.backyard))) { Label("Refill Water", systemImage: "arrow.clockwise") .foregroundStyle(.secondary) .frame(maxWidth: .infinity) .padding(.vertical, 8) .padding(.horizontal, 12) .background(.quaternary, in: .containerRelative) } The app allows for configuration of the widget by implementing the `WidgetConfigurationIntent` protocol: struct BackyardWidgetIntent: WidgetConfigurationIntent { static let title: LocalizedStringResource = "Backyard" static let description = IntentDescription("Keep track of your backyards.") @Parameter(title: "Backyards", default: BackyardWidgetContent.all) var backyards: BackyardWidgetContent @Parameter(title: "Backyard") var specificBackyard: BackyardEntity? init(backyards: BackyardWidgetContent = .all, specificBackyard: BackyardEntity? = nil) { self.backyards = backyards self.specificBackyard = specificBackyard } init() { } static var parameterSummary: some ParameterSummary { When(\.$backyards, .equalTo, BackyardWidgetContent.specific) { Summary { \.$backyards \.$specificBackyard } } otherwise: { Summary { \.$backyards } } } } ### Provide a new in-app purchase experience The sample app uses `ProductView` to display several different bird food upgrades available for purchase on a store shelf. To prominently feature an in-app purchase item, the app uses the `.productViewStyle(.large)` modifier: ProductView(id: product.id) { BirdFoodProductIcon(birdFood: birdFood, quantity: product.quantity) .bestBirdFoodValueBadge() } .padding(.vertical) .background(.background.secondary, in: .rect(cornerRadius: 20)) .productViewStyle(.large) The Backyard Birds Pass page displays renewable subscriptions using the `SubscriptionStoreView` view. The app uses the `PassMarketingContent` view as the content of the `SubscriptionStoreView`: SubscriptionStoreView( groupID: passGroupID, visibleRelationships: showPremiumUpgrade ? .upgrade : .all ) { PassMarketingContent(showPremiumUpgrade: showPremiumUpgrade) #if !os(watchOS) .containerBackground(for: .subscriptionStoreFullHeight) { SkyBackground() } #endif } ## See Also ### Creating an app Destination Video Leverage SwiftUI to build an immersive media experience in a multiplatform app. Hello World Use windows, volumes, and immersive spaces to teach people about the Earth. Food Truck: Building a SwiftUI multiplatform app Create a single codebase and app target for Mac, iPad, and iPhone. Fruta: Building a Feature-Rich App with SwiftUI Create a shared codebase to build a multiplatform app that offers widgets and an App Clip. Migrating to the SwiftUI life cycle Use a scene-based life cycle in SwiftUI while keeping your existing codebase. `protocol App` A type that represents the structure and behavior of an app. --- # https://developer.apple.com/documentation/swiftui/food_truck_building_a_swiftui_multiplatform_app - SwiftUI - Food Truck: Building a SwiftUI multiplatform app Sample Code # Food Truck: Building a SwiftUI multiplatform app Create a single codebase and app target for Mac, iPad, and iPhone. Download Xcode 14.3+ ## Overview Using the Food Truck app, someone who operates a food truck can keep track of orders, discover the most-popular menu items, and check the weather at their destination. The sample implements the new `NavigationSplitView` to manage the app’s views, Layout modifiers to show the main interface and pending orders, Swift Charts to show trends, and `WeatherService` to get weather data. Food Truck also implements Live Activities to show the remaining order preparation time with ActivityKit on the lock screen, and with `DynamicIsland` on the home screen. You can access the source code for this sample on GitHub. The Food Truck sample project contains two types of app targets: - Simple app target you can build using personal team signing. This app runs in Simulator, and only requires a standard Apple ID to install on a device. It includes in-app purchase, and a widget extension that enable users to add a widget to their iOS Home Screen or the macOS Notification Center. - Full-featured Food Truck All app target. The full app runs in Simulator, and on devices with an Apple Developer membership. It also allows you to create and sign in with passkeys. ### Configure the sample code project To configure the Food Truck app without an Apple Developer account, follow these steps: 1. In the Food Truck target’s Signing & Capabilities panes click Add Account, and log in with your Apple ID. 2. Chose Your Name (Personal Team) from the team menu for the Food Truck and Widgets targets. 3. Build and run your app. To configure the Food Truck All app to run on your devices, follow these steps: 1. Open the sample with Xcode 14.3 or later. 2. Select the top-level Food Truck project. 3. For all targets, choose your team from the Team menu in the Signing & Capabilities pane, so Xcode can automatically manage your provisioning profile. 4. Add the Associated Domains capability, and specify your domain with the `webcredentials` service. For more information about the `webcredentials` service, see `Associated Domains Entitlement`. 5. Ensure an `apple-app-site-association` (AASA) file is present on your domain, in the `.well-known` directory, and it contains an entry for this app’s App ID for the `webcredentials` service. For more information about the `apple-app-site-association` file, see Supporting associated domains. 6. In the `AccountManager.swift` file, replace all occurrences of `example.com` with the name of your domain. ### Create a multiplatform app Food Truck is a multiplatform app, and there are no separate targets to run on macOS or iOS. Instead, there is only one app target that builds for macOS, iPadOS, and iOS. ### Define a default navigation destination The sample’s navigation interface consists of a `NavigationSplitView` with a `Sidebar` view, and a `NavigationStack`: NavigationSplitView { Sidebar(selection: $selection) } detail: { NavigationStack(path: $path) { DetailColumn(selection: $selection, model: model) } } At app launch, the sample presents the `TruckView` as the default view. The `Panel` enum encodes the views the user can select in the sidebar, and hence appear in the detail view. The value corresponding to `TruckView` is `.truck`, and the app sets this to be the default selection. @State private var selection: Panel? = Panel.truck ### Construct a dynamic layout In the Truck view, the New Orders panel shows the five most-recent orders, and each order shows a `DonutStackView`, which is a diagonal stack of donut thumbnails. The Layout modifiers protocol allows the app to define a `DiagonalDonutStackLayout` that arranges the donut thumbnails into the diagonal layout. The layout’s `placeSubviews(in:proposal:subviews:cache:)` implementation calculates the donuts’ positions. for index in subviews.indices { switch (index, subviews.count) { case (_, 1): subviews[index].place( at: center, anchor: .center, proposal: ProposedViewSize(size) ) case (_, 2): let direction = index == 0 ? -1.0 : 1.0 let offsetX = minBound * direction * 0.15 let offsetY = minBound * direction * 0.20 subviews[index].place( at: CGPoint(x: center.x + offsetX, y: center.y + offsetY), anchor: .center, proposal: ProposedViewSize(CGSize(width: size.width * 0.7, height: size.height * 0.7)) ) case (1, 3): subviews[index].place( at: center, anchor: .center, proposal: ProposedViewSize(CGSize(width: size.width * 0.65, height: size.height * 0.65)) ) case (_, 3): let direction = index == 0 ? -1.0 : 1.0 let offsetX = minBound * direction * 0.15 let offsetY = minBound * direction * 0.23 subviews[index].place( at: CGPoint(x: center.x + offsetX, y: center.y + offsetY), anchor: .center, proposal: ProposedViewSize(CGSize(width: size.width * 0.7, height: size.height * 0.65)) ) ### Display a chart of popular items The sample contains several charts. The most popular items are shown on the `TopFiveDonutsView`. This chart is implemented in `TopDonutSalesChart`, which uses a `BarMark` to construct a bar chart. Chart { ForEach(sortedSales) { sale in BarMark( x: .value("Donut", sale.donut.name), y: .value("Sales", sale.sales) ) .cornerRadius(6, style: .continuous) .foregroundStyle(.linearGradient(colors: [Color("BarBottomColor"), .accentColor], startPoint: .bottom, endPoint: .top)) .annotation(position: .top, alignment: .top) { Text(sale.sales.formatted()) .padding(.vertical, 4) .padding(.horizontal, 8) .background(.quaternary.opacity(0.5), in: Capsule()) .background(in: Capsule()) .font(.caption) } } } The _x_ axis of the chart shows labels with the names and thumbnails of the items that correspond to each data point. .chartXAxis { AxisMarks { value in AxisValueLabel { let donut = donutFromAxisValue(for: value) VStack { DonutView(donut: donut) .frame(height: 35) Text(donut.name) .lineLimit(2, reservesSpace: true) .multilineTextAlignment(.center) } .frame(idealWidth: 80) .padding(.horizontal, 4) } } } ### Obtain a weather forecast The app shows a forecasted temperature graph in the Forecast panel in the Truck view. The app obtains this data from the WeatherKit framework. .task(id: city.id) { for parkingSpot in city.parkingSpots { do { let weather = try await WeatherService.shared.weather(for: parkingSpot.location) condition = weather.currentWeather.condition cloudCover = weather.currentWeather.cloudCover temperature = weather.currentWeather.temperature symbolName = weather.currentWeather.symbolName let attribution = try await WeatherService.shared.attribution attributionLink = attribution.legalPageURL attributionLogo = colorScheme == .light ? attribution.combinedMarkLightURL : attribution.combinedMarkDarkURL if willRainSoon == false { spot = parkingSpot break } } catch { print("Could not gather weather information...", error.localizedDescription) condition = .clear willRainSoon = false cloudCover = 0.15 } } } ### Configure the project for WeatherKit The data from the `WeatherService` instance in WeatherKit requires additional configuration for the Food Truck All target. If you don’t configure WeatherKit, the sample will detect an error and use static data in the project instead. 1. Create a unique App ID on the Provisioning Portal, and select the WeatherKit service on the App Services tab. 2. In Xcode, for the Food Truck All target on the Signing & Capabilities tab, change the bundle ID to be the same as the App ID from step 1, and add the WeatherKit capability. 3. For the Widgets target on the Signing & Capabilities tab, change the bundle ID to make the part before `.Widgets` the same as the bundle ID for the Food Truck All target. 4. Wait 30 minutes while the service registers your app’s bundle ID. 5. Build and run the Food Truck All target. ### Track preparation time with Live Activity The app allows the food truck operator to keep track of order preparation time, which is guaranteed to be 60 seconds or less. To facilitate this, the app implements a toolbar button on the order details screen for orders with `placed` status. Tapping this button changes the order status to `preparing`, and creates an `Activity` instance to start a Live Activity, which shows the countdown timer and order details on an iPhone lock screen. let timerSeconds = 60 let activityAttributes = TruckActivityAttributes( orderID: String(order.id.dropFirst(6)), order: order.donuts.map(\.id), sales: order.sales, activityName: "Order preparation activity." ) let future = Date(timeIntervalSinceNow: Double(timerSeconds)) let initialContentState = TruckActivityAttributes.ContentState(timerRange: Date.now...future) let activityContent = ActivityContent(state: initialContentState, staleDate: Calendar.current.date(byAdding: .minute, value: 2, to: Date())!) do { pushType: nil) print(" Requested MyActivity live activity. ID: \(myActivity.id)") postNotification() } catch let error { print("Error requesting live activity: \(error.localizedDescription)") } The app also implements `DynamicIsland` to show the same information as on the lock screen in the Dynamic Island on iPhone 14 Pro devices. DynamicIsland { DynamicIslandExpandedRegion(.leading) { ExpandedLeadingView() } DynamicIslandExpandedRegion(.trailing, priority: 1) { ExpandedTrailingView(orderNumber: context.attributes.orderID, timerInterval: context.state.timerRange) .dynamicIsland(verticalPlacement: .belowIfTooWide) } } compactLeading: { Image("IslandCompactIcon") .padding(4) .background(.indigo.gradient, in: ContainerRelativeShape()) } compactTrailing: { Text(timerInterval: context.state.timerRange, countsDown: true) .monospacedDigit() .foregroundColor(Color("LightIndigo")) .frame(width: 40) } minimal: { Image("IslandCompactIcon") .padding(4) .background(.indigo.gradient, in: ContainerRelativeShape()) } .contentMargins(.trailing, 32, for: .expanded) .contentMargins([.leading, .top, .bottom], 6, for: .compactLeading) .contentMargins(.all, 6, for: .minimal) .widgetURL(URL(string: "foodtruck://order/\(context.attributes.orderID)")) Tapping the same button again changes the status to `complete`, and ends the Live Activity. This removes the Live Activity from the lock screen and from the Dynamic Island. Task { // Check if this is the activity associated with this order. if activity.attributes.orderID == String(order.id.dropFirst(6)) { await activity.end(nil, dismissalPolicy: .immediate) } } } --- # https://developer.apple.com/documentation/swiftui/migrating-to-the-swiftui-life-cycle - SwiftUI - App organization - Migrating to the SwiftUI life cycle Article # Migrating to the SwiftUI life cycle Use a scene-based life cycle in SwiftUI while keeping your existing codebase. ## Overview Take advantage of the declarative syntax in SwiftUI and its compatibility with spatial frameworks by moving your app to the SwiftUI life cycle. Moving to the SwiftUI life cycle requires several steps, including changing your app’s entry point, configuring the launch of your app, and monitoring life-cycle changes with the methods that SwiftUI provides. ### Change your app’s entry point The UIKit framework defines the `AppDelegate` file as the entry point of your app with the annotation `@main`. For more information on `@main`, see the Attributes section in The Swift Programming Language. To indicate the entry of a SwiftUI app, you’ll need to create a new file that defines your app’s structure. 1. Open your project in Xcode. 4. Add `import SwiftUI` at the top of the file. 5. Annotate the app structure with the `@main` attribute to indicate the entry point of the SwiftUI app, as shown in the code snippet below. Use following code to create the SwiftUI app structure. To learn more about this structure, follow the tutorial in Exploring the structure of a SwiftUI app. import SwiftUI @main struct MyExampleApp: App { var body: some Scene { WindowGroup { ContentView() } } } ### Support app delegate methods To continue using methods in your app delegate, use the `UIApplicationDelegateAdaptor` property wrapper. To tell SwiftUI about a delegate that conforms to the `UIApplicationDelegate` protocol, place this property wrapper inside your `App` declaration: @main struct MyExampleApp: App { @UIApplicationDelegateAdaptor private var appDelegate: MyAppDelegate var body: some Scene { ... } } This example marks a custom app delegate named `MyAppDelegate` as the delegate adaptor. Be sure to implement any necessary delegate methods in that type. ### Configure the launch of your app If you’re migrating an app that contains storyboards to SwiftUI, make sure to remove them when they’re no longer needed. 2. Remove `Main.storyboard` from the project navigator. 3. Choose your app’s target. 4. Open the `Info.plist` file. 5. Remove the `Main storyboard file base name` key. This figure shows the structure of the `Info.plist` file before removing these keys. The scene delegate continues to be called after removing the keys from the `Info.plist` file, so you can still handle other scene-based life cycle changes in this file. If you were previously launching your app in your scene delegate, remove the `scene(_:willConnectTo:options:)` method from your scene delegate. If you didn’t previously support scenes in your app and rely on your app delegate to respond to the launch of your app, ensure you’re no longer setting a root view controller in `application(_:didFinishLaunchingWithOptions:)`. Instead, return `true`. ### Monitor life cycle changes You will no longer be able to monitor life-cycle changes in your app delegate due to the scene-based nature of SwiftUI (see `Scene`). Prefer to handle these changes in `ScenePhase`, the life cycle enumeration that SwiftUI provides to monitor the phases of a scene. Observe the `Environment` value to initiate actions when the phase changes. @Environment(\.scenePhase) private var scenePhase Interpret the value differently based on where you read it from. If you read the phase from inside a `View` instance, the value reflects the phase of the scene that contains the view. If you read the phase from within an `App` instance, the value reflects an aggregation of the phases of all of the scenes in your app. To handle scene-based events with a scene delegate, provide your scene delegate to your SwiftUI app inside your app delegate. For more information, see the “Scene delegates” section of `UIApplicationDelegateAdaptor`. For more information on handling scene-based life cycle events, see Managing your app’s life cycle. ## See Also ### Creating an app Destination Video Leverage SwiftUI to build an immersive media experience in a multiplatform app. Hello World Use windows, volumes, and immersive spaces to teach people about the Earth. Backyard Birds: Building an app with SwiftData and widgets Create an app with persistent data, interactive widgets, and an all new in-app purchase experience. Food Truck: Building a SwiftUI multiplatform app Create a single codebase and app target for Mac, iPad, and iPhone. Fruta: Building a Feature-Rich App with SwiftUI Create a shared codebase to build a multiplatform app that offers widgets and an App Clip. `protocol App` A type that represents the structure and behavior of an app. --- # https://developer.apple.com/documentation/swiftui/nsapplicationdelegateadaptor - SwiftUI - NSApplicationDelegateAdaptor Structure # NSApplicationDelegateAdaptor A property wrapper type that you use to create an AppKit app delegate. @MainActor @preconcurrency @propertyWrapper ## Mentioned in Migrating to the SwiftUI life cycle ## Overview To handle app delegate callbacks in an app that uses the SwiftUI life cycle, define a type that conforms to the `NSApplicationDelegate` protocol, and implement the delegate methods that you need. For example, you can implement the `application(_:didRegisterForRemoteNotificationsWithDeviceToken:)` method to handle remote notification registration: class MyAppDelegate: NSObject, NSApplicationDelegate, ObservableObject { func application( _ application: NSApplication, didRegisterForRemoteNotificationsWithDeviceToken deviceToken: Data ) { // Record the device token. } } Then use the `NSApplicationDelegateAdaptor` property wrapper inside your `App` declaration to tell SwiftUI about the delegate type: @main struct MyApp: App { @NSApplicationDelegateAdaptor private var appDelegate: MyAppDelegate var body: some Scene { ... } } SwiftUI instantiates the delegate and calls the delegate’s methods in response to life cycle events. Define the delegate adaptor only in your `App` declaration, and only once for a given app. If you declare it more than once, SwiftUI generates a runtime error. If your app delegate conforms to the `ObservableObject` protocol, as in the example above, then SwiftUI puts the delegate it creates into the `Environment`. You can access the delegate from any scene or view in your app using the `EnvironmentObject` property wrapper: @EnvironmentObject private var appDelegate: MyAppDelegate This enables you to use the dollar sign ( `$`) prefix to get a binding to published properties that you declare in the delegate. For more information, see `projectedValue`. ## Topics ### Creating a delegate adaptor `init(_:)` Creates an AppKit app delegate adaptor using an observable delegate. ### Getting the delegate adaptor A projection of the observed object that provides bindings to its properties. `var wrappedValue: DelegateType` The underlying delegate. ## Relationships ### Conforms To - `DynamicProperty` - `Sendable` - `SendableMetatype` --- # https://developer.apple.com/documentation/swiftui/wkapplicationdelegateadaptor - SwiftUI - WKApplicationDelegateAdaptor Structure # WKApplicationDelegateAdaptor A property wrapper that is used in `App` to provide a delegate from WatchKit. @MainActor @preconcurrency @propertyWrapper ## Mentioned in Migrating to the SwiftUI life cycle ## Topics ### Creating a delegate adaptor `init(_:)` Creates an `WKApplicationDelegateAdaptor` using a WatchKit Application Delegate. ### Getting the delegate adaptor A projection of the observed object that creates bindings to its properties using dynamic member lookup. `var wrappedValue: DelegateType` The underlying delegate. ## Relationships ### Conforms To - `DynamicProperty` - `Sendable` - `SendableMetatype` ## See Also ### Targeting watchOS `struct WKExtensionDelegateAdaptor` A property wrapper type that you use to create a WatchKit extension delegate. --- # https://developer.apple.com/documentation/swiftui/wkextensiondelegateadaptor - SwiftUI - WKExtensionDelegateAdaptor Structure # WKExtensionDelegateAdaptor A property wrapper type that you use to create a WatchKit extension delegate. @MainActor @preconcurrency @propertyWrapper ## Overview To handle extension delegate callbacks in an extension that uses the SwiftUI life cycle, define a type that conforms to the `WKExtensionDelegate` protocol, and implement the delegate methods that you need. For example, you can implement the `didRegisterForRemoteNotifications(withDeviceToken:)` method to handle remote notification registration: class MyExtensionDelegate: NSObject, WKExtensionDelegate, ObservableObject { func didRegisterForRemoteNotifications(withDeviceToken: Data) { // Record the device token. } } Then use the `WKExtensionDelegateAdaptor` property wrapper inside your `App` declaration to tell SwiftUI about the delegate type: @main struct MyApp: App { @WKExtensionDelegateAdaptor private var extensionDelegate: MyExtensionDelegate var body: some Scene { ... } } SwiftUI instantiates the delegate and calls the delegate’s methods in response to life cycle events. Define the delegate adaptor only in your `App` declaration, and only once for a given extension. If you declare it more than once, SwiftUI generates a runtime error. If your extension delegate conforms to the `ObservableObject` protocol, as in the example above, then SwiftUI puts the delegate it creates into the `Environment`. You can access the delegate from any scene or view in your extension using the `EnvironmentObject` property wrapper: @EnvironmentObject private var extensionDelegate: MyExtensionDelegate This enables you to use the dollar sign ( `$`) prefix to get a binding to published properties that you declare in the delegate. For more information, see `projectedValue`. ## Topics ### Creating a delegate adaptor `init(_:)` Creates a WatchKit extension delegate adaptor using an observable delegate. ### Getting the delegate adaptor A projection of the observed object that provides bindings to its properties. `var wrappedValue: DelegateType` The underlying delegate. ## Relationships ### Conforms To - `DynamicProperty` - `Sendable` - `SendableMetatype` ## See Also ### Targeting watchOS `struct WKApplicationDelegateAdaptor` A property wrapper that is used in `App` to provide a delegate from WatchKit. --- # https://developer.apple.com/documentation/swiftui/creating-a-tvos-media-catalog-app-in-swiftui - SwiftUI - App organization - Creating a tvOS media catalog app in SwiftUI Sample Code # Creating a tvOS media catalog app in SwiftUI Build standard content lockups and rows of content shelves for your tvOS app. Download Xcode 16.0+ ## Overview This sample code project shows how to create the standard content lockups for tvOS, and provides best practices for building out rows of content shelves. It also includes examples for product pages, search views, and tab views, including the new sidebar adaptive tab view style that provides a sidebar in tvOS. The sample project contains the following examples: - `StackView` implements an example landing page for a content catalog app, defining several shelves with a showcase or hero header area above them. It also gives an example of an above- and below-the-fold switching animation. - `ButtonsView` provides a showcase of the various button styles available in tvOS. - `DescriptionView` provides an example of how to build a product page similar to those you see on the Apple TV app, with a custom material blur. - `SearchView` shows an example of a simple search page using the `searchable(text:placement:prompt:)` and `searchSuggestions(_:)` modifiers. - `SidebarContentView` shows how to make a sectioned sidebar using the new tab bar APIs in tvOS 18. - `HeroHeaderView` gives an example of creating a material gradient to blur content in a certain area, fading it into unblurred content. ### Create content lockups The `borderless` button style provides the primary lockup style you use in tvOS, including all the focus interactions and hover effects. The button’s title and any nearby section titles automatically move out of the way of the button’s image as it scales up on focus. Provide a separate `Image` and `Text` view in the button’s label closure to ensure the correct vertical appearance. Using a `Label` usually results in a horizontal layout, and, depending on the current label style, may not give you the appearance you expect. Button { /* action */ } label: { Image("discovery_portrait") .resizable() .frame(width: 250, height: 375) Text("Borderless Portrait") } By default, the button style locates the first `Image` within the button’s label and attaches a `highlight` hover effect to it, providing lift, a specular highlight, and gimbal motion effects. To ensure the hover effect applies to exactly the right view, you can manually attach it to a particular subview of the button’s label using the `hoverEffect(_:)` modifier. For instance, to ensure an SF Symbols image hovers along with its background, do the following: Button { /* action */ } label: { Image(systemName: "person.circle") .font(.title) .background(Color.blue.grayscale(0.7)) .hoverEffect(.highlight) Text("Shaped") } .buttonBorderShape(.circle) You can also attach the hover effect to a custom view. Button { /* action */ } label: { CodeSampleArtwork(size: .appIconSize) .frame(width: 400, height: 240) .hoverEffect(.highlight) Text("Custom Icon View") } ### Show information-dense lockups For lockups with more dense information, consider using the `card` button style, which provides a platter and a more subtle motion effect on focus. Providing containers with padding as the button’s label gives you something similar to the search result lockups on the Apple TV app. Button { /* action */ } label: { HStack(alignment: .top, spacing: 10) { Image( . . . ) .resizable() .aspectRatio(contentMode: .fit) .clipShape(RoundedRectangle(cornerRadius: 12)) VStack(alignment: .leading) { Text(asset.title) .font(.body) Text("Subtitle text goes here, limited to two lines.") .font(.caption2) .foregroundStyle(.secondary) .lineLimit(2) Spacer(minLength: 0) HStack(spacing: 4) { ForEach(1..<4) { _ in Image(systemName: "ellipsis.rectangle.fill") } } .foregroundStyle(.secondary) } } .padding(12) } You can also use a custom `LabelStyle` to create a standard card-based lockup appearance while keeping your button’s declarations clean at the point of use. struct CardOverlayLabelStyle: LabelStyle { ZStack(alignment: .bottomLeading) { configuration.icon .resizable() .aspectRatio(400/240, contentMode: .fit) .overlay { LinearGradient( stops: [\ .init(color: .black.opacity(0.6), location: 0.1),\ .init(color: .black.opacity(0.2), location: 0.25),\ .init(color: .black.opacity(0), location: 0.4)\ ], startPoint: .bottom, endPoint: .top ) } .overlay { RoundedRectangle(cornerRadius: 12) .stroke(lineWidth: 2) .foregroundStyle(.quaternary) } configuration.title .font(.caption.bold()) .foregroundStyle(.secondary) .padding(6) } .frame(maxWidth: 400) } } Button { /* action */ } label: { Label("Title at the bottom", image: "discovery_landscape") } ### Display content shelves Content shelves are usually horizontal stacks in scroll views. Disabling scroll clipping is necessary to allow the focus effects to scale up and lift each lockup. Shelves typically contain only a single style of lockup, so assign your button style on the outside of the shelf container. ScrollView(.horizontal) { LazyHStack(spacing: 40) { ForEach(Asset.allCases) { asset in // . . . } } } .scrollClipDisabled() .buttonStyle(.borderless) To arrange your lockups nicely, use the `containerRelativeFrame(_:count:span:spacing:alignment:)` modifier to let SwiftUI determine the best size for each. You can specify how many lockups you want on the screen, and the amount of spacing your stack view provides. Then SwiftUI arranges the content so that the edges of the leading and trailing items align with the leading and trailing safe area insets of its container. For borderless buttons, you can attach the modifier to the `Image` instance within the button’s label closure to make the image the source of the frame calculations and alignments. asset.portraitImage .resizable() .aspectRatio(250 / 375, contentMode: .fit) .containerRelativeFrame(.horizontal, count: 6, spacing: 40) Text(asset.title) ### Show content above and below the fold For a landing page you can implement above- and below-the-fold appearances through a combination of `ScrollTargetBehavior` and a background view with a gradient mask. Define your showcase or header section as a stack with a container relative frame to make it take up a particular percentage of the available space. Attach a `focusSection()` modifier to the stack as well, so that its full width can act as a target for focus movement, which it then diverts to its content. Otherwise, moving focus up from the right side of the shelves below might fail, or might jump all the way to the tab bar because the focus engine searches for the nearest focusable view along a straight line from the currently focused item. VStack(alignment: .leading) { // Header content. } .frame(maxWidth: .infinity, alignment: .leading) .focusSection() .containerRelativeFrame(.vertical, alignment: .topLeading) { length, _ in length * 0.8 } The code above is the above-the-fold section. To detect when focus moves below the fold, use `onScrollVisibilityChange(threshold:_:)` to detect when the header view moves more than halfway off the screen. .onScrollVisibilityChange { visible in // When the header scrolls more than 50% offscreen, toggle // to the below-the-fold state. withAnimation { belowFold = !visible } } You can define the background of your landing page using a full-screen image with a material in an overlay. Then you can turn the material into a gradient by masking it with a `LinearGradient`, and you can adjust the opacity of that gradient’s stops according to the view’s above- or below-the-fold status. Image("beach_landscape") .resizable() .aspectRatio(contentMode: .fill) .overlay { // Build the gradient material by filling an area with a material, and // then masking that area using a linear gradient. Rectangle() .fill(.regularMaterial) .mask { LinearGradient( stops: [\ .init(color: .black, location: 0.25),\ .init(color: .black.opacity(belowFold ? 1 : 0.3), location: 0.375),\ .init(color: .black.opacity(belowFold ? 1 : 0), location: 0.5)\ ], startPoint: .bottom, endPoint: .top ) } } .ignoresSafeArea() By adjusting the opacity of the gradient stops, rather than swapping out the mask view, you achieve a smooth animation between the above-the-fold appearance, where the material fades out above a certain height to reveal the image behind, and the below-the-fold appearance where the entire image blurs. ### Snap at the fold point You can implement a custom `ScrollTargetBehavior` to create a fold-snapping effect. Then add a check to determine whether the target of a scroll event is crossing a fold threshold, and update that target to either the top of the page (if moving upward) or to the top of your first content shelf (if moving downward). With your view already tracking the above/below fold state, it can pass that information into the behavior to indicate which operation to check for. ScrollView { // . . . } .scrollTargetBehavior( FoldSnappingScrollTargetBehavior( aboveFold: !belowFold, showcaseHeight: showcaseHeight)) struct FoldSnappingScrollTargetBehavior: ScrollTargetBehavior { var aboveFold: Bool var showcaseHeight: CGFloat func updateTarget(_ target: inout ScrollTarget, context: TargetContext) { // The view is above the fold and not moving far enough down, so make no // change. if aboveFold && target.rect.minY < showcaseHeight * 0.3 { return } // The view is below the fold, and the header isn't coming onscreen, so // make no change. return } // Upward movement: Require revealing over 30% of the header, or don't let // the scroll go upward. let showcaseRevealThreshold = showcaseHeight * 0.7 let snapToHideRange = showcaseRevealThreshold...showcaseHeight if aboveFold || snapToHideRange.contains(target.rect.origin.y) { // Snap to align the first content shelf at the top of the screen. target.rect.origin.y = showcaseHeight } else { // Snap upward to reveal the header. target.rect.origin.y = 0 } } } ### Provide product highlight pages It’s common for product pages to use a material gradient appearance with above- and below-the-fold snapping. You most likely need to tune the gradient a little differently to account for a taller bar of content at the bottom of the screen, but you typically want to keep the content’s showcase image, with a suitable blur, as a background for the view when scrolling below. This makes each product’s page unique, with its defining artwork tinting the content. This is the same effect that root screen on the Apple TV uses — the system blurs the most recently displayed top-shelf image and uses it as the background of the tvOS home screen. In your description view, you may want to display a stack of bordered buttons, and stretch each to the same width. SwiftUI implements bordered buttons by attaching a background to their labels, so increasing the size of the button view isn’t necessarily going to cause the background platter to grow. Instead, you need to specify that the _label content_ is able to expand, and its background then expands as well. Attaching a `frame(minWidth:idealWidth:maxWidth:minHeight:idealHeight:maxHeight:alignment:)` modifier to the button’s label content achieves this for you. VStack(spacing: 12) { Button { /* action */ } label: { Text("Sign Up") .font(.body.bold()) .frame(maxWidth: .infinity) } Button { /* action */ } label: { Text("Buy or Rent") .font(.body.bold()) .frame(maxWidth: .infinity) } Button { /* action */ } label: { Label("Add to Up Next", systemImage: "plus") .font(.body.bold()) .frame(maxWidth: .infinity) } } When displaying your content’s description, allow it to truncate on the page, and place it within a `Button` using the `.plain` style. People can then select it, and you can present the full description using an overlay view that you attach with the `fullScreenCover(isPresented:onDismiss:content:)` modifier. .fullScreenCover(isPresented: $showDescription) { VStack(alignment: .center) { Text(loremIpsum) .frame(maxWidth: 600) } } ### Search for content For your search page, prefer using a `LazyVGrid` to contain your results, and a landscape orientation for the lockups themselves. This allows more content to appear onscreen at one time, with several rows of three to five items per row. A tall content container area makes it much easier to see the effects of changes to your search term. The search implementation consists of simple view modifiers that function identically on each Apple platform. The `searchable(text:placement:prompt:)` modifier provides the entire search UI for you, binding the search field to the provided text. By attaching a `searchSuggestions(_:)` modifier, you can present a list of potential search keyword completions. These are commonly `Text` instances, but `Button` and `Label` also work. Be sure to sort your search results so that the content of your grid is stable and predictable. ScrollView(.vertical) { LazyVGrid( columns: Array(repeating: .init(.flexible(), spacing: 40), count: 4), spacing: 40 ) { ForEach(/* matching assets, sorted */) { asset in Button { /* action */ } label: { asset.landscapeImage .resizable() .aspectRatio(16 / 9, contentMode: .fit) Text(asset.title) } } } .buttonStyle(.borderless) } .scrollClipDisabled() .searchable(text: $searchTerm) .searchSuggestions { ForEach(/* keywords matching search term */, id: \.self) { suggestion in Text(suggestion) } } --- # https://developer.apple.com/documentation/swiftui/worldrecenterphase - SwiftUI - WorldRecenterPhase Beta Enumeration # WorldRecenterPhase A type that represents information associated with a phase of a system recenter event. Values of this type are passed to the closure specified in View.onWorldRecenter(action:). enum WorldRecenterPhase ## Topics ### Enumeration Cases `case began` The app has begun to fade out. It is not re-positioned yet. `case ended` The app has begun to fade in after it has been re-positioned. ## Relationships ### Conforms To - `Copyable` - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/uiapplicationdelegateadaptor). --- # https://developer.apple.com/documentation/swiftui/backyard-birds-sample) --- # https://developer.apple.com/documentation/swiftui/food_truck_building_a_swiftui_multiplatform_app) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/migrating-to-the-swiftui-life-cycle) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/uiapplicationdelegateadaptor) --- # https://developer.apple.com/documentation/swiftui/nsapplicationdelegateadaptor) --- # https://developer.apple.com/documentation/swiftui/wkapplicationdelegateadaptor) --- # https://developer.apple.com/documentation/swiftui/wkextensiondelegateadaptor) --- # https://developer.apple.com/documentation/swiftui/creating-a-tvos-media-catalog-app-in-swiftui) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/worldrecenterphase) --- # https://developer.apple.com/documentation/swiftui/scene/immersionstyle(selection:in:) #app-main) - SwiftUI - Scene - immersionStyle(selection:in:) Instance Method # immersionStyle(selection:in:) Sets the style for an immersive space. nonisolated func immersionStyle( in styles: any ImmersionStyle... ## Parameters `selection` A `Binding` to the style that the space uses. You can change this value to change the scene’s style even after you present the immersive space. Even though you provide a binding, the value changes only if you change it. `styles` The list of styles that the `selection` input can have. Include any styles that you plan to use during the lifetime of the scene. ## Return Value A scene that uses one of the specified `styles`. ## Discussion Use this modifier to configure the appearance and behavior of an `ImmersiveSpace`. Specify a style that conforms to the `ImmersionStyle` protocol, like `mixed` or `full`. For example, the following app defines a solar system scene that uses full immersion: @main struct SolarSystemApp: App { @State private var style: ImmersionStyle = .full var body: some Scene { ImmersiveSpace { SolarSystem() } .immersionStyle(selection: $style, in: .full) } } ## See Also ### Creating an immersive space `struct ImmersiveSpace` A scene that presents its content in an unbounded space. `struct ImmersiveSpaceContentBuilder` A result builder for composing a collection of immersive space elements. `protocol ImmersionStyle` The styles that an immersive space can have. `var immersiveSpaceDisplacement: Pose3D` The displacement that the system applies to the immersive space when moving the space away from its default position, in meters. `struct ImmersiveEnvironmentBehavior` The behavior of the system-provided immersive environments when a scene is opened by your app. Beta `struct ProgressiveImmersionAspectRatio` Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/immersionstyle/mixed - SwiftUI - ImmersionStyle - mixed Type Property # mixed An immersion style that displays unbounded content intermixed with other app content, along with passthrough video. static var mixed: MixedImmersionStyle { get } Available when `Self` is `MixedImmersionStyle`. ## Discussion When this immersion style is selected, the immersion amount reported by the closure of `onImmersionChange(initial:_:)` is `0.0`. Use the `immersionStyle(selection:in:)` scene modifier to specify this style for an `ImmersiveSpace`. However, this is the default immersion style if you don’t specify one. The immersion style affects how windows interact with virtual objects in the environment. In `mixed` immersion, a virtual object obscures part or all of a window that’s behind the object. Similarly, a window obscures a virtual object that’s behind the window. ## See Also ### Getting built-in styles `static var automatic: AutomaticImmersionStyle` The default immersion style. `static var full: FullImmersionStyle` An immersion style that displays unbounded content that completely replaces passthrough video. `static var progressive: ProgressiveImmersionStyle` An immersion style that displays unbounded content that partially replaces passthrough video. --- # https://developer.apple.com/documentation/swiftui/immersionstyle/full --- # https://developer.apple.com/documentation/swiftui/immersionstyle/progressive - SwiftUI - ImmersionStyle - progressive Type Property # progressive An immersion style that displays unbounded content that partially replaces passthrough video. static var progressive: ProgressiveImmersionStyle { get } Available when `Self` is `ProgressiveImmersionStyle`. ## Discussion The system initially uses a radial portal effect that replaces passthrough in a portion of the field of view. People can interactively adjust the size of the portal by turning the Digital Crown, including down to a minimum amount of immersion defined by the system and up to the point where the portal fully covers passthrough. If someone tries to reduce the portal size below the minimum value, the portal smoothly bounces immersion style, including the configurable visibility of the viewer’s upper limbs. When this immersion style is selected, the immersion amount reported by the closure of `onImmersionChange(initial:_:)` is within the range of the immersion that this style uses. Use the `immersionStyle(selection:in:)` scene modifier to specify this style for an `ImmersiveSpace`: @main struct ImmersiveApp: App { @State private var immersionStyle: ImmersionStyle = .progressive var body: some Scene { ImmersiveSpace { ... } .immersionStyle(selection: $immersionStyle, in: .progressive)) } } The immersion style affects how windows interact with virtual objects in the environment. In `progressive` immersion, windows always render in front of virtual content, no matter how someone positions the window or the content. This helps people avoid losing track of windows behind virtual content when passthrough is off. ## See Also ### Getting built-in styles `static var automatic: AutomaticImmersionStyle` The default immersion style. `static var full: FullImmersionStyle` An immersion style that displays unbounded content that completely replaces passthrough video. `static var mixed: MixedImmersionStyle` An immersion style that displays unbounded content intermixed with other app content, along with passthrough video. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/immersivespace - SwiftUI - ImmersiveSpace Structure # ImmersiveSpace A scene that presents its content in an unbounded space. ## Overview Use an immersive space as a container for a view hierarchy that your app presents. The hierarchy that you declare as the immersive space’s content serves as a template for it: @main struct SolarSystemApp: App { var body: some Scene { ImmersiveSpace { SolarSystem() } } } If you want to create a bounded scene instead, use one of the types that creates a window or a volume, like `WindowGroup` or `DocumentGroup`. ### Style the immersive space By default, immersive spaces use the `mixed` style which places virtual content in a person’s surroundings. You can select a different style for the immersive space by adding the `immersionStyle(selection:in:)` scene modifier to the scene. For example, you can completely control the visual experience using the `full` immersion style: @main struct SolarSystemApp: App { @State private var style: ImmersionStyle = .full var body: some Scene { ImmersiveSpace { SolarSystem() } .immersionStyle(selection: $style, in: .full) } } You can change the immersion style after presenting the immersive space by changing the modifier’s `selection` input, although you can only use one of the values that you specify in the modifier’s second parameter. For any style of immersion, the other parts of your app’s interface — namely its windows — remain visible. However, the immersion style affects how windows interact with virtual objects in the environment: - For the `mixed` style, a virtual object obscures part or all of a window that’s behind the object. Similarly, a window obscures a virtual object that’s behind the window. - For other styles, windows always render in front of virtual content, no matter how someone positions the window or the content. This helps people to avoid losing track of windows behind virtual content when passthrough is partially or completely off. ### Open an immersive space You can programmatically open an immersive space by giving it an identifier. For example, you can label the solar system view from the previous example: ImmersiveSpace(id: "solarSystem") { SolarSystem() } Elsewhere in your code, you use the `openImmersiveSpace` environment value to get the instance of the `OpenImmersiveSpaceAction` structure for a given `Environment`. You call the instance directly — for example, from a button’s closure, like in the following code — using the identifier: struct NewSolarSystemImmersiveSpace: View { var solarSystem: SolarSystem @Environment(\.openImmersiveSpace) private var openImmersiveSpace var body: some View { Button("Present Solar System") { Task { await openImmersiveSpace(id: "solarSystem") } } } } Mark the call to the action with `await` because it executes asynchronously. When your app opens an immersive space, the system hides all other visible apps. The system allows only one immersive space to be open at a time. Be sure to close the open immersive space before opening another one. ### Dismiss an immersive space You can dismiss an immersive space by calling the `dismissImmersiveSpace` action from the environment. For example, you can define a button that dismisses an immersive space: struct DismissImmersiveSpaceButton: View { @Environment(\.dismissImmersiveSpace) private var dismissImmersiveSpace var body: some View { Button("Close Solar System") { Task { await dismissImmersiveSpace() } } } } The dismiss action runs asynchronously, like the open action. You don’t need to specify an identifier when dismissing an immersive space because there can only be one immersive space open at a time. ### Present an immersive space at launch When an app launches, it opens an instance of the first scene that’s listed in the app’s body. However, to open an immersive space at launch, you need to provide additional configuration information in your app’s `Info.plist` file. In particular, set the `UIApplicationPreferredDefaultSceneSessionRole` key in the scene manifest to the value `UISceneSessionRoleImmersiveSpaceApplication`. To configure the style of the immersive space that opens at launch, add a scene configuration to the scene session role. Use the `UISceneInitialImmersionStyle` key together with a value that indicates one of the mixed, full, or progressive styles. See the initial immersion style key for more information. ## Topics ### Creating an immersive space `init(content:)` Creates an immersive space. ### Identifying an immersive space `init(id:content:)` Creates the immersive space associated with the specified identifier. Deprecated ### Creating a data-driven immersive space `init(for:content:)` Creates the immersive space for a specified type of presented data. `init(id:for:content:)` Creates the immersive space associated with an identifier for a specified type of presented data. ### Providing default data to an immersive space `init(for:content:defaultValue:)` `init(id:for:content:defaultValue:)` Creates the immersive space associated with an identifier for a specified type of presented data, and a default value, if the data is not set. ### Supporting types `struct ImmersiveSpaceViewContent` Immersive space content that uses a SwiftUI view hierarchy as the content. `protocol ImmersiveSpaceContent` A type that you can use as the content of an immersive space. ### Initializers `init(id:makeContent:)` ## Relationships ### Conforms To - `Scene` ## See Also ### Creating an immersive space `struct ImmersiveSpaceContentBuilder` A result builder for composing a collection of immersive space elements. Sets the style for an immersive space. `protocol ImmersionStyle` The styles that an immersive space can have. `var immersiveSpaceDisplacement: Pose3D` The displacement that the system applies to the immersive space when moving the space away from its default position, in meters. `struct ImmersiveEnvironmentBehavior` The behavior of the system-provided immersive environments when a scene is opened by your app. Beta `struct ProgressiveImmersionAspectRatio` Beta --- # https://developer.apple.com/documentation/swiftui/immersivespacecontentbuilder - SwiftUI - ImmersiveSpaceContentBuilder Structure # ImmersiveSpaceContentBuilder A result builder for composing a collection of immersive space elements. @resultBuilder struct ImmersiveSpaceContentBuilder ## Topics ## See Also ### Creating an immersive space `struct ImmersiveSpace` A scene that presents its content in an unbounded space. Sets the style for an immersive space. `protocol ImmersionStyle` The styles that an immersive space can have. `var immersiveSpaceDisplacement: Pose3D` The displacement that the system applies to the immersive space when moving the space away from its default position, in meters. `struct ImmersiveEnvironmentBehavior` The behavior of the system-provided immersive environments when a scene is opened by your app. Beta `struct ProgressiveImmersionAspectRatio` Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/immersionstyle - SwiftUI - ImmersionStyle Protocol # ImmersionStyle The styles that an immersive space can have. protocol ImmersionStyle ## Overview Configure the appearance and behavior of an `ImmersiveSpace` by adding the `immersionStyle(selection:in:)` scene modifier to the space and specifying a style that conforms to this protocol, like `mixed` or `full`. For example, the following app defines a solar system scene that uses full immersion: @main struct SolarSystemApp: App { @State private var style: ImmersionStyle = .full var body: some Scene { ImmersiveSpace { SolarSystem() } .immersionStyle(selection: $style, in: .full) } } ## Topics ### Getting built-in styles `static var automatic: AutomaticImmersionStyle` The default immersion style. `static var full: FullImmersionStyle` An immersion style that displays unbounded content that completely replaces passthrough video. `static var mixed: MixedImmersionStyle` An immersion style that displays unbounded content intermixed with other app content, along with passthrough video. `static var progressive: ProgressiveImmersionStyle` An immersion style that displays unbounded content that partially replaces passthrough video. ### Supporting types `struct AutomaticImmersionStyle` The default style of immersive spaces. `struct FullImmersionStyle` `struct MixedImmersionStyle` `struct ProgressiveImmersionStyle` ### Type Methods `static progressive(_:initialAmount:)` `static progressive(_:initialAmount:aspectRatio:)` Beta ## Relationships ### Conforming Types - `AutomaticImmersionStyle` - `FullImmersionStyle` - `MixedImmersionStyle` - `ProgressiveImmersionStyle` ## See Also ### Creating an immersive space `struct ImmersiveSpace` A scene that presents its content in an unbounded space. `struct ImmersiveSpaceContentBuilder` A result builder for composing a collection of immersive space elements. Sets the style for an immersive space. `var immersiveSpaceDisplacement: Pose3D` The displacement that the system applies to the immersive space when moving the space away from its default position, in meters. `struct ImmersiveEnvironmentBehavior` The behavior of the system-provided immersive environments when a scene is opened by your app. `struct ProgressiveImmersionAspectRatio` Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/environmentvalues/immersivespacedisplacement - SwiftUI - EnvironmentValues - immersiveSpaceDisplacement Instance Property # immersiveSpaceDisplacement The displacement that the system applies to the immersive space when moving the space away from its default position, in meters. var immersiveSpaceDisplacement: Pose3D { get } ## Discussion By default, the system places the origin of the immersive space at floor level, at the person’s feet. When joining a shared activity, the system moves the immersive space to an appropriate location for all participants. As participants join and leave the activity, the location of participants and the immersive space can update. Read this property to get the current offset of the immersive space relative to its default position. If you access this property outside of an open immersive space, it contains the value `identity`. If you display participant-specific views or entities in your shared activity, use the inverse of this displacement value to position those views and entities in the immersive space. Applying the inverse value positions them as if they were in a single-participant immersive space. In the following example, this value is applied to position a game HUD entity at the person’s location, rather than the shared activity’s location: @main struct GameApp: App { var body: some Scene { ImmersiveSpace { ImmersiveGameView() } } } struct ImmersiveGameView: View { @Environment(\.immersiveSpaceDisplacement) private var immersiveSpaceDisplacement let gameHUDEntity = makeGameHUDEntity() var body: some View { RealityView { content in // ... } update: { content in let inverseDisplacement = float4x4(immersiveSpaceDisplacement.inverse) gameHUDEntity.setTransformMatrix(inverseDisplacement, relativeTo: nil) } } } ## See Also ### Creating an immersive space `struct ImmersiveSpace` A scene that presents its content in an unbounded space. `struct ImmersiveSpaceContentBuilder` A result builder for composing a collection of immersive space elements. Sets the style for an immersive space. `protocol ImmersionStyle` The styles that an immersive space can have. `struct ImmersiveEnvironmentBehavior` The behavior of the system-provided immersive environments when a scene is opened by your app. Beta `struct ProgressiveImmersionAspectRatio` Beta --- # https://developer.apple.com/documentation/swiftui/immersiveenvironmentbehavior - SwiftUI - ImmersiveEnvironmentBehavior Beta Structure # ImmersiveEnvironmentBehavior The behavior of the system-provided immersive environments when a scene is opened by your app. struct ImmersiveEnvironmentBehavior ## Overview Use one of these values with the `immersiveEnvironmentBehavior(_:)` scene modifier to indicate how the immersive environment should behave when your app opens a scene. ## Topics ### Type Properties `static var automatic: ImmersiveEnvironmentBehavior` A behavior that matches the system default behavior. `static var coexist: ImmersiveEnvironmentBehavior` A behavior that keeps the system’s immersive environment as is when opening a scene. `static var replace: ImmersiveEnvironmentBehavior` A behavior that replaces any currently opened immersive environment with the new scene. ## Relationships ### Conforms To - `Equatable` - `Sendable` - `SendableMetatype` ## See Also ### Creating an immersive space `struct ImmersiveSpace` A scene that presents its content in an unbounded space. `struct ImmersiveSpaceContentBuilder` A result builder for composing a collection of immersive space elements. Sets the style for an immersive space. `protocol ImmersionStyle` The styles that an immersive space can have. `var immersiveSpaceDisplacement: Pose3D` The displacement that the system applies to the immersive space when moving the space away from its default position, in meters. `struct ProgressiveImmersionAspectRatio` Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/progressiveimmersionaspectratio - SwiftUI - ProgressiveImmersionAspectRatio Beta Structure # ProgressiveImmersionAspectRatio struct ProgressiveImmersionAspectRatio ## Topics ### Type Properties `static var automatic: ProgressiveImmersionAspectRatio` The system will choose a default portal aspect ratio. `static var landscape: ProgressiveImmersionAspectRatio` The portal will be wide. `static var portrait: ProgressiveImmersionAspectRatio` The portal will be tall. ## Relationships ### Conforms To - `Equatable` - `Sendable` - `SendableMetatype` ## See Also ### Creating an immersive space `struct ImmersiveSpace` A scene that presents its content in an unbounded space. `struct ImmersiveSpaceContentBuilder` A result builder for composing a collection of immersive space elements. Sets the style for an immersive space. `protocol ImmersionStyle` The styles that an immersive space can have. `var immersiveSpaceDisplacement: Pose3D` The displacement that the system applies to the immersive space when moving the space away from its default position, in meters. `struct ImmersiveEnvironmentBehavior` The behavior of the system-provided immersive environments when a scene is opened by your app. Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/environmentvalues/openimmersivespace - SwiftUI - EnvironmentValues - openImmersiveSpace Instance Property # openImmersiveSpace An action that presents an immersive space. var openImmersiveSpace: OpenImmersiveSpaceAction { get } ## Discussion Use this environment value to get the instance of the `OpenImmersiveSpaceAction` structure for a given `Environment`. Then call the instance to present a space. You call the instance directly because it defines `callAsFunction()` methods that Swift calls when you call the instance. On macOS, this may be used to open a remote immersive space declared with `RemoteImmersiveSpace`. When your app opens a remote immersive space, the system may ask the user for a preferred device with which to display the content. For example, you can define a button that opens a specified planet in an immersive space: @main struct SolarSystemApp: App { var body: some Scene { ImmersiveSpace(for: Planet.ID.self) { $planetID in // ... } } } struct ShowPlanetButton: View { var planet: Planet @Environment(\.openImmersiveSpace) private var openImmersiveSpace var body: some View { Button("Show \(planet.name)") { Task { await openImmersiveSpace(value: planet.ID) } } } } You indicate which immersive space to open by providing one of the following: - A string identifier that you pass through the `id` parameter. - A `value` parameter that has a type that matches the type that you specify in the space’s initializer, as in the above example. - Both an identifier and a value. This enables you to define multiple spaces that take input values of the same type and distinguish them by their string identifiers. The call is asynchronous and returns after presenting the space or if an error occurs. You can check for errors by inspecting the call’s return value, which is of type `OpenImmersiveSpaceAction.Result`. For example, the call returns an error if you already have an immersive space open, because the system enables only one space to be open at a time. If you provide a value when you open the space, the scene’s trailing closure receives a binding to the value that you provide. For best performance, use lightweight data for the presentation value. For structured model values that conform to `Identifiable`, the value’s identifier makes a good presentation value, like the `planet.ID` value in the above code. ## See Also ### Opening an immersive space `struct OpenImmersiveSpaceAction` Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/openimmersivespaceaction - SwiftUI - OpenImmersiveSpaceAction Structure # OpenImmersiveSpaceAction An action that presents an immersive space. @MainActor struct OpenImmersiveSpaceAction ## Overview Use the `openImmersiveSpace` environment value to get the instance of this structure for a given `Environment`. Then call the instance to present a space. You call the instance directly because it defines `callAsFunction()` methods that Swift calls when you call the instance. On macOS, this may be used to open a remote immersive space declared with `RemoteImmersiveSpace`. When your app opens a remote immersive space, the system may ask the user for a preferred device with which to display the content. For example, you can define a button that opens a specified planet in an immersive space: @main struct SolarSystemApp: App { var body: some Scene { ImmersiveSpace(for: Planet.ID.self) { $planetID in // ... } } } struct ShowPlanetButton: View { var planet: Planet @Environment(\.openImmersiveSpace) private var openImmersiveSpace var body: some View { Button("Show \(planet.name)") { Task { await openImmersiveSpace(value: planet.ID) } } } } You indicate which immersive space to open by providing one of the following: - A string identifier that you pass through the `id` parameter. - A `value` parameter that has a type that matches the type that you specify in the space’s initializer, as in the above example. - Both an identifier and a value. This enables you to define multiple spaces that take input values of the same type and distinguish them by their string identifiers. The call is asynchronous and returns after presenting the space or if an error occurs. You can check for errors by inspecting the call’s return value, which is of type `OpenImmersiveSpaceAction.Result`. For example, the call returns an error if you already have an immersive space open, because the system enables only one space to be open at a time. If you provide a value when you open the space, the scene’s trailing closure receives a binding to the value that you provide. For best performance, use lightweight data for the presentation value. For structured model values that conform to `Identifiable`, the value’s identifier makes a good presentation value, like the `planet.ID` value in the above code. ## Topics ### Calling the action Presents an immersive space for the scene with the specified identifier. Presents the immersive space that your app defines for the specified identifier and that handles the type of the presented value. Presents the immersive space that handles the type of the presented value. ### Getting the result `enum Result` The outcome of an attempt to open an immersive space. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Opening an immersive space `var openImmersiveSpace: OpenImmersiveSpaceAction` Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/environmentvalues/dismissimmersivespace - SwiftUI - EnvironmentValues - dismissImmersiveSpace Instance Property # dismissImmersiveSpace An immersive space dismissal action stored in a view’s environment. var dismissImmersiveSpace: DismissImmersiveSpaceAction { get } ## Discussion Use this environment value to get a `DismissImmersiveSpaceAction` instance for a given `Environment`. Then call the instance to dismiss a space. You call the instance directly because it defines a `callAsFunction()` method that Swift calls when you call the instance. On macOS, this may be used to dismiss a remote immersive space declared with `RemoteImmersiveSpace`. For example, you can define a button that dismisses an immersive space: @main struct MyApp: App { var body: some Scene { WindowGroup { DismissImmersiveSpaceButton() } ImmersiveSpace(id: "solarSystem") { SolarSystemView() } } } struct DismissImmersiveSpaceButton: View { @Environment(\.dismissImmersiveSpace) private var dismissImmersiveSpace var body: some View { Button("Dismiss") { Task { await dismissImmersiveSpace() } } } } The asynchronous call returns after the system finishes dismissing the space. Unlike the call to `openImmersiveSpace` that you use to open the space — which requires an identifier, a value, or both to specify which space to open — the dismiss action requires no parameters because there can be only one immersive space open at a time. The call closes the space that is currently open, if any. ## See Also ### Closing the immersive space `struct DismissImmersiveSpaceAction` An action that dismisses an immersive space. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/dismissimmersivespaceaction - SwiftUI - DismissImmersiveSpaceAction Structure # DismissImmersiveSpaceAction An action that dismisses an immersive space. @MainActor struct DismissImmersiveSpaceAction ## Overview Use the `dismissImmersiveSpace` environment value to get an instance of this type for a given `Environment`. Then call the instance to dismiss a space. You call the instance directly because it defines a `callAsFunction()` method that Swift calls when you call the instance. On macOS, this may be used to dismiss a remote immersive space declared with `RemoteImmersiveSpace`. For example, you can define a button that dismisses an immersive space: @main struct MyApp: App { var body: some Scene { WindowGroup { DismissImmersiveSpaceButton() } ImmersiveSpace(id: "solarSystem") { SolarSystemView() } } } struct DismissImmersiveSpaceButton: View { @Environment(\.dismissImmersiveSpace) private var dismissImmersiveSpace var body: some View { Button("Dismiss") { Task { await dismissImmersiveSpace() } } } } The asynchronous call returns after the system finishes dismissing the space. Unlike the call to `openImmersiveSpace` that you use to open the space — which requires an identifier, a value, or both to specify which space to open — the dismiss action requires no parameters because there can be only one immersive space open at a time. The call closes the space that is currently open, if any. ## Topics ### Calling the action `func callAsFunction() async` Dismisses the currently opened immersive space. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Closing the immersive space `var dismissImmersiveSpace: DismissImmersiveSpaceAction` An immersive space dismissal action stored in a view’s environment. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/scene/upperlimbvisibility(_:) #app-main) - SwiftUI - Scene - upperLimbVisibility(\_:) Instance Method # upperLimbVisibility(\_:) Sets the preferred visibility of the user’s upper limbs, while an `ImmersiveSpace` scene is presented. nonisolated ## Parameters `preferredVisibility` A value indicating if the upper limbs should be visible. Use `.automatic` for a system-defined standard behavior, `.visible` to keep the upper limbs visible, and `.hidden` to hide the upper limbs. ## Discussion The system can show the user’s upper limbs during fully immersive experiences, but you can also hide them, for example, in order to display virtual hands instead. Note that this modifier only sets a preference and ultimately the system will decide if it will honor it or not. The system may by unable to honor the preference if the immersive space is currently not visible. ## See Also ### Hiding upper limbs during immersion Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/upperlimbvisibility(_:) #app-main) - SwiftUI - View - upperLimbVisibility(\_:) Instance Method # upperLimbVisibility(\_:) Sets the preferred visibility of the user’s upper limbs, while an `ImmersiveSpace` scene is presented. nonisolated ## Parameters `preferredVisibility` A value indicating if the upper limbs should be visible. Use `.automatic` for a system-defined standard behavior, `.visible` to keep the upper limbs visible, and `.hidden` to hide the upper limbs. ## Discussion The system can show the user’s upper limbs during fully immersive experiences, but you can also hide them, for example, in order to display virtual hands instead. Note that this modifier only sets a preference and ultimately the system will decide if it will honor it or not. The system may by unable to honor the preference if the immersive space is currently not visible. ## See Also ### Hiding upper limbs during immersion --- # https://developer.apple.com/documentation/swiftui/scene/immersivecontentbrightness(_:) #app-main) - SwiftUI - Scene - immersiveContentBrightness(\_:) Instance Method # immersiveContentBrightness(\_:) Sets the content brightness of an immersive space. nonisolated ## Parameters `brightness` The level of content brightness that you prefer. ## Return Value A scene that has the specified content brightness. ## Discussion Pass one of the standard brightness levels defined in `ImmersiveContentBrightness` or a custom one that you create with the `custom(_:)` method to this scene modifier to set a preference for the content brightness in an `ImmersiveSpace`. The system takes the value that you set into account, but might not be able to honor a specific preference. When you do this to create an environment that’s suitable for video playback, the standard brightness values provide good results for most use cases. To optimize further, you can create a custom brightness using a normalized value that expresses the linear brightness ratio between a standard dynamic range white video frame and the background that surrounds the player window. ## See Also ### Adjusting content brightness `struct ImmersiveContentBrightness` The content brightness of an immersive space. --- # https://developer.apple.com/documentation/swiftui/immersivecontentbrightness - SwiftUI - ImmersiveContentBrightness Structure # ImmersiveContentBrightness The content brightness of an immersive space. struct ImmersiveContentBrightness ## Overview Use a value of this type as an input to the `immersiveContentBrightness(_:)` scene modifier to indicate the ambient content brightness of an `ImmersiveSpace`. When you do this to create an environment that’s suitable for video playback, use one of the standard brightness values like `bright`, `dim`, or `dark` to provide good results for most use cases. To optimize further, you can create a custom brightness using a normalized value that expresses the linear brightness ratio between a standard dynamic range white video frame and the background that surrounds the player window. ## Topics ### Type Properties `static let automatic: ImmersiveContentBrightness` The default content brightness. `static let bright: ImmersiveContentBrightness` A bright content brightness. `static let dark: ImmersiveContentBrightness` A dark content brightness. `static let dim: ImmersiveContentBrightness` A dimmed content brightness. ### Type Methods Creates a content brightness with a custom value. ## Relationships ### Conforms To - `Equatable` ## See Also ### Adjusting content brightness Sets the content brightness of an immersive space. --- # https://developer.apple.com/documentation/swiftui/view/onimmersionchange(initial:_:) #app-main) - SwiftUI - View - onImmersionChange(initial:\_:) Instance Method # onImmersionChange(initial:\_:) Performs an action when the immersion state of your app changes. nonisolated func onImmersionChange( initial: Bool = true, ## Parameters `initial` Whether the action should be run when this view initially appears. `action` A closure to run when the immersion changes. ## Discussion Depending on the immersion style used for the Immersive Space in your app, the amount of immersion can be controlled by actions such as turning the Digital Crown. Use this modifier to define a closure that is run when the immersion state changes. The following example sets the value of a binding depending on the current amount of immersion: struct ImmersiveView: View { @Binding var enableSoundEffects: Bool var body: some View { MyView() .onImmersionChange { _, newImmersion in guard let amount = newImmersion.amount else { enableSoundEffects = false return } // Enable some effects based on the updated // amount of immersion } } } ## See Also ### Responding to immersion changes `struct ImmersionChangeContext` A structure that represents a state of immersion of your app. --- # https://developer.apple.com/documentation/swiftui/immersionchangecontext - SwiftUI - ImmersionChangeContext Structure # ImmersionChangeContext A structure that represents a state of immersion of your app. struct ImmersionChangeContext ## Overview You don’t use this structure directly. Instead, SwiftUI provides instances of this structure via the `onImmersionChange` modifier’s closure. ## Topics ### Instance Properties `let amount: Double?` The current amount of immersion. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Responding to immersion changes Performs an action when the immersion state of your app changes. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/immersiveenvironmentpicker(content:) #app-main) - SwiftUI - View - immersiveEnvironmentPicker(content:) Instance Method # immersiveEnvironmentPicker(content:) Add menu items to open immersive spaces from a media player’s environment picker. nonisolated ## Discussion These items are added alongside recently used system environments. SystemPlayerView(player: player) .immersiveEnvironmentPicker { Button("Chalet", systemImage: "fireplace") { Task { await openImmersiveSpace(id: "Chalet") } } } Use a `UIViewControllerRepresentable` instance to display a `AVPlayerViewController` class in your SwiftUI interface. struct SystemPlayerView: UIViewControllerRepresentable { let player: AVPlayer return AVPlayerViewController() } func updateUIViewController(_ avPlayerViewController: AVPlayerViewController, context: Context) { viewController.player = player } } Items will be donated to media players (like `AVPlayerViewController`) downstream in the hierarchy. --- # https://developer.apple.com/documentation/swiftui/remoteimmersivespace --- # https://developer.apple.com/documentation/swiftui/remotedeviceidentifier - SwiftUI - RemoteDeviceIdentifier Beta Structure # RemoteDeviceIdentifier An opaque type that identifies a remote device displaying scene content in a `RemoteImmersiveSpace`. struct RemoteDeviceIdentifier ## Overview Access this from the `remoteDeviceIdentifier` environment property in a remote scene to get the identifier for that scene’s device. When accessed in a context that is being presented on the local device, this value will be `nil`. This identifier can also be used to initialize an `ARKitSession` associated with the remote device. struct SolarSystem: CompositorContent { @Environment(\.remoteDeviceIdentifier) private var deviceID var body: some CompositorContent { RemoteImmersiveSpace { CompositorLayer { layerRenderer in // Create an ARSession for the device let arSession = ARKitSession(deviceID) // Set up and run the Metal render loop. let renderThread = Thread { let engine = solar_engine_create( layerRenderer, arSession) solar_engine_render_loop(engine) } renderThread.name = "Render Thread" renderThread.start() } } } } ## Topics ### Instance Properties `var cDevice: ar_device_t` Returns the `ar_device` associated with this device. ## Relationships ### Conforms To - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Handling remote immersive spaces `struct RemoteImmersiveSpace` A scene that presents its content in an unbounded space on a remote device. Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/scene/immersionstyle(selection:in:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/immersionstyle/mixed) --- # https://developer.apple.com/documentation/swiftui/immersionstyle/full) --- # https://developer.apple.com/documentation/swiftui/immersionstyle/progressive) --- # https://developer.apple.com/documentation/swiftui/immersivespace) --- # https://developer.apple.com/documentation/swiftui/immersivespacecontentbuilder) --- # https://developer.apple.com/documentation/swiftui/immersionstyle) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/immersivespacedisplacement) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/immersiveenvironmentbehavior) --- # https://developer.apple.com/documentation/swiftui/progressiveimmersionaspectratio) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/openimmersivespace) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/openimmersivespaceaction) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/dismissimmersivespace) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/dismissimmersivespaceaction) --- # https://developer.apple.com/documentation/swiftui/scene/upperlimbvisibility(_:)) --- # https://developer.apple.com/documentation/swiftui/view/upperlimbvisibility(_:)) --- # https://developer.apple.com/documentation/swiftui/scene/immersivecontentbrightness(_:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/immersivecontentbrightness) --- # https://developer.apple.com/documentation/swiftui/view/onimmersionchange(initial:_:)) --- # https://developer.apple.com/documentation/swiftui/immersionchangecontext) --- # https://developer.apple.com/documentation/swiftui/view/immersiveenvironmentpicker(content:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/remoteimmersivespace) --- # https://developer.apple.com/documentation/swiftui/remotedeviceidentifier) --- # https://developer.apple.com/documentation/swiftui/remoteimmersivespace). --- # https://developer.apple.com/documentation/swiftui/scene - SwiftUI - Scene Protocol # Scene A part of an app’s user interface with a life cycle managed by the system. @MainActor @preconcurrency protocol Scene ## Mentioned in Building and customizing the menu bar with SwiftUI Migrating to the SwiftUI life cycle ## Overview You create an `App` by combining one or more instances that conform to the `Scene` protocol in the app’s `body`. You can use the built-in scenes that SwiftUI provides, like `WindowGroup`, along with custom scenes that you compose from other scenes. To create a custom scene, declare a type that conforms to the `Scene` protocol. Implement the required `body` computed property and provide the content for your custom scene: struct MyScene: Scene { var body: some Scene { WindowGroup { MyRootView() } } } A scene acts as a container for a view hierarchy that you want to display to the user. The system decides when and how to present the view hierarchy in the user interface in a way that’s platform-appropriate and dependent on the current state of the app. For example, for the window group shown above, the system lets the user create or remove windows that contain `MyRootView` on platforms like macOS and iPadOS. On other platforms, the same view hierarchy might consume the entire display when active. Read the `scenePhase` environment value from within a scene or one of its views to check whether a scene is active or in some other state. You can create a property that contains the scene phase, which is one of the values in the `ScenePhase` enumeration, using the `Environment` attribute: struct MyScene: Scene { @Environment(\.scenePhase) private var scenePhase // ... } The `Scene` protocol provides scene modifiers, defined as protocol methods with default implementations, that you use to configure a scene. For example, you can use the `onChange(of:perform:)` modifier to trigger an action when a value changes. The following code empties a cache when all of the scenes in the window group have moved to the background: struct MyScene: Scene { @Environment(\.scenePhase) private var scenePhase @StateObject private var cache = DataCache() var body: some Scene { WindowGroup { MyRootView() } .onChange(of: scenePhase) { newScenePhase in if newScenePhase == .background { cache.empty() } } } } A type conforming to this protocol inherits `@preconcurrency @MainActor` isolation from the protocol if the conformance is included in the type’s base declaration: struct MyCustomType: Transition { // `@preconcurrency @MainActor` isolation by default } Isolation to the main actor is the default, but it’s not required. Declare the conformance in an extension to opt out of main actor isolation: extension MyCustomType: Transition { // `nonisolated` by default } ## Topics ### Creating a scene `var body: Self.Body` The content and behavior of the scene. **Required** `associatedtype Body : Scene` The type of scene that represents the body of this scene. ### Watching for changes `func onChange(of:initial:_:)` Adds an action to perform when the given value changes. Specifies the external events for which SwiftUI opens a new instance of the modified scene. ### Creating background tasks Runs the specified action when the system provides a background task. ### Managing app storage The default store used by `AppStorage` contained within the scene and its view content. ### Setting commands Adds commands to the scene. Removes all commands defined by the modified scene. Replaces all commands defined by the modified scene with the commands from the builder. Defines a keyboard shortcut for opening new scene windows. ### Sizing and positioning the scene Sets a default position for a window. `func defaultSize(_:)` Sets a default size for a window. Sets a default width and height for a window. Sets a default size for a volumetric window. Defines a function used for determining the default placement of windows. Sets the kind of resizability to use for a window. Specifies how windows derived form this scene should determine their size when zooming. Provides a function which determines a placement to use when windows of a scene zoom. Configures the role for windows derived from `self` when participating in a managed window context, such as full screen or Stage Manager. ### Interacting with volumes Specifies how a volume should be aligned when moved in the world. Specify the world scaling behavior for the window. ### Configuring scene visibility Sets the default launch behavior for this scene. Sets the restoration behavior for this scene. Sets the preferred visibility of the non-transient system views overlaying the app. ### Styling the scene Sets the style for an immersive space. Sets the preferred visibility of the user’s upper limbs, while an `ImmersiveSpace` scene is presented. Sets the style for windows created by this scene. Sets the window level of this scene. Sets the style for the toolbar defined within this scene. Sets the label style of items in a toolbar and enables user customization. Sets the label style of items in a toolbar. ### Configuring a data model Sets the model context in this scene’s environment. Sets the model container and associated model context in this scene’s environment. `func modelContainer(for:inMemory:isAutosaveEnabled:isUndoEnabled:onSetup:)` Sets the model container in this scene for storing the provided model type, creating a new container if necessary, and also sets a model context for that container in this scene’s environment. ### Managing the environment Places an observable object in the scene’s environment. Sets the environment value of the specified key path to the given value. Supplies an `ObservableObject` to a view subhierarchy. Transforms the environment value of the specified key path with the given function. ### Interacting with dialogs Configures the icon used by alerts. Sets the severity for alerts. Enables user suppression of an alert with a custom suppression message. `func dialogSuppressionToggle(_:isSuppressed:)` ### Supporting drag behavior Configures the behavior of dragging a window by its background. ### Deprecated symbols Deprecated ### Instance Methods Adds to a `DocumentGroupLaunchScene` actions that accept a list of selected files as their parameter. Sets the content brightness of an immersive space. Sets the immersive environment behavior that should apply when this scene opens. Beta Sets the style for menu bar extra created by this scene. ## Relationships ### Conforming Types - `AlertScene` - `AssistiveAccess` - `DocumentGroup` - `DocumentGroupLaunchScene` - `Group` Conforms when `Content` conforms to `Scene`. - `ImmersiveSpace` - `MenuBarExtra` - `ModifiedContent` Conforms when `Content` conforms to `Scene` and `Modifier` conforms to `_SceneModifier`. - `RemoteImmersiveSpace` - `Settings` - `UtilityWindow` - `WKNotificationScene` - `Window` - `WindowGroup` ## See Also ### Creating scenes `struct SceneBuilder` A result builder for composing a collection of scenes into a single composite scene. --- # https://developer.apple.com/documentation/swiftui/scene/commands(content:) #app-main) - SwiftUI - Scene - commands(content:) Instance Method # commands(content:) Adds commands to the scene. nonisolated ## Mentioned in Building and customizing the menu bar with SwiftUI ## Discussion Commands are realized in different ways on different platforms. On macOS, the main menu uses the available command menus and groups to organize its main menu items. Each menu is represented as a top-level menu bar menu, and each command group has a corresponding set of menu items in one of the top-level menus, delimited by separator menu items. On iPadOS, commands with keyboard shortcuts are exposed in the shortcut discoverability HUD that users see when they hold down the Command (⌘) key. ## See Also ### Defining commands Removes all commands defined by the modified scene. Replaces all commands defined by the modified scene with the commands from the builder. `protocol Commands` Conforming types represent a group of related commands that can be exposed to the user via the main menu on macOS and key commands on iOS. `struct CommandMenu` Command menus are stand-alone, top-level containers for controls that perform related, app-specific commands. `struct CommandGroup` Groups of controls that you can add to existing command menus. `struct CommandsBuilder` Constructs command sets from multi-expression closures. Like `ViewBuilder`, it supports up to ten expressions in the closure body. `struct CommandGroupPlacement` The standard locations that you can place new command groups relative to. --- # https://developer.apple.com/documentation/swiftui/scenebuilder - SwiftUI - SceneBuilder Structure # SceneBuilder A result builder for composing a collection of scenes into a single composite scene. @resultBuilder struct SceneBuilder ## Topics ### Building content `static buildBlock(_:)` Passes a single scene written as a child scene through unmodified. Builds an expression within the builder. `static buildLimitedAvailability(_:)` Processes scene content for a conditional compiler-control statement that performs an availability check. Produces an optional scene for conditional statements in multi-statement closures that’s only visible when the condition evaluates to true. ## See Also ### Creating scenes `protocol Scene` A part of an app’s user interface with a life cycle managed by the system. --- # https://developer.apple.com/documentation/swiftui/environmentvalues/scenephase - SwiftUI - EnvironmentValues - scenePhase Instance Property # scenePhase The current phase of the scene. var scenePhase: ScenePhase { get set } ## Discussion The system sets this value to provide an indication of the operational state of a scene or collection of scenes. The exact meaning depends on where you access the value. For more information, see `ScenePhase`. ## See Also ### Monitoring scene life cycle `enum ScenePhase` An indication of a scene’s operational state. --- # https://developer.apple.com/documentation/swiftui/scenephase - SwiftUI - ScenePhase Enumeration # ScenePhase An indication of a scene’s operational state. enum ScenePhase ## Mentioned in Migrating to the SwiftUI life cycle ## Overview The system moves your app’s `Scene` instances through phases that reflect a scene’s operational state. You can trigger actions when the phase changes. Read the current phase by observing the `scenePhase` value in the `Environment`: @Environment(\.scenePhase) private var scenePhase How you interpret the value depends on where it’s read from. If you read the phase from inside a `View` instance, you obtain a value that reflects the phase of the scene that contains the view. The following example uses the `onChange(of:initial:_:)` method to enable a timer whenever the enclosing scene enters the `ScenePhase.active` phase and disable the timer when entering any other phase: struct MyView: View { @ObservedObject var model: DataModel @Environment(\.scenePhase) private var scenePhase var body: some View { TimerView() .onChange(of: scenePhase) { model.isTimerRunning = (scenePhase == .active) } } } If you read the phase from within an `App` instance, you obtain an aggregate value that reflects the phases of all the scenes in your app. The app reports a value of `ScenePhase.active` if any scene is active, or a value of `ScenePhase.inactive` when no scenes are active. This includes multiple scene instances created from a single scene declaration; for example, from a `WindowGroup`. When an app enters the `ScenePhase.background` phase, expect the app to terminate soon after. You can use that opportunity to free any resources: @main struct MyApp: App { @Environment(\.scenePhase) private var scenePhase var body: some Scene { WindowGroup { MyRootView() } .onChange(of: scenePhase) { if scenePhase == .background { // Perform cleanup when all scenes within // MyApp go to the background. } } } } ## Topics ### Getting scene phases `case active` The scene is in the foreground and interactive. `case inactive` The scene is in the foreground but should pause its work. `case background` The scene isn’t currently visible in the UI. ## Relationships ### Conforms To - `Comparable` - `Copyable` - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Monitoring scene life cycle `var scenePhase: ScenePhase` The current phase of the scene. --- # https://developer.apple.com/documentation/swiftui/settings - SwiftUI - Settings Structure # Settings A scene that presents an interface for viewing and modifying an app’s settings. ## Mentioned in Declaring a custom view Building and customizing the menu bar with SwiftUI ## Overview Use a settings scene to have SwiftUI manage views with controls for your app’s settings when you declare your app using the `App` protocol. When you use an `App` declaration for multiple platforms, compile the settings scene only in macOS: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } #if os(macOS) Settings { SettingsView() } #endif } } Passing a view as the argument to a settings scene in the `App` declaration causes SwiftUI to enable the app’s Settings menu item. SwiftUI manages displaying and removing the settings view when the user selects the Settings item from the application menu or the equivalent keyboard shortcut: The contents of your settings view are controls that modify bindings to `UserDefaults` values that SwiftUI manages using the `AppStorage` property wrapper: struct GeneralSettingsView: View { @AppStorage("showPreview") private var showPreview = true @AppStorage("fontSize") private var fontSize = 12.0 var body: some View { Form { Toggle("Show Previews", isOn: $showPreview) Slider(value: $fontSize, in: 9...96) { Text("Font Size (\(fontSize, specifier: "%.0f") pts)") } } } } You can define your settings in a single view, or you can use a `TabView` to group settings into different collections: struct SettingsView: View { var body: some View { TabView { Tab("General", systemImage: "gear") { GeneralSettingsView() } Tab("Advanced", systemImage: "star") { AdvancedSettingsView() } } .scenePadding() .frame(maxWidth: 350, minHeight: 100) } } ## Topics ### Creating a settings scene Creates a scene that presents an interface for viewing and modifying an app’s preferences. ## Relationships ### Conforms To - `Scene` ## See Also ### Managing a settings window `struct SettingsLink` A view that opens the Settings scene defined by an app. `struct OpenSettingsAction` An action that presents the settings scene for an app. `var openSettings: OpenSettingsAction` A Settings presentation action stored in a view’s environment. --- # https://developer.apple.com/documentation/swiftui/settingslink - SwiftUI - SettingsLink Structure # SettingsLink A view that opens the Settings scene defined by an app. ## Overview On macOS, clicking on the link opens the window for the scene or orders it to the front if it is already open. ## Topics ### Creating a settings link `init()` Creates a settings link with the default system label. Creates a settings link with a custom label. ### Supporting types `struct DefaultSettingsLinkLabel` The default label to use for a settings link. ## Relationships ### Conforms To - `View` ## See Also ### Managing a settings window `struct Settings` A scene that presents an interface for viewing and modifying an app’s settings. `struct OpenSettingsAction` An action that presents the settings scene for an app. `var openSettings: OpenSettingsAction` A Settings presentation action stored in a view’s environment. --- # https://developer.apple.com/documentation/swiftui/opensettingsaction - SwiftUI - OpenSettingsAction Structure # OpenSettingsAction An action that presents the settings scene for an app. @MainActor @preconcurrency struct OpenSettingsAction ## Overview Use the `openSettings` environment value to get the instance of this structure for a given `Environment`. Then call the instance to open a window. You call the instance directly because it defines a `callAsFunction()` method that Swift calls when you call the instance. For example, you can define a button that opens the settings window to a particular tab: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } #if os(macOS) Settings { SettingsView() } #endif } } struct SettingsView: View { @AppStorage("selectedSettingsTab") private var selectedSettingsTab = SettingsTab.general var body: some View { TabView(selection: $selectedSettingsTab) { GeneralSettings() AdvancedSettings() } } } struct AdvancedSettingsButton: View { @AppStorage("selectedSettingsTab") private var selectedSettingsTab = SettingsTab.general @Environment(\.openSettings) private var openSettings var body: some View { Button("Open Advanced Settings…") { selectedSettingsTab = .advanced openSettings() } } } enum SettingsTab: Int { case general case advanced } ## Topics ### Instance Methods `func callAsFunction()` Opens the window associated to the `Settings` scene defined by this app, if one exists. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` ## See Also ### Managing a settings window `struct Settings` A scene that presents an interface for viewing and modifying an app’s settings. `struct SettingsLink` A view that opens the Settings scene defined by an app. `var openSettings: OpenSettingsAction` A Settings presentation action stored in a view’s environment. --- # https://developer.apple.com/documentation/swiftui/environmentvalues/opensettings - SwiftUI - EnvironmentValues - openSettings Instance Property # openSettings A Settings presentation action stored in a view’s environment. var openSettings: OpenSettingsAction { get } ## Discussion Use the `openSettings` environment value to get an `OpenSettingsAction` instance for a given `Environment`. Then call the instance to open a window. You call the instance directly because it defines a `callAsFunction()` method that Swift calls when you call the instance. For example, you can define a button that opens the settings window to a particular tab: @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } #if os(macOS) Settings { SettingsView() } #endif } } struct SettingsView: View { @AppStorage("selectedSettingsTab") private var selectedSettingsTab = SettingsTab.general var body: some View { TabView(selection: $selectedSettingsTab) { GeneralSettings() AdvancedSettings() } } } struct AdvancedSettingsButton: View { @AppStorage("selectedSettingsTab") private var selectedSettingsTab = SettingsTab.general @Environment(\.openSettings) private var openSettings var body: some View { Button("Open Advanced Settings…") { selectedSettingsTab = .advanced openSettings() } } } enum SettingsTab: Int { case general case advanced } ## See Also ### Managing a settings window `struct Settings` A scene that presents an interface for viewing and modifying an app’s settings. `struct SettingsLink` A view that opens the Settings scene defined by an app. `struct OpenSettingsAction` An action that presents the settings scene for an app. --- # https://developer.apple.com/documentation/swiftui/building-and-customizing-the-menu-bar-with-swiftui - SwiftUI - Menus and commands - Building and customizing the menu bar with SwiftUI Article # Building and customizing the menu bar with SwiftUI Provide a seamless, cross-platform user experience by building a native menu bar for iPadOS and macOS. ## Overview On iPadOS and macOS, the menu bar provides access to crucial system-provided actions, such as Cut, Copy, Paste, and window management. The system groups these actions by function into menus and submenus through the menu bar. Apps can add contextual actions, like showing and hiding a sidebar, and can also create custom menus and menu items to allow people to perform app-specific actions from the menu bar. You can also bind menu bar to keyboard shortcuts to make your app quicker and easier to use. Apps include instances of `Scene` which display the main views of the app. Each scene provides different default menu sets and actions in the menu bar. Contextually relevant menus and actions, and even custom menus and actions, are specified with the `commands(content:)` modifier. The order of system-provided menus and menu items is consistent across all apps, but some menus and menu items are added depending on context. For example, document-based apps include options in the File menu for creating and opening documents. Similarly, not all apps include text-formatting capabilities, but those that include text editing views get a Format menu with options for choosing fonts and styling text by including `TextFormattingCommands` in the scene’s commands. The system will then add the appropriate menu groups and items that people expect in this context. ## Populate the menu bar When your app launches, the menu bar populates with menus and menu items based on the implemented scenes and commands. Menu items for conditional or context-dependent commands are made active or inactive dynamically, using information from the active scene and its view hierarchy in focus. Each scene includes a set of default menus and menu items, which you can supplement with your own app-specific needs using the `commands(content:)` modifier. A scene’s default menus and menu items are dependent on the functionality the scene type supports. For example, `WindowGroup` includes commands for quitting and hiding the app, as well as Copy and Paste support and window management. @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } } } @main struct MyApp: App { var body: some Scene { WindowGroup { ContentView() } #if os(macOS) Settings { SettingsView() } #endif } } The `DocumentGroup` scene includes actions that `WindowGroup` includes, as well as a number of actions that support document management capabilities, like Save and Duplicate. Using scenes together creates a menu bar that includes menu items for all of the core functionality of an app that creates and edits documents, manages multiple windows, and exposes user-configurable settings. @main struct MyApp: App { var body: some Scene { DocumentGroup(newDocument: MyAppDocument()) { file in // ... } #if os(macOS) Settings { // ... } #endif ## Add contextual system-provided menu items Some common menu items are optional, but are helpful if the app contains certain capabilities. For example, not every scene includes a navigation sidebar, but for those that do, people expect to find a menu item that controls the navigation sidebar’s visibility. If your scene includes a navigation sidebar, include this menu item using the `commands(content:)` modifier and implementing `SidebarCommands`: @main struct MyApp: App { var body: some Scene { DocumentGroup(newDocument: MyAppDocument()) { file in ContentView(document: file.$document) } .commands { SidebarCommands() } } } For more information on system-provided command groups, such as text formatting, toolbars, and inspectors, see `Commands`. ## Create custom menus and menu items Organize and group your app’s custom menu items in custom menus using `CommandMenu`. The system inserts custom menus into the menu bar after the View menu. Custom menu items are created with standard SwiftUI views, for example `Button` and `Toggle`. `Menu` creates a submenu. For more information about menu item creation, see Populating SwiftUI menus with adaptive controls. WindowGroup { ContentView() } .commands { CommandMenu("Actions") { Button("Run", systemImage: "play.fill") { ... } .keyboardShortcut("R") Button("Stop", systemImage: "stop.fill") { ... } .keyboardShortcut(".") } } ## Modify standard menus Modify system-provided menus using `CommandGroup`. These groups either extend menus with additional menu items or they replace existing menu items in the indicated command group. When you add menu items in this way, you can specify the location of the menu item based on system-provided menu items. WindowGroup { ContentView() } .commands { CommandGroup(before: .systemServices) { Button("Check for Updates") { ... } } CommandGroup(after: .newItem) { Button("New from Clipboard") { ... } } CommandGroup(replacing: .help) { Button("User Manual") { ... } } } ## Update menus and menu items dynamically Many menu items update their appearance or action depending on whether the scene is active, if the scene has focus, or what is currently selected. For example, the system grays out the Close Window command in the File menu when the app’s last window closes. Similarly, the Cut and Copy menu items are only available in the active window if the person selects copyable data. This behavior also applies to custom menus and menu items your app provides. Use `FocusedValue` to create contextual dependencies with your menus and menu items. For example, a menu item’s title can change if the current focus is on a photo or a photo album. A focused value is state data that requires an active scene with its view hierarchy in focus. Use a dynamic property to react to changes in the views of the scene. In the following, an app with a `WindowGroup` scene has an `Observable()` data model for each window that supplies that window’s contents. The active window’s data model is made available as a focused value using the `focusedSceneValue(_:)` modifier in the window view hierarchy. @Observable final class DataModel { var messages: [Message] ... } struct ContentView: View { @State private var model = DataModel() var body: some View { VStack { ForEach(model.messages) { ... } } .focusedSceneValue(model) } } Use the `FocusedValue` property wrapper to represent the active scene’s data model in the menu bar. The data model changes whether the “New Message” button is active or inactive: struct MessageCommands: Commands { @FocusedValue(DataModel.self) private var dataModel: DataModel? var body: some Commands { CommandGroup(after: .newItem) { Button("New Message") { dataModel?.messages.append(...) } .disabled(dataModel == nil) } } } @main struct MessagesApp: App { var body: some Scene { WindowGroup { ContentView() } .commands { MessageCommands() } } } Similar to the `Environment` dynamic property, `FocusedValue` uses a key you provide to find the current value. When the focused value is an `Observable` object, that key can simply be the object’s type. To share value-typed values, extend `FocusedValues` with a custom entry using the `Entry()` macro, and pass the resulting key path when declaring the `FocusedValue` property. Custom entry values must always be optional. struct ContentView: View { @State private var items: [Item] = ... @State private var selection: UUID? var body: some View { List(items, selection: $selection) { item in ... } // When active, views in the same scene or in the menu bar // can read the selected item ID. .focusedSceneValue(\.selectedItemID, selection) } } struct ItemCommands: Commands { @FocusedValue(\.selectedItemID) var selectedItemID: UUID? var body: some Commands { ... } } extension FocusedValues { @Entry var selectedItemID: UUID? } Use `focusedValue(_:)` when a menu item depends on the current placement of focus within the active scene’s view hierarchy. This creates a focused value that’s’ only visible to other views when focus is on the modified view or one of its subviews. When focus is elsewhere, the value of corresponding `FocusedValue` property is `nil`. var body: some View { NavigationSplitView { SidebarContent() } detail: { List(items, selection: $selection) { item in ... } // The selected item ID is visible when focus is on the // navigation detail list. If focus is on the sidebar, the value of // `@FocusedValue(\.selectedItemID)` is `nil`. .focusedValue(\.selectedItemID, selection) } } } --- # https://developer.apple.com/documentation/swiftui/menubarextra - SwiftUI - MenuBarExtra Structure # MenuBarExtra A scene that renders itself as a persistent control in the system menu bar. ## Overview Use a `MenuBarExtra` when you want to provide access to commonly used functionality, even when your app is not active. @main struct AppWithMenuBarExtra: App { @AppStorage("showMenuBarExtra") private var showMenuBarExtra = true var body: some Scene { WindowGroup { ContentView() } MenuBarExtra( "App Menu Bar Extra", systemImage: "star", isInserted: $showMenuBarExtra) { StatusMenu() } } } Or alternatively, to create a utility app that only shows in the menu bar. @main struct UtilityApp: App { var body: some Scene { MenuBarExtra("Utility App", systemImage: "hammer") { AppMenu() } } } An app that only shows in the menu bar will be automatically terminated if the user removes the extra from the menu bar. For apps that only show in the menu bar, a common behavior is for the app to not display its icon in either the Dock or the application switcher. To enable this behavior, set the `LSUIElement` flag in your app’s `Information Property List` file to `true`. For more complex or data rich menu bar extras, you can use the `window` style, which displays a popover-like window from the menu bar icon that contains standard controls. You define the layout and contents of those controls with the content that you provide: MenuBarExtra("Utility App", systemImage: "hammer") { ScrollView { LazyVGrid(...) } } .menuBarExtraStyle(.window) ## Topics ### Creating a menu bar extra `init(_:content:)` Creates a menu bar extra with a key for a localized string to use as the label. The extra defines the primary scene of an `App`. Creates a menu bar extra that will be displayed in the system menu bar, and defines the primary scene of an `App`. `init(_:isInserted:content:)` Creates a menu bar extra with a key for a localized string to use as the label. The item will be displayed in the system menu bar when the specified binding is set to `true`. If the user removes the item from the menu bar, the binding will be set to `false`. Creates a menu bar extra. The item will be displayed in the system menu bar when the specified binding is set to `true`. If the user removes the item from the menu bar, the binding will be set to `false`. ### Creating a menu bar extra with an image `init(_:image:content:)` Creates a menu bar extra with an image to use as the items label. The provided title will be used by the accessibility system. `init(_:image:isInserted:content:)` `init(_:systemImage:content:)` Creates a menu bar extra with a system image to use as the items label. The provided title will be used by the accessibility system. `init(_:systemImage:isInserted:content:)` ## Relationships ### Conforms To - `Scene` ## See Also ### Creating a menu bar extra Sets the style for menu bar extra created by this scene. `protocol MenuBarExtraStyle` A specification for the appearance and behavior of a menu bar extra scene. --- # https://developer.apple.com/documentation/swiftui/scene/menubarextrastyle(_:) #app-main) - SwiftUI - Scene - menuBarExtraStyle(\_:) Instance Method # menuBarExtraStyle(\_:) Sets the style for menu bar extra created by this scene. nonisolated ## See Also ### Creating a menu bar extra `struct MenuBarExtra` A scene that renders itself as a persistent control in the system menu bar. `protocol MenuBarExtraStyle` A specification for the appearance and behavior of a menu bar extra scene. --- # https://developer.apple.com/documentation/swiftui/menubarextrastyle - SwiftUI - MenuBarExtraStyle Protocol # MenuBarExtraStyle A specification for the appearance and behavior of a menu bar extra scene. protocol MenuBarExtraStyle ## Topics ### Getting menu bar extra styles `static var automatic: AutomaticMenuBarExtraStyle` The default menu bar extra style. `static var menu: PullDownMenuBarExtraStyle` A menu bar extra style that renders its contents as a menu that pulls down from the icon in the menu bar. `static var window: WindowMenuBarExtraStyle` A menu bar extra style that renders its contents in a popover-like window. ### Supporting types `struct AutomaticMenuBarExtraStyle` The default menu bar extra style. You can also use `automatic` to construct this style. `struct PullDownMenuBarExtraStyle` `struct WindowMenuBarExtraStyle` ## Relationships ### Conforming Types - `AutomaticMenuBarExtraStyle` - `PullDownMenuBarExtraStyle` - `WindowMenuBarExtraStyle` ## See Also ### Creating a menu bar extra `struct MenuBarExtra` A scene that renders itself as a persistent control in the system menu bar. Sets the style for menu bar extra created by this scene. --- # https://developer.apple.com/documentation/swiftui/wknotificationscene - SwiftUI - WKNotificationScene Structure # WKNotificationScene A scene which appears in response to receiving the specified category of remote or local notifications. ## Mentioned in Declaring a custom view ## Topics ### Creating a notification scene `init(controller: Controller.Type, category: String)` Creates a scene that appears in response to receiving a specific category of remote or local notifications. ## Relationships ### Conforms To - `Scene` --- # https://developer.apple.com/documentation/swiftui/scene) --- # https://developer.apple.com/documentation/swiftui/documents). --- # https://developer.apple.com/documentation/swiftui/scene/commands(content:)) --- # https://developer.apple.com/documentation/swiftui/scenebuilder) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/scenephase) --- # https://developer.apple.com/documentation/swiftui/scenephase) --- # https://developer.apple.com/documentation/swiftui/settings) --- # https://developer.apple.com/documentation/swiftui/settingslink) --- # https://developer.apple.com/documentation/swiftui/opensettingsaction) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/opensettings) --- # https://developer.apple.com/documentation/swiftui/building-and-customizing-the-menu-bar-with-swiftui) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/menubarextra) --- # https://developer.apple.com/documentation/swiftui/scene/menubarextrastyle(_:)) --- # https://developer.apple.com/documentation/swiftui/menubarextrastyle) --- # https://developer.apple.com/documentation/swiftui/wknotificationscene) --- # https://developer.apple.com/documentation/swiftui/navigationstack - SwiftUI - NavigationStack Structure # NavigationStack A view that displays a root view and enables you to present additional views over the root view. @MainActor @preconcurrency ## Mentioned in Migrating to new navigation types Understanding the navigation stack Adding a search interface to your app ## Overview Use a navigation stack to present a stack of views over a root view. People can add views to the top of the stack by clicking or tapping a `NavigationLink`, and remove views using built-in, platform-appropriate controls, like a Back button or a swipe gesture. The stack always displays the most recently added view that hasn’t been removed, and doesn’t allow the root view to be removed. To create navigation links, associate a view with a data type by adding a `navigationDestination(for:destination:)` modifier inside the stack’s view hierarchy. Then initialize a `NavigationLink` that presents an instance of the same kind of data. The following stack displays a `ParkDetails` view for navigation links that present data of type `Park`: NavigationStack { List(parks) { park in NavigationLink(park.name, value: park) } .navigationDestination(for: Park.self) { park in ParkDetails(park: park) } } In this example, the `List` acts as the root view and is always present. Selecting a navigation link from the list adds a `ParkDetails` view to the stack, so that it covers the list. Navigating back removes the detail view and reveals the list again. The system disables backward navigation controls when the stack is empty and the root view, namely the list, is visible. ### Manage navigation state By default, a navigation stack manages state to keep track of the views on the stack. However, your code can share control of the state by initializing the stack with a binding to a collection of data values that you create. The stack adds items to the collection as it adds views to the stack and removes items when it removes views. For example, you can create a `State` property to manage the navigation for the park detail view: @State private var presentedParks: [Park] = [] Initializing the state as an empty array indicates a stack with no views. Provide a `Binding` to this state property using the dollar sign ( `$`) prefix when you create a stack using the `init(path:root:)` initializer: NavigationStack(path: $presentedParks) { List(parks) { park in NavigationLink(park.name, value: park) } .navigationDestination(for: Park.self) { park in ParkDetails(park: park) } } Like before, when someone taps or clicks the navigation link for a park, the stack displays the `ParkDetails` view using the associated park data. However, now the stack also puts the park data in the `presentedParks` array. Your code can observe this array to read the current stack state. It can also modify the array to change the views on the stack. For example, you can create a method that configures the stack with a specific set of parks: func showParks() { presentedParks = [Park("Yosemite"), Park("Sequoia")] } The `showParks` method replaces the stack’s display with a view that shows details for Sequoia, the last item in the new `presentedParks` array. Navigating back from that view removes Sequoia from the array, which reveals a view that shows details for Yosemite. Use a path to support deep links, state restoration, or other kinds of programmatic navigation. ### Navigate to different view types To create a stack that can present more than one kind of view, you can add multiple `navigationDestination(for:destination:)` modifiers inside the stack’s view hierarchy, with each modifier presenting a different data type. The stack matches navigation links with navigation destinations based on their respective data types. To create a path for programmatic navigation that contains more than one kind of data, you can use a `NavigationPath` instance as the path. ## Topics ### Creating a navigation stack Creates a navigation stack that manages its own navigation state. ### Creating a navigation stack with a path `init(path:root:)` Creates a navigation stack with homogeneous navigation state that you can control. ## Relationships ### Conforms To - `View` ## See Also ### Stacking views in one column `struct NavigationPath` A type-erased list of data representing the content of a navigation stack. Associates a destination view with a presented data type for use within a navigation stack. Associates a destination view with a binding that can be used to push the view onto a `NavigationStack`. `func navigationDestination(item: Binding>, destination: (D) -> C) -> some View` Associates a destination view with a bound value for use within a navigation stack or navigation split view --- # https://developer.apple.com/documentation/swiftui/tabview - SwiftUI - TabView Structure # TabView A view that switches between multiple child views using interactive user interface elements. ## Overview To create a user interface with tabs, place `Tab` s in a `TabView`. On iOS, you can also use one of the badge modifiers, like `badge(_:)`, to assign a badge to each of the tabs. The following example creates a tab view with three tabs, each presenting a custom child view. The first tab has a numeric badge and the third has a string badge. TabView { Tab("Received", systemImage: "tray.and.arrow.down.fill") { ReceivedView() } .badge(2) Tab("Sent", systemImage: "tray.and.arrow.up.fill") { SentView() } Tab("Account", systemImage: "person.crop.circle.fill") { AccountView() } .badge("!") } To programatically select different tabs, use the `init(selection:content:)` initializer. You can assign a selection value to each tab using a `Tab` initializer that takes a value. Each tab should have a unique selection value and all tabs should have the same selection value type. When people select a tab in the tab view, the tab view updates the selection binding to the value of the currently selected tab. The following example creates a tab view that supports programatic selection and has 3 tabs. TabView(selection: $selection) { Tab("Received", systemImage: "tray.and.arrow.down.fill", value: 0) { ReceivedView() } Tab("Sent", systemImage: "tray.and.arrow.up.fill", value: 1) { SentView() } Tab("Account", systemImage: "person.crop.circle.fill", value: 2) { AccountView() } } You can use the `page` style to display a tab view with multiple scrolling pages of content. The following example uses a `ForEach` to create a scrolling tab view that shows the temperatures of various cities. TabView { ForEach(cities) { city in TemperatureView(city) } } .tabViewStyle(.page) ### Using tab sections The `sidebarAdaptable` style supports declaring a secondary tab hierarchy by grouping tabs with a `TabSection`. On iPadOS, tab sections appear in both the sidebar and the tab bar. On iOS and the horizontally compact size class on iPadOS, secondary tabs appear in the tab bar. When secondary tabs appear in the tab bar, the section header doesn’t appear in the tab bar. Consider limiting the number of tabs on iOS and the iPadOS horizontal compact size class so all tabs fit in the tab bar. The following example has 5 tabs, three of which are grouped within a `TabSection`. TabView { Tab("Requests", systemImage: "paperplane") { RequestsView() } Tab("Account", systemImage: "person.crop.circle.fill") { AccountView() } TabSection("Messages") { Tab("Received", systemImage: "tray.and.arrow.down.fill") { ReceivedView() } Tab("Drafts", systemImage: "pencil") { DraftsView() } } } .tabViewStyle(.sidebarAdaptable) ### Changing tab structure between horizontal and regular size classes The following example shows a `TabView` with 4 tabs in compact and 5 tabs in regular. In compact, one of the tabs is a ‘Browse’ tab that displays a custom list view. This list view allows navigating to the destinations that are contained within the ‘Library’ and ‘Playlists’ sections in the horizontally regular size class. The navigation path and the selection state are updated when the number of tabs changes. struct BrowseTabExample: View { @Environment(\.horizontalSizeClass) var sizeClass @State var selection: MusicTab = .listenNow @State var browseTabPath: [MusicTab] = [] @State var playlists = [Playlist("All Playlists"), Playlist("Running")] var body: some View { TabView(selection: $selection) { Tab("Listen Now", systemImage: "play.circle", value: .listenNow) { ListenNowView() } Tab("Radio", systemImage: "dot.radiowaves.left.and.right", value: .radio) { RadioView() } Tab("Search", systemImage: "magnifyingglass", value: .search) { SearchDetailView() } Tab("Browse", systemImage: "list.bullet", value: .browse) { LibraryView(path: $browseTabPath) } .hidden(sizeClass != .compact) TabSection("Library") { Tab("Recently Added", systemImage: "clock", value: MusicTab.library(.recentlyAdded)) { RecentlyAddedView() } Tab("Artists", systemImage: "music.mic", value: MusicTab.library(.artists)) { ArtistsView() } } .hidden(sizeClass == .compact) TabSection("Playlists") { ForEach(playlists) { playlist in Tab(playlist.name, image: playlist.imafe, value: MusicTab.playlists(playlist)) { playlist.detailView() } } } .hidden(sizeClass == .compact) } .tabViewStyle(.sidebarAdaptable) .onChange(of: sizeClass, initial: true) { _, sizeClass in if sizeClass == .compact && selection.showInBrowseTab { browseTabPath = [selection] selection = .browse } else if sizeClass == .regular && selection == .browse { selection = browseTabPath.last ?? .library(.recentlyAdded) } } } } } struct LibraryView: View { @Binding var path: [MusicTab] var body: some View { NavigationStack(path: $path) { List { ForEach(MusicLibraryTab.allCases, id: \.self) { tab in NavigationLink(tab.rawValue, value: MusicTab.library(tab)) } // Code to add playlists here } .navigationDestination(for: MusicTab.self) { tab in tab.detail() } } } } ### Adding support for customization You can allow people to customize the tabs in a `TabView` by using `sidebarAdaptable` style with the `tabViewCustomization(_:)` modifier. Customization allows people to drag tabs from the sidebar to the tab bar, hide tabs, and rearrange tabs in the sidebar. All tabs and tab sections that support customization need to have a customization ID. You can mark a tab as being non-customizable by specifying a `disabled` behavior in all adaptable tab bar placements using `customizationBehavior(_:for:)`. On macOS, a default interaction is provided for reordering sections but not for controlling the visibility of individual tabs. A custom experience should be provided if desired by setting the visibility of the tab on the customization. You can use `@AppStorage` or `@SceneStorage` to automatically persist any visibility or section order customizations a person makes. The following example supports customizing all 4 tabs in the tab view and uses `@AppStorage` to persist the customizations a person makes. @AppStorage private var customization: TabViewCustomization TabView { Tab("Home", systemImage: "house") { MyHomeView() } .customizationID("com.myApp.home") Tab("Reports", systemImage: "chart.bar") { MyReportsView() } .customizationID("com.myApp.reports") TabSection("Categories") { Tab("Climate", systemImage: "fan") { ClimateView() } .customizationID("com.myApp.climate") Tab("Lights", systemImage: "lightbulb") { LightsView() } .customizationID("com.myApp.lights") } .customizationID("com.myApp.browse") } .tabViewStyle(.sidebarAdaptable) .tabViewCustomization($customization) ## Topics ### Creating a tab view `init(content:)` Creates a tab view that uses a builder to create its tabs. `init(selection:content:)` Creates a tab view that uses a builder to create and specify selection values for its tabs. ## Relationships ### Conforms To - `View` ## See Also ### Presenting views in tabs Enhancing your app’s content with tab navigation Keep your app content front and center while providing quick access to navigation using the tab bar. `struct Tab` The content for a tab and the tab’s associated tab item in a tab view. `struct TabRole` A value that defines the purpose of the tab. `struct TabSection` A container that you can use to add hierarchy within a tab view. Sets the style for the tab view within the current environment. --- # https://developer.apple.com/documentation/swiftui/view/navigationsplitviewstyle(_:) #app-main) - SwiftUI - View - navigationSplitViewStyle(\_:) Instance Method # navigationSplitViewStyle(\_:) Sets the style for navigation split views within this view. nonisolated ## Parameters `style` The style to set. ## Return Value A view that uses the specified navigation split view style. ## Mentioned in Migrating to new navigation types ## See Also ### Presenting views in columns Bringing robust navigation structure to your SwiftUI app Use navigation links, stacks, destinations, and paths to provide a streamlined experience for all platforms, as well as behaviors such as deep linking and state restoration. Improve navigation behavior in your app by replacing navigation views with navigation stacks and navigation split views. `struct NavigationSplitView` A view that presents views in two or three columns, where selections in leading columns control presentations in subsequent columns. Sets a fixed, preferred width for the column containing this view. Sets a flexible, preferred width for the column containing this view. `struct NavigationSplitViewVisibility` The visibility of the leading columns in a navigation split view. `struct NavigationLink` A view that controls a navigation presentation. --- # https://developer.apple.com/documentation/swiftui/view/navigationtitle(_:) --- # https://developer.apple.com/documentation/swiftui/understanding-the-composition-of-navigation-stack --- # https://developer.apple.com/documentation/swiftui/bringing-robust-navigation-structure-to-your-swiftui-app --- # https://developer.apple.com/documentation/swiftui/migrating-to-new-navigation-types --- # https://developer.apple.com/documentation/swiftui/view/navigationsplitviewcolumnwidth(_:) --- # https://developer.apple.com/documentation/swiftui/view/navigationsplitviewcolumnwidth(min:ideal:max:) --- # https://developer.apple.com/documentation/swiftui/navigationsplitviewvisibility --- # https://developer.apple.com/documentation/swiftui/navigationlink --- # https://developer.apple.com/documentation/swiftui/navigationpath --- # https://developer.apple.com/documentation/swiftui/view/navigationdestination(for:destination:) --- # https://developer.apple.com/documentation/swiftui/view/navigationdestination(ispresented:destination:) --- # https://developer.apple.com/documentation/swiftui/view/navigationdestination(item:destination:) --- # https://developer.apple.com/documentation/swiftui/navigationsplitviewcolumn --- # https://developer.apple.com/documentation/swiftui/view/navigationsubtitle(_:) --- # https://developer.apple.com/documentation/swiftui/view/navigationdocument(_:) --- # https://developer.apple.com/documentation/swiftui/view/navigationdocument(_:preview:) --- # https://developer.apple.com/documentation/swiftui/view/navigationbarbackbuttonhidden(_:) --- # https://developer.apple.com/documentation/swiftui/view/navigationbartitledisplaymode(_:) --- # https://developer.apple.com/documentation/swiftui/navigationbaritem --- # https://developer.apple.com/documentation/swiftui/environmentvalues/sidebarrowsize --- # https://developer.apple.com/documentation/swiftui/sidebarrowsize - SwiftUI - SidebarRowSize Enumeration # SidebarRowSize The standard sizes of sidebar rows. enum SidebarRowSize ## Overview On macOS, sidebar rows have three different sizes: small, medium, and large. The size is primarily controlled by the current users’ “Sidebar Icon Size” in Appearance settings, and applies to all applications. On all other platforms, the only supported sidebar size is `.medium`. This size can be read or written in the environment using `EnvironmentValues.sidebarRowSize`. ## Topics ### Getting row sizes `case small` The standard “small” row size `case medium` The standard “medium” row size `case large` The standard “large” row size ## Relationships ### Conforms To - `Copyable` - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Configuring the sidebar `var sidebarRowSize: SidebarRowSize` The current size of sidebar rows. --- # https://developer.apple.com/documentation/swiftui/enhancing-your-app-content-with-tab-navigation --- # https://developer.apple.com/documentation/swiftui/tab - SwiftUI - Tab Structure # Tab The content for a tab and the tab’s associated tab item in a tab view. ## Topics ### Creating a tab Creates a new tab that you can use in a tab view, with an empty label. `init(value:content:)` `init(value:role:content:)` Creates a new tab with a label inferred from the role. ### Creating a tab with label Creates a new tab with a label that you can use in a tab view. ### Creating a tab with system symbol `init(_:systemImage:content:)` Creates a new tab that you can use in a tab view using a system image for the tab item’s image, and a localized string key label. `init(_:systemImage:value:content:)` Creates a tab that the tab view presents when the tab view’s selection matches the tab’s value using a system image for the tab’s tab item image, with a localized string key label. `init(_:systemImage:role:content:)` `init(_:systemImage:value:role:content:)` ### Creating a tab with image `init(_:image:content:)` Creates a new tab that you can use in a tab view, with a localized string key label. `init(_:image:value:content:)` Creates a tab that the tab view presents when the tab view’s selection matches the tab’s value, with a localized string key label. `init(_:image:role:content:)` `init(_:image:value:role:content:)` ### Supporting types `struct DefaultTabLabel` The default label to use for a tab or tab section. ### Initializers `init(value:content:label:)` `init(value:role:content:label:)` ## Relationships ### Conforms To - `Copyable` - `TabContent` Conforms when `Value` conforms to `Hashable`, `Content` conforms to `View`, and `Label` conforms to `View`. ## See Also ### Presenting views in tabs Enhancing your app’s content with tab navigation Keep your app content front and center while providing quick access to navigation using the tab bar. `struct TabView` A view that switches between multiple child views using interactive user interface elements. `struct TabRole` A value that defines the purpose of the tab. `struct TabSection` A container that you can use to add hierarchy within a tab view. Sets the style for the tab view within the current environment. --- # https://developer.apple.com/documentation/swiftui/tabrole - SwiftUI - TabRole Structure # TabRole A value that defines the purpose of the tab. struct TabRole ## Topics ### Type Properties `static var search: TabRole` The search role. ## Relationships ### Conforms To - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Presenting views in tabs Enhancing your app’s content with tab navigation Keep your app content front and center while providing quick access to navigation using the tab bar. `struct TabView` A view that switches between multiple child views using interactive user interface elements. `struct Tab` The content for a tab and the tab’s associated tab item in a tab view. `struct TabSection` A container that you can use to add hierarchy within a tab view. Sets the style for the tab view within the current environment. --- # https://developer.apple.com/documentation/swiftui/tabsection - SwiftUI - TabSection Structure # TabSection A container that you can use to add hierarchy within a tab view. ## Overview Use `TabSection` to organize tab content into separate sections. Each section has custom tab content that you provide on a per-instance basis. You can also provide a header for each section. ## Topics ### Creating a tab section `init(content:)` Creates a section with the provided section content. `init(_:content:)` Creates a section with the provided content. `init(content:header:)` Creates a section with a header and the provided section content. ### Supporting types `struct DefaultTabLabel` The default label to use for a tab or tab section. ## Relationships ### Conforms To - `Copyable` - `TabContent` Conforms when `Header` conforms to `View`, `Content` conforms to `TabContent`, `Footer` conforms to `View`, and `SelectionValue` is `Content.TabValue`. ## See Also ### Presenting views in tabs Enhancing your app’s content with tab navigation Keep your app content front and center while providing quick access to navigation using the tab bar. `struct TabView` A view that switches between multiple child views using interactive user interface elements. `struct Tab` The content for a tab and the tab’s associated tab item in a tab view. `struct TabRole` A value that defines the purpose of the tab. Sets the style for the tab view within the current environment. --- # https://developer.apple.com/documentation/swiftui/view/tabviewstyle(_:) --- # https://developer.apple.com/documentation/swiftui/view/tabviewsidebarheader(content:) #app-main) - SwiftUI - View - tabViewSidebarHeader(content:) Instance Method # tabViewSidebarHeader(content:) Adds a custom header to the sidebar of a tab view. nonisolated ## Discussion The header appears at the top of the sidebar before any tab labels and can scroll with the content. The header is only visible when the `TabView` is displaying the sidebar. The following example adds a welcome message to the top of the sidebar: TabView { Tab("Home", systemImage: "house") { HomeView() } Tab("Alerts", systemImage: "bell") { AlertsView() } Tab("Browse", systemImage: "list.bullet") { MyBrowseView() } } .tabViewStyle(.sidebarAdaptable) .tabViewSidebarHeader { WelcomeHeaderView() } ## See Also ### Configuring a tab bar Adds a custom footer to the sidebar of a tab view. Adds a custom bottom bar to the sidebar of a tab view. `struct AdaptableTabBarPlacement` A placement for tabs in a tab view using the adaptable sidebar style. `var tabBarPlacement: TabBarPlacement?` The current placement of the tab bar. `struct TabBarPlacement` A placement for tabs in a tab view. `var isTabBarShowingSections: Bool` A Boolean value that determines whether a tab view shows the expanded contents of a tab section. `struct TabBarMinimizeBehavior` Beta `enum TabViewBottomAccessoryPlacement` A placement of the bottom accessory in a tab view. You can use this to adjust the content of the accessory view based on the placement. Beta --- # https://developer.apple.com/documentation/swiftui/view/tabviewsidebarfooter(content:) --- # https://developer.apple.com/documentation/swiftui/view/tabviewsidebarbottombar(content:) #app-main) - SwiftUI - View - tabViewSidebarBottomBar(content:) Instance Method # tabViewSidebarBottomBar(content:) Adds a custom bottom bar to the sidebar of a tab view. nonisolated ## Discussion The content is pinned at the bottom of the sidebar, so it’s always visible when the sidebar is visible and doesn’t scroll with the content. The following example adds an account button to the bottom of the sidebar: TabView { Tab("Home", systemImage: "house") { HomeView() } Tab("Alerts", systemImage: "bell") { AlertsView() } Tab("Browse", systemImage: "list.bullet") { MyBrowseView() } } .tabViewStyle(.sidebarAdaptable) .tabViewSidebarBottomBar { AccountButton() } ## See Also ### Configuring a tab bar Adds a custom header to the sidebar of a tab view. Adds a custom footer to the sidebar of a tab view. `struct AdaptableTabBarPlacement` A placement for tabs in a tab view using the adaptable sidebar style. `var tabBarPlacement: TabBarPlacement?` The current placement of the tab bar. `struct TabBarPlacement` A placement for tabs in a tab view. `var isTabBarShowingSections: Bool` A Boolean value that determines whether a tab view shows the expanded contents of a tab section. `struct TabBarMinimizeBehavior` Beta `enum TabViewBottomAccessoryPlacement` A placement of the bottom accessory in a tab view. You can use this to adjust the content of the accessory view based on the placement. Beta --- # https://developer.apple.com/documentation/swiftui/adaptabletabbarplacement --- # https://developer.apple.com/documentation/swiftui/environmentvalues/tabbarplacement - SwiftUI - EnvironmentValues - tabBarPlacement Instance Property # tabBarPlacement The current placement of the tab bar. var tabBarPlacement: TabBarPlacement? { get } ## Discussion Note that this value is only set within the content views of a `TabView`. A `nil` value corresponds to an undefined placement. ## See Also ### Configuring a tab bar Adds a custom header to the sidebar of a tab view. Adds a custom footer to the sidebar of a tab view. Adds a custom bottom bar to the sidebar of a tab view. `struct AdaptableTabBarPlacement` A placement for tabs in a tab view using the adaptable sidebar style. `struct TabBarPlacement` A placement for tabs in a tab view. `var isTabBarShowingSections: Bool` A Boolean value that determines whether a tab view shows the expanded contents of a tab section. `struct TabBarMinimizeBehavior` Beta `enum TabViewBottomAccessoryPlacement` A placement of the bottom accessory in a tab view. You can use this to adjust the content of the accessory view based on the placement. Beta --- # https://developer.apple.com/documentation/swiftui/tabbarplacement - SwiftUI - TabBarPlacement Structure # TabBarPlacement A placement for tabs in a tab view. struct TabBarPlacement ## Topics ### Type Properties `static let bottomBar: TabBarPlacement` Bottom bar of a tab view. `static let ornament: TabBarPlacement` Tab view displaying as an ornament. `static let pageIndicator: TabBarPlacement` Tab view displaying as an indicator that shows the position within the pages. `static let sidebar: TabBarPlacement` The sidebar of a tab view. `static let topBar: TabBarPlacement` Top bar of a tab view. ## Relationships ### Conforms To - `Equatable` - `Hashable` ## See Also ### Configuring a tab bar Adds a custom header to the sidebar of a tab view. Adds a custom footer to the sidebar of a tab view. Adds a custom bottom bar to the sidebar of a tab view. `struct AdaptableTabBarPlacement` A placement for tabs in a tab view using the adaptable sidebar style. `var tabBarPlacement: TabBarPlacement?` The current placement of the tab bar. `var isTabBarShowingSections: Bool` A Boolean value that determines whether a tab view shows the expanded contents of a tab section. `struct TabBarMinimizeBehavior` Beta `enum TabViewBottomAccessoryPlacement` A placement of the bottom accessory in a tab view. You can use this to adjust the content of the accessory view based on the placement. Beta --- # https://developer.apple.com/documentation/swiftui/environmentvalues/istabbarshowingsections - SwiftUI - EnvironmentValues - isTabBarShowingSections Instance Property # isTabBarShowingSections A Boolean value that determines whether a tab view shows the expanded contents of a tab section. var isTabBarShowingSections: Bool { get } ## See Also ### Configuring a tab bar Adds a custom header to the sidebar of a tab view. Adds a custom footer to the sidebar of a tab view. Adds a custom bottom bar to the sidebar of a tab view. `struct AdaptableTabBarPlacement` A placement for tabs in a tab view using the adaptable sidebar style. `var tabBarPlacement: TabBarPlacement?` The current placement of the tab bar. `struct TabBarPlacement` A placement for tabs in a tab view. `struct TabBarMinimizeBehavior` Beta `enum TabViewBottomAccessoryPlacement` A placement of the bottom accessory in a tab view. You can use this to adjust the content of the accessory view based on the placement. Beta --- # https://developer.apple.com/documentation/swiftui/tabbarminimizebehavior - SwiftUI - TabBarMinimizeBehavior Beta Structure # TabBarMinimizeBehavior struct TabBarMinimizeBehavior ## Topics ### Type Properties `static let automatic: TabBarMinimizeBehavior` Determine the behavior automatically based on the surrounding context. `static let never: TabBarMinimizeBehavior` Never minimize the tab bar. `static let onScrollDown: TabBarMinimizeBehavior` Minimize the tab bar when downwards scrolling starts. Minimizing is supported for tab bars on only iPhone. `static let onScrollUp: TabBarMinimizeBehavior` Minimize the tab bar when upwards scrolling starts. Minimizing is supported for tab bars on only iPhone. ## Relationships ### Conforms To - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Configuring a tab bar Adds a custom header to the sidebar of a tab view. Adds a custom footer to the sidebar of a tab view. Adds a custom bottom bar to the sidebar of a tab view. `struct AdaptableTabBarPlacement` A placement for tabs in a tab view using the adaptable sidebar style. `var tabBarPlacement: TabBarPlacement?` The current placement of the tab bar. `struct TabBarPlacement` A placement for tabs in a tab view. `var isTabBarShowingSections: Bool` A Boolean value that determines whether a tab view shows the expanded contents of a tab section. `enum TabViewBottomAccessoryPlacement` A placement of the bottom accessory in a tab view. You can use this to adjust the content of the accessory view based on the placement. Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/tabviewbottomaccessoryplacement - SwiftUI - TabViewBottomAccessoryPlacement Beta Enumeration # TabViewBottomAccessoryPlacement A placement of the bottom accessory in a tab view. You can use this to adjust the content of the accessory view based on the placement. enum TabViewBottomAccessoryPlacement ## Overview The following example shows playback controls when the view is inline, and an expanded slider player view when the view is expanded. struct MusicPlaybackView: View { @Environment(\.tabViewBottomAccessoryPlacement) var placement var body: some View { switch placement { case .inline: ControlsPlaybackView() case .expanded: SliderPlaybackView() } } You can set the `TabView` bottom accessory using `tabViewBottomAccessory(content:)` TabView { Tab("Home", systemImage: "house") { HomeView() } Tab("Alerts", systemImage: "bell") { AlertsView() } TabSection("Categories") { Tab("Climate", systemImage: "fan") { ClimateView() } Tab("Lights", systemImage: "lightbulb") { LightsView() } } } .tabViewBottomAccessory { HomeStatusView() } ## Topics ### Enumeration Cases `case expanded` The bar is expanded on top of the bottom tab bar, if there is a bottom tab bar, or at the bottom of the tab’s content view. `case inline` The view is displayed in line with the bottom tab bar. ## Relationships ### Conforms To - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` ## See Also ### Configuring a tab bar Adds a custom header to the sidebar of a tab view. Adds a custom footer to the sidebar of a tab view. Adds a custom bottom bar to the sidebar of a tab view. `struct AdaptableTabBarPlacement` A placement for tabs in a tab view using the adaptable sidebar style. `var tabBarPlacement: TabBarPlacement?` The current placement of the tab bar. `struct TabBarPlacement` A placement for tabs in a tab view. `var isTabBarShowingSections: Bool` A Boolean value that determines whether a tab view shows the expanded contents of a tab section. `struct TabBarMinimizeBehavior` Beta Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/sectionactions(content:) #app-main) - SwiftUI - View - sectionActions(content:) Instance Method # sectionActions(content:) Adds custom actions to a section. nonisolated ## Discussion On iOS, the actions are displayed as items after the content of the section. On macOS, the actions are displayed when a user hovers over the section. The following example adds an ‘Add’ button to the ‘Categories’ section. List { Label("Home", systemImage: "house") Label("Alerts", systemImage: "bell") Section("Categories") { Label("Climate", systemImage: "fan") Label("Lights", systemImage: "lightbulb") } .sectionActions { Button("Add Category", systemImage: "plus") { } } } ## See Also ### Configuring a tab `struct TabPlacement` A place that a tab can appear. `struct TabContentBuilder` A result builder that constructs tabs for a tab view that supports programmatic selection. This builder requires that all tabs in the tab view have the same selection type. `protocol TabContent` A type that provides content for programmatically selectable tabs in a tab view. `struct AnyTabContent` Type erased tab content. --- # https://developer.apple.com/documentation/swiftui/tabplacement - SwiftUI - TabPlacement Structure # TabPlacement A place that a tab can appear. struct TabPlacement ## Overview Not all `TabView` styles support all placements. ## Topics ### Type Properties `static let automatic: TabPlacement` The default tab location. `static let pinned: TabPlacement` The pinned tab placement location. `static let sidebarOnly: TabPlacement` The sidebar tab placement location. ## Relationships ### Conforms To - `Equatable` - `Hashable` ## See Also ### Configuring a tab Adds custom actions to a section. `struct TabContentBuilder` A result builder that constructs tabs for a tab view that supports programmatic selection. This builder requires that all tabs in the tab view have the same selection type. `protocol TabContent` A type that provides content for programmatically selectable tabs in a tab view. `struct AnyTabContent` Type erased tab content. --- # https://developer.apple.com/documentation/swiftui/tabcontentbuilder - SwiftUI - TabContentBuilder Structure # TabContentBuilder A result builder that constructs tabs for a tab view that supports programmatic selection. This builder requires that all tabs in the tab view have the same selection type. @resultBuilder ## Topics ### Structures `struct Content` A view representation of the content of a builder-based tab view with selection. ### Type Methods `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:_:_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:_:_:_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:_:_:_:_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:_:_:_:_:_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:_:_:_:_:_:_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:_:_:_:_:_:_:_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:_:_:_:_:_:_:_:_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildblock(_:_:_:_:_:_:_:_:_:_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildexpression(_:)) `](https://developer.apple.com/documentation/swiftui/tabcontentbuilder/buildif(_:)) ## See Also ### Configuring a tab Adds custom actions to a section. `struct TabPlacement` A place that a tab can appear. `protocol TabContent` A type that provides content for programmatically selectable tabs in a tab view. `struct AnyTabContent` Type erased tab content. --- # https://developer.apple.com/documentation/swiftui/tabcontent --- # https://developer.apple.com/documentation/swiftui/anytabcontent - SwiftUI - AnyTabContent Structure # AnyTabContent Type erased tab content. ## Topics ### Initializers Create an instance that type-erases `tabContent`. ## Relationships ### Conforms To - `TabContent` ## See Also ### Configuring a tab Adds custom actions to a section. `struct TabPlacement` A place that a tab can appear. `struct TabContentBuilder` A result builder that constructs tabs for a tab view that supports programmatic selection. This builder requires that all tabs in the tab view have the same selection type. `protocol TabContent` A type that provides content for programmatically selectable tabs in a tab view. --- # https://developer.apple.com/documentation/swiftui/view/tabviewcustomization(_:) --- # https://developer.apple.com/documentation/swiftui/tabviewcustomization - SwiftUI - TabViewCustomization Structure # TabViewCustomization The customizations a person makes to an adaptable sidebar tab view. struct TabViewCustomization ## Overview By default, if a person hasn’t made customizations, tabs appear according to the default builder visibilities and sections appear in the order you declare in the tab view’s tab builder. You can change the default visibility by using the `defaultVisibility(_:for:)` with a `sidebar` placement. You can change the default section order by changing the order in the builder. If there’s an existing persisted customization, reset the order by calling `resetTabOrder()` when you change the order. All tabs and tab sections that support customization need to have a customization ID. You can mark a tab as being non-customizable by specifying a `disabled` behavior in all adaptable tab bar placements using `customizationBehavior(_:for:)`. On macOS, a default interaction is provided for reordering sections but not for controlling the visibility of individual tabs. A custom experience should be provided if desired by setting the visibility of the tab on the customization. The following code example uses `@AppStorage` to automatically persist any visibility or section order customizations a person makes. @AppStorage private var customization: TabViewCustomization TabView { Tab("Home", systemImage: "house") { MyHomeView() } .customizationID("com.myApp.home") Tab("Reports", systemImage: "chart.bar") { MyReportsView() } .customizationID("com.myApp.reports") TabSection("Categories") { Tab("Climate", systemImage: "fan") { ClimateView() } .customizationID("com.myApp.climate") Tab("Lights", systemImage: "lightbulb") { LightsView() } .customizationID("com.myApp.lights") } .customizationID("com.myApp.browse") } .tabViewStyle(.sidebarAdaptable) .tabViewCustomization($customization) ## Topics ### Structures `struct SectionCustomization` The customizations a user has made to a `TabSection`. `struct TabCustomization` The customizations a user has made to a `Tab`. ### Initializers `init()` Creates an empty tab sidebar customization. ### Instance Methods `func resetSectionOrder()` Resets ordering ) Resets all tab sidebar visibilities The customization of the section, identified by its customization identifier. The customization for a section’s children, identified by the section’s customization identifier. Deprecated The visibility of the tab identified by its customization identifier. The customization of the tab, identified by its customization identifier. ## Relationships ### Conforms To - `Decodable` - `Encodable` - `Equatable` - `Sendable` - `SendableMetatype` ## See Also ### Enabling tab customization Specifies the customizations to apply to the sidebar representation of the tab view. `struct TabCustomizationBehavior` The customization behavior of customizable tab view content. --- # https://developer.apple.com/documentation/swiftui/tabcustomizationbehavior --- # https://developer.apple.com/documentation/swiftui/hsplitview - SwiftUI - HSplitView Structure # HSplitView A layout container that arranges its children in a horizontal line and allows the user to resize them using dividers placed between them. ## Topics ## Relationships ### Conforms To - `View` ## See Also ### Displaying views in multiple panes `struct VSplitView` A layout container that arranges its children in a vertical line and allows the user to resize them using dividers placed between them. --- # https://developer.apple.com/documentation/swiftui/vsplitview - SwiftUI - VSplitView Structure # VSplitView A layout container that arranges its children in a vertical line and allows the user to resize them using dividers placed between them. ## Topics ## Relationships ### Conforms To - `View` ## See Also ### Displaying views in multiple panes `struct HSplitView` A layout container that arranges its children in a horizontal line and allows the user to resize them using dividers placed between them. --- # https://developer.apple.com/documentation/swiftui/navigationview - SwiftUI - NavigationView Deprecated Structure # NavigationView A view for presenting a stack of views that represents a visible path in a navigation hierarchy. iOS 13.0–26.0DeprecatediPadOS 13.0–26.0DeprecatedMac Catalyst 13.0–26.0DeprecatedmacOS 10.15–26.0DeprecatedtvOS 13.0–26.0DeprecatedvisionOS 1.0–26.0DeprecatedwatchOS 7.0–26.0Deprecated ## Mentioned in Migrating to new navigation types Displaying data in lists Picking container views for your content ## Overview Use a `NavigationView` to create a navigation-based app in which the user can traverse a collection of views. Users navigate to a destination view by selecting a `NavigationLink` that you provide. On iPadOS and macOS, the destination content appears in the next column. Other platforms push a new view onto the stack, and enable removing items from the stack with platform-specific controls, like a Back button or a swipe gesture. Use the `init(content:)` initializer to create a navigation view that directly associates navigation links and their destination views: NavigationView { List(model.notes) { note in NavigationLink(note.title, destination: NoteEditor(id: note.id)) } Text("Select a Note") } Style a navigation view by modifying it with the `navigationViewStyle(_:)` view modifier. Use other modifiers, like `navigationTitle(_:)`, on views presented by the navigation view to customize the navigation interface for the presented view. ## Topics ### Creating a navigation view Creates a destination-based navigation view. ### Styling navigation views Sets the style for navigation views within this view. `protocol NavigationViewStyle` A specification for the appearance and interaction of a navigation view. ## Relationships ### Conforms To - `View` ## See Also ### Deprecated Types Sets the tab bar item associated with this view. Deprecated --- # https://developer.apple.com/documentation/swiftui/view/tabitem(_:) #app-main) - SwiftUI - View - tabItem(\_:) Deprecated Instance Method # tabItem(\_:) Sets the tab bar item associated with this view. iOS 13.0–26.0DeprecatediPadOS 13.0–26.0DeprecatedMac Catalyst 13.0–26.0DeprecatedmacOS 10.15–26.0DeprecatedtvOS 13.0–26.0DeprecatedwatchOS 7.0–26.0Deprecated nonisolated ## Parameters `label` The tab bar item to associate with this view. ## Discussion Use `tabItem(_:)` to configure a view as a tab bar item in a `TabView`. The example below adds two views as tabs in a `TabView`: struct View1: View { var body: some View { Text("View 1") } } struct View2: View { var body: some View { Text("View 2") } } struct TabItem: View { var body: some View { TabView { View1() .tabItem { Label("Menu", systemImage: "list.dash") } View2() .tabItem { Label("Order", systemImage: "square.and.pencil") } } } } ## See Also ### Deprecated Types `struct NavigationView` A view for presenting a stack of views that represents a visible path in a navigation hierarchy. Deprecated --- # https://developer.apple.com/documentation/swiftui/navigationstack), --- # https://developer.apple.com/documentation/swiftui/tabview). --- # https://developer.apple.com/documentation/swiftui/view/navigationsplitviewstyle(_:)) --- # https://developer.apple.com/documentation/swiftui/view/navigationtitle(_:)) --- # https://developer.apple.com/documentation/swiftui/understanding-the-composition-of-navigation-stack) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/bringing-robust-navigation-structure-to-your-swiftui-app) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/migrating-to-new-navigation-types) --- # https://developer.apple.com/documentation/swiftui/view/navigationsplitviewcolumnwidth(_:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/view/navigationsplitviewcolumnwidth(min:ideal:max:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/navigationsplitviewvisibility) --- # https://developer.apple.com/documentation/swiftui/navigationlink) --- # https://developer.apple.com/documentation/swiftui/navigationstack) --- # https://developer.apple.com/documentation/swiftui/navigationpath) --- # https://developer.apple.com/documentation/swiftui/view/navigationdestination(for:destination:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/view/navigationdestination(ispresented:destination:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/navigationstack). --- # https://developer.apple.com/documentation/swiftui/view/navigationdestination(item:destination:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/navigationsplitviewcolumn) --- # https://developer.apple.com/documentation/swiftui/view/navigationsubtitle(_:)) --- # https://developer.apple.com/documentation/swiftui/view/navigationdocument(_:)) --- # https://developer.apple.com/documentation/swiftui/view/navigationdocument(_:preview:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/view/navigationbarbackbuttonhidden(_:)) --- # https://developer.apple.com/documentation/swiftui/view/navigationbartitledisplaymode(_:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/navigationbaritem) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/sidebarrowsize) --- # https://developer.apple.com/documentation/swiftui/sidebarrowsize) --- # https://developer.apple.com/documentation/swiftui/enhancing-your-app-content-with-tab-navigation) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/tabview) --- # https://developer.apple.com/documentation/swiftui/tab) --- # https://developer.apple.com/documentation/swiftui/tabrole) --- # https://developer.apple.com/documentation/swiftui/tabsection) --- # https://developer.apple.com/documentation/swiftui/view/tabviewstyle(_:)) --- # https://developer.apple.com/documentation/swiftui/view/tabviewsidebarheader(content:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/view/tabviewsidebarfooter(content:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/view/tabviewsidebarbottombar(content:)) )#app-main) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/adaptabletabbarplacement) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/tabbarplacement) --- # https://developer.apple.com/documentation/swiftui/tabbarplacement) --- # https://developer.apple.com/documentation/swiftui/environmentvalues/istabbarshowingsections) # The page you're looking for can't be found. Search developer.apple.comSearch Icon --- # https://developer.apple.com/documentation/swiftui/tabbarminimizebehavior) --- # https://developer.apple.com/documentation/swiftui/tabviewbottomaccessoryplacement) --- # https://developer.apple.com/documentation/swiftui/view/sectionactions(content:)) --- # https://developer.apple.com/documentation/swiftui/tabplacement) --- # https://developer.apple.com/documentation/swiftui/tabcontentbuilder) --- # https://developer.apple.com/documentation/swiftui/tabcontent) --- # https://developer.apple.com/documentation/swiftui/anytabcontent) --- # https://developer.apple.com/documentation/swiftui/view/tabviewcustomization(_:)) --- # https://developer.apple.com/documentation/swiftui/tabviewcustomization) --- # https://developer.apple.com/documentation/swiftui/tabcustomizationbehavior) --- # https://developer.apple.com/documentation/swiftui/hsplitview) --- # https://developer.apple.com/documentation/swiftui/vsplitview) --- # https://developer.apple.com/documentation/swiftui/navigationview) --- # https://developer.apple.com/documentation/swiftui/view/tabitem(_:)) --- # https://developer.apple.com/documentation/swiftui/app/body-swift.property - SwiftUI - App - body Instance Property # body The content and behavior of the app. @SceneBuilder @MainActor @preconcurrency var body: Self.Body { get } **Required** ## Discussion For any app that you create, provide a computed `body` property that defines your app’s scenes, which are instances that conform to the `Scene` protocol. For example, you can create a simple app with a single scene containing a single view: @main struct MyApp: App { var body: some Scene { WindowGroup { Text("Hello, world!") } } } Swift infers the app’s `Body` associated type based on the scene provided by the `body` property. ## See Also ### Implementing an app `associatedtype Body : Scene` The type of scene representing the content of the app. --- # https://developer.apple.com/documentation/swiftui/app/main() #app-main) - SwiftUI - App - main() Type Method # main() Initializes and runs the app. @MainActor @preconcurrency static func main() ## Discussion If you precede your `App` conformer’s declaration with the @main attribute, the system calls the conformer’s `main()` method to launch the app. SwiftUI provides a default implementation of the method that manages the launch process in a platform-appropriate way. ## See Also ### Running an app `init()` Creates an instance of the app using the body that you define for its content. **Required** --- # https://developer.apple.com/documentation/swiftui/stateobject - SwiftUI - StateObject Structure # StateObject A property wrapper type that instantiates an observable object. @MainActor @frozen @propertyWrapper @preconcurrency ## Overview Use a state object as the single source of truth for a reference type that you store in a view hierarchy. Create a state object in an `App`, `Scene`, or `View` by applying the `@StateObject` attribute to a property declaration and providing an initial value that conforms to the `ObservableObject` protocol. Declare state objects as private to prevent setting them from a memberwise initializer, which can conflict with the storage management that SwiftUI provides: class DataModel: ObservableObject { @Published var name = "Some Name" @Published var isEnabled = false } struct MyView: View { @StateObject private var model = DataModel() // Create the state object. var body: some View { Text(model.name) // Updates when the data model changes. MySubView() .environmentObject(model) } } SwiftUI creates a new instance of the model object only once during the lifetime of the container that declares the state object. For example, SwiftUI doesn’t create a new instance if a view’s inputs change, but does create a new instance if the identity of a view changes. When published properties of the observable object change, SwiftUI updates any view that depends on those properties, like the `Text` view in the above example. ### Share state objects with subviews You can pass a state object into a subview through a property that has the `ObservedObject` attribute. Alternatively, add the object to the environment of a view hierarchy by applying the `environmentObject(_:)` modifier to a view, like `MySubView` in the above code. You can then read the object inside `MySubView` or any of its descendants using the `EnvironmentObject` attribute: struct MySubView: View { @EnvironmentObject var model: DataModel var body: some View { Toggle("Enabled", isOn: $model.isEnabled) } } Get a `Binding` to the state object’s properties using the dollar sign ( `$`) operator. Use a binding when you want to create a two-way connection. In the above code, the `Toggle` controls the model’s `isEnabled` value through a binding. ### Initialize state objects using external data When a state object’s initial state depends on data that comes from outside its container, you can call the object’s initializer explicitly from within its container’s initializer. For example, suppose the data model from the previous example takes a `name` input during initialization and you want to use a value for that name that comes from outside the view. You can do this with a call to the state object’s initializer inside an explicit initializer that you create for the view: struct MyInitializableView: View { @StateObject private var model: DataModel init(name: String) { // SwiftUI ensures that the following initialization uses the // closure only once during the lifetime of the view, so // later changes to the view's name input have no effect. _model = StateObject(wrappedValue: DataModel(name: name)) } var body: some View { VStack { Text("Name: \(model.name)") } } } Use caution when doing this. SwiftUI only initializes a state object the first time you call its initializer in a given view. This ensures that the object provides stable storage even as the view’s inputs change. However, it might result in unexpected behavior or unwanted side effects if you explicitly initialize the state object. In the above example, if the `name` input to `MyInitializableView` changes, SwiftUI reruns the view’s initializer with the new value. However, SwiftUI runs the autoclosure that you provide to the state object’s initializer only the first time you call the state object’s initializer, so the model’s stored `name` value doesn’t change. Explicit state object initialization works well when the external data that the object depends on doesn’t change for a given instance of the object’s container. For example, you can create two views with different constant names: var body: some View { VStack { MyInitializableView(name: "Ravi") MyInitializableView(name: "Maria") } } ### Force reinitialization by changing view identity If you want SwiftUI to reinitialize a state object when a view input changes, make sure that the view’s identity changes at the same time. One way to do this is to bind the view’s identity to the value that changes using the `id(_:)` modifier. For example, you can ensure that the identity of an instance of `MyInitializableView` changes when its `name` input changes: MyInitializableView(name: name) .id(name) // Binds the identity of the view to the name property. If you need the view to reinitialize state based on changes in more than one value, you can combine the values into a single identifier using a `Hasher`. For example, if you want to update the data model in `MyInitializableView` when the values of either `name` or `isEnabled` change, you can combine both variables into a single hash: var hash: Int { var hasher = Hasher() hasher.combine(name) hasher.combine(isEnabled) return hasher.finalize() } Then apply the combined hash to the view as an identifier: MyInitializableView(name: name, isEnabled: isEnabled) .id(hash) Be mindful of the performance cost of reinitializing the state object every time the input changes. Also, changing view identity can have side effects. For example, SwiftUI doesn’t automatically animate changes inside the view if the view’s identity changes at the same time. Also, changing the identity resets _all_ state held by the view, including values that you manage as `State`, `FocusState`, `GestureState`, and so on. ## Topics ### Creating a state object Creates a new state object with an initial wrapped value. ### Getting the value `var wrappedValue: ObjectType` The underlying value referenced by the state object. A projection of the state object that creates bindings to its properties. ## Relationships ### Conforms To - `DynamicProperty` - `Sendable` - `SendableMetatype` ## See Also ### Creating model data Managing model data in your app Create connections between your app’s data model and views. Migrating from the Observable Object protocol to the Observable macro Update your existing app to leverage the benefits of Observation in Swift. `@attached(member, names: named(_$observationRegistrar), named(access), named(withMutation), named(shouldNotifyObservers)) @attached(memberAttribute) @attached(extension, conformances: Observable) macro Observable()` Defines and implements conformance of the Observable protocol. Monitoring data changes in your app Show changes to data in your app’s user interface by using observable objects. `struct ObservedObject` A property wrapper type that subscribes to an observable object and invalidates a view whenever the observable object changes. `protocol ObservableObject : AnyObject` A type of object with a publisher that emits before the object has changed. --- # https://developer.apple.com/documentation/swiftui/observedobject - SwiftUI - ObservedObject Structure # ObservedObject A property wrapper type that subscribes to an observable object and invalidates a view whenever the observable object changes. @MainActor @propertyWrapper @preconcurrency @frozen ## Overview Add the `@ObservedObject` attribute to a parameter of a SwiftUI `View` when the input is an `ObservableObject` and you want the view to update when the object’s published properties change. You typically do this to pass a `StateObject` into a subview. The following example defines a data model as an observable object, instantiates the model in a view as a state object, and then passes the instance to a subview as an observed object: class DataModel: ObservableObject { @Published var name = "Some Name" @Published var isEnabled = false } struct MyView: View { @StateObject private var model = DataModel() var body: some View { Text(model.name) MySubView(model: model) } } struct MySubView: View { @ObservedObject var model: DataModel var body: some View { Toggle("Enabled", isOn: $model.isEnabled) } } When any published property of the observable object changes, SwiftUI updates any view that depends on the object. Subviews can also make updates to the model properties, like the `Toggle` in the above example, that propagate to other observers throughout the view hierarchy. Don’t specify a default or initial value for the observed object. Use the attribute only for a property that acts as an input for a view, as in the above example. ## Topics ### Creating an observed object `init(wrappedValue: ObjectType)` Creates an observed object with an initial wrapped value. `init(initialValue: ObjectType)` Creates an observed object with an initial value. ### Getting the value `var wrappedValue: ObjectType` The underlying value that the observed object references. A projection of the observed object that creates bindings to its properties. `struct Wrapper` A wrapper of the underlying observable object that can create bindings to its properties. ## Relationships ### Conforms To - `DynamicProperty` - `Sendable` - `SendableMetatype` ## See Also ### Creating model data Managing model data in your app Create connections between your app’s data model and views. Migrating from the Observable Object protocol to the Observable macro Update your existing app to leverage the benefits of Observation in Swift. `@attached(member, names: named(_$observationRegistrar), named(access), named(withMutation), named(shouldNotifyObservers)) @attached(memberAttribute) @attached(extension, conformances: Observable) macro Observable()` Defines and implements conformance of the Observable protocol. Monitoring data changes in your app Show changes to data in your app’s user interface by using observable objects. `struct StateObject` A property wrapper type that instantiates an observable object. `protocol ObservableObject : AnyObject` A type of object with a publisher that emits before the object has changed. --- # https://developer.apple.com/documentation/swiftui/environmentobject - SwiftUI - EnvironmentObject Structure # EnvironmentObject A property wrapper type for an observable object that a parent or ancestor view supplies. @MainActor @frozen @propertyWrapper @preconcurrency ## Overview An environment object invalidates the current view whenever the observable object that conforms to `ObservableObject` changes. If you declare a property as an environment object, be sure to set a corresponding model object on an ancestor view by calling its `environmentObject(_:)` modifier. ## Topics ### Creating an environment object `init()` Creates an environment object. ### Getting the value `var wrappedValue: ObjectType` The underlying value referenced by the environment object. A projection of the environment object that creates bindings to its properties using dynamic member lookup. `struct Wrapper` A wrapper of the underlying environment object that can create bindings to its properties using dynamic member lookup. ## Relationships ### Conforms To - `DynamicProperty` - `Sendable` - `SendableMetatype` ## See Also ### Distributing model data throughout your app Supplies an observable object to a view’s hierarchy. Supplies an `ObservableObject` to a view subhierarchy. --- # https://developer.apple.com/documentation/swiftui/app/body-swift.associatedtype - SwiftUI - App - Body Associated Type # Body The type of scene representing the content of the app. associatedtype Body : Scene **Required** ## Discussion When you create a custom app, Swift infers this type from your implementation of the required `body` property. ## See Also ### Implementing an app `var body: Self.Body` The content and behavior of the app. --- # https://developer.apple.com/documentation/swiftui/app/init() #app-main) - SwiftUI - App - init() Initializer # init() Creates an instance of the app using the body that you define for its content. @MainActor @preconcurrency init() **Required** ## Discussion Swift synthesizes a default initializer for structures that don’t provide one. You typically rely on the default initializer for your app. ## See Also ### Running an app `static func main()` Initializes and runs the app. --- # https://developer.apple.com/documentation/swiftui/app/body-swift.property) --- # https://developer.apple.com/documentation/swiftui/app/main()) --- # https://developer.apple.com/documentation/swiftui/stateobject) --- # https://developer.apple.com/documentation/swiftui/observedobject) --- # https://developer.apple.com/documentation/swiftui/environmentobject) --- # https://developer.apple.com/documentation/swiftui/app/body-swift.associatedtype) --- # https://developer.apple.com/documentation/swiftui/app/init()) --- # https://developer.apple.com/documentation/swiftui/declaring-a-custom-view - SwiftUI - View fundamentals - Declaring a custom view Article # Declaring a custom view Define views and assemble them into a view hierarchy. ## Overview SwiftUI offers a declarative approach to user interface design. With a traditional imperative approach, the burden is on your controller code not only to instantiate, lay out, and configure views, but also to continually make updates as conditions change. In contrast, with a declarative approach, you create a lightweight description of your user interface by declaring views in a hierarchy that mirrors the desired layout of your interface. SwiftUI then manages drawing and updating these views in response to events like user input or state changes. SwiftUI provides tools for defining and configuring the views in your user interface. You compose custom views out of built-in views that SwiftUI provides, plus other composite views that you’ve already defined. You configure these views with view modifiers and connect them to your data model. You then place your custom views within your app’s view hierarchy. ### Conform to the view protocol Declare a custom view type by defining a structure that conforms to the `View` protocol: struct MyView: View { } Like other Swift protocols, the `View` protocol provides a blueprint for functionality — in this case, the behavior of an element that SwiftUI draws onscreen. Conformance to the protocol comes with both requirements that a view must fulfill, and functionality that the protocol provides. After you fulfill the requirements, you can insert your custom view into a view hierarchy so that it becomes part of your app’s user interface. ### Declare a body The `View` protocol’s main requirement is that conforming types must define a `body` computed property: struct MyView: View { var body: some View { } } SwiftUI reads the value of this property any time it needs to update the view, which can happen repeatedly during the life of the view, typically in response to user input or system events. The value that the view returns is an element that SwiftUI draws onscreen. The `View` protocol’s secondary requirement is that conforming types must indicate an associated type for the body property. However, you don’t make an explicit declaration. Instead, you declare the body property as an opaque type, using the `some View` syntax, to indicate only that the body’s type conforms to `View`. The exact type depends on the body’s content, which varies as you edit the body during development. Swift infers the exact type automatically. ### Assemble the view’s content Describe your view’s appearance by adding content to the view’s body property. You can compose the body from built-in views that SwiftUI provides, as well as custom views that you’ve defined elsewhere. For example, you can create a body that draws the string “Hello, World!” using a built-in `Text` view: struct MyView: View { var body: some View { Text("Hello, World!") } } In addition to views for specific kinds of content, controls, and indicators, like `Text`, `Toggle`, and `ProgressView`, SwiftUI also provides built-in views that you can use to arrange other views. For example, you can vertically stack two `Text` views using a `VStack`: struct MyView: View { var body: some View { VStack { Text("Hello, World!") Text("Glad to meet you.") } } } Views that take multiple input child views, like the stack in the example above, typically do so using a closure marked with the `ViewBuilder` attribute. This enables a multiple-statement closure that doesn’t require additional syntax at the call site. You only need to list the input views in succession. For examples of views that contain other views, see Layout fundamentals. ### Configure views with modifiers To configure the views in your view’s body, you apply view modifiers. A modifier is nothing more than a method called on a particular view. The method returns a new, altered view that effectively takes the place of the original in the view hierarchy. SwiftUI extends the `View` protocol with a large set of methods for this purpose. All `View` protocol conformers — both built-in and custom views — have access to these methods that alter the behavior of a view in some way. For example, you can change the font of a text view by applying the `font(_:)` modifier: struct MyView: View { var body: some View { VStack { Text("Hello, World!") .font(.title) Text("Glad to meet you.") } } } For more information about how view modifiers work, and how to use them on your views, see Configuring views. ### Manage data To supply inputs to your views, add properties. For example, you can make the font of the “Hello, World!” string configurable: struct MyView: View { let helloFont: Font var body: some View { VStack { Text("Hello, World!") .font(helloFont) Text("Glad to meet you.") } } } If an input value changes, SwiftUI notices the change and redraws only the affected parts of your interface. This might involve reinitializing your entire view, but SwiftUI manages that for you. Because the system may reinitialize a view at any time, it’s important to avoid doing any significant work in your view’s initialization code. It’s often best to omit an explicit initializer, as in the example above, allowing Swift to synthesize a _member-wise initializer_ instead. SwiftUI provides many tools to help you manage your app’s data under these constraints, as described in Model data. For information about Swift initializers, see Initialization in _The Swift Programming Language_. ### Add your view to the view hierarchy After you define a view, you can incorporate it in other views, just like you do with built-in views. You add your view by declaring it at the point in the hierarchy at which you want it to appear. For example, you could put `MyView` in your app’s `ContentView`, which Xcode creates automatically as the root view of a new app: struct ContentView: View { var body: some View { MyView(helloFont: .title) } } Alternatively, you could add your view as the root view of a new scene in your app, like the `Settings` scene that declares content for a macOS preferences window, or a `WKNotificationScene` scene that declares the content for a watchOS notification. For more information about defining your app structure with SwiftUI, see App organization. ## See Also ### Creating a view `protocol View` A type that represents part of your app’s user interface and provides modifiers that you use to configure views. `struct ViewBuilder` A custom parameter attribute that constructs views from closures. --- # https://developer.apple.com/documentation/swiftui/configuring-views - SwiftUI - View fundamentals - Configuring views Article # Configuring views Adjust the characteristics of a view by applying view modifiers. ## Overview In SwiftUI, you assemble views into a hierarchy that describes your app’s user interface. To help you customize the appearance and behavior of your app’s views, you use _view modifiers_. For example, you can use modifiers to: - Add accessibility features to a view. - Adjust a view’s styling, layout, and other appearance characteristics. - Respond to events, like copy and paste. - Conditionally present modal views, like popovers. - Configure supporting views, like toolbars. Because view modifiers are Swift methods with behavior provided by the `View` protocol, you can apply them to any type that conforms to the `View` protocol. That includes built-in views like `Text`, `Image`, and `Button`, as well as views that you define. ### Configure a view with a modifier Like other Swift methods, a modifier operates on an instance — a view of some kind in this case — and can optionally take input parameters. For example, you can apply the `foregroundColor(_:)` modifier to set the color of a `Text` view: Text("Hello, World!") .foregroundColor(.red) // Display red text. Modifiers return a view that wraps the original view and replaces it in the view hierarchy. You can think of the two lines in the example above as resolving to a single view that displays red text. While the code above follows the rules of Swift, the code’s structure might be unfamiliar for developers new to SwiftUI. SwiftUI uses a declarative approach, where you declare and configure a view at the point in your code that corresponds to the view’s position in the view hierarchy. For more information, see Declaring a custom view. ### Chain modifiers to achieve complex effects You commonly chain modifiers, each wrapping the result of the previous one, by calling them one after the other. For example, you can wrap a text view in an invisible box with a given width using the `frame(width:height:alignment:)` modifier to influence its layout, and then use the `border(_:width:)` modifier to draw an outline around that: Text("Title") .frame(width: 100) .border(Color.gray) The order in which you apply modifiers matters. For example, the border that results from the code above outlines the full width of the frame. By specifying the frame modifier after the border modifier, SwiftUI applies the border only to the text view, which never takes more space than it needs to render its contents. Text("Title") .border(Color.gray) // Apply the border first this time. .frame(width: 100) Wrapping that view in an invisible one with a fixed 100 point width affects the layout of the composite view, but has no effect on the border. ### Configure child views You can apply any view modifier defined by the `View` protocol to any concrete view, even when the modifier doesn’t have an immediate effect on its target view. The effects of a modifier propagate to child views that don’t explicitly override the modifier. For example, a `VStack` instance on its own acts only to vertically stack other views — it doesn’t have any text to display. Therefore, applying a `font(_:)` modifier to the stack has no effect on the stack. Yet the font modifier does apply to any of the stack’s child views, some of which might display text. You can, however, locally override the stack’s modifier by adding another to a specific child view: VStack { Text("Title") .font(.title) // Override the font of this view. Text("First body line.") Text("Second body line.") } .font(.body) // Set a default font for text in the stack. ### Use view-specific modifiers While many view types rely on standard view modifiers for customization and control, some views do define modifiers that are specific to that view type. You can’t use such a modifier on anything but the appropriate kind of view. For example, `Text` defines the `bold()` modifier as a convenience for adding a bold effect to the view’s text. While you can use `font(_:)` on any view because it’s part of the `View` protocol, you can use `bold()` only on `Text` views. As a result, you can’t use it on a container view: VStack { Text("Hello, world!") } .bold() // Fails because 'VStack' doesn't have a 'bold' modifier. You also can’t use it on a `Text` view after applying another general modifier because general modifiers return an opaque type. For example, the return value from the padding modifier isn’t `Text`, but rather an opaque result type that can’t take a bold modifier: Text("Hello, world!") .padding() .bold() // Fails because 'some View' doesn't have a 'bold' modifier. Instead, apply the bold modifier directly to the `Text` view and then add the padding: Text("Hello, world!") .bold() // Succeeds. .padding() ## See Also ### Modifying a view Reducing view modifier maintenance Bundle view modifiers that you regularly reuse into a custom view modifier. Applies a modifier to a view and returns a new view. `protocol ViewModifier` A modifier that you apply to a view or another view modifier, producing a different version of the original value. `struct EmptyModifier` An empty, or identity, modifier, used during development to switch modifiers at compile time. `struct ModifiedContent` A value with a modifier applied to it. `protocol EnvironmentalModifier` A modifier that must resolve to a concrete modifier in an environment before use. `struct ManipulableModifier` Beta `struct ManipulableResponderModifier` Beta `struct ManipulableTransformBindingModifier` Beta `struct ManipulationGeometryModifier` Beta `struct ManipulationGestureModifier` Beta `struct ManipulationUsingGestureStateModifier` Beta `enum Manipulable` A namespace for various manipulable related types. Beta --- # https://developer.apple.com/documentation/swiftui/reducing-view-modifier-maintenance - SwiftUI - View fundamentals - Reducing view modifier maintenance Article # Reducing view modifier maintenance Bundle view modifiers that you regularly reuse into a custom view modifier. ## Overview To create consistent views, you might reuse the same view modifier or group of modifiers repeatedly across your views. For example, you might apply the same font and foreground color to many text instances throughout your app, so they all match. Unfortunately, this can lead to maintenance challenges, because even a small change in format, like a different font size, requires changes in many different parts of your code. To avoid this overhead, collect a set of modifiers into a single location using an instance of the `ViewModifier` protocol. Then, extend the `View` protocol with a method that uses your modifier, making it easy to use and understand. Collecting the modifiers together provides a single location to update when you want to change them. ### Create a custom view modifier When you create your custom modifier, name it to reflect the purpose of the collection. For example, if you repeatedly apply the `caption` font style and a secondary color scheme to views to represent a secondary styling, collect them together as `CaptionTextFormat`: struct CaptionTextFormat: ViewModifier { content .font(.caption) .foregroundColor(.secondary) } } Apply your modifier using the `modifier(_:)` method. The following code applies the above example to a `Text` instance: Text("Some additional information...") .modifier(CaptionTextFormat()) ### Extend the view protocol to provide fluent modifier access To make your custom view modifier conveniently accessible, extend the `View` protocol with a function that applies your modifier: extension View { modifier(CaptionTextFormat()) } } Apply the modifier to a text view by including this extension: Text("Some additional information...") .captionTextFormat() ## See Also ### Modifying a view Configuring views Adjust the characteristics of a view by applying view modifiers. Applies a modifier to a view and returns a new view. `protocol ViewModifier` A modifier that you apply to a view or another view modifier, producing a different version of the original value. `struct EmptyModifier` An empty, or identity, modifier, used during development to switch modifiers at compile time. `struct ModifiedContent` A value with a modifier applied to it. `protocol EnvironmentalModifier` A modifier that must resolve to a concrete modifier in an environment before use. `struct ManipulableModifier` Beta `struct ManipulableResponderModifier` Beta `struct ManipulableTransformBindingModifier` Beta `struct ManipulationGeometryModifier` Beta `struct ManipulationGestureModifier` Beta `struct ManipulationUsingGestureStateModifier` Beta `enum Manipulable` A namespace for various manipulable related types. Beta --- # https://developer.apple.com/documentation/swiftui/displaying-data-in-lists - SwiftUI - Lists - Displaying data in lists Article # Displaying data in lists Visualize collections of data with platform-appropriate appearance. ## Overview Displaying a collection of data in a vertical list is a common requirement in many apps. Whether it’s a list of contacts, a schedule of events, an index of categories, or a shopping list, you’ll often find a use for a `List`. List views display collections of items vertically, load rows as needed, and add scrolling when the rows don’t fit on the screen, making them suitable for displaying large collections of data. By default, list views also apply platform-appropriate styling to their elements. For example, on iOS, the default configuration of a list displays a separator line between each row, and adds disclosure indicators next to items that initiate navigation actions. The code in this article shows the use of list views to display a company’s staff directory. Each section enhances the usefulness of the list, by adding custom cells, splitting the list into sections, and using the list selection to navigate to a detail view. ### Prepare your data for iteration The most common use of `List` is for representing collections of information in your data model. The following example defines a `Person` as an `Identifiable` type with the properties `name` and `phoneNumber`. An array called `staff` contains two instances of this type. struct Person: Identifiable { let id = UUID() var name: String var phoneNumber: String } var staff = [\ Person(name: "Juan Chavez", phoneNumber: "(408) 555-4301"),\ Person(name: "Mei Chen", phoneNumber: "(919) 555-2481")\ ] To present the contents of the array as a list, the example creates a `List` instance. The list’s content builder uses a `ForEach` to iterate over the `staff` array. For each member of the array, the listing creates a row view by instantiating a new `Text` that contains the name of the `Person`. struct StaffList: View { var body: some View { List { ForEach(staff) { person in Text(person.name) } } } } Members of a list must be uniquely identifiable from one another. Unique identifiers allow SwiftUI to automatically generate animations for changes in the underlying data, like inserts, deletions, and moves. Identify list members either by using a type that conforms to `Identifiable`, as `Person` does, or by providing an `id` parameter with the key path to a unique property of the type. The `ForEach` that populates the list above depends on this behavior, as do the `List` initializers that take a `RandomAccessCollection` of members to iterate over. ### Display data inside a row Each row inside a `List` must be a SwiftUI `View`. You may be able to represent your data with a single view such as an `Image` or `Text` view, or you may need to define a custom view to compose several views into something more complex. As your row views get more sophisticated, refactor the views into separate view structures, passing in the data that the row needs to render. The following example defines a `PersonRowView` to create a two-line view for a `Person`, using fonts, colors, and the system “phone” icon image to visually style the data. struct PersonRowView: View { var person: Person var body: some View { VStack(alignment: .leading, spacing: 3) { Text(person.name) .foregroundColor(.primary) .font(.headline) HStack(spacing: 3) { Label(person.phoneNumber, systemImage: "phone") } .foregroundColor(.secondary) .font(.subheadline) } } } struct StaffList: View { var body: some View { List { ForEach(staff) { person in PersonRowView(person: person) } } } } For more information on composing the types of views commonly used inside list rows, see Building layouts with stack views. ### Represent data hierarchy with sections `List` views can also display data with a level of hierarchy, grouping associated data into sections. Consider an expanded data model that represents an entire company, including multiple departments. Each `Department` has a name and an array of `Person` instances, and the company has an array of the `Department` type. struct Department: Identifiable { let id = UUID() var name: String var staff: [Person] } struct Company { var departments: [Department] } var company = Company(departments: [\ Department(name: "Sales", staff: [\ Person(name: "Juan Chavez", phoneNumber: "(408) 555-4301"),\ Person(name: "Mei Chen", phoneNumber: "(919) 555-2481"),\ // ...\ ]),\ Department(name: "Engineering", staff: [\ Person(name: "Bill James", phoneNumber: "(408) 555-4450"),\ Person(name: "Anne Johnson", phoneNumber: "(417) 555-9311"),\ // ...\ ]),\ // ...\ ]) Use `Section` views to give the data inside a `List` a level of hierarchy. Start by creating the `List`, using a `ForEach` to iterate over the `company.departments` array, and then create `Section` views for each department. Within the section’s view builder, use a `ForEach` to iterate over the department’s `staff`, and return a customized view for each `Person`. List { ForEach(company.departments) { department in Section(header: Text(department.name)) { ForEach(department.staff) { person in PersonRowView(person: person) } } } } ## Use Lists for Navigation Using a `NavigationLink` within a `List` contained inside a `NavigationView` adds platform-appropriate visual styling, and in some cases, additional container views that provide the structure for navigation. SwiftUI uses one of two visual presentations, based on the runtime environment: - A list with disclosure indicators, which performs an animated navigation to a destination scene when the user chooses a list item. SwiftUI uses this presentation on watchOS, tvOS, and on most iOS devices except as described below. - A two-panel split view, with the top-level data as a list on the left side and the detail on the right. To get this presentation, you also need to provide a placeholder view after the list; this placeholder fills the detail pane until the user makes a selection. SwiftUI uses this two-panel approach on macOS, iPadOS, and on iOS devices with sufficient horizontal space, as indicated by the `horizontalSizeClass` environment value. The following example sets up a navigation-based UI by wrapping the list with a navigation view. Instances of `NavigationLink` wrap the list’s rows to provide a `destination` view to navigate to when the user taps the row. If a split view navigation is appropriate for the platform, the right panel initially contains the “No Selection” placeholder view, which the navigation view replaces with the destination view when the user makes a selection. NavigationView { List { ForEach(company.departments) { department in Section(header: Text(department.name)) { ForEach(department.staff) { person in NavigationLink(destination: PersonDetailView(person: person)) { PersonRowView(person: person) } } } } } .navigationTitle("Staff Directory") // Placeholder Text("No Selection") .font(.headline) } In this example, the view passed in as the `destination` is a `PersonDetailView`, which repeats the information from the list. In a more complex app, this detail view could show more information about a `Person` than would fit inside the list row. struct PersonDetailView: View { var person: Person var body: some View { VStack { Text(person.name) .foregroundColor(.primary) .font(.title) .padding() HStack { Label(person.phoneNumber, systemImage: "phone") } .foregroundColor(.secondary) } } } On most iOS devices (those with a compact horizontal size class), the list appears as a view by itself, and tapping a row performs an animated transition to the destination view. The following figure shows both the list view and the destination view that appears when the user makes a selection: On the other hand, iPadOS and macOS show the list and the detail view together as a multi-column view. The following figure shows what this example looks like on macOS prior to making a selection, which means the “No selection” placeholder view is still in the detail column. You can use the `navigationViewStyle(_:)` view modifier to change the default behavior of a `NavigationView`. For example, on iOS, the `StackNavigationViewStyle` forces single-column mode, even on an iPad in landscape orientation. ## See Also ### Creating a list `struct List` A container that presents rows of data arranged in a single column, optionally providing the ability to select one or more members. Sets the style for lists within this view. --- # https://developer.apple.com/documentation/swiftui/view/body-8kl5o - SwiftUI - View - body Instance Property # body The content and behavior of the view. @ViewBuilder @MainActor @preconcurrency var body: Self.Body { get } **Required** Default implementations provided. ## Mentioned in Declaring a custom view ## Discussion When you implement a custom view, you must implement a computed `body` property to provide the content for your view. Return a view that’s composed of built-in views that SwiftUI provides, plus other composite views that you’ve already defined: struct MyView: View { var body: some View { Text("Hello, World!") } } For more information about composing views and a view hierarchy, see Declaring a custom view. ## Default Implementations ### NSViewControllerRepresentable Implementations `var body: Never` Declares the content and behavior of this view. ### NSViewRepresentable Implementations ### UIViewControllerRepresentable Implementations ### UIViewRepresentable Implementations ### WKInterfaceObjectRepresentable Implementations ## See Also ### Implementing a custom view `associatedtype Body : View` The type of view representing the body of this view. **Required** Applies a modifier to a view and returns a new view. Generate dynamic, interactive previews of your custom views. --- # https://developer.apple.com/documentation/swiftui/text - SwiftUI - Text Structure # Text A view that displays one or more lines of read-only text. @frozen struct Text ## Mentioned in Configuring views Declaring a custom view Laying out a simple view Building layouts with stack views Performing a search operation ## Overview A text view draws a string in your app’s user interface using a `body` font that’s appropriate for the current platform. You can choose a different standard font, like `title` or `caption`, using the `font(_:)` view modifier. Text("Hamlet") .font(.title) If you need finer control over the styling of the text, you can use the same modifier to configure a system font or choose a custom font. You can also apply view modifiers like `bold()` or `italic()` to further adjust the formatting. Text("by William Shakespeare") .font(.system(size: 12, weight: .light, design: .serif)) .italic() To apply styling within specific portions of the text, you can create the text view from an `AttributedString`, which in turn allows you to use Markdown to style runs of text. You can mix string attributes and SwiftUI modifiers, with the string attributes taking priority. let attributedString = try! AttributedString( markdown: "_Hamlet_ by William Shakespeare") var body: some View { Text(attributedString) .font(.system(size: 12, weight: .light, design: .serif)) } A text view always uses exactly the amount of space it needs to display its rendered contents, but you can affect the view’s layout. For example, you can use the `frame(width:height:alignment:)` modifier to propose specific dimensions to the view. If the view accepts the proposal but the text doesn’t fit into the available space, the view uses a combination of wrapping, tightening, scaling, and truncation to make it fit. With a width of `100` points but no constraint on the height, a text view might wrap a long string: Text("To be, or not to be, that is the question:") .frame(width: 100) Use modifiers like `lineLimit(_:)`, `allowsTightening(_:)`, `minimumScaleFactor(_:)`, and `truncationMode(_:)` to configure how the view handles space constraints. For example, combining a fixed width and a line limit of `1` results in truncation for text that doesn’t fit in that space: Text("Brevity is the soul of wit.") .frame(width: 100) .lineLimit(1) ### Localizing strings If you initialize a text view with a string literal, the view uses the `init(_:tableName:bundle:comment:)` initializer, which interprets the string as a localization key and searches for the key in the table you specify, or in the default table if you don’t specify one. Text("pencil") // Searches the default table in the main bundle. For an app localized in both English and Spanish, the above view displays “pencil” and “lápiz” for English and Spanish users, respectively. If the view can’t perform localization, it displays the key instead. For example, if the same app lacks Danish localization, the view displays “pencil” for users in that locale. Similarly, an app that lacks any localization information displays “pencil” in any locale. To explicitly bypass localization for a string literal, use the `init(verbatim:)` initializer. Text(verbatim: "pencil") // Displays the string "pencil" in any locale. If you initialize a text view with a variable value, the view uses the `init(_:)` initializer, which doesn’t localize the string. However, you can request localization by creating a `LocalizedStringKey` instance first, which triggers the `init(_:tableName:bundle:comment:)` initializer instead: // Don't localize a string variable... Text(writingImplement) // ...unless you explicitly convert it to a localized string key. Text(LocalizedStringKey(writingImplement)) When localizing a string variable, you can use the default table by omitting the optional initialization parameters — as in the above example — just like you might for a string literal. When composing a complex string, where there is a need to assemble multiple pieces of text, use string interpolation: let name: String = //… Text("Hello, \(name)") This would look up the `"Hello, %@"` localization key in the localized string file and replace the format specifier `%@` with the value of `name` before rendering the text on screen. Using string interpolation ensures that the text in your app can be localized correctly in all locales, especially in right-to-left languages. If you desire to style only parts of interpolated text while ensuring that the content can still be localized correctly, interpolate `Text` or `AttributedString`: let name = Text(person.name).bold() Text("Hello, \(name)") The example above uses `appendInterpolation(_:)` and will look up the `"Hello, %@"` in the localized string file and interpolate a bold text rendering the value of `name`. Using `appendInterpolation(_:)` you can interpolate `Image` in text. ## Topics ### Creating a text view `init(LocalizedStringKey, tableName: String?, bundle: Bundle?, comment: StaticString?)` Creates a text view that displays localized content identified by a key. `init(_:)` Creates a text view that displays styled attributed content. `init(verbatim: String)` Creates a text view that displays a string literal without localization. `init(Date, style: Text.DateStyle)` Creates an instance that displays localized dates and times using a specific style. `init(_:format:)` Creates a text view that displays the formatted representation of a nonstring type supported by a corresponding format style. `init(_:formatter:)` Creates a text view that displays the formatted representation of a Foundation object. Creates an instance that displays a timer counting within the provided interval. ### Choosing a font Sets the default font for text in the view. Sets the font weight of the text. Sets the font design of the text. Sets the font width of the text. ### Styling the view’s text Sets the style of the text displayed by this view. Applies a bold or emphasized treatment to the fonts of the text. Applies a bold font weight to the text. Applies italics to the text. Applies a strikethrough to the text. Applies an underline to the text. Modifies the font of the text to use the fixed-width variant of the current font, if possible. Modifies the text view’s font to use fixed-width digits, while leaving other characters proportionally spaced. Sets the spacing, or kerning, between characters. Sets the tracking for the text. Sets the vertical offset for the text relative to its baseline. `enum Case` A scheme for transforming the capitalization of characters within text. `struct DateStyle` A predefined style used to display a `Date`. `struct LineStyle` Description of the style used to draw the line for `StrikethroughStyleAttribute` and `UnderlineStyleAttribute`. ### Fitting text into available space Applies a text scale to the text. `struct Scale` Defines text scales `enum TruncationMode` The type of truncation to apply to a line of text when it’s too long to fit in the available space. ### Localizing text `func typesettingLanguage(_:isEnabled:)` Specifies the language for typesetting. ### Configuring voiceover Raises or lowers the pitch of spoken text. Sets whether VoiceOver should always speak all punctuation in the text view. Controls whether to queue pending announcements behind existing speech rather than interrupting speech in progress. Sets whether VoiceOver should speak the contents of the text view character by character. ### Providing accessibility information Sets the accessibility level of this heading. `func accessibilityLabel(_:)` Adds a label to the view that describes its contents. Sets an accessibility text content type. ### Combining text views Concatenates the text in two text views in a new text view. Deprecated ### Deprecated symbols Sets the color of the text displayed by this view. ### Structures `struct AlignmentStrategy` The way SwiftUI infers the appropriate text alignment if no value is explicitly provided. Beta `struct Layout` A value describing the layout and custom attributes of a tree of `Text` views. `struct LayoutKey` A preference key that provides the `Text.Layout` values for all text views in the queried subtree. `struct WritingDirectionStrategy` The way SwiftUI infers the appropriate writing direction if no value is explicitly provided. ### Instance Methods Adds a custom attribute to the text view. Controls the way text size variants are chosen. ## Relationships ### Conforms To - `Copyable` - `Equatable` - `Sendable` - `SendableMetatype` - `View` ## See Also ### Displaying text `struct Label` A standard label for user interface items, consisting of an icon with a title. Sets the style for labels within this view. --- # https://developer.apple.com/documentation/swiftui/view/opacity(_:) #app-main) - SwiftUI - View - opacity(\_:) Instance Method # opacity(\_:) Sets the transparency of this view. nonisolated ## Parameters `opacity` A value between 0 (fully transparent) and 1 (fully opaque). ## Return Value A view that sets the transparency of this view. ## Discussion Apply opacity to reveal views that are behind another view or to de-emphasize a view. When applying the `opacity(_:)` modifier to a view that has already had its opacity transformed, the modifier multiplies the effect of the underlying opacity transformation. The example below shows yellow and red rectangles configured to overlap. The top yellow rectangle has its opacity set to 50%, allowing the occluded portion of the bottom rectangle to be visible: struct Opacity: View { var body: some View { VStack { Color.yellow.frame(width: 100, height: 100, alignment: .center) .zIndex(1) .opacity(0.5) Color.red.frame(width: 100, height: 100, alignment: .center) .padding(-40) } } } ## See Also ### Hiding views Hides this view unconditionally. --- # https://developer.apple.com/documentation/swiftui/view-layout --- # https://developer.apple.com/documentation/swiftui/view-accessibility --- # https://developer.apple.com/documentation/swiftui/view-input-and-events Collection - SwiftUI - View fundamentals - View - Input and event modifiers API Collection # Input and event modifiers Supply actions for a view to perform in response to user input and system events. ## Overview Use input and event modifiers to configure and provide handlers for a wide variety of user inputs or system events. For example, you can detect and control focus, respond to life cycle events like view appearance and disappearance, manage keyboard shortcuts, and much more. ## Topics ### Interactivity Adds a condition that controls whether users can interact with this view. Sets a tag that you use for tracking interactivity. ### List controls Adds custom swipe actions to a row in a list. Marks this view as refreshable. Adds a condition that controls whether users can select this view. ### Scroll controls Associates a binding to a scroll position with a scroll view within this view. Associates a binding to be updated when a scroll view within this view scrolls. Associates an anchor to control which part of the scroll view’s content should be rendered by default. Associates an anchor to control the position of a scroll view in a particular circumstance. Sets the scroll behavior of views scrollable in the provided axes. Configures the outermost layout as a scroll target layout. Applies the given transition, animating between the phases of the transition as this view appears and disappears within the visible region of the containing scroll view. Adds an action to be performed when a value, created from a scroll geometry, changes. Adds an action to be called with information about what views would be considered visible. Adds an action to be called when the view crosses the threshold to be considered on/off screen. `func onScrollPhaseChange(_:)` Adds an action to perform when the scroll phase of the first scroll view in the hierarchy changes. ### Geometry `func onGeometryChange(for:of:action:)` Adds an action to be performed when a value, created from a geometry proxy, changes. ### Taps and gestures For more information, see Gestures. Adds an action to perform when this view recognizes a tap gesture. `func onTapGesture(count:coordinateSpace:perform:)` Adds an action to perform when this view recognizes a tap gesture, and provides the action with the location of the interaction. Adds an action to perform when this view recognizes a long press gesture. Adds an action to perform when this view recognizes a remote long touch gesture. A long touch gesture is when the finger is on the remote touch surface without actually pressing. `func gesture(_:)` Attaches an `NSGestureRecognizerRepresentable` to the view. Beta Attaches a gesture to the view with a lower precedence than gestures defined by the view. Attaches a gesture to the view with a higher precedence than gestures defined by the view. Attaches a gesture to the view to process simultaneously with gestures defined by the view. Sets the screen edge from which you want your gesture to take precedence over the system gesture. Adds an action to perform after the user double-taps their Apple Pencil. Adds an action to perform when the user squeezes their Apple Pencil. Configures whether gestures in this view hierarchy can handle events that activate the containing window. ### Keyboard input Performs an action if the user presses a key on a hardware keyboard while the view has focus. Performs an action if the user presses any key on a hardware keyboard while the view has focus. Performs an action if the user presses one or more keys on a hardware keyboard while the view has focus. Performs an action whenever the user presses or releases a hardware modifier key. ### Keyboard shortcuts `func keyboardShortcut(_:)` Assigns a keyboard shortcut to the modified control. Defines a keyboard shortcut and assigns it to the modified control. Builds a view to use in place of the modified view when the user presses the modifier key(s) indicated by the given set. ### Hover Adds an action to perform when the user moves the pointer over or away from the view’s frame. `func onContinuousHover(coordinateSpace:perform:)` Adds an action to perform when the pointer enters, moves within, and exits the view’s bounds. Applies a hover effect to this view. `func hoverEffect(_:isEnabled:)` Applies a hover effect to this view, optionally adding it to a `HoverEffectGroup`. Applies a hover effect to this view described by the given closure. Adds an implicit `HoverEffectGroup` to all effects defined on descendant views, so that all effects added to subviews activate as a group whenever this view or any descendant views are hovered. Adds a `HoverEffectGroup` to all effects defined on descendant views, and activates the group whenever this view or any descendant views are hovered. Adds a condition that controls whether this view can display hover effects. `func defaultHoverEffect(_:)` Sets the default hover effect to use for views within this view. Requests that the containing list row use the provided hover effect. Requests that the containing list row have its hover effect disabled. ### Pointer Sets the visibility of the pointer when it’s over the view. Sets the pointer style to display when the pointer is over the view. ### Focus For more information, see Focus. Modifies this view by binding its focus state to the given state value. Modifies this view by binding its focus state to the given Boolean state value. Sets the focused value for the given object type. `func focusedValue(_:_:)` Modifies this view by injecting a value that you provide for use by other views whose state depends on the focused view hierarchy. Sets the focused value for the given object type at a scene-wide scope. `func focusedSceneValue(_:_:)` Modifies this view by injecting a value that you provide for use by other views whose state depends on the focused scene. `func focusedObject(_:)` Creates a new view that exposes the provided object to other views whose whose state depends on the focused view hierarchy. `func focusedSceneObject(_:)` Creates a new view that exposes the provided object to other views whose whose state depends on the active scene. Indicates that the view should receive focus by default for a given namespace. Creates a focus scope that SwiftUI uses to limit default focus preferences. Indicates that the view’s frame and cohort of focusable descendants should be used to guide focus movement. Specifies if the view is focusable. Specifies if the view is focusable, and if so, what focus-driven interactions it supports. Adds a condition that controls whether this view can display focus effects, such as a default focus ring or hover effect. Defines a region of the window in which default focus is evaluated by assigning a value to a given focus state binding. Modifies this view by binding the focus state of the search field associated with the nearest searchable modifier to the given Boolean value. Modifies this view by binding the focus state of the search field associated with the nearest searchable modifier to the given value. ### Copy and paste For more information, see Clipboard. Specifies a list of items to copy in response to the system’s Copy command. Specifies an action that moves items to the Clipboard in response to the system’s Cut command. Specifies an action that adds validated items to a view in response to the system’s Paste command. Adds an action to perform in response to the system’s Copy command. Adds an action to perform in response to the system’s Cut command. `func onPasteCommand(of:perform:)` Adds an action to perform in response to the system’s Paste command. `func onPasteCommand(of:validator:perform:)` Adds an action to perform in response to the system’s Paste command with items that you validate. ### Drag and drop For more information, see Drag and drop. Activates this view as the source of a drag and drop operation. Provides a closure that vends the drag representation to be used for a particular data element. `func onDrop(of:isTargeted:perform:)` Defines the destination of a drag-and-drop operation that handles the dropped content with a closure that you specify. `func onDrop(of:delegate:)` Defines the destination of a drag and drop operation using behavior controlled by the delegate that you provide. Defines the destination of a drag and drop operation that handles the dropped content with a closure that you specify. Sets the spring loading behavior this view. ### Submission Adds an action to perform when the user submits a value to this view. Prevents submission triggers originating from this view to invoke a submission action configured by a submission modifier higher up in the view hierarchy. Sets the submit label for this view. ### Movement Adds an action to perform in response to a move command, like when the user presses an arrow key on a Mac keyboard, or taps the edge of the Siri Remote when controlling an Apple TV. Adds a condition for whether the view’s view hierarchy is movable. ### Deletion Adds an action to perform in response to the system’s Delete command, or pressing either the ⌫ (backspace) or ⌦ (forward delete) keys while the view has focus. Adds a condition for whether the view’s view hierarchy is deletable. ### Commands Steps a value through a range in response to page up or page down commands. Sets up an action that triggers in response to receiving the exit command while the view has focus. Adds an action to perform in response to the system’s Play/Pause command. Adds an action to perform in response to the given selector. ### Digital crown Specifies the visibility of Digital Crown accessory Views on Apple Watch. Places an accessory View next to the Digital Crown on Apple Watch. Tracks Digital Crown rotations by updating the specified binding. `func digitalCrownRotation(detent:from:through:by:sensitivity:isContinuous:isHapticFeedbackEnabled:onChange:onIdle:)` ### Immersive Spaces For more information, see Immersive spaces. Performs an action when the immersion state of your app changes. ### Volumes Adds an action to perform when the viewpoint of the volume changes. Specifies which viewpoints are supported for the window bar and ornaments in a volume. ### User activities Advertises a user activity type. Registers a handler to invoke in response to a user activity that your app receives. Specifies the external events that the view’s scene handles if the scene is already open. ### View life cycle Adds an action to perform before this view appears. Adds an action to perform after this view disappears. `func onChange(of:initial:_:)` Adds a modifier for this view that fires an action when a specific value changes. Adds an asynchronous task to perform before this view appears. Adds a task to perform before this view appears or when a specified value changes. ### File renaming `func renameAction(_:)` Sets a closure to run for the rename action. ### URLs Registers a handler to invoke in response to a URL that your app receives. Sets the URL to open in the containing app when the user clicks the widget. ### Publisher events Adds an action to perform when this view detects data emitted by the given publisher. ### Hit testing Configures whether this view participates in hit test operations. ### Content shape Defines the content shape for hit testing. Sets the content shape for this view. ### Import and export Exports a read-only item provider for consumption by shortcuts, quick actions, and services. Exports a read-write item provider for consumption by shortcuts, quick actions, and services. Enables importing item providers from services, such as Continuity Camera on macOS. Exports items for consumption by shortcuts, quick actions, and services. Exports read-write items for consumption by shortcuts, quick actions, and services. Enables importing items from services, such as Continuity Camera on macOS. ### App intents Sets the given style for ShortcutsLinks within the view hierarchy Sets the given style for SiriTipView within the view hierarchy ### Camera Used to register an action triggered by system capture events. Used to register actions triggered by system capture events. Specifies the view that should act as the virtual camera for Apple Vision Pro 2D Persona stream. ## See Also ### Providing interactivity Enable people to search for content in your app. Define additional views for the view to present under specified conditions. Access storage and provide child views with configuration data. --- # https://developer.apple.com/documentation/swiftui/view/body-swift.associatedtype - SwiftUI - View - Body Associated Type # Body The type of view representing the body of this view. associatedtype Body : View **Required** ## Discussion When you create a custom view, Swift infers this type from your implementation of the required `body` property. ## See Also ### Implementing a custom view `var body: Self.Body` The content and behavior of the view. **Required** Default implementations provided. Applies a modifier to a view and returns a new view. Generate dynamic, interactive previews of your custom views. --- # https://developer.apple.com/documentation/swiftui/view/modifier(_:) #app-main) - SwiftUI - View - modifier(\_:) Instance Method # modifier(\_:) Applies a modifier to a view and returns a new view. nonisolated ## Parameters `modifier` The modifier to apply to this view. ## Mentioned in Reducing view modifier maintenance ## Discussion Use this modifier to combine a `View` and a `ViewModifier`, to create a new view. For example, if you create a view modifier for a new kind of caption with blue text surrounded by a rounded rectangle: struct BorderedCaption: ViewModifier { content .font(.caption2) .padding(10) .overlay( RoundedRectangle(cornerRadius: 15) .stroke(lineWidth: 1) ) .foregroundColor(Color.blue) } } You can use `modifier(_:)` to extend `View` to create new modifier for applying the `BorderedCaption` defined above: extension View { modifier(BorderedCaption()) } } Then you can apply the bordered caption to any view: Image(systemName: "bus") .resizable() .frame(width:50, height:50) Text("Downtown Bus") .borderedCaption() ## See Also ### Modifying a view Configuring views Adjust the characteristics of a view by applying view modifiers. Bundle view modifiers that you regularly reuse into a custom view modifier. `protocol ViewModifier` A modifier that you apply to a view or another view modifier, producing a different version of the original value. `struct EmptyModifier` An empty, or identity, modifier, used during development to switch modifiers at compile time. `struct ModifiedContent` A value with a modifier applied to it. `protocol EnvironmentalModifier` A modifier that must resolve to a concrete modifier in an environment before use. `struct ManipulableModifier` Beta `struct ManipulableResponderModifier` Beta `struct ManipulableTransformBindingModifier` Beta `struct ManipulationGeometryModifier` Beta `struct ManipulationGestureModifier` Beta `struct ManipulationUsingGestureStateModifier` Beta `enum Manipulable` A namespace for various manipulable related types. Beta --- # https://developer.apple.com/documentation/swiftui/view-appearance Collection - SwiftUI - View fundamentals - View - Appearance modifiers API Collection # Appearance modifiers Configure a view’s foreground and background styles, controls, and visibility. ## Overview Use these modifiers to configure the appearance of a view, including the use of color and tint, and the application of overlays and background elements. Control the visibility of a view and specific elements within a view. Manage the shape and size of various controls. For information about configuring views, see View configuration. ## Topics ### Colors and patterns Sets the specified style to render backgrounds within the view. Sets a view’s foreground elements to use a given style. Sets the primary and secondary levels of the foreground style in the child view. Sets the primary, secondary, and tertiary levels of the foreground style. Returns a new view configured with the specified allowed dynamic range. ### Tint `func tint(_:)` Sets the tint color within this view. Sets the tint color associated with a row. Sets the tint color associated with a section. `func listItemTint(_:)` Sets a fixed tint color for content in a list. ### Light and dark appearance Sets the preferred color scheme for this presentation. Applies an effect to passthrough video. ### Foreground elements Adds a border to this view with the specified style and width. Layers the views that you specify in front of this view. Layers the specified style in front of this view. Layers a shape that you specify in front of this view. ### Background elements Layers the views that you specify behind this view. Sets the view’s background to a style. Sets the view’s background to the default background style. `func background(_:in:fillStyle:)` Sets the view’s background to an insettable shape filled with a style. `func background(in:fillStyle:)` Sets the view’s background to an insettable shape filled with the default background style. Overrides whether lists and tables in this view have alternating row backgrounds. Places a custom background view behind a list row item. Specifies the visibility of the background for scrollable views within this view. Sets the container background of the enclosing container using a view. Fills the view’s background with an automatic glass background effect and container-relative rounded rectangle shape. Fills the view’s background with an automatic glass background effect and a shape that you specify. ### Control configuration Sets the default wheel-style picker item height. Sets the style for radio group style pickers within this view to be horizontally positioned with the radio buttons inside the layout. `func controlSize(_:)` Sets the size for controls within this view. Sets the border shape for buttons in this view. Sets whether buttons in this view should repeatedly trigger their actions on prolonged interactions. Sets the header prominence for this view. Disables or enables scrolling in scrollable views. Configures the bounce behavior of scrollable views along the specified axis. Flashes the scroll indicators of a scrollable view when it appears. Flashes the scroll indicators of scrollable views when a value changes. Sets the preferred order of items for menus presented from this view. Tells a menu whether to dismiss after performing an action. Specifies the selection effect to apply to a palette item. `func typeSelectEquivalent(_:)` Sets an explicit type select equivalent text in a collection, such as a list or table. ### Symbol effects Returns a new view with a symbol effect added to it. Returns a new view with its inherited symbol image effects either removed or left unchanged. ### Privacy and redaction Marks the view as containing sensitive, private user data. Adds a reason to apply a redaction to this view hierarchy. Removes any reason to apply a redaction to this view hierarchy. Mark the receiver as their content might be invalidated. ### Visibility Hides this view unconditionally. Hides the labels of any controls contained within this view. Sets the menu indicator visibility for controls within this view. Sets the display mode for the separator associated with this specific row. Sets whether to hide the separator associated with a list section. Sets the preferred visibility of the non-transient system views overlaying the app. Sets the visibility of scroll indicators within this view. Sets whether a scroll view clips its content to its bounds. Controls the visibility of a `Table`’s column header views. Sets the preferred visibility of the user’s upper limbs, while an `ImmersiveSpace` scene is presented. Sets the visibility of the baseplate of a volume, which appears when a user looks towards the ‘floor’ of a volume and during resize. Both `automatic` and `visible` will show the baseplate. `hidden` will never show it. ### Sensory feedback Plays the specified `feedback` when the provided `trigger` value changes. `func sensoryFeedback(trigger:_:)` Plays feedback when returned from the `feedback` closure after the provided `trigger` value changes. Plays the specified `feedback` when the provided `trigger` value changes and the `condition` closure returns `true`. ### Widget configuration Adds the view and all of its subviews to the accented group. Displays the widget’s content along a curve if the context allows it. `func widgetLabel(_:)` Returns a localized text label that displays additional content outside the accessory family widget’s main SwiftUI view. Creates a label for displaying additional content outside an accessory family widget’s main SwiftUI view. Specifies the vertical placement for a view of an expanded Live Activity that appears in the Dynamic Island. ### Window behaviors Configures the dismiss functionality for the window enclosing `self`. Configures the full screen functionality for the window enclosing `self`. Configures the minimize functionality for the window enclosing `self`. Configures the resize functionality for the window enclosing `self`. ## See Also ### Configuring view elements Make your SwiftUI apps accessible to everyone, including people with disabilities. Manage the rendering, selection, and entry of text in your view. Add and configure supporting views, like toolbars and context menus. Configure charts that you declare with Swift Charts. --- # https://developer.apple.com/documentation/swiftui/view-text-and-symbols Collection - SwiftUI - View fundamentals - View - Text and symbol modifiers API Collection # Text and symbol modifiers Manage the rendering, selection, and entry of text in your view. ## Overview SwiftUI provides built-in views that display text to the user, like `Text` and `Label`, or that collect text from the user, like `TextField` and `TextEditor`. Use text and symbol modifiers to control how SwiftUI displays and manages that text. For example, you can set a font, specify text layout parameters, and indicate what kind of input to expect. To learn more about the kinds of views that you use to display text and the ways in which you can configure those views, see Text input and output. ## Topics ### Fonts Sets the default font for text in this view. ### Dynamic type `func dynamicTypeSize(_:)` Sets the Dynamic Type size within the view to the given value. ### Text style Applies a bold font weight to the text in this view. Sets the font design of the text in this view. Sets the font weight of the text in this view. Sets the font width of the text in this view. Applies italics to the text in this view. Modifies the fonts of all child views to use the fixed-width variant of the current font, if possible. Modifies the fonts of all child views to use fixed-width digits, if possible, while leaving other characters proportionally spaced. Applies a strikethrough to the text in this view. Sets a transform for the case of the text contained in this view when displayed. Applies a text scale to text in the view. Applies an underline to the text in this view. ### Text layout Sets whether text in this view can compress the space between characters when necessary to fit text in a line. Sets the vertical offset for the text relative to its baseline in this view. Sets whether this view mirrors its contents horizontally when the layout direction is right-to-left. Sets the spacing, or kerning, between characters for the text in this view. Sets the minimum amount that text in this view scales down to fit in the available space. Sets the tracking for the text in this view. Sets the truncation mode for lines of text that are too long to fit in the available space. `func typesettingLanguage(_:isEnabled:)` Specifies the language for typesetting. ### Multiline text `func lineLimit(_:)` Sets to a closed range the number of lines that text can occupy in this view. Sets a limit for the number of lines text can occupy in this view. Sets the amount of space between lines of text in this view. Sets the alignment of a text view that contains multiple lines of text. ### Text selection Controls whether people can select text within this view. ### Text entry Sets whether to disable autocorrection for this view. Sets the keyboard type for this view. Configures the behavior in which scrollable content interacts with the software keyboard. Sets how often the shift key in the keyboard is automatically enabled. Associates a fully formed string with the value of this view when used as a text input suggestion Configures the text input suggestions for this view. Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on a watchOS device. Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on macOS. Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on an iOS or tvOS device. ### Find and replace Programmatically presents the find and replace interface for text editor views. Prevents find and replace operations in a text editor. Prevents replace operations in a text editor. ### Symbol appearance Sets the rendering mode for symbol images within this view. Makes symbols within the view show a particular variant. ## See Also ### Configuring view elements Make your SwiftUI apps accessible to everyone, including people with disabilities. Configure a view’s foreground and background styles, controls, and visibility. Add and configure supporting views, like toolbars and context menus. Configure charts that you declare with Swift Charts. --- # https://developer.apple.com/documentation/swiftui/view-auxiliary-views Collection - SwiftUI - View fundamentals - View - Auxiliary view modifiers API Collection # Auxiliary view modifiers Add and configure supporting views, like toolbars and context menus. ## Overview Use these modifiers to manage supplemental views that present context-specific controls and information. For example, you can add titles and buttons to navigation bars, manage the status bar, create context menus, and add badges many different kinds of views. ## Topics ### Navigation titles Configure your apps navigation titles Use a navigation title to display the current navigation state of an interface. `func navigationTitle(_:)` Configures the view’s title for purposes of navigation, using a string binding. `func navigationSubtitle(_:)` Configures the view’s subtitle for purposes of navigation. ### Navigation title configuration `func navigationDocument(_:)` Configures the view’s document for purposes of navigation. `func navigationDocument(_:preview:)` ### Navigation bars Hides the navigation bar back button for the view. Configures the title display mode for this view. ### Navigation stacks and columns Associates a destination view with a presented data type for use within a navigation stack. Associates a destination view with a binding that can be used to push the view onto a `NavigationStack`. `func navigationDestination(item: Binding>, destination: (D) -> C) -> some View` Associates a destination view with a bound value for use within a navigation stack or navigation split view Sets a fixed, preferred width for the column containing this view. Sets a flexible, preferred width for the column containing this view. ### Tab views Specifies the customizations to apply to the sidebar representation of the tab view. Specifies the default placement for the tabs in a tab view using the adaptable sidebar style. Adds a custom header to the sidebar of a tab view. Adds a custom footer to the sidebar of a tab view. Adds a custom bottom bar to the sidebar of a tab view. Adds custom actions to a section. ### Toolbars For information about toolbars, see Toolbars. `func toolbar(content:)` Populates the toolbar or navigation bar with the specified items. Populates the toolbar or navigation bar with the specified items, allowing for user customization. Specifies the visibility of a bar managed by SwiftUI. Remove a toolbar item present by default `func toolbarBackground(_:for:)` Specifies the preferred shape style of the background of a bar managed by SwiftUI. Specifies the preferred visibility of backgrounds on a bar managed by SwiftUI. Specifies the preferred foreground style of bars managed by SwiftUI. Specifies the preferred color scheme of a bar managed by SwiftUI. Configures the semantic role for the content populating the toolbar. Configure the title menu of a toolbar. Configures the toolbar title display mode for this view. `func ornament(visibility:attachmentAnchor:contentAlignment:ornament:)` Presents an ornament. ### Context menus For information about menus in your app, see Menus and commands. Adds a context menu to a view. Adds a context menu with a custom preview to a view. Adds an item-based context menu to a view. ### Badges `func badge(_:)` Generates a badge for the view from an integer value. Specifies the prominence of badges created by this view. ### Help text `func help(_:)` Adds help text to a view using a text view that you provide. ### Status bar Sets the visibility of the status bar. ### Touch Bar Sets the content that the Touch Bar displays. Sets the Touch Bar content to be shown in the Touch Bar when applicable. Sets principal views that have special significance to this Touch Bar. Sets a user-visible string that identifies the view’s functionality. Sets the behavior of the user-customized view. ## See Also ### Configuring view elements Make your SwiftUI apps accessible to everyone, including people with disabilities. Configure a view’s foreground and background styles, controls, and visibility. Manage the rendering, selection, and entry of text in your view. Configure charts that you declare with Swift Charts. --- # https://developer.apple.com/documentation/swiftui/view-chart-view Collection - SwiftUI - View fundamentals - View - Chart view modifiers API Collection # Chart view modifiers Configure charts that you declare with Swift Charts. ## Overview Use these modifiers to configure a `Chart` view that you add to your SwiftUI app. ## Topics ### Styles Adds a background to a view that contains a chart. Configures the foreground style scale for charts. Configures the plot area of charts. ### Legends Configures the legend for charts. ### Overlays Adds an overlay to a view that contains a chart. ### Axes Sets the visibility of the x axis. Configures the x-axis for charts in the view. Configures the x axis content of charts. Sets the visibility of the y axis. Configures the y-axis for charts in the view. Configures the y axis content of charts. ### Axis Labels `func chartXAxisLabel(_:position:alignment:spacing:)` Adds x axis label for charts in the view. `func chartYAxisLabel(_:position:alignment:spacing:)` Adds y axis label for charts in the view. ### Axis scales Configures the x scale for charts. Configures the y scale for charts. ### Symbol scales `func chartSymbolScale(_:)` Configures the symbol scale for charts. Configures the symbol style scale for charts. `func chartSymbolScale(domain:range:)` `func chartSymbolScale(range:)` ### Symbol size scales Configures the symbol size scale for charts. ### Line style scales Configures the line style scale for charts. ### Scrolling Sets the initial scroll position along the x-axis. Once the user scrolls the scroll view, the value provided to this modifier will have no effect. Sets the initial scroll position along the y-axis. Once the user scrolls the scroll view, the value provided to this modifier will have no effect. Associates a binding to be updated when the chart scrolls along the x-axis. Associates a binding to be updated when the chart scrolls along the y-axis. Sets the scroll behavior of the scrollable chart. Configures the scrollable behavior of charts in this view. ### Visible domain Sets the length of the visible domain in the X dimension. Sets the length of the visible domain in the Y dimension. ## See Also ### Configuring view elements Make your SwiftUI apps accessible to everyone, including people with disabilities. Configure a view’s foreground and background styles, controls, and visibility. Manage the rendering, selection, and entry of text in your view. Add and configure supporting views, like toolbars and context menus. --- # https://developer.apple.com/documentation/swiftui/view-style-modifiers Collection - SwiftUI - View fundamentals - View - Style modifiers API Collection # Style modifiers Apply built-in styles to different types of views. ## Overview SwiftUI defines built-in styles for certain kinds of views, and chooses the appropriate style for a particular presentation context. For example, a `Label` might appear as an icon, a string title, or both, depending on factors like the platform, whether the view appears in a toolbar, and so on. You can override the automatic style by using one of the style modifiers. These modifiers typically propagate through container views, so you can wrap an entire view hierarchy in a style modifier to affect all the views of the given type within the hierarchy. Some view types enable you to create custom styles, which you also apply using style modifiers. For more information about styling views, see View styles. ## Topics ### Controls `func buttonStyle(_:)` Sets the style for buttons within this view to a button style with a custom appearance and standard interaction behavior. Sets the style for date pickers within this view. Sets the style for menus within this view. Sets the style for pickers within this view. Sets the style for toggles in a view hierarchy. ### Indicators Sets the style for gauges within this view. Sets the style for progress views in this view. ### Text Sets the style for labels within this view. Sets the style for text fields within this view. Sets the style for text editors within this view. ### Collections Sets the style for lists within this view. Sets the style for tables within this view. Sets the style for disclosure groups within this view. ### Presentation Sets the style for navigation split views within this view. Sets the style for the tab view within the current environment. Sets the style for windows created by interacting with this view. Sets the style for the toolbar in windows created by interacting with this view. ### Groups Sets the style for control groups within this view. Sets the style for group boxes within this view. Sets the style for the index view within the current environment. ## See Also ### Drawing views Tell a view how to arrange itself within a view hierarchy by adjusting its size, position, alignment, padding, and so on. Affect the way the system draws a view, for example by scaling or masking a view, or by applying graphical effects. --- # https://developer.apple.com/documentation/swiftui/view-graphics-and-rendering Collection - SwiftUI - View fundamentals - View - Graphics and rendering modifiers API Collection # Graphics and rendering modifiers Affect the way the system draws a view, for example by scaling or masking a view, or by applying graphical effects. ## Overview Use these view modifiers to apply many of the rendering effects typically associated with a graphics context, like adding masks and creating composites. You can apply these effects to graphical views, like Shapes, as well as any other SwiftUI view. When you do need the flexibility of immediate mode drawing in a graphics context, use a `Canvas` view instead. This can be particularly helpful when you want to draw an extremely large number of dynamic shapes — for example, to create particle effects. For more information about using these effects in your app, see Drawing and graphics. ## Topics ### Masks and clipping Masks this view using the alpha channel of the given view. Clips this view to its bounding rectangular frame. Sets a clipping shape for this view. Sets the container shape to use for any container relative shape within this view. ### Scale Scales this view to fill its parent. Scales this view to fit its parent. `func scaleEffect(_:anchor:)` Scales this view’s rendered output by the given amount in both the horizontal and vertical directions, relative to an anchor point. Scales this view’s rendered output by the given horizontal and vertical amounts, relative to an anchor point. Scales this view by the specified horizontal, vertical, and depth factors, relative to an anchor point. Scales images within the view according to one of the relative sizes available including small, medium, and large images sizes. `func aspectRatio(_:contentMode:)` Constrains this view’s dimensions to the specified aspect ratio. ### Rotation and transformation Rotates a view’s rendered output in two dimensions around the specified point. Rotates the view’s content by the specified 3D rotation value. Renders a view’s content as if it’s rotated in three dimensions around the specified axis. `func rotation3DEffect(_:axis:anchor:)` Rotates the view’s content by an angle about an axis that you specify as a tuple of elements. Applies a projection transformation to this view’s rendered output. Applies an affine transformation to this view’s rendered output. Applies a 3D transformation to this view’s rendered output. ### Graphical effects Applies a Gaussian blur to this view. Sets the transparency of this view. Brightens this view by the specified amount. Sets the contrast and separation between similar colors in this view. Inverts the colors in this view. Adds a color multiplication effect to this view. Adjusts the color saturation of this view. Adds a grayscale effect to this view. Applies a hue rotation effect to this view. Adds a luminance to alpha effect to this view. Adds a shadow to this view. Applies effects to this view, while providing access to layout information through a geometry proxy. Applies effects to this view, while providing access to layout information through a 3D geometry proxy. ### Shaders Returns a new view that applies `shader` to `self` as a filter effect on the color of each pixel. Returns a new view that applies `shader` to `self` as a geometric distortion effect on the location of each pixel. Returns a new view that applies `shader` to `self` as a filter on the raster layer created from `self`. ### Composites Sets the blend mode for compositing this view with overlapping views. Wraps this view in a compositing group. Composites this view’s contents into an offscreen image before final display. ### Animations `func animation(_:)` Applies the given animation to this view when this view changes. Applies the given animation to this view when the specified value changes. Applies the given animation to all animatable values within the `body` closure. Loops the given keyframes continuously, updating the view using the modifiers you apply in `body`. Plays the given keyframes when the given trigger value changes, updating the view using the modifiers you apply in `body`. Animates effects that you apply to a view over a sequence of phases that change continuously. Animates effects that you apply to a view over a sequence of phases that change based on a trigger. Modifies the view to use a given transition as its method of animating changes to the contents of its views. `func transition(_:)` Associates a transition with the view. Applies the given transaction mutation function to all animations used within the view. Applies the given transaction mutation function to all animations used within the `body` closure. Defines a group of views with synchronized geometry using an identifier and namespace that you provide. Isolates the geometry (e.g. position and size) of the view from its parent view. ## See Also ### Drawing views Apply built-in styles to different types of views. Tell a view how to arrange itself within a view hierarchy by adjusting its size, position, alignment, padding, and so on. --- # https://developer.apple.com/documentation/swiftui/view-search --- # https://developer.apple.com/documentation/swiftui/view-presentation Collection - SwiftUI - View fundamentals - View - Presentation modifiers API Collection # Presentation modifiers Define additional views for the view to present under specified conditions. ## Overview Use presentation modifiers to show different kinds of modal presentations, like alerts, popovers, sheets, and confirmation dialogs. Because SwiftUI is a declarative framework, you don’t call a method at the moment you want to present the modal. Rather, you define how the presentation looks and the condition under which SwiftUI should present it. SwiftUI detects when the condition changes and makes the presentation for you. Because you provide a `Binding` to the condition that initiates the presentation, SwiftUI can reset the underlying value when the user dismisses the presentation. For more information about how to use these modifiers, see Modal presentations. ## Topics ### Alerts `func alert(_:isPresented:actions:)` Presents an alert when a given condition is true, using a text view for the title. `func alert(_:isPresented:presenting:actions:)` Presents an alert using the given data to produce the alert’s content and a text view as a title. Presents an alert when an error is present. ### Alerts with a message `func alert(_:isPresented:actions:message:)` Presents an alert with a message when a given condition is true using a text view as a title. `func alert(_:isPresented:presenting:actions:message:)` Presents an alert with a message using the given data to produce the alert’s content and a text view for a title. Presents an alert with a message when an error is present. ### Confirmation dialogs `func confirmationDialog(_:isPresented:titleVisibility:actions:)` Presents a confirmation dialog when a given condition is true, using a text view for the title. `func confirmationDialog(_:isPresented:titleVisibility:presenting:actions:)` Presents a confirmation dialog using data to produce the dialog’s content and a text view for the title. `func dismissalConfirmationDialog(_:shouldPresent:actions:)` Presents a confirmation dialog when a dismiss action has been triggered. ### Confirmation dialogs with a message `func confirmationDialog(_:isPresented:titleVisibility:actions:message:)` Presents a confirmation dialog with a message when a given condition is true, using a text view for the title. `func confirmationDialog(_:isPresented:titleVisibility:presenting:actions:message:)` Presents a confirmation dialog with a message using data to produce the dialog’s content and a text view for the message. `func dismissalConfirmationDialog(_:shouldPresent:actions:message:)` ### Dialog configuration Configures the icon used by dialogs within this view. Enables user suppression of dialogs and alerts presented within `self`, with a default suppression message on macOS. Unused on other platforms. `func dialogSuppressionToggle(_:isSuppressed:)` Enables user suppression of dialogs and alerts presented within `self`, with a custom suppression message on macOS. Unused on other platforms. ### Sheets Presents a sheet when a binding to a Boolean value that you provide is true. Presents a sheet using the given item as a data source for the sheet’s content. Presents a modal view that covers as much of the screen as possible when binding to a Boolean value you provide is true. Presents a modal view that covers as much of the screen as possible using the binding you provide as a data source for the sheet’s content. ### Popovers Presents a popover using the given item as a data source for the popover’s content. Presents a popover when a given condition is true. ### Sheet and popover configuration Conditionally prevents interactive dismissal of presentations like popovers, sheets, and inspectors. Sets the available detents for the enclosing sheet. Sets the available detents for the enclosing sheet, giving you programmatic control of the currently selected detent. Sets the visibility of the drag indicator on top of a sheet. Sets the presentation background of the enclosing sheet using a shape style. Sets the presentation background of the enclosing sheet to a custom view. Controls whether people can interact with the view behind a presentation. Specifies how to adapt a presentation to horizontally and vertically compact size classes. Specifies how to adapt a presentation to compact size classes. Configures the behavior of swipe gestures on a presentation. Requests that the presentation have a specific corner radius. Sets the sizing of the containing presentation. ### File exporter `func fileExporter(isPresented:document:contentType:defaultFilename:onCompletion:)` Presents a system interface for exporting a document that’s stored in a value type, like a structure, to a file on disk. `func fileExporter(isPresented:documents:contentType:onCompletion:)` Presents a system interface for exporting a collection of value type documents to files on disk. `func fileExporter(isPresented:document:contentTypes:defaultFilename:onCompletion:onCancellation:)` Presents a system interface for allowing the user to export a `FileDocument` to a file on disk. `func fileExporter(isPresented:documents:contentTypes:onCompletion:onCancellation:)` Presents a system dialog for allowing the user to export a collection of documents that conform to `FileDocument` to files on disk. Presents a system interface allowing the user to export a `Transferable` item to file on disk. Presents a system interface allowing the user to export a collection of items to files on disk. `func fileExporterFilenameLabel(_:)` On macOS, configures the `fileExporter` with a label for the file name field. ### File importer Presents a system interface for allowing the user to import multiple files. Presents a system interface for allowing the user to import an existing file. Presents a system dialog for allowing the user to import multiple files. ### File mover Presents a system interface for allowing the user to move an existing file to a new location. Presents a system interface for allowing the user to move a collection of existing files to a new location. Presents a system dialog for allowing the user to move an existing file to a new location. Presents a system dialog for allowing the user to move a collection of existing files to a new location. ### File dialog configuration On macOS, configures the `fileExporter`, `fileImporter`, or `fileMover` to provide a refined URL search experience: include or exclude hidden files, allow searching by tag, etc. `func fileDialogConfirmationLabel(_:)` On macOS, configures the the `fileExporter`, `fileImporter`, or `fileMover` with a custom confirmation button label. On macOS, configures the `fileExporter`, `fileImporter`, or `fileMover` to persist and restore the file dialog configuration. Configures the `fileExporter`, `fileImporter`, or `fileMover` to open with the specified default directory. On macOS, configures the `fileExporter`, `fileImporter`, or `fileMover` behavior when a user chooses an alias. `func fileDialogMessage(_:)` On macOS, configures the the `fileExporter`, `fileImporter`, or `fileMover` with a custom text that is presented to the user, similar to a title. On macOS, configures the the `fileImporter` or `fileMover` to conditionally disable presented URLs. ### Inspectors Inserts an inspector at the applied position in the view hierarchy. Sets a fixed, preferred width for the inspector containing this view when presented as a trailing column. Sets a flexible, preferred width for the inspector in a trailing-column presentation. ### Quick look previews Presents a Quick Look preview of the contents of a single URL. Presents a Quick Look preview of the URLs you provide. ### Family Sharing Presents an activity picker view as a sheet. ### Live Activities The text color for the auxiliary action button that the system shows next to a Live Activity on the Lock Screen. Sets the tint color for the background of a Live Activity that appears on the Lock Screen. ### Apple Music Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. ### StoreKit Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. ### PhotoKit Presents a Photos picker that selects a `PhotosPickerItem`. Presents a Photos picker that selects a `PhotosPickerItem` from a given photo library. Presents a Photos picker that selects a collection of `PhotosPickerItem`. Presents a Photos picker that selects a collection of `PhotosPickerItem` from a given photo library. Sets the accessory visibility of the Photos picker. Accessories include anything between the content and the edge, like the navigation bar or the sidebar. Disables capabilities of the Photos picker. Sets the mode of the Photos picker. ## See Also ### Providing interactivity Supply actions for a view to perform in response to user input and system events. Enable people to search for content in your app. Access storage and provide child views with configuration data. --- # https://developer.apple.com/documentation/swiftui/view-state Collection - SwiftUI - View fundamentals - View - State modifiers API Collection # State modifiers Access storage and provide child views with configuration data. ## Overview SwiftUI provides tools for managing data in your app. For example, you can store values and objects in an environment that’s shared among the views in a view hierarchy. Any view that shares the environment — typically all the descendant views of the view that stores the item — can then access the stored item. For more information about the types that SwiftUI provides to help manage data in your app, see Model data. ## Topics ### Identity Sets the unique tag value of this view. Binds a view’s identity to the given proxy value. Prevents the view from updating its child view when its new value is the same as its old value. ### Environment values Places an observable object in the view’s environment. Sets the environment value of the specified key path to the given value. Supplies an observable object to a view’s hierarchy. Transforms the environment value of the specified key path with the given function. ### Preferences Sets a value for the given preference. Applies a transformation to a preference value. Sets a value for the specified preference key, the value is a function of a geometry value tied to the current coordinate space, allowing readers of the value to convert the geometry to their local coordinates. Sets a value for the specified preference key, the value is a function of the key’s current value and a geometry value tied to the current coordinate space, allowing readers of the value to convert the geometry to their local coordinates. Adds an action to perform when the specified preference key’s value changes. Reads the specified preference value from the view, using it to produce a second view that is applied as the background of the original view. Reads the specified preference value from the view, using it to produce a second view that is applied as an overlay to the original view. ### Default storage The default store used by `AppStorage` contained within the view. ### Configuring a model Sets the model context in this view’s environment. Sets the model container and associated model context in this view’s environment. `func modelContainer(for:inMemory:isAutosaveEnabled:isUndoEnabled:onSetup:)` Sets the model container in this view for storing the provided model type, creating a new container if necessary, and also sets a model context for that container in this view’s environment. ## See Also ### Providing interactivity Supply actions for a view to perform in response to user input and system events. Enable people to search for content in your app. Define additional views for the view to present under specified conditions. --- # https://developer.apple.com/documentation/swiftui/view-deprecated Collection - SwiftUI - View fundamentals - View - Deprecated modifiers API Collection # Deprecated modifiers Review unsupported modifiers and their replacements. ## Overview Avoid using deprecated modifiers in your app. Select a modifier to see the replacement that you should use instead. ## Topics ### Accessibility modifiers Adds a label to the view that describes its contents. Deprecated Adds a textual description of the value that the view contains. Specifies whether to hide this view from system accessibility features. Uses the specified string to identify the view. Sets a selection identifier for this view’s accessibility element. Communicates to the user what happens after performing the view’s action. `func accessibility(activationPoint:)` Specifies the point where activations occur in the view. Sets alternate input labels with which users identify a view. Adds the given traits to the view. Removes the given traits from this view. Sets the sort priority order for this view’s accessibility element, relative to other elements at the same level. ### Appearance modifiers Sets this view’s color scheme. Sets the color that the system applies to the row background when this view is placed in a list. Layers the given view behind this view. Layers a secondary view in front of this view. Sets the color of the foreground elements displayed by this view. Promotes this view to the foreground in a complication. ### Text modifiers Sets whether to apply auto-capitalization to this view. Sets whether to disable autocorrection for this view. ### Auxiliary view modifiers `func navigationBarTitle(_:)` Sets the title in the navigation bar for this view. `func navigationBarTitle(_:displayMode:)` Sets the title and display mode in the navigation bar for this view. Sets the navigation bar items for this view. Configures the navigation bar items for this view. Hides the navigation bar for this view. Sets the visibility of the status bar. Adds a context menu to the view. ### Style modifiers Sets the style for menu buttons within this view. Sets the style for navigation views within this view. ### Layout modifiers Positions this view within an invisible frame. Changes the view’s proposed area to extend outside the screen’s safe areas. Assigns a name to the view’s coordinate space, so other code can operate on dimensions like points and sizes relative to the named space. ### Graphics and rendering modifiers Sets the accent color for this view and the views it contains. Masks this view using the alpha channel of the given view. Applies the given animation to all animatable values within this view. Clips this view to its bounding frame, with the specified corner radius. ### Input and events modifiers Adds an action to perform when the given value changes. Adds an action to perform when this view recognizes a tap gesture, and provides the action with the location of the interaction. Adds an action to perform when this view recognizes a long press gesture. Adds an action to perform in response to the system’s Paste command. Adds an action to perform in response to the system’s Paste command with items that you validate. Defines the destination for a drag and drop operation with the same size and position as this view, with behavior controlled by the given delegate. `func onDrop(of:isTargeted:perform:)` Defines the destination of a drag-and-drop operation that handles the dropped content with a closure that you specify. Specifies if the view is focusable and, if so, adds an action to perform when the view comes into focus. Adds an action to perform when the pointer enters, moves within, and exits the view’s bounds. ### View presentation modifiers Presents an action sheet when a given condition is true. Presents an action sheet using the given item as a data source for the sheet’s content. Presents an alert to the user. ### Search modifiers `func searchable(text:placement:prompt:suggestions:)` Marks this view as searchable, which configures the display of a search field. ### Tab modifiers Sets the tab bar item associated with this view. --- # https://developer.apple.com/documentation/swiftui/view/accessibilityactions(category:_:) #app-main) - SwiftUI - View - accessibilityActions(category:\_:) Instance Method # accessibilityActions(category:\_:) Adds multiple accessibility actions to the view with a specific category. Actions allow assistive technologies, such as VoiceOver, to interact with the view by invoking the action and are grouped by their category. When multiple action modifiers with an equal category are applied to the view, the actions are combined together. nonisolated category: AccessibilityActionCategory, ## Parameters `category` The category the accessibility actions are grouped by. `content` The accessibility actions added to the view. ## Discussion Var body: some View { EditorView() .accessibilityActions(category: .edit) { ForEach(editActions) { action in Button(action.title) { action() } } if hasTextSuggestions { Button(“Show Text Suggestions”) { presentTextSuggestions() } } } } ## See Also ### Adding actions to views Adds an accessibility action to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. Adds multiple accessibility actions to the view. `func accessibilityAction(named:_:)` Adds an accessibility action labeled by the contents of `label` to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. When the action is performed, the `intent` will be invoked. Adds an accessibility action representing `actionKind` to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. When the action is performed, the `intent` will be invoked. `func accessibilityAction(named:intent:)` Adds an accessibility action labeled `name` to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. When the action is performed, the `intent` will be invoked. Adds an accessibility adjustable action to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. Adds an accessibility scroll action to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. `struct AccessibilityActionKind` The structure that defines the kinds of available accessibility actions. `enum AccessibilityAdjustmentDirection` A directional indicator you use when making an accessibility adjustment. `struct AccessibilityActionCategory` Designates an accessibility action category that is provided and named by the system. --- # https://developer.apple.com/documentation/swiftui/view/accessibilitydefaultfocus(_:_:) #app-main) - SwiftUI - View - accessibilityDefaultFocus(\_:\_:) Beta Instance Method # accessibilityDefaultFocus(\_:\_:) Defines a region in which default accessibility focus is evaluated by assigning a value to a given accessibility focus state binding. nonisolated _ value: Value ## Parameters `binding` An accessibility focus state binding to update when evaluating default accessibility focus. `value` The value to set the binding to during evaluation. ## Discussion Accessibility default focus is evaluated when a scene appears and an accessibility technology like VoiceOver focuses on its content, when an accessibility focus state binding update moves focus automatically, and when the layout of a scene changes and the accessibility technology must refocus on new content. In the following example, an accessibility technology, like VoiceOver, automatically lands on the title of the playlist as the most important view to initially have focus on, rather than navigating through all controls to understand what the primary content of the view is. var body: some View { VStack { PlayerControls(currentSong: $currentSong) Text(playlist.title) .font(.title) .accessibilityFocused($focusedField, equals: .title) PlaylistEntries(entries: playlist.entries) } .accessibilityDefaultFocus($focusedField, .title) } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/accessibilityscrollstatus(_:isenabled:) #app-main) - SwiftUI - View - accessibilityScrollStatus(\_:isEnabled:) Beta Instance Method # accessibilityScrollStatus(\_:isEnabled:) Changes the announcement provided by accessibility technologies when a user scrolls a scroll view within this view. nonisolated func accessibilityScrollStatus( _ status: LocalizedStringResource, isEnabled: Bool = true Show all declarations ## Parameters `status` The current status of the scroll view. `isEnabled` If true the accessibility scroll status is applied; otherwise the accessibility scroll status is unchanged. ## Discussion Use this modifier to provide a description of the content at the current position in the scroll view. For example, you could use this modifier to announce the current month being scrolled to in a view that contains a calendar. ScrollView { LazyVStack { ForEach(months) { months in MonthView(month: months) } } .scrollTargetLayout() } .scrollPosition($position) .accessibilityScrollStatus(”(months.name(position.viewID)) (year)”) By default, VoiceOver announces “Page X of Y” while scrolling. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/accessorywidgetgroupstyle(_:) #app-main) - SwiftUI - View - accessoryWidgetGroupStyle(\_:) Instance Method # accessoryWidgetGroupStyle(\_:) The view modifier that can be applied to `AccessoryWidgetGroup` to specify the shape the three content views will be masked with. The value of `style` is set to `.automatic`, which is `.circular` by default. @MainActor @preconcurrency ## Parameters `style` The shape with which the content views are masked. The available shapes are circle and rounded square. --- # https://developer.apple.com/documentation/swiftui/view/addordertowalletbuttonstyle(_:) --- # https://developer.apple.com/documentation/swiftui/view/addpasstowalletbuttonstyle(_:) #app-main) - SwiftUI - View - addPassToWalletButtonStyle(\_:) Instance Method # addPassToWalletButtonStyle(\_:) Sets the style to be used by the button. (see `PKAddPassButtonStyle`). PassKitSwiftUI nonisolated ## See Also ### Accessing Apple Pay and Wallet A view that displays a button for identity verification. Sets the button’s style. Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. Sets the action on the PayLaterView. See `PKPayLaterAction`. Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Sets the style to be used by the button. (see `PKIdentityButtonStyle`). Provides a task to perform before this view appears --- # https://developer.apple.com/documentation/swiftui/view/allowswindowactivationevents() #app-main) - SwiftUI - View - allowsWindowActivationEvents() Instance Method # allowsWindowActivationEvents() Configures gestures in this view hierarchy to handle events that activate the containing window. nonisolated ## Discussion Views higher in the hierarchy can override the value you set on this view. In the following example, the tap gesture on the `Rectangle` won’t handle events that activate the containing window because the outer `allowsWindowActivationEvents(_:)` view modifier overrides the inner one: HStack { Rectangle() .onTapGesture { ... } .allowsWindowActivationEvents() } .allowsWindowActivationEvents(false) --- # https://developer.apple.com/documentation/swiftui/view/appstoreoffer(ispresented:kind:ondismiss:) #app-main) - SwiftUI - View - appStoreOffer(isPresented:kind:onDismiss:) Beta Instance Method # appStoreOffer(isPresented:kind:onDismiss:) StoreKitSwiftUI nonisolated func appStoreOffer( kind: AppStoreOfferKind, Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/aspectratio3d(_:contentmode:) #app-main) - SwiftUI - View - aspectRatio3D(\_:contentMode:) Beta Instance Method # aspectRatio3D(\_:contentMode:) Constrains this view’s dimensions to the specified 3D aspect ratio. nonisolated func aspectRatio3D( _ aspectRatio: Size3D? = nil, contentMode: ContentMode ## Parameters `aspectRatio` The ratio of width to height to depth to use for the resulting view. If `aspectRatio` is `nil`, the resulting view maintains this view’s aspect ratio. `contentMode` A flag indicating whether this view should fit or fill the parent context. ## Return Value A view that constrains this view’s dimensions to `aspectRatio`, using `contentMode` as its scaling algorithm. ## Discussion If this view is resizable, the resulting view will have `aspectRatio` as its aspect ratio. In this example, the Model3D has a 2 : 3 : 1 width to height to depth ratio, and scales to fit its frame: Model3D(named: "Sphere") { resolved in let ratio3D = Size3D(width: 2, height: 3, depth: 1) resolved .resizable() .aspectRatio3D(ratio3D, contentMode: .fit) } placeholder: { ProgressView() } .frame(width: 200, height: 200) .frame(depth: 200) .border(Color(white: 0.75)) Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/assistiveaccessnavigationicon(_:) #app-main) - SwiftUI - View - assistiveAccessNavigationIcon(\_:) Beta Instance Method # assistiveAccessNavigationIcon(\_:) Configures the view’s icon for purposes of navigation. nonisolated ## Parameters `icon` The icon image to display. ## Discussion In an Assistive Access scene on iOS and iPadOS, the icon is displayed adjacent to the navigation title. Otherwise, the icon is unused. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/assistiveaccessnavigationicon(systemimage:) #app-main) - SwiftUI - View - assistiveAccessNavigationIcon(systemImage:) Beta Instance Method # assistiveAccessNavigationIcon(systemImage:) Configures the view’s icon for purposes of navigation. nonisolated ## Parameters `systemImage` The system symbol to display. ## Discussion In an Assistive Access scene on iOS and iPadOS, the icon is displayed adjacent to the navigation title. Otherwise, the icon is unused. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/attributedtextformattingdefinition(_:) #app-main) - SwiftUI - View - attributedTextFormattingDefinition(\_:) Beta Instance Method # attributedTextFormattingDefinition(\_:) Apply a text formatting definition to all nested editor views. @MainActor @preconcurrency Show all declarations ## Discussion Applying a text formatting definition to a view makes sure that any content observable to the user adheres to the constraints of the formatting definition. You can compose your own definition from an attribute scope and a series of `AttributedTextValueConstraint` s: // MyTextFormattingDefinition.swift struct MyTextFormattingDefinition: AttributedTextFormattingDefinition { var body: some AttributedTextFormattingDefinition< ValueConstraint( for: \.underlineStyle, values: [nil, .single], default: .single) MyAttributedTextValueConstraint() } } // MyEditorView.swift TextEditor(text: $text) .attributedTextFormattingDefinition(MyTextFormattingDefinition()) To manually enforce constraints, e.g. before serializing text contents, use the `AttributedTextValueConstraint/constrain(_:)-6cp64` method. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/automateddeviceenrollmentaddition(ispresented:) #app-main) - SwiftUI - View - automatedDeviceEnrollmentAddition(isPresented:) Instance Method # automatedDeviceEnrollmentAddition(isPresented:) Presents a modal view that enables users to add devices to their organization. @MainActor @preconcurrency ## Parameters `isPresented` A binding to a Boolean value that determines whether to present the view. ## Return Value The modal view that the system presents to the user. ## Discussion Use this view modifier to present UI in your app for device administrators to add devices purchased outside of the official channel to their organization — Apple School Manager, Apple Business Manager, or Apple Business Essentials. The system requires sign in with a Managed Apple Account that includes device enrollment privileges. The following code example shows one way to present this view to your users: Example Usage: import SwiftUI import AutomatedDeviceEnrollment struct ContentView: View { @State private var isAddingDevices: Bool = false var body: some View { Button("Add Devices to Automated Device Enrollment") { isAddingDevices = true } .automatedDeviceEnrollmentAddition(isPresented: $isAddingDevices) .onChange(of: isAddingDevices) { if !isAddingDevices { // Handle dismiss action } } } } ## See Also ### Working with managed devices Applies a managed content style to the view. --- # https://developer.apple.com/documentation/swiftui/view/breakthrougheffect(_:) #app-main) - SwiftUI - View - breakthroughEffect(\_:) Beta Instance Method # breakthroughEffect(\_:) Ensures that the view is always visible to the user, even when other content is occluding it, like 3D models. nonisolated ## Parameters `effect` The type of effect to apply when the view is occluded by other content. ## Discussion Breakthrough is an effect allowing elements to be visible to the user even when other app content (3D models, UI elements) is positioned in front. The way the element breaks through content in front depends on the chosen `BreakthroughEffect`. This modifier can be used in a number of scenarios, including ornaments and `RealityView` attachments to have them break through in their entirety. ### Regular Elements To have SwiftUI element break through content in front, apply the `breakthroughEffect` modifier directly to the View: ResizeHandle() .breakthroughEffect(.subtle) ### Ornaments When applied to the whole content of an ornament, the ornament (including its background) will break through content in front: Text("A view with an ornament") .ornament(attachmentAnchor: .scene(.bottom)) { OrnamentContent() .glassBackgroundEffect() .breakthroughEffect(.prominent) } ### RealityView Attachments Similarly, a `RealityView` `Attachment` can break through other entities in the RealityView, including the entity it is attached to: Attachment(id: "example") { AttachmentContent() .breakthroughEffect(.subtle) } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/buttonsizing(_:) #app-main) - SwiftUI - View - buttonSizing(\_:) Beta Instance Method # buttonSizing(\_:) nonisolated Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/certificatesheet(trust:title:message:help:) #app-main) - SwiftUI - View - certificateSheet(trust:title:message:help:) Instance Method # certificateSheet(trust:title:message:help:) Displays a certificate sheet using the provided certificate trust. @MainActor @preconcurrency func certificateSheet( title: String? = nil, message: String? = nil, help: URL? = nil ## Parameters `trust` `title` The title to display. Uses a default title if nil. `message` The message to display. Uses a default message if nil. `help` URL for the “Learn More” button. Uses a default URL if nil. --- # https://developer.apple.com/documentation/swiftui/view/chart3dcameraprojection(_:) --- # https://developer.apple.com/documentation/swiftui/view/chart3dpose(_:) --- # https://developer.apple.com/documentation/swiftui/view/chart3drenderingstyle(_:) #app-main) - SwiftUI - View - chart3DRenderingStyle(\_:) Beta Instance Method # chart3DRenderingStyle(\_:) @MainActor @preconcurrency Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/chartzaxis(_:) --- # https://developer.apple.com/documentation/swiftui/view/chartzaxis(content:) #app-main) - SwiftUI - View - chartZAxis(content:) Beta Instance Method # chartZAxis(content:) Configures the z-axis for 3D charts in the view. nonisolated ## Parameters `content` The axis content. ## Discussion Use this modifier to customize the z-axis of a chart. Provide an `AxisMarks` builder that composes `AxisGridLine`, `AxisTick`, and `AxisValueLabel` structures to form the axis. Omit components from the builder to omit them from the resulting axis. For example, the following code adds grid lines to the z-axis: .chartZAxis { AxisMarks { AxisGridLine() } } Use arguments such as `position:` or `values:` to control the placement of the axis values it displays. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/chartzaxislabel(_:position:alignment:spacing:) --- # https://developer.apple.com/documentation/swiftui/view/chartzscale(domain:range:type:) --- # https://developer.apple.com/documentation/swiftui/view/chartzscale(domain:type:) #app-main) - SwiftUI - View - chartZScale(domain:type:) Beta Instance Method # chartZScale(domain:type:) nonisolated domain: Domain, type: ScaleType? = nil Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/chartzscale(range:type:) --- # https://developer.apple.com/documentation/swiftui/view/chartzselection(range:) #app-main) - SwiftUI - View - chartZSelection(range:) Beta Instance Method # chartZSelection(range:) nonisolated Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/chartzselection(value:) #app-main) - SwiftUI - View - chartZSelection(value:) Beta Instance Method # chartZSelection(value:) nonisolated Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/contactaccessbuttoncaption(_:) #app-main) - SwiftUI - View - contactAccessButtonCaption(\_:) Instance Method # contactAccessButtonCaption(\_:) @MainActor @preconcurrency ## See Also ### Managing contact access Modally present UI which allows the user to select which contacts your app has access to. --- # https://developer.apple.com/documentation/swiftui/view/contactaccessbuttonstyle(_:) --- # https://developer.apple.com/documentation/swiftui/view/containervalue(_:_:) --- # https://developer.apple.com/documentation/swiftui/view/contentcaptureprotected(_:) --- # https://developer.apple.com/documentation/swiftui/view/contenttoolbar(for:content:) #app-main) - SwiftUI - View - contentToolbar(for:content:) Instance Method # contentToolbar(for:content:) Populates the toolbar of the specified content view type with the views you provide. nonisolated for placement: ContentToolbarPlacement, Show all declarations ## Parameters `content` The views representing the content of the toolbar. ## Discussion Use this modifier to add toolbar content that remains consistent regardless of the content view. Use a `toolbar` modifier within the content view if the toolbar content is dependent the content view is showing. Unlike the toolbar modifier, which configures the toolbar of the modified view’s container, the `contentToolbar` modifier configures the toolbar within the modified view’s content instead. This means that the `contentToolbar` modifier should generally be applied directly to a container view, instead of to the content within a container view. For example, to configure the toolbar of tab view’s sidebar, apply the `contentToolbar` modifier to the `TabView` itself, not to any of the tabs within the `TabView`. The content toolbar modifier expects a collection of toolbar items that you can provide by either supplying a collection of views with each view wrapped in a `ToolbarItem`, or by providing a collection of views as a `ToolbarItemGroup`. The example below adds an account summary to the bottom of the tab view sidebar and a button to the tab view sidebar overflow menu. TabView { Tab("Home", systemImage: "house") { HomeView() } Tab("Alerts", systemImage: "bell") { AlertsView() } TabSection("Categories") { Tab("Climate", systemImage: "fan") { ClimateView() } Tab("Lights", systemImage: "lightbulb") { LightsView() } } } .tabViewStyle(.sidebarAdaptable) .contentToolbar(for: .tabViewSidebar) { ToolbarItem(placement: .automatic) { DisconnectDevicesButton() } ToolbarItem(placement: .bottomBar) { AccountSummaryView() } } --- # https://developer.apple.com/documentation/swiftui/view/continuitydevicepicker(ispresented:ondidconnect:) --- # https://developer.apple.com/documentation/swiftui/view/controlwidgetactionhint(_:) #app-main) - SwiftUI - View - controlWidgetActionHint(\_:) Instance Method # controlWidgetActionHint(\_:) The action hint of the control described by the modified label. @MainActor @preconcurrency Show all declarations ## Parameters `hint` The localized string resource to display. ## Discussion This text will appear next to the Action Button to describe what your control will do when activated. By default, a control’s action hint is derived from its display name, the type of control, and value text, if any: // Action Hint: “Hold for ‘Ping My Watch’” struct PingMyWatchButton: Control { static let displayName: LocalizedStringResource = “Ping My Watch” … } // When this button’s action conforms to `OpenIntent`: // Action Hint: “Hold to Open Notes” struct NotesLauncher: Control { static let displayName: LocalizedStringResource = “Notes” … } // Action Hint: “Hold to Turn On ‘Silent Mode’” / “Hold to Turn Off ‘Silent Mode’” struct SilentModeToggle: Control { static let displayName: LocalizedStringResource = “Silent Mode” … } // Action Hint: “Hold for Silent” / “Hold for Ring” ControlWidgetToggle(…) { isOn in Label( isOn ? “Silent” : “Ring”, systemImage: isOn ? “bell.slash” : “bell” ) } When the default action hint is insufficiently descriptive, you can customize the hint by applying this modifier to the control’s label. For instance, we can describe what the user will use our `NotesLauncher` control to do, “Compose a Note”, instead of the default “Hold to Open Notes” hint, like this: ControlWidgetButton(…) { Image(systemName: “note.text”) .controlWidgetActionHint(“Compose a Note”) } ## See Also ### Composing control widgets `protocol ControlWidget` The configuration and content of a control widget to display in system spaces such as Control Center, the Lock Screen, and the Action Button. `protocol ControlWidgetConfiguration` A type that describes a control widget’s content. `struct EmptyControlWidgetConfiguration` An empty control widget configuration. `struct ControlWidgetConfigurationBuilder` A custom attribute that constructs a control widget’s body. `protocol ControlWidgetTemplate` `struct EmptyControlWidgetTemplate` An empty control widget template. `struct ControlWidgetTemplateBuilder` A custom attribute that constructs a control widget template’s body. `func controlWidgetStatus(_:)` The status of the control described by the modified label. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/controlwidgetstatus(_:) #app-main) - SwiftUI - View - controlWidgetStatus(\_:) Instance Method # controlWidgetStatus(\_:) The status of the control described by the modified label. @MainActor @preconcurrency Show all declarations ## Parameters `status` The localized string resource to display. ## Discussion This text will appear in Control Center when your control’s state changes. You can customize the text by applying this modifier to the control’s value label: // Status Text: "Do Not Disturb Until This Evening" / "Do Not Disturb Disabled" ControlWidgetToggle("Do Not Disturb", ...) { isOn in Image(systemName: "moon") .controlWidgetStatus(isOn ? "Do Not Disturb Until This Evening" : "Do Not Disturb Disabled") } ## See Also ### Composing control widgets `protocol ControlWidget` The configuration and content of a control widget to display in system spaces such as Control Center, the Lock Screen, and the Action Button. `protocol ControlWidgetConfiguration` A type that describes a control widget’s content. `struct EmptyControlWidgetConfiguration` An empty control widget configuration. `struct ControlWidgetConfigurationBuilder` A custom attribute that constructs a control widget’s body. `protocol ControlWidgetTemplate` `struct EmptyControlWidgetTemplate` An empty control widget template. `struct ControlWidgetTemplateBuilder` A custom attribute that constructs a control widget template’s body. `func controlWidgetActionHint(_:)` The action hint of the control described by the modified label. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/currententitlementtask(for:priority:action:) #app-main) - SwiftUI - View - currentEntitlementTask(for:priority:action:) Instance Method # currentEntitlementTask(for:priority:action:) Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. StoreKitSwiftUI nonisolated func currentEntitlementTask( for productID: String, priority: TaskPriority = .medium, ## Parameters `productID` The product ID to get the entitlement for. The task restarts whenever this parameter changes. `priority` The task priority to use when creating the task. `action` The action to perform when the task’s state changes. ## Discussion Before a view modified with this method appears, a task will start in the background to get the current entitlement. While the view is presented, the task will call `action` whenever the entitlement changes or the task’s state changes. Consumable in-app purchases will always pass `nil` to `action`. For auto-renewable subscriptions, use `subscriptionStatusTask(for:priority:action:)` to get the full status information for the subscription. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. Declares the view as dependent on a collection of In-App Purchase products and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/dialogpreventsapptermination(_:) --- # https://developer.apple.com/documentation/swiftui/view/dragconfiguration(_:) --- # https://developer.apple.com/documentation/swiftui/view/dragcontainer(for:id:in:_:) #app-main) - SwiftUI - View - dragContainer(for:id:in:\_:) Beta Instance Method # dragContainer(for:id:in:\_:) A container with draggable views. The drag payload is based on the current selection. nonisolated for itemType: Item.Type = Item.self, in namespace: Namespace.ID? = nil, ## Parameters `itemType` A type of the dragged item. `id` A closure that provides the item’s identifier. `namespace` An optional namespace that identifies the drag container. `payload` A closure which is called when a drag operation begins. As an argument, the closure receives the identifier of the dragged view under the finger or cursor. Using the passed identifier, put together the payload to drag, and return from the closure. Return an empty `Collection` to disable the drag. ## Return Value A view that can be activated as the source of a drag and drop operation, beginning with user gesture input. ## Discussion Below is an example of a container view with three sections. Each section is draggable. Also, each section is selectable, and each view in a section is selectable as well. When a section drag starts, the app wants to use its custom logic to decide what the payload should be. If an unselected section is dragged, it should be the only one on the drag payload. If a selected section is dragged, the payload should contain other selected sections, and also the sections that have at least one fruit selected. var berries: [Fruit] var citruses: [Fruit] var tropical: [Fruit] @State var selectedSections: [UUID] @State var selectedFruits: [UUID] var body: some View { ScrollView { VStack { BerriesSectionView(FruitSection(berries)) .draggable(containerItemID: FruitSection.berries) CitrusSectionView(FruitSection(citruses)) .draggable(containerItemID: FruitSection.citruses) TropicalSectionView(FruitSection(tropical)) .draggable(containerItemID: FruitSection.tropical) } } .dragContainer { draggedSectionID in let identifiers = sectionIDsToDrag(for: draggedSectionID) return sections(identifiers: identifiers) } } // an unselected section is dragged if !selectedSections.contains(draggedID) { return [draggedID] } // a selected section is dragged let payloadIDs = selectedSections + sectionIdentifiersOfSelectedFruits() return uniqueSections(from: payloadIDs) } struct Fruit { let id: UUID } struct FruitSection: Transferable { static let berries: UUID static let citruses: UUID static let tropical: UUID let id: UUID var fruits: [Fruit] } struct BerriesSectionView: View { var section: FruitSection var body: some View { HStack { ForEach(section.fruit) { berry in BerryView(berry) } } } } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/dragcontainer(for:id:in:selection:_:) #app-main) - SwiftUI - View - dragContainer(for:id:in:selection:\_:) Beta Instance Method # dragContainer(for:id:in:selection:\_:) A container with single item selection and draggable views. The drag payload is based on the current selection and provided identifiers. nonisolated for itemType: Item.Type = Item.self, in namespace: Namespace.ID? = nil, Show all declarations ## Parameters `itemType` A type of the dragged item. `id` A closure that returns the identifier of a given dragged item. `namespace` An optional namespace that identifies the drag container. `selection` A closure returning the item that is currently selected. Return `nil` to indicate that the selection is empty. `payload` A closure that returns the item with a given identifier. Return `nil` to disable drag. ## Return Value A view that can be activated as the source of a drag and drop operation, beginning with user gesture input. ## Discussion In an example below, an app presents a view with `Fruit` values. `Fruit` uses the name as its identifier. @State private var fruits: [Fruit] @State private var selection: Fruit.ID? var body: some View { VStack { ForEach(fruits) { fruit in FruitView(fruit) .draggable(containerItemID: fruit.name) } } .dragContainer(selection: selection, id: \.name) { draggedID in fruit(id: id) } } struct Fruit: Transferable { var name: String ... } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/dragcontainer(for:in:_:) --- # https://developer.apple.com/documentation/swiftui/view/dragcontainer(for:in:selection:_:) #app-main) - SwiftUI - View - dragContainer(for:in:selection:\_:) Beta Instance Method # dragContainer(for:in:selection:\_:) A container with multiple selection and draggable views. The drag payload is identifiable and is based on the current selection. nonisolated for itemType: Item.Type = Item.self, in namespace: Namespace.ID? = nil, Show all declarations ## Parameters `itemType` A type of the dragged items. `namespace` An optional namespace that identifies the drag container. `selection` Identifiers of the currently selected items. `payload` A closure which is called when a drag operation begins. As an argument, the closure receives either the identifiers of all the selected items, if the dragged item is a part of selection, or only the identifier of the dragged item, if it is not part of the selection. With the passed identifiers, put together the payload to drag, and return from the closure. The number of returned items can be different from the number of dragged identifiers. Only the views that correspond to returned item identifiers will be dragged. Return an empty `Collection` to disable the drag. ## Return Value A view that can be activated as the source of a drag and drop operation, beginning with user gesture input. ## Discussion In an example below, an app presents a view with `Fruit` values. When a user starts drag, SwiftUI uses the selection to put together the list of item identifiers to drag. var fruits: [Fruit] @State var selection: [Fruit.ID] var body: some View { VStack { ForEach(fruits) { fruit in FruitView(fruit) .draggable(containerItemID: fruit.id) } } .dragContainer(selection: selection) { ids in fruits(ids: ids) } } /// Returns the Fruit values with given identifiers. struct Fruit: Transferable, Identifiable { ... } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/dragpreviewsformation(_:) #app-main) - SwiftUI - View - dragPreviewsFormation(\_:) Beta Instance Method # dragPreviewsFormation(\_:) Describes the way dragged previews are visually composed. nonisolated Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/draggable(_:_:) --- # https://developer.apple.com/documentation/swiftui/view/draggable(containeritemid:) --- # https://developer.apple.com/documentation/swiftui/view/draggable(for:id:_:) --- # https://developer.apple.com/documentation/swiftui/view/dropconfiguration(_:) --- # https://developer.apple.com/documentation/swiftui/view/droppreviewsformation(_:) --- # https://developer.apple.com/documentation/swiftui/view/formstyle(_:) --- # https://developer.apple.com/documentation/swiftui/view/gamesynceddirectoryloadingview(directory:finishedloading:) --- # https://developer.apple.com/documentation/swiftui/view/glassbackgroundeffect(_:displaymode:) --- # https://developer.apple.com/documentation/swiftui/view/glassbackgroundeffect(_:in:displaymode:) --- # https://developer.apple.com/documentation/swiftui/view/glasseffecttransition(_:isenabled:) --- # https://developer.apple.com/documentation/swiftui/view/glasseffectunion(id:namespace:) --- # https://developer.apple.com/documentation/swiftui/view/groupactivityassociation(_:) #app-main) - SwiftUI - View - groupActivityAssociation(\_:) Beta Instance Method # groupActivityAssociation(\_:) Specifies how a view should be associated with the current SharePlay group activity. GroupActivitiesSwiftUI nonisolated ## Parameters `kind` If given, the kind of group activity association. You can dynamically remove the group activity's association with a view by setting the given `kind` to `nil` instead of `.primary(_:)`. ## Discussion When a group of people join a SharePlay activity with their spatial Personas, the system selects a common, primary scene to arrange their spatial Personas around. This association between the group activity and a primary scene in your app creates a shared space for the spatial Personas to interact in; enabling participants to gesture at the associated scene and understand each other. For more information about spatial Personas and SharePlay on visionOS, see doc:adding-spatial-persona-support-to-an-activity. By default, the system uses your scene’s activation conditions in concert with your activity’s `SceneAssociationBehavior` to select a scene to associate with the activity. You can specify a different scene or dynamically change the associated scene by using this modifier to set a view’s group activity association to `GroupActivityAssociationKind/primary`. struct MyApp: App { var body: some Scene { ... Window("Game Window") { GameView() .groupActivityAssociation(.primary("game-window")) } } } If there are multiple scenes that are simultaneously configured with the primary group activity association, the most recently associated scene will be used. For example, if your app defines two windows and both contain views with the primary association kind, the most recently opened one will be used as the primary scene. If that second window is subsequently closed, the original window will be used again. You can dynamically remove the group activity’s association with a view by setting the given kind to `nil` instead of `.primary`. @State var activityState: ActivityState var body: some Scene { WindowGroup { TeamSelectionView() .groupActivityAssociation(activityState == .teamSelection ? .primary("team-selection") : nil) } WindowGroup { CardGameVolume() .groupActivityAssociation(activityState == .inGame ? .primary("in-game") : nil) } .windowStyle(.volumetric) } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/handgestureshortcut(_:isenabled:) #app-main) - SwiftUI - View - handGestureShortcut(\_:isEnabled:) Instance Method # handGestureShortcut(\_:isEnabled:) Assigns a hand gesture shortcut to the modified control. nonisolated func handGestureShortcut( _ shortcut: HandGestureShortcut, isEnabled: Bool = true ## Parameters `shortcut` The shortcut to associate with this control. `isEnabled` A Boolean value that indicates whether the shortcut is is enabled for this control. ## Discussion Performing the control’s shortcut while the control is anywhere in the frontmost scene is equivalent to direct interaction with the control to perform its primary action. The following example lets users of a watchOS music app toggle playback by double-tapping their thumb and index finger together: struct PlaybackControls: View { let model: TrackModel var body: some View { HStack { Button("Skip Back") { model.skipBack() } Button("Play/Pause") { model.playPause() } .handGestureShortcut(.primaryAction) Button("Skip Forward") { model.skipForward() } } } } The target of a hand gesture shortcut is resolved in a leading-to-trailing traversal of the active scene. ## See Also ### Defining custom gestures Attaches a gesture to the view with a higher precedence than gestures defined by the view. Sets the screen edge from which you want your gesture to take precedence over the system gesture. `protocol Gesture` An instance that matches a sequence of events to a gesture, and returns a stream of values for each of its states. `struct AnyGesture` A type-erased gesture. `struct HandActivationBehavior` An activation behavior specific to hand-driven input. `struct HandGestureShortcut` Hand gesture shortcuts describe finger and wrist movements that the user can perform in order to activate a button or toggle. --- # https://developer.apple.com/documentation/swiftui/view/handpointerbehavior(_:) #app-main) - SwiftUI - View - handPointerBehavior(\_:) Instance Method # handPointerBehavior(\_:) Sets the behavior of the hand pointer while the user is interacting with the view. nonisolated ## Parameters `behavior` The behavior to apply to the hand pointer. If `nil`, the hand pointer behavior will be inherited from the view’s ancestors. ## Return Value A view that applies the given behavior to the hand pointer. ## See Also ### Changing view appearance for hover events Applies a hover effect to this view. `struct HoverEffect` An effect applied when the pointer hovers over a view. Applies a hover effect to this view, optionally adding it to a `HoverEffectGroup`. Applies a hover effect to this view described by the given closure. `protocol CustomHoverEffect` A type that represents how a view should change when a pointer hovers over a view, or when someone looks at the view. `struct ContentHoverEffect` A `CustomHoverEffect` that applies effects to a view on hover using a closure. Beta `struct HoverEffectGroup` Describes a grouping of effects that activate together. Adds an implicit `HoverEffectGroup` to all effects defined on descendant views, so that all effects added to subviews activate as a group whenever this view or any descendant views are hovered. Adds a `HoverEffectGroup` to all effects defined on descendant views, and activates the group whenever this view or any descendant views are hovered. `struct GroupHoverEffect` A `CustomHoverEffect` that activates a named group of effects. `protocol HoverEffectContent` A type that describes the effects of a view for a particular hover effect phase. `struct EmptyHoverEffectContent` An empty base effect that you use to build other effects. `struct HandPointerBehavior` A behavior that can be applied to the hand pointer while the user is interacting with a view. --- # https://developer.apple.com/documentation/swiftui/view/handlesgamecontrollerevents(matching:) #app-main) - SwiftUI - View - handlesGameControllerEvents(matching:) Instance Method # handlesGameControllerEvents(matching:) Specifies the game controllers events which should be delivered through the GameController framework when the view, or one of its descendants has focus. GameControllerSwiftUI nonisolated ## Discussion SpriteView(scene: MyGameScene()) .handlesGameControllerEvents(matching: .gamepad) .focused(true) --- # https://developer.apple.com/documentation/swiftui/view/handlesgamecontrollerevents(matching:withoptions:) #app-main) - SwiftUI - View - handlesGameControllerEvents(matching:withOptions:) Beta Instance Method # handlesGameControllerEvents(matching:withOptions:) Specifies the game controllers events which should be delivered through the GameController framework when the view or one of its descendants has focus. GameControllerSwiftUI nonisolated func handlesGameControllerEvents( matching types: GCUIEventTypes, withOptions options: GameControllerEventHandlingOptions? ## Discussion SpriteView(scene: MyGameScene()) .handlesGameControllerEvents(matching: .gamepad, withOptions: .defaultOptions) .focused(true) Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/healthdataaccessrequest(store:objecttype:predicate:trigger:completion:) #app-main) - SwiftUI - View - healthDataAccessRequest(store:objectType:predicate:trigger:completion:) Instance Method # healthDataAccessRequest(store:objectType:predicate:trigger:completion:) Asynchronously requests permission to read a data type that requires per-object authorization (such as vision prescriptions). @preconcurrency nonisolated func healthDataAccessRequest( store: HKHealthStore, objectType: HKObjectType, predicate: NSPredicate? = nil, trigger: some Equatable, ## Parameters `store` The HealthKit store where you’re requesting authorization. `objectType` The data type you want to read. This type must be a type that requires per-object authorization. `predicate` An optional predicate that further restricts the objects of interest. `trigger` A value used to trigger the request. This value must be a `State` variable. Any change to the variable triggers a request. `completion` A block that the system calls after the request is complete. The system passes the result parameter. ## Discussion Some samples require per-object authorization. For these samples, people can select which ones your app can read on a sample-by-sample basis. By default, your app can read any of the per-object authorization samples that it has saved to the HealthKit store; however, you may not always have access to those samples. People can update the authorization status for any of these samples at any time. Your app can begin by setting up the request in SwiftUI. @State private var trigger = false let store = HKHealthStore() var body: some Scene { WindowGroup { ContentView(enabled: $authenticated) .healthDataAccessRequest(store: store, objectType: .visionPrescriptionType(), predicate: nil, trigger: trigger) { result in switch result { case .success(_): authenticated = true case .failure(let error): // Handle the error here. fatalError("*** An error occurred while requesting authentication: \(error) ***") } logger.debug("Authentication Complete.") } } } Next, query for any samples that it already has permission to read. // Read the newest prescription from the HealthKit store. let queryDescriptor = HKSampleQueryDescriptor(predicates: [.visionPrescription()], sortDescriptors: [SortDescriptor(\.startDate, order: .reverse)], limit: 1) let prescription: HKVisionPrescription do { guard let result = try await queryDescriptor.result(for: store).first else { print("*** No prescription found. ***") return } prescription = result } catch { // Handle the error here. fatalError("*** An error occurred while reading the most recent vision prescriptions: \(error.localizedDescription) ***") } Based on the results, you can then decide whether you need to request authorization for additional samples. Modify the trigger’s value to prompt someone to modify the samples your app has access to read. // Request authorization for additional samples. trigger.toggle() When your app calls this method, HealthKit displays an authorization sheet that asks for permission to read the samples that match the predicate and object type. The person using your app can then select individual samples to share with your app. The system always asks for permission, regardless of whether the user previously granted it. People can individually enable each of the prescriptions. After they respond, the system calls the callback handler on an arbitrary background queue. ## See Also ### Accessing health data Requests permission to read the specified HealthKit data types. Requests permission to save and read the specified HealthKit data types. Presents a preview of the workout contents as a modal sheet --- # https://developer.apple.com/documentation/swiftui/view/healthdataaccessrequest(store:readtypes:trigger:completion:) #app-main) - SwiftUI - View - healthDataAccessRequest(store:readTypes:trigger:completion:) Instance Method # healthDataAccessRequest(store:readTypes:trigger:completion:) Requests permission to read the specified HealthKit data types. @preconcurrency nonisolated func healthDataAccessRequest( store: HKHealthStore, trigger: some Equatable, ## Parameters `store` The HealthKit store where you’re requesting authorization. `readTypes` An optional set containing the data types you want to read. This set can contain any concrete subclass of the `HKObjectType` class (any of the `HKCharacteristicType`, `HKQuantityType`, `HKCategoryType`, `HKWorkoutType`, or `HKCorrelationType` classes ). If the user grants permission, your app can read these data types from the HealthKit store. `trigger` A value used to trigger the request. This value must be a `State` variable. Any change to the variable triggers a request. `completion` A block that the system calls after the request is complete. The system passes the result parameter. ## Discussion HealthKit performs this request asynchronously when you modify the trigger’s value. If you call this method with a new data type (a type of data that the user hasn’t previously granted or denied permission for in this app), the system automatically displays the authorization sheet when you modify the trigger’s value. The authorization sheet lists all the requested permissions. After the user finishes responding, HealthKit calls the completion block on a background queue. If the user has already chosen to grant or prohibit access to all of the types specified, HealthKit calls the completion when you modify the trigger without prompting the user. @State private var trigger = false var body: some Scene { WindowGroup { ContentView(enabled: $authenticated) .healthDataAccessRequest(store: store, readTypes: healthDataTypes, trigger: trigger) { result in switch result { case .success(_): authenticated = true case .failure(let error): // Handle the error here. fatalError("*** An error occurred while requesting authentication: \(error) ***") } logger.debug("Authentication Complete.") } .onAppear() { trigger.toggle() } } } import SwiftUI import HealthKit import HealthKitUI import os let healthDataTypes: Set = [\ HKQuantityType.workoutType(),\ HKQuantityType(.heartRate),\ HKQuantityType(.activeEnergyBurned),\ HKQuantityType(.basalEnergyBurned),\ HKQuantityType(.distanceWalkingRunning),\ HKQuantityType(.stepCount)\ ] private let logger = Logger(subsystem: "example.com.MyWorkoutApp", category: "iOS App") @main struct MyApp: App { @State private var authenticated = false @State private var trigger = false let store = HKHealthStore() logger.debug("Authentication Complete.") } .onAppear() { trigger.toggle() } } } } Customize the messages displayed on the permissions sheet by setting the following key: - `NSHealthShareUsageDescription` customizes the message for reading data. Set the key in the Target Properties list on the app’s Info tab. After users set the permissions for your app, they can always change them using either the Settings or the Health app. Your app appears in the Health app’s Sources tab, even if the user didn’t allow permission to read data. ## See Also ### Accessing health data Asynchronously requests permission to read a data type that requires per-object authorization (such as vision prescriptions). Requests permission to save and read the specified HealthKit data types. Presents a preview of the workout contents as a modal sheet --- # https://developer.apple.com/documentation/swiftui/view/healthdataaccessrequest(store:sharetypes:readtypes:trigger:completion:) #app-main) - SwiftUI - View - healthDataAccessRequest(store:shareTypes:readTypes:trigger:completion:) Instance Method # healthDataAccessRequest(store:shareTypes:readTypes:trigger:completion:) Requests permission to save and read the specified HealthKit data types. @preconcurrency nonisolated func healthDataAccessRequest( store: HKHealthStore, trigger: some Equatable, ## Parameters `store` The HealthKit store where you’re requesting authorization. `shareTypes` A set containing the data types you want to share. This set can contain any concrete subclass of the `HKSampleType` class (any of the `HKQuantityType`, `HKCategoryType`, `HKWorkoutType`, or `HKCorrelationType` classes). If the user grants permission, your app can create and save these data types to the HealthKit store. `readTypes` An optional set containing the data types you want to read. This set can contain any concrete subclass of the `HKObjectType` class (any of the `HKCharacteristicType`, `HKQuantityType`, `HKCategoryType`, `HKWorkoutType`, or `HKCorrelationType` classes ). If the user grants permission, your app can read these data types from the HealthKit store. `trigger` A value used to trigger the request. This value must be a `State` variable. Any change to the variable triggers a request. `completion` A block that the system calls after the request is complete. The system passes the result parameter. ## Discussion HealthKit performs these requests asynchronously when you modify the trigger’s value. If you call this method with a new data type (a type of data that the user hasn’t previously granted or denied permission for in this app), the system automatically displays the authorization sheet when you modify the trigger’s value. The authorization sheet lists all the requested permissions. After the user finishes responding, HealthKit calls the completion block on a background queue. If the user has already chosen to grant or prohibit access to all of the types specified, HealthKit calls the completion when you modify the trigger without prompting the user. Each data type has two separate permissions, one to read it and one to share it. You can make a single request, and include all the data types your app needs. @State private var trigger = false var body: some Scene { WindowGroup { ContentView(enabled: $authenticated) .healthDataAccessRequest(store: store, shareTypes: healthDataTypes, readTypes: healthDataTypes, trigger: trigger) { result in switch result { case .success(_): authenticated = true case .failure(let error): // Handle the error here. fatalError("*** An error occurred while requesting authentication: \(error) ***") } logger.debug("Authentication Complete.") } .onAppear() { trigger.toggle() } } } import SwiftUI import HealthKit import HealthKitUI import os let healthDataTypes: Set = [\ HKQuantityType.workoutType(),\ HKQuantityType(.heartRate),\ HKQuantityType(.activeEnergyBurned),\ HKQuantityType(.basalEnergyBurned),\ HKQuantityType(.distanceWalkingRunning),\ HKQuantityType(.stepCount)\ ] private let logger = Logger(subsystem: "example.com.MyWorkoutApp", category: "iOS App") @main struct MyApp: App { @State private var authenticated = false @State private var trigger = false let store = HKHealthStore() logger.debug("Authentication Complete.") } .onAppear() { trigger.toggle() } } } } Customize the messages displayed on the permissions sheet by setting the following keys: - `NSHealthShareUsageDescription` customizes the message for reading data. - `NSHealthUpdateUsageDescription` customizes the message for writing data. Set these keys in the Target Properties list on the app’s Info tab. After users set the permissions for your app, they can always change them using either the Settings or the Health app. Your app appears in the Health app’s Sources tab, even if the user didn’t allow permission to read or share data. ## See Also ### Accessing health data Asynchronously requests permission to read a data type that requires per-object authorization (such as vision prescriptions). Requests permission to read the specified HealthKit data types. Presents a preview of the workout contents as a modal sheet --- # https://developer.apple.com/documentation/swiftui/view/imageplaygroundpersonalizationpolicy(_:) #app-main) - SwiftUI - View - imagePlaygroundPersonalizationPolicy(\_:) Instance Method # imagePlaygroundPersonalizationPolicy(\_:) Policy determining whether to support the usage of people in the playground or not. nonisolated ## Parameters `policy` Policy determining whether personalization is enabled or not. ## Return Value An image playground sheet that does or does not support personalization, based on the `enabled` flag. ## Discussion Enabling people support will allow the user to condition image generation using: - A person from their system Photos library - A character represented by an appearance and a skin tone Personalization options are available through several user interfaces, including: - A people picker - Detection of people names in the prompt text field - Importing images containing people faces from the system photo library Enabled by default when the modifier is not set or when the policy is set to `automatic`. --- # https://developer.apple.com/documentation/swiftui/view/imageplaygroundsheet(ispresented:concept:sourceimage:oncompletion:oncancellation:) #app-main) - SwiftUI - View - imagePlaygroundSheet(isPresented:concept:sourceImage:onCompletion:onCancellation:) Instance Method # imagePlaygroundSheet(isPresented:concept:sourceImage:onCompletion:onCancellation:) Presents the system sheet to create images from the specified input. @MainActor @preconcurrency func imagePlaygroundSheet( concept: String, sourceImage: Image? = nil, ## Parameters `isPresented` A binding to a Boolean value that determines whether to display the sheet. `concept` An initial natural language string that describes the expected contents of the image. The person viewing the creation UI can edit the concepts from inside that UI. `concept: str` is equivalent to `concepts: [.text(str)]`. `sourceImage` Specify an existing image to use as source input for creating the new image. The person viewing the sheet can override the image you provide, and choose different images and concepts inside the creation UI. If you don’t provide a starting image, the system creates the new image using only the contents of the `concepts` parameter. `onCompletion` The block to receive the created image. The block has no return value and receives the following parameter: url A URL with the path to the image. The system saves the file at a temporary location inside your app container. Move the file to a new location if you intend to keep it after the dismissal of the sheet, or remove it if you don’t. `onCancellation` The block to handle the cancellation of the image-creation process, when the user chooses to exit the creation UI without choosing any image. After executing this block, the system automatically dismisses the sheet. ## Discussion Add this modifier to a view to display the system’s image-creation sheet. When the variable in the `isPresented` parameter is `true`, the view presents the sheet. Present the sheet in situations where someone might want to generate a new image for their content. When configuring the sheet, specify an optional starting image and text description to use to create the initial image. While visible, the sheet allows people to experiment with the contents of an image before returning it to your app. The person viewing the sheet can accept the image they created or cancel the operation. When they make their choice, the system executes the appropriate block. You can use this modifier only if the device supports creating new images. Check the `ImagePlayground/SwiftUICore/EnvironmentValues/supportsImagePlayground` environment variable to determine the availability of the feature. The following code creates a button to display the sheet only when the feature is available: @State private var showSheet = false @State private var createdImageURL: URL? = nil @Environment(\.supportsImagePlayground) private var supportsImagePlayground // .... if supportsImagePlayground { Button("Show Generation Sheet") { showSheet = true }.imagePlaygroundSheet( isPresented: $showSheet, concept: "Dog on a surfboard", sourceImage: sourceImage) { url in createdImageURL = url } } --- # https://developer.apple.com/documentation/swiftui/view/imageplaygroundsheet(ispresented:concept:sourceimageurl:oncompletion:oncancellation:) --- # https://developer.apple.com/documentation/swiftui/view/inapppurchaseoptions(_:) #app-main) - SwiftUI - View - inAppPurchaseOptions(\_:) Instance Method # inAppPurchaseOptions(\_:) Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. StoreKitSwiftUI nonisolated ## Parameters `options` The system calls this function before processing a purchase, with the product to be purchased is provided as a parameter. Return a set of purchase options to add to the purchase. ## Discussion In-app stores within this view will add any default purchase options to the set you return, and use the result for configuring the purchase. If you just want to react to in-app purchases beginning without adding purchase options, you can add an action with `onInAppPurchaseStart(perform:)`. You can remove any options ancestor views may have added by providing `nil` for the action. This will result in using the default set of purchase options. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. Declares the view as dependent on a collection of In-App Purchase products and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/journalingsuggestionspicker(ispresented:journalingsuggestiontoken:oncompletion:) --- # https://developer.apple.com/documentation/swiftui/view/journalingsuggestionspicker(ispresented:oncompletion:) #app-main) - SwiftUI - View - journalingSuggestionsPicker(isPresented:onCompletion:) Instance Method # journalingSuggestionsPicker(isPresented:onCompletion:) Presents a visual picker interface that contains events and images that a person can select to retrieve more information. @MainActor @preconcurrency func journalingSuggestionsPicker( ## Parameters `isPresented` A binding to a `Bool` value that determines whether to show the picker. `onCompletion` Code that you supply, which processes any suggestions that a person may choose in the picker. ## Discussion For more information about the Journaling Suggestions picker, see: doc:presenting-the-suggestions-picker-and-processing-a-selection. --- # https://developer.apple.com/documentation/swiftui/view/labelicontotitlespacing(_:) #app-main) - SwiftUI - View - labelIconToTitleSpacing(\_:) Beta Instance Method # labelIconToTitleSpacing(\_:) Set the spacing between the icon and title in labels. nonisolated ## Discussion Use this modifier to set the value that should be used for the icon-to-title spacing in labels. This applies to label styles and in contexts where the label displays its icon and title stacked horizontally. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/labelreservediconwidth(_:) #app-main) - SwiftUI - View - labelReservedIconWidth(\_:) Beta Instance Method # labelReservedIconWidth(\_:) Set the width reserved for icons in labels. nonisolated ## Discussion Use this modifier to set the value that should be used for the reserved icon width in labels. This applies to label styles and in contexts where the label displays its icon and title stacked horizontally. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/labeledcontentstyle(_:) #app-main) - SwiftUI - View - labeledContentStyle(\_:) Instance Method # labeledContentStyle(\_:) Sets a style for labeled content. nonisolated ## See Also ### Grouping inputs `struct Form` A container for grouping controls used for data entry, such as in settings or inspectors. Sets the style for forms in a view hierarchy. `struct LabeledContent` A container for attaching a label to a value-bearing view. --- # https://developer.apple.com/documentation/swiftui/view/labelsvisibility(_:) #app-main) - SwiftUI - View - labelsVisibility(\_:) Instance Method # labelsVisibility(\_:) Controls the visibility of labels of any controls contained within this view. nonisolated ## Discussion Use this modifier when you want to omit a label from one or more labeled content in your user interface. For example, the first `Toggle` in the following example hides its label: VStack { Toggle(isOn: $toggle1) { Text("Toggle 1") } .labelsVisibility(.hidden) Toggle(isOn: $toggle2) { Text("Toggle 2") } } The `VStack` in the example above centers the first toggle’s control element in the available space, while it centers the second toggle’s combined label and control element: Always provide a label for controls, even when you hide the label, because SwiftUI uses labels for other purposes, including accessibility. On iOS, a `Picker` within a `Menu` hides its label by default. You can use this modifier to explicitly show the label in that context: Menu { Picker("Flavor", selection: $selectedFlavor) { Text("Chocolate").tag(Flavor.chocolate) Text("Vanilla").tag(Flavor.vanilla) Text("Strawberry").tag(Flavor.strawberry) } .labelsVisibility(.visible) } ## See Also ### Hiding system elements Hides the labels of any controls contained within this view. `var labelsVisibility: Visibility` The labels visibility set by `labelsVisibility(_:)`. Sets the menu indicator visibility for controls within this view. Sets the visibility of the status bar. Sets the preferred visibility of the non-transient system views overlaying the app. `enum Visibility` The visibility of a UI element, chosen automatically based on the platform, current context, and other factors. --- # https://developer.apple.com/documentation/swiftui/view/lineheight(_:) #app-main) - SwiftUI - View - lineHeight(\_:) Beta Instance Method # lineHeight(\_:) A modifier for the default line height in the view hierarchy. nonisolated ## Discussion The default value is `nil`. In that case, SwiftUI automatically chooses an appropriate line height setting for each context. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/listrowinsets(_:_:) #app-main) - SwiftUI - View - listRowInsets(\_:\_:) Beta Instance Method # listRowInsets(\_:\_:) Sets the insets of rows in a list on the specified edges. nonisolated func listRowInsets( _ edges: Edge.Set = .all, _ length: CGFloat? ## Parameters `edges` The edges to set the insets to. `length` An amount, given in points, to set the insets to on the specified edges. ## Return Value A view in which the margins of list sections are set to the specified amount ## Discussion Use this modifier to change the default insets of list rows on the specified edges. In the example below, the `Flavor` enumeration provides content for list items. The SwiftUI `ForEach` structure computes views for each element of the `Flavor` enumeration and extracts the raw value of each of its elements using the resulting text to create each list row item. The `listRowInsets(_:_:)` modifier then changes the leading inset of each row of the list and leaves the default insets on the other edges untouched: struct ContentView: View { enum Flavor: String, CaseIterable, Identifiable { var id: String { self.rawValue } case vanilla, chocolate, strawberry } var body: some View { List { ForEach(Flavor.allCases) { Text($0.rawValue) .listRowInsets(.leading, 25) } } } } When applying multiple `listRowInsets` modifiers, modifiers with the same edges will override modifiers higher up in the view hierarchy. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/listsectionindexvisibility(_:) #app-main) - SwiftUI - View - listSectionIndexVisibility(\_:) Beta Instance Method # listSectionIndexVisibility(\_:) Changes the visibility of the list section index. nonisolated ## Parameters `visibility` The visibility of the list section index. ## Discussion The section index shows the section index labels of sections, which are set using the `sectionIndexLabel` modifier. These are typically the letters of the alphabet, used for sorted sections. List(sections) { section in Section(section.title) { ForEach(section.rows) { row in // ... } } .sectionIndexLabel(section.indexTitle) } .listSectionIndexVisibility(.visible) On iOS, the section index is displayed as a number of vertically stacked letters on the trailing side of the list. Users can jump to a specific section in the list by tapping on the corresponding index label. On watchOS, the index of the section currently visible is displayed next to the scroll indicator when the user is scrolling through the list using the crown. By default, the list section index is visible if the list contains any sections with an index label. The index only shows labels for sections with a `sectionIndexLabel` modifier. This can be used to hide certain sections from the index. By hiding section headers of empty sections with an index label, a list section index can be made to show index labels without a corresponding section. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/listsectionmargins(_:_:) #app-main) - SwiftUI - View - listSectionMargins(\_:\_:) Beta Instance Method # listSectionMargins(\_:\_:) Set the section margins for the specific edges. nonisolated func listSectionMargins( _ edges: Edge.Set = .all, _ length: CGFloat? ## Parameters `edges` The set of edges to pad for sections in this view. The default is `all`. `length` An amount, given in points, to pad section on the specified edges. ## Return Value A view in which the margins of list sections are set to the specified amount on the specified edges. ## Discussion Use this modifier on a list section to set customize its margins. Indicate the edges to set the margin of by naming either a single value from `Edge.Set`, or by specifying an `OptionSet` that contains edge values. Margins for the other edges remain unchanged. The default section margins are based on the list style, list section spacing and content margins of the list. Using this modifier overrides these default values completely. For sections that have headers or footers, the section margins are applied around these. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/lookaroundviewer(ispresented:initialscene:allowsnavigation:showsroadlabels:pointsofinterest:ondismiss:) #app-main) - SwiftUI - View - lookAroundViewer(isPresented:initialScene:allowsNavigation:showsRoadLabels:pointsOfInterest:onDismiss:) Instance Method # lookAroundViewer(isPresented:initialScene:allowsNavigation:showsRoadLabels:pointsOfInterest:onDismiss:) MapKitSwiftUI @MainActor @preconcurrency func lookAroundViewer( initialScene: MKLookAroundScene?, allowsNavigation: Bool = true, showsRoadLabels: Bool = true, pointsOfInterest: PointOfInterestCategories = .all, ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/lookaroundviewer(ispresented:scene:allowsnavigation:showsroadlabels:pointsofinterest:ondismiss:) #app-main) - SwiftUI - View - lookAroundViewer(isPresented:scene:allowsNavigation:showsRoadLabels:pointsOfInterest:onDismiss:) Instance Method # lookAroundViewer(isPresented:scene:allowsNavigation:showsRoadLabels:pointsOfInterest:onDismiss:) MapKitSwiftUI @MainActor @preconcurrency func lookAroundViewer( allowsNavigation: Bool = true, showsRoadLabels: Bool = true, pointsOfInterest: PointOfInterestCategories = .all, ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/managesubscriptionssheet(ispresented:subscriptiongroupid:) --- # https://developer.apple.com/documentation/swiftui/view/managedcontentstyle(_:) #app-main) - SwiftUI - View - managedContentStyle(\_:) Instance Method # managedContentStyle(\_:) Applies a managed content style to the view. ManagedAppDistributionSwiftUI @MainActor @preconcurrency ## Parameters `style` The style to apply to the view. ## Return Value The styled view. ## See Also ### Working with managed devices Presents a modal view that enables users to add devices to their organization. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/manipulable(coordinatespace:operations:inertia:isenabled:onchanged:) #app-main) - SwiftUI - View - manipulable(coordinateSpace:operations:inertia:isEnabled:onChanged:) Beta Instance Method # manipulable(coordinateSpace:operations:inertia:isEnabled:onChanged:) Allows this view to be manipulated using common hand gestures. nonisolated func manipulable( coordinateSpace: some CoordinateSpaceProtocol = .local, operations: Manipulable.Operation.Set = .all, inertia: Manipulable.Inertia = .medium, isEnabled: Bool = true, ## Parameters `coordinateSpace` The coordinate space of the manipulation gesture event locations. `operations` The set of allowed operations that can be applied when a person manipulates this view. `inertia` The inertia of this view that defines how much it resists being manipulated. `isEnabled` The Boolean value that indicates whether the manipulation gesture added by this view modifier is enabled or not. `onChanged` The action to perform with each new manipulation gesture event. ## Return Value A view that can be manipulated using common hand gestures. ## Discussion When a person ends the manipulation gesture, the view will --- # https://developer.apple.com/documentation/swiftui/view/manipulable(transform:coordinatespace:operations:inertia:isenabled:onchanged:) --- # https://developer.apple.com/documentation/swiftui/view/manipulable(using:) #app-main) - SwiftUI - View - manipulable(using:) Beta Instance Method # manipulable(using:) Allows the view to be manipulated using a manipulation gesture attached to a different view. nonisolated ## Parameters `gestureState` The manipulation gesture state that’s updated by a manipulation gesture added to a different view. ## Return Value A view that can be manipulated by a manipulation gesture attached to a different view. ## Discussion Use this view modifier alongside `manipulationGesture(updating:coordinateSpace:operations:inertia:isEnabled:onChanged:)` when you want to allow a person to manipulate a view by interacting with a different view. In the following example, a person can begin a manipulation gesture attached to a deck of cards which, in turn, manipulates a single card instead of the entire deck: struct CardDeck: View { @State private var manipulationState = Manipulable.GestureState() var body: some View { ZStack { Model3D(named: "CardDeck") .manipulationGesture(updating: $manipulationState) Model3D(named: "Card") .manipulable(using: manipulationState) .opacity(manipulationState.isActive ? 1 : 0) } } } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/manipulationgesture(updating:coordinatespace:operations:inertia:isenabled:onchanged:) --- # https://developer.apple.com/documentation/swiftui/view/mapcamerakeyframeanimator(trigger:keyframes:) #app-main) - SwiftUI - View - mapCameraKeyframeAnimator(trigger:keyframes:) Instance Method # mapCameraKeyframeAnimator(trigger:keyframes:) Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. MapKitSwiftUI @MainActor @preconcurrency func mapCameraKeyframeAnimator( trigger: some Equatable, ## Parameters `trigger` A value to observe for changes. `keyframes` A keyframes builder closure that is called when starting a new keyframe animation. The current map camera is provided as the only parameter. ## Discussion When the trigger value changes, the map calls the `keyframes` closure to generate the keyframes that will animate the camera. The animation will continue for the duration of the keyframes that you specify. If the user performs a gesture while the animation is in progress, the animation will be immediately removed, allowing the interaction to take control of the camera. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/mapcontrolvisibility(_:) #app-main) - SwiftUI - View - mapControlVisibility(\_:) Instance Method # mapControlVisibility(\_:) Configures all Map controls in the environment to have the specified visibility MapKitSwiftUI @MainActor @preconcurrency ## Parameters `visibility` How modified map controls should show or hide ## Discussion MapCompass, MapScaleView, and MapPitchToggle may automatically show and hide based on the current state of the Map. That may not be appropriate for all use cases, where always showing a control may be desirable. HStack { MapCompass() MapScaleView() MapPitchToggle() } .mapControls(.visible) Other controls don’t have an automatic visibility behavior, so they will always be visible when automatic is specified. Controls may also be hidden via this modifier when conditionalizing the view is not appropriate MapUserLocationButton() .mapControls(.automatic) MapZoomStepper() .mapControls(.hidden) ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/mapcontrols(_:) #app-main) - SwiftUI - View - mapControls(\_:) Instance Method # mapControls(\_:) Configures all `Map` views in the associated environment to have standard size and position controls MapKitSwiftUI @MainActor @preconcurrency ## Parameters `content` A view builder returning the controls you wish your `Map` ## Discussion You provide the controls you want to appear atop your map. When using a control in conjunction with `.mapControls` you don’t need to specify a scope. Views that are not MapKit controls will be ignored. Map() .mapControls { MapScaleView() MapUserLocationButton() } Controls can be modified individually or all at once. Custom frames and alignments set on controls are ignored. Map() .mapControls { MapCompass() .mapControls(.visible) MapPitchToggle() .buttonBorderShape(.circular) .tint(.purple) } .controlSize(.large) On watchOS, space is at a premium. When using the mapControls modifier, MapUserLocationButton and MapCompass are automatically combined if present. Map() .mapControls { MapUserLocationButton() MapCompass() } ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/mapfeatureselectionaccessory(_:) #app-main) - SwiftUI - View - mapFeatureSelectionAccessory(\_:) Instance Method # mapFeatureSelectionAccessory(\_:) Specifies the selection accessory to display for a `MapFeature` MapKitSwiftUI @MainActor @preconcurrency ## Parameters `style` The map item detail selection accessory style. If `nil`, no selection accessory will be displayed. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/mapfeatureselectioncontent(content:) #app-main) - SwiftUI - View - mapFeatureSelectionContent(content:) Instance Method # mapFeatureSelectionContent(content:) Specifies a custom presentation for the currently selected feature. MapKitSwiftUI @MainActor @preconcurrency ## Parameters `content` Generates the custom presentation for a given map feature. ## Discussion The supported presentation options are `Annotation`, and `Marker`. Other types of map content will be ignored and handled as though no content was returned. If empty map content is returned, the system presentation will be used. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/mapfeatureselectiondisabled(_:) #app-main) - SwiftUI - View - mapFeatureSelectionDisabled(\_:) Instance Method # mapFeatureSelectionDisabled(\_:) Specifies which map features should have selection disabled. MapKitSwiftUI @MainActor @preconcurrency ## Parameters `selectionDisabled` Determines if selection should be disabled for a given map feature. ## Discussion The `selectionDisabled` parameter takes a closure which maps map features, to booleans. If that closure returns true for a given map feature, that map feature will be considered unselectable. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/mapitemdetailpopover(ispresented:item:displaysmap:attachmentanchor:) --- # https://developer.apple.com/documentation/swiftui/view/mapitemdetailpopover(ispresented:item:displaysmap:attachmentanchor:arrowedge:) #app-main) - SwiftUI - View - mapItemDetailPopover(isPresented:item:displaysMap:attachmentAnchor:arrowEdge:) Instance Method # mapItemDetailPopover(isPresented:item:displaysMap:attachmentAnchor:arrowEdge:) Presents a map item detail popover. MapKitSwiftUI @MainActor @preconcurrency func mapItemDetailPopover( item: MKMapItem?, displaysMap: Bool = true, attachmentAnchor: PopoverAttachmentAnchor = .rect(.bounds), arrowEdge: Edge ## Parameters `isPresented` The binding to whether the detail sheet should be shown. `item` The map item to display. If nil, a “loading” view is displayed. `displaysMap` If an inline map should be displayed with the place data. A value of `true` must be specified if the application UI is not already showing the place in a map view. `attachmentAnchor` The positioning anchor that defines the attachment point of the popover. The default is `bounds`. `arrowEdge` The edge of the `attachmentAnchor` that defines the location of the popover’s arrow. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes --- # https://developer.apple.com/documentation/swiftui/view/mapitemdetailpopover(item:displaysmap:attachmentanchor:) #app-main) - SwiftUI - View - mapItemDetailPopover(item:displaysMap:attachmentAnchor:) Instance Method # mapItemDetailPopover(item:displaysMap:attachmentAnchor:) Presents a map item detail popover. MapKitSwiftUI @MainActor @preconcurrency func mapItemDetailPopover( displaysMap: Bool = true, attachmentAnchor: PopoverAttachmentAnchor = .rect(.bounds) ## Parameters `item` When `item` is non- `nil`, a detail popover is displayed for the map item. `displaysMap` If an inline map should be displayed with the place data. A value of `true` must be specified if the application UI is not already showing the place in a map view. `attachmentAnchor` The positioning anchor that defines the attachment point of the popover. The default is `bounds`. ## Discussion Use this modifier if you want the system to choose the best orientation of the popover’s arrow. If you want to specify a particular edge for the arrow, use `mapItemDetailPopover(item:displaysMap:attachmentAnchor:arrowEdge:)`. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes --- # https://developer.apple.com/documentation/swiftui/view/mapitemdetailpopover(item:displaysmap:attachmentanchor:arrowedge:) #app-main) - SwiftUI - View - mapItemDetailPopover(item:displaysMap:attachmentAnchor:arrowEdge:) Instance Method # mapItemDetailPopover(item:displaysMap:attachmentAnchor:arrowEdge:) Presents a map item detail popover. MapKitSwiftUI @MainActor @preconcurrency func mapItemDetailPopover( displaysMap: Bool = true, attachmentAnchor: PopoverAttachmentAnchor = .rect(.bounds), arrowEdge: Edge ## Parameters `item` When `item` is non- `nil`, a detail popover is displayed for the map item. `displaysMap` If an inline map should be displayed with the place data. A value of `true` must be specified if the application UI is not already showing the place in a map view. `attachmentAnchor` The positioning anchor that defines the attachment point of the popover. The default is `bounds`. `arrowEdge` The edge of the `attachmentAnchor` that defines the location of the popover’s arrow. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes --- # https://developer.apple.com/documentation/swiftui/view/mapitemdetailsheet(ispresented:item:displaysmap:) #app-main) - SwiftUI - View - mapItemDetailSheet(isPresented:item:displaysMap:) Instance Method # mapItemDetailSheet(isPresented:item:displaysMap:) Presents a map item detail sheet. MapKitSwiftUI @MainActor @preconcurrency func mapItemDetailSheet( item: MKMapItem?, displaysMap: Bool = true ## Parameters `isPresented` The binding to whether the detail sheet should be shown. `item` The map item to display. If nil, a “loading” view is displayed. `displaysMap` If an inline map should be displayed with the place data. A value of `true` must be specified if the application UI is not already showing the place in a map view. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/mapitemdetailsheet(item:displaysmap:) #app-main) - SwiftUI - View - mapItemDetailSheet(item:displaysMap:) Instance Method # mapItemDetailSheet(item:displaysMap:) Presents a map item detail sheet. MapKitSwiftUI @MainActor @preconcurrency func mapItemDetailSheet( displaysMap: Bool = true ## Parameters `item` When `item` is non- `nil`, a detail sheet is displayed for the map item. `displaysMap` If an inline map should be displayed with the place data. A value of `true` must be specified if the application UI is not already showing the place in a map view. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/mapscope(_:) #app-main) - SwiftUI - View - mapScope(\_:) Instance Method # mapScope(\_:) Creates a mapScope that SwiftUI uses to connect map controls to an associated map. MapKitSwiftUI @MainActor @preconcurrency ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/mapstyle(_:) #app-main) - SwiftUI - View - mapStyle(\_:) Instance Method # mapStyle(\_:) Specifies the map style to be used. MapKitSwiftUI @MainActor @preconcurrency ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. `func onMapCameraChange(frequency:_:)` Performs an action when Map camera framing changes Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/matchedtransitionsource(id:in:) #app-main) - SwiftUI - View - matchedTransitionSource(id:in:) Instance Method # matchedTransitionSource(id:in:) Identifies this view as the source of a navigation transition, such as a zoom transition. nonisolated func matchedTransitionSource( id: some Hashable, in namespace: Namespace.ID ## Parameters `id` The identifier, often derived from the identifier of the data being displayed by the view. `namespace` The namespace in which defines the `id`. New namespaces are created by adding an `Namespace` variable to a `View` type and reading its value in the view’s body method. ## See Also ### Defining transitions `func transition(_:)` Associates a transition with the view. `protocol Transition` A description of view changes to apply when a view is added to and removed from the view hierarchy. `struct TransitionProperties` The properties a `Transition` can have. `enum TransitionPhase` An indication of which the current stage of a transition. `struct AsymmetricTransition` A composite `Transition` that uses a different transition for insertion versus removal. `struct AnyTransition` A type-erased transition. Modifies the view to use a given transition as its method of animating changes to the contents of its views. `var contentTransition: ContentTransition` The current method of animating the contents of views. `var contentTransitionAddsDrawingGroup: Bool` A Boolean value that controls whether views that render content transitions use GPU-accelerated rendering. `struct ContentTransition` A kind of transition that applies to the content within a single view, rather than to the insertion or removal of a view. `struct PlaceholderContentView` A placeholder used to construct an inline modifier, transition, or other helper type. Sets the navigation transition style for this view. `protocol NavigationTransition` A type that defines the transition to use when navigating to a view. `protocol MatchedTransitionSourceConfiguration` A configuration that defines the appearance of a matched transition source. --- # https://developer.apple.com/documentation/swiftui/view/matchedtransitionsource(id:in:configuration:) #app-main) - SwiftUI - View - matchedTransitionSource(id:in:configuration:) Instance Method # matchedTransitionSource(id:in:configuration:) Identifies this view as the source of a navigation transition, such as a zoom transition. nonisolated func matchedTransitionSource( id: some Hashable, in namespace: Namespace.ID, ## Parameters `id` The identifier, often derived from the identifier of the data being displayed by the view. `namespace` The namespace in which defines the `id`. New namespaces are created by adding an `Namespace` variable to a `View` type and reading its value in the view’s body method. `configuration` A closure that you can use to apply styling to the source. ## Discussion The appearance of the source can be configured using the `configuration` trailing closure. Any modifiers applied will be smoothly interpolated when a zoom transition originates from this matched transition source. MyView() .matchedTransitionSource(id: someID, in: someNamespace) { source in source .cornerRadius(8.0) } ## See Also ### Defining transitions `func transition(_:)` Associates a transition with the view. `protocol Transition` A description of view changes to apply when a view is added to and removed from the view hierarchy. `struct TransitionProperties` The properties a `Transition` can have. `enum TransitionPhase` An indication of which the current stage of a transition. `struct AsymmetricTransition` A composite `Transition` that uses a different transition for insertion versus removal. `struct AnyTransition` A type-erased transition. Modifies the view to use a given transition as its method of animating changes to the contents of its views. `var contentTransition: ContentTransition` The current method of animating the contents of views. `var contentTransitionAddsDrawingGroup: Bool` A Boolean value that controls whether views that render content transitions use GPU-accelerated rendering. `struct ContentTransition` A kind of transition that applies to the content within a single view, rather than to the insertion or removal of a view. `struct PlaceholderContentView` A placeholder used to construct an inline modifier, transition, or other helper type. Sets the navigation transition style for this view. `protocol NavigationTransition` A type that defines the transition to use when navigating to a view. `protocol MatchedTransitionSourceConfiguration` A configuration that defines the appearance of a matched transition source. --- # https://developer.apple.com/documentation/swiftui/view/materialactiveappearance(_:) #app-main) - SwiftUI - View - materialActiveAppearance(\_:) Instance Method # materialActiveAppearance(\_:) Sets an explicit active appearance for materials in this view. nonisolated ## See Also ### Transforming colors Brightens this view by the specified amount. Sets the contrast and separation between similar colors in this view. Inverts the colors in this view. Adds a color multiplication effect to this view. Adjusts the color saturation of this view. Adds a grayscale effect to this view. Applies a hue rotation effect to this view. Adds a luminance to alpha effect to this view. `var materialActiveAppearance: MaterialActiveAppearance` The behavior materials should use for their active state, defaulting to `automatic`. `struct MaterialActiveAppearance` The behavior for how materials appear active and inactive. --- # https://developer.apple.com/documentation/swiftui/view/multilinetextalignment(strategy:) #app-main) - SwiftUI - View - multilineTextAlignment(strategy:) Beta Instance Method # multilineTextAlignment(strategy:) A modifier for the default text alignment strategy in the view hierarchy. nonisolated ## Discussion To control the alignment explicitly at a view level, choose the `layoutBased` mode and set the `multilineTextAlignment` to the appropriate value. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/navigationlinkindicatorvisibility(_:) --- # https://developer.apple.com/documentation/swiftui/view/navigationtransition(_:) #app-main) - SwiftUI - View - navigationTransition(\_:) Instance Method # navigationTransition(\_:) Sets the navigation transition style for this view. nonisolated ## Discussion Add this modifier to a view that appears within a `NavigationStack` or a sheet, outside of any containers such as `VStack`. struct ContentView: View { @Namespace private var namespace var body: some View { NavigationStack { NavigationLink { DetailView() .navigationTransition(.zoom(sourceID: "world", in: namespace)) } label: { Image(systemName: "globe") .matchedTransitionSource(id: "world", in: namespace) } } } } ## See Also ### Defining transitions `func transition(_:)` Associates a transition with the view. `protocol Transition` A description of view changes to apply when a view is added to and removed from the view hierarchy. `struct TransitionProperties` The properties a `Transition` can have. `enum TransitionPhase` An indication of which the current stage of a transition. `struct AsymmetricTransition` A composite `Transition` that uses a different transition for insertion versus removal. `struct AnyTransition` A type-erased transition. Modifies the view to use a given transition as its method of animating changes to the contents of its views. `var contentTransition: ContentTransition` The current method of animating the contents of views. `var contentTransitionAddsDrawingGroup: Bool` A Boolean value that controls whether views that render content transitions use GPU-accelerated rendering. `struct ContentTransition` A kind of transition that applies to the content within a single view, rather than to the insertion or removal of a view. `struct PlaceholderContentView` A placeholder used to construct an inline modifier, transition, or other helper type. `protocol NavigationTransition` A type that defines the transition to use when navigating to a view. Identifies this view as the source of a navigation transition, such as a zoom transition. `protocol MatchedTransitionSourceConfiguration` A configuration that defines the appearance of a matched transition source. --- # https://developer.apple.com/documentation/swiftui/view/onappintentexecution(_:perform:) #app-main) - SwiftUI - View - onAppIntentExecution(\_:perform:) Instance Method # onAppIntentExecution(\_:perform:) Registers a handler to invoke in response to the specified app intent that your app receives. AppIntentsSwiftUI nonisolated _ intent: I.Type = I.self, ## Parameters `intent` The type of App Intent that the `action` closure handles. `action` A closure that SwiftUI calls when the specified app intent is being performed. The closure takes the app intent instance as an input parameter. ## Return Value A view that handles the specified app intent’s perform ## Discussion Use this view modifier to receive instances in a particular scene within your app. The scene that SwiftUI routes the incoming user activity to depends on the structure of your app, what scenes are active, and other configuration. For more information, see `handlesExternalEvents(matching:)`. If the app intent implements a perform() method, it will be called after the action closure. This can be useful if your app intent supports running in the background via the AppIntent.IntentModes API Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/onapplepaycouponcodechange(perform:) --- # https://developer.apple.com/documentation/swiftui/view/onapplepaypaymentmethodchange(perform:) #app-main) - SwiftUI - View - onApplePayPaymentMethodChange(perform:) Instance Method # onApplePayPaymentMethodChange(perform:) Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. PassKitSwiftUI nonisolated ## Return Value An update to the payment request method. ## See Also ### Accessing Apple Pay and Wallet A view that displays a button for identity verification. Sets the button’s style. Sets the style to be used by the button. (see `PKAddPassButtonStyle`). Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. Sets the action on the PayLaterView. See `PKPayLaterAction`. Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Sets the style to be used by the button. (see `PKIdentityButtonStyle`). Provides a task to perform before this view appears --- # https://developer.apple.com/documentation/swiftui/view/onapplepayshippingcontactchange(perform:) #app-main) - SwiftUI - View - onApplePayShippingContactChange(perform:) Instance Method # onApplePayShippingContactChange(perform:) Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. PassKitSwiftUI nonisolated ## Return Value An update to the payment request shipping methods. ## See Also ### Accessing Apple Pay and Wallet A view that displays a button for identity verification. Sets the button’s style. Sets the style to be used by the button. (see `PKAddPassButtonStyle`). Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. Sets the action on the PayLaterView. See `PKPayLaterAction`. Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Sets the style to be used by the button. (see `PKIdentityButtonStyle`). Provides a task to perform before this view appears --- # https://developer.apple.com/documentation/swiftui/view/onapplepayshippingmethodchange(perform:) #app-main) - SwiftUI - View - onApplePayShippingMethodChange(perform:) Instance Method # onApplePayShippingMethodChange(perform:) Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. PassKitSwiftUI nonisolated ## Return Value An update to the payment request shipping method. ## See Also ### Accessing Apple Pay and Wallet A view that displays a button for identity verification. Sets the button’s style. Sets the style to be used by the button. (see `PKAddPassButtonStyle`). Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. Sets the action on the PayLaterView. See `PKPayLaterAction`. Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Sets the style to be used by the button. (see `PKIdentityButtonStyle`). Provides a task to perform before this view appears --- # https://developer.apple.com/documentation/swiftui/view/oncameracaptureevent(isenabled:defaultsounddisabled:action:) --- # https://developer.apple.com/documentation/swiftui/view/oncameracaptureevent(isenabled:defaultsounddisabled:primaryaction:secondaryaction:) --- # https://developer.apple.com/documentation/swiftui/view/ondragsessionupdated(_:) --- # https://developer.apple.com/documentation/swiftui/view/ondropsessionupdated(_:) #app-main) - SwiftUI - View - onDropSessionUpdated(\_:) Beta Instance Method # onDropSessionUpdated(\_:) Specifies an action to perform on each update of an ongoing drop operation activated by `dropDestination(_:)` or other drop modifiers. nonisolated ## Discussion The `onUpdate` closure is called when the closest drop session in the child view hierarchy becomes active. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/ongeometrychange3d(for:of:action:) --- # https://developer.apple.com/documentation/swiftui/view/oninapppurchasecompletion(perform:) #app-main) - SwiftUI - View - onInAppPurchaseCompletion(perform:) Instance Method # onInAppPurchaseCompletion(perform:) Add an action to perform when a purchase initiated from a StoreKit view within this view completes. StoreKitSwiftUI nonisolated ## Parameters `action` The action to perform, with the product value and the purchase result provided as parameters. ## Discussion By default, transactions from successful in-app store view purchases will be emitted from `Transaction.updates`. If the purchase fails with an error, an alert will be displayed. You can revert a view ) modifier. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. Declares the view as dependent on a collection of In-App Purchase products and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/oninapppurchasestart(perform:) --- # https://developer.apple.com/documentation/swiftui/view/onmapcamerachange(frequency:_:) #app-main) - SwiftUI - View - onMapCameraChange(frequency:\_:) Instance Method # onMapCameraChange(frequency:\_:) Performs an action when Map camera framing changes MapKitSwiftUI @MainActor @preconcurrency func onMapCameraChange( frequency: MapCameraUpdateFrequency = .onEnd, Show all declarations ## Parameters `frequency` How frequently the action should be performed during a camera interaction. `action` A closure to run when the camera framing changes. ## See Also ### Getting location information `@MainActor @preconcurrency struct LocationButton` A SwiftUI button that grants one-time location authorization. A view that displays an embedded map interface. Specifies the map style to be used. Creates a mapScope that SwiftUI uses to connect map controls to an associated map. Specifies which map features should have selection disabled. Specifies the selection accessory to display for a `MapFeature` Specifies a custom presentation for the currently selected feature. Configures all `Map` views in the associated environment to have standard size and position controls Configures all Map controls in the environment to have the specified visibility Uses the given keyframes to animate the camera of a `Map` when the given trigger value changes. Presents a map item detail popover. --- # https://developer.apple.com/documentation/swiftui/view/onopenurl(prefersinapp:) #app-main) - SwiftUI - View - onOpenURL(prefersInApp:) Beta Instance Method # onOpenURL(prefersInApp:) Sets an `OpenURLAction` that prefers opening URL with an in-app browser. It’s equivalent to calling `.onOpenURL(_:)` @MainActor @preconcurrency ## Discussion .onOpenURL { _ in .systemAction(prefersInApp: prefersInApp) } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/onworldrecenter(action:) --- # https://developer.apple.com/documentation/swiftui/view/paylaterviewaction(_:) #app-main) - SwiftUI - View - payLaterViewAction(\_:) Instance Method # payLaterViewAction(\_:) Sets the action on the PayLaterView. See `PKPayLaterAction`. PassKitSwiftUI nonisolated ## See Also ### Accessing Apple Pay and Wallet A view that displays a button for identity verification. Sets the button’s style. Sets the style to be used by the button. (see `PKAddPassButtonStyle`). Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Sets the style to be used by the button. (see `PKIdentityButtonStyle`). Provides a task to perform before this view appears --- # https://developer.apple.com/documentation/swiftui/view/paylaterviewdisplaystyle(_:) #app-main) - SwiftUI - View - payLaterViewDisplayStyle(\_:) Instance Method # payLaterViewDisplayStyle(\_:) Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. PassKitSwiftUI nonisolated ## See Also ### Accessing Apple Pay and Wallet A view that displays a button for identity verification. Sets the button’s style. Sets the style to be used by the button. (see `PKAddPassButtonStyle`). Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. Sets the action on the PayLaterView. See `PKPayLaterAction`. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Sets the style to be used by the button. (see `PKIdentityButtonStyle`). Provides a task to perform before this view appears --- # https://developer.apple.com/documentation/swiftui/view/paywithapplepaybuttondisablecardart() #app-main) - SwiftUI - View - payWithApplePayButtonDisableCardArt() Beta Instance Method # payWithApplePayButtonDisableCardArt() Sets the features that should be allowed to show on the payment buttons. PassKitSwiftUI nonisolated Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/paywithapplepaybuttonstyle(_:) --- # https://developer.apple.com/documentation/swiftui/view/popovertip(_:arrowedge:action:) #app-main) - SwiftUI - View - popoverTip(\_:arrowEdge:action:) Instance Method # popoverTip(\_:arrowEdge:action:) Presents a popover tip on the modified view. @preconcurrency nonisolated func popoverTip( _ tip: (any Tip)?, arrowEdge: Edge? = nil, ## Parameters `tip` The tip to display. `arrowEdge` The edge of the attachmentAnchor that defines the location of the popover’s arrow. By default, the system will choose the best orientation of the popover’s arrow. `action` The action to perform when the user triggers a tip’s button. ### Discussion Use this modifier to present a tip as a popover on an existing view when the tip becomes eligible for display. import SwiftUI import TipKit // Define your tip's content. struct SampleTip: Tip { var title: Text { Text("Save as a Favorite") } var message: Text? { Text("Your favorite backyards always appear at the top of the list.") } var image: Image? { Image(systemName: "star") } } struct SampleView: View { // Create an instance of your tip. var tip = SampleTip() var body: some View { VStack { // Add `.popoverTip` to the view you want to modify. // Tips.configure(options:) must be called before your tip will be eligible for display. Image(systemName: "star") .popoverTip(tip) } } } ## See Also ### Providing tips Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. Sets the corner radius for an inline tip view. Sets the size for a tip’s image. Sets the given style for TipView within the view hierarchy. Sets the style for a tip’s image. --- # https://developer.apple.com/documentation/swiftui/view/posttophotossharedalbumsheet(ispresented:items:photolibrary:defaultalbumidentifier:completion:) #app-main) - SwiftUI - View - postToPhotosSharedAlbumSheet(isPresented:items:photoLibrary:defaultAlbumIdentifier:completion:) Beta Instance Method # postToPhotosSharedAlbumSheet(isPresented:items:photoLibrary:defaultAlbumIdentifier:completion:) Presents an “Add to Shared Album” sheet that allows the user to post the given items to a shared album. PhotosUISwiftUI @MainActor func postToPhotosSharedAlbumSheet( items: [PHPickerResult], photoLibrary: PHPhotoLibrary, defaultAlbumIdentifier: String? = nil, Show all declarations ## Discussion - isPresented: The binding to whether the sheet should be shown. - items: The items to be posted to the shared album. - photoLibrary: Library to choose from. - defaultAlbumIdentifier: Identifier for the shared album to be pre-selected. If none provided user can manually choose the shared album in UI. - completion: Called with the result on completion of the request. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/preferredwindowclippingmargins(_:_:) --- # https://developer.apple.com/documentation/swiftui/view/presentationbreakthrougheffect(_:) #app-main) - SwiftUI - View - presentationBreakthroughEffect(\_:) Beta Instance Method # presentationBreakthroughEffect(\_:) Changes the way the enclosing presentation breaks through content occluding it. nonisolated ## Parameters `effect` The type of effect to apply when a presentation element is occluded by other content. ## Discussion Use this modifier to disable or customize a breakthrough effect for the enclosing presentation. Breakthrough is an effect allowing elements to be visible to the user even when other app content (3D models, UI elements) is occluding it. The way the element appears depends on the chosen `BreakthroughEffect`. Most system presentations appear with a breakthrough effect by default. For these cases, the `presentationBreakthroughEffect` modifier allows customization of the type of effect. This is achieved by applying the modifier to the content of the presentation: Button("Show Details") { isShowingDetails = true } .popover(isPresented: $isShowingDetails) { DetailsView() .presentationBreakthroughEffect(.prominent) } Only popovers allow breakthrough to be disabled altogether. Passing a `.none` value for a sheet doesn’t have any effect. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/presentationpreventsapptermination(_:) #app-main) - SwiftUI - View - presentationPreventsAppTermination(\_:) Instance Method # presentationPreventsAppTermination(\_:) Whether a presentation prevents the app from being terminated/quit by the system or app termination menu item. nonisolated ## Discussion SwiftUI uses the buttons in a sheet’s toolbar to determine whether a particular sheet should block termination by default. If there is a singular toolbar item with the `confirmationAction` or the `cancellationAction` placement and no other toolbar items, the sheet will not prevent termination by default. Use this modifier to specify whether a sheet should prevent app termination. Pass `nil` to explicitly request the automatic behavior/for the inert version of this modifier. Non-nil values will override `nil`, and `true` takes precedence over `false`. Use this modifier within the `content` argument to `View/sheet` struct LaunchScreen: View { @State private var presentLogin = false var body: some View { HomeView() .sheet(isPresented: $presentLogin) { LoginView() // explicitly allow app termination because the // default behavior would resolve to `true`. .presentationPreventsAppTermination(false) .toolbar { ToolbarItem(placement: .cancellationAction) { Button("Cancel") { presentLogin = false } } ToolbarItem(placement: .confirmationAction) { Button("Login") { // Attempt login... presentLogin = false } } } } } } --- # https://developer.apple.com/documentation/swiftui/view/productdescription(_:) #app-main) - SwiftUI - View - productDescription(\_:) Instance Method # productDescription(\_:) Configure the visibility of labels displaying an in-app purchase product description within the view. StoreKitSwiftUI nonisolated ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. Declares the view as dependent on a collection of In-App Purchase products and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/producticonborder() --- # https://developer.apple.com/documentation/swiftui/view/productviewstyle(_:) #app-main) - SwiftUI - View - productViewStyle(\_:) Instance Method # productViewStyle(\_:) Sets the style for In-App Purchase product views within a view. StoreKitSwiftUI nonisolated ## Parameters `style` The style to apply to the in-app purchase product views within the view. ## Discussion This modifier styles any `ProductView` or `StoreView` instances within a view. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. Declares the view as dependent on a collection of In-App Purchase products and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/realityviewcameracontrols(_:) #app-main) - SwiftUI - View - realityViewCameraControls(\_:) Instance Method # realityViewCameraControls(\_:) Adds gestures that control the position and direction of a virtual camera. RealityKitSwiftUI @MainActor @preconcurrency ## Discussion You can use a drag gesture from a mouse, trackpad, or screen touches with iOS and iPadOS devices to `.tilt`, `.pan`, `.orbit`, or `.dolly` a virtual camera. ## See Also ### Configuring camera controls `var realityViewCameraControls: CameraControls` The camera controls for the reality view. --- # https://developer.apple.com/documentation/swiftui/view/realityviewlayoutbehavior(_:) --- # https://developer.apple.com/documentation/swiftui/view/rotation3dlayout(_:) #app-main) - SwiftUI - View - rotation3DLayout(\_:) Beta Instance Method # rotation3DLayout(\_:) Rotates a view with impacts to its frame in a containing layout nonisolated ## Parameters `rotation` A rotation to apply to the view and its frame. ## Discussion The following example will rotate the top plane by 45 degrees while adjusting its frame to account for this rotation. The VStack sizes to fit the rotated and standard models. VStack { Model3D(named: "plane") .rotation3DLayout(Rotation3D(angle: .degrees(45), axis: .z)) Model3D(named: "plane") } The layout system will use a bounding box that completely contains the rotated view, meaning this modifier can change the size of the view it is applied to. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/rotation3dlayout(_:axis:) #app-main) - SwiftUI - View - rotation3DLayout(\_:axis:) Beta Instance Method # rotation3DLayout(\_:axis:) Rotates a view with impacts to its frame in a containing layout nonisolated func rotation3DLayout( _ angle: Angle, axis: (x: CGFloat, y: CGFloat, z: CGFloat) Show all declarations ## Parameters `angle` The angle by which to rotate the view and its frame. `axis` The axis of rotation. ## Discussion The following example will rotate the top plane by 45 degrees while adjusting its frame to account for this rotation. The VStack sizes to fit the rotated and standard models. VStack { Model3D(named: "plane") .rotation3DLayout(.degrees(45), axis: (x: 0, y: 0, z: 1)) Model3D(named: "plane") } The layout system will use a bounding box that completely contains the rotated view, meaning this modifier can change the size of the view it is applied to. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/safeareabar(edge:alignment:spacing:content:) #app-main) - SwiftUI - View - safeAreaBar(edge:alignment:spacing:content:) Beta Instance Method # safeAreaBar(edge:alignment:spacing:content:) Renders the provided content appropriately to be displayed as a custom bar. nonisolated func safeAreaBar( edge: HorizontalEdge, alignment: VerticalAlignment = .center, spacing: CGFloat? = nil, Show all declarations ## Discussion Similar to a `View/safeAreaInset(edge:alignment:spacing:content)` modifier, the modified view will have its horizontal safe area inset by the height of the content. In addition to adjusting the safe area, the bar modifier configures the `content` to support views to automatically extend the edge effect of any scroll view’s the bar adjusts safe area of. ## See Also ### Configuring scroll edge effects Configures the scroll edge effect style for scroll views within this hierarchy. Beta Disables any scroll edge effects for scroll views within this hierarchy. `struct ScrollEdgeEffectStyle` A structure that defines the style of pocket a scroll view will have. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/scaledtofill3d() #app-main) - SwiftUI - View - scaledToFill3D() Beta Instance Method # scaledToFill3D() Scales this view to fill its parent. nonisolated ## Return Value A view that scales this view to fit its parent, maintaining this view’s aspect ratio. ## Discussion This view’s 3D aspect ratio is maintained as the view scales. This method is equivalent to calling `aspectRatio3D(nil, contentMode: .fill)`. Model3D(named: "Sphere") { resolved in resolved .resizable() .scaledToFill3D() } placeholder: { ProgressView() } .frame(width: 300, height: 100) .frame(depth: 300) .border(Color(white: 0.75)) Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/scaledtofit3d() #app-main) - SwiftUI - View - scaledToFit3D() Beta Instance Method # scaledToFit3D() Scales this view to fit its parent. nonisolated ## Return Value A view that scales this view to fit its parent, maintaining this view’s aspect ratio. ## Discussion This view’s 3D aspect ratio is maintained as the view scales. This method is equivalent to calling `aspectRatio3D(nil, contentMode: .fit)`. Model3D(named: "Plane") { resolved in resolved .resizable() .scaledToFit3D() } placeholder: { ProgressView() } .frame(width: 400, height: 400) .frame(depth: 200) .border(Color(white: 0.75)) Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/scrolledgeeffectdisabled(_:for:) #app-main) - SwiftUI - View - scrollEdgeEffectDisabled(\_:for:) Beta Instance Method # scrollEdgeEffectDisabled(\_:for:) Disables any scroll edge effects for scroll views within this hierarchy. nonisolated func scrollEdgeEffectDisabled( _ disabled: Bool = true, for edges: Edge.Set = .all ## Discussion By default, a scroll view will render an automatic edge effect style. You use this modifier to disable the rendering of any edge effects for scroll views within this hierarchy. ScrollView { LazyVStack { ForEach(data) { item in RowView(item) } } } .scrollEdgeEffectDisabled() ## See Also ### Configuring scroll edge effects Configures the scroll edge effect style for scroll views within this hierarchy. Beta `struct ScrollEdgeEffectStyle` A structure that defines the style of pocket a scroll view will have. `func safeAreaBar(edge:alignment:spacing:content:)` Renders the provided content appropriately to be displayed as a custom bar. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/scrolledgeeffectstyle(_:for:) #app-main) - SwiftUI - View - scrollEdgeEffectStyle(\_:for:) Beta Instance Method # scrollEdgeEffectStyle(\_:for:) Configures the scroll edge effect style for scroll views within this hierarchy. nonisolated func scrollEdgeEffectStyle( _ style: ScrollEdgeEffectStyle?, for edges: Edge.Set ## Discussion By default, a scroll view will render an automatic edge effect. You use this modifier to change rendered edge effect style. ScrollView { LazyVStack { ForEach(data) { item in RowView(item) } } } .scrollEdgeEffectStyle(.hard) ## See Also ### Configuring scroll edge effects Disables any scroll edge effects for scroll views within this hierarchy. Beta `struct ScrollEdgeEffectStyle` A structure that defines the style of pocket a scroll view will have. `func safeAreaBar(edge:alignment:spacing:content:)` Renders the provided content appropriately to be displayed as a custom bar. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/scrollinputbehavior(_:for:) #app-main) - SwiftUI - View - scrollInputBehavior(\_:for:) Instance Method # scrollInputBehavior(\_:for:) Enables or disables scrolling in scrollable views when using particular inputs. @MainActor @preconcurrency func scrollInputBehavior( _ behavior: ScrollInputBehavior, for input: ScrollInputKind ## Parameters `behavior` Whether scrolling should be enabled or disabled for this input. `input` The input for which to enable or disable scrolling. ## Discussion In contrast to `scrollDisabled(_:)`, this modifier will enable or disable scrolling only for particular inputs. The following, for instance, disables double-tap-to-scroll on watchOS while preserving the ability to scroll via touch and the Digital Crown: ScrollView(...) .scrollInputBehavior(.disabled, for: .handGestureShortcut) If `scrollDisabled(true)` has been applied to this view, scrolling will be disabled for all inputs and this modifier cannot be used to re-enable scrolling. ## See Also ### Managing scrolling for different inputs `struct ScrollInputKind` Inputs used to scroll views. `struct ScrollInputBehavior` A type that defines whether input should scroll a view. --- # https://developer.apple.com/documentation/swiftui/view/searchtoolbarbehavior(_:) #app-main) - SwiftUI - View - searchToolbarBehavior(\_:) Beta Instance Method # searchToolbarBehavior(\_:) Configures the behavior for search in the toolbar. nonisolated ## Discussion This modifier can be used to change the default behavior of a search field that appears in the toolbar. Place this modifier after the `searchable(text:isPresented:placement:prompt:)` modifier that renders search in the toolbar. On iPhone, the search field in the bottom toolbar can be configured to appear as a button-like control when inactive: @State private var searchText = "" NavigationStack { RecipeList() .searchable($searchText) .searchToolbarBehavior(.minimized) } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/sectionindexlabel(_:) #app-main) - SwiftUI - View - sectionIndexLabel(\_:) Beta Instance Method # sectionIndexLabel(\_:) Sets the label that is used in a section index to point to this section, typically only a single character long. nonisolated Show all declarations ## Parameters `label` The label to display in the section index, or `nil` to display no label for this section. ## Discussion - See also `listSectionIndexVisibility(_:)` Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/signinwithapplebuttonstyle(_:) --- # https://developer.apple.com/documentation/swiftui/view/spatialoverlay(alignment:content:) #app-main) - SwiftUI - View - spatialOverlay(alignment:content:) Beta Instance Method # spatialOverlay(alignment:content:) Adds secondary views within the 3D bounds of this view. nonisolated alignment: Alignment3D = .center, ## Parameters `alignment` The alignment with a default value of `center` that you use to position the secondary view. `content` The view builder which produces views to occupy the same 3D space as this view. Multiple views provided by content are organized into a `SpatialContainer`. ## Return Value A view that adds `content` within the view’s 3D bounds. ## Discussion Multiple views provided by `content` are stacked depthwise. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/spatialoverlaypreferencevalue(_:alignment:_:) #app-main) - SwiftUI - View - spatialOverlayPreferenceValue(\_:alignment:\_:) Beta Instance Method # spatialOverlayPreferenceValue(\_:alignment:\_:) Uses the specified preference value from the view to produce another view occupying the same 3D space of the first view. nonisolated _ key: K.Type, alignment: Alignment3D = .center, Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/storebutton(_:for:) #app-main) - SwiftUI - View - storeButton(\_:for:) Instance Method # storeButton(\_:for:) Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. StoreKitSwiftUI nonisolated func storeButton( _ visibility: Visibility, for buttonKinds: StoreButtonKind... ## Parameters `visibility` The preferred visibility of the buttons. `buttonKinds` The type of store button. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Declares the view as dependent on an In-App Purchase product and returns a modified view. Declares the view as dependent on a collection of In-App Purchase products and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/storeproducttask(for:priority:action:) #app-main) - SwiftUI - View - storeProductTask(for:priority:action:) Instance Method # storeProductTask(for:priority:action:) Declares the view as dependent on an In-App Purchase product and returns a modified view. StoreKitSwiftUI nonisolated func storeProductTask( for id: Product.ID, priority: TaskPriority = .medium, ## Parameters `id` The product ID to load from the App Store. The task restarts whenever this parameter changes. `priority` The task priority to use when creating the task. `action` The action to perform when the task’s state changes. ## Discussion Before a view modified with this method appears, a task will start in the background to load the product from the App Store. While the view is presented, the task will call `action` whenever the product changes or the task’s state changes. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on a collection of In-App Purchase products and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/storeproductstask(for:priority:action:) --- # https://developer.apple.com/documentation/swiftui/view/subscriptionintroductoryoffer(applyoffer:compactjws:) #app-main) - SwiftUI - View - subscriptionIntroductoryOffer(applyOffer:compactJWS:) Beta Instance Method # subscriptionIntroductoryOffer(applyOffer:compactJWS:) Selects the introductory offer eligibility preference to apply to a purchase a customer makes from a subscription store view. StoreKitSwiftUI nonisolated func subscriptionIntroductoryOffer( ## Parameters `applyOffer` The system calls this function before drawing the given subscription product on the subscription store view. Return if the introductory offer should be applied to a given product, if any, to have system-provided UI reflect the discounted terms under the selected offer. `compactJWS` The system calls this function before processing a purchase, with the product to be purchased provided as a parameter. Return a compact JWS signature you generate on your server that validates the selected offer eligibility preference. Errors thrown from this closure will be surfaced via the `onInAppPurchaseCompletion(perform:)` modifier. For information about generating the JWS signature, see Generating JWS to sign App Store requests. ## Discussion Subscription stores within this view uses the introductory subscription offers to configure the appearance of the subscription plans displayed, when you use a system-provided `SubscriptionStoreControlStyle` to style the in-app subscription store. Standard `ProductViewStyle` instances don’t show introductory or promotional offers in UI, instead use `SubscriptionStoreView`. Determine if the introductory offer should be displayed in the view and applied to the purchase using the `applyOffer`. If the signature passes validation, the system applies or removes the offer to the purchases according to the offer eligibility preference. If the signature fails validation, the purchase will fail with `Product.PurchaseError.invalidOfferSignature`. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/subscriptionofferviewbuttonvisibility(_:for:) #app-main) - SwiftUI - View - subscriptionOfferViewButtonVisibility(\_:for:) Beta Instance Method # subscriptionOfferViewButtonVisibility(\_:for:) StoreKitSwiftUI nonisolated func subscriptionOfferViewButtonVisibility( _ visibility: Visibility, for buttonKinds: SubscriptionOfferViewButtonKind... Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/subscriptionofferviewdetailaction(_:) #app-main) - SwiftUI - View - subscriptionOfferViewDetailAction(\_:) Beta Instance Method # subscriptionOfferViewDetailAction(\_:) StoreKitSwiftUI nonisolated Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/subscriptionofferviewstyle(_:) #app-main) - SwiftUI - View - subscriptionOfferViewStyle(\_:) Beta Instance Method # subscriptionOfferViewStyle(\_:) StoreKitSwiftUI nonisolated Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/subscriptionpromotionaloffer(offer:compactjws:) #app-main) - SwiftUI - View - subscriptionPromotionalOffer(offer:compactJWS:) Beta Instance Method # subscriptionPromotionalOffer(offer:compactJWS:) Selects a promotional offer to apply to a purchase a customer makes from a subscription store view. StoreKitSwiftUI nonisolated func subscriptionPromotionalOffer( ## Parameters `offer` The system calls this function before drawing the given subscription product on the subscription store view. Return the promotional offer to apply to the product, if any, to have system-provided UI reflect the discounted terms under the selected offer. `compactJWS` The system calls this function before processing a purchase, with the product to be purchased provided as a parameter, along with the selected subscription offer to be applied to the purchase. Return a compact JWS signature you generate on your server that validates the selected offer. Errors thrown from this closure will be surfaced via the `onInAppPurchaseCompletion(perform:)` modifier. For information about generating the JWS signature, see Generating JWS to sign App Store requests.. ## Discussion Subscription stores within this view uses the specified subscription offer to configure the appearance of the subscription plans displayed, when you use a system-provided `SubscriptionStoreControlStyle` to style the in-app subscription store. Standard `ProductViewStyle` instances don’t show introductory or promotional offers in UI. Use the `SubscriptionStoreView` instead to show these offers in the UI. If the signature passes validation for the offer you select, the system applies the offer to the purchase. If the signature fails validation for the offer you select, the purchase fails with `Product.PurchaseError.invalidOfferSignature`. Promotional offers you select in this modifier overwrite any offers you specified in ancestor views. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/subscriptionpromotionaloffer(offer:signature:) #app-main) - SwiftUI - View - subscriptionPromotionalOffer(offer:signature:) Deprecated Instance Method # subscriptionPromotionalOffer(offer:signature:) Selects a promotional offer to apply to a purchase a customer makes from a subscription store view. StoreKitSwiftUIiOS 17.4–26.0DeprecatediPadOS 17.4–26.0DeprecatedmacOS 14.4–26.0DeprecatedtvOS 17.4–26.0DeprecatedvisionOS 1.1–26.0DeprecatedwatchOS 10.4–26.0Deprecated nonisolated func subscriptionPromotionalOffer( ## Parameters `offer` The system calls this function before drawing the given subscription product on the subscription store view. Return the promotional offer to apply to the product, if any, to have system-provided UI reflect the discounted terms under the selected offer. `signature` The system calls this function before processing a purchase, with the product to be purchased provided as a parameter, along with the selected subscription offer to be applied to the purchase. Return a signature you generate on your server that validates the selected offer. Errors thrown from this closure will be surfaced via the `onInAppPurchaseCompletion(perform:)` modifier. For information about generating the signature, see Generating a signature for promotional offers. ## Discussion Subscription stores within this view uses the specified subscription offer to configure the appearance of the subscription plans displayed, when you use a system-provided `SubscriptionStoreControlStyle` to style the in-app subscription store. Standard `ProductViewStyle` instances don’t show introductory or promotional offers in UI. Use the `SubscriptionStoreView` instead to show these offers in the UI. If the signature passes validation for the offer you select, the system applies the offer to the purchase. If the signature fails validation for the offer you select, the purchase fails with `Product.PurchaseError.invalidOfferSignature`. Promotional offers you select in this modifier overwrite any offers you specified in ancestor views. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorebuttonlabel(_:) --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorecontrolbackground(_:) #app-main) - SwiftUI - View - subscriptionStoreControlBackground(\_:) Instance Method # subscriptionStoreControlBackground(\_:) Set a standard effect to use for the background of subscription store view controls within the view. StoreKitSwiftUI nonisolated Show all declarations ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorecontrolicon(icon:) #app-main) - SwiftUI - View - subscriptionStoreControlIcon(icon:) Instance Method # subscriptionStoreControlIcon(icon:) Sets a view to use to decorate individual subscription options within a subscription store view. StoreKitSwiftUI nonisolated ## Parameters `icon` A closure that takes a `Product` and `Product.SubscriptionInfo` and returns a view. ## Discussion You can adjust this view to provide a different appearance for each subscription option. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorecontrolstyle(_:) #app-main) - SwiftUI - View - subscriptionStoreControlStyle(\_:) Instance Method # subscriptionStoreControlStyle(\_:) Sets the control style for subscription store views within a view. StoreKitSwiftUI nonisolated ## Discussion This view modifier set the style of controls for `SubscriptionStoreView` instances within a view. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorecontrolstyle(_:placement:) #app-main) - SwiftUI - View - subscriptionStoreControlStyle(\_:placement:) Instance Method # subscriptionStoreControlStyle(\_:placement:) Sets the control style and control placement for subscription store views within a view. StoreKitSwiftUI nonisolated _ style: S, placement: S.Placement ## Parameters `style` The subscription store control style to use when drawing the subscription controls of `SubscriptionStoreView` instances within a view. `placement` The desired region of the subscription store view for placing the subscription controls. ## Discussion This modifier sets the style and placement of the subscription controls in any `SubscriptionStoreView` instance within a view. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstoreoptiongroupstyle(_:) #app-main) - SwiftUI - View - subscriptionStoreOptionGroupStyle(\_:) Instance Method # subscriptionStoreOptionGroupStyle(\_:) Sets the style subscription store views within this view use to display groups of subscription options. StoreKitSwiftUI nonisolated ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorepickeritembackground(_:) --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorepickeritembackground(_:in:) #app-main) - SwiftUI - View - subscriptionStorePickerItemBackground(\_:in:) Instance Method # subscriptionStorePickerItemBackground(\_:in:) Sets the background shape and style for subscription store view picker items within a view. StoreKitSwiftUI nonisolated func subscriptionStorePickerItemBackground( _ backgroundStyle: some ShapeStyle, in shape: some Shape ## Parameters `backgroundStyle` A `ShapeStyle` that determines the background style for the subscription store view picker items. `shape` An instance of a type that conforms to `Shape` and determines the shape of the subscription store view picker items. Omit the shape parameter to use the default shape. ## Discussion Use this view modifier to customize the shape of the picker options in a subscription store view, as well as the background style. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorepolicydestination(for:destination:) #app-main) - SwiftUI - View - subscriptionStorePolicyDestination(for:destination:) Instance Method # subscriptionStorePolicyDestination(for:destination:) Configures a view as the destination for a policy button action in subscription store views. StoreKitSwiftUI nonisolated func subscriptionStorePolicyDestination( for button: SubscriptionStorePolicyKind, ## Parameters `button` The policy button to associate the URL with. `destination` The view to present when someone chooses to view the policy. ## Discussion Except on tvOS, you can also set a URL as the destination using `subscriptionStorePolicyDestination(url:for:)`. If you do not set a destination, the system will use the automatic behavior. Check the documentation for the value you provide for `button` to understand the automatic behavior. By default, the subscription store shows the & buttons if you set a destination for at least one policy. The policy that is not explicitly set will use the automatic behavior. You can override this behavior using the `storeButton(_:for:)` modifier, with `policies` as the second parameter. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorepolicydestination(url:for:) --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorepolicyforegroundstyle(_:) #app-main) - SwiftUI - View - subscriptionStorePolicyForegroundStyle(\_:) Instance Method # subscriptionStorePolicyForegroundStyle(\_:) Sets the style for the and buttons within a subscription store view. StoreKitSwiftUI nonisolated ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstorepolicyforegroundstyle(_:_:) #app-main) - SwiftUI - View - subscriptionStorePolicyForegroundStyle(\_:\_:) Instance Method # subscriptionStorePolicyForegroundStyle(\_:\_:) Sets the primary and secondary style for the and buttons within a subscription store view. StoreKitSwiftUI nonisolated func subscriptionStorePolicyForegroundStyle( _ primary: some ShapeStyle, _ secondary: some ShapeStyle ## Parameters `primary` The color or pattern to use for the and buttons `secondary` The color or pattern to use for the conjunction between the buttons in the policy section ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/subscriptionstoresigninaction(_:) #app-main) - SwiftUI - View - subscriptionStoreSignInAction(\_:) Instance Method # subscriptionStoreSignInAction(\_:) Adds an action to perform when a person uses the sign-in button on a subscription store view within a view. StoreKitSwiftUI nonisolated ## Parameters `action` The action to perform. Pass `nil` to remove the sign in action for subscription stores within this view. The default value is `nil`. ## Discussion You can only have one sign in action for a view. If an ancestor view specifies a sign in action, using this modifier will replace the ancestor’s sign in action. If the value is `nil`, subscription stores will never show a sign in button. You can also hide the sign in button without removing the action by using the `storeButton(_:for:)` modifier, providing `signIn` as the button kind. ## See Also ### Interacting with the App Store and Apple Music Presents a StoreKit overlay when a given condition is true. Display the refund request sheet for the given transaction. Presents a sheet that enables users to redeem subscription offer codes that you configure in App Store Connect. Initiates the process of presenting a sheet with subscription offers for Apple Music when the `isPresented` binding is `true`. Declares the view as dependent on the entitlement of an In-App Purchase product, and returns a modified view. Add a function to call before initiating a purchase from StoreKit view within this view, providing a set of options for the purchase. Add an action to perform when a purchase initiated from a StoreKit view within this view completes. Add an action to perform when a user triggers the purchase button on a StoreKit view within this view. Adds a standard border to an in-app purchase product’s icon . Sets the style for In-App Purchase product views within a view. Configure the visibility of labels displaying an in-app purchase product description within the view. Specifies the visibility of auxiliary buttons that store view and subscription store view instances may use. Declares the view as dependent on an In-App Purchase product and returns a modified view. --- # https://developer.apple.com/documentation/swiftui/view/symbolcolorrenderingmode(_:) #app-main) - SwiftUI - View - symbolColorRenderingMode(\_:) Beta Instance Method # symbolColorRenderingMode(\_:) Sets the color rendering mode for symbol images. nonisolated ## Parameters `mode` The color rendering mode, or nil to use the default mode. ## Return Value A view that specifies the color rendering mode for symbol images. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/symbolvariablevaluemode(_:) --- # https://developer.apple.com/documentation/swiftui/view/tabbarminimizebehavior(_:) #app-main) - SwiftUI - View - tabBarMinimizeBehavior(\_:) Beta Instance Method # tabBarMinimizeBehavior(\_:) Sets the behavior for tab bar minimization. nonisolated ## Parameters `behavior` The minimize behavior. ## Discussion The following TabView minimizes its tab bar when scrolling in the ‘Numbers’ or ‘Alerts’ tabs on iPhone. struct ContentView: View { var body: some View { TabView { Tab("Numbers", systemImage: "number") { ScrollView { ForEach(0 ..< 50) { index in Text("\(index)") .padding() } } } Tab("Alerts", systemImage: "bell") { AlertsView() } } .tabBarMinimizeBehavior(.onScrollDown) } } Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/tabviewbottomaccessory(content:) #app-main) - SwiftUI - View - tabViewBottomAccessory(content:) Beta Instance Method # tabViewBottomAccessory(content:) nonisolated Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/tabletopgame(_:parent:automaticupdate:) --- # https://developer.apple.com/documentation/swiftui/view/tabletopgame(_:parent:automaticupdate:interaction:) --- # https://developer.apple.com/documentation/swiftui/view/textcontenttype(_:) #app-main) - SwiftUI - View - textContentType(\_:) Instance Method # textContentType(\_:) Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on macOS. nonisolated Show all declarations ## Parameters `textContentType` One of the content types available in the `NSTextContentType` structure that identify the semantic meaning expected for a text-entry area. ## Discussion Use this method to set the content type for input text. For example, you can configure a `TextField` for the entry of a username: TextField("Enter your username", text: $username) .textContentType(.username) ## See Also ### Managing text entry Sets whether to disable autocorrection for this view. `var autocorrectionDisabled: Bool` A Boolean value that determines whether the view hierarchy has auto-correction enabled. Sets the keyboard type for this view. Configures the behavior in which scrollable content interacts with the software keyboard. Sets how often the shift key in the keyboard is automatically enabled. `struct TextInputAutocapitalization` The kind of autocapitalization behavior applied during text input. Associates a fully formed string with the value of this view when used as a text input suggestion Configures the text input suggestions for this view. Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on a watchOS device. Sets the text content type for this view, which the system uses to offer suggestions while the user enters text on an iOS or tvOS device. `struct TextInputFormattingControlPlacement` A structure defining the system text formatting controls available on each platform. Beta --- # https://developer.apple.com/documentation/swiftui/view/textinputformattingcontrolvisibility(_:for:) #app-main) - SwiftUI - View - textInputFormattingControlVisibility(\_:for:) Beta Instance Method # textInputFormattingControlVisibility(\_:for:) Define which system text formatting controls are available. @MainActor @preconcurrency func textInputFormattingControlVisibility( _ visibility: Visibility, for placement: TextInputFormattingControlPlacement.Set ## Parameters `visibility` Whether the control may become visible to the user `placement` The onscreen control to modify Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/textrenderer(_:) #app-main) - SwiftUI - View - textRenderer(\_:) Instance Method # textRenderer(\_:) Returns a new view such that any text views within it will use `renderer` to draw themselves. nonisolated ## Parameters `renderer` The renderer value. ## Return Value A new view that will use `renderer` to draw its text views. ## See Also ### Rendering text Creating visual effects with SwiftUI Add scroll effects, rich color treatments, custom transitions, and advanced effects using shaders and a text renderer. `protocol TextAttribute` A value that you can attach to text views and that text renderers can query. `protocol TextRenderer` A value that can replace the default text view rendering behavior. `struct TextProxy` A proxy for a text view that custom text renderers use. --- # https://developer.apple.com/documentation/swiftui/view/textselectionaffinity(_:) #app-main) - SwiftUI - View - textSelectionAffinity(\_:) Instance Method # textSelectionAffinity(\_:) Sets the direction of a selection or cursor relative to a text character. nonisolated ## Parameters `affinity` The text selection affinity strategy to apply. ## Return Value A view that uses the specified selection affinity strategy. ## Discussion Use this modifier when you need to handle line breaks in a specific way, alter cursor movement or deal with bidirectional text (text that contains both LTR and RTL scripts, like English and Arabic combined). Selection affinity also determines whether, for example, the insertion point appears after the last character on a line or before the first character on the following line in cases where text wraps across line boundaries. Given the scenario `hello|مرحبا`, where `|` represents the cursor & `مرحبا` represents “hello” in Arabic, the ambiguity arises because: - If the cursor is associated with the end of the English word, it would be as if you’re continuing to type in English (LTR). - If the cursor is associated with the beginning of the Arabic word, it would also be as if you’re continuing to type in Arabic (RTL). This modifier helps resolve this ambiguity by determining the direction or association of the cursor relative to the surrounding text. The following example shows how you would specify a specific selection affinity on the given hierarchy: struct SuggestionTextEditor: View { @State var text: String = "" @State var selection: TextSelection? = nil var body: some View { VStack { TextEditor(text: $text, selection: $selection) // A helper view that offers live suggestions based on selection. SuggestionsView( substrings: getSubstrings(text: text, indices: selection?.indices)) } .textSelectionAffinity(.upstream) } private func getSubstrings( text: String, indices: TextSelection.Indices? // Resolve substrings representing the current selection... } } struct SuggestionsView: View { ... } ## See Also ### Selecting text Controls whether people can select text within this view. `protocol TextSelectability` A type that describes the ability to select text. `struct TextSelection` Represents a selection of text. `var textSelectionAffinity: TextSelectionAffinity` A representation of the direction or association of a selection or cursor relative to a text character. This concept becomes much more prominent when dealing with bidirectional text (text that contains both LTR and RTL scripts, like English and Arabic combined). `enum TextSelectionAffinity` `struct AttributedTextSelection` Represents a selection of attributed text. Beta --- # https://developer.apple.com/documentation/swiftui/view/tipbackground(_:) #app-main) - SwiftUI - View - tipBackground(\_:) Instance Method # tipBackground(\_:) Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. nonisolated ## Parameters `style` An instance of a type that conforms to `ShapeStyle` that SwiftUI draws behind the modified view. ## Return Value A view with the specified style drawn behind it. ## See Also ### Providing tips Presents a popover tip on the modified view. Sets the corner radius for an inline tip view. Sets the size for a tip’s image. Sets the given style for TipView within the view hierarchy. Sets the style for a tip’s image. --- # https://developer.apple.com/documentation/swiftui/view/tipcornerradius(_:antialiased:) #app-main) - SwiftUI - View - tipCornerRadius(\_:antialiased:) Instance Method # tipCornerRadius(\_:antialiased:) Sets the corner radius for an inline tip view. nonisolated func tipCornerRadius( _ cornerRadius: CGFloat, antialiased: Bool = true ## See Also ### Providing tips Presents a popover tip on the modified view. Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. Sets the size for a tip’s image. Sets the given style for TipView within the view hierarchy. Sets the style for a tip’s image. --- # https://developer.apple.com/documentation/swiftui/view/tipimagesize(_:) #app-main) - SwiftUI - View - tipImageSize(\_:) Instance Method # tipImageSize(\_:) Sets the size for a tip’s image. nonisolated ## See Also ### Providing tips Presents a popover tip on the modified view. Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. Sets the corner radius for an inline tip view. Sets the given style for TipView within the view hierarchy. Sets the style for a tip’s image. --- # https://developer.apple.com/documentation/swiftui/view/tipimagestyle(_:) #app-main) - SwiftUI - View - tipImageStyle(\_:) Instance Method # tipImageStyle(\_:) Sets the style for a tip’s image. nonisolated ## See Also ### Providing tips Presents a popover tip on the modified view. Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. Sets the corner radius for an inline tip view. Sets the size for a tip’s image. Sets the given style for TipView within the view hierarchy. --- # https://developer.apple.com/documentation/swiftui/view/tipimagestyle(_:_:) #app-main) - SwiftUI - View - tipImageStyle(\_:\_:) Instance Method # tipImageStyle(\_:\_:) Sets the style for a tip’s image. nonisolated _ primary: S1, _ secondary: S2 ## See Also ### Providing tips Presents a popover tip on the modified view. Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. Sets the corner radius for an inline tip view. Sets the size for a tip’s image. Sets the given style for TipView within the view hierarchy. --- # https://developer.apple.com/documentation/swiftui/view/tipimagestyle(_:_:_:) #app-main) - SwiftUI - View - tipImageStyle(\_:\_:\_:) Instance Method # tipImageStyle(\_:\_:\_:) Sets the style for a tip’s image. nonisolated _ primary: S1, _ secondary: S2, _ tertiary: S3 ## See Also ### Providing tips Presents a popover tip on the modified view. Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. Sets the corner radius for an inline tip view. Sets the size for a tip’s image. Sets the given style for TipView within the view hierarchy. --- # https://developer.apple.com/documentation/swiftui/view/tipviewstyle(_:) #app-main) - SwiftUI - View - tipViewStyle(\_:) Instance Method # tipViewStyle(\_:) Sets the given style for TipView within the view hierarchy. nonisolated ## Parameters `style` The style to set. ## Return Value A view that uses the specified style on its child views. ## Discussion For more information on styling tips, see `TipKit/TipViewStyle`. ## See Also ### Providing tips Presents a popover tip on the modified view. Sets the tip’s view background to a style. Currently this only applies to inline tips, not popover tips. Sets the corner radius for an inline tip view. Sets the size for a tip’s image. Sets the style for a tip’s image. --- # https://developer.apple.com/documentation/swiftui/view/toolbaritemhidden(_:) #app-main) - SwiftUI - View - toolbarItemHidden(\_:) Instance Method # toolbarItemHidden(\_:) Hides an individual view within a control group toolbar item. nonisolated ## Parameters `hidden` Whether the view in a control group toolbar item is hidden. ## Discussion Use this modifier to hide individual views of a `ControlGroup` without hiding the entire group. On macOS and iOS, hidden items will be displayed during user customization. The following example displays a collaboration button in a group when there is an active collaboration session. struct ContentView { @State private var inCollaboration = false var body: some View { BrowserView() .toolbar(id: "browserToolbar") { ToolbarItem(id: "share") { ControlGroup { ShareButton() CollaborationButton() .toolbarItemHidden(!inCollaboration) } } } } } --- # https://developer.apple.com/documentation/swiftui/view/transactiontask(_:action:) #app-main) - SwiftUI - View - transactionTask(\_:action:) Instance Method # transactionTask(\_:action:) Provides a task to perform before this view appears SecureElementCredentialSwiftUI nonisolated func transactionTask( _ configuration: CredentialTransaction.Configuration?, ## Parameters `configuration` A configuration containing information about the transaction task. When the task is completed or an error is encountered while performing the task, the system invalidates this configuration, and the `CredentialTransaction` is invalidated. `action` A closure that will be called when `isPerformingTransaction` is `true`. It provides a `CredentialTransaction` instance that can be used to perform transactions. ## Discussion This task provides an instance of a `CredentialTransaction` to be used to perform transactions. A typical client should use the APIs in the following sequence: 1. `acquirePresentmentIntentAssertion()` prior to showing any proprietary payment UI 2. `relinquish()` the assertion before invoking the transaction API 3. `configuration.invalidate()` after presenting the credential 4. Optionally, `acquirePresentmentIntentAssertion()` to finish up any proprietary payment UI 5. `relinquish()` the assertion For example: struct TransactionView: View { @State private var configuration: CredentialTransaction.Configuration? private var assertion: PresentmentIntentAssertion // acquirePresentmentIntentAssertion() before transitioning into this view (step 1) private var activeSession: CredentialSession private var selectedCredential: Credential var body: some View { VStack { Button("Perform Transaction") { guard let configuration else { configuration = activeSession.configuration() return } configuration.invalidate() // step 3 // Optional assertion = try await session.acquirePresentmentIntentAssertion() // step 4 // handle any proprietary UI try await assertion.relinquish() // step 5 // Optional end } .transactionTask(configuration) { transaction in do { try await assertion.relinquish() // step 2 try await transaction.performTransaction(using: selectedCredential) } catch { // code to handle error } } } } } ## See Also ### Accessing Apple Pay and Wallet A view that displays a button for identity verification. Sets the button’s style. Sets the style to be used by the button. (see `PKAddPassButtonStyle`). Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. Sets the action on the PayLaterView. See `PKPayLaterAction`. Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Sets the style to be used by the button. (see `PKIdentityButtonStyle`). --- # https://developer.apple.com/documentation/swiftui/view/translationpresentation(ispresented:text:attachmentanchor:arrowedge:replacementaction:) #app-main) - SwiftUI - View - translationPresentation(isPresented:text:attachmentAnchor:arrowEdge:replacementAction:) Instance Method # translationPresentation(isPresented:text:attachmentAnchor:arrowEdge:replacementAction:) Presents a translation popover when a given condition is true. TranslationSwiftUI nonisolated func translationPresentation( text: String, attachmentAnchor: PopoverAttachmentAnchor = .rect(.bounds), arrowEdge: Edge = .top, ## Parameters `isPresented` A binding to a Boolean value that determines whether to present the popover. `text` The text to be translated. Changing this after the popover presents has no effect. `attachmentAnchor` The positioning anchor that defines the attachment point of the popover. The default is `bounds`. `arrowEdge` The edge of the `attachmentAnchor` that defines the location of the popover’s arrow in macOS. The default is `Edge.top`. iOS ignores this parameter. `replacementAction` An optional action to perform when someone interacts with the “Replace with Translation” button. The “Replace with Translation” button appears when you provide this action. ## Discussion Use this method to show a system UI translation popover when the `translationVisible` Boolean variable is `true`. Attach this view modifier to the containing view holding the text to translate. Then set the `isPresented` Boolean binding to `true` when you want the popover to display. When you do, a system UI translation popover appears offering a translation. In the example below, the popover appears when the user toggles the `translationVisible` state variable by pressing the Translate button. struct ContentView: View { @State private var translationVisible = false private var originalText = "Hallo, Welt!" var body: some View { VStack { Text(verbatim: originalText) .translationPresentation(isPresented: $translationVisible, text: originalText) Button("Translate") { translationVisible.toggle() } } } } To replace the original text with the translation, pass in a trailing closure to the `replacementAction` parameter. When you do, a Replace with Translation button appears in the system UI. When the user taps this button, the closure returns a translation of the text as a string. Use that string to update the original text with the translated text as shown below: struct ReplaceTranslation: View { @State private var translationVisible = false @State private var originalText = "Hallo, Welt!" var body: some View { VStack(spacing: 20) { TextField("Text to translate", text: $originalText, axis: .vertical) .textFieldStyle(.roundedBorder) .translationPresentation(isPresented: $translationVisible, text: originalText) { translatedString in // Update the original text with the translated result. originalText = translatedString } Button("Translate") { translationVisible.toggle() } } .padding() } } If the system can’t detect the source language, it asks the user to select the language to translate from. For a list of supported languages see `LanguageAvailability.supportedLanguages`. While this function does support long strings of text, it works best with short ones (no more than a couple of sentences or phrases in length). ## See Also ### Showing a translation Adds a task to perform before this view appears or when the translation configuration changes. Adds a task to perform before this view appears or when the specified source or target languages change. --- # https://developer.apple.com/documentation/swiftui/view/translationtask(_:action:) #app-main) - SwiftUI - View - translationTask(\_:action:) Instance Method # translationTask(\_:action:) Adds a task to perform before this view appears or when the translation configuration changes. TranslationSwiftUI nonisolated func translationTask( _ configuration: TranslationSession.Configuration?, ## Parameters `configuration` A configuration for a `TranslationSession`. When this configuration is non-nil and changes. the `action` runs providing an instance of `TranslationSession` to perform translations. `action` A closure that runs when the `configuration` is non-nil and changes. This closure runs when the view appears if `configuration` is initially non-nil. It provides a `TranslationSession` instance to perform one or multiple translations. ## Discussion This task provides an instance of `TranslationSession` to use in translations. Whenever `TranslationSession/Configuration` changes and isn’t `nil`, the closure `action` runs, providing a `TranslationSession` instance to perform one or more translations. For example, you can create a `TranslationSession/Configuration` in response to a button press to trigger translation: struct ContentView: View { @State private var sourceText = "Hallo, Welt!" var sourceLanguage: Locale.Language? var targetLanguage: Locale.Language? @State private var targetText: String? @State private var configuration: TranslationSession.Configuration? var body: some View { VStack { Text(targetText ?? sourceText) Button("Translate") { guard configuration == nil else { configuration?.invalidate() return } configuration = TranslationSession.Configuration( source: sourceLanguage, target: targetLanguage) } .translationTask(configuration) { session in Task { @MainActor in do { let response = try await session.translate(sourceText) targetText = response.targetText } catch { // code to handle error } } } } } } The system throws a `fatalError` if you use a `TranslationSession` instance after the view it attaches to disappears, or if you use it after changing the `configuration`, causing the `action` closure to provide a new `TranslationSession` instance. ## See Also ### Showing a translation Presents a translation popover when a given condition is true. Adds a task to perform before this view appears or when the specified source or target languages change. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/translationtask(source:target:action:) #app-main) - SwiftUI - View - translationTask(source:target:action:) Instance Method # translationTask(source:target:action:) Adds a task to perform before this view appears or when the specified source or target languages change. TranslationSwiftUI nonisolated func translationTask( source: Locale.Language? = nil, target: Locale.Language? = nil, ## Parameters `source` The language the source content is in. If this is `nil` the session tries to identify the language, and prompt the user to pick the source language if it’s unclear. All text translated within the session should be in the same source language. Changing this value cancels previous tasks and creates a new one to perform translations again. `target` The language to translate content into. A `nil` value means the session picks a target according to the user’s `Locale.preferredLanguages`, and the `source`. Changing this value cancels previous tasks and create a new one to perform translations again. `action` A closure that runs when the view first appears, and when `source` or `target` change. It provides a `TranslationSession` instance to perform one or multiple translations. ## Discussion This task provides an instance of `TranslationSession` to use to perform translations. If you need to perform new translations again with the same `source` and `target` language, it’s better to use `translationTask(_:action:)` and call `TranslationSession/Configuration/invalidate()`. For example, you can translate when content appears: struct ContentView: View { var sourceText = "Hallo, Welt!" var sourceLanguage: Locale.Language? var targetLanguage: Locale.Language? @State private var targetText: String? var body: some View { Text(targetText ?? sourceText) .translationTask( source: sourceLanguage, target: targetLanguage ) { session in Task { @MainActor in do { let response = try await session.translate(sourceText) targetText = response.targetText } catch { // code to handle error } } } } } The system throws a `fatalError` if you use a `TranslationSession` instance after the view it attaches to disappears, or if you use it after changing the `source` or `target` parameters, causing the `action` closure to provide a new `TranslationSession` instance. ## See Also ### Showing a translation Presents a translation popover when a given condition is true. Adds a task to perform before this view appears or when the translation configuration changes. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/verifyidentitywithwalletbuttonstyle(_:) #app-main) - SwiftUI - View - verifyIdentityWithWalletButtonStyle(\_:) Instance Method # verifyIdentityWithWalletButtonStyle(\_:) Sets the style to be used by the button. (see `PKIdentityButtonStyle`). PassKitSwiftUI nonisolated ## See Also ### Accessing Apple Pay and Wallet A view that displays a button for identity verification. Sets the button’s style. Sets the style to be used by the button. (see `PKAddPassButtonStyle`). Called when a user has entered or updated a coupon code. This is required if the user is being asked to provide a coupon code. Called when a payment method has changed and asks for an update payment request. If this modifier isn’t provided Wallet will assume the payment method is valid. Called when a user selected a shipping address. This is required if the user is being asked to provide a shipping contact. Called when a user selected a shipping method. This is required if the user is being asked to provide a shipping method. Sets the action on the PayLaterView. See `PKPayLaterAction`. Sets the display style on the PayLaterView. See `PKPayLaterDisplayStyle`. Sets the style to be used by the button. (see `PayWithApplePayButtonStyle`). Provides a task to perform before this view appears --- # https://developer.apple.com/documentation/swiftui/view/webviewbackforwardnavigationgestures(_:) #app-main) - SwiftUI - View - webViewBackForwardNavigationGestures(\_:) Instance Method # webViewBackForwardNavigationGestures(\_:) Determines whether horizontal swipe gestures trigger backward and forward page navigation. WebKitSwiftUI nonisolated --- # https://developer.apple.com/documentation/swiftui/view/webviewcontentbackground(_:) #app-main) - SwiftUI - View - webViewContentBackground(\_:) Instance Method # webViewContentBackground(\_:) Specifies the visibility of the webpage’s natural background color within this view. WebKitSwiftUI nonisolated ## Parameters `visibility` The visibility to use for the background. ## Discussion By default, WebViews are opaque, and use the page’s natural background color as their background color. Use this modifier if you would like to not use this behavior and instead provide a custom background using SwiftUI. --- # https://developer.apple.com/documentation/swiftui/view/webviewcontextmenu(menu:) --- # https://developer.apple.com/documentation/swiftui/view/webviewelementfullscreenbehavior(_:) #app-main) - SwiftUI - View - webViewElementFullscreenBehavior(\_:) Instance Method # webViewElementFullscreenBehavior(\_:) Determines whether a web view can display content full screen. WebKitSwiftUI nonisolated --- # https://developer.apple.com/documentation/swiftui/view/webviewlinkpreviews(_:) #app-main) - SwiftUI - View - webViewLinkPreviews(\_:) Instance Method # webViewLinkPreviews(\_:) Determines whether pressing a link displays a preview of the destination for the link. WebKitSwiftUI nonisolated --- # https://developer.apple.com/documentation/swiftui/view/webviewmagnificationgestures(_:) #app-main) - SwiftUI - View - webViewMagnificationGestures(\_:) Instance Method # webViewMagnificationGestures(\_:) Determines whether magnify gestures change the view’s magnification. WebKitSwiftUI nonisolated --- # https://developer.apple.com/documentation/swiftui/view/webviewonscrollgeometrychange(for:of:action:) #app-main) - SwiftUI - View - webViewOnScrollGeometryChange(for:of:action:) Instance Method # webViewOnScrollGeometryChange(for:of:action:) Adds an action to be performed when a value, created from a scroll geometry, changes. WebKitSwiftUI nonisolated for type: T.Type, ## Parameters `type` The type of value transformed from a `ScrollGeometry`. `transform` A closure that transforms a `ScrollGeometry` to your type. `action` A closure to run when the transformed data changes. ## Discussion --- # https://developer.apple.com/documentation/swiftui/view/webviewscrollinputbehavior(_:for:) --- # https://developer.apple.com/documentation/swiftui/view/webviewscrollposition(_:) #app-main) - SwiftUI - View - webViewScrollPosition(\_:) Instance Method # webViewScrollPosition(\_:) Associates a binding to a scroll position with the web view. WebKitSwiftUI nonisolated ## Discussion --- # https://developer.apple.com/documentation/swiftui/view/webviewtextselection(_:) --- # https://developer.apple.com/documentation/swiftui/view/windowresizeanchor(_:) --- # https://developer.apple.com/documentation/swiftui/view/workoutpreview(_:ispresented:) #app-main) - SwiftUI - View - workoutPreview(\_:isPresented:) Instance Method # workoutPreview(\_:isPresented:) Presents a preview of the workout contents as a modal sheet WorkoutKitSwiftUI nonisolated func workoutPreview( _ workout: WorkoutPlan, ## Parameters `workout` The `WorkoutContainer` the preview displays `isPresented` A binding to a Boolean value that determines whether to present the preview ## Discussion struct WorkoutPreviewer: View { let workout: WorkoutPlan @State var presented: Bool = false var body: some View { Button { isPresented = true } label: { WorkoutContainerView(workout) } .workoutPreview(workout, isPresented: $presented) } } ## See Also ### Accessing health data Asynchronously requests permission to read a data type that requires per-object authorization (such as vision prescriptions). Requests permission to read the specified HealthKit data types. Requests permission to save and read the specified HealthKit data types. --- # https://developer.apple.com/documentation/swiftui/view/writingdirection(strategy:) #app-main) - SwiftUI - View - writingDirection(strategy:) Beta Instance Method # writingDirection(strategy:) A modifier for the default text writing direction strategy in the view hierarchy. nonisolated ## Discussion To control the writing direction explicitly, choose the `layoutBased` mode and set the `layoutDirection` to the appropriate value. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/view/writingtoolsaffordancevisibility(_:) --- # https://developer.apple.com/documentation/swiftui/view/writingtoolsbehavior(_:) --- # https://developer.apple.com/documentation/swiftui/dynamicviewcontent - SwiftUI - DynamicViewContent Protocol # DynamicViewContent A type of view that generates views from an underlying collection of data. ## Topics ### Managing the data `var data: Self.Data` The collection of underlying data. **Required** `associatedtype Data : Collection` The type of the underlying collection of data. ### Responding to updates Sets the deletion action for the dynamic view. You must delete the corresponding item within `action`, as it will be called after the row has already been removed from the `List`. Sets the insert action for the dynamic view. Sets the move action for the dynamic view. ### Deprecated symbols Deprecated ### Instance Methods `func onInsert(of:perform:)` ## Relationships ### Inherits From - `View` ### Conforming Types - `ForEach` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, and `Content` conforms to `View`. - `ModifiedContent` Conforms when `Content` conforms to `DynamicViewContent` and `Modifier` conforms to `ViewModifier`. ## See Also ### Iterating over dynamic data `struct ForEach` A structure that computes views on demand from an underlying collection of identified data. `struct ForEachSectionCollection` A collection which allows a view to be treated as a collection of its sections in a for each loop. `struct ForEachSubviewCollection` A collection which allows a view to be treated as a collection of its subviews in a for each loop. --- # https://developer.apple.com/documentation/swiftui/insettableshape --- # https://developer.apple.com/documentation/swiftui/nsviewcontrollerrepresentable --- # https://developer.apple.com/documentation/swiftui/nsviewrepresentable - SwiftUI - NSViewRepresentable Protocol # NSViewRepresentable A wrapper that you use to integrate an AppKit view into your SwiftUI view hierarchy. @MainActor @preconcurrency protocol NSViewRepresentable : View where Self.Body == Never ## Overview Use an `NSViewRepresentable` instance to create and manage an `NSView` object in your SwiftUI interface. Adopt this protocol in one of your app’s custom instances, and use its methods to create, update, and tear down your view. The creation and update processes parallel the behavior of SwiftUI views, and you use them to configure your view with your app’s current state information. Use the teardown process to remove your view cleanly from your SwiftUI. For example, you might use the teardown process to notify other objects that the view is disappearing. To add your view into your SwiftUI interface, create your `NSViewRepresentable` instance and add it to your SwiftUI interface. The system calls the methods of your representable instance at appropriate times to create and update the view. The following example shows the inclusion of a custom `MyRepresentedCustomView` struct in the view hierarchy. struct ContentView: View { var body: some View { VStack { Text("Global Sales") MyRepresentedCustomView() } } } The system doesn’t automatically communicate changes occurring within your view controller to other parts of your SwiftUI interface. When you want your view controller to coordinate with other SwiftUI views, you must provide a `Coordinator` object to facilitate those interactions. For example, you use a coordinator to forward target-action and delegate messages from your view controller to any SwiftUI views. ## Topics ### Creating and updating the view Creates the view object and configures its initial state. **Required** `func updateNSView(Self.NSViewType, context: Self.Context)` Updates the state of the specified view with new information from SwiftUI. `typealias Context` `associatedtype NSViewType : NSView` The type of view to present. ### Specifying a size Given a proposed size, returns the preferred size of the composite view. **Required** Default implementation provided. ### Cleaning up the view `static func dismantleNSView(Self.NSViewType, coordinator: Self.Coordinator)` Cleans up the presented AppKit view (and coordinator) in anticipation of their removal. ### Providing a custom coordinator object Creates the custom instance that you use to communicate changes from your view to other parts of your SwiftUI interface. `associatedtype Coordinator = Void` A type to coordinate with the view. ### Performing layout `typealias LayoutOptions` ## Relationships ### Inherits From - `View` ## See Also ### Adding AppKit views to SwiftUI view hierarchies `struct NSViewRepresentableContext` Contextual information about the state of the system that you use to create and update your AppKit view. `protocol NSViewControllerRepresentable` A wrapper that you use to integrate an AppKit view controller into your SwiftUI interface. `struct NSViewControllerRepresentableContext` Contextual information about the state of the system that you use to create and update your AppKit view controller. --- # https://developer.apple.com/documentation/swiftui/shape --- # https://developer.apple.com/documentation/swiftui/shapeview - SwiftUI - ShapeView Protocol # ShapeView A view that provides a shape that you can use for drawing operations. ## Overview Use this type with the drawing methods on `Shape` to apply multiple fills and/or strokes to a shape. For example, the following code applies a fill and stroke to a capsule shape: Capsule() .fill(.yellow) .stroke(.blue, lineWidth: 8) ## Topics ### Getting the shape `var shape: Self.Content` The shape that this type draws and provides for other drawing operations. **Required** `associatedtype Content : Shape` The type of shape this can provide. ### Modify the shape Fills this shape with a color or gradient. Traces the outline of this shape with a color or gradient. Returns a view that’s the result of insetting this view by half of its style’s line width. Returns a view that’s the result of filling an inner stroke of this view with the content you supply. ## Relationships ### Inherits From - `View` ### Conforming Types - `FillShapeView` - `StrokeBorderShapeView` - `StrokeShapeView` ## See Also ### Defining shape behavior `protocol Shape` A 2D shape that you can use when drawing a view. `struct AnyShape` A type-erased shape value. `enum ShapeRole` Ways of styling a shape. `struct StrokeStyle` The characteristics of a stroke that traces a path. `struct StrokeShapeView` A shape provider that strokes its shape. `struct StrokeBorderShapeView` A shape provider that strokes the border of its shape. `struct FillStyle` A style for rasterizing vector shapes. `struct FillShapeView` A shape provider that fills its shape. --- # https://developer.apple.com/documentation/swiftui/uiviewcontrollerrepresentable - SwiftUI - UIViewControllerRepresentable Protocol # UIViewControllerRepresentable A view that represents a UIKit view controller. @MainActor @preconcurrency protocol UIViewControllerRepresentable : View where Self.Body == Never ## Overview Use a `UIViewControllerRepresentable` instance to create and manage a `UIViewController` object in your SwiftUI interface. Adopt this protocol in one of your app’s custom instances, and use its methods to create, update, and tear down your view controller. The creation and update processes parallel the behavior of SwiftUI views, and you use them to configure your view controller with your app’s current state information. Use the teardown process to remove your view controller cleanly from your SwiftUI. For example, you might use the teardown process to notify other objects that the view controller is disappearing. To add your view controller into your SwiftUI interface, create your `UIViewControllerRepresentable` instance and add it to your SwiftUI interface. The system calls the methods of your custom instance at appropriate times. The system doesn’t automatically communicate changes occurring within your view controller to other parts of your SwiftUI interface. When you want your view controller to coordinate with other SwiftUI views, you must provide a `Coordinator` instance to facilitate those interactions. For example, you use a coordinator to forward target-action and delegate messages from your view controller to any SwiftUI views. ## Topics ### Creating and updating the view controller Creates the view controller object and configures its initial state. **Required** `func updateUIViewController(Self.UIViewControllerType, context: Self.Context)` Updates the state of the specified view controller with new information from SwiftUI. `typealias Context` `associatedtype UIViewControllerType : UIViewController` The type of view controller to present. ### Specifying a size Given a proposed size, returns the preferred size of the composite view. **Required** Default implementation provided. ### Cleaning up the view controller `static func dismantleUIViewController(Self.UIViewControllerType, coordinator: Self.Coordinator)` Cleans up the presented view controller (and coordinator) in anticipation of their removal. ### Providing a custom coordinator object Creates the custom instance that you use to communicate changes from your view controller to other parts of your SwiftUI interface. `associatedtype Coordinator = Void` A type to coordinate with the view controller. ### Performing layout `typealias LayoutOptions` ## Relationships ### Inherits From - `View` ## See Also ### Adding UIKit views to SwiftUI view hierarchies `protocol UIViewRepresentable` A wrapper for a UIKit view that you use to integrate that view into your SwiftUI view hierarchy. `struct UIViewRepresentableContext` Contextual information about the state of the system that you use to create and update your UIKit view. `struct UIViewControllerRepresentableContext` Contextual information about the state of the system that you use to create and update your UIKit view controller. --- # https://developer.apple.com/documentation/swiftui/uiviewrepresentable - SwiftUI - UIViewRepresentable Protocol # UIViewRepresentable A wrapper for a UIKit view that you use to integrate that view into your SwiftUI view hierarchy. @MainActor @preconcurrency protocol UIViewRepresentable : View where Self.Body == Never ## Overview Use a `UIViewRepresentable` instance to create and manage a `UIView` object in your SwiftUI interface. Adopt this protocol in one of your app’s custom instances, and use its methods to create, update, and tear down your view. The creation and update processes parallel the behavior of SwiftUI views, and you use them to configure your view with your app’s current state information. Use the teardown process to remove your view cleanly from your SwiftUI. For example, you might use the teardown process to notify other objects that the view is disappearing. To add your view into your SwiftUI interface, create your `UIViewRepresentable` instance and add it to your SwiftUI interface. The system calls the methods of your representable instance at appropriate times to create and update the view. The following example shows the inclusion of a custom `MyRepresentedCustomView` structure in the view hierarchy. struct ContentView: View { var body: some View { VStack { Text("Global Sales") MyRepresentedCustomView() } } } The system doesn’t automatically communicate changes occurring within your view to other parts of your SwiftUI interface. When you want your view to coordinate with other SwiftUI views, you must provide a `Coordinator` instance to facilitate those interactions. For example, you use a coordinator to forward target-action and delegate messages from your view to any SwiftUI views. ## Topics ### Creating and updating the view Creates the view object and configures its initial state. **Required** `func updateUIView(Self.UIViewType, context: Self.Context)` Updates the state of the specified view with new information from SwiftUI. `typealias Context` `associatedtype UIViewType : UIView` The type of view to present. ### Specifying a size Given a proposed size, returns the preferred size of the composite view. **Required** Default implementation provided. ### Cleaning up the view `static func dismantleUIView(Self.UIViewType, coordinator: Self.Coordinator)` Cleans up the presented UIKit view (and coordinator) in anticipation of their removal. ### Providing a custom coordinator object Creates the custom instance that you use to communicate changes from your view to other parts of your SwiftUI interface. `associatedtype Coordinator = Void` A type to coordinate with the view. ### Performing layout `typealias LayoutOptions` ## Relationships ### Inherits From - `View` ## See Also ### Adding UIKit views to SwiftUI view hierarchies `struct UIViewRepresentableContext` Contextual information about the state of the system that you use to create and update your UIKit view. `protocol UIViewControllerRepresentable` A view that represents a UIKit view controller. `struct UIViewControllerRepresentableContext` Contextual information about the state of the system that you use to create and update your UIKit view controller. --- # https://developer.apple.com/documentation/swiftui/wkinterfaceobjectrepresentable - SwiftUI - WKInterfaceObjectRepresentable Protocol # WKInterfaceObjectRepresentable A view that represents a WatchKit interface object. @MainActor @preconcurrency protocol WKInterfaceObjectRepresentable : View where Self.Body == Never ## Overview Use a `WKInterfaceObjectRepresentable` instance to create and manage a `WKInterfaceObject` in your SwiftUI interface. Adopt this protocol in one of your app’s custom instances, and use its methods to create, update, and tear down your interface object. The creation and update processes parallel the behavior of SwiftUI views, and you use them to configure your interface object with your app’s current state information. Use the teardown process to remove your interface object cleanly from your SwiftUI. For example, you might use the teardown process to notify other parts of your app that the interface object is disappearing. To add your interface object into your SwiftUI interface, create your `WKInterfaceObjectRepresentable` instance and add it to your SwiftUI interface. The system calls the methods of your representable instance at appropriate times to create and update the interface object. The system doesn’t automatically communicate changes occurring within your interface object to other parts of your SwiftUI interface. When you want your interface object to coordinate with other SwiftUI views, you must provide a `Coordinator` instance to facilitate those interactions. For example, you use a coordinator to forward target-action and delegate messages from your interface object to any SwiftUI views. ## Topics ### Creating and updating the interface object Creates a WatchKit interface object and configures its initial state. **Required** `func updateWKInterfaceObject(Self.WKInterfaceObjectType, context: Self.Context)` Updates the presented WatchKit interface object (and its coordinator) to the latest configuration. `typealias Context` ### Cleaning up the interface object `static func dismantleWKInterfaceObject(Self.WKInterfaceObjectType, coordinator: Self.Coordinator)` Cleans up the presented WatchKit interface object (and its coordinator) in anticipation of their removal. **Required** Default implementation provided. ### Providing a custom coordinator object Creates the custom instance that you use to communicate changes from your interface object to other parts of your SwiftUI interface. `associatedtype Coordinator = Void` A type to coordinate with the WatchKit interface object. `associatedtype WKInterfaceObjectType : WKInterfaceObject` The type of WatchKit interface object to be presented. ## Relationships ### Inherits From - `View` ## See Also ### Adding WatchKit views to SwiftUI view hierarchies `struct WKInterfaceObjectRepresentableContext` Contextual information about the state of the system that you use to create and update your WatchKit interface object. --- # https://developer.apple.com/documentation/swiftui/angulargradient --- # https://developer.apple.com/documentation/swiftui/anyshape - SwiftUI - AnyShape Structure # AnyShape A type-erased shape value. @frozen struct AnyShape ## Overview You can use this type to dynamically switch between shape types: struct MyClippedView: View { var isCircular: Bool var body: some View { OtherView().clipShape(isCircular ? AnyShape(Circle()) : AnyShape(Capsule())) } } ## Topics ### Creating a shape Create an any shape instance from a shape. ## Relationships ### Conforms To - `Animatable` - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Defining shape behavior `protocol ShapeView` A view that provides a shape that you can use for drawing operations. `protocol Shape` A 2D shape that you can use when drawing a view. `enum ShapeRole` Ways of styling a shape. `struct StrokeStyle` The characteristics of a stroke that traces a path. `struct StrokeShapeView` A shape provider that strokes its shape. `struct StrokeBorderShapeView` A shape provider that strokes the border of its shape. `struct FillStyle` A style for rasterizing vector shapes. `struct FillShapeView` A shape provider that fills its shape. --- # https://developer.apple.com/documentation/swiftui/anyview - SwiftUI - AnyView Structure # AnyView A type-erased view. @frozen struct AnyView ## Overview An `AnyView` allows changing the type of view used in a given view hierarchy. Whenever the type of view used with an `AnyView` changes, the old hierarchy is destroyed and a new hierarchy is created for the new type. ## Topics ### Creating a view Create an instance that type-erases `view`. ## Relationships ### Conforms To - `View` ## See Also ### Supporting view types `struct EmptyView` A view that doesn’t contain any content. `struct EquatableView` A view type that compares itself against its previous value and prevents its child updating if its new value is the same as its old value. `struct SubscriptionView` A view that subscribes to a publisher with an action. `struct TupleView` A View created from a swift tuple of View values. --- # https://developer.apple.com/documentation/swiftui/asyncimage - SwiftUI - AsyncImage Structure # AsyncImage A view that asynchronously loads and displays an image. ## Overview This view uses the shared `URLSession` instance to load an image from the specified URL, and then display it. For example, you can display an icon that’s stored on a server: AsyncImage(url: URL(string: "https://example.com/icon.png")) .frame(width: 200, height: 200) Until the image loads, the view displays a standard placeholder that fills the available space. After the load completes successfully, the view updates to display the image. In the example above, the icon is smaller than the frame, and so appears smaller than the placeholder. You can specify a custom placeholder using `init(url:scale:content:placeholder:)`. With this initializer, you can also use the `content` parameter to manipulate the loaded image. For example, you can add a modifier to make the loaded image resizable: AsyncImage(url: URL(string: "https://example.com/icon.png")) { image in image.resizable() } placeholder: { ProgressView() } .frame(width: 50, height: 50) For this example, SwiftUI shows a `ProgressView` first, and then the image scaled to fit in the specified frame: To gain more control over the loading process, use the `init(url:scale:transaction:content:)` initializer, which takes a `content` closure that receives an `AsyncImagePhase` to indicate the state of the loading operation. Return a view that’s appropriate for the current phase: AsyncImage(url: URL(string: "https://example.com/icon.png")) { phase in if let image = phase.image { image // Displays the loaded image. } else if phase.error != nil { Color.red // Indicates an error. } else { Color.blue // Acts as a placeholder. } } ## Topics ### Loading an image `init(url: URL?, scale: CGFloat)` Loads and displays an image from the specified URL. Loads and displays a modifiable image from the specified URL using a custom placeholder until the image loads. ### Loading an image in phases Loads and displays a modifiable image from the specified URL in phases. ## Relationships ### Conforms To - `View` ## See Also ### Loading images asynchronously `enum AsyncImagePhase` The current phase of the asynchronous image loading operation. --- # https://developer.apple.com/documentation/swiftui/button --- # https://developer.apple.com/documentation/swiftui/buttonbordershape - SwiftUI - ButtonBorderShape Structure # ButtonBorderShape A shape used to draw a button’s border. struct ButtonBorderShape ## Overview Use the `buttonBorderShape(_:)` view modifier to apply the shape to bordered buttons within a view hierarchy. ## Topics ### Getting border shapes `static let automatic: ButtonBorderShape` A shape that defers to the system to determine an appropriate shape for the given context and platform. `static let capsule: ButtonBorderShape` A capsule shape. `static let circle: ButtonBorderShape` A circular shape. `static let roundedRectangle: ButtonBorderShape` A rounded rectangle shape. ## Relationships ### Conforms To - `Animatable` - `Copyable` - `Equatable` - `InsettableShape` - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Creating buttons `struct Button` A control that initiates an action. `func buttonStyle(_:)` Sets the style for buttons within this view to a button style with a custom appearance and standard interaction behavior. Sets the border shape for buttons in this view. Sets whether buttons in this view should repeatedly trigger their actions on prolonged interactions. `var buttonRepeatBehavior: ButtonRepeatBehavior` Whether buttons with this associated environment should repeatedly trigger their actions on prolonged interactions. `struct ButtonRole` A value that describes the purpose of a button. `struct ButtonRepeatBehavior` The options for controlling the repeatability of button actions. `struct ButtonSizing` Beta --- # https://developer.apple.com/documentation/swiftui/buttonstyleconfiguration/label-swift.struct - SwiftUI - ButtonStyleConfiguration - ButtonStyleConfiguration.Label Structure # ButtonStyleConfiguration.Label A type-erased label of a button. @MainActor @preconcurrency struct Label ## Relationships ### Conforms To - `View` ## See Also ### Configuring a button’s label `let label: ButtonStyleConfiguration.Label` A view that describes the effect of pressing the button. --- # https://developer.apple.com/documentation/swiftui/canvas - SwiftUI - Canvas Structure # Canvas A view type that supports immediate mode drawing. ## Overview Use a canvas to draw rich and dynamic 2D graphics inside a SwiftUI view. The canvas passes a `GraphicsContext` to the closure that you use to perform immediate mode drawing operations. The canvas also passes a `CGSize` value that you can use to customize what you draw. For example, you can use the context’s `stroke(_:with:lineWidth:)` command to draw a `Path` instance: Canvas { context, size in context.stroke( Path(ellipseIn: CGRect(origin: .zero, size: size)), with: .color(.green), lineWidth: 4) } .frame(width: 300, height: 200) .border(Color.blue) The example above draws the outline of an ellipse that exactly inscribes a canvas with a blue border: In addition to outlined and filled paths, you can draw images, text, and complete SwiftUI views. To draw views, use the `init(opaque:colorMode:rendersAsynchronously:renderer:symbols:)` method to supply views that you can reference from inside the renderer. You can also add masks, apply filters, perform transforms, control blending, and more. For information about how to draw, see `GraphicsContext`. A canvas doesn’t offer interactivity or accessibility for individual elements, including for views that you pass in as symbols. However, it might provide better performance for a complex drawing that involves dynamic data. Use a canvas to improve performance for a drawing that doesn’t primarily involve text or require interactive elements. ## Topics ### Creating a canvas Creates and configures a canvas. Creates and configures a canvas that you supply with renderable child views. ### Managing opacity and color `var isOpaque: Bool` A Boolean that indicates whether the canvas is fully opaque. `var colorMode: ColorRenderingMode` The working color space and storage format of the canvas. ### Referencing symbols `var symbols: Symbols` A view that provides child views that you can use in the drawing callback. ### Rendering `var rendersAsynchronously: Bool` A Boolean that indicates whether the canvas can present its contents to its parent view asynchronously. The drawing callback that you use to draw into the canvas. ## Relationships ### Conforms To - `Copyable` - `View` Conforms when `Symbols` conforms to `View`. ## See Also ### Immediate mode drawing Add Rich Graphics to Your SwiftUI App Make your apps stand out by adding background materials, vibrancy, custom graphics, and animations. `struct GraphicsContext` An immediate mode drawing destination, and its current state. --- # https://developer.apple.com/documentation/swiftui/capsule --- # https://developer.apple.com/documentation/swiftui/circle --- # https://developer.apple.com/documentation/swiftui/color - SwiftUI - Color Structure # Color A representation of a color that adapts to a given context. @frozen struct Color ## Mentioned in Laying out a simple view ## Overview You can create a color in one of several ways: - Load a color from an Asset Catalog: let aqua = Color("aqua") // Looks in your app's main bundle by default. - Specify component values, like red, green, and blue; hue, saturation, and brightness; or white level: let skyBlue = Color(red: 0.4627, green: 0.8392, blue: 1.0) let lemonYellow = Color(hue: 0.1639, saturation: 1, brightness: 1) let steelGray = Color(white: 0.4745) - Create a color instance from another color, like a `UIColor` or an `NSColor`: #if os(iOS) let linkColor = Color(uiColor: .link) #elseif os(macOS) let linkColor = Color(nsColor: .linkColor) #endif - Use one of a palette of predefined colors, like `black`, `green`, and `purple`. Some view modifiers can take a color as an argument. For example, `foregroundStyle(_:)` uses the color you provide to set the foreground color for view elements, like text or SF Symbols: Image(systemName: "leaf.fill") .foregroundStyle(Color.green) Because SwiftUI treats colors as `View` instances, you can also directly add them to a view hierarchy. For example, you can layer a rectangle beneath a sun image using colors defined above: ZStack { skyBlue Image(systemName: "sun.max.fill") .foregroundStyle(lemonYellow) } .frame(width: 200, height: 100) A color used as a view expands to fill all the space it’s given, as defined by the frame of the enclosing `ZStack` in the above example: SwiftUI only resolves a color to a concrete value just before using it in a given environment. This enables a context-dependent appearance for system defined colors, or those that you load from an Asset Catalog. For example, a color can have distinct light and dark variants that the system chooses from at render time. ## Topics ### Creating a color `init(String, bundle: Bundle?)` Creates a color from a color set that you indicate by name. `init(_:)` Creates a constant color with the values specified by the resolved color. Evaluates this color to a resolved color given the current `context`. ### Creating a color from component values `init(hue: Double, saturation: Double, brightness: Double, opacity: Double)` Creates a constant color from hue, saturation, and brightness values. `init(Color.RGBColorSpace, white: Double, opacity: Double)` Creates a constant grayscale color. `init(Color.RGBColorSpace, red: Double, green: Double, blue: Double, opacity: Double)` Creates a constant color from red, green, and blue component values. `enum RGBColorSpace` A profile that specifies how to interpret a color value for display. ### Creating a color from another color `init(uiColor: UIColor)` Creates a color from a UIKit color. `init(nsColor: NSColor)` Creates a color from an AppKit color. `init(cgColor: CGColor)` Creates a color from a Core Graphics color. ### Getting standard colors `static let black: Color` A black color suitable for use in UI elements. `static let blue: Color` A context-dependent blue color suitable for use in UI elements. `static let brown: Color` A context-dependent brown color suitable for use in UI elements. `static let clear: Color` A clear color suitable for use in UI elements. `static let cyan: Color` A context-dependent cyan color suitable for use in UI elements. `static let gray: Color` A context-dependent gray color suitable for use in UI elements. `static let green: Color` A context-dependent green color suitable for use in UI elements. `static let indigo: Color` A context-dependent indigo color suitable for use in UI elements. `static let mint: Color` A context-dependent mint color suitable for use in UI elements. `static let orange: Color` A context-dependent orange color suitable for use in UI elements. `static let pink: Color` A context-dependent pink color suitable for use in UI elements. `static let purple: Color` A context-dependent purple color suitable for use in UI elements. `static let red: Color` A context-dependent red color suitable for use in UI elements. `static let teal: Color` A context-dependent teal color suitable for use in UI elements. `static let white: Color` A white color suitable for use in UI elements. `static let yellow: Color` A context-dependent yellow color suitable for use in UI elements. ### Getting semantic colors `static var accentColor: Color` A color that reflects the accent color of the system or app. `static let primary: Color` The color to use for primary content. `static let secondary: Color` The color to use for secondary content. ### Modifying a color Multiplies the opacity of the color by the given amount. `var gradient: AnyGradient` Returns the standard gradient for the color `self`. Returns a version of self mixed with `rhs` by the amount specified by `fraction`. Returns a new color with an exposure adjustment applied. Beta Creates a new color with specified HDR content headroom. ### Working with high dynamic range (HDR) colors Evaluates this color to a resolved color with content headroom, given a set of environment values. / `struct ResolvedHDR` A concrete color value, including HDR headroom information. ### Describing a color `var description: String` A textual representation of the color. ### Comparing colors Indicates whether two colors are equal. `func hash(into: inout Hasher)` Hashes the essential components of the color by feeding them into the given hash function. ### Deprecated symbols `var cgColor: CGColor?` A Core Graphics representation of the color, if available. Deprecated ## Relationships ### Conforms To - `Copyable` - `CustomStringConvertible` - `Equatable` - `Hashable` - `Sendable` - `SendableMetatype` - `ShapeStyle` - `Transferable` - `View` ## See Also ### Setting a color `func tint(_:)` Sets the tint color within this view. --- # https://developer.apple.com/documentation/swiftui/colorpicker - SwiftUI - ColorPicker Structure # ColorPicker A control used to select a color from the system color picker UI. ## Overview The color picker provides a color well that shows the currently selected color, and displays the larger system color picker that allows users to select a new color. By default color picker supports colors with opacity; to disable opacity support, set the `supportsOpacity` parameter to `false`. In this mode the color picker won’t show controls for adjusting the opacity of the selected color, and strips out opacity from any color set programmatically or selected from the user’s system favorites. You use `ColorPicker` by embedding it inside a view hierarchy and initializing it with a title string and a `Binding` to a `Color`: struct FormattingControls: View { @State private var bgColor = Color(.sRGB, red: 0.98, green: 0.9, blue: 0.2) var body: some View { VStack { ColorPicker("Alignment Guides", selection: $bgColor) } } } ## Topics ### Creating a color picker `init(_:selection:supportsOpacity:)` Creates a color picker with a text label generated from a title string key. `init(selection:supportsOpacity:label:)` Creates an instance that selects a color. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/containerrelativeshape - SwiftUI - ContainerRelativeShape Structure # ContainerRelativeShape A shape that is replaced by an inset version of the current container shape. If no container shape was defined, is replaced by a rectangle. @frozen struct ContainerRelativeShape ## Topics ### Creating the shape `init()` ## Relationships ### Conforms To - `Animatable` - `BitwiseCopyable` - `Copyable` - `InsettableShape` - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Setting a container shape Sets the container shape to use for any container relative shape within this view. `protocol InsettableShape` A shape type that is able to inset itself to produce another shape. --- # https://developer.apple.com/documentation/swiftui/contentunavailableview - SwiftUI - ContentUnavailableView Structure # ContentUnavailableView An interface, consisting of a label and additional content, that you display when the content of your app is unavailable to users. ## Overview It is recommended to use `ContentUnavailableView` in situations where a view’s content cannot be displayed. That could be caused by a network error, a list without items, a search that returns no results etc. You create an `ContentUnavailableView` in its simplest form, by providing a label and some additional content such as a description or a call to action: ContentUnavailableView { Label("No Mail", systemImage: "tray.fill") } description: { Text("New mails you receive will appear here.") } The system provides default `ContentUnavailableView` s that you can use in specific situations. The example below illustrates the usage of the `search` view: struct ContentView: View { @ObservedObject private var viewModel = ContactsViewModel() var body: some View { NavigationStack { List { ForEach(viewModel.searchResults) { contact in NavigationLink { ContactsView(contact) } label: { Text(contact.name) } } } .navigationTitle("Contacts") .searchable(text: $viewModel.searchText) .overlay { if searchResults.isEmpty { ContentUnavailableView.search } } } } } ## Topics ### Getting built-in unavailable views Creates a `ContentUnavailableView` instance that conveys a search state. ### Creating an unavailable view Creates an interface, consisting of a label and additional content, that you display when the content of your app is unavailable to users. `init(_:image:description:)` Creates an interface, consisting of a title generated from a localized string, an image and additional content, that you display when the content of your app is unavailable to users. `init(_:systemImage:description:)` Creates an interface, consisting of a title generated from a localized string, a system icon image and additional content, that you display when the content of your app is unavailable to users. ### Supporting types `struct SearchUnavailableContent` A structure that represents the body of a static placeholder search view. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/controlgroup - SwiftUI - ControlGroup Structure # ControlGroup A container view that displays semantically-related controls in a visually-appropriate manner for the context ## Mentioned in Populating SwiftUI menus with adaptive controls ## Overview You can provide an optional label to this view that describes its children. This view may be used in different ways depending on the surrounding context. For example, when you place the control group in a toolbar item, SwiftUI uses the label when the group is moved to the toolbar’s overflow menu. ContentView() .toolbar(id: "items") { ToolbarItem(id: "media") { ControlGroup { MediaButton() ChartButton() GraphButton() } label: { Label("Plus", systemImage: "plus") } } } ## Topics ### Creating a control group Creates a new ControlGroup with the specified children Creates a new control group with the specified content and a label. `init(_:content:)` Creates a new control group with the specified content that generates its label from a string. ### Creating a control group with an image `init(_:image:content:)` Creates a new control group with the specified content that generates its label from a string and image name. `init(_:systemImage:content:)` ### Creating a configured control group `init(ControlGroupStyleConfiguration)` Creates a control group based on a style configuration. ### Supporting types `struct LabeledControlGroupContent` A view that represents the body of a control group with a specified label. ## Relationships ### Conforms To - `View` ## See Also ### Presenting a group of controls Sets the style for control groups within this view. --- # https://developer.apple.com/documentation/swiftui/controlgroupstyleconfiguration/content-swift.struct - SwiftUI - ControlGroupStyleConfiguration - ControlGroupStyleConfiguration.Content Structure # ControlGroupStyleConfiguration.Content A type-erased content of a `ControlGroup`. @MainActor @preconcurrency struct Content ## Relationships ### Conforms To - `View` ## See Also ### Configuring the content `let content: ControlGroupStyleConfiguration.Content` A view that represents the content of the `ControlGroup`. --- # https://developer.apple.com/documentation/swiftui/controlgroupstyleconfiguration/label-swift.struct - SwiftUI - ControlGroupStyleConfiguration - ControlGroupStyleConfiguration.Label Structure # ControlGroupStyleConfiguration.Label A type-erased label of a `ControlGroup`. @MainActor @preconcurrency struct Label ## Relationships ### Conforms To - `View` ## See Also ### Configuring the label `let label: ControlGroupStyleConfiguration.Label` A view that provides the optional label of the `ControlGroup`. --- # https://developer.apple.com/documentation/swiftui/datepicker - SwiftUI - DatePicker Structure # DatePicker A control for selecting an absolute date. ## Mentioned in Laying out a simple view ## Overview Use a `DatePicker` when you want to provide a view that allows the user to select a calendar date, and optionally a time. The view binds to a `Date` instance. The following example creates a basic `DatePicker`, which appears on iOS as text representing the date. This example limits the display to only the calendar date, not the time. When the user taps or clicks the text, a calendar view animates in, from which the user can select a date. When the user dismisses the calendar view, the view updates the bound `Date`. @State private var date = Date() var body: some View { DatePicker( "Start Date", selection: $date, displayedComponents: [.date] ) } For cases where adding a subtitle to the label is desired, use a view builder that creates multiple `Text` views where the first text represents the title and the second text represents the subtitle: var body: some View { DatePicker(selection: $date) { Text("Start Date") Text("Select the starting date for the event") } } You can limit the `DatePicker` to specific ranges of dates, allowing selections only before or after a certain date, or between two dates. The following example shows a date-and-time picker that only permits selections within the year 2021 (in the `UTC` time zone). let calendar = Calendar.current let startComponents = DateComponents(year: 2021, month: 1, day: 1) let endComponents = DateComponents(year: 2021, month: 12, day: 31, hour: 23, minute: 59, second: 59) return calendar.date(from:startComponents)! ... calendar.date(from:endComponents)! }() var body: some View { DatePicker( "Start Date", selection: $date, in: dateRange, displayedComponents: [.date, .hourAndMinute] ) } ### Styling date pickers To use a different style of date picker, use the `datePickerStyle(_:)` view modifier. The following example shows the graphical date picker style. var body: some View { DatePicker( "Start Date", selection: $date, displayedComponents: [.date] ) .datePickerStyle(.graphical) } ## Topics ### Creating a date picker for any date `init(_:selection:displayedComponents:)` Creates an instance that selects a `Date` with an unbounded range. ### Creating a date picker for specific dates `init(_:selection:in:displayedComponents:)` Creates an instance that selects a `Date` in a closed range. `init(selection:in:displayedComponents:label:)` ### Setting date picker components `typealias Components` `struct DatePickerComponents` ## Relationships ### Conforms To - `View` ## See Also ### Choosing dates Sets the style for date pickers within this view. `struct MultiDatePicker` A control for picking multiple dates. `var calendar: Calendar` The current calendar that views should use when handling dates. `var timeZone: TimeZone` The current time zone that views should use when handling dates. --- # https://developer.apple.com/documentation/swiftui/datepickerstyleconfiguration/label-swift.struct - SwiftUI - DatePickerStyleConfiguration - DatePickerStyleConfiguration.Label Structure # DatePickerStyleConfiguration.Label A type-erased label of a `DatePicker`. @MainActor @preconcurrency struct Label ## Relationships ### Conforms To - `View` ## See Also ### Labeling the date picker `let label: DatePickerStyleConfiguration.Label` A description of the `DatePicker`. `var displayedComponents: DatePickerComponents` The date components that the user is able to view and edit. --- # https://developer.apple.com/documentation/swiftui/debugreplaceableview - SwiftUI - DebugReplaceableView Beta Structure # DebugReplaceableView Erases view opaque result types in debug builds. struct DebugReplaceableView ## Overview You don’t use this type directly. Instead SwiftUI creates this type on your behalf when building in debug mode. When in debug builds, SwiftUI will erase all opaque result types to `DebugReplaceableView`. This allows developer tools, such as Xcode Previews, to replace the definition of the view without fully rebuilding. As such, seeing this type in traces and the view debugger is expected when building for debugging. This type erasure can impact performance, especially when dealing with dynamic content (like content generated by a ForEach, or List) so any performance testing should be done in release mode. This type acts similarly to an `AnyView` in that it type-erases its content, however it depends on the underlying type of the value not actually changing as it is in place of an opaque result type. As such, it _should not be used in app code_. ## Topics ### Initializers Creates a debug replaceable view erasing the given view. Deprecated ## Relationships ### Conforms To - `View` Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/defaultbuttonlabel - SwiftUI - DefaultButtonLabel Beta Structure # DefaultButtonLabel The default label to use for a button. struct DefaultButtonLabel ## Overview You don’t use this type directly. Instead, the system creates it automatically when you construct certain types of `Button`. ## Relationships ### Conforms To - `View` ## See Also ### Indicating a value `struct Gauge` A view that shows a value within a range. Sets the style for gauges within this view. `struct ProgressView` A view that shows the progress toward completion of a task. Sets the style for progress views in this view. `struct DefaultDateProgressLabel` The default type of the current value label when used by a date-relative progress view. Beta Software This documentation contains preliminary information about an API or technology in development. This information is subject to change, and software implemented according to this documentation should be tested with final operating system software. Learn more about using Apple's beta software --- # https://developer.apple.com/documentation/swiftui/defaultdateprogresslabel - SwiftUI - DefaultDateProgressLabel Structure # DefaultDateProgressLabel The default type of the current value label when used by a date-relative progress view. struct DefaultDateProgressLabel ## Relationships ### Conforms To - `View` ## See Also ### Indicating a value `struct Gauge` A view that shows a value within a range. Sets the style for gauges within this view. `struct ProgressView` A view that shows the progress toward completion of a task. Sets the style for progress views in this view. `struct DefaultButtonLabel` The default label to use for a button. Beta --- # https://developer.apple.com/documentation/swiftui/defaultsettingslinklabel - SwiftUI - DefaultSettingsLinkLabel Structure # DefaultSettingsLinkLabel The default label to use for a settings link. struct DefaultSettingsLinkLabel ## Overview You don’t use this type directly. Instead, the system creates it automatically when you construct a `SettingsLink` with the default label. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/defaultsharelinklabel - SwiftUI - DefaultShareLinkLabel Structure # DefaultShareLinkLabel The default label used for a share link. struct DefaultShareLinkLabel ## Overview You don’t use this type directly. Instead, `ShareLink` uses it automatically depending on how you create a share link. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/defaulttablabel - SwiftUI - DefaultTabLabel Structure # DefaultTabLabel The default label to use for a tab or tab section. struct DefaultTabLabel ## Overview You don’t use this type directly. Instead, the system creates it automatically when you construct a `Tab` or `TabSection`. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/defaultwindowvisibilitytogglelabel --- # https://developer.apple.com/documentation/swiftui/disclosuregroup - SwiftUI - DisclosureGroup Structure # DisclosureGroup A view that shows or hides another content view, based on the state of a disclosure control. ## Mentioned in Displaying data in lists ## Overview A disclosure group view consists of a label to identify the contents, and a control to show and hide the contents. Showing the contents puts the disclosure group into the “expanded” state, and hiding them makes the disclosure group “collapsed”. In the following example, a disclosure group contains two toggles and an embedded disclosure group. The top level disclosure group exposes its expanded state with the bound property, `topLevelExpanded`. By expanding the disclosure group, the user can use the toggles to update the state of the `toggleStates` structure. struct ToggleStates { var oneIsOn: Bool = false var twoIsOn: Bool = true } @State private var toggleStates = ToggleStates() @State private var topExpanded: Bool = true var body: some View { DisclosureGroup("Items", isExpanded: $topExpanded) { Toggle("Toggle 1", isOn: $toggleStates.oneIsOn) Toggle("Toggle 2", isOn: $toggleStates.twoIsOn) DisclosureGroup("Sub-items") { Text("Sub-item 1") } } } ## Topics ### Creating a disclosure group `init(_:content:)` Creates a disclosure group, using a provided localized string key to create a text view for the label. Creates a disclosure group with the given label and content views. `init(_:isExpanded:content:)` Creates a disclosure group, using a provided localized string key to create a text view for the label, and a binding to the expansion state (expanded or collapsed). Creates a disclosure group with the given label and content views, and a binding to the expansion state (expanded or collapsed). ## Relationships ### Conforms To - `View` ## See Also ### Disclosing information progressively `struct OutlineGroup` A structure that computes views and disclosure groups on demand from an underlying collection of tree-structured, identified data. Sets the style for disclosure groups within this view. --- # https://developer.apple.com/documentation/swiftui/disclosuregroupstyleconfiguration/content-swift.struct - SwiftUI - DisclosureGroupStyleConfiguration - DisclosureGroupStyleConfiguration.Content Structure # DisclosureGroupStyleConfiguration.Content A type-erased content of a disclosure group. @MainActor @preconcurrency struct Content ## Relationships ### Conforms To - `View` ## See Also ### Configuring the content `let content: DisclosureGroupStyleConfiguration.Content` The content of the disclosure group. --- # https://developer.apple.com/documentation/swiftui/disclosuregroupstyleconfiguration/label-swift.struct - SwiftUI - DisclosureGroupStyleConfiguration - DisclosureGroupStyleConfiguration.Label Structure # DisclosureGroupStyleConfiguration.Label A type-erased label of a disclosure group. @MainActor @preconcurrency struct Label ## Relationships ### Conforms To - `View` ## See Also ### Configuring the label `let label: DisclosureGroupStyleConfiguration.Label` The label for the disclosure group. --- # https://developer.apple.com/documentation/swiftui/divider - SwiftUI - Divider Structure # Divider A visual element that can be used to separate other content. struct Divider ## Mentioned in Building layouts with stack views Populating SwiftUI menus with adaptive controls ## Overview When contained in a stack, the divider extends across the minor axis of the stack, or horizontally when not in a stack. ## Topics ### Creating a divider `init()` ## Relationships ### Conforms To - `View` ## See Also ### Separators `struct Spacer` A flexible space that expands along the major axis of its containing stack layout, or on both axes if not contained in a stack. --- # https://developer.apple.com/documentation/swiftui/editbutton - SwiftUI - EditButton Structure # EditButton A button that toggles the edit mode environment value. struct EditButton ## Overview An edit button toggles the environment’s `editMode` value for content within a container that supports edit mode. In the following example, an edit button placed inside a `NavigationView` supports editing of a `List`: @State private var fruits = [\ "Apple",\ "Banana",\ "Papaya",\ "Mango"\ ] var body: some View { NavigationView { List { ForEach(fruits, id: \.self) { fruit in Text(fruit) } .onDelete { fruits.remove(atOffsets: $0) } .onMove { fruits.move(fromOffsets: $0, toOffset: $1) } } .navigationTitle("Fruits") .toolbar { EditButton() } } } Because the `ForEach` in the above example defines behaviors for `onDelete(perform:)` and `onMove(perform:)`, the editable list displays the delete and move UI when the user taps Edit. Notice that the Edit button displays the title “Done” while edit mode is active: You can also create custom views that react to changes in the edit mode state, as described in `EditMode`. ## Topics ### Creating an edit button `init()` Creates an Edit button instance. ## Relationships ### Conforms To - `View` ## See Also ### Creating special-purpose buttons `struct PasteButton` A system button that reads items from the pasteboard and delivers it to a closure. `struct RenameButton` A button that triggers a standard rename action. --- # https://developer.apple.com/documentation/swiftui/editablecollectioncontent - SwiftUI - EditableCollectionContent Structure # EditableCollectionContent An opaque wrapper view that adds editing capabilities to a row in a list. ## Overview You don’t use this type directly. Instead SwiftUI creates this type on your behalf. ## Relationships ### Conforms To - `Copyable` - `View` Conforms when `Content` conforms to `View`, `Data` conforms to `Copyable`, and `Data` conforms to `Escapable`. ## See Also ### Editing a list Adds a condition for whether the view’s view hierarchy is movable. Adds a condition for whether the view’s view hierarchy is deletable. An indication of whether the user can edit the contents of a view associated with this environment. `enum EditMode` A mode that indicates whether the user can edit a view’s content. `struct EditActions` A set of edit actions on a collection of data that a view can offer to a user. `struct IndexedIdentifierCollection` A collection wrapper that iterates over the indices and identifiers of a collection together. --- # https://developer.apple.com/documentation/swiftui/ellipse - SwiftUI - Ellipse Structure # Ellipse An ellipse aligned inside the frame of the view containing it. @frozen struct Ellipse ## Topics ### Creating an ellipse `init()` Creates a new ellipse shape. ## Relationships ### Conforms To - `Animatable` - `BitwiseCopyable` - `Copyable` - `InsettableShape` - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Creating circular shapes `struct Circle` A circle centered on the frame of the view containing it. `struct Capsule` A capsule shape aligned inside the frame of the view containing it. --- # https://developer.apple.com/documentation/swiftui/ellipticalgradient - SwiftUI - EllipticalGradient Structure # EllipticalGradient A radial gradient that draws an ellipse. @frozen struct EllipticalGradient ## Overview The gradient maps its coordinate space to the unit space square in which its center and radii are defined, then stretches that square to fill its bounding rect, possibly also stretching the circular gradient to have elliptical contours. For example, an elliptical gradient centered on the view, filling its bounds: EllipticalGradient(gradient: .init(colors: [.red, .yellow])) When using an elliptical gradient as a shape style, you can also use `ellipticalGradient(_:center:startRadiusFraction:endRadiusFraction:)`. ## Topics ### Creating an elliptical gradient `init(gradient: Gradient, center: UnitPoint, startRadiusFraction: CGFloat, endRadiusFraction: CGFloat)` Creates an elliptical gradient. [`init(colors: [Color], center: UnitPoint, startRadiusFraction: CGFloat, endRadiusFraction: CGFloat)`](https://developer.apple.com/documentation/swiftui/ellipticalgradient/init(colors:center:startradiusfraction:endradiusfraction:)) Creates an elliptical gradient from a collection of colors. [`init(stops: [Gradient.Stop], center: UnitPoint, startRadiusFraction: CGFloat, endRadiusFraction: CGFloat)`](https://developer.apple.com/documentation/swiftui/ellipticalgradient/init(stops:center:startradiusfraction:endradiusfraction:)) Creates an elliptical gradient from a collection of color stops. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` - `ShapeStyle` - `View` ## See Also ### Supporting types `struct AngularGradient` An angular gradient. `struct LinearGradient` A linear gradient. `struct RadialGradient` A radial gradient. `struct Material` A background material type. `struct ImagePaint` A shape style that fills a shape by repeating a region of an image. `struct HierarchicalShapeStyle` A shape style that maps to one of the numbered content styles. `struct HierarchicalShapeStyleModifier` Styles that you can apply to hierarchical shapes. `struct ForegroundStyle` The foreground style in the current context. `struct BackgroundStyle` The background style in the current context. `struct SelectionShapeStyle` A style used to visually indicate selection following platform conventional colors and behaviors. `struct SeparatorShapeStyle` A style appropriate for foreground separator or border lines. `struct TintShapeStyle` A style that reflects the current tint color. `struct FillShapeStyle` A shape style that displays one of the overlay fills. `struct LinkShapeStyle` A style appropriate for links. `struct PlaceholderTextShapeStyle` A style appropriate for placeholder text. --- # https://developer.apple.com/documentation/swiftui/emptyview --- # https://developer.apple.com/documentation/swiftui/equatableview - SwiftUI - EquatableView Structure # EquatableView A view type that compares itself against its previous value and prevents its child updating if its new value is the same as its old value. @frozen ## Topics ### Creating an equatable view `init(content: Content)` `var content: Content` ## Relationships ### Conforms To - `View` ## See Also ### Supporting view types `struct AnyView` A type-erased view. `struct EmptyView` A view that doesn’t contain any content. `struct SubscriptionView` A view that subscribes to a publisher with an action. `struct TupleView` A View created from a swift tuple of View values. --- # https://developer.apple.com/documentation/swiftui/fillshapeview --- # https://developer.apple.com/documentation/swiftui/foreach - SwiftUI - ForEach Structure # ForEach A structure that computes views on demand from an underlying collection of identified data. ## Mentioned in Creating performant scrollable stacks Grouping data with lazy stack views Displaying data in lists Picking container views for your content ## Overview Use `ForEach` to provide views based on a `RandomAccessCollection` of some data type. Either the collection’s elements must conform to `Identifiable` or you need to provide an `id` parameter to the `ForEach` initializer. The following example creates a `NamedFont` type that conforms to `Identifiable`, and an array of this type called `namedFonts`. A `ForEach` instance iterates over the array, producing new `Text` instances that display examples of each SwiftUI `Font` style provided in the array. private struct NamedFont: Identifiable { let name: String let font: Font var id: String { name } } private let namedFonts: [NamedFont] = [\ NamedFont(name: "Large Title", font: .largeTitle),\ NamedFont(name: "Title", font: .title),\ NamedFont(name: "Headline", font: .headline),\ NamedFont(name: "Body", font: .body),\ NamedFont(name: "Caption", font: .caption)\ ] var body: some View { ForEach(namedFonts) { namedFont in Text(namedFont.name) .font(namedFont.font) } } Some containers like `List` or `LazyVStack` will query the elements within a for each lazily. To obtain maximal performance, ensure that the view created from each element in the collection represents a constant number of views. For example, the following view uses an if statement which means each element of the collection can represent either 1 or 0 views, a non-constant number. ForEach(namedFonts) { namedFont in if namedFont.name.count != 2 { Text(namedFont.name) } } You can make the above view represent a constant number of views by wrapping the condition in a `VStack`, an `HStack`, or a `ZStack`. ForEach(namedFonts) { namedFont in VStack { if namedFont.name.count != 2 { Text(namedFont.name) } } } When enabling the following launch argument, SwiftUI will log when it encounters a view that produces a non-constant number of views in these containers: -LogForEachSlowPath YES ## Topics ### Creating a collection `init(Data)` Creates an instance that uniquely identifies and creates table rows across updates based on the identity of the underlying data. `init(_:content:)` Creates an instance that uniquely identifies and creates map content across updates based on the identity of the underlying data. `init(_:id:content:)` Creates an instance that uniquely identifies and creates map content across updates based on the provided key path to the underlying data’s identifier. ### Creating an editable collection Creates an instance that uniquely identifies and creates views across updates based on the identity of the underlying data. ### Accessing content A function to create content on demand using the underlying data. `var data: Data` The collection of underlying identified data that SwiftUI uses to create views dynamically. ### Initializers Creates an instance that uniquely identifies and creates views across updates based on the sections of a given view. Creates an instance that uniquely identifies and creates views across updates based on the subviews of a given view. ## Relationships ### Conforms To - `AccessibilityRotorContent` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, and `Content` conforms to `AccessibilityRotorContent`. - `AttachmentContent` - `Chart3DContent` - `ChartContent` - `Copyable` - `DynamicMapContent` - `DynamicTableRowContent` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, and `Content` conforms to `TableRowContent`. - `DynamicViewContent` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, and `Content` conforms to `View`. - `MapContent` - `TabContent` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, and `Content` conforms to `TabContent`. - `TableRowContent` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, and `Content` conforms to `TableRowContent`. - `View` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, and `Content` conforms to `View`. ## See Also ### Iterating over dynamic data `struct ForEachSectionCollection` A collection which allows a view to be treated as a collection of its sections in a for each loop. `struct ForEachSubviewCollection` A collection which allows a view to be treated as a collection of its subviews in a for each loop. `protocol DynamicViewContent` A type of view that generates views from an underlying collection of data. --- # https://developer.apple.com/documentation/swiftui/form - SwiftUI - Form Structure # Form A container for grouping controls used for data entry, such as in settings or inspectors. ## Mentioned in Picking container views for your content Grouping data with lazy stack views ## Overview SwiftUI applies platform-appropriate styling to views contained inside a form, to group them together. Form-specific styling applies to things like buttons, toggles, labels, lists, and more. Keep in mind that these stylings may be platform-specific. For example, forms apppear as grouped lists on iOS, and as aligned vertical stacks on macOS. The following example shows a simple data entry form on iOS, grouped into two sections. The supporting types ( `NotifyMeAboutType` and `ProfileImageSize`) and state variables ( `notifyMeAbout`, `profileImageSize`, `playNotificationSounds`, and `sendReadReceipts`) are omitted for simplicity. var body: some View { NavigationView { Form { Section(header: Text("Notifications")) { Picker("Notify Me About", selection: $notifyMeAbout) { Text("Direct Messages").tag(NotifyMeAboutType.directMessages) Text("Mentions").tag(NotifyMeAboutType.mentions) Text("Anything").tag(NotifyMeAboutType.anything) } Toggle("Play notification sounds", isOn: $playNotificationSounds) Toggle("Send read receipts", isOn: $sendReadReceipts) } Section(header: Text("User Profiles")) { Picker("Profile Image Size", selection: $profileImageSize) { Text("Large").tag(ProfileImageSize.large) Text("Medium").tag(ProfileImageSize.medium) Text("Small").tag(ProfileImageSize.small) } Button("Clear Image Cache") {} } } } } On macOS, a similar form renders as a vertical stack. To adhere to macOS platform conventions, this version doesn’t use sections, and uses colons at the end of its labels. It also sets the picker to use the `inline` style, which produces radio buttons on macOS. var body: some View { Spacer() HStack { Spacer() Form { Picker("Notify Me About:", selection: $notifyMeAbout) { Text("Direct Messages").tag(NotifyMeAboutType.directMessages) Text("Mentions").tag(NotifyMeAboutType.mentions) Text("Anything").tag(NotifyMeAboutType.anything) } Toggle("Play notification sounds", isOn: $playNotificationSounds) Toggle("Send read receipts", isOn: $sendReadReceipts) Picker("Profile Image Size:", selection: $profileImageSize) { Text("Large").tag(ProfileImageSize.large) Text("Medium").tag(ProfileImageSize.medium) Text("Small").tag(ProfileImageSize.small) } .pickerStyle(.inline) Button("Clear Image Cache") {} } Spacer() } Spacer() } ## Topics ### Creating a form Creates a form with the provided content. ### Creating a form from a configuration `init(FormStyleConfiguration)` Creates a form based on a form style configuration. ## Relationships ### Conforms To - `View` ## See Also ### Grouping inputs Sets the style for forms in a view hierarchy. `struct LabeledContent` A container for attaching a label to a value-bearing view. Sets a style for labeled content. --- # https://developer.apple.com/documentation/swiftui/formstyleconfiguration/content-swift.struct - SwiftUI - FormStyleConfiguration - FormStyleConfiguration.Content Structure # FormStyleConfiguration.Content A type-erased content of a form. @MainActor @preconcurrency struct Content ## Relationships ### Conforms To - `View` ## See Also ### Getting configuration content `let content: FormStyleConfiguration.Content` A view that is the content of the form. --- # https://developer.apple.com/documentation/swiftui/gauge - SwiftUI - Gauge Structure # Gauge A view that shows a value within a range. ## Overview A gauge is a view that shows a current level of a value in relation to a specified finite capacity, very much like a fuel gauge in an automobile. Gauge displays are configurable; they can show any combination of the gauge’s current value, the range the gauge can display, and a label describing the purpose of the gauge itself. In its most basic form, a gauge displays a single value along the path of the gauge mapped into a range from 0 to 100 percent. The example below sets the gauge’s indicator to a position 40 percent along the gauge’s path: struct SimpleGauge: View { @State private var batteryLevel = 0.4 var body: some View { Gauge(value: batteryLevel) { Text("Battery Level") } } } You can make a gauge more descriptive by describing its purpose, showing its current value and its start and end values. This example shows the gauge variant that accepts a range and adds labels using multiple trailing closures describing the current value and the minimum and maximum values of the gauge: struct LabeledGauge: View { @State private var current = 67.0 @State private var minValue = 0.0 @State private var maxValue = 170.0 var body: some View { Gauge(value: current, in: minValue...maxValue) { Text("BPM") } currentValueLabel: { Text("\(Int(current))") } minimumValueLabel: { Text("\(Int(minValue))") } maximumValueLabel: { Text("\(Int(maxValue))") } } } As shown above, the default style for gauges is a linear, continuous bar with an indicator showing the current value, and optional labels describing the gauge’s purpose, current, minimum, and maximum values. To change the style of a gauge, use the `gaugeStyle(_:)` view modifier and supply an initializer for a specific gauge style. For example, to display the same gauge in a circular style, apply the `circular` style to the view: var body: some View { Gauge(value: current, in: minValue...maxValue) { Text("BPM") } currentValueLabel: { Text("\(Int(current))") } minimumValueLabel: { Text("\(Int(minValue))") } maximumValueLabel: { Text("\(Int(maxValue))") } .gaugeStyle(.circular) } } To style elements of a gauge’s presentation, you apply view modifiers to the elements that you want to change. In the example below, the current value, minimum and maximum value labels have custom colors: struct StyledGauge: View { @State private var current = 67.0 @State private var minValue = 50.0 @State private var maxValue = 170.0 var body: some View { Gauge(value: current, in: minValue...maxValue) { Image(systemName: "heart.fill") .foregroundColor(.red) } currentValueLabel: { Text("\(Int(current))") .foregroundColor(Color.green) } minimumValueLabel: { Text("\(Int(minValue))") .foregroundColor(Color.green) } maximumValueLabel: { Text("\(Int(maxValue))") .foregroundColor(Color.red) } .gaugeStyle(.circular) } } You can further style a gauge’s appearance by supplying a tint color or a gradient to the style’s initializer. The following example shows the effect of a gradient in the initialization of a `CircularGaugeStyle` gauge with a colorful gradient across the length of the gauge: struct StyledGauge: View { @State private var current = 67.0 @State private var minValue = 50.0 @State private var maxValue = 170.0 let gradient = Gradient(colors: [.green, .yellow, .orange, .red]) var body: some View { Gauge(value: current, in: minValue...maxValue) { Image(systemName: "heart.fill") .foregroundColor(.red) } currentValueLabel: { Text("\(Int(current))") .foregroundColor(Color.green) } minimumValueLabel: { Text("\(Int(minValue))") .foregroundColor(Color.green) } maximumValueLabel: { Text("\(Int(maxValue))") .foregroundColor(Color.red) } .gaugeStyle(CircularGaugeStyle(tint: gradient)) } } ## Topics ### Creating a gauge Creates a gauge showing a value within a range and describes the gauge’s purpose and current value. Creates a gauge showing a value within a range and that describes the gauge’s purpose and current value. Creates a gauge representing a value within a range. Creates a gauge showing a value within a range and describes the gauge’s current, minimum, and maximum values. ## Relationships ### Conforms To - `View` ## See Also ### Indicating a value Sets the style for gauges within this view. `struct ProgressView` A view that shows the progress toward completion of a task. Sets the style for progress views in this view. `struct DefaultDateProgressLabel` The default type of the current value label when used by a date-relative progress view. `struct DefaultButtonLabel` The default label to use for a button. Beta --- # https://developer.apple.com/documentation/swiftui/gaugestyleconfiguration/currentvaluelabel-swift.struct - SwiftUI - GaugeStyleConfiguration - GaugeStyleConfiguration.CurrentValueLabel Structure # GaugeStyleConfiguration.CurrentValueLabel A type-erased value label of a gauge that contains the current value. @MainActor @preconcurrency struct CurrentValueLabel ## Relationships ### Conforms To - `View` ## See Also ### Setting the value `var value: Double` The current value of the gauge. `var currentValueLabel: GaugeStyleConfiguration.CurrentValueLabel?` A view that describes the current value. `struct MarkedValueLabel` A type-erased label describing a specific value of a gauge. --- # https://developer.apple.com/documentation/swiftui/gaugestyleconfiguration/label-swift.struct - SwiftUI - GaugeStyleConfiguration - GaugeStyleConfiguration.Label Structure # GaugeStyleConfiguration.Label A type-erased label of a gauge, describing its purpose. @MainActor @preconcurrency struct Label ## Relationships ### Conforms To - `View` ## See Also ### Describing the purpose of the gauge `var label: GaugeStyleConfiguration.Label` A view that describes the purpose of the gauge. --- # https://developer.apple.com/documentation/swiftui/gaugestyleconfiguration/markedvaluelabel - SwiftUI - GaugeStyleConfiguration - GaugeStyleConfiguration.MarkedValueLabel Structure # GaugeStyleConfiguration.MarkedValueLabel A type-erased label describing a specific value of a gauge. @MainActor @preconcurrency struct MarkedValueLabel ## Relationships ### Conforms To - `View` ## See Also ### Setting the value `var value: Double` The current value of the gauge. `var currentValueLabel: GaugeStyleConfiguration.CurrentValueLabel?` A view that describes the current value. `struct CurrentValueLabel` A type-erased value label of a gauge that contains the current value. --- # https://developer.apple.com/documentation/swiftui/gaugestyleconfiguration/maximumvaluelabel-swift.struct - SwiftUI - GaugeStyleConfiguration - GaugeStyleConfiguration.MaximumValueLabel Structure # GaugeStyleConfiguration.MaximumValueLabel A type-erased value label of a gauge describing the maximum value. @MainActor @preconcurrency struct MaximumValueLabel ## Relationships ### Conforms To - `View` ## See Also ### Reporting the range `var minimumValueLabel: GaugeStyleConfiguration.MinimumValueLabel?` A view that describes the minimum of the range for the current value. `struct MinimumValueLabel` A type-erased value label of a gauge describing the minimum value. `var maximumValueLabel: GaugeStyleConfiguration.MaximumValueLabel?` A view that describes the maximum of the range for the current value. --- # https://developer.apple.com/documentation/swiftui/gaugestyleconfiguration/minimumvaluelabel-swift.struct - SwiftUI - GaugeStyleConfiguration - GaugeStyleConfiguration.MinimumValueLabel Structure # GaugeStyleConfiguration.MinimumValueLabel A type-erased value label of a gauge describing the minimum value. @MainActor @preconcurrency struct MinimumValueLabel ## Relationships ### Conforms To - `View` ## See Also ### Reporting the range `var minimumValueLabel: GaugeStyleConfiguration.MinimumValueLabel?` A view that describes the minimum of the range for the current value. `var maximumValueLabel: GaugeStyleConfiguration.MaximumValueLabel?` A view that describes the maximum of the range for the current value. `struct MaximumValueLabel` A type-erased value label of a gauge describing the maximum value. --- # https://developer.apple.com/documentation/swiftui/geometryreader - SwiftUI - GeometryReader Structure # GeometryReader A container view that defines its content as a function of its own size and coordinate space. @frozen ## Overview This view returns a flexible preferred size to its parent layout. ## Topics ## Relationships ### Conforms To - `View` ## See Also ### Measuring a view `struct GeometryReader3D` `struct GeometryProxy` A proxy for access to the size and coordinate space (for anchor resolution) of the container view. `struct GeometryProxy3D` A proxy for access to the size and coordinate space of the container view. Assigns a name to the view’s coordinate space, so other code can operate on dimensions like points and sizes relative to the named space. `enum CoordinateSpace` A resolved coordinate space created by the coordinate space protocol. `protocol CoordinateSpaceProtocol` A frame of reference within the layout system. `struct PhysicalMetric` Provides access to a value in points that corresponds to the specified physical measurement. `struct PhysicalMetricsConverter` A physical metrics converter provides conversion between point values and their extent in 3D space, in the form of physical length measurements. --- # https://developer.apple.com/documentation/swiftui/geometryreader3d - SwiftUI - GeometryReader3D Structure # GeometryReader3D A container view that defines its content as a function of its own size and coordinate space. @frozen ## Overview This view returns a flexible preferred size to its own container view. This container differs from `GeometryReader` in that it also reads available depth, and thus also returns a flexible preferred depth to its parent layout. Use the 3D version only in situations where you need to read depth, because it affects depth layout when used in a container like a `ZStack`. ## Topics ## Relationships ### Conforms To - `View` ## See Also ### Measuring a view `struct GeometryReader` `struct GeometryProxy` A proxy for access to the size and coordinate space (for anchor resolution) of the container view. `struct GeometryProxy3D` A proxy for access to the size and coordinate space of the container view. Assigns a name to the view’s coordinate space, so other code can operate on dimensions like points and sizes relative to the named space. `enum CoordinateSpace` A resolved coordinate space created by the coordinate space protocol. `protocol CoordinateSpaceProtocol` A frame of reference within the layout system. `struct PhysicalMetric` Provides access to a value in points that corresponds to the specified physical measurement. `struct PhysicalMetricsConverter` A physical metrics converter provides conversion between point values and their extent in 3D space, in the form of physical length measurements. --- # https://developer.apple.com/documentation/swiftui/glassbackgroundeffectconfiguration/content-swift.struct - SwiftUI - GlassBackgroundEffectConfiguration - GlassBackgroundEffectConfiguration.Content Structure # GlassBackgroundEffectConfiguration.Content A type-erased content of a glass background. @MainActor @preconcurrency struct Content ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` - `View` --- # https://developer.apple.com/documentation/swiftui/grid - SwiftUI - Grid Structure # Grid A container view that arranges other views in a two dimensional layout. @frozen ## Overview Create a two dimensional layout by initializing a `Grid` with a collection of `GridRow` structures. The first view in each grid row appears in the grid’s first column, the second view in the second column, and so on. The following example creates a grid with two rows and two columns: Grid { GridRow { Text("Hello") Image(systemName: "globe") } GridRow { Image(systemName: "hand.wave") Text("World") } } A grid and its rows behave something like a collection of `HStack` instances wrapped in a `VStack`. However, the grid handles row and column creation as a single operation, which applies alignment and spacing to cells, rather than first to rows and then to a column of unrelated rows. The grid produced by the example above demonstrates this: ### Multicolumn cells If you provide a view rather than a `GridRow` as an element in the grid’s content, the grid uses the view to create a row that spans all of the grid’s columns. For example, you can add a `Divider` between the rows of the previous example: Grid { GridRow { Text("Hello") Image(systemName: "globe") } Divider() GridRow { Image(systemName: "hand.wave") Text("World") } } Because a divider takes as much horizontal space as its parent offers, the entire grid widens to fill the width offered by its parent view. To prevent a flexible view from taking more space on a given axis than the other cells in a row or column require, add the `gridCellUnsizedAxes(_:)` view modifier to the view: Divider() .gridCellUnsizedAxes(.horizontal) This restores the grid to the width that the text and images require: To make a cell span a specific number of columns rather than the whole grid, use the `gridCellColumns(_:)` modifier on a view that’s contained inside a `GridRow`. ### Column count The grid’s column count grows to handle the row with the largest number of columns. If you create rows with different numbers of columns, the grid adds empty cells to the trailing edge of rows that have fewer columns. The example below creates three rows with different column counts: Grid { GridRow { Text("Row 1") ForEach(0..<2) { _ in Color.red } } GridRow { Text("Row 2") ForEach(0..<5) { _ in Color.green } } GridRow { Text("Row 3") ForEach(0..<4) { _ in Color.blue } } } The resulting grid has as many columns as the widest row, adding empty cells to rows that don’t specify enough views: The grid sets the width of all the cells in a column to match the needs of column’s widest cell. In the example above, the width of the first column depends on the width of the widest `Text` view that the column contains. The other columns, which contain flexible `Color` views, share the remaining horizontal space offered by the grid’s parent view equally. Similarly, the tallest cell in a row sets the height of the entire row. The cells in the first column of the grid above need only the height required for each string, but the `Color` cells expand to equally share the total height available to the grid. As a result, the color cells determine the row heights. ### Cell spacing and alignment You can control the spacing between cells in both the horizontal and vertical dimensions and set a default alignment for the content in all the grid cells when you initialize the grid using the `init(alignment:horizontalSpacing:verticalSpacing:content:)` initializer. Consider a modified version of the previous example: Grid(alignment: .bottom, horizontalSpacing: 1, verticalSpacing: 1) { // ... } This configuration causes all of the cells to use `bottom` alignment — which only affects the text cells because the colors fill their cells completely — and it reduces the spacing between cells: You can override the alignment of specific cells or groups of cells. For example, you can change the horizontal alignment of the cells in a column by adding the `gridColumnAlignment(_:)` modifier, or the vertical alignment of the cells in a row by configuring the row’s `init(alignment:content:)` initializer. You can also align a single cell with the `gridCellAnchor(_:)` modifier. ### Performance considerations A grid can size its rows and columns correctly because it renders all of its child views immediately. If your app exhibits poor performance when it first displays a large grid that appears inside a `ScrollView`, consider switching to a `LazyVGrid` or `LazyHGrid` instead. Lazy grids render their cells when SwiftUI needs to display them, rather than all at once. This reduces the initial cost of displaying a large scrollable grid that’s never fully visible, but also reduces the grid’s ability to optimally lay out cells. Switch to a lazy grid only if profiling your code shows a worthwhile performance improvement. ## Topics ### Creating a grid Creates a grid with the specified spacing, alignment, and child views. ## Relationships ### Conforms To - `Copyable` - `View` Conforms when `Content` conforms to `View`. ## See Also ### Statically arranging views in two dimensions `struct GridRow` A horizontal row in a two dimensional grid container. Tells a view that acts as a cell in a grid to span the specified number of columns. Specifies a custom alignment anchor for a view that acts as a grid cell. Asks grid layouts not to offer the view extra size in the specified axes. Overrides the default horizontal alignment of the grid column that the view appears in. --- # https://developer.apple.com/documentation/swiftui/gridrow - SwiftUI - GridRow Structure # GridRow A horizontal row in a two dimensional grid container. @frozen ## Overview Use one or more `GridRow` instances to define the rows of a `Grid` container. The child views inside the row define successive grid cells. You can add rows to the grid explicitly, or use the `ForEach` structure to generate multiple rows. Similarly, you can add cells to the row explicitly or you can use `ForEach` to generate multiple cells inside the row. The following example mixes these strategies: Grid { GridRow { Color.clear .gridCellUnsizedAxes([.horizontal, .vertical]) ForEach(1..<4) { column in Text("C\(column)") } } ForEach(1..<4) { row in GridRow { Text("R\(row)") ForEach(1..<4) { _ in Circle().foregroundStyle(.mint) } } } } The grid in the example above has an explicit first row and three generated rows. Similarly, each row has an explicit first cell and three generated cells: To create an empty cell, use something invisible, like the `clear` color that appears in the first column of the first row in the example above. However, if you use a flexible view like a `Color` or a `Spacer`, you might also need to add the `gridCellUnsizedAxes(_:)` modifier to prevent the view from taking up more space than the other cells in the row or column need. By default, the cells in the row use the `Alignment` that you define when you initialize the `Grid`. However, you can override the vertical alignment for the cells in a row by providing a `VerticalAlignment` value to the row’s `init(alignment:content:)` initializer. If you apply a view modifier to a row, the row applies the modifier to all of the cells, similar to how a `Group` behaves. For example, if you apply the `border(_:width:)` modifier to a row, SwiftUI draws a border on each cell in the row rather than around the row. ## Topics ### Creating a grid row Creates a horizontal row of child views in a grid. ## Relationships ### Conforms To - `Copyable` - `View` Conforms when `Content` conforms to `View`. ## See Also ### Statically arranging views in two dimensions `struct Grid` A container view that arranges other views in a two dimensional layout. Tells a view that acts as a cell in a grid to span the specified number of columns. Specifies a custom alignment anchor for a view that acts as a grid cell. Asks grid layouts not to offer the view extra size in the specified axes. Overrides the default horizontal alignment of the grid column that the view appears in. --- # https://developer.apple.com/documentation/swiftui/group - SwiftUI - Group Structure # Group A type that collects multiple instances of a content type — like views, scenes, or commands — into a single unit. @frozen ## Overview Use a group to collect multiple views into a single instance, without affecting the layout of those views, like an `HStack`, `VStack`, or `Section` would. After creating a group, any modifier you apply to the group affects all of that group’s members. For example, the following code applies the `headline` font to three views in a group. Group { Text("SwiftUI") Text("Combine") Text("Swift System") } .font(.headline) Because you create a group of views with a `ViewBuilder`, you can use the group’s initializer to produce different kinds of views from a conditional, and then optionally apply modifiers to them. The following example uses a `Group` to add a navigation bar title, regardless of the type of view the conditional produces: Group { if isLoggedIn { WelcomeView() } else { LoginView() } } .navigationBarTitle("Start") The modifier applies to all members of the group — and not to the group itself. For example, if you apply `onAppear(perform:)` to the above group, it applies to all of the views produced by the `if isLoggedIn` conditional, and it executes every time `isLoggedIn` changes. Because a group of views itself is a view, you can compose a group within other view builders, including nesting within other groups. This allows you to add large numbers of views to different view builder containers. The following example uses a `Group` to collect 10 `Text` instances, meaning that the vertical stack’s view builder returns only two views — the group, plus an additional `Text`: var body: some View { VStack { Group { Text("1") Text("2") Text("3") Text("4") Text("5") Text("6") Text("7") Text("8") Text("9") Text("10") } Text("11") } } You can initialize groups with several types other than `View`, such as `Scene` and `ToolbarContent`. The closure you provide to the group initializer uses the corresponding builder type ( `SceneBuilder`, `ToolbarContentBuilder`, and so on), and the capabilities of these builders vary between types. For example, you can use groups to return large numbers of scenes or toolbar content instances, but not to return different scenes or toolbar content based on conditionals. ## Topics ### Creating a group `init(content:)` Creates an instance that generates Rotor content by combining, in order, all the Rotor content specified in the passed-in result builder. ### Initializers Constructs a group from the sections of the given view. Constructs a group from the subviews of the given view. ## Relationships ### Conforms To - `AccessibilityRotorContent` Conforms when `Content` conforms to `AccessibilityRotorContent`. - `Commands` Conforms when `Content` conforms to `Commands`. - `Copyable` - `CustomizableToolbarContent` Conforms when `Content` conforms to `CustomizableToolbarContent`. - `MapContent` - `Scene` Conforms when `Content` conforms to `Scene`. - `TabContent` Conforms when `Content` conforms to `TabContent`. - `TableColumnContent` Conforms when `Content` conforms to `TableColumnContent`. - `TableRowContent` Conforms when `Content` conforms to `TableRowContent`. - `ToolbarContent` Conforms when `Content` conforms to `ToolbarContent`. - `View` Conforms when `Content` conforms to `View`. ## See Also ### Grouping views into a container Creating custom container views Access individual subviews to compose flexible container views. `struct GroupElementsOfContent` Transforms the subviews of a given view into a resulting content view. `struct GroupSectionsOfContent` Transforms the sections of a given view into a resulting content view. --- # https://developer.apple.com/documentation/swiftui/groupbox - SwiftUI - GroupBox Structure # GroupBox A stylized view, with an optional label, that visually collects a logical grouping of content. ## Overview Use a group box when you want to visually distinguish a portion of your user interface with an optional title for the boxed content. The following example sets up a `GroupBox` with the label “End-User Agreement”, and a long `agreementText` string in a `Text` view wrapped by a `ScrollView`. The box also contains a `Toggle` for the user to interact with after reading the text. var body: some View { GroupBox(label: Label("End-User Agreement", systemImage: "building.columns") ) { ScrollView(.vertical, showsIndicators: true) { Text(agreementText) .font(.footnote) } .frame(height: 100) Toggle(isOn: $userAgreed) { Text("I agree to the above terms") } } } ## Topics ### Creating a group box Creates an unlabeled group box with the provided view content. Creates a group box with the provided label and view content. `init(_:content:)` Creates a group box with the provided view content and title. ### Creating a group box from a configuration `init(GroupBoxStyleConfiguration)` Creates a group box based on a style configuration. ## Relationships ### Conforms To - `View` ## See Also ### Grouping views into a box Sets the style for group boxes within this view. --- # https://developer.apple.com/documentation/swiftui/groupboxstyleconfiguration/content-swift.struct - SwiftUI - GroupBoxStyleConfiguration - GroupBoxStyleConfiguration.Content Structure # GroupBoxStyleConfiguration.Content A type-erased content of a group box. @MainActor @preconcurrency struct Content ## Relationships ### Conforms To - `View` ## See Also ### Configuring the content `let content: GroupBoxStyleConfiguration.Content` A view that represents the content of the group box. --- # https://developer.apple.com/documentation/swiftui/groupboxstyleconfiguration/label-swift.struct --- # https://developer.apple.com/documentation/swiftui/groupelementsofcontent - SwiftUI - GroupElementsOfContent Structure # GroupElementsOfContent Transforms the subviews of a given view into a resulting content view. ## Overview You don’t use this type directly. Instead SwiftUI creates this type on your behalf. ## Relationships ### Conforms To - `View` ## See Also ### Grouping views into a container Creating custom container views Access individual subviews to compose flexible container views. `struct Group` A type that collects multiple instances of a content type — like views, scenes, or commands — into a single unit. `struct GroupSectionsOfContent` Transforms the sections of a given view into a resulting content view. --- # https://developer.apple.com/documentation/swiftui/groupsectionsofcontent - SwiftUI - GroupSectionsOfContent Structure # GroupSectionsOfContent Transforms the sections of a given view into a resulting content view. ## Overview You don’t use this type directly. Instead SwiftUI creates this type on your behalf. ## Relationships ### Conforms To - `View` ## See Also ### Grouping views into a container Creating custom container views Access individual subviews to compose flexible container views. `struct Group` A type that collects multiple instances of a content type — like views, scenes, or commands — into a single unit. `struct GroupElementsOfContent` Transforms the subviews of a given view into a resulting content view. --- # https://developer.apple.com/documentation/swiftui/hstack - SwiftUI - HStack Structure # HStack A view that arranges its subviews in a horizontal line. @frozen ## Mentioned in Laying out a simple view Building layouts with stack views Creating performant scrollable stacks Aligning views within a stack Aligning views across stacks ## Overview Unlike `LazyHStack`, which only renders the views when your app needs to display them onscreen, an `HStack` renders the views all at once, regardless of whether they are on- or offscreen. Use the regular `HStack` when you have a small number of subviews or don’t want the delayed rendering behavior of the “lazy” version. The following example shows a simple horizontal stack of five text views: var body: some View { HStack( alignment: .top, spacing: 10 ) { ForEach( 1...5, id: \.self ) { Text("Item \($0)") } } } ## Topics ### Creating a stack Creates a horizontal stack with the given spacing and vertical alignment. ## Relationships ### Conforms To - `View` ## See Also ### Statically arranging views in one dimension Compose complex layouts from primitive container views. `struct VStack` A view that arranges its subviews in a vertical line. --- # https://developer.apple.com/documentation/swiftui/helplink - SwiftUI - HelpLink Structure # HelpLink A button with a standard appearance that opens app-specific help documentation. struct HelpLink ## Overview A help link opens documentation relevant to the context where they are used. Typically this is by opening to an anchor in an Apple Help book, but can also perform an arbitrary action such as opening a URL or opening a window. HelpLink(anchor: "accountSetupHelp") HelpLink { openURL(onlineHelpURL) } Help links have a standard appearance, as well as conventional placement within a view. When used within an alert or confirmation dialog’s actions, the help link will automatically be placed in the top trailing corner. Or when used in a sheet toolbar, the help link is automatically placed in the lower leading corner. struct SheetContentView: View { var body: some View { Form { ... } .toolbar { ToolbarItem(.confirmationAction) { Button("Save") { ... } } ToolbarItem(.cancellationAction) { Button("Cancel") { ... } } ToolbarItem { HelpLink(anchor: "sheetHelp") } } } } ## Topics ### Creating a help link Constructs a new help link with the specified action. `init(destination: URL)` Constructs a new help link that opens the specified destination URL. `init(anchor: NSHelpManager.AnchorName)` Constructs a new help link with the specified anchor in the main app bundle’s book. `init(anchor: NSHelpManager.AnchorName, book: NSHelpManager.BookName)` Constructs a new help link with the specified anchor and book. ## Relationships ### Conforms To - `View` ## See Also ### Linking to other content `struct Link` A control for navigating to a URL. `struct ShareLink` A view that controls a sharing presentation. `struct SharePreview` A representation of a type to display in a share preview. `struct TextFieldLink` A control that requests text input from the user when pressed. --- # https://developer.apple.com/documentation/swiftui/keyframeanimator - SwiftUI - KeyframeAnimator Structure # KeyframeAnimator A container that animates its content with keyframes. ## Overview The `content` closure updates every frame while animating, so avoid performing any expensive operations directly within `content`. ## Topics ### Creating a phase animator Loops the given keyframes continuously, updating the view using the modifiers you apply in `body`. Plays the given keyframes when the given trigger value changes, updating the view using the modifiers you apply in `body`. ## Relationships ### Conforms To - `View` ## See Also ### Creating keyframe-based animation `protocol Keyframes` A type that defines changes to a value over time. `struct KeyframeTimeline` A description of how a value changes over time, modeled using keyframes. `struct KeyframeTrack` A sequence of keyframes animating a single property of a root type. `struct KeyframeTrackContentBuilder` The builder that creates keyframe track content from the keyframes that you define within a closure. `struct KeyframesBuilder` A builder that combines keyframe content values into a single value. `protocol KeyframeTrackContent` A group of keyframes that define an interpolation curve of an animatable value. `struct CubicKeyframe` A keyframe that uses a cubic curve to smoothly interpolate between values. `struct LinearKeyframe` A keyframe that uses simple linear interpolation. `struct MoveKeyframe` A keyframe that immediately moves to the given value without interpolating. `struct SpringKeyframe` A keyframe that uses a spring function to interpolate to the given value. --- # https://developer.apple.com/documentation/swiftui/label - SwiftUI - Label Structure # Label A standard label for user interface items, consisting of an icon with a title. ## Mentioned in Performing a search operation Preparing views for localization Populating SwiftUI menus with adaptive controls ## Overview One of the most common and recognizable user interface components is the combination of an icon and a label. This idiom appears across many kinds of apps and shows up in collections, lists, menus of action items, and disclosable lists, just to name a few. You create a label, in its simplest form, by providing a title and the name of an image, such as an icon from the SF Symbols collection: Label("Lightning", systemImage: "bolt.fill") You can also apply styles to labels in several ways. In the case of dynamic changes to the view after device rotation or change to a window size you might want to show only the text portion of the label using the `titleOnly` label style: Label("Lightning", systemImage: "bolt.fill") .labelStyle(.titleOnly) Conversely, there’s also an icon-only label style: Label("Lightning", systemImage: "bolt.fill") .labelStyle(.iconOnly) Some containers might apply a different default label style, such as only showing icons within toolbars on macOS and iOS. To opt in to showing both the title and the icon, you can apply the `titleAndIcon` label style: Label("Lightning", systemImage: "bolt.fill") .labelStyle(.titleAndIcon) You can also create a customized label style by modifying an existing style; this example adds a red border to the default label style: struct RedBorderedLabelStyle: LabelStyle { Label(configuration) .border(Color.red) } } For more extensive customization or to create a completely new label style, you’ll need to adopt the `LabelStyle` protocol and implement a `LabelStyleConfiguration` for the new style. To apply a common label style to a group of labels, apply the style to the view hierarchy that contains the labels: VStack { Label("Rain", systemImage: "cloud.rain") Label("Snow", systemImage: "snow") Label("Sun", systemImage: "sun.max") } .labelStyle(.iconOnly) It’s also possible to make labels using views to compose the label’s icon programmatically, rather than using a pre-made image. In this example, the icon portion of the label uses a filled `Circle` overlaid with the user’s initials: Label { Text(person.fullName) .font(.body) .foregroundColor(.primary) Text(person.title) .font(.subheadline) .foregroundColor(.secondary) } icon: { Circle() .fill(person.profileColor) .frame(width: 44, height: 44, alignment: .center) .overlay(Text(person.initials)) } ## Topics ### Creating a label `init(_:image:)` Creates a label with an icon image and a title generated from a localized string. `init(_:systemImage:)` Creates a label with a system icon image and a title generated from a localized string. Creates a label with a custom title and icon. `init(_:)` Creates a label representing a family activity application. ## Relationships ### Conforms To - `View` ## See Also ### Displaying text `struct Text` A view that displays one or more lines of read-only text. Sets the style for labels within this view. --- # https://developer.apple.com/documentation/swiftui/labelstyleconfiguration/icon-swift.struct - SwiftUI - LabelStyleConfiguration - LabelStyleConfiguration.Icon Structure # LabelStyleConfiguration.Icon A type-erased icon view of a label. @MainActor @preconcurrency struct Icon ## Relationships ### Conforms To - `Copyable` - `View` ## See Also ### Setting the icon `var icon: LabelStyleConfiguration.Icon` A symbolic representation of the labeled item. --- # https://developer.apple.com/documentation/swiftui/labelstyleconfiguration/title-swift.struct - SwiftUI - LabelStyleConfiguration - LabelStyleConfiguration.Title Structure # LabelStyleConfiguration.Title A type-erased title view of a label. @MainActor @preconcurrency struct Title ## Relationships ### Conforms To - `Copyable` - `View` ## See Also ### Setting the title `var title: LabelStyleConfiguration.Title` A description of the labeled item. --- # https://developer.apple.com/documentation/swiftui/labeledcontent --- # https://developer.apple.com/documentation/swiftui/labeledcontentstyleconfiguration/content-swift.struct - SwiftUI - LabeledContentStyleConfiguration - LabeledContentStyleConfiguration.Content Structure # LabeledContentStyleConfiguration.Content A type-erased content of a labeled content instance. @MainActor @preconcurrency struct Content ## Relationships ### Conforms To - `View` ## See Also ### Configuring the content `let content: LabeledContentStyleConfiguration.Content` The content of the labeled content instance. --- # https://developer.apple.com/documentation/swiftui/labeledcontentstyleconfiguration/label-swift.struct - SwiftUI - LabeledContentStyleConfiguration - LabeledContentStyleConfiguration.Label Structure # LabeledContentStyleConfiguration.Label A type-erased label of a labeled content instance. @MainActor @preconcurrency struct Label ## Relationships ### Conforms To - `View` ## See Also ### Configuring the label `let label: LabeledContentStyleConfiguration.Label` The label of the labeled content instance. --- # https://developer.apple.com/documentation/swiftui/labeledcontrolgroupcontent - SwiftUI - LabeledControlGroupContent Structure # LabeledControlGroupContent A view that represents the body of a control group with a specified label. ## Overview You don’t create this type directly. SwiftUI creates it when you build a `ControlGroup`. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/labeledtoolbaritemgroupcontent - SwiftUI - LabeledToolbarItemGroupContent Structure # LabeledToolbarItemGroupContent A view that represents the view of a toolbar item group with a specified label. ## Overview You don’t create this type directly. SwiftUI creates it when you build a `ToolbarItemGroup`. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/lazyhgrid - SwiftUI - LazyHGrid Structure # LazyHGrid A container view that arranges its child views in a grid that grows horizontally, creating items only as needed. ## Mentioned in Picking container views for your content ## Overview Use a lazy horizontal grid when you want to display a large, horizontally scrollable collection of views arranged in a two dimensional layout. The first view that you provide to the grid’s `content` closure appears in the top row of the column that’s on the grid’s leading edge. Additional views occupy successive cells in the grid, filling the first column from top to bottom, then the second column, and so on. The number of columns can grow unbounded, but you specify the number of rows by providing a corresponding number of `GridItem` instances to the grid’s initializer. The grid in the following example defines two rows and uses a `ForEach` structure to repeatedly generate a pair of `Text` views for the rows in each column: struct HorizontalSmileys: View { let rows = [GridItem(.fixed(30)), GridItem(.fixed(30))] var body: some View { ScrollView(.horizontal) { LazyHGrid(rows: rows) { ForEach(0x1f600...0x1f679, id: \.self) { value in Text(String(format: "%x", value)) Text(emoji(value)) .font(.largeTitle) } } } } guard let scalar = UnicodeScalar(value) else { return "?" } return String(Character(scalar)) } } For each column in the grid, the top row shows a Unicode code point from the “Smileys” group, and the bottom shows its corresponding emoji: You can achieve a similar layout using a `Grid` container. Unlike a lazy grid, which creates child views only when SwiftUI needs to display them, a regular grid creates all of its child views right away. This enables the grid to provide better support for cell spacing and alignment. Only use a lazy grid if profiling your app shows that a `Grid` view performs poorly because it tries to load too many views at once. ## Topics ### Creating a horizontal grid Creates a grid that grows horizontally. ## Relationships ### Conforms To - `View` ## See Also ### Dynamically arranging views in two dimensions `struct LazyVGrid` A container view that arranges its child views in a grid that grows vertically, creating items only as needed. `struct GridItem` A description of a row or a column in a lazy grid. --- # https://developer.apple.com/documentation/swiftui/lazyhstack - SwiftUI - LazyHStack Structure # LazyHStack A view that arranges its children in a line that grows horizontally, creating items only as needed. ## Mentioned in Picking container views for your content Grouping data with lazy stack views Creating performant scrollable stacks ## Overview The stack is “lazy,” in that the stack view doesn’t create items until it needs to render them onscreen. In the following example, a `ScrollView` contains a `LazyHStack` that consists of a horizontal row of text views. The stack aligns to the top of the scroll view and uses 10-point spacing between each text view. ScrollView(.horizontal) { LazyHStack(alignment: .top, spacing: 10) { ForEach(1...100, id: \.self) { Text("Column \($0)") } } } ## Topics ### Creating a lazy-loading horizontal stack Creates a lazy horizontal stack view with the given spacing, vertical alignment, pinning behavior, and content. ## Relationships ### Conforms To - `View` ## See Also ### Dynamically arranging views in one dimension Split content into logical sections inside lazy stack views. Display large numbers of repeated views efficiently with scroll views, stack views, and lazy stacks. `struct LazyVStack` A view that arranges its children in a line that grows vertically, creating items only as needed. `struct PinnedScrollableViews` A set of view types that may be pinned to the bounds of a scroll view. --- # https://developer.apple.com/documentation/swiftui/lazyvgrid - SwiftUI - LazyVGrid Structure # LazyVGrid A container view that arranges its child views in a grid that grows vertically, creating items only as needed. ## Mentioned in Picking container views for your content ## Overview Use a lazy vertical grid when you want to display a large, vertically scrollable collection of views arranged in a two dimensional layout. The first view that you provide to the grid’s `content` closure appears in the top row of the column that’s on the grid’s leading edge. Additional views occupy successive cells in the grid, filling the first row from leading to trailing edges, then the second row, and so on. The number of rows can grow unbounded, but you specify the number of columns by providing a corresponding number of `GridItem` instances to the grid’s initializer. The grid in the following example defines two columns and uses a `ForEach` structure to repeatedly generate a pair of `Text` views for the columns in each row: struct VerticalSmileys: View { let columns = [GridItem(.flexible()), GridItem(.flexible())] var body: some View { ScrollView { LazyVGrid(columns: columns) { ForEach(0x1f600...0x1f679, id: \.self) { value in Text(String(format: "%x", value)) Text(emoji(value)) .font(.largeTitle) } } } } guard let scalar = UnicodeScalar(value) else { return "?" } return String(Character(scalar)) } } For each row in the grid, the first column shows a Unicode code point from the “Smileys” group, and the second shows its corresponding emoji: You can achieve a similar layout using a `Grid` container. Unlike a lazy grid, which creates child views only when SwiftUI needs to display them, a regular grid creates all of its child views right away. This enables the grid to provide better support for cell spacing and alignment. Only use a lazy grid if profiling your app shows that a `Grid` view performs poorly because it tries to load too many views at once. ## Topics ### Creating a vertical grid Creates a grid that grows vertically. ## Relationships ### Conforms To - `View` ## See Also ### Dynamically arranging views in two dimensions `struct LazyHGrid` A container view that arranges its child views in a grid that grows horizontally, creating items only as needed. `struct GridItem` A description of a row or a column in a lazy grid. --- # https://developer.apple.com/documentation/swiftui/lazyvstack - SwiftUI - LazyVStack Structure # LazyVStack A view that arranges its children in a line that grows vertically, creating items only as needed. ## Mentioned in Grouping data with lazy stack views Picking container views for your content Displaying data in lists Creating performant scrollable stacks ## Overview The stack is “lazy,” in that the stack view doesn’t create items until it needs to render them onscreen. In the following example, a `ScrollView` contains a `LazyVStack` that consists of a vertical row of text views. The stack aligns to the leading edge of the scroll view, and uses default spacing between the text views. ScrollView { LazyVStack(alignment: .leading) { ForEach(1...100, id: \.self) { Text("Row \($0)") } } } ## Topics ### Creating a lazy-loading vertical stack Creates a lazy vertical stack view with the given spacing, vertical alignment, pinning behavior, and content. ## Relationships ### Conforms To - `View` ## See Also ### Dynamically arranging views in one dimension Split content into logical sections inside lazy stack views. Display large numbers of repeated views efficiently with scroll views, stack views, and lazy stacks. `struct LazyHStack` A view that arranges its children in a line that grows horizontally, creating items only as needed. `struct PinnedScrollableViews` A set of view types that may be pinned to the bounds of a scroll view. --- # https://developer.apple.com/documentation/swiftui/lineargradient --- # https://developer.apple.com/documentation/swiftui/link - SwiftUI - Link Structure # Link A control for navigating to a URL. @MainActor @preconcurrency ## Overview Create a link by providing a destination URL and a title. The title tells the user the purpose of the link, and can be a string, a title key that produces a localized string, or a view that acts as a label. The example below creates a link to `example.com` and displays the title string as a link-styled view: Link("View Our ", destination: URL(string: "https://www.example.com/TOS.html")!) When a user taps or clicks a `Link`, the default behavior depends on the contents of the URL. For example, SwiftUI opens a Universal Link in the associated app if possible, or in the user’s default web browser if not. Alternatively, you can override the default behavior by setting the `openURL` environment value with a custom `OpenURLAction`: Link("Visit Our Site", destination: URL(string: "https://www.example.com")!) .environment(\.openURL, OpenURLAction { url in print("Open \(url)") return .handled }) As with other views, you can style links using standard view modifiers depending on the view type of the link’s label. For example, a `Text` label could be modified with a custom `font(_:)` or `foregroundColor(_:)` to customize the appearance of the link in your app’s UI. ## Topics ### Creating a link `init(_:destination:)` Creates a control, consisting of a URL and a title key, used to navigate to a URL. Creates a control, consisting of a URL and a label, used to navigate to the given URL. ## Relationships ### Conforms To - `View` ## See Also ### Linking to other content `struct ShareLink` A view that controls a sharing presentation. `struct SharePreview` A representation of a type to display in a share preview. `struct TextFieldLink` A control that requests text input from the user when pressed. `struct HelpLink` A button with a standard appearance that opens app-specific help documentation. --- # https://developer.apple.com/documentation/swiftui/list - SwiftUI - List Structure # List A container that presents rows of data arranged in a single column, optionally providing the ability to select one or more members. @MainActor @preconcurrency ## Mentioned in Picking container views for your content Displaying data in lists Grouping data with lazy stack views Migrating to new navigation types Making a view into a drag source ## Overview In its simplest form, a `List` creates its contents statically, as shown in the following example: var body: some View { List { Text("A List Item") Text("A Second List Item") Text("A Third List Item") } } More commonly, you create lists dynamically from an underlying collection of data. The following example shows how to create a simple list from an array of an `Ocean` type which conforms to `Identifiable`: struct Ocean: Identifiable { let name: String let id = UUID() } private var oceans = [\ Ocean(name: "Pacific"),\ Ocean(name: "Atlantic"),\ Ocean(name: "Indian"),\ Ocean(name: "Southern"),\ Ocean(name: "Arctic")\ ] var body: some View { List(oceans) { Text($0.name) } } ### Supporting selection in lists To make members of a list selectable, provide a binding to a selection variable. Binding to a single instance of the list data’s `Identifiable.ID` type creates a single-selection list. Binding to a `Set` creates a list that supports multiple selections. The following example shows how to add multiselect to the previous example: struct Ocean: Identifiable, Hashable { let name: String let id = UUID() } var body: some View { NavigationView { List(oceans, selection: $multiSelection) { Text($0.name) } .navigationTitle("Oceans") .toolbar { EditButton() } } Text("\(multiSelection.count) selections") } When people make a single selection by tapping or clicking, the selected cell changes its appearance to indicate the selection. To enable multiple selections with tap gestures, put the list into edit mode by either modifying the `editMode` value, or adding an `EditButton` to your app’s interface. When you put the list into edit mode, the list shows a circle next to each list item. The circle contains a checkmark when the user selects the associated item. The example above uses an Edit button, which changes its title to Done while in edit mode: People can make multiple selections without needing to enter edit mode on devices that have a keyboard and mouse or trackpad, like Mac and iPad. ### Refreshing the list content To make the content of the list refreshable using the standard refresh control, use the `refreshable(action:)` modifier. The following example shows how to add a standard refresh control to a list. When the user drags the top of the list downward, SwiftUI reveals the refresh control and executes the specified action. Use an `await` expression inside the `action` closure to refresh your data. The refresh indicator remains visible for the duration of the awaited operation. struct Ocean: Identifiable, Hashable { let name: String let id = UUID() let stats: [String: String] } class OceanStore: ObservableObject { @Published var oceans = Ocean func loadStats() async {} } @EnvironmentObject var store: OceanStore var body: some View { NavigationView { List(store.oceans) { ocean in HStack { Text(ocean.name) StatsSummary(stats: ocean.stats) // A custom view for showing statistics. } } .refreshable { await store.loadStats() } .navigationTitle("Oceans") } } ### Supporting multidimensional lists To create two-dimensional lists, group items inside `Section` instances. The following example creates sections named after the world’s oceans, each of which has `Text` views named for major seas attached to those oceans. The example also allows for selection of a single list item, identified by the `id` of the example’s `Sea` type. struct ContentView: View { struct Sea: Hashable, Identifiable { let name: String let id = UUID() } struct OceanRegion: Identifiable { let name: String let seas: [Sea] let id = UUID() } private let oceanRegions: [OceanRegion] = [\ OceanRegion(name: "Pacific",\ seas: [Sea(name: "Australasian Mediterranean"),\ Sea(name: "Philippine"),\ Sea(name: "Coral"),\ Sea(name: "South China")]),\ OceanRegion(name: "Atlantic",\ seas: [Sea(name: "American Mediterranean"),\ Sea(name: "Sargasso"),\ Sea(name: "Caribbean")]),\ OceanRegion(name: "Indian",\ seas: [Sea(name: "Bay of Bengal")]),\ OceanRegion(name: "Southern",\ seas: [Sea(name: "Weddell")]),\ OceanRegion(name: "Arctic",\ seas: [Sea(name: "Greenland")])\ ] @State private var singleSelection: UUID? var body: some View { NavigationView { List(selection: $singleSelection) { ForEach(oceanRegions) { region in Section(header: Text("Major \(region.name) Ocean Seas")) { ForEach(region.seas) { sea in Text(sea.name) } } } } .navigationTitle("Oceans and Seas") } } } Because this example uses single selection, people can make selections outside of edit mode on all platforms. ### Creating hierarchical lists You can also create a hierarchical list of arbitrary depth by providing tree-structured data and a `children` parameter that provides a key path to get the child nodes at any level. The following example uses a deeply-nested collection of a custom `FileItem` type to simulate the contents of a file system. The list created from this data uses collapsing cells to allow the user to navigate the tree structure. struct ContentView: View { struct FileItem: Hashable, Identifiable, CustomStringConvertible { var id: Self { self } var name: String var children: [FileItem]? = nil var description: String { switch children { case nil: return "📄 \(name)" case .some(let children): return children.isEmpty ? "📂 \(name)" : "📁 \(name)" } } } let fileHierarchyData: [FileItem] = [\ FileItem(name: "users", children:\ [FileItem(name: "user1234", children:\ [FileItem(name: "Photos", children:\ [FileItem(name: "photo001.jpg"),\ FileItem(name: "photo002.jpg")]),\ FileItem(name: "Movies", children:\ [FileItem(name: "movie001.mp4")]),\ FileItem(name: "Documents", children: [])\ ]),\ FileItem(name: "newuser", children:\ [FileItem(name: "Documents", children: [])\ ])\ ]),\ FileItem(name: "private", children: nil)\ ] var body: some View { List(fileHierarchyData, children: \.children) { item in Text(item.description) } } } ### Styling lists SwiftUI chooses a display style for a list based on the platform and the view type in which it appears. Use the `listStyle(_:)` modifier to apply a different `ListStyle` to all lists within a view. For example, adding `.listStyle(.plain)` to the example shown in the “Creating Multidimensional Lists” topic applies the `plain` style, the following screenshot shows: ## Topics ### Creating a list from a set of views Creates a list with the given content. `init(selection:content:)` Creates a list with the given content that supports selecting a single row that cannot be deselcted. ### Creating a list from enumerated data `init(_:rowContent:)` Creates a list that computes its rows on demand from an underlying collection of identifiable data. `init(_:selection:rowContent:)` Creates a list that computes its rows on demand from an underlying collection of identifiable data, optionally allowing users to select a single row. `init(_:id:rowContent:)` Creates a list that identifies its rows based on a key path to the identifier of the underlying data. `init(_:id:selection:rowContent:)` Creates a list that identifies its rows based on a key path to the identifier of the underlying data, optionally allowing users to select a single row. ### Creating a list from hierarchical data `init(_:children:rowContent:)` Creates a hierarchical list that computes its rows on demand from a binding to an underlying collection of identifiable data. `init(_:children:selection:rowContent:)` Creates a hierarchical list that computes its rows on demand from a binding to an underlying collection of identifiable data and allowing users to have exactly one row always selected. `init(_:id:children:rowContent:)` Creates a hierarchical list that identifies its rows based on a key path to the identifier of the underlying data. `init(_:id:children:selection:rowContent:)` Creates a hierarchical list that identifies its rows based on a key path to the identifier of the underlying data and allowing users to have exactly one row always selected. ### Creating a list from editable data Creates a list that computes its rows on demand from an underlying collection of identifiable data and allows to edit the collection. `init(_:editActions:selection:rowContent:)` Creates a list that computes its rows on demand from an underlying collection of identifiable data, allows to edit the collection, and requires a selection of a single row. `init(_:id:editActions:selection:rowContent:)` Creates a list that computes its rows on demand from an underlying collection of identifiable, allows to edit the collection, and requires a selection of a single row. ### Supporting types `var body: some View` The content of the list. ## Relationships ### Conforms To - `View` ## See Also ### Creating a list Visualize collections of data with platform-appropriate appearance. Sets the style for lists within this view. --- # https://developer.apple.com/documentation/swiftui/menu - SwiftUI - Menu Structure # Menu A control for presenting a menu of actions. ## Mentioned in Populating SwiftUI menus with adaptive controls Building and customizing the menu bar with SwiftUI ## Overview The following example presents a menu of three buttons and a submenu, which contains three buttons of its own. Menu("Actions") { Button("Duplicate", action: duplicate) Button("Rename", action: rename) Button("Delete…", action: delete) Menu("Copy") { Button("Copy", action: copy) Button("Copy Formatted", action: copyFormatted) Button("Copy Library Path", action: copyPath) } } You can create the menu’s title with a `LocalizedStringKey`, as seen in the previous example, or with a view builder that creates multiple views, such as an image and a text view: Menu { Button("Open in Preview", action: openInPreview) Button("Save as PDF", action: saveAsPDF) } label: { Label("PDF", systemImage: "doc.fill") } To support subtitles on menu items, initialize your `Button` with a view builder that creates multiple `Text` views where the first text represents the title and the second text represents the subtitle. The same approach applies to other controls such as `Toggle`: Menu { Button(action: openInPreview) { Text("Open in Preview") Text("View the document in Preview") } Button(action: saveAsPDF) { Text("Save as PDF") Text("Export the document as a PDF file") } } label: { Label("PDF", systemImage: "doc.fill") } ### Primary action Menus can be created with a custom primary action. The primary action will be performed when the user taps or clicks on the body of the control, and the menu presentation will happen on a secondary gesture, such as on long press or on click of the menu indicator. The following example creates a menu that adds bookmarks, with advanced options that are presented in a menu. Menu { Button(action: addCurrentTabToReadingList) { Label("Add to Reading List", systemImage: "eyeglasses") } Button(action: bookmarkAll) { Label("Add Bookmarks for All Tabs", systemImage: "book") } Button(action: show) { Label("Show All Bookmarks", systemImage: "books.vertical") } } label: { Label("Add Bookmark", systemImage: "book") } primaryAction: { addBookmark() } ### Styling menus Use the `menuStyle(_:)` modifier to change the style of all menus in a view. The following example shows how to apply a custom style: Menu("Editing") { Button("Set In Point", action: setInPoint) Button("Set Out Point", action: setOutPoint) } .menuStyle(EditingControlsMenuStyle()) ## Topics ### Creating a menu from content `init(_:content:)` Creates a menu that generates its label from a localized string key. Creates a menu with a custom label. `init(_:image:content:)` Creates a menu that generates its label from a localized string key and image resource. `init(_:systemImage:content:)` Creates a menu that generates its label from a localized string key and system image. ### Creating a menu with a primary action `init(_:content:primaryAction:)` Creates a menu with a custom primary action that generates its label from a localized string key. Creates a menu with a custom primary action and custom label. `init(_:image:content:primaryAction:)` `init(_:systemImage:content:primaryAction:)` Creates a menu with a custom primary action that generates its label from a localized string key and system image. ### Creating a menu from a configuration `init(MenuStyleConfiguration)` Creates a menu based on a style configuration. ## Relationships ### Conforms To - `View` ## See Also ### Creating a menu Improve your app by populating menus with controls and organizing your content intuitively. Sets the style for menus within this view. --- # https://developer.apple.com/documentation/swiftui/menubutton - SwiftUI - MenuButton Deprecated Structure # MenuButton A button that displays a menu containing a list of choices when pressed. macOS 10.15–26.0Deprecated ## Topics ### Creating a menu button `init(_:content:)` Creates a menu button with the specified localized title and content. Creates a menu button with the specified label and content. ### Styling a menu button Sets the style for menu buttons within this view. `protocol MenuButtonStyle` A custom specification for the appearance and interaction of a menu button. ## Relationships ### Conforms To - `View` ## See Also ### Deprecated types `typealias PullDownButton` Deprecated `struct ContextMenu` A container for views that you present as menu items in a context menu. Deprecated --- # https://developer.apple.com/documentation/swiftui/menustyleconfiguration/content --- # https://developer.apple.com/documentation/swiftui/menustyleconfiguration/label - SwiftUI - MenuStyleConfiguration - MenuStyleConfiguration.Label Structure # MenuStyleConfiguration.Label A type-erased label of a menu. @MainActor @preconcurrency struct Label ## Relationships ### Conforms To - `View` ## See Also ### Setting the label and content `struct Content` A type-erased content of a menu. --- # https://developer.apple.com/documentation/swiftui/meshgradient - SwiftUI - MeshGradient Structure # MeshGradient A two-dimensional gradient defined by a 2D grid of positioned colors. struct MeshGradient ## Overview Each vertex has a position, a color and four surrounding Bezier control points (leading, top, trailing, bottom) that define the tangents connecting the vertex with its four neighboring vertices. (Vertices on the corners or edges of the mesh have less than four neighbors, they ignore their extra control points.) Control points may either be specified explicitly or implicitly. When rendering, a tessellated sequence of Bezier patches are created, and vertex colors are interpolated across each patch, either linearly, or via another set of cubic curves derived from how the colors change between neighbors – the latter typically gives smoother color transitions. MeshGradient(width: 3, height: 3, points: [\ .init(0, 0), .init(0.5, 0), .init(1, 0),\ .init(0, 0.5), .init(0.5, 0.5), .init(1, 0.5),\ .init(0, 1), .init(0.5, 1), .init(1, 1)\ ], colors: [\ .red, .purple, .indigo,\ .orange, .white, .blue,\ .yellow, .green, .mint\ ]) ## Topics ### Structures `struct BezierPoint` One location in a gradient mesh, along with the four Bezier control points surrounding it. ### Initializers [`init(width: Int, height: Int, bezierPoints: [MeshGradient.BezierPoint], colors: [Color], background: Color, smoothsColors: Bool, colorSpace: Gradient.ColorSpace)`](https://developer.apple.com/documentation/swiftui/meshgradient/init(width:height:bezierpoints:colors:background:smoothscolors:colorspace:)) Creates a new gradient mesh specified as a 2D grid of colored points, specifying the Bezier control points explicitly. [`init(width: Int, height: Int, bezierPoints: [MeshGradient.BezierPoint], resolvedColors: [Color.Resolved], background: Color, smoothsColors: Bool, colorSpace: Gradient.ColorSpace)`](https://developer.apple.com/documentation/swiftui/meshgradient/init(width:height:bezierpoints:resolvedcolors:background:smoothscolors:colorspace:)) Creates a new gradient mesh specified as a 2D grid of colored points, specifying the Bezier control points explicitly, with already-resolved sRGB colors. `init(width: Int, height: Int, locations: MeshGradient.Locations, colors: MeshGradient.Colors, background: Color, smoothsColors: Bool, colorSpace: Gradient.ColorSpace)` Creates a new gradient mesh specified as a 2D grid of colored vertices. Creates a new gradient mesh specified as a 2D grid of colored points. Creates a new gradient mesh specified as a 2D grid of colored points, with already-resolved sRGB colors. ### Instance Properties `var background: Color` The background color, this fills any points outside the defined vertex mesh. `var colorSpace: Gradient.ColorSpace` The color space in which to interpolate vertex colors. `var colors: MeshGradient.Colors` The array of colors. Must contain `width x height` elements. `var height: Int` The height of the mesh, i.e. the number of vertices per column. `var locations: MeshGradient.Locations` The array of locations. Must contain `width x height` elements. `var smoothsColors: Bool` Whether cubic (smooth) interpolation should be used for the colors in the mesh (rather than only for the shape of the mesh). `var width: Int` The width of the mesh, i.e. the number of vertices per row. ### Enumerations `enum Colors` An array of colors. `enum Locations` An array of 2D locations and their control points. ## Relationships ### Conforms To - `Copyable` - `Equatable` - `Sendable` - `SendableMetatype` - `ShapeStyle` - `View` ## See Also ### Styling content Adds a border to this view with the specified style and width. Sets a view’s foreground elements to use a given style. Sets the primary and secondary levels of the foreground style in the child view. Sets the primary, secondary, and tertiary levels of the foreground style. Sets the specified style to render backgrounds within the view. `var backgroundStyle: AnyShapeStyle?` An optional style that overrides the default system background style when set. `protocol ShapeStyle` A color or pattern to use when rendering a shape. `struct AnyShapeStyle` A type-erased ShapeStyle value. `struct Gradient` A color gradient represented as an array of color stops, each having a parametric location value. `struct AnyGradient` A color gradient. `struct ShadowStyle` A style to use when rendering shadows. `struct Glass` A structure that defines the configuration of the Liquid Glass material. Beta --- # https://developer.apple.com/documentation/swiftui/modifiedcontent - SwiftUI - ModifiedContent Structure # ModifiedContent A value with a modifier applied to it. @frozen ## Topics ### Creating a modified content view `init(content: Content, modifier: Modifier)` A structure that defines the content and modifier needed to produce a new view or view modifier. `var content: Content` The content that the modifier transforms into a new view or new view modifier. `var modifier: Modifier` The view modifier. ### Instance Methods `func accessibility(activationPoint:)` Specifies the point where activations occur in the view. Deprecated Adds the given traits to the view. Specifies whether to hide this view from system accessibility features. Communicates to the user what happens after performing the view’s action. Uses the specified string to identify the view. Sets alternate input labels with which users identify a view. Adds a label to the view that describes its contents. Removes the given traits from this view. Sets a selection identifier for this view’s accessibility element. Sets the sort priority order for this view’s accessibility element, relative to other elements at the same level. Adds a textual description of the value that the view contains. Adds an accessibility action to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. Adds an accessibility action representing `actionKind` to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. When the action is performed, the `intent` will be invoked. `func accessibilityAction(named:_:)` `func accessibilityAction(named:intent:)` Adds an accessibility action labeled `name` to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. When the action is performed, the `intent` will be invoked. `func accessibilityActivationPoint(_:)` The activation point for an element is the location assistive technologies use to initiate gestures. `func accessibilityActivationPoint(_:isEnabled:)` Adds an accessibility adjustable action to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. `func accessibilityCustomContent(_:_:importance:)` Add additional accessibility information to the view. Explicitly set whether this accessibility element is a direct touch area. Direct touch areas passthrough touch events to the app rather than being handled through an assistive technology, such as VoiceOver. The modifier accepts an optional `AccessibilityDirectTouchOptions` option set to customize the functionality of the direct touch area. `func accessibilityDragPoint(_:description:)` The point an assistive technology should use to begin a drag interaction. `func accessibilityDragPoint(_:description:isEnabled:)` `func accessibilityDropPoint(_:description:)` The point an assistive technology should use to end a drag interaction. `func accessibilityDropPoint(_:description:isEnabled:)` Set the level of this heading. `func accessibilityHint(_:)` `func accessibilityHint(_:isEnabled:)` Uses the string you specify to identify the view. `func accessibilityInputLabels(_:)` `func accessibilityInputLabels(_:isEnabled:)` `func accessibilityLabel(_:)` `func accessibilityLabel(_:isEnabled:)` Explicitly set whether this Accessibility element responds to user interaction and would thus be interacted with by technologies such as Switch Control, Voice Control or Full Keyboard Access. Adds an accessibility scroll action to the view. Actions allow assistive technologies, such as the VoiceOver, to interact with the view by invoking the action. `func accessibilityScrollStatus(_:isEnabled:)` Changes the announcement provided by accessibility technologies when a user scrolls a scroll view within this view. Beta Sets an accessibility text content type. `func accessibilityValue(_:)` `func accessibilityValue(_:isEnabled:)` Adds an accessibility zoom action to the view. Actions allow assistive technologies, such as VoiceOver, to interact with the view by invoking the action. ## Relationships ### Conforms To - `Animatable` Conforms when `Content` conforms to `Animatable` and `Modifier` conforms to `Animatable`. - `Chart3DContent` - `Copyable` - `CustomHoverEffect` Conforms when `Content` conforms to `CustomHoverEffect` and `Modifier` conforms to `CustomHoverEffect`. - `DynamicMapContent` - `DynamicTableRowContent` Conforms when `Content` conforms to `DynamicTableRowContent` and `Modifier` conforms to `_TableRowContentModifier`. - `DynamicViewContent` Conforms when `Content` conforms to `DynamicViewContent` and `Modifier` conforms to `ViewModifier`. - `Equatable` - `HoverEffectContent` Conforms when `Content` conforms to `HoverEffectContent` and `Modifier` conforms to `HoverEffectContent`. - `MapContent` - `Scene` Conforms when `Content` conforms to `Scene` and `Modifier` conforms to `_SceneModifier`. - `Sendable` - `SendableMetatype` - `TableRowContent` Conforms when `Content` conforms to `TableRowContent` and `Modifier` conforms to `_TableRowContentModifier`. - `View` Conforms when `Content` conforms to `View` and `Modifier` conforms to `ViewModifier`. - `ViewModifier` Conforms when `Content` conforms to `ViewModifier` and `Modifier` conforms to `ViewModifier`. - `VisualEffect` Conforms when `Content` conforms to `VisualEffect` and `Modifier` conforms to `VisualEffect`. ## See Also ### Modifying a view Configuring views Adjust the characteristics of a view by applying view modifiers. Reducing view modifier maintenance Bundle view modifiers that you regularly reuse into a custom view modifier. Applies a modifier to a view and returns a new view. `protocol ViewModifier` A modifier that you apply to a view or another view modifier, producing a different version of the original value. `struct EmptyModifier` An empty, or identity, modifier, used during development to switch modifiers at compile time. `protocol EnvironmentalModifier` A modifier that must resolve to a concrete modifier in an environment before use. `struct ManipulableModifier` Beta `struct ManipulableResponderModifier` Beta `struct ManipulableTransformBindingModifier` Beta `struct ManipulationGeometryModifier` Beta `struct ManipulationGestureModifier` Beta `struct ManipulationUsingGestureStateModifier` Beta `enum Manipulable` A namespace for various manipulable related types. --- # https://developer.apple.com/documentation/swiftui/multidatepicker - SwiftUI - MultiDatePicker Structure # MultiDatePicker A control for picking multiple dates. ## Overview Use a `MultiDatePicker` when you want to provide a view that allows the user to select multiple dates. The following example creates a basic `MultiDatePicker`, which appears as a calendar view representing the selected dates: var body: some View { MultiDatePicker("Dates Available", selection: $dates) } You can limit the `MultiDatePicker` to specific ranges of dates allowing selections only before or after a certain date or between two dates. The following example shows a multi-date picker that only permits selections within the 6th and (excluding) the 16th of December 2021 (in the `UTC` time zone): @Environment(\.calendar) var calendar @Environment(\.timeZone) var timeZone let start = calendar.date(from: DateComponents( timeZone: timeZone, year: 2022, month: 6, day: 6))! let end = calendar.date(from: DateComponents( timeZone: timeZone, year: 2022, month: 6, day: 16))! return start ..< end } var body: some View { MultiDatePicker("Dates Available", selection: $dates, in: bounds) } You can also specify an alternative locale, calendar and time zone through environment values. This can be useful when using a `PreviewProvider` to see how your multi-date picker behaves in environments that differ from your own. The following example shows a multi-date picker with a custom locale, calendar and time zone: struct ContentView_Previews: PreviewProvider { static var previews: some View { MultiDatePicker("Dates Available", selection: .constant([])) .environment(\.locale, Locale.init(identifier: "zh")) .environment( \.calendar, Calendar.init(identifier: .chinese)) .environment(\.timeZone, TimeZone(abbreviation: "HKT")!) } } ## Topics ### Picking dates `init(_:selection:)` Creates an instance that selects multiple dates with an unbounded range. `init(selection: Binding>, label: () -> Label)` ### Picking dates in a range `init(_:selection:in:)` Creates an instance that selects multiple dates on or after some start date. `init(selection:in:label:)` ## Relationships ### Conforms To - `View` ## See Also ### Choosing dates `struct DatePicker` A control for selecting an absolute date. Sets the style for date pickers within this view. `var calendar: Calendar` The current calendar that views should use when handling dates. `var timeZone: TimeZone` The current time zone that views should use when handling dates. --- # https://developer.apple.com/documentation/swiftui/offsetshape - SwiftUI - OffsetShape Structure # OffsetShape A shape with a translation offset transform applied to it. @frozen ## Topics ### Creating an offset shape `init(shape: Content, offset: CGSize)` ### Getting the shape’s characteristics `var offset: CGSize` `var shape: Content` ### Supporting types The data to animate. ## Relationships ### Conforms To - `Animatable` - `Copyable` - `InsettableShape` Conforms when `Content` conforms to `InsettableShape`. - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Transforming a shape `struct ScaledShape` A shape with a scale transform applied to it. `struct RotatedShape` A shape with a rotation transform applied to it. `struct TransformedShape` A shape with an affine transform applied to it. --- # https://developer.apple.com/documentation/swiftui/outlinegroup - SwiftUI - OutlineGroup Structure # OutlineGroup A structure that computes views and disclosure groups on demand from an underlying collection of tree-structured, identified data. ## Mentioned in Displaying data in lists ## Overview Use an outline group when you need a view that can represent a hierarchy of data by using disclosure views. This allows the user to navigate the tree structure by using the disclosure views to expand and collapse branches. In the following example, a tree structure of `FileItem` data offers a simplified view of a file system. Passing the root of this tree and the key path of its children allows you to quickly create a visual representation of the file system. struct FileItem: Hashable, Identifiable, CustomStringConvertible { var id: Self { self } var name: String var children: [FileItem]? = nil var description: String { switch children { case nil: return "📄 \(name)" case .some(let children): return children.isEmpty ? "📂 \(name)" : "📁 \(name)" } } } let data = FileItem(name: "users", children: [FileItem(name: "user1234", children:\ [FileItem(name: "Photos", children:\ [FileItem(name: "photo001.jpg"),\ FileItem(name: "photo002.jpg")]),\ FileItem(name: "Movies", children:\ [FileItem(name: "movie001.mp4")]),\ FileItem(name: "Documents", children: [])\ ]),\ FileItem(name: "newuser", children:\ [FileItem(name: "Documents", children: [])\ ])\ ]) OutlineGroup(data, children: \.children) { item in Text("\(item.description)") } ### Type parameters Five generic type constraints define a specific `OutlineGroup` instance: - `Data`: The type of a collection containing the children of an element in the tree-shaped data. - `ID`: The type of the identifier for an element. - `Parent`: The type of the visual representation of an element whose children property is non- `nil` - `Leaf`: The type of the visual representation of an element whose children property is `nil`. - `Subgroup`: A type of a view that groups a parent view and a view representing its children, typically with some mechanism for showing and hiding the children ## Topics ### Creating an outline group `init(_:children:)` Creates an outline group from a collection of root data elements and a key path to element’s children. `init(_:children:content:)` Creates an outline group from a binding to a collection of root data elements and a key path to its children. `init(_:id:children:content:)` Creates an outline group from a binding to a collection of root data elements, the key path to a data element’s identifier, and a key path to its children. ### Supporting types `struct OutlineSubgroupChildren` A type-erased view representing the children in an outline subgroup. ## Relationships ### Conforms To - `Copyable` - `TableRowContent` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` is `Data.Element.ID`, `Parent` conforms to `TableRowContent`, `Parent` is `Leaf`, `Leaf` is `Subgroup`, and `Data.Element` is `Parent.TableRowValue`. - `View` Conforms when `Data` conforms to `RandomAccessCollection`, `ID` conforms to `Hashable`, `Parent` conforms to `View`, `Leaf` conforms to `View`, and `Subgroup` conforms to `View`. ## See Also ### Disclosing information progressively `struct DisclosureGroup` A view that shows or hides another content view, based on the state of a disclosure control. Sets the style for disclosure groups within this view. --- # https://developer.apple.com/documentation/swiftui/outlinesubgroupchildren - SwiftUI - OutlineSubgroupChildren Structure # OutlineSubgroupChildren A type-erased view representing the children in an outline subgroup. struct OutlineSubgroupChildren ## Overview `OutlineGroup` uses this type as a generic constraint for the `Content` of the `DisclosureGroup` instances it creates. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/pastebutton --- # https://developer.apple.com/documentation/swiftui/path - SwiftUI - Path Structure # Path The outline of a 2D shape. @frozen struct Path ## Topics ### Creating a path `init()` Creates an empty path. `init(_:)` Creates an empty path, then executes a closure to add its initial elements. `init(ellipseIn: CGRect)` Creates a path as an ellipse within the given rectangle. `init(roundedRect: CGRect, cornerRadius: CGFloat, style: RoundedCornerStyle)` Creates a path containing a rounded rectangle. `init(roundedRect: CGRect, cornerSize: CGSize, style: RoundedCornerStyle)` `init(roundedRect: CGRect, cornerRadii: RectangleCornerRadii, style: RoundedCornerStyle)` Creates a path as the given rounded rectangle, which may have uneven corner radii. ### Getting the path’s characteristics `var boundingRect: CGRect` A rectangle containing all path segments. `var cgPath: CGPath` An immutable path representing the elements in the path. Returns true if the path contains a specified point. `var currentPoint: CGPoint?` Returns the last point in the path, or nil if the path contains no points. `var description: String` A description of the path that may be used to recreate the path via `init?(_:)`. `var isEmpty: Bool` A Boolean value indicating whether the path contains zero elements. ### Drawing a path `func move(to: CGPoint)` Begins a new subpath at the specified point. `func addArc(center: CGPoint, radius: CGFloat, startAngle: Angle, endAngle: Angle, clockwise: Bool, transform: CGAffineTransform)` Adds an arc of a circle to the path, specified with a radius and angles. `func addArc(tangent1End: CGPoint, tangent2End: CGPoint, radius: CGFloat, transform: CGAffineTransform)` Adds an arc of a circle to the path, specified with a radius and two tangent lines. `func addCurve(to: CGPoint, control1: CGPoint, control2: CGPoint)` Adds a cubic Bézier curve to the path, with the specified end point and control points. `func addEllipse(in: CGRect, transform: CGAffineTransform)` Adds an ellipse that fits inside the specified rectangle to the path. `func addLine(to: CGPoint)` Appends a straight line segment from the current point to the specified point. [`func addLines([CGPoint])`](https://developer.apple.com/documentation/swiftui/path/addlines(_:)) Adds a sequence of connected straight-line segments to the path. `func addPath(Path, transform: CGAffineTransform)` Appends another path value to this path. `func addQuadCurve(to: CGPoint, control: CGPoint)` Adds a quadratic Bézier curve to the path, with the specified end point and control point. `func addRect(CGRect, transform: CGAffineTransform)` Adds a rectangular subpath to the path. [`func addRects([CGRect], transform: CGAffineTransform)`](https://developer.apple.com/documentation/swiftui/path/addrects(_:transform:)) Adds a set of rectangular subpaths to the path. `func addRelativeArc(center: CGPoint, radius: CGFloat, startAngle: Angle, delta: Angle, transform: CGAffineTransform)` Adds an arc of a circle to the path, specified with a radius and a difference in angle. `func addRoundedRect(in: CGRect, cornerSize: CGSize, style: RoundedCornerStyle, transform: CGAffineTransform)` Adds a rounded rectangle to the path. `func closeSubpath()` Closes and completes the current subpath. ### Transforming the path Returns a path constructed by applying the transform to all points of the path. Returns a path constructed by translating all its points. Returns a partial copy of the path. ### Performing operations on the path Returns a new path with filled regions common to both paths. Returns a new path with a line from this path that overlaps the filled regions of the given path. Returns a new path with a line from this path that does not overlap the filled region of the given path. Returns a new weakly-simple copy of this path. Returns a new path with filled regions from this path that are not in the given path. Returns a new path with filled regions either from this path or the given path, but not in both. Returns a new path with filled regions in either this path or the given path. ### Operating over path elements Calls `body` with each element in the path. `enum Element` An element of a path. ### Applying a style Returns a stroked copy of the path using `style` to define how the stroked outline is created. ### Instance Methods `func addRoundedRect(in: CGRect, cornerRadii: RectangleCornerRadii, style: RoundedCornerStyle, transform: CGAffineTransform)` Adds a rounded rectangle with uneven corners to the path. ## Relationships ### Conforms To - `Animatable` - `Copyable` - `CustomStringConvertible` - `Equatable` - `LosslessStringConvertible` - `Sendable` - `SendableMetatype` - `Shape` - `View` --- # https://developer.apple.com/documentation/swiftui/phaseanimator --- # https://developer.apple.com/documentation/swiftui/picker - SwiftUI - Picker Structure # Picker A control for selecting from a set of mutually exclusive values. ## Mentioned in Picking container views for your content Performing a search operation Scoping a search operation Populating SwiftUI menus with adaptive controls ## Overview You create a picker by providing a selection binding, a label, and the content for the picker to display. Set the `selection` parameter to a bound property that provides the value to display as the current selection. Set the label to a view that visually describes the purpose of selecting content in the picker, and then provide the content for the picker to display. For example, consider an enumeration of ice cream flavors and a `State` variable to hold the selected flavor: enum Flavor: String, CaseIterable, Identifiable { case chocolate, vanilla, strawberry var id: Self { self } } @State private var selectedFlavor: Flavor = .chocolate You can create a picker to select among the values by providing a label, a binding to the current selection, and a collection of views for the picker’s content. Append a tag to each of these content views using the `View/tag(_:)` view modifier so that the type of each selection matches the type of the bound state variable: List { Picker("Flavor", selection: $selectedFlavor) { Text("Chocolate").tag(Flavor.chocolate) Text("Vanilla").tag(Flavor.vanilla) Text("Strawberry").tag(Flavor.strawberry) } } If you provide a string label for the picker, as the example above does, the picker uses it to initialize a `Text` view as a label. Alternatively, you can use the `init(selection:content:label:)` initializer to compose the label from other views. The exact appearance of the picker depends on the context. If you use a picker in a `List` in iOS, it appears in a row with the label and selected value, and a chevron to indicate that you can tap the row to select a new value: For cases where adding a subtitle to the label is desired, use a view builder that creates multiple `Text` views where the first text represents the title and the second text represents the subtitle: List { Picker(selection: $selectedFlavor) { Text("Chocolate").tag(Flavor.chocolate) Text("Vanilla").tag(Flavor.vanilla) Text("Strawberry").tag(Flavor.strawberry) } label: { Text("Flavor") Text("Choose your favorite flavor") } } ### Iterating over a picker’s options To provide selection values for the `Picker` without explicitly listing each option, you can create the picker with a `ForEach`: Picker("Flavor", selection: $selectedFlavor) { ForEach(Flavor.allCases) { flavor in Text(flavor.rawValue.capitalized) } } `ForEach` automatically assigns a tag to the selection views using each option’s `id`. This is possible because `Flavor` conforms to the `Identifiable` protocol. The example above relies on the fact that `Flavor` defines the type of its `id` parameter to exactly match the selection type. If that’s not the case, you need to override the tag. For example, consider a `Topping` type and a suggested topping for each flavor: enum Topping: String, CaseIterable, Identifiable { case nuts, cookies, blueberries var id: Self { self } } extension Flavor { var suggestedTopping: Topping { switch self { case .chocolate: return .nuts case .vanilla: return .cookies case .strawberry: return .blueberries } } } @State private var suggestedTopping: Topping = .nuts The following example shows a picker that’s bound to a `Topping` type, while the options are all `Flavor` instances. Each option uses the tag modifier to associate the suggested topping with the flavor it displays: List { Picker("Flavor", selection: $suggestedTopping) { ForEach(Flavor.allCases) { flavor in Text(flavor.rawValue.capitalized) .tag(flavor.suggestedTopping) } } HStack { Text("Suggested Topping") Spacer() Text(suggestedTopping.rawValue.capitalized) .foregroundStyle(.secondary) } } When the user selects chocolate, the picker sets `suggestedTopping` to the value in the associated tag: Another example of when the views in a picker’s `ForEach` need an explicit tag modifier is when you select over the cases of an enumeration that conforms to the `Identifiable` protocol by using anything besides `Self` as the `id` parameter type. For example, a string enumeration might use the case’s `rawValue` string as the `id`. That identifier type doesn’t match the selection type, which is the type of the enumeration itself. ### Styling pickers You can customize the appearance and interaction of pickers using styles that conform to the `PickerStyle` protocol, like `segmented` or `menu`. To set a specific style for all picker instances within a view, use the `pickerStyle(_:)` modifier. The following example applies the `segmented` style to two pickers that independently select a flavor and a topping: VStack { Picker("Flavor", selection: $selectedFlavor) { ForEach(Flavor.allCases) { flavor in Text(flavor.rawValue.capitalized) } } Picker("Topping", selection: $selectedTopping) { ForEach(Topping.allCases) { topping in Text(topping.rawValue.capitalized) } } } .pickerStyle(.segmented) ## Topics ### Creating a picker `init(_:selection:content:)` Creates a picker that generates its label from a localized string key. Creates a picker that displays a custom label. ### Creating a picker for a collection `init(_:sources:selection:content:)` Creates a picker bound to a collection of bindings that generates its label from a string. `init(sources: C, selection: KeyPath>, content: () -> Content, label: () -> Label)` ### Creating a picker with an image label `init(_:image:selection:content:)` Creates a picker that generates its label from a localized string key and image resource `init(_:image:sources:selection:content:)` Creates a picker bound to a collection of bindings that generates its label from a string and image resource. `init(_:systemImage:selection:content:)` Creates a picker that generates its label from a localized string key and system image. `init(_:systemImage:sources:selection:content:)` ### Deprecated initializers Deprecated ### Initializers `init(_:image:selection:content:currentValueLabel:)` Creates a picker that accepts a custom current value label and generates its label from a localized string key and image resource `init(_:image:sources:selection:content:currentValueLabel:)` Creates a picker bound to a collection of bindings that accepts a custom current value label and generates its label from a string and image resource. `init(_:selection:content:currentValueLabel:)` Creates a picker that generates its label from a localized string key and accepts a custom current value label. `init(_:sources:selection:content:currentValueLabel:)` Creates a picker bound to a collection of bindings that generates its label from a string and accepts a custom current value label. `init(_:systemImage:selection:content:currentValueLabel:)` Creates a picker that accepts a custom current value label and generates its label from a localized string key and system image. `init(_:systemImage:sources:selection:content:currentValueLabel:)` Creates a picker bound to a collection of bindings that accepts a custom current value label and generates its label from a string. Creates a picker that displays a custom label and a custom value label where applicable. `init(sources: C, selection: KeyPath>, content: () -> Content, label: () -> Label, currentValueLabel: () -> some View)` Creates a picker that displays a custom label and current value label where applicable. ## Relationships ### Conforms To - `View` ## See Also ### Choosing from a set of options Sets the style for pickers within this view. Sets the style for radio group style pickers within this view to be horizontally positioned with the radio buttons inside the layout. Sets the default wheel-style picker item height. `var defaultWheelPickerItemHeight: CGFloat` The default height of an item in a wheel-style picker, such as a date picker. Specifies the selection effect to apply to a palette item. `struct PaletteSelectionEffect` The selection effect to apply to a palette item. --- # https://developer.apple.com/documentation/swiftui/placeholdercontentview --- # https://developer.apple.com/documentation/swiftui/presentedwindowcontent - SwiftUI - PresentedWindowContent Structure # PresentedWindowContent A view that represents the content of a presented window. ## Overview You don’t create this type directly. `WindowGroup` creates values for you. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/previewmodifiercontent - SwiftUI - PreviewModifierContent Structure # PreviewModifierContent The type-erased content of a preview. struct PreviewModifierContent ## Relationships ### Conforms To - `View` ## See Also ### Defining a preview `macro Previewable()` Tag allowing a dynamic property to appear inline in a preview. `protocol PreviewProvider` A type that produces view previews in Xcode. `enum PreviewPlatform` Platforms that can run the preview. Sets a user visible name to show in the canvas for a preview. `protocol PreviewModifier` A type that defines an environment in which previews can appear. --- # https://developer.apple.com/documentation/swiftui/primitivebuttonstyleconfiguration/label-swift.struct - SwiftUI - PrimitiveButtonStyleConfiguration - PrimitiveButtonStyleConfiguration.Label Structure # PrimitiveButtonStyleConfiguration.Label A type-erased label of a button. @MainActor @preconcurrency struct Label ## Relationships ### Conforms To - `View` ## See Also ### Configuring a button’s label `let label: PrimitiveButtonStyleConfiguration.Label` A view that describes the effect of calling the button’s action. --- # https://developer.apple.com/documentation/swiftui/progressview - SwiftUI - ProgressView Structure # ProgressView A view that shows the progress toward completion of a task. ## Mentioned in Declaring a custom view ## Overview Use a progress view to show that a task is incomplete but advancing toward completion. A progress view can show both determinate (percentage complete) and indeterminate (progressing or not) types of progress. Create a determinate progress view by initializing a `ProgressView` with a binding to a numeric value that indicates the progress, and a `total` value that represents completion of the task. By default, the progress is `0.0` and the total is `1.0`. The example below uses the state property `progress` to show progress in a determinate `ProgressView`. The progress view uses its default total of `1.0`, and because `progress` starts with an initial value of `0.5`, the progress view begins half-complete. A “More” button below the progress view allows people to increment the progress in increments of five percent: struct LinearProgressDemoView: View { @State private var progress = 0.5 var body: some View { VStack { ProgressView(value: progress) Button("More") { progress += 0.05 } } } } To create an indeterminate progress view, use an initializer that doesn’t take a progress value: var body: some View { ProgressView() } You can also create a progress view that covers a closed range of `Date` values. As long as the current date is within the range, the progress view automatically updates, filling or depleting the progress view as it nears the end of the range. The following example shows a five-minute timer whose start time is that of the progress view’s initialization: struct DateRelativeProgressDemoView: View { let workoutDateRange = Date()...Date().addingTimeInterval(5*60) var body: some View { ProgressView(timerInterval: workoutDateRange) { Text("Workout") } } } ### Styling progress views You can customize the appearance and interaction of progress views by creating styles that conform to the `ProgressViewStyle` protocol. To set a specific style for all progress view instances within a view, use the `progressViewStyle(_:)` modifier. In the following example, a custom style adds a rounded pink border to all progress views within the enclosing `VStack`: struct BorderedProgressViews: View { var body: some View { VStack { ProgressView(value: 0.25) { Text("25% progress") } ProgressView(value: 0.75) { Text("75% progress") } } .progressViewStyle(PinkBorderedProgressViewStyle()) } } struct PinkBorderedProgressViewStyle: ProgressViewStyle { ProgressView(configuration) .padding(4) .border(.pink, width: 3) .cornerRadius(4) } } SwiftUI provides two built-in progress view styles, `linear` and `circular`, as well as an automatic style that defaults to the most appropriate style in the current context. The following example shows a circular progress view that starts at 60 percent completed. struct CircularProgressDemoView: View { @State private var progress = 0.6 var body: some View { VStack { ProgressView(value: progress) .progressViewStyle(.circular) } } } On platforms other than macOS, the circular style may appear as an indeterminate indicator instead. ## Topics ### Creating an indeterminate progress view `init()` Creates a progress view for showing indeterminate progress, without a label. Creates a progress view for showing indeterminate progress that displays a custom label. `init(LocalizedStringKey)` Creates a progress view for showing indeterminate progress that generates its label from a localized string. Creates a progress view for showing indeterminate progress that generates its label from a string. ### Creating a determinate progress view `init(Progress)` Creates a progress view for visualizing the given progress instance. Creates a progress view for showing determinate progress. `init(_:value:total:)` Creates a progress view for showing determinate progress that generates its label from a string. Creates a progress view for showing determinate progress, with a custom label. ### Create a progress view spanning a date range Creates a progress view for showing continuous progress as time passes. Creates a progress view for showing continuous progress as time passes, with a descriptive label. Creates a progress view for showing continuous progress as time passes, with descriptive and current progress labels. ### Initializers `init(_:)` Creates a progress view based on a style configuration. ## Relationships ### Conforms To - `View` ## See Also ### Indicating a value `struct Gauge` A view that shows a value within a range. Sets the style for gauges within this view. Sets the style for progress views in this view. `struct DefaultDateProgressLabel` The default type of the current value label when used by a date-relative progress view. `struct DefaultButtonLabel` The default label to use for a button. Beta --- # https://developer.apple.com/documentation/swiftui/progressviewstyleconfiguration/currentvaluelabel-swift.struct - SwiftUI - ProgressViewStyleConfiguration - ProgressViewStyleConfiguration.CurrentValueLabel Structure # ProgressViewStyleConfiguration.CurrentValueLabel A type-erased label that describes the current value of a progress view. @MainActor @preconcurrency struct CurrentValueLabel ## Relationships ### Conforms To - `View` ## See Also ### Configuring the current value label `var currentValueLabel: ProgressViewStyleConfiguration.CurrentValueLabel?` A view that describes the current value of a progress view. --- # https://developer.apple.com/documentation/swiftui/progressviewstyleconfiguration/label-swift.struct - SwiftUI - ProgressViewStyleConfiguration - ProgressViewStyleConfiguration.Label Structure # ProgressViewStyleConfiguration.Label A type-erased label describing the task represented by the progress view. @MainActor @preconcurrency struct Label ## Relationships ### Conforms To - `View` ## See Also ### Configuring the label `var label: ProgressViewStyleConfiguration.Label?` A view that describes the task represented by the progress view. --- # https://developer.apple.com/documentation/swiftui/radialgradient - SwiftUI - RadialGradient Structure # RadialGradient A radial gradient. @frozen struct RadialGradient ## Overview The gradient applies the color function as the distance from a center point, scaled to fit within the defined start and end radii. The gradient maps the unit space center point into the bounding rectangle of each shape filled with the gradient. When using a radial gradient as a shape style, you can also use `radialGradient(_:center:startRadius:endRadius:)`. ## Topics ### Creating a radial gradient `init(gradient: Gradient, center: UnitPoint, startRadius: CGFloat, endRadius: CGFloat)` Creates a radial gradient from a base gradient. [`init(colors: [Color], center: UnitPoint, startRadius: CGFloat, endRadius: CGFloat)`](https://developer.apple.com/documentation/swiftui/radialgradient/init(colors:center:startradius:endradius:)) Creates a radial gradient from a collection of colors. [`init(stops: [Gradient.Stop], center: UnitPoint, startRadius: CGFloat, endRadius: CGFloat)`](https://developer.apple.com/documentation/swiftui/radialgradient/init(stops:center:startradius:endradius:)) Creates a radial gradient from a collection of color stops. ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` - `ShapeStyle` - `View` ## See Also ### Supporting types `struct AngularGradient` An angular gradient. `struct EllipticalGradient` A radial gradient that draws an ellipse. `struct LinearGradient` A linear gradient. `struct Material` A background material type. `struct ImagePaint` A shape style that fills a shape by repeating a region of an image. `struct HierarchicalShapeStyle` A shape style that maps to one of the numbered content styles. `struct HierarchicalShapeStyleModifier` Styles that you can apply to hierarchical shapes. `struct ForegroundStyle` The foreground style in the current context. `struct BackgroundStyle` The background style in the current context. `struct SelectionShapeStyle` A style used to visually indicate selection following platform conventional colors and behaviors. `struct SeparatorShapeStyle` A style appropriate for foreground separator or border lines. `struct TintShapeStyle` A style that reflects the current tint color. `struct FillShapeStyle` A shape style that displays one of the overlay fills. `struct LinkShapeStyle` A style appropriate for links. `struct PlaceholderTextShapeStyle` A style appropriate for placeholder text. --- # https://developer.apple.com/documentation/swiftui/rectangle - SwiftUI - Rectangle Structure # Rectangle A rectangular shape aligned inside the frame of the view containing it. @frozen struct Rectangle ## Topics ### Creating a rectangle `init()` Creates a new rectangle shape. ## Relationships ### Conforms To - `Animatable` - `BitwiseCopyable` - `Copyable` - `InsettableShape` - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Creating rectangular shapes `struct RoundedRectangle` A rectangular shape with rounded corners, aligned inside the frame of the view containing it. `enum RoundedCornerStyle` Defines the shape of a rounded rectangle’s corners. `struct UnevenRoundedRectangle` A rectangular shape with rounded corners with different values, aligned inside the frame of the view containing it. `struct RectangleCornerRadii` Describes the corner radius values of a rounded rectangle with uneven corners. --- # https://developer.apple.com/documentation/swiftui/rotatedshape - SwiftUI - RotatedShape Structure # RotatedShape A shape with a rotation transform applied to it. @frozen ## Topics ### Creating a rotated shape `init(shape: Content, angle: Angle, anchor: UnitPoint)` ### Getting the shape’s characteristics `var anchor: UnitPoint` `var angle: Angle` `var shape: Content` ### Supporting types The data to animate. ## Relationships ### Conforms To - `Animatable` - `Copyable` - `InsettableShape` Conforms when `Content` conforms to `InsettableShape`. - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Transforming a shape `struct ScaledShape` A shape with a scale transform applied to it. `struct OffsetShape` A shape with a translation offset transform applied to it. `struct TransformedShape` A shape with an affine transform applied to it. --- # https://developer.apple.com/documentation/swiftui/roundedrectangle - SwiftUI - RoundedRectangle Structure # RoundedRectangle A rectangular shape with rounded corners, aligned inside the frame of the view containing it. @frozen struct RoundedRectangle ## Topics ### Creating a rounded rectangle `init(cornerRadius: CGFloat, style: RoundedCornerStyle)` Creates a new rounded rectangle shape. `init(cornerSize: CGSize, style: RoundedCornerStyle)` ### Getting the shape’s characteristics `var cornerSize: CGSize` The width and height of the rounded rectangle’s corners. `var style: RoundedCornerStyle` The style of corners drawn by the rounded rectangle. ### Supporting types `var animatableData: CGSize.AnimatableData` The data to animate. ## Relationships ### Conforms To - `Animatable` - `Copyable` - `InsettableShape` - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Creating rectangular shapes `struct Rectangle` A rectangular shape aligned inside the frame of the view containing it. `enum RoundedCornerStyle` Defines the shape of a rounded rectangle’s corners. `struct UnevenRoundedRectangle` A rectangular shape with rounded corners with different values, aligned inside the frame of the view containing it. `struct RectangleCornerRadii` Describes the corner radius values of a rounded rectangle with uneven corners. --- # https://developer.apple.com/documentation/swiftui/scaledshape - SwiftUI - ScaledShape Structure # ScaledShape A shape with a scale transform applied to it. @frozen ## Topics ### Creating a scaled shape `init(shape: Content, scale: CGSize, anchor: UnitPoint)` ### Getting the shape’s characteristics `var anchor: UnitPoint` `var scale: CGSize` `var shape: Content` ### Supporting types The data to animate. ## Relationships ### Conforms To - `Animatable` - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Transforming a shape `struct RotatedShape` A shape with a rotation transform applied to it. `struct OffsetShape` A shape with a translation offset transform applied to it. `struct TransformedShape` A shape with an affine transform applied to it. --- # https://developer.apple.com/documentation/swiftui/scrollview - SwiftUI - ScrollView Structure # ScrollView A scrollable view. ## Mentioned in Picking container views for your content Creating performant scrollable stacks Grouping data with lazy stack views ## Overview The scroll view displays its content within the scrollable content region. As the user performs platform-appropriate scroll gestures, the scroll view adjusts what portion of the underlying content is visible. `ScrollView` can scroll horizontally, vertically, or both, but does not provide zooming functionality. In the following example, a `ScrollView` allows the user to scroll through a `VStack` containing 100 `Text` views. The image after the listing shows the scroll view’s temporarily visible scrollbar at the right; you can disable it with the `showsIndicators` parameter of the `ScrollView` initializer. var body: some View { ScrollView { VStack(alignment: .leading) { ForEach(0..<100) { Text("Row \($0)") } } } } ### Controlling Scroll Position You can influence where a scroll view is initially scrolled by using the `defaultScrollAnchor(_:)` view modifier. Provide a value of \`UnitPoint/center\`\` to have the scroll view start in the center of its content when a scroll view is scrollable in both axes. ScrollView([.horizontal, .vertical]) { // initially centered content } .defaultScrollAnchor(.center) Or provide an alignment of \`UnitPoint/bottom\`\` to have the scroll view start at the bottom of its content when a scroll view is scrollable in its vertical axes. ScrollView { // initially bottom aligned content } .defaultScrollAnchor(.bottom) After the scroll view initially renders, the user may scroll the content of the scroll view. To perform programmatic scrolling, wrap one or more scroll views with a `ScrollViewReader`. ## Topics ### Creating a scroll view Creates a new instance that’s scrollable in the direction of the given axis and can show indicators while scrolling. Deprecated ### Configuring a scroll view `var content: Content` The scroll view’s content. `var axes: Axis.Set` The scrollable axes of the scroll view. `var showsIndicators: Bool` A value that indicates whether the scroll view displays the scrollable component of the content offset, in a way that’s suitable for the platform. ### Supporting types `var body: some View` The content and behavior of the scroll view. ## Relationships ### Conforms To - `View` ## See Also ### Creating a scroll view `struct ScrollViewReader` A view that provides programmatic scrolling, by working with a proxy to scroll to known child views. `struct ScrollViewProxy` A proxy value that supports programmatic scrolling of the scrollable views within a view hierarchy. --- # https://developer.apple.com/documentation/swiftui/scrollviewreader - SwiftUI - ScrollViewReader Structure # ScrollViewReader A view that provides programmatic scrolling, by working with a proxy to scroll to known child views. @frozen ## Overview The scroll view reader’s content view builder receives a `ScrollViewProxy` instance; you use the proxy’s `scrollTo(_:anchor:)` to perform scrolling. The following example creates a `ScrollView` containing 100 views that together display a color gradient. It also contains two buttons, one each at the top and bottom. The top button tells the `ScrollViewProxy` to scroll to the bottom button, and vice versa. @Namespace var topID @Namespace var bottomID var body: some View { ScrollViewReader { proxy in ScrollView { Button("Scroll to Bottom") { withAnimation { proxy.scrollTo(bottomID) } } .id(topID) VStack(spacing: 0) { ForEach(0..<100) { i in color(fraction: Double(i) / 100) .frame(height: 32) } } Button("Top") { withAnimation { proxy.scrollTo(topID) } } .id(bottomID) } } } Color(red: fraction, green: 1 - fraction, blue: 0.5) } ## Topics ### Creating a scroll view reader Creates an instance that can perform programmatic scrolling of its child scroll views. ### Configuring a scroll view reader The view builder that creates the reader’s content. ## Relationships ### Conforms To - `View` ## See Also ### Creating a scroll view `struct ScrollView` A scrollable view. `struct ScrollViewProxy` A proxy value that supports programmatic scrolling of the scrollable views within a view hierarchy. --- # https://developer.apple.com/documentation/swiftui/searchunavailablecontent/actions - SwiftUI - SearchUnavailableContent - SearchUnavailableContent.Actions Structure # SearchUnavailableContent.Actions A view that represents the actions of a static `ContentUnavailableView.search` view. @MainActor @preconcurrency struct Actions ## Overview You don’t create this type directly. SwiftUI creates it when you build a search `ContentUnavailableView`. ## Relationships ### Conforms To - `View` ## See Also ### Getting content types `struct Description` A view that represents the description of a static `ContentUnavailableView.search` view. `struct Label` A view that represents the label of a static placeholder search view. --- # https://developer.apple.com/documentation/swiftui/searchunavailablecontent/description - SwiftUI - SearchUnavailableContent - SearchUnavailableContent.Description Structure # SearchUnavailableContent.Description A view that represents the description of a static `ContentUnavailableView.search` view. @MainActor @preconcurrency struct Description ## Overview You don’t create this type directly. SwiftUI creates it when you build a search\`\`ContentUnavailableView\`. ## Relationships ### Conforms To - `View` ## See Also ### Getting content types `struct Actions` A view that represents the actions of a static `ContentUnavailableView.search` view. `struct Label` A view that represents the label of a static placeholder search view. --- # https://developer.apple.com/documentation/swiftui/searchunavailablecontent/label - SwiftUI - SearchUnavailableContent - SearchUnavailableContent.Label Structure # SearchUnavailableContent.Label A view that represents the label of a static placeholder search view. @MainActor @preconcurrency struct Label ## Overview You don’t create this type directly. SwiftUI creates it when you build a search `ContentUnavailableView`. ## Relationships ### Conforms To - `View` ## See Also ### Getting content types `struct Actions` A view that represents the actions of a static `ContentUnavailableView.search` view. `struct Description` A view that represents the description of a static `ContentUnavailableView.search` view. --- # https://developer.apple.com/documentation/swiftui/section - SwiftUI - Section Structure # Section A container view that you can use to add hierarchy within certain views. ## Mentioned in Grouping data with lazy stack views Populating SwiftUI menus with adaptive controls Suggesting search terms Displaying data in lists ## Overview Use `Section` instances in views like `List`, `Picker`, and `Form` to organize content into separate sections. Each section has custom content that you provide on a per-instance basis. You can also provide headers and footers for each section. ### Collapsible sections Create sections that expand and collapse by using an initializer that accepts an `isExpanded` binding. A collapsible section in a `List` that uses the `sidebar` style shows a disclosure indicator next to the section’s header. Tapping on the disclosure indicator toggles the appearance of the section’s content. ## Topics ### Creating a section `init(content:)` Creates a section with the provided section content. `init(_:content:)` ### Adding headers and footers `init(content:header:)` Creates a section with a header and the provided section content. Creates a section with a footer and the provided section content. Creates a section with a header, footer, and the provided section content. ### Controlling collapsibility `init(_:isExpanded:content:)` `init(isExpanded:content:header:)` Creates a section with a header, the provided section content, and a binding representing the section’s expansion state. ### Deprecated symbols Deprecated Sets whether a section can be collapsed by the user. ## Relationships ### Conforms To - `Copyable` - `TableRowContent` Conforms when `Parent` conforms to `TableRowContent`, `Content` conforms to `TableRowContent`, and `Footer` conforms to `TableRowContent`. - `View` Conforms when `Parent` conforms to `View`, `Content` conforms to `View`, and `Footer` conforms to `View`. ## See Also ### Organizing views into sections `struct SectionCollection` An opaque collection representing the sections of view. `struct SectionConfiguration` Specifies the contents of a section. --- # https://developer.apple.com/documentation/swiftui/sectionconfiguration/actions-swift.struct - SwiftUI - SectionConfiguration - SectionConfiguration.Actions Structure # SectionConfiguration.Actions The type-erased actions of a section. @MainActor @preconcurrency struct Actions ## Relationships ### Conforms To - `Sendable` - `SendableMetatype` - `View` --- # https://developer.apple.com/documentation/swiftui/securefield - SwiftUI - SecureField Structure # SecureField A control into which people securely enter private text. ## Overview Use a secure field when you want the behavior of a `TextField`, but you want to hide the field’s text. Typically, you use this for entering passwords and other sensitive information, as the second field in the following screenshot demonstrates: The field: - Displays one dot for each character someone types. - Hides the dots when someone takes a screenshot in iOS. - Prevents anyone from cutting or copying the field’s contents. - Displays an indicator when Caps Lock is enabled. ### Bind to a string A secure field binds to a string value and updates the string on every keystroke or other edit, so you can read its value at any time from elsewhere in your code. The following code shows how to create the above interface, with the secure field bound to a `password` string: @State private var username: String = "" @State private var password: String = "" var body: some View { VStack { TextField("Username", text: $username) .autocorrectionDisabled(true) #if !os(macOS) .textInputAutocapitalization(.never) #endif SecureField("Password", text: $password) .onSubmit { handleLogin(username: username, password: password) } } .textFieldStyle(.roundedBorder) } The field in the above example has an `onSubmit(of:_:)` modifier that sends the `username` and `password` strings to a custom `handleLogin(username:password:)` method if someone presses the Return key while the secure field has focus. You can alternatively provide another mechanism — like a button — to do the same thing. ### Guide people with a prompt In addition to the string or view that you provide as a label, you can also provide a `Text` view prompt to help guide someone who uses the field, as the following `Form` does: Form { TextField(text: $username, prompt: Text("Required")) { Text("Username") } .autocorrectionDisabled(true) #if !os(macOS) #endif SecureField(text: $password, prompt: Text("Required")) { Text("Password") } } The system uses the label and prompt in different ways depending on the context. For example, a form in macOS places the label against the leading edge of the field and uses the prompt as placeholder text inside the field. The same form in iOS also uses the prompt as placeholder text, but doesn’t display the label: If you remove the prompt from the previous example, the field keeps the label on the leading edge and omits the placeholder text in macOS, but displays the label as a placeholder in iOS: ## Topics ### Creating a secure text field `init(_:text:)` Creates a secure field with a prompt generated from a `Text`. `init(_:text:prompt:)` ### Deprecated initializers `init(_:text:onCommit:)` Creates an instance. Deprecated ## Relationships ### Conforms To - `View` ## See Also ### Getting text input Building rich SwiftUI text experiences Build an editor for formatted text using SwiftUI text editor views and attributed strings. `struct TextField` A control that displays an editable text interface. Sets the style for text fields within this view. `struct TextEditor` A view that can display and edit long-form text. --- # https://developer.apple.com/documentation/swiftui/sharelink - SwiftUI - ShareLink Structure # ShareLink A view that controls a sharing presentation. ## Overview People tap or click on a share link to present a share interface. The link typically uses a system-standard appearance; you only need to supply the content to share: ShareLink(item: URL(string: "https://developer.apple.com/xcode/swiftui/")!) You can control the appearance of the link by providing view content. For example, you can use a `Label` to display a link with a custom icon: ShareLink(item: URL(string: "https://developer.apple.com/xcode/swiftui/")!) { Label("Share", image: "MyCustomShareIcon") } If you only wish to customize the link’s title, you can use one of the convenience initializers that takes a string and creates a `Label` for you: ShareLink("Share URL", item: URL(string: "https://developer.apple.com/xcode/swiftui/")!) The link can share any content that is `Transferable`. Many framework types, like `URL`, already conform to this protocol. You can also make your own types transferable. For example, you can use `ProxyRepresentation` to resolve your own type to a framework type: struct Photo: Transferable { static var transferRepresentation: some TransferRepresentation { ProxyRepresentation(\.image) } public var image: Image public var caption: String } struct PhotoView: View { let photo: Photo var body: View { photo.image .toolbar { ShareLink( item: photo, preview: SharePreview( photo.caption, image: photo.image)) } } } Sometimes the content that your app shares isn’t immediately available. You can use `FileRepresentation` or `DataRepresentation` when you need an asynchronous operation, like a network request, to retrieve and prepare the content. A `Transferable` type also lets you provide multiple content types for a single shareable item. The share interface shows relevant sharing services based on the types that you provide. The previous example also shows how you provide a preview of your content to show in the share interface. A preview isn’t required when sharing URLs or non-attributed strings. When sharing these types of content, the system can automatically determine a preview. You can provide a preview even when it’s optional. For instance, when sharing URLs, the automatic preview first shows a placeholder link icon alongside the base URL while fetching the link’s metadata over the network. The preview updates once the link’s icon and title become available. If you provide a preview instead, the preview appears immediately without fetching data over the network. Some share activities support subject and message fields. You can pre-populate these fields with the `subject` and `message` parameters: ShareLink( item: photo, subject: Text("Cool Photo"), message: Text("Check it out!") preview: SharePreview( photo.caption, image: photo.image)) ## Topics ### Sharing an item `init(item:subject:message:)` Creates an instance that presents the share interface. `init(_:item:subject:message:)` Creates an instance, with a custom label, that presents the share interface. `init(item:subject:message:label:)` ### Sharing an item with a preview `init(_:item:subject:message:preview:)` ### Sharing items `init(items:subject:message:)` `init(_:items:subject:message:)` `init(items:subject:message:label:)` ### Sharing items with a preview `init(_:items:subject:message:preview:)` ### Supporting types `struct DefaultShareLinkLabel` The default label used for a share link. ## Relationships ### Conforms To - `View` ## See Also ### Linking to other content `struct Link` A control for navigating to a URL. `struct SharePreview` A representation of a type to display in a share preview. `struct TextFieldLink` A control that requests text input from the user when pressed. `struct HelpLink` A button with a standard appearance that opens app-specific help documentation. --- # https://developer.apple.com/documentation/swiftui/slider - SwiftUI - Slider Structure # Slider A control for selecting a value from a bounded linear range of values. ## Mentioned in Populating SwiftUI menus with adaptive controls ## Overview A slider consists of a “thumb” image that the user moves between two extremes of a linear “track”. The ends of the track represent the minimum and maximum possible values. As the user moves the thumb, the slider updates its bound value. The following example shows a slider bound to the value `speed`. As the slider updates this value, a bound `Text` view shows the value updating. The `onEditingChanged` closure passed to the slider receives callbacks when the user drags the slider. The example uses this to change the color of the value text. @State private var speed = 50.0 @State private var isEditing = false var body: some View { VStack { Slider( value: $speed, in: 0...100, onEditingChanged: { editing in isEditing = editing } ) Text("\(speed)") .foregroundColor(isEditing ? .red : .blue) } } You can also use a `step` parameter to provide incremental steps along the path of the slider. For example, if you have a slider with a range of `0` to `100`, and you set the `step` value to `5`, the slider’s increments would be `0`, `5`, `10`, and so on. The following example shows this approach, and also adds optional minimum and maximum value labels. var body: some View { Slider( value: $speed, in: 0...100, step: 5 ) { Text("Speed") } minimumValueLabel: { Text("0") } maximumValueLabel: { Text("100") } onEditingChanged: { editing in isEditing = editing } Text("\(speed)") .foregroundColor(isEditing ? .red : .blue) } The slider also uses the `step` to increase or decrease the value when a VoiceOver user adjusts the slider with voice commands. ## Topics ### Creating a slider Creates a slider to select a value from a given range. Creates a slider to select a value from a given range, subject to a step increment. ### Creating a slider with labels Creates a slider to select a value from a given range, which displays the provided label. Creates a slider to select a value from a given range, subject to a step increment, which displays the provided label. Creates a slider to select a value from a given range, which displays the provided labels. Creates a slider to select a value from a given range, subject to a step increment, which displays the provided labels. ### Deprecated initializers Deprecated ## Relationships ### Conforms To - `View` ## See Also ### Getting numeric inputs `struct Stepper` A control that performs increment and decrement actions. `struct Toggle` A control that toggles between on and off states. Sets the style for toggles in a view hierarchy. --- # https://developer.apple.com/documentation/swiftui/spacer - SwiftUI - Spacer Structure # Spacer A flexible space that expands along the major axis of its containing stack layout, or on both axes if not contained in a stack. @frozen struct Spacer ## Mentioned in Building layouts with stack views Adding a background to your view Picking container views for your content ## Overview A spacer creates an adaptive view with no content that expands as much as it can. For example, when placed within an `HStack`, a spacer expands horizontally as much as the stack allows, moving sibling views out of the way, within the limits of the stack’s size. SwiftUI sizes a stack that doesn’t contain a spacer up to the combined ideal widths of the content of the stack’s child views. The following example provides a simple checklist row to illustrate how you can use a spacer: struct ChecklistRow: View { let name: String var body: some View { HStack { Image(systemName: "checkmark") Text(name) } .border(Color.blue) } } Adding a spacer before the image creates an adaptive view with no content that expands to push the image and text to the right side of the stack. The stack also now expands to take as much space as the parent view allows, shown by the blue border that indicates the boundary of the stack: var body: some View { HStack { Spacer() Image(systemName: "checkmark") Text(name) } .border(Color.blue) } } Moving the spacer between the image and the name pushes those elements to the left and right sides of the `HStack`, respectively. Because the stack contains the spacer, it expands to take as much horizontal space as the parent view allows; the blue border indicates its size: var body: some View { HStack { Image(systemName: "checkmark") Spacer() Text(name) } .border(Color.blue) } } Adding two spacer views on the outside of the stack leaves the image and text together, while the stack expands to take as much horizontal space as the parent view allows: var body: some View { HStack { Spacer() Image(systemName: "checkmark") Text(name) Spacer() } .border(Color.blue) } } ## Topics ### Creating a spacer `init(minLength: CGFloat?)` `var minLength: CGFloat?` The minimum length this spacer can be shrunk to, along the axis or axes of expansion. ## Relationships ### Conforms To - `BitwiseCopyable` - `Copyable` - `Sendable` - `SendableMetatype` - `View` ## See Also ### Separators `struct Divider` A visual element that can be used to separate other content. --- # https://developer.apple.com/documentation/swiftui/stepper - SwiftUI - Stepper Structure # Stepper A control that performs increment and decrement actions. ## Overview Use a stepper control when you want the user to have granular control while incrementing or decrementing a value. For example, you can use a stepper to: - Change a value up or down by `1`. - Operate strictly over a prescribed range. - Step by specific amounts over a stepper’s range of possible values. The example below uses an array that holds a number of `Color` values, a local state variable, `value`, to set the control’s background color, and title label. When the user clicks or taps the stepper’s increment or decrement buttons, SwiftUI executes the relevant closure that updates `value`, wrapping the `value` to prevent overflow. SwiftUI then re-renders the view, updating the text and background color to match the current index: struct StepperView: View { @State private var value = 0 let colors: [Color] = [.orange, .red, .gray, .blue,\ .green, .purple, .pink] func incrementStep() { value += 1 } func decrementStep() { value -= 1 if value < 0 { value = colors.count - 1 } } var body: some View { Stepper { Text("Value: \(value) Color: \(colors[value].description)") } onIncrement: { incrementStep() } onDecrement: { decrementStep() } .padding(5) .background(colors[value]) } } The following example shows a stepper that displays the effect of incrementing or decrementing a value with the step size of `step` with the bounds defined by `range`: struct StepperView: View { @State private var value = 0 let step = 5 let range = 1...50 var body: some View { Stepper( value: $value, in: range, step: step ) { Text("Current: \(value) in \(range.description) " + "stepping by \(step)") } .padding(10) } } ## Topics ### Creating a stepper Creates a stepper configured to increment or decrement a binding to a value using a step value you provide. Creates a stepper configured to increment or decrement a binding to a value using a step value you provide, displaying its value with an applied format style. `init(_:value:step:onEditingChanged:)` Creates a stepper with a title and configured to increment and decrement a binding to a value and step amount you provide. `init(_:value:step:format:onEditingChanged:)` Creates a stepper with a title key and configured to increment and decrement a binding to a value and step amount you provide, displaying its value with an applied format style. ### Creating a stepper over a range Creates a stepper configured to increment or decrement a binding to a value using a step value and within a range of values you provide. Creates a stepper configured to increment or decrement a binding to a value using a step value and within a range of values you provide, displaying its value with an applied format style. `init(_:value:in:step:onEditingChanged:)` Creates a stepper instance that increments and decrements a binding to a value, by a step size and within a closed range that you provide. `init(_:value:in:step:format:onEditingChanged:)` Creates a stepper instance that increments and decrements a binding to a value, by a step size and within a closed range that you provide, displaying its value with an applied format style. ### Creating a stepper with change behavior Creates a stepper instance that performs the closures you provide when the user increments or decrements the stepper. `init(_:onIncrement:onDecrement:onEditingChanged:)` Creates a stepper that uses a title key and executes the closures you provide when the user clicks or taps the stepper’s increment and decrement buttons. ### Deprecated initializers Deprecated ## Relationships ### Conforms To - `View` ## See Also ### Getting numeric inputs `struct Slider` A control for selecting a value from a bounded linear range of values. `struct Toggle` A control that toggles between on and off states. Sets the style for toggles in a view hierarchy. --- # https://developer.apple.com/documentation/swiftui/strokebordershapeview - SwiftUI - StrokeBorderShapeView Structure # StrokeBorderShapeView A shape provider that strokes the border of its shape. @frozen ## Overview You don’t create this type directly; it’s the return type of `Shape.strokeBorder`. ## Topics ### Creating a stroke border shape view `init(shape: Content, style: Style, strokeStyle: StrokeStyle, isAntialiased: Bool, background: Background)` Create a stroke border shape. ### Getting shape view properties `var background: Background` The background shown beneath this view. `var isAntialiased: Bool` Whether this shape should be drawn antialiased. `var shape: Content` The shape that this type draws and provides for other drawing operations. `var strokeStyle: StrokeStyle` The stroke style used when stroking this view’s shape. `var style: Style` The style that strokes the border of this view’s shape. ## Relationships ### Conforms To - `ShapeView` - `View` ## See Also ### Defining shape behavior `protocol ShapeView` A view that provides a shape that you can use for drawing operations. `protocol Shape` A 2D shape that you can use when drawing a view. `struct AnyShape` A type-erased shape value. `enum ShapeRole` Ways of styling a shape. `struct StrokeStyle` The characteristics of a stroke that traces a path. `struct StrokeShapeView` A shape provider that strokes its shape. `struct FillStyle` A style for rasterizing vector shapes. `struct FillShapeView` A shape provider that fills its shape. --- # https://developer.apple.com/documentation/swiftui/strokeshapeview - SwiftUI - StrokeShapeView Structure # StrokeShapeView A shape provider that strokes its shape. @frozen ## Overview You don’t create this type directly; it’s the return type of `Shape.stroke`. ## Topics ### Creating a stroke shape view `init(shape: Content, style: Style, strokeStyle: StrokeStyle, isAntialiased: Bool, background: Background)` Create a StrokeShapeView. ### Getting shape view properties `var background: Background` The background shown beneath this view. `var isAntialiased: Bool` Whether this shape should be drawn antialiased. `var shape: Content` The shape that this type draws and provides for other drawing operations. `var strokeStyle: StrokeStyle` The stroke style used when stroking this view’s shape. `var style: Style` The style that strokes this view’s shape. ## Relationships ### Conforms To - `ShapeView` - `View` ## See Also ### Defining shape behavior `protocol ShapeView` A view that provides a shape that you can use for drawing operations. `protocol Shape` A 2D shape that you can use when drawing a view. `struct AnyShape` A type-erased shape value. `enum ShapeRole` Ways of styling a shape. `struct StrokeStyle` The characteristics of a stroke that traces a path. `struct StrokeBorderShapeView` A shape provider that strokes the border of its shape. `struct FillStyle` A style for rasterizing vector shapes. `struct FillShapeView` A shape provider that fills its shape. --- # https://developer.apple.com/documentation/swiftui/subscriptionview - SwiftUI - SubscriptionView Structure # SubscriptionView A view that subscribes to a publisher with an action. @frozen ## Topics ### Managing the subscription `var publisher: PublisherType` The `Publisher` that is being subscribed. The `Action` executed when `publisher` emits an event. `var content: Content` The content view. ## Relationships ### Conforms To - `View` ## See Also ### Supporting view types `struct AnyView` A type-erased view. `struct EmptyView` A view that doesn’t contain any content. `struct EquatableView` A view type that compares itself against its previous value and prevents its child updating if its new value is the same as its old value. `struct TupleView` A View created from a swift tuple of View values. --- # https://developer.apple.com/documentation/swiftui/subview - SwiftUI - Subview Structure # Subview An opaque value representing a subview of another view. struct Subview ## Overview Access to a `Subview` can be obtained by using `ForEach(subviews:)` or `Group(subviews:)`. Subviews are proxies to the resolved view they represent, meaning that modifiers applied to the original view will be applied before modifiers applied to the subview, and the view is resolved using the environment of its container, _not_ the environment of the its subview proxy. Additionally, because subviews must represent a single leaf view, or container, a subview may represent a view after the application of styles. As such, attempting to apply a style to it may have no affect. ## Topics ### Structures `struct ID` A unique identifier for a subview. ### Instance Properties `var containerValues: ContainerValues` The container values associated with the given subview. `var id: Subview.ID` The unique identifier of the view. ### Enumerations `enum ContainerSizingOptions` Options on how all subviews should be sized when in a container. Beta ## Relationships ### Conforms To - `Identifiable` - `View` ## See Also ### Accessing a container’s subviews `struct SubviewsCollection` An opaque collection representing the subviews of view. `struct SubviewsCollectionSlice` A slice of a SubviewsCollection. Sets a particular container value of a view. `struct ContainerValues` A collection of container values associated with a given view. `protocol ContainerValueKey` A key for accessing container values. --- # https://developer.apple.com/documentation/swiftui/subviewscollection - SwiftUI - SubviewsCollection Structure # SubviewsCollection An opaque collection representing the subviews of view. struct SubviewsCollection ## Overview Subviews collection constructs subviews on demand, so only access the part of the collection you need to create the resulting content. You can get access to a view’s subview collection by using the `Group/init(sectionsOf:transform:)` initializer. The collection’s elements are the pieces that make up the given view, and the collection as a whole acts as a proxy for the original view. ## Relationships ### Conforms To - `BidirectionalCollection` - `Collection` - `Copyable` - `RandomAccessCollection` - `Sequence` - `View` ## See Also ### Accessing a container’s subviews `struct Subview` An opaque value representing a subview of another view. `struct SubviewsCollectionSlice` A slice of a SubviewsCollection. Sets a particular container value of a view. `struct ContainerValues` A collection of container values associated with a given view. `protocol ContainerValueKey` A key for accessing container values. --- # https://developer.apple.com/documentation/swiftui/subviewscollectionslice - SwiftUI - SubviewsCollectionSlice Structure # SubviewsCollectionSlice A slice of a SubviewsCollection. struct SubviewsCollectionSlice ## Relationships ### Conforms To - `BidirectionalCollection` - `Collection` - `Copyable` - `RandomAccessCollection` - `Sequence` - `View` ## See Also ### Accessing a container’s subviews `struct Subview` An opaque value representing a subview of another view. `struct SubviewsCollection` An opaque collection representing the subviews of view. Sets a particular container value of a view. `struct ContainerValues` A collection of container values associated with a given view. `protocol ContainerValueKey` A key for accessing container values. --- # https://developer.apple.com/documentation/swiftui/tabcontentbuilder/content - SwiftUI - TabContentBuilder - TabContentBuilder.Content Structure # TabContentBuilder.Content A view representation of the content of a builder-based tab view with selection. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/table - SwiftUI - Table Structure # Table A container that presents rows of data arranged in one or more columns, optionally providing the ability to select one or more members. ## Overview You commonly create tables from collections of data. The following example shows how to create a simple, three-column table from an array of `Person` instances that conform to the `Identifiable` protocol: struct Person: Identifiable { let givenName: String let familyName: String let emailAddress: String let id = UUID() var fullName: String { givenName + " " + familyName } } @State private var people = [\ Person(givenName: "Juan", familyName: "Chavez", emailAddress: "juanchavez@icloud.com"),\ Person(givenName: "Mei", familyName: "Chen", emailAddress: "meichen@icloud.com"),\ Person(givenName: "Tom", familyName: "Clark", emailAddress: "tomclark@icloud.com"),\ Person(givenName: "Gita", familyName: "Kumar", emailAddress: "gitakumar@icloud.com")\ ] struct PeopleTable: View { var body: some View { Table(people) { TableColumn("Given Name", value: \.givenName) TableColumn("Family Name", value: \.familyName) TableColumn("E-Mail Address", value: \.emailAddress) } } } If there are more rows than can fit in the available space, `Table` provides vertical scrolling automatically. On macOS, the table also provides horizontal scrolling if there are more columns than can fit in the width of the view. Scroll bars appear as needed on iOS; on macOS, the `Table` shows or hides scroll bars based on the “Show scroll bars” system preference. ### Supporting selection in tables To make rows of a table selectable, provide a binding to a selection variable. Binding to a single instance of the table data’s `id` type creates a single-selection table. Binding to a `Set` creates a table that supports multiple selections. The following example shows how to add multi-select to the previous example. A `Text` view below the table shows the number of items currently selected. struct SelectableTable: View { var body: some View { Table(people, selection: $selectedPeople) { TableColumn("Given Name", value: \.givenName) TableColumn("Family Name", value: \.familyName) TableColumn("E-Mail Address", value: \.emailAddress) } Text("\(selectedPeople.count) people selected") } } ### Supporting sorting in tables To make the columns of a table sortable, provide a binding to an array of `SortComparator` instances. The table reflects the sorted state through its column headers, allowing sorting for any columns with key paths. When the table sort descriptors update, re-sort the data collection that underlies the table; the table itself doesn’t perform a sort operation. You can watch for changes in the sort descriptors by using a `onChange(of:perform:)` modifier, and then sort the data in the modifier’s `perform` closure. The following example shows how to add sorting capability to the previous example: struct SortableTable: View { @State private var sortOrder = [KeyPathComparator(\Person.givenName)] var body: some View { Table(people, sortOrder: $sortOrder) { TableColumn("Given Name", value: \.givenName) TableColumn("Family Name", value: \.familyName) TableColumn("E-Mail address", value: \.emailAddress) } .onChange(of: sortOrder) { _, sortOrder in people.sort(using: sortOrder) } } } ### Building tables with static rows To create a table from static rows, rather than the contents of a collection of data, you provide both the columns and the rows. The following example shows a table that calculates prices from applying varying gratuities (“tips”) to a fixed set of prices. It creates the table with the `init(of:columns:rows:)` initializer, with the `rows` parameter providing the base price that each row uses for its calculations. Each column receives each price and performs its calculation, producing a `Text` to display the formatted result. struct Purchase: Identifiable { let price: Decimal let id = UUID() } struct TipTable: View { let currencyStyle = Decimal.FormatStyle.Currency(code: "USD") var body: some View { Table(of: Purchase.self) { TableColumn("Base price") { purchase in Text(purchase.price, format: currencyStyle) } TableColumn("With 15% tip") { purchase in Text(purchase.price * 1.15, format: currencyStyle) } TableColumn("With 20% tip") { purchase in Text(purchase.price * 1.2, format: currencyStyle) } TableColumn("With 25% tip") { purchase in Text(purchase.price * 1.25, format: currencyStyle) } } rows: { TableRow(Purchase(price: 20)) TableRow(Purchase(price: 50)) TableRow(Purchase(price: 75)) } } } ### Styling tables Use the `tableStyle(_:)` modifier to set a `TableStyle` for all tables within a view. SwiftUI provides several table styles, such as `InsetTableStyle` and, on macOS, `BorderedTableStyle`. The default style is `AutomaticTableStyle`, which is available on all platforms that support `Table`. ### Using tables on different platforms You can define a single table for use on macOS, iOS, and iPadOS. However, on iPhone or in a compact horizontal size class environment — typical on on iPad in certain modes, like Slide Over — the table has limited space to display its columns. To conserve space, the table automatically hides headers and all columns after the first when it detects this condition. To provide a good user experience in a space-constrained environment, you can customize the first column to show more information when you detect that the `horizontalSizeClass` environment value becomes `UserInterfaceSizeClass.compact`. For example, you can modify the sortable table from above to conditionally show all the information in the first column: struct CompactableTable: View { #if os(iOS) @Environment(\.horizontalSizeClass) private var horizontalSizeClass private var isCompact: Bool { horizontalSizeClass == .compact } #else private let isCompact = false #endif @State private var sortOrder = [KeyPathComparator(\Person.givenName)] var body: some View { Table(people, sortOrder: $sortOrder) { TableColumn("Given Name", value: \.givenName) { person in VStack(alignment: .leading) { Text(isCompact ? person.fullName : person.givenName) if isCompact { Text(person.emailAddress) .foregroundStyle(.secondary) } } } TableColumn("Family Name", value: \.familyName) TableColumn("E-Mail Address", value: \.emailAddress) } .onChange(of: sortOrder) { _, sortOrder in people.sort(using: sortOrder) } } } By making this change, you provide a list-like appearance for narrower displays, while displaying the full table on wider ones. Because you use the same table instance in both cases, you get a seamless transition when the size class changes, like when someone moves your app into or out of Slide Over. ## Topics ### Creating a table from columns Creates a table that computes its rows based on a collection of identifiable data. `init(_:selection:columns:)` Creates a table that computes its rows based on a collection of identifiable data, and that supports selecting multiple rows. ### Creating a sortable table from columns Creates a sortable table that computes its rows based on a collection of identifiable data. `init(_:selection:sortOrder:columns:)` Creates a sortable table that computes its rows based on a collection of identifiable data, and supports selecting multiple rows. ### Creating a table from columns and rows Creates a table with the given columns and rows that generates its contents using values of the given type. `init(of:selection:columns:rows:)` Creates a table with the given columns and rows that supports selecting multiple rows that generates its data using values of the given type. ### Creating a sortable table from columns and rows Creates a sortable table with the given columns and rows. `init(of:selection:sortOrder:columns:rows:)` Creates a sortable table with the given columns and rows that supports selecting multiple rows. `init(selection:sortOrder:columns:rows:)` ### Creating a table with customizable columns `init(Data, columnCustomization: Binding>, columns: () -> Columns)` Creates a table that computes its rows based on a collection of identifiable data and has dynamically customizable columns. `init(_:selection:columnCustomization:columns:)` Creates a table that computes its rows based on a collection of identifiable data, that supports selecting multiple rows, and that has dynamically customizable columns. `init(_:selection:sortOrder:columnCustomization:columns:)` Creates a sortable table that computes its rows based on a collection of identifiable data, supports selecting multiple rows, and has dynamically customizable columns. [`init(Data, sortOrder: Binding<[Sort]>, columnCustomization: Binding>, columns: () -> Columns)`](https://developer.apple.com/documentation/swiftui/table/init(_:sortorder:columncustomization:columns:)) Creates a sortable table that computes its rows based on a collection of identifiable data and has dynamically customizable columns. ### Creating a table with dynamically customizable columns `init(of: Value.Type, columnCustomization: Binding>, columns: () -> Columns, rows: () -> Rows)` Creates a table with the given columns and rows that generates its contents using values of the given type and has dynamically customizable columns. `init(of:selection:columnCustomization:columns:rows:)` Creates a table with the given columns and rows that supports selecting multiple rows that generates its data using values of the given type and has dynamically customizable columns. `init(of:selection:sortOrder:columnCustomization:columns:rows:)` Creates a sortable table with the given columns and rows that supports selecting multiple rows and dynamically customizable columns. [`init(of: Value.Type, sortOrder: Binding<[Sort]>, columnCustomization: Binding>, columns: () -> Columns, rows: () -> Rows)`](https://developer.apple.com/documentation/swiftui/table/init(of:sortorder:columncustomization:columns:rows:)) Creates a sortable table with the given columns and rows and has dynamically customizable columns. ### Creating a hierarchical table `init(Data, children: KeyPath, columnCustomization: Binding>?, columns: () -> Columns)` Creates a hierarchical table that computes its rows based on a collection of identifiable data and key path to the children of that data. `init(_:children:selection:columnCustomization:columns:)` Creates a hierarchical table that computes its rows based on a collection of identifiable data and key path to the children of that data, and supports selecting multiple rows. `init(_:children:selection:sortOrder:columnCustomization:columns:)` Creates a sortable, hierarchical table that computes its rows based on a collection of identifiable data and key path to the children of that data, and supports selecting multiple rows. [`init(Data, children: KeyPath, sortOrder: Binding<[Sort]>, columnCustomization: Binding>?, columns: () -> Columns)`](https://developer.apple.com/documentation/swiftui/table/init(_:children:sortorder:columncustomization:columns:)) Creates a sortable, hierarchical table that computes its rows based on a collection of identifiable data and key path to the children of that data. ## Relationships ### Conforms To - `View` ## See Also ### Creating a table Building a Great Mac App with SwiftUI Create engaging SwiftUI Mac apps by incorporating side bars, tables, toolbars, and several other popular user interface elements. Sets the style for tables within this view. --- # https://developer.apple.com/documentation/swiftui/texteditor - SwiftUI - TextEditor Structure # TextEditor A view that can display and edit long-form text. struct TextEditor ## Overview A text editor view allows you to display and edit multiline, scrollable text in your app’s user interface. By default, the text editor view styles the text using characteristics inherited from the environment, like `font(_:)`, `foregroundColor(_:)`, and `multilineTextAlignment(_:)`. You create a text editor by adding a `TextEditor` instance to the body of your view, and initialize it by passing in a `Binding` to a string variable in your app: struct TextEditingView: View { @State private var fullText: String = "This is some editable text..." var body: some View { TextEditor(text: $fullText) } } To style the text, use the standard view modifiers to configure a system font, set a custom font, or change the color of the view’s text. In this example, the view renders the editor’s text in gray with a custom font: var body: some View { TextEditor(text: $fullText) .foregroundColor(Color.gray) .font(.custom("HelveticaNeue", size: 13)) } } If you want to change the spacing or font scaling aspects of the text, you can use modifiers like `lineLimit(_:)`, `lineSpacing(_:)`, and `minimumScaleFactor(_:)` to configure how the view displays text depending on the space constraints. For example, here the `lineSpacing(_:)` modifier sets the spacing between lines to 5 points: var body: some View { TextEditor(text: $fullText) .foregroundColor(Color.gray) .font(.custom("HelveticaNeue", size: 13)) .lineSpacing(5) } } ## Topics ### Creating a text editor Creates a plain text editor. ### Initializers `init(text:selection:)` Creates a styled text editor. ## Relationships ### Conforms To - `View` ## See Also ### Getting text input Building rich SwiftUI text experiences Build an editor for formatted text using SwiftUI text editor views and attributed strings. `struct TextField` A control that displays an editable text interface. Sets the style for text fields within this view. `struct SecureField` A control into which people securely enter private text. --- # https://developer.apple.com/documentation/swiftui/textfield - SwiftUI - TextField Structure # TextField A control that displays an editable text interface. ## Overview You create a text field with a label and a binding to a value. If the value is a string, the text field updates this value continuously as the user types or otherwise edits the text in the field. For non-string types, it updates the value when the user commits their edits, such as by pressing the Return key. The following example shows a text field to accept a username, and a `Text` view below it that shadows the continuously updated value of `username`. The `Text` view changes color as the user begins and ends editing. When the user submits their completed entry to the text field, the `onSubmit(of:_:)` modifier calls an internal `validate(name:)` method. @State private var username: String = "" @FocusState private var emailFieldIsFocused: Bool = false var body: some View { TextField( "User name (email address)", text: $username ) .focused($emailFieldIsFocused) .onSubmit { validate(name: username) } .textInputAutocapitalization(.never) .disableAutocorrection(true) .border(.secondary) Text(username) .foregroundColor(emailFieldIsFocused ? .red : .blue) } The bound value doesn’t have to be a string. By using a `FormatStyle`, you can bind the text field to a nonstring type, using the format style to convert the typed text into an instance of the bound type. The following example uses a `PersonNameComponents.FormatStyle` to convert the name typed in the text field to a `PersonNameComponents` instance. A `Text` view below the text field shows the debug description string of this instance. @State private var nameComponents = PersonNameComponents() var body: some View { TextField( "Proper name", value: $nameComponents, format: .name(style: .medium) ) .onSubmit { validate(components: nameComponents) } .disableAutocorrection(true) .border(.secondary) Text(nameComponents.debugDescription) } ### Text field prompts You can set an explicit prompt on the text field to guide users on what text they should provide. Each text field style determines where and when the text field uses a prompt and label. For example, a form on macOS always places the label at the leading edge of the field and uses a prompt, when available, as placeholder text within the field itself. In the same context on iOS, the text field uses either the prompt or label as placeholder text, depending on whether the initializer provided a prompt. The following example shows a `Form` with two text fields, each of which provides a prompt to indicate that the field is required, and a view builder to provide a label: Form { TextField(text: $username, prompt: Text("Required")) { Text("Username") } SecureField(text: $password, prompt: Text("Required")) { Text("Password") } } ### Styling text fields SwiftUI provides a default text field style that reflects an appearance and behavior appropriate to the platform. The default style also takes the current context into consideration, like whether the text field is in a container that presents text fields with a special style. Beyond this, you can customize the appearance and interaction of text fields using the `textFieldStyle(_:)` modifier, passing in an instance of `TextFieldStyle`. The following example applies the `roundedBorder` style to both text fields within a `VStack`. @State private var givenName: String = "" @State private var familyName: String = "" var body: some View { VStack { TextField( "Given Name", text: $givenName ) .disableAutocorrection(true) TextField( "Family Name", text: $familyName ) .disableAutocorrection(true) } .textFieldStyle(.roundedBorder) } ## Topics ### Creating a text field with a string `init(_:text:)` Creates a text field with a text label generated from a localized title string. `init(_:text:prompt:)` Creates a text field with a prompt generated from a `Text`. ### Creating a scrollable text field `init(_:text:axis:)` Creates a text field with a preferred axis and a text label generated from a localized title string. `init(_:text:prompt:axis:)` Creates a text field with a preferred axis and a prompt generated from a `Text`. ### Creating a text field with a value Use these initializers to create a text field that binds to a value of an arbitrary type. `init(_:value:format:prompt:)` Creates a text field that applies a format style to a bound value, with a label generated from a localized title string. `init(value:format:prompt:label:)` Creates a text field that applies a format style to a bound value, with a label generated from a view builder. `init(_:value:formatter:)` Create an instance which binds over an arbitrary type, `V`. `init(_:value:formatter:prompt:)` Creates a text field that applies a formatter to a bound value, with a label generated from a title string. Creates a text field that applies a formatter to a bound optional value, with a label generated from a view builder. ### Deprecated initializers Review deprecated text field initializers. ### Initializers `init(_:text:selection:prompt:axis:)` Creates a text field with a binding to the current selection and a text label generated from a localized title string. ## Relationships ### Conforms To - `View` ## See Also ### Getting text input Building rich SwiftUI text experiences Build an editor for formatted text using SwiftUI text editor views and attributed strings. Sets the style for text fields within this view. `struct SecureField` A control into which people securely enter private text. `struct TextEditor` A view that can display and edit long-form text. --- # https://developer.apple.com/documentation/swiftui/textfieldlink - SwiftUI - TextFieldLink Structure # TextFieldLink A control that requests text input from the user when pressed. ## Overview A `TextFieldLink` should be used to request text input from the user through a button interface. ## Topics ### Creating a text field link `init(_:prompt:onSubmit:)` Creates a TextFieldLink which when pressed will request text input from the user. ## Relationships ### Conforms To - `View` ## See Also ### Linking to other content `struct Link` A control for navigating to a URL. `struct ShareLink` A view that controls a sharing presentation. `struct SharePreview` A representation of a type to display in a share preview. `struct HelpLink` A button with a standard appearance that opens app-specific help documentation. --- # https://developer.apple.com/documentation/swiftui/timelineview - SwiftUI - TimelineView Structure # TimelineView A view that updates according to a schedule that you provide. ## Overview A timeline view acts as a container with no appearance of its own. Instead, it redraws the content it contains at scheduled points in time. For example, you can update the face of an analog timer once per second: TimelineView(.periodic(from: startDate, by: 1)) { context in AnalogTimerView(date: context.date) } The closure that creates the content receives an input of type `TimelineView.Context` that you can use to customize the content’s appearance. The context includes the `date` that triggered the update. In the example above, the timeline view sends that date to an analog timer that you create so the timer view knows how to draw the hands on its face. The context also includes a `cadence` property that you can use to hide unnecessary detail. For example, you can use the cadence to decide when it’s appropriate to display the timer’s second hand: TimelineView(.periodic(from: startDate, by: 1.0)) { context in AnalogTimerView( date: context.date, showSeconds: context.cadence <= .seconds) } The system might use a cadence that’s slower than the schedule’s update rate. For example, a view on watchOS might remain visible when the user lowers their wrist, but update less frequently, and thus require less detail. You can define a custom schedule by creating a type that conforms to the `TimelineSchedule` protocol, or use one of the built-in schedule types: - Use an `everyMinute` schedule to update at the beginning of each minute. - Use a `periodic(from:by:)` schedule to update periodically with a custom start time and interval between updates. - Use an `explicit(_:)` schedule when you need a finite number, or irregular set of updates. For a schedule containing only dates in the past, the timeline view shows the last date in the schedule. For a schedule containing only dates in the future, the timeline draws its content using the current date until the first scheduled date arrives. ## Topics ### Creating a timeline Creates a new timeline view that uses the given schedule. `struct Context` Information passed to a timeline view’s content callback. ### Deprecated symbols Deprecated ### Initializers `init(_:content:)` ## Relationships ### Conforms To - `Copyable` - `View` Conforms when `Schedule` conforms to `TimelineSchedule` and `Content` conforms to `View`. ## See Also ### Updating a view on a schedule Updating watchOS apps with timelines Seamlessly schedule updates to your user interface, even while it’s inactive. `protocol TimelineSchedule` A type that provides a sequence of dates for use as a schedule. `typealias TimelineViewDefaultContext` --- # https://developer.apple.com/documentation/swiftui/toggle - SwiftUI - Toggle Structure # Toggle A control that toggles between on and off states. ## Mentioned in Building and customizing the menu bar with SwiftUI Declaring a custom view Laying out a simple view Populating SwiftUI menus with adaptive controls ## Overview You create a toggle by providing an `isOn` binding and a label. Bind `isOn` to a Boolean property that determines whether the toggle is on or off. Set the label to a view that visually describes the purpose of switching between toggle states. For example: @State private var vibrateOnRing = false var body: some View { Toggle(isOn: $vibrateOnRing) { Text("Vibrate on Ring") } } For the common case of `Label` based labels, you can use the convenience initializer that takes a title string (or localized string key) and the name of a system image: @State private var vibrateOnRing = true var body: some View { Toggle( "Vibrate on Ring", systemImage: "dot.radiowaves.left.and.right", isOn: $vibrateOnRing ) } For text-only labels, you can use the convenience initializer that takes a title string (or localized string key) as its first parameter, instead of a trailing closure: var body: some View { Toggle("Vibrate on Ring", isOn: $vibrateOnRing) } For cases where adding a subtitle to the label is desired, use a view builder that creates multiple `Text` views where the first text represents the title and the second text represents the subtitle: var body: some View { Toggle(isOn: $vibrateOnRing) { Text("Vibrate on Ring") Text("Enable vibration when the phone rings") } } ### Styling toggles Toggles use a default style that varies based on both the platform and the context. For more information, read about the `automatic` toggle style. You can customize the appearance and interaction of toggles by applying styles using the `toggleStyle(_:)` modifier. You can apply built-in styles, like `switch`, to either a toggle, or to a view hierarchy that contains toggles: VStack { Toggle("Vibrate on Ring", isOn: $vibrateOnRing) Toggle("Vibrate on Silent", isOn: $vibrateOnSilent) } .toggleStyle(.switch) You can also define custom styles by creating a type that conforms to the `ToggleStyle` protocol. ## Topics ### Creating a toggle `init(_:isOn:)` Creates a toggle that generates its label from a localized string key. Creates a toggle that displays a custom label. `init(_:image:isOn:)` Creates a toggle that generates its label from a localized string key and image resource. `init(_:systemImage:isOn:)` Creates a toggle that generates its label from a localized string key and system image. ### Creating a toggle for a collection `init(_:sources:isOn:)` Creates a toggle representing a collection of values that generates its label from a localized string key. `init(sources: C, isOn: KeyPath>, label: () -> Label)` Creates a toggle representing a collection of values with a custom label. `init(_:image:sources:isOn:)` Creates a toggle representing a collection of values that generates its label from a localized string key and image resource. `init(_:systemImage:sources:isOn:)` Creates a toggle representing a collection of values that generates its label from a localized string key and system image. ### Creating a toggle from a configuration `init(ToggleStyleConfiguration)` Creates a toggle based on a toggle style configuration. ### Creating a toggle for an App Intent Creates a toggle performing an `AppIntent`. `init(_:isOn:intent:)` Creates a toggle performing an `AppIntent` and generates its label from a localized string key. ## Relationships ### Conforms To - `View` ## See Also ### Getting numeric inputs `struct Slider` A control for selecting a value from a bounded linear range of values. `struct Stepper` A control that performs increment and decrement actions. Sets the style for toggles in a view hierarchy. --- # https://developer.apple.com/documentation/swiftui/togglestyleconfiguration/label-swift.struct - SwiftUI - ToggleStyleConfiguration - ToggleStyleConfiguration.Label Structure # ToggleStyleConfiguration.Label A type-erased label of a toggle. @MainActor @preconcurrency struct Label ## Overview SwiftUI provides a value of this type — which is a `View` type — as the `label` to your custom toggle style implementation. Use the label to help define the appearance of the toggle. ## Relationships ### Conforms To - `View` ## See Also ### Getting the label view `let label: ToggleStyleConfiguration.Label` A view that describes the effect of switching the toggle between states. --- # https://developer.apple.com/documentation/swiftui/transformedshape - SwiftUI - TransformedShape Structure # TransformedShape A shape with an affine transform applied to it. @frozen ## Topics ### Creating a transformed shape `init(shape: Content, transform: CGAffineTransform)` ### Getting the shape’s characteristics `var shape: Content` `var transform: CGAffineTransform` ## Relationships ### Conforms To - `Animatable` - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Transforming a shape `struct ScaledShape` A shape with a scale transform applied to it. `struct RotatedShape` A shape with a rotation transform applied to it. `struct OffsetShape` A shape with a translation offset transform applied to it. --- # https://developer.apple.com/documentation/swiftui/tupleview - SwiftUI - TupleView Structure # TupleView A View created from a swift tuple of View values. @frozen ## Topics ### Creating a tuple view `init(T)` `var value: T` ## Relationships ### Conforms To - `View` ## See Also ### Supporting view types `struct AnyView` A type-erased view. `struct EmptyView` A view that doesn’t contain any content. `struct EquatableView` A view type that compares itself against its previous value and prevents its child updating if its new value is the same as its old value. `struct SubscriptionView` A view that subscribes to a publisher with an action. --- # https://developer.apple.com/documentation/swiftui/unevenroundedrectangle - SwiftUI - UnevenRoundedRectangle Structure # UnevenRoundedRectangle A rectangular shape with rounded corners with different values, aligned inside the frame of the view containing it. @frozen struct UnevenRoundedRectangle ## Topics ### Creating an uneven rounded rectangle `init(cornerRadii: RectangleCornerRadii, style: RoundedCornerStyle)` Creates a new rounded rectangle shape with uneven corners. `init(topLeadingRadius: CGFloat, bottomLeadingRadius: CGFloat, bottomTrailingRadius: CGFloat, topTrailingRadius: CGFloat, style: RoundedCornerStyle)` ### Getting the shape’s characteristics `var cornerRadii: RectangleCornerRadii` The radii of each corner of the rounded rectangle. `var style: RoundedCornerStyle` The style of corners drawn by the rounded rectangle. ### Supporting types `var animatableData: RectangleCornerRadii.AnimatableData` The data to animate. ## Relationships ### Conforms To - `Animatable` - `Copyable` - `InsettableShape` - `Sendable` - `SendableMetatype` - `Shape` - `View` ## See Also ### Creating rectangular shapes `struct Rectangle` A rectangular shape aligned inside the frame of the view containing it. `struct RoundedRectangle` A rectangular shape with rounded corners, aligned inside the frame of the view containing it. `enum RoundedCornerStyle` Defines the shape of a rounded rectangle’s corners. `struct RectangleCornerRadii` Describes the corner radius values of a rounded rectangle with uneven corners. --- # https://developer.apple.com/documentation/swiftui/vstack - SwiftUI - VStack Structure # VStack A view that arranges its subviews in a vertical line. @frozen ## Mentioned in Building layouts with stack views Creating performant scrollable stacks Picking container views for your content Adding a background to your view Inspecting view layout ## Overview Unlike `LazyVStack`, which only renders the views when your app needs to display them, a `VStack` renders the views all at once, regardless of whether they are on- or offscreen. Use the regular `VStack` when you have a small number of subviews or don’t want the delayed rendering behavior of the “lazy” version. The following example shows a simple vertical stack of 10 text views: var body: some View { VStack( alignment: .leading, spacing: 10 ) { ForEach( 1...10, id: \.self ) { Text("Item \($0)") } } } ## Topics ### Creating a stack Creates an instance with the given spacing and horizontal alignment. ## Relationships ### Conforms To - `View` ## See Also ### Statically arranging views in one dimension Compose complex layouts from primitive container views. `struct HStack` A view that arranges its subviews in a horizontal line. --- # https://developer.apple.com/documentation/swiftui/viewthatfits - SwiftUI - ViewThatFits Structure # ViewThatFits A view that adapts to the available space by providing the first child view that fits. @frozen ## Overview `ViewThatFits` evaluates its child views in the order you provide them to the initializer. It selects the first child whose ideal size on the constrained axes fits within the proposed size. This means that you provide views in order of preference. Usually this order is largest to smallest, but since a view might fit along one constrained axis but not the other, this isn’t always the case. By default, `ViewThatFits` constrains in both the horizontal and vertical axes. The following example shows an `UploadProgressView` that uses `ViewThatFits` to display the upload progress in one of three ways. In order, it attempts to display: - An `HStack` that contains a `Text` view and a `ProgressView`. - Only the `ProgressView`. - Only the `Text` view. The progress views are fixed to a 100-point width. struct UploadProgressView: View { var uploadProgress: Double var body: some View { ViewThatFits(in: .horizontal) { HStack { Text("\(uploadProgress.formatted(.percent))") ProgressView(value: uploadProgress) .frame(width: 100) } ProgressView(value: uploadProgress) .frame(width: 100) Text("\(uploadProgress.formatted(.percent))") } } } This use of `ViewThatFits` evaluates sizes only on the horizontal axis. The following code fits the `UploadProgressView` to several fixed widths: VStack { UploadProgressView(uploadProgress: 0.75) .frame(maxWidth: 200) UploadProgressView(uploadProgress: 0.75) .frame(maxWidth: 100) UploadProgressView(uploadProgress: 0.75) .frame(maxWidth: 50) } ## Topics ### Creating a view that fits Produces a view constrained in the given axes from one of several alternatives provided by a view builder. ## Relationships ### Conforms To - `View` --- # https://developer.apple.com/documentation/swiftui/zstack - SwiftUI - ZStack Structure # ZStack A view that overlays its subviews, aligning them in both axes. @frozen ## Mentioned in Building layouts with stack views Laying out a simple view Adding a background to your view Aligning views within a stack Creating performant scrollable stacks ## Overview The `ZStack` assigns each successive subview a higher z-axis value than the one before it, meaning later subviews appear “on top” of earlier ones. The following example creates a `ZStack` of 100 x 100 point `Rectangle` views filled with one of six colors, offsetting each successive subview by 10 points so they don’t completely overlap: let colors: [Color] = [.red, .orange, .yellow, .green, .blue, .purple] var body: some View { ZStack { ForEach(0..