DOCSEARCHbyAlgolia
Submit Docs

OpenSwiftUI Documentation

repository·main·Indexed 25 days ago

https://github.com/openswiftuiproject/openswiftui

An open-source implementation of Apple's SwiftUI designed for cross-platform GUI development on Linux and Windows, as well as debugging SwiftUI on Apple platforms. The project includes OpenSwiftUI, OpenSwiftUIExtension, and OpenSwiftUIBridge, maintaining maximum compatibility with the original SwiftUI API for research and learning purposes.

Tokens
19.6K
Snippets
40
Records
153
Agent score
79%

What's inside OpenSwiftUI

  1. Overview of OpenSwiftUI

    main

    OpenSwiftUI is a framework for declaring user interfaces and behaviors across multiple platforms. It provides a declarative approach to building apps using views, controls, and layout structures.

    Key capabilities include:

    • UI Declaration: Use views and controls to build interfaces.
    • Event Handling: Manage user input such as taps and gestures.
    • Data Management: Tools to flow data from models to views.
    • Platform Adaptability: Views and controls that adapt to their specific context and presentation.
    • Interoperability: Integration with UIKit, AppKit, and WatchKit for platform-specific functionality.

  2. Overview of OpenSwiftUI

    main

    OpenSwiftUI is an open-source implementation of Apple's SwiftUI designed to:

    • Enable building GUI applications on non-Apple platforms (e.g., Linux and Windows).
    • Diagnose and debug SwiftUI issues on Apple platforms.

    The API design and documentation aim to maintain maximum compatibility with the original SwiftUI API.

    Warning: This package uses many hidden APIs and private frameworks on Apple platforms. It is intended for learning and research purposes only. DO NOT use this package in Apple production environments (e.g., App Store), as it may break or crash during future SDK/OS updates.

  3. Draw and style shapes in OpenSwiftUI

    main

    OpenSwiftUI allows you to trace and fill built-in shapes (like circles and rectangles) or custom paths with colors, gradients, or other patterns. You can apply styles to the foreground, background, and outline of these shapes, including support for environment-aware colors, rich gradients, and material effects.

    Note on Performance: If you require the efficiency or flexibility of immediate mode drawing (for example, to create particle effects), use the Canvas view instead of standard shape views.

  4. React to system events in OpenSwiftUI

    main

    OpenSwiftUI allows you to respond to system-level events by applying specific view and scene modifiers. These modifiers define how your application behaves when it receives external triggers, such as universal links or background task completions.

    Key mechanisms include:

    • View Modifiers: Use modifiers like onOpenURL(perform:) to define actions when the app receives a URL.
    • Scene Modifiers: Use modifiers like backgroundTask(_:action:) to specify asynchronous tasks that should run in response to background events (e.g., the completion of a background URL session).

  5. Fine-tune layout with layout view modifiers

    main

    While layout containers like stacks and grids provide the primary structure for your UI, you can use layout view modifiers to make fine adjustments. These modifiers allow you to:

    • Adjust or constrain the size and position of a view.
    • Control the alignment of a view.
    • Add padding around a view.
    • Define how a view interacts with system-defined safe areas.

  6. What is SwiftCorelibs in OpenSwiftUI

    main

    SwiftCorelibs provides system API compatibility headers for non-Darwin platforms (such as Linux, WASI, and Windows). These headers allow OpenSwiftUI to interface with core system types on platforms where the standard Apple Darwin frameworks are unavailable.

    It includes the following header sets:

    • CoreFoundation: CoreFoundation types (e.g., CFBase, CFArray, CFDictionary, CFString, CFRuntime) sourced from swift-corelibs-foundation.
    • dispatch: Grand Central Dispatch (libdispatch) headers sourced from swift-corelibs-libdispatch.
    • os: OS abstraction headers (os/object.h) sourced from swift-corelibs-libdispatch.

    These headers are applied via the -isystem include path and are intended exclusively for non-Darwin environments.

  7. OpenSwiftUI Product Ecosystem

    main

    The project consists of three main components:

    • OpenSwiftUI: A SwiftUI source compatibility framework.
    • OpenSwiftUIExtension: An extensive collection of APIs for both OpenSwiftUI and standard SwiftUI.
    • OpenSwiftUIBridge: A bridge layer that allows for incremental migration from other DSL frameworks to OpenSwiftUI and enables mixing them freely.

  8. Make custom data types animatable in OpenSwiftUI

    main

    To create smooth visual transitions for custom data types during state changes, your types must conform to the Animatable protocol. This allows OpenSwiftUI to interpolate between values over time.

    When dealing with multiple values that need to animate simultaneously, use AnimatablePair to group them. For complex types, you may need to implement VectorArithmetic to define how the values interpolate. If a type should not participate in animations, use EmptyAnimatableData.

  9. Share state with child views using @Binding

    main

    To allow a child view to read and write to a state owned by a parent view, use the @Binding property wrapper in the child. A binding does not have its own storage; instead, it creates a two-way connection to an existing source of truth.

    How to use:

    1. In the Child: Declare the property with @Binding.
    2. In the Parent: Pass the state variable to the child by prefixing it with a dollar sign ($). This accesses the property's projectedValue, which is a binding to the underlying storage.
    3. Scoped Bindings: You can create bindings to specific properties within a larger state object using the $ prefix (e.g., $episode.isFavorite).
    // Child View
struct PlayButton: View {
    @Binding var isPlaying: Bool
    
    var body: some View {
        Button(action: {
            self.isPlaying.toggle()
        }) {
            Image(systemName: isPlaying ? "pause.circle" : "play.circle")
        }
    }
}

// Parent View
struct PlayerView: View {
    var episode: Episode
    @State private var isPlaying: Bool = false
    
    var body: some View {
        VStack {
            Text(episode.title)
            Text(episode.showTitle)
            PlayButton(isPlaying: $isPlaying) // Pass the binding using $
        }
    }
}

  11. Use delegate adaptors for platform-specific callbacks

    main

    While OpenSwiftUI allows you to write cross-platform code for Apple platforms, Linux, and Windows, you may need to respond to system-level callbacks specific to certain platforms (like UIKit, AppKit, or WatchKit). You can achieve this by defining a delegate object and instantiating it within your App structure using the appropriate adaptor property wrapper.

    • For iOS and iPadOS, use @UIApplicationDelegateAdaptor.
    • For macOS, use @NSApplicationDelegateAdaptor.

  12. Use UIApplicationDelegateAdaptor to integrate UIKit delegates

    main

    Use UIApplicationDelegateAdaptor to bridge traditional UIKit UIApplicationDelegate implementations into an OpenSwiftUI application. This allows you to handle app-level lifecycle events (like didFinishLaunchingWithOptions) within a SwiftUI-style architecture.

    Creating a delegate adaptor

    Initialize the adaptor by passing in an instance of your custom UIApplicationDelegate class using the init(_:) initializer.

    Accessing the delegate

    • wrappedValue: Returns the actual delegate instance you provided during initialization.
    • projectedValue: Provides access to the delegate via a projected value (typically used for observing changes or accessing the delegate instance through the $ prefix).