FloatingPanel Documentation

To present a floating panel modally in SwiftUI, you must implement a custom coordinator by conforming to the FloatingPanelCoordinator protocol.

Inside setupFloatingPanel, you configure the contentHostingController and use a Task to present the controller on the next run loop cycle to ensure the view hierarchy is correctly established.

struct HomeView: View {
  var view: some View {
    MainView()
        .floatingPanel(
          coordinator: MyPanelCoordinator.self
        ) { proxy in
          ...
        }
  }
}

class MyPanelCoordinator: FloatingPanelCoordinator {
    ...
    func setupFloatingPanel<Main, Content>(
        mainHostingController: UIHostingController<Main>,
        contentHostingController: UIHostingController<Content>
    ) where Main: View, Content: View {
        // Set the delegate object
        controller.delegate = delegate

        // Set up the content
        contentHostingController.view.backgroundColor = .clear
        controller.set(contentViewController: contentHostingController)

        /* =============== HERE ==================== */
        // NOTE: 
        // Present the floating panel on the next run loop cycle
        // to ensure proper view hierarchy setup.
        Task { @MainActor in
            mainHostingController.present(controller, animated: false)
        }
    }
    ...
}

If you need granular control, you can bypass addPanel and removePanelFromParent by manually managing the FloatingPanelController in the view hierarchy.

To add the controller:

1. Add fpc.view as a subview to your controller's view.
2. Set fpc.view.frame to match your controller's view bounds.
3. Use Auto Layout to constrain fpc.view to all four edges.
4. Add the controller as a child using addChild(fpc).
5. Call fpc.show(animated: true) and call fpc.didMove(toParent: self) in the completion block.

To remove the controller:

1. Call fpc.willMove(toParent: nil).
2. Call fpc.hide(animated: true).
3. In the completion block, remove fpc.view from its superview and call fpc.removeFromParent().

// Add the floating panel view to the controller's view on top of other views.
self.view.addSubview(fpc.view)

// REQUIRED. It makes the floating panel view have the same size as the controller's view.
fpc.view.frame = self.view.bounds

// In addition, Auto Layout constraints are highly recommended.
fpc.view.translatesAutoresizingMaskIntoConstraints = false
NSLayoutConstraint.activate([
  fpc.view.topAnchor.constraint(equalTo: self.view.topAnchor, constant: 0.0),
  fpc.view.leftAnchor.constraint(equalTo: self.view.leftAnchor, constant: 0.0),
  fpc.view.rightAnchor.constraint(equalTo: self.view.rightAnchor, constant: 0.0),
  fpc.view.bottomAnchor.constraint(equalTo: self.view.bottomAnchor, constant: 0.0),
])

// Add the floating panel controller to the controller hierarchy.
self.addChild(fpc)

// Show the floating panel at the initial position defined in your `FloatingPanelLayout` object.
fpc.show(animated: true) {
    // Inform the floating panel controller that the transition to the controller hierarchy has completed.
    fpc.didMove(toParent: self)
}

When implementing a custom FloatingPanelCoordinator, follow these best practices:

• Define Meaningful Events: Create an Event enum that captures only the interactions your SwiftUI views actually need to respond to.
• Use Lazy Delegate Initialization: To allow your coordinator to act as the FloatingPanelControllerDelegate, initialize the delegate lazily: lazy var delegate: FloatingPanelControllerDelegate? = self.
• Handle Environment Changes Efficiently: In onUpdate, compare the new environment values against the current panel state before performing updates to avoid redundant work.
• Coordinate with SwiftUI Animations: On iOS 18+, use the transaction's animation context when moving the panel to ensure smooth transitions:

if #available(iOS 18.0, *) {
    let animation = context.transaction.animation ?? .spring(response: 0.25, dampingFraction: 0.9)
    UIView.animate(animation) {
        proxy.move(to: .full, animated: false)
    }
}

To add a floating panel as a child view controller in UIKit:

1. Initialize a FloatingPanelController.
2. Set its delegate (optional).
3. Set the content view controller using .set(contentViewController:).
4. Track a scroll view using .track(scrollView:).
5. Add the panel to the parent view controller using .addPanel(toParent:).

import UIKit
import FloatingPanel

class ViewController: UIViewController, FloatingPanelControllerDelegate {
    var fpc: FloatingPanelController!

    override func viewDidLoad() {
        super.viewDidLoad()
        // Initialize a `FloatingPanelController` object.
        fpc = FloatingPanelController()

        // Assign self as the delegate of the controller.
        fpc.delegate = self // Optional

        // Set a content view controller.
        let contentVC = ContentViewController()
        fpc.set(contentViewController: contentVC)

        // Track a scroll view(or the siblings) in the content view controller.
        fpc.track(scrollView: contentVC.tableView)

        // Add and show the views managed by the `FloatingPanelController` object to self.view.
        fpc.addPanel(toParent: self)
    }
}