Introduction

When you want content inside a UIScrollView to fit the visible bounds initially, the key is to compute a minimum zoom scale that matches the scroll view’s size. After that, you center the content with insets so the view looks correct both when it fits exactly and when it becomes smaller than the viewport.

Core Sections

Start with a dedicated zoomable content view

A scroll view zooms one subview, not an abstract concept of “all content.” In practice that means you usually embed an image view or container view inside the scroll view and return that view from viewForZooming(in:).

1import UIKit
2
3final class ZoomViewController: UIViewController, UIScrollViewDelegate {
4    let scrollView = UIScrollView()
5    let imageView = UIImageView(image: UIImage(named: "map"))
6
7    override func viewDidLoad() {
8        super.viewDidLoad()
9
10        scrollView.frame = view.bounds
11        scrollView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
12        scrollView.delegate = self
13        view.addSubview(scrollView)
14
15        imageView.frame = CGRect(origin: .zero, size: imageView.image?.size ?? .zero)
16        scrollView.addSubview(imageView)
17        scrollView.contentSize = imageView.bounds.size
18    }
19
20    func viewForZooming(in scrollView: UIScrollView) -> UIView? {
21        imageView
22    }
23}

That wiring is required before zoom configuration does anything useful.

Compute the fit-to-bounds scale

To show the content uncut inside the scroll view, compare the scroll view size to the content size and choose the smaller scaling ratio.

1func updateZoomScales() {
2    let boundsSize = scrollView.bounds.size
3    let contentSize = imageView.bounds.size
4
5    let xScale = boundsSize.width / contentSize.width
6    let yScale = boundsSize.height / contentSize.height
7    let minScale = min(xScale, yScale)
8
9    scrollView.minimumZoomScale = minScale
10    scrollView.maximumZoomScale = max(minScale, 4.0)
11    scrollView.zoomScale = minScale
12}

Using min(xScale, yScale) ensures the entire content fits inside the visible bounds without cropping.

Center the content when it becomes smaller than the viewport

After zooming out, the zoomed view may be smaller than the scroll view. Without extra work, it sticks to the top-left corner. The usual fix is to adjust contentInset based on the zoomed frame size.

1func centerContent() {
2    let boundsSize = scrollView.bounds.size
3    let contentFrame = imageView.frame
4
5    let horizontalInset = max(0, (boundsSize.width - contentFrame.width) / 2)
6    let verticalInset = max(0, (boundsSize.height - contentFrame.height) / 2)
7
8    scrollView.contentInset = UIEdgeInsets(
9        top: verticalInset,
10        left: horizontalInset,
11        bottom: verticalInset,
12        right: horizontalInset
13    )
14}

Call this in scrollViewDidZoom(_:) and after setting the initial scale.

func scrollViewDidZoom(_ scrollView: UIScrollView) {
    centerContent()
}

Update on layout changes

Rotation and safe-area changes can invalidate the fit-to-bounds calculation. Recompute scales in viewDidLayoutSubviews() once the scroll view has its final size.

1override func viewDidLayoutSubviews() {
2    super.viewDidLayoutSubviews()
3    updateZoomScales()
4    centerContent()
5}

If you skip this, the initial zoom may look correct in one orientation and wrong after rotation.

Distinguish “fit to bounds” from “actual size”

The phrase “unscaled” can be misleading. If the content is larger than the viewport, fitting it to the bounds requires scaling it down. If you instead want one image pixel to map as directly as possible to screen points, that is a different goal and may require a zoom scale of 1.0 rather than the computed fit scale.

So the first question is: do you want “entire content visible,” or do you want “display at intrinsic scale”? Those are not always the same thing.

Common Pitfalls

• Forgetting to implement viewForZooming(in:), which means the scroll view never actually knows which subview should zoom.
• Setting zoom scales before the scroll view has its final bounds, which leads to wrong fit calculations on first layout or after rotation.
• Computing the fit scale correctly but never centering smaller content, so it stays pinned to the top-left corner.
• Assuming “unscaled” and “fit to bounds” mean the same behavior even when the content is larger than the viewport.
• Updating only zoomScale and forgetting to keep contentSize and layout assumptions consistent with the zoomable view.

Summary

• Put the zoomable content in a dedicated subview and return it from viewForZooming(in:).
• Compute the minimum zoom scale from the scroll view bounds and content size.
• Center content with insets when the zoomed view is smaller than the viewport.
• Recalculate zoom behavior after layout changes such as rotation.
• Decide clearly whether you want fit-to-bounds behavior or true intrinsic-scale display.