Introduction is a foundational class in UIKit and . Everything we see on the screen is constructed from `s and their subclasses. UIView iOS development UIView One topic often considered basic is the geometry of . It's easy to grasp initially, but complete understanding is often elusive, even for very experienced iOS engineers. In this article, we will dive deeply into the world of geometry. We will explain the main concepts, such as , , , , , how they relate to each other, and answer more advanced questions about computing the and Autolayout specifics. UIView UIView frame bounds center anchorPoint transform frame Playground To better understand the geometry, I've also developed a small iOS app: . https://github.com/psharanda/UIViewGeometry In the app, you can experiment with different properties in real time by adjusting sliders. Such an interactive approach is really helpful for grasping the nuances. UIView frame The definition of in Apple documentation is: UIView.frame The frame rectangle, which describes the view’s location and size in its superview’s coordinate system. Most of the time, we operate just with frames, either during manual layout or when printing the view's debug description. The designated initializer for also uses the frame as the only param. UIView This seems simple and straightforward. However, the reality is more complex. The frame is actually a computed property of . It is not the definitive source of the view's geometry. So, what is it exactly? UIView bounds Apparently, has many more properties related to geometry, and we’re now going to check the real, non-computed ones. Let’s examine the first of them: . UIView bounds The definition of is: UIView.bounds The bounds rectangle, which describes the view’s location and size in its own coordinate system. Usually, both and are simply equal to , and is the same as (however, it is not always true). bounds.origin.x bounds.origin.y 0.0 bounds.size frame.size What happens if is not equal to ? In that case, bounds basically act as a viewport, defining which part of the view coordinate system is visible to the outside world (superview). can also be seen as an additional translation (with a minus sign) for all subviews and view’s content rendered using . bounds.origin .zero bounds.origin drawRect This might remind you of . It is for a reason: the property of a is directly linked to its . UIScrollView contentOffset UIScrollView bounds.origin It's important to note that border, background, and shadow are rendered without considering . bounds.origin Previously, we mentioned that sometimes cannot be equal to . It may happen if transform is not equal to . frame.size bounds.size .identity According to the documentation, setting to any value when is not is considered undefined behavior (getting is still fine). However, setting when is not is valid.  In that case, describes the rectangle that fits the view after all transformations in its superview’s coordinate system. frame transform .identity bounds transform .identity frame center The definition of : UIView.center The center point of the view's frame rectangle in its superview’s coordinate system. However, the term "center" can be a bit misleading. It only represents the actual center of the view if the (more on this in the next section) is positioned at the center, specifically at ( , ). A more accurate definition for would be: view.anchorPoint 0.5 0.5 center The coordinates of the view’s anchor point in its superview’s coordinate system. UIView’s is exactly the same as . center CALayer.position The combination of and can fully replace the use of bounds center frame transform The transform property in iOS development is a fundamental concept that enables developers to apply geometric transformations to views. UIView The transform property of is of the type , which represents a matrix used for affine transformations. Affine transformations include: UIView CGAffineTransform Translation To move a view, you set the transform property with . For instance, moves the view 50 points to the right and 75 points down. CGAffineTransform(translationX:y:) view.transform = CGAffineTransform(translationX: 50, y: 75) Scaling To scale a view, use . For example, halves the size of the view in both width and height. CGAffineTransform(scaleX:y:) view.transform = CGAffineTransform(scaleX: 0.5, y: 0.5) Rotation To rotate a view, apply . The angle is in radians, so to rotate 30 degrees, you would use . CGAffineTransform(rotationAngle:) view.transform = CGAffineTransform(rotationAngle: .pi / 6) Combining Transforms One of the powerful aspects of the transform property is the ability to combine transformations. You can combine scaling, rotation, and translation into a single transform using concatenation, for example: var t = CGAffineTransform.identity // 0
t = t.concatenating(CGAffineTransform(scaleX: 0.5, y: 0.5)) //1
t = t.concatenating(CGAffineTransform(rotationAngle: .pi / 6)) //2
t = t.concatenating(CGAffineTransform(translationX: 50, y: 150)) //3
view.transform = t To reset a transformation, set the property to , which is also the default for a newly created . transform CGAffineTransform.identity UIView Perspective ’s transform is baked by which has the type and can be used for even more advanced transformations like changing the perspective UIView CALayer.transform CATransform3D var transform = CATransform3DIdentity;
transform.m34 = 1.0 / 500.0;
view.layer.transform = CATransform3DRotate(transform, .pi / 4, 0, 1, 0) anchorPoint The anchor point defines how a view behaves during transformations. It's specified using the unit coordinate space, where ( , ) is the top-left corner of the view's bounds rectangle, and ( , ) is the bottom-right corner. By default, the anchor point of a is set to ( , ), which is the center of the view’s bounds rectangle. 0 0 1 1 UIView 0.5 0.5 Interestingly, the property was only added to in iOS 16, but it has always been accessible through . anchorPoint UIView view.layer.anchorPoint Geometric manipulations, like rotation or scaling, occur around the anchor point. For example, if you apply a rotation transform to a view with the default anchor point, the view will rotate around its center. If you change the anchor point to a different location, the view will rotate around this new point. How to calculate the frame? We mentioned in the beginning that is a computed property. Now, with enough knowledge, let’s compile all the observations into actual code that computes the frame. frame First, let’s follow the positioning logic that is used during the render process. We start with a rectangle, with set to and set to . is not involved in calculations since it only affects subviews and the output. origin .zero size bounds.size bounds.origin drawRect Before applying the transform, we must translate the view according to its . We apply the transform only when the view, with its , is aligned with the starting point coordinates ( , ). anchorPoint anchorPoint 0 0 Now, we can apply the transform. The last step is to translate the view by its value, positioning it correctly. center These transformations can be concatenated into a single transform (i.e., absolute one), which is then applied to zero-origin bounds by using function. CGRectApplyAffineTransform Here is the final function which computes the frame: func computeFrame(bounds: CGRect,
                  center: CGPoint,
                  anchorPoint: CGPoint,
                  tranform: CGAffineTransform) -> CGRect {

    // set the initial rectangle to bounds with origin set to (0, 0)
    let zeroOriginBounds = CGRect(origin: .zero, size: bounds.size) // 1

    // combine transformations
    let absoluteTransform = CGAffineTransform(
            translationX: -anchorPoint.x * bounds.width,
            y: -anchorPoint.y * bounds.height
        ) // 2
        .concatenating(tranform) // 3
        .concatenating(CGAffineTransform(translationX: center.x, y: center.y)) // 4

    // apply transform to the initial rectangle
    return CGRectApplyAffineTransform(zeroOriginBounds, absoluteTransform)
} How can this knowledge be useful for us? Apart from just satisfying curiosity and gaining a better understanding of the internals, this algorithm has some real-world applications. A classic example is an image editor. Imagine you are building an application that creates custom stories. You want to place stickers on top of a photo, move, scale, and rotate them with your finger. For the editing mode, you use the actual and layout it by modifying its properties like center, bounds, and transform. Eventually, you’d like to render your story project into a bitmap and share it in high resolution, and that’s where understanding how geometry works becomes really useful. The image rendering code can look like the following: UIImageView UIView let renderer = UIGraphicsImageRenderer(size: imageSize)
let image = renderer.image { context in
    let cgContext = context.cgContext
    // render photo…
    // render other things…
    
    // render our sticker
    let absoluteTransform = CGAffineTransform(
        translationX: -sticker.anchorPoint.x * sticker.bounds.width,
        y: -sticker.anchorPoint.y * sticker.bounds.height
    )
        .concatenating(sticker.transform)
        .concatenating(
            CGAffineTransform(translationX: sticker.center.x, y: sticker.center.y)
        )
    
    cgContext.saveGState()
    cgContext.concatenate(absoluteTransform)
    sticker.image.draw(in: CGRect(origin: .zero, size: sticker.bounds.size))
    cgContext.restoreGState()
} What about Autolayout? Autolayout doesn't work with . It also ignores the and properties during its calculations. For each view, Autolayout calculates and sets only the and . The and are still used, but only for the final render on screen, and are applied afterward. frame transform anchorPoint bounds center transform anchorPoint To reiterate, in the Autolayout world, , , and don't exist. The Autolayout process is: constraints in, and out. frame transform anchorPoint bounds center Additional Resources UIView Documentation – https://developer.apple.com/documentation/uikit/uiview View Programming Guide – https://developer.apple.com/library/archive/documentation/WindowsViews/Conceptual/ViewPG_iPhoneOS/WindowsandViews/WindowsandViews.html#//apple_ref/doc/uid/TP40009503-CH2-SW5 Core Animation Basics – https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/CoreAnimation_guide/CoreAnimationBasics/CoreAnimationBasics.html#//apple_ref/doc/uid/TP40004514-CH2-SW3 Understanding UIKit Rendering – https://www.wwdcnotes.com/notes/wwdc11/121/ Understanding UIKit: CALayer Anchor Point – https://ikyle.me/blog/2022/understanding-uikit-calayer-anchor-point Understanding UIScrollView – https://oleb.net/blog/2014/04/understanding-uiscrollview/

Walkthroughs, tutorials, guides, and tips. This story will teach you how to do something new or how to do something better.

Mastering UIView Geometry: A Dive into UIKit's Foundational Class and Geometry Concepts for iOS

About Author

Comments

TOPICS

THIS ARTICLE WAS FEATURED IN

Related Stories

Untitled Story

NativeBook: Toolkit for Building IOS UI Components Inspired by Storybook.js

3D Engines: A Comprehensive Guide to Automation

Computer Graphics: Scan Line Polygon Fill Algorithm

Happy 3December!

Real-Time Rendering Tool with Reconstructions Based on UE4 Raytracing Tech

NativeBook: Toolkit for Building IOS UI Components Inspired by Storybook.js

3D Engines: A Comprehensive Guide to Automation

Computer Graphics: Scan Line Polygon Fill Algorithm

Happy 3December!

Real-Time Rendering Tool with Reconstructions Based on UE4 Raytracing Tech

Light-Mode

Classic

Newspaper

Dark-Mode

Neon Noir

Minty

HN StartUps