Swift Notes on Software Development Notes

How to create a binary tree using an array in Swift - part 2

Eric Callanan — Sunday, 10 Mar 2024

This is the second part on my notes on creating a binary tree using an array in Swift. This is based on reading of Advanced Algorithms and Data Structures by Marcello La Rocca. In this article, I'll implement the code for the priority queue.

An overview of a Priority Queue was presented in part 1.

These are my notes on the book
Advanced Algorithms and Data Structures - by Marcello La Rocca
May 2021, ISBN 9781617295485

Related articles on Advanced Algorithms and Data Structures:

How to create a binary tree using an array in Swift - part 1

How to create a binary tree using an array in Swift - part 2

Priority List in Swift

Start with defining a structure for the Elements that will be placed in the priority queue. The initial code for the PriorityQueue simply contains an array of elements. Unit tests are included in the project so these can be used to validate the various functions on the priority queue, as they are written. There is not much to the PriorityQueue yet and not much testing to be done on Element.

There is a design decision as to whether the priority of an element is a property of the element or whether elements do not have priority. In the second case the priority queue could be constructed of tuples containing an element and a priority. I will go with the element containing a property for its priority for now.

Element

 1struct Element : Identifiable {
 2    var id = UUID()
 3    var value: String
 4    var priority: Int
 5    var color: Color
 6    
 7    init(_ value: String, priority: Int, color: Color = .white) {
 8        self.value = value
 9        self.priority = priority
10        self.color = color
11    }
12}

PriorityQueue

1struct PriorityQueue {
2    var elements: [Element]
3}

ElementTests

 1import XCTest
 2import SwiftUI
 3
 4@testable import BinaryTreeApp
 5
 6final class ElementTests: XCTestCase {
 7    func testCreateElement_priority10_success() throws {
 8        // 1. Arrange
 9        let elem = Element("test", priority: 10)
10        
11        // 2. Act
12        
13        // 3. Assert
14        XCTAssertEqual(elem.value, "test")
15        XCTAssertEqual(elem.priority, 10)
16        XCTAssertEqual(elem.color, Color.white)
17    }
18
19    func testSetElementColor_blue_success() throws {
20        // 1. Arrange
21        var elem = Element("test", priority: 1)
22        
23        // 2. Act
24        elem.color = .blue
25        
26        // 3. Assert
27        XCTAssertEqual(elem.color, Color.blue)
28    }
29
30    func testSetElementPriority_200_success() throws {
31        // 1. Arrange
32        var elem = Element("test", priority: 1)
33        
34        // 2. Act
35        elem.priority = 200
36        
37        // 3. Assert
38        XCTAssertEqual(elem.priority, 200)
39    }
40
41    func testSetElementValue_testValue_success() throws {
42        // 1. Arrange
43        var elem = Element("test", priority: 1)
44        
45        // 2. Act
46        elem.value = "test value"
47        
48        // 3. Assert
49        XCTAssertEqual(elem.value, "test value")
50    }
51}

Bubble Up method in Priority Queue

The next step is to implement the internal functions of the priority queue that will be used by the external API. The first of these is the bubbleUp method based on the pseudocode in the book. The bubbleUp method takes a specified element index in the priority queue and compares its priority to that of its parent and if necessary swaps the elements. This process is repeated for each element in the while loop until the element is in the correct priority position in the queue.

There are two implementations of the bubbleUp method as detailed in the book. The first of these compares each element in turn with its parent and swaps the elements if necessary. The second method places the selected element in a temporary variable, and for each step in the while loop, it only needs to set the child element to its parent until the final element is reached and then assigns the temporary variable to that position in the queue. The second implementation is estimated to be more performant as it will have less assignments to make, however the first method in swift uses tuple assignment to make the swaps, which is more efficient than using a temporary variable.

Unit tests were written for the bubble up method and these pass when either bubbleUp method is used. I will defer measuring performance for now.

Initial bubbleUp code

 1    mutating func bubbleUp(index: Int) {
 2        var parentIndex = index
 3        while parentIndex > 0 {
 4            let currentIndex = parentIndex
 5            parentIndex = (currentIndex - 1) / 2
 6            if elements[parentIndex].priority > elements[currentIndex].priority
 7            {
 8                (elements[parentIndex],  elements[currentIndex]) = (elements[currentIndex],  elements[parentIndex])
 9            }
10            else {
11                break
12            }
13        }
14    }

Optimised bubbleUp code

 1    mutating func bubbleUp(index: Int) {
 2        var currentIndex = index
 3        let current = elements[index]
 4        while currentIndex > 0 {
 5            let parentIndex = (currentIndex - 1) / 2
 6            if elements[parentIndex].priority > current.priority
 7            {
 8                elements[currentIndex] = elements[parentIndex]
 9                currentIndex = parentIndex
10            } else {
11                break
12            }
13        }
14        elements[currentIndex] = current
15    }

Example of node swap with bubbleUp function in a Binary Tree

bubbleUp - Unit Tests

  1    // MARK: Bubble Up tests
  2    
  3    func testBubbleUp_two_swapped() throws {
  4        // 1. Arrange
  5        var priorityQueue = PriorityQueue(elements: [
  6            Element("10", priority: 10),
  7            Element("8", priority: 8)
  8        ])
  9        
 10        // 2. Act
 11        priorityQueue.bubbleUp(index: 1)
 12        
 13        // 3. Assert
 14        XCTAssertEqual(priorityQueue.elements[0].priority, 8)
 15        XCTAssertEqual(priorityQueue.elements[1].priority, 10)
 16    }
 17
 18    func testBubbleUp_two_noSwap() throws {
 19        // 1. Arrange
 20        var priorityQueue = PriorityQueue(elements: [
 21            Element("1", priority: 1),
 22            Element("2", priority: 2)
 23        ])
 24        
 25        // 2. Act
 26        priorityQueue.bubbleUp(index: 1)
 27        
 28        // 3. Assert
 29        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
 30        XCTAssertEqual(priorityQueue.elements[1].priority, 2)
 31    }
 32
 33    func testBubbleUp_ten_lastToFirst() throws {
 34        // 1. Arrange
 35        var priorityQueue = PriorityQueue(elements: [
 36            Element("abc", priority: 5),
 37            Element("abc", priority: 6),
 38            Element("abc", priority: 7),
 39            Element("abc", priority: 8),
 40            Element("abc", priority: 9),
 41            Element("abc", priority: 10),
 42            Element("abc", priority: 11),
 43            Element("abc", priority: 12),
 44            Element("abc", priority: 13),
 45            Element("abc", priority: 2)
 46        ])
 47        
 48        print("Before")
 49        _ = priorityQueue.elements.map {print("elem priority = \($0.priority)")}
 50        // 2. Act
 51        priorityQueue.bubbleUp(index: priorityQueue.elements.count-1)
 52
 53        print("After")
 54        _ = priorityQueue.elements.map {print("elem priority = \($0.priority)")}
 55        // 3. Assert
 56        XCTAssertEqual(priorityQueue.elements[0].priority, 2)
 57        XCTAssertEqual(priorityQueue.elements.count, 10)
 58    }
 59
 60    func testBubbleUp2_ten_lastToFirst() throws {
 61        // 1. Arrange
 62        var priorityQueue = PriorityQueue(elements: [
 63            Element("abc", priority: 5),
 64            Element("abc", priority: 6),
 65            Element("abc", priority: 7),
 66            Element("abc", priority: 8),
 67            Element("abc", priority: 9),
 68            Element("abc", priority: 10),
 69            Element("abc", priority: 11),
 70            Element("abc", priority: 12),
 71            Element("abc", priority: 13),
 72            Element("abc", priority: 2)
 73        ])
 74        
 75        // 2. Act
 76        priorityQueue.bubbleUp2(index: priorityQueue.elements.count-1)
 77
 78        // 3. Assert
 79        XCTAssertEqual(priorityQueue.elements[0].priority, 2)
 80        XCTAssertEqual(priorityQueue.elements.count, 10)
 81    }
 82
 83    func testBubbleUp_ten_middleOneMove() throws {
 84        // 1. Arrange
 85        var priorityQueue = PriorityQueue(elements: [
 86            Element("abc", priority: 1),
 87            Element("abc", priority: 5),
 88            Element("abc", priority: 3),
 89            Element("abc", priority: 4),
 90            Element("abc", priority: 2),
 91            Element("abc", priority: 6),
 92            Element("abc", priority: 7),
 93            Element("abc", priority: 8),
 94            Element("abc", priority: 9),
 95            Element("abc", priority: 10)
 96        ])
 97
 98        // 2. Act
 99        priorityQueue.bubbleUp(index: 4)
100
101        // 3. Assert
102        XCTAssertEqual(priorityQueue.elements[4].priority, 5)
103        XCTAssertEqual(priorityQueue.elements[1].priority, 2)
104        XCTAssertEqual(priorityQueue.elements[9].priority, 10)
105        XCTAssertEqual(priorityQueue.elements.count, 10)
106    }

Push Down method in Priority Queue

The next internal method required in the priority queue is the pushDown method. This is the reverse of the bubbleUp method, whereby an element is examined and compared to its children and if it is a lower priority then those elements are swapped. This process is repeated until the specified element is in the correct position in the priority queue. Similar to the bubbleUp method, there is an optimisation that can be made to use a temporary variable for the specified element and move the elements from parent to child until the appropriate level is reached, and then add in the selected element. There is a formula used to identify the first leaf index of the binary tree, which is used to determine the path to push down towards.

First Leaf Index:

$$ \begin{aligned} firstLeafIndex = (elements.count - 2) / 2 + 1 \end{aligned} $$

There is another difference between the bubbleUp method and the pushDwon method in that the highest priority child element needs to be identified to make the swap. In the bubbleUp there is only one parent to swap with, but there is a choice to identify the correct child when pushing down. The helper method highestPriorityChild is created to identify the correct child element. I did discover an issue with the initial implementation of highestPriorityChild where an index out of bounds error would occur if there was no right child index, so a check was added for that. This is where unit tests can be great.

highestPriorityChild

1    fileprivate func highestPriorityChild(index: Int) -> Int {
2        let leftChildIndex = (2 * index) + 1
3        let rightChildIndex = 2 * (index + 1)
4        if rightChildIndex > (elements.count - 1) || elements[leftChildIndex].priority < elements[rightChildIndex].priority {
5            return leftChildIndex
6        } else {
7            return rightChildIndex
8        }
9    }

Initial pushDown code

 1    mutating func pushDown(index: Int) {
 2        var currentIndex = index
 3        let firstLeafIndex = (elements.count - 2) / 2 + 1
 4        while currentIndex < firstLeafIndex {
 5            let (child, childIndex) = highestPriorityChild(index: currentIndex)
 6            if child.priority < elements[currentIndex].priority {
 7                (elements[currentIndex],  elements[childIndex]) = (elements[childIndex],  elements[currentIndex])
 8                currentIndex = childIndex
 9            } else {
10                break
11            }
12        }
13    }

Optimised pushDown code

 1    mutating func pushDown(index: Int) {
 2        var currentIndex = index
 3        let current = elements[index]
 4        let firstLeafIndex = (elements.count - 2) / 2 + 1
 5        while currentIndex < firstLeafIndex {
 6            let (child, childIndex) = highestPriorityChild(index: currentIndex)
 7            if child.priority < current.priority {
 8                elements[currentIndex] = elements[childIndex]
 9                currentIndex = childIndex
10            } else {
11                break
12            }
13        }
14        elements[currentIndex] = current
15    }

Example of node swap with pushUp function in a Binary Tree

pushDown - Unit Tests

  1    // MARK: Push Down tests
  2    
  3    func testPushDown_ten_firstDown() throws {
  4        // 1. Arrange
  5        var priorityQueue = PriorityQueue(elements: [
  6            Element("abc", priority: 15),
  7            Element("abc", priority: 2),
  8            Element("abc", priority: 3),
  9            Element("abc", priority: 4),
 10            Element("abc", priority: 5),
 11            Element("abc", priority: 6),
 12            Element("abc", priority: 7),
 13            Element("abc", priority: 8),
 14            Element("abc", priority: 9),
 15            Element("abc", priority: 10)
 16        ])
 17
 18        // 2. Act
 19        priorityQueue.pushDown(index: 0)
 20
 21        // 3. Assert
 22        XCTAssertEqual(priorityQueue.elements[0].priority, 2)
 23        XCTAssertEqual(priorityQueue.elements[1].priority, 4)
 24        XCTAssertEqual(priorityQueue.elements[3].priority, 8)
 25        XCTAssertEqual(priorityQueue.elements[7].priority, 15)
 26        XCTAssertEqual(priorityQueue.elements.count, 10)
 27    }
 28
 29    func testPushDown_one_noMove() throws {
 30        // 1. Arrange
 31        var priorityQueue = PriorityQueue(elements: [
 32            Element("abc", priority: 15)
 33        ])
 34
 35        // 2. Act
 36        priorityQueue.pushDown(index: 0)
 37
 38        // 3. Assert
 39        XCTAssertEqual(priorityQueue.elements[0].priority, 15)
 40        XCTAssertEqual(priorityQueue.elements.count, 1)
 41    }
 42
 43    func testPushDown_two_noMove() throws {
 44        // 1. Arrange
 45        var priorityQueue = PriorityQueue(elements: [
 46            Element("abc", priority: 1),
 47            Element("abc", priority: 2)
 48        ])
 49
 50        // 2. Act
 51        priorityQueue.pushDown(index: 0)
 52
 53        // 3. Assert
 54        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
 55        XCTAssertEqual(priorityQueue.elements.count, 2)
 56    }
 57
 58    func testPushDown_two_moveLeft() throws {
 59        // 1. Arrange
 60        var priorityQueue = PriorityQueue(elements: [
 61            Element("abc", priority: 2),
 62            Element("abc", priority: 1)
 63        ])
 64
 65        // 2. Act
 66        priorityQueue.pushDown(index: 0)
 67
 68        // 3. Assert
 69        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
 70        XCTAssertEqual(priorityQueue.elements.count, 2)
 71    }
 72
 73    func testPushDown_three_moveLeft() throws {
 74        // 1. Arrange
 75        var priorityQueue = PriorityQueue(elements: [
 76            Element("abc", priority: 5),
 77            Element("abc", priority: 1),
 78            Element("abc", priority: 2)
 79        ])
 80
 81        // 2. Act
 82        priorityQueue.pushDown(index: 0)
 83
 84        // 3. Assert
 85        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
 86        XCTAssertEqual(priorityQueue.elements.count, 3)
 87    }
 88
 89    func testPushDown_four_moveRight() throws {
 90        // 1. Arrange
 91        var priorityQueue = PriorityQueue(elements: [
 92            Element("abc", priority: 5),
 93            Element("abc", priority: 2),
 94            Element("abc", priority: 1),
 95            Element("abc", priority: 3)
 96        ])
 97
 98        // 2. Act
 99        priorityQueue.pushDown(index: 0)
100
101        // 3. Assert
102        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
103        XCTAssertEqual(priorityQueue.elements.count, 4)
104    }
105
106    func testPushDown_ten_middleDown() throws {
107        // 1. Arrange
108        var priorityQueue = PriorityQueue(elements: [
109            Element("abc", priority: 1),
110            Element("abc", priority: 2),
111            Element("abc", priority: 3),
112            Element("abc", priority: 14),
113            Element("abc", priority: 5),
114            Element("abc", priority: 6),
115            Element("abc", priority: 7),
116            Element("abc", priority: 8),
117            Element("abc", priority: 9),
118            Element("abc", priority: 10)
119        ])
120
121        // 2. Act
122        priorityQueue.pushDown(index: 3)
123        
124        // 3. Assert
125        XCTAssertEqual(priorityQueue.elements[3].priority, 8)
126        XCTAssertEqual(priorityQueue.elements[7].priority, 14)
127        XCTAssertEqual(priorityQueue.elements.count, 10)
128    }
129
130    func testPushDown_tenLast_noMove() throws {
131        // 1. Arrange
132        var priorityQueue = PriorityQueue(elements: [
133            Element("abc", priority: 1),
134            Element("abc", priority: 2),
135            Element("abc", priority: 3),
136            Element("abc", priority: 4),
137            Element("abc", priority: 5),
138            Element("abc", priority: 6),
139            Element("abc", priority: 7),
140            Element("abc", priority: 8),
141            Element("abc", priority: 9),
142            Element("abc", priority: 10)
143        ])
144
145        // 2. Act
146        priorityQueue.pushDown(index: 9)
147        
148        // 3. Assert
149        XCTAssertEqual(priorityQueue.elements[9].priority, 10)
150        XCTAssertEqual(priorityQueue.elements.count, 10)
151    }

Code for peek and Top operations

Now we can implement the public API for the priority queue.

Top - Remove and return the top priority element from the queue
Insert - Add a new element to the queue
Remove - Remove an element from the queue
Peek - Return the top priority element from the queue, without removing the element
Update - Update the priority of an element in the queue

The easiest to implement is the peek method as it simply returns a copy of the highest priority element in the queue without altering the queue.

The top method is similar in that it returns the highest priority element, but it removes this from the queue. The challenge is to restore the binary tree when the first element is removed. The pseudocode in the book solves this in an elegant way by moving the last element to the first and then use the pushDown operation on the first element in the array.

I've implemented both peek and top to return an optional element, which means the calling code will have to check the value is not nil. There is some logic to check in case the array is empty or only has one element, but the complicated logic has already been done in the pushDown method.

peek operation

1    func peek() -> Element? {
2        return elements.first
3    }

top operation

 1    mutating func top() -> Element? {
 2        guard !elements.isEmpty else {
 3            print("The list is empty")
 4            return nil
 5        }
 6        
 7        let lastElem = elements.removeLast()
 8        if elements.isEmpty {
 9            return lastElem
10        } else {
11            if let topElem = elements.first {
12                elements[0] = lastElem
13                pushDown(index: 0)
14                return topElem
15            }
16        }
17        return nil
18    }

Top operation on priority queue

Binary Tree view of Top operation on priority queue

top - Unit Tests

 1    // MARK: Top tests
 2    
 3    func testTop_two_leavesOne() throws {
 4        // 1. Arrange
 5        var priorityQueue = PriorityQueue(elements: [
 6            Element("abc", priority: 2),
 7            Element("abc", priority: 3)
 8        ])
 9
10        // 2. Act
11        _ = priorityQueue.top()
12
13        // 3. Assert
14        XCTAssertEqual(priorityQueue.elements[0].priority, 3)
15        XCTAssertEqual(priorityQueue.elements.count, 1)
16    }
17    
18    func testTop_empty_nil() throws {
19        // 1. Arrange
20        var priorityQueue = PriorityQueue(elements: [])
21
22        // 2. Act
23        let result = priorityQueue.top()
24
25        // 3. Assert
26        XCTAssertNil(result)
27    }
28    
29    func testTop_repeatThree_leavesTwo() throws {
30        // 1. Arrange
31        var priorityQueue = PriorityQueue(elements: [
32            Element("abc", priority: 1),
33            Element("abc", priority: 2),
34            Element("abc", priority: 3),
35            Element("abc", priority: 4),
36            Element("abc", priority: 5)
37        ])
38
39        // 2. Act
40        let one = priorityQueue.top()
41        let two = priorityQueue.top()
42        let three = priorityQueue.top()
43
44        // 3. Assert
45        XCTAssertEqual(one!.priority, 1)
46        XCTAssertEqual(two!.priority, 2)
47        XCTAssertEqual(three!.priority, 3)
48        XCTAssertEqual(priorityQueue.elements[0].priority, 4)
49        XCTAssertEqual(priorityQueue.elements[1].priority, 5)
50        XCTAssertEqual(priorityQueue.elements.count, 2)
51    }
52    
53    func testTop_twoElements_thirdReturnsNil() throws {
54        // 1. Arrange
55        var priorityQueue = PriorityQueue(elements: [
56            Element("abc", priority: 1),
57            Element("abc", priority: 2)
58        ])
59
60        // 2. Act
61        _ = priorityQueue.top()
62        _ = priorityQueue.top()
63        let thirdElem = priorityQueue.top()
64
65        // 3. Assert
66        XCTAssertNil(thirdElem)
67        XCTAssertEqual(priorityQueue.elements.count, 0)
68    }
69    
70    func testTop_oneElement_emptiesQueue() throws {
71        // 1. Arrange
72        var priorityQueue = PriorityQueue(elements: [
73            Element("abc", priority: 1)
74        ])
75
76        // 2. Act
77        let topElem = priorityQueue.top()
78
79        // 3. Assert
80        XCTAssertEqual(topElem?.priority, 1)
81        XCTAssertEqual(priorityQueue.elements.count, 0)
82        XCTAssertNil(priorityQueue.top())
83    }

Code for insert operation

The insert operation is also straight forward with the use of the bubbleUp function already written. The new element is simply added to the end of the array and then bubbleUp is called on the last element in the array.

insert operation

1    mutating func insert(element: Element) {
2        elements.append(element)
3        bubbleUp(index: elements.count - 1)
4    }

Insert operation on priority queue

insert - Unit Tests

 1    // MARK: insert tests
 2
 3    func testInsert_top_movedToTop() throws {
 4        // 1. Arrange
 5        let newElem = Element("abc", priority: 1)
 6        var priorityQueue = PriorityQueue(elements: [
 7            Element("abc", priority: 2),
 8            Element("abc", priority: 3),
 9            Element("abc", priority: 4),
10            Element("abc", priority: 5),
11            Element("abc", priority: 6),
12            Element("abc", priority: 7),
13            Element("abc", priority: 8),
14            Element("abc", priority: 9),
15            Element("abc", priority: 10),
16            Element("abc", priority: 11)
17        ])
18
19        // 2. Act
20        priorityQueue.insert(element: newElem)
21
22        // 3. Assert
23        XCTAssertEqual(newElem, priorityQueue.peek())
24        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
25        XCTAssertEqual(priorityQueue.elements.count, 11)
26    }
27    
28    func testInsert_middle_movedToMiddle() throws {
29        // 1. Arrange
30        let newElem = Element("abc", priority: 5)
31        var priorityQueue = PriorityQueue(elements: [
32            Element("abc", priority: 1),
33            Element("abc", priority: 2),
34            Element("abc", priority: 3),
35            Element("abc", priority: 4),
36            Element("abc", priority: 6),
37            Element("abc", priority: 7),
38            Element("abc", priority: 8),
39            Element("abc", priority: 9),
40            Element("abc", priority: 10),
41            Element("abc", priority: 11)
42        ])
43
44        // 2. Act
45        priorityQueue.insert(element: newElem)
46
47        // 3. Assert
48        XCTAssertEqual(newElem, priorityQueue.elements[4])
49        XCTAssertEqual(priorityQueue.elements[4].priority, 5)
50        XCTAssertEqual(priorityQueue.elements[10].priority, 6)
51        XCTAssertEqual(priorityQueue.elements.count, 11)
52    }
53    
54    func testInsert_last_movedToEnd() throws {
55        // 1. Arrange
56        let newElem = Element("abc", priority: 15)
57        var priorityQueue = PriorityQueue(elements: [
58            Element("abc", priority: 1),
59            Element("abc", priority: 2),
60            Element("abc", priority: 3),
61            Element("abc", priority: 4),
62            Element("abc", priority: 5),
63            Element("abc", priority: 6),
64            Element("abc", priority: 7),
65            Element("abc", priority: 8),
66            Element("abc", priority: 9),
67            Element("abc", priority: 10)
68        ])
69
70        // 2. Act
71        priorityQueue.insert(element: newElem)
72
73        // 3. Assert
74        XCTAssertEqual(newElem, priorityQueue.elements[10])
75        XCTAssertEqual(priorityQueue.elements[10].priority, 15)
76        XCTAssertEqual(priorityQueue.elements.count, 11)
77    }
78    
79    func testInsert_emptyQueue_added() throws {
80        // 1. Arrange
81        let newElem = Element("abc", priority: 15)
82        var priorityQueue = PriorityQueue(elements: [])
83
84        // 2. Act
85        priorityQueue.insert(element: newElem)
86
87        // 3. Assert
88        XCTAssertEqual(newElem, priorityQueue.elements[0])
89        XCTAssertEqual(priorityQueue.elements.count, 1)
90    }

Code for remove operation

The remove operation is not always included as part of the API for a priority queue. It can be beneficial when an item in a queue may no longer be required and needs to be removed. The most expensive step of removing an element is finding the element in the queue. In this code we rely on the Swift firstIndex(where:) function to get the index of the element in the collection. Similar to the top method, the last element in the array is removed and put in the place of the removed element.

Initially, I had logic in place to determine if the replaced element should call either bubbleUp or pushDown. However, since it is the last element that is inserted, we can just call pushDown to get the priority back to the correct state.

remove operation

 1    mutating func remove(oldElement: Element) {
 2        guard !elements.isEmpty else {
 3            print("The list is empty")
 4            return
 5        }
 6        
 7        if let index = elements.firstIndex( where: {$0 == oldElement} ) {
 8            let lastElem = elements.removeLast()
 9            if elements.isEmpty || lastElem == oldElement {
10                return
11            } else {
12                elements[index] = lastElem
13                pushDown(index: index)
14            }
15        }
16    }

Remove operation on priority queue

remove - Unit Tests

  1    // MARK: Remove tests
  2
  3    func testRemove_first_pushDown() throws {
  4        // 1. Arrange
  5        var priorityQueue = PriorityQueue(elements: [
  6            Element("abc", priority: 1),
  7            Element("abc", priority: 2),
  8            Element("abc", priority: 3),
  9            Element("abc", priority: 4),
 10            Element("abc", priority: 5),
 11            Element("abc", priority: 6),
 12            Element("abc", priority: 7),
 13            Element("abc", priority: 8),
 14            Element("abc", priority: 9),
 15            Element("abc", priority: 10)
 16        ])
 17
 18        // 2. Act
 19        let elem = priorityQueue.elements[0]
 20        priorityQueue.remove(oldElement: elem)
 21
 22        // 3. Assert
 23        XCTAssertEqual(priorityQueue.elements[0].priority, 2)
 24        XCTAssertEqual(priorityQueue.elements[1].priority, 4)
 25        XCTAssertEqual(priorityQueue.elements[3].priority, 8)
 26        XCTAssertEqual(priorityQueue.elements[7].priority, 10)
 27        XCTAssertEqual(priorityQueue.elements.count, 9)
 28    }
 29
 30    func testRemove_last_noMove() throws {
 31        // 1. Arrange
 32        var priorityQueue = PriorityQueue(elements: [
 33            Element("abc", priority: 1),
 34            Element("abc", priority: 2),
 35            Element("abc", priority: 3),
 36            Element("abc", priority: 4),
 37            Element("abc", priority: 5),
 38            Element("abc", priority: 6),
 39            Element("abc", priority: 7),
 40            Element("abc", priority: 8),
 41            Element("abc", priority: 9),
 42            Element("abc", priority: 10)
 43        ])
 44
 45        // 2. Act
 46        let elem = priorityQueue.elements[9]
 47        priorityQueue.remove(oldElement: elem)
 48
 49        // 3. Assert
 50        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
 51        XCTAssertEqual(priorityQueue.elements[8].priority, 9)
 52        XCTAssertEqual(priorityQueue.elements.count, 9)
 53    }
 54    
 55    func testRemove_secondLast_pushDown() throws {
 56        // 1. Arrange
 57        var priorityQueue = PriorityQueue(elements: [
 58            Element("abc", priority: 1),
 59            Element("abc", priority: 2),
 60            Element("abc", priority: 3),
 61            Element("abc", priority: 4),
 62            Element("abc", priority: 5),
 63            Element("abc", priority: 6),
 64            Element("abc", priority: 7),
 65            Element("abc", priority: 8),
 66            Element("abc", priority: 9),
 67            Element("abc", priority: 10)
 68        ])
 69
 70        // 2. Act
 71        let elem = priorityQueue.elements[8]
 72        priorityQueue.remove(oldElement: elem)
 73
 74        // 3. Assert
 75        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
 76        XCTAssertEqual(priorityQueue.elements[8].priority, 10)
 77        XCTAssertEqual(priorityQueue.elements.count, 9)
 78    }
 79    
 80    func testRemove_two_pushDown() throws {
 81        // 1. Arrange
 82        var priorityQueue = PriorityQueue(elements: [
 83            Element("abc", priority: 1),
 84            Element("abc", priority: 2),
 85            Element("abc", priority: 3),
 86            Element("abc", priority: 4),
 87            Element("abc", priority: 5),
 88            Element("abc", priority: 6),
 89            Element("abc", priority: 7),
 90            Element("abc", priority: 8),
 91            Element("abc", priority: 9),
 92            Element("abc", priority: 10)
 93        ])
 94
 95        // 2. Act
 96        let elem1 = priorityQueue.elements[3]
 97        priorityQueue.remove(oldElement: elem1)
 98        let elem2 = priorityQueue.elements[1]
 99        priorityQueue.remove(oldElement: elem2)
100
101        // 3. Assert
102        XCTAssertEqual(priorityQueue.elements[1].priority, 5)
103        XCTAssertEqual(priorityQueue.elements.count, 8)
104    }
105    
106    func testRemove_oneEmpty_noChange() throws {
107        // 1. Arrange
108        var priorityQueue = PriorityQueue(elements: [])
109
110        // 2. Act
111        let elem = Element("abc", priority: 23)
112        priorityQueue.remove(oldElement: elem)
113
114        // 3. Assert
115        XCTAssertTrue(priorityQueue.elements.isEmpty)
116        XCTAssertEqual(priorityQueue.elements.count, 0)
117    }

Code for update operations

Similar to remove operation, the most expensive step of updating an element is finding the element in the queue. There is no other cost to the update if some of the contents of the element need to be changed. However, if the priority needs to be changed, then the queue needs to be reset to priority order. Again, similar to remove operation, either bubbleUp or pushDown is called depending on the new priority being higher or lower than the old priority.

update operation

 1    mutating func update(oldElement:Element, newPriority: Int) {
 2        if let index = elements.firstIndex( where: {$0 == oldElement} ) {
 3            let oldPriority = oldElement.priority
 4            var newElement = oldElement
 5            newElement.priority = newPriority
 6            elements[index] = newElement
 7            if newPriority < oldPriority {
 8                bubbleUp(index: index)
 9            } else if newPriority > oldPriority {
10                pushDown(index: index)
11            }
12        }
13    }

Update operation to update the priority of an item in a priority queue

update - Unit Tests

  1    // MARK: update tests
  2
  3    func testUpdate_first_pushDown() throws {
  4        // 1. Arrange
  5        var priorityQueue = PriorityQueue(elements: [
  6            Element("abc", priority: 1),
  7            Element("abc", priority: 2),
  8            Element("abc", priority: 3),
  9            Element("abc", priority: 4),
 10            Element("abc", priority: 5),
 11            Element("abc", priority: 6),
 12            Element("abc", priority: 7),
 13            Element("abc", priority: 8),
 14            Element("abc", priority: 9),
 15            Element("abc", priority: 10)
 16        ])
 17
 18        // 2. Act
 19        let elem = priorityQueue.elements[0]
 20        priorityQueue.update(oldElement: elem, newPriority: 25)
 21
 22        // 3. Assert
 23        XCTAssertEqual(priorityQueue.elements[0].priority, 2)
 24        XCTAssertEqual(priorityQueue.elements[7].priority, 25)
 25        XCTAssertEqual(priorityQueue.elements.count, 10)
 26    }
 27    
 28    func testUpdate_first_noMove() throws {
 29        // 1. Arrange
 30        var priorityQueue = PriorityQueue(elements: [
 31            Element("abc", priority: 10),
 32            Element("abc", priority: 20),
 33            Element("abc", priority: 30),
 34            Element("abc", priority: 40),
 35            Element("abc", priority: 50),
 36            Element("abc", priority: 60),
 37            Element("abc", priority: 70),
 38            Element("abc", priority: 80),
 39            Element("abc", priority: 90),
 40            Element("abc", priority: 100)
 41        ])
 42
 43        // 2. Act
 44        let elem = priorityQueue.elements[0]
 45        priorityQueue.update(oldElement: elem, newPriority: 1)
 46
 47        // 3. Assert
 48        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
 49        XCTAssertEqual(priorityQueue.elements[1].priority, 20)
 50        XCTAssertEqual(priorityQueue.elements.count, 10)
 51    }
 52    
 53    func testUpdate_middle_pushDown() throws {
 54        // 1. Arrange
 55        var priorityQueue = PriorityQueue(elements: [
 56            Element("abc", priority: 1),
 57            Element("abc", priority: 2),
 58            Element("abc", priority: 3),
 59            Element("abc", priority: 4),
 60            Element("abc", priority: 5),
 61            Element("abc", priority: 6),
 62            Element("abc", priority: 7),
 63            Element("abc", priority: 8),
 64            Element("abc", priority: 9),
 65            Element("abc", priority: 10)
 66        ])
 67
 68        // 2. Act
 69        let elem = priorityQueue.elements[4]
 70        priorityQueue.update(oldElement: elem, newPriority: 25)
 71
 72        // 3. Assert
 73        XCTAssertEqual(priorityQueue.elements[4].priority, 10)
 74        XCTAssertEqual(priorityQueue.elements[9].priority, 25)
 75        XCTAssertEqual(priorityQueue.elements.count, 10)
 76    }
 77    
 78    func testUpdate_middle_bubbleUp() throws {
 79        // 1. Arrange
 80        var priorityQueue = PriorityQueue(elements: [
 81            Element("abc", priority: 2),
 82            Element("abc", priority: 3),
 83            Element("abc", priority: 4),
 84            Element("abc", priority: 5),
 85            Element("abc", priority: 6),
 86            Element("abc", priority: 7),
 87            Element("abc", priority: 8),
 88            Element("abc", priority: 9),
 89            Element("abc", priority: 10),
 90            Element("abc", priority: 11)
 91        ])
 92
 93        // 2. Act
 94        let elem = priorityQueue.elements[4]
 95        priorityQueue.update(oldElement: elem, newPriority: 1)
 96
 97        // 3. Assert
 98        XCTAssertEqual(priorityQueue.elements[0].priority, 1)
 99        XCTAssertEqual(priorityQueue.elements.count, 10)
100    }
101    
102    func testUpdate_last_bubbleUp() throws {
103        // 1. Arrange
104        var priorityQueue = PriorityQueue(elements: [
105            Element("abc", priority: 20),
106            Element("abc", priority: 30),
107            Element("abc", priority: 40),
108            Element("abc", priority: 50),
109            Element("abc", priority: 60),
110            Element("abc", priority: 70),
111            Element("abc", priority: 80),
112            Element("abc", priority: 90),
113            Element("abc", priority: 100),
114            Element("abc", priority: 110)
115        ])
116
117        // 2. Act
118        let elem = priorityQueue.elements[9]
119        priorityQueue.update(oldElement: elem, newPriority: 35)
120
121        // 3. Assert
122        XCTAssertEqual(priorityQueue.elements[0].priority, 20)
123        XCTAssertEqual(priorityQueue.elements.count, 10)
124    }
125    
126    func testUpdate_last_noMove() throws {
127        // 1. Arrange
128        var priorityQueue = PriorityQueue(elements: [
129            Element("abc", priority: 20),
130            Element("abc", priority: 30),
131            Element("abc", priority: 40),
132            Element("abc", priority: 50),
133            Element("abc", priority: 60),
134            Element("abc", priority: 70),
135            Element("abc", priority: 80),
136            Element("abc", priority: 90),
137            Element("abc", priority: 100),
138            Element("abc", priority: 110)
139        ])
140
141        // 2. Act
142        let elem = priorityQueue.elements[9]
143        priorityQueue.update(oldElement: elem, newPriority: 200)
144
145        // 3. Assert
146        XCTAssertEqual(priorityQueue.elements[9].priority, 200)
147        XCTAssertEqual(priorityQueue.elements.count, 10)
148    }

Conclusion

This is the second part of implementing a priority queue using an array in Swift. Part 1 walked through the concepts of the public API, while this article developed the swift code to implement the Priority Queue. The public API relies on the two internal functions (bubbleUp and pushDown) to get the queue back into priority order after an operation. Once these functions are in place the implementation of the public operations is more straight forward.

Next, I would like to look into populating the priority queue and measuring performance. There is also the question of access, the internal functions bubbleUp and pushDown have been written with public access so that unit tests can be written to validate their functionality. These should ideally be fileprivate and the unit testing to be done on the public API.

How to create a binary tree using an array in Swift - part 1

Eric Callanan — Sunday, 18 Feb 2024

I recently started reading a book on Algorithms and Data Structures by Marcello La Rocca that I find fascinating. I'm going to take a deep dive into chapter 2 and adapt the pseudocode to implement a priority queue in Swift. This article will look at the properties of a priority queue and how this can be implemented using an array to store a binary tree structure..

These are my notes on the book
Advanced Algorithms and Data Structures - by Marcello La Rocca
May 2021, ISBN 9781617295485

Related articles on Advanced Algorithms and Data Structures:

How to create a binary tree using an array in Swift - part 1

How to create a binary tree using an array in Swift - part 2

I've just started reading this book in January 2024 and I think it is fantastic. Marcello has a great way of explaining the concepts and is well able to justify mathematically why a particular algorithm is going to be more performant.

The big "Ah Ha!" (or Dah ha!) moment for me was how an array could be used to represent a binary tree. This inspired me to implement this code and try out creating such a priority queue in a binary tree, using an array for the underlying structure.

This is just for fun, I don't have any affiliation with the book and I hope I have not mis-interpreted anything. These notes are for me and I hope others find them useful.

Priority Queue

A priority queue is an abstract data type referring to a group of elements organised in order of priority. A priority queue must support a number of operations and the book lists the following 5 operations.

Top - Remove and return the top priority element from the queue
Insert - Add a new element to the queue
Remove - Remove an element from the queue
Peek - Return the top priority element from the queue, without removing the element
Update - Update the priority of an element in the queue

The priority queue needs to remain in a valid state after each of these operations.

Finally, a priority queue needs to set how to manage priorities. The easiest mechanism is to use numbers to represent the priority of an element and to decide whether higher numbers represent a higher priority or a lower priority. The priority queues represented here will use a lower number to represent a higher priority, simply because we often use the term "number one priority" to represent our most importent item.

Priority queue ordered from lowest to highest

Top and Peek

The Top and Peek operations on a priority queue are similar in that they return the highest priority element in the queue. The difference is in that Top removes the element from the queue so that the next priority element becomes the top priority element. The Peek operation does not alter the queue, so that calling Peek repeatedly on a priority queue will return the same element. Calling Top repeatedly on a priority queue will keep removing and returning the top element until the queue is empty.

Peek operation on priority queue

Top operation on priority queue

Insert

There has to be a mechanism to add new elements to a priority queue. The priority of the element to be added is unlikely to be the lowest priority and will somehow need to be inserted into the appropriate place in the queue.

Insert operation on priority queue

Remove

There will be times when an item somewhere in the middle of the priority queue is no longer needed. In this case, it will be necessary to remove the element from the queue. As discussed more in the book, the challenge here can be in finding an element in the priority queue. The priority queue needs to be left in a valid state when the element has been removed.

Remove operation on priority queue

Update Priority

There may be options to update elements in a priority queue. The update could involve just updating some of the contents on an element or it could involve changing the priority of an element in the queue. Similar to removing, finding the element is first required. If the priority of the element is to be changed, then elements in the queue will need to be moved to get the queue into a valid state.

Update operation to update the priority of an item in a priority queue

Array to represent a binary tree

I probably have not thought about storing data for a binary tree much, but if I did, I would consider using some kind of linked list of nodes. Such as a note structure that could contain the node data and three optional values; a pointer to parent node; a pointer to a left child node; and a pointer to a right child node. Then that is probably where I stop thinking about it.

The book shows that a binary tree (or and n-branch tree) can be stored in an array.

In the array representation, if we are starting to count indices from 0, the children of the i-th node are stored in the positions (2 * i) + 1 and 2 * (i + 1), while the parent of node i is at index (i - 1) / 2 (except for the root, which has no parent).

Binary tree containing letters to represent the elements in the tree

Array and Binary Tree showing array indexes

Node paths

It is easier to understand the relationship between nodes and their index in the arrays using an example. Take the node containing E at index 4 in the array and binary tree above.

Parent node of E:

$$ \begin{aligned} Index \ of node \ E &= 4 \\ Parent \ node \ index \ &= (i - 1) / 2 \\ Parent \ node \ index \ &= (4 - 1) / 2 \\ Parent \ node \ index \ &= 3 / 2 \\ Parent \ node \ index \ &= 1 \\ Parent \ node \ &= Array[1] \\ Parent \ node \ &= B \end{aligned} $$

Left child node of E:

$$ \begin{aligned} Index \ of node \ E &= 4 \\ Left \ child \ node \ index \ &= (2 * i) + 1 \\ Left \ child \ node \ index \ &= (2 * 4) + 1 \\ Left \ child \ node \ index \ &= 8 + 1 \\ Left \ child \ node \ index \ &= 9 \\ Left \ child \ node \ &= Array[9] \\ Left \ child \ node \ &= J \end{aligned} $$

Right child node of E:

$$ \begin{aligned} Index \ of node \ E &= 4 \\ Right \ child \ node \ index \ &= 2 * (i + 1) \\ Right \ child \ node \ index \ &= 2 * (4 + 1) \\ Right \ child \ node \ index \ &= 2 * 5 \\ Right \ child \ node \ index \ &= 10 \\ Right \ child \ node \ &= Array[10] \\ Right \ child \ node \ &= K \end{aligned} $$

Array index of parent and child nodes in a Binary Tree

Bubble Up method

There are two internal functions that need to be implemented on the Priority Queue that can be used by the public operations on the queue. The first of these is called bubbleUp in the book. bubbleUp takes a node and the priority queue and if the priority of the specified node is higher than that of its parent, the nodes are swapped. The focus moves to the new parent node and repeats the comparison.

The example in the diagram starts with the addition of a node at the end of the array with a priority of 15. The Priority Queue is using lower values to represent higher priority. So this node with a priority of 15 is higher priority than its parent (priority = 70), so these values are swapped. Next the node with priority 15 is compared with its new parent (priority = 30) and once again these nodes are swapped. Finally the node with priority 15 is compared with its new parent (priority = 10) and no swap is required as the parent has a higher priority and the Priority Queue is back in a valid state.

Example of node swap with bubbleUp function in a Binary Tree

Push Down method

The second internal function is called pushDown and performs more or less the reverse of the bubbleUp method. It is used to move nodes down towards the leaves of the Binary Tree if their priority is lower than their chid nodes.

The example here starts with the priority of a node being set to 150, which is a lower priority than both of its child nodes. This node is swapped with the first child (priority = 60). The node is still lower priority than it s child nodes so it is swapped its child node (priority = 120). The node is now a leaf node and so no further swaps are required and the Priority Queue is back in a valid state.

Example of node swap with pushUp function in a Binary Tree

Conclusion

As I said at the start, these are my notes to help me learn the use of an array to manage a priority queue as a binary tree structure. If we just wanted to manage a list of tasks in a kind of TODO app, then a simple sorted list would be fine. The book is discussing when the list of priority items goes into millions or billions. If you have a TODO list of millions - you have bigger problems than how to store this in a prioritised list!

This article has outlined the required operations of a Priority Queue. I've shown how this can be represented in a binary tree and how an Array can be used to manage the queue. I've outlined two internal functions required to implement a Priority Queue and depicted how these functions work on a binary tree.

In the next article, I'll dive into Swift code to implement the Priority Queue and then I want to do some timing tests to confirm the performance characteristics.

Scroll transition effects in iOS 17

Eric Callanan — Sunday, 28 Jan 2024

Apple added scroll transition effects in iOS 17 that allow items behavior to be animated as they scroll into and out of view. There are a number of attributes that can be modified such as size, visibility as well as rotation of the object.

Card view to scroll

Start by defining a view to contain an image of an animal on a card. Load a group of images into resources for the App and label these from 'animal-01 to 'animal-25'. On the Card View, the images are set to resizable and scaledToFit, so the images are not distorted and a pale yellow border surrounds the pictures. Define a list of Animals that contains a list of identifiable Animal objects.

AnimalCardView

 1struct AnimalCardView: View {
 2    var animal: Animal
 3    
 4    var body: some View {
 5        ZStack {
 6            RoundedRectangle(cornerRadius: 40)
 7                .fill(.yellow.opacity(0.3))
 8                .frame(width: 320, height: 240)
 9                .shadow(color: .black, radius: 7, x: 8, y: 10)
10            Image(animal.name)
11                .resizable()
12                .scaledToFit()
13                .frame(width: 320, height: 240)
14                .clipShape(RoundedRectangle(cornerRadius: 40))
15                .overlay(RoundedRectangle(cornerRadius: 40)
16                    .strokeBorder(Color.yellow.opacity(0.4), lineWidth: 6))
17        }
18    }
19}

Animals

 1struct Animal: Identifiable {
 2    let id = UUID()
 3    let name: String
 4    
 5    init(num: Int) {
 6        self.name = "animal-\( String(repeating: "0", count: num < 10 ? 1 : 0) )\(num)"
 7    }
 8}
 9
10
11struct Animals {
12    var animalList: [Animal]
13    
14    init() {
15        animalList = []
16        for i in 1...25 {
17            animalList.append(Animal(num: i))
18        }
19    }
20    
21}

SwiftUI view to display an image in a card view

Scroll without any transition effect

Place the animal cards in a vertical stack in a scroll view to see the default scroll behavior.

NoTransitionView

 1struct NoTransitionView: View {
 2    let animals = Animals()
 3    
 4    var body: some View {
 5        VStack {
 6            HeaderView(heading: "No Transition")
 7
 8            ScrollView {
 9                LazyVStack {
10                    ForEach (animals.animalList) { animal in
11                        AnimalCardView(animal: animal)
12                    }
13                }
14            }
15        }
16    }
17}

Vertical stack of cards scrolling without any transition

Vertical stack of cards scrolling without transition

Scale Transition

Adding a scroll transition effect is achieved by adding a scrollTransition modifier to the Animal Card View. Scale effect can be set to some value less than 1 based on the ScrollTransitionPhase identity. The isIdentity transition phase is true when the view is in full view and false when the view is no longer in view. The transition is taken care of automatically where the scale begins to change as the view is scrolled out of view.

ScaleTransitionView

 1struct ScaleTransitionView: View {
 2    let animals = Animals()
 3
 4    var body: some View {
 5        VStack {
 6            HeaderView(heading: "Scale Transition")
 7            
 8            ScrollView {
 9                LazyVStack {
10                    ForEach (animals.animalList) { animal in
11                        AnimalCardView(animal: animal)
12                            .scrollTransition { content, phase in content
13                                    .scaleEffect(phase.isIdentity ? 1 : 0.6)
14                            }
15                    }
16                }
17            }
18        }
19    }
20}

Vertical stack of cards scrolling with a scale transition

Opacity Transition

The opacity of the content can be bound to the scroll transition phase identity so that the contents fade as the view is scrolled out of view. The degree to which the view fades can be set by specifying the opacity value when the phase isIdentity is false.

OpacityTransitionView

 1struct OpacityTransitionView: View {
 2    let animals = Animals()
 3
 4    var body: some View {
 5        VStack {
 6            HeaderView(heading: "Opacity Transition")
 7
 8            ScrollView {
 9                LazyVStack {
10                    ForEach (animals.animalList) { animal in
11                        AnimalCardView(animal: animal)
12                            .scrollTransition { content, phase in 
13                                content.opacity(phase.isIdentity ? 1 : 0)
14                            }
15                    }
16                }
17            }
18        }
19    }
20}

Vertical stack of cards scrolling with a opacity transition

Offset Transition

The x and y positioning can also be bound to the scroll transition phase identity so that the contents can slide in to place as the view is scrolled. The following code adjusts the x offset so that the cards seems to slide in and out from the trailing direction.

OffsetTransitionView

 1struct OffsetTransitionView: View {
 2    let animals = Animals()
 3    
 4    var body: some View {
 5        VStack {
 6            HeaderView(heading: "Offset Transition")
 7            
 8            ScrollView {
 9                LazyVStack {
10                    ForEach (animals.animalList) { animal in
11                        AnimalCardView(animal: animal)
12                            .scrollTransition { content, phase in 
13                                content.offset(x: phase.isIdentity ? 0 : 400)
14                            }
15                    }
16                }
17            }
18        }
19    }
20}

Vertical stack of cards scrolling with a offset transition

Scale and Opacity Transition

Multiple effects can be applied at the same time as the cards scroll into view. The example in the Apple documentation is to combine scaling with opacity, which creates the effect of the views appearing from the background and fading back into the background.

ScaleOpacityView

 1struct ScaleOpacityView: View {
 2    let animals = Animals()
 3
 4    var body: some View {
 5        VStack {
 6            HeaderView(heading: "Scale & Opacity Transition")
 7
 8            ScrollView {
 9                LazyVStack {
10                    ForEach (animals.animalList) { animal in
11                        AnimalCardView(animal: animal)
12                            .scrollTransition { content, phase in 
13                                content
14                                    .scaleEffect(phase.isIdentity ? 1 : 0.3)
15                                    .opacity(phase.isIdentity ? 1 : 0.3)
16                            }
17                    }
18                }
19            }
20        }
21    }
22}

Vertical stack of cards scrolling with combined scale and opacity transition

View Aligned

The viewAligned behavior can be used so that the scrolling always stops at the edge of a leading view. This works with scrollTargetLayout modifier to layout the LazyVStack container, that contain the main repeating content, within a ScrollView .

ViewAlignedView

 1struct ViewAlignedView: View {
 2    let animals = Animals()
 3
 4    var body: some View {
 5        VStack {
 6            HeaderView(heading: "Scale & Opacity Transition")
 7            Text("viewAligned")
 8
 9            ScrollView {
10                LazyVStack {
11                    ForEach (animals.animalList) { animal in
12                        AnimalCardView(animal: animal)
13                            .scrollTransition { content, phase in
14                                content
15                                    .scaleEffect(phase.isIdentity ? 1 : 0.3)
16                                    .opacity(phase.isIdentity ? 1 : 0.3)
17                            }
18                    }
19                }
20                .scrollTargetLayout()
21            }
22            .scrollTargetBehavior(.viewAligned)
23        }
24    }
25}

Vertical stack of cards scrolling with scrollTargetBehavior set to viewAligned

Vertical stack of cards scrolling with Scale and Opacity transition

Scale, Opacity, Rotation and Offset Transition

Where to stop with the effects on scroll transitions? The following combines scaling, opacity, rotation and offset to show the cards flying in from an angle and getting bigger and clearer and then flying out in the opposite direction. I think this might be a bit too much. The scroll transition phase value is used to determine the offset. This phase value is -1.0 when the view is in the topLeading phase, zero when in the identity phase and 1.0 when in the bottomTrailing phase.

ScaleOpacityRotationView

 1struct ScaleOpacityRotationView: View {
 2    let animals = Animals()
 3
 4    var body: some View {
 5        VStack {
 6            HeaderView(heading: "Scale, Opacity,")
 7            HeaderView(heading: "Rotation and Offset")
 8
 9            ScrollView {
10                LazyVStack {
11                    ForEach (animals.animalList) { animal in
12                        AnimalCardView(animal: animal)
13                            .scrollTransition(.interactive) { content, phase in 
14                                content
15                                    .scaleEffect(phase.isIdentity ? 1.0 : 0.2)
16                                    .opacity(phase.isIdentity ? 1 : 0.5)
17                                    .rotation3DEffect(
18                                        Angle.degrees(phase.isIdentity ? 0: 90),
19                                        axis: (x: 0.5, y: 0.0, z: 0.1))
20                                    .offset(x: phase.value * -200)
21                            }
22                    }
23                }
24                .scrollTargetLayout()
25            }
26            .scrollTargetBehavior(.viewAligned)
27        }
28    }
29}

Vertical stack of cards scrolling with combined scale, opacity, rotation and offset transition

Vertical stack of cards scrolling with Scale, Opacity, 3D Rotation and Offset in scroll transition

Conclusion

Scroll transition effects were added to SwiftUI in iOS 17. This allows views behavior to be animated as they scroll into and out of view. A common effect is to add a scale and opacity change so that the views appear to fade into the background. There are a number of behaviors that can be applied to the views as they scroll into and out of view, but adding too many effects can draw too much attention to the scrolling effect. This might distract from the actual view and have the user too focussed on the scrolling behavior. Having said that, I did find that once a scroll transition has been added, then a scroll without any transition seems somewhat broken or inferior.

The source code for ScrollEffectApp is available on GitHub.

Conway's Game of life with SwiftUI

Eric Callanan — Wednesday, 27 Dec 2023

I thought it would be fun to look into creating Conway's Game of life in SwiftUI over the holidays. Conway's Game of life is an automatic game consisting of a 2D grid where cells are either alive or dead. The state of each cell in the next iteration is based on the cells around it in the current iteration following some simple rules.

Conway's Game of Life was devised by John Conway in 1970 can be fascinating to watch the different patterns evolve. Here are the 4 simple rules of the game:

Any live cell with fewer than two live neighbours dies, as if by underpopulation.

Any live cell with two or three live neighbours lives on to the next generation.

Any live cell with more than three live neighbours dies, as if by overpopulation.

Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

Grid to display

The implementation is broken into two phases; the UI to display the state of the game and animate as the game changes; and the logic to change the cell status from generation to generation based on the 4 rules of the game. Start with using the Grid container view that arranges views in a 2D grid and use rounded rectangles to represent each cell. A green color to represent a live cell and a gray color to represent a dead cell.

The view sets the color of each cell randomly to represent a live or dead cell.

GridLayoutView

 1struct GridLayoutView: View {
 2    var body: some View {
 3        VStack {
 4            VStack(spacing: 5) {
 5                Text("Use Grid")
 6                    .font(.largeTitle)
 7                    .fontWeight(.bold)
 8                
 9                Grid(alignment: .center, horizontalSpacing: 2, verticalSpacing: 2) {
10                    ForEach(0..<5) { row in
11                        GridRow {
12                            ForEach(0..<5) { _ in
13                                let n = Int.random(in: 1..<10)
14                                
15                                RoundedRectangle(cornerRadius: 5)
16                                    .foregroundStyle(n%3 == 0 ? .green : .gray)
17                            }
18                        }
19                    }
20                }
21                .padding(5)
22                .background(.black)
23                .frame(width:300, height: 300)
24            }
25            
26            Spacer()
27                .frame(height: 20)
28            
29            Divider()
30            
31            VStack(spacing: 5) {
32                Text("Grid 50 * 50")
33                    .font(.largeTitle)
34                    .fontWeight(.bold)
35                
36                Grid(alignment: .center, horizontalSpacing: 0.1, verticalSpacing: 0.1) {
37                    ForEach(0..<50) { row in
38                        GridRow {
39                            ForEach(0..<50) { _ in
40                                let n = Int.random(in: 1..<10)
41                                RoundedRectangle(cornerRadius: 5)
42                                    .foregroundStyle(n%9 == 0 ? .green : .gray)
43                            }
44                        }
45                    }
46                }
47                .padding(5)
48                .background(.black)
49                .frame(width:300, height: 300)
50                
51                Spacer()
52            }
53        }
54    }
55}

Using Grid to layout rectangles to represent cells

Grid to display from 2D array

The view uses a the Grid container view to layout cells and set the color based on values in a 2 dimensional grid of values. The values in the grid are hard-coded with values of 1 or 0 representing live and dead respectively.

GridFromArrayView

 1struct GridFromArrayView: View {    
 2    let gridData = [
 3        [1,1,0,0,0],
 4        [0,1,0,1,0],
 5        [0,0,0,0,1],
 6        [0,1,0,1,0],
 7        [0,0,0,1,0]
 8    ]
 9    var body: some View {
10        VStack {
11            Text("Grid from 2D array")
12                .font(.largeTitle)
13                .fontWeight(.bold)
14            Grid(alignment: .center, horizontalSpacing: 2, verticalSpacing: 2) {
15                ForEach(0..<gridData.count, id:\.self) { r in
16                    GridRow {
17                        ForEach(0..<gridData[r].count,  id:\.self) { c in
18                            Rectangle().fill(gridData[r][c] == 1 ? .green: .gray)
19                        }
20                    }
21                }
22            }
23            .padding(2)
24            .background(.black)
25            .frame(width: 300, height: 300)
26            
27            Spacer()
28                .frame(height: 40)
29            
30            Divider()
31            
32            Text("Values in 2D array")
33                .font(.largeTitle)
34                .fontWeight(.bold)
35            Grid(alignment: .center, horizontalSpacing: 3, verticalSpacing: 3) {
36                ForEach(0..<gridData.count, id:\.self) { r in
37                    GridRow {
38                        ForEach(0..<gridData[r].count,  id:\.self) { c in
39                            Rectangle().fill(.quaternary)
40                                .overlay(
41                                    Text("\(gridData[r][c])")
42                                        .font(.title2)
43                                        .fontWeight(.bold)
44                                )
45                        }
46                    }
47                }
48            }
49            .background(.quaternary)
50            .frame(width: 200, height: 200)
51            
52            Spacer()
53        }
54    }
55}

Using Grid to layout cells based on values in 2D array

Canvas to display

Grid container view may not be the most efficient way to display the cells from the Game of Life, as all the cells will need to change on each iteration of the game. Canvas may be a more efficient way to display all the cells insite one view. In Better performance with canvas in SwiftUI, I found that the use of canvas can be very efficient in rendering and updating the SwiftUI views.

The CanvasLayoutView uses a Canvas to layout a grid of rounded rectangles and sets the color of each cell randomly to represent a live or dead cell.

CanvasLayoutView

 1struct CanvasLayoutView: View {
 2    var body: some View {
 3        VStack {
 4            VStack(spacing: 5) {
 5                Text("Use Canvas")
 6                    .font(.largeTitle)
 7                    .fontWeight(.bold)
 8                Canvas { context, size in
 9                    let w = size.width
10                    let h = size.height
11                    let rows = 5
12                    let cols = 5
13                    let offset = 0.03 * w / CGFloat(cols)
14                    
15                    for r in 0..<rows {
16                        for c in 0..<cols {
17                            let n = Int.random(in: 1..<10)
18
19                            let x = w / CGFloat(cols) * CGFloat(c) + offset
20                            let y = h / CGFloat(rows) * CGFloat(r) + offset
21                            context.fill(
22                                Path(
23                                    roundedRect: CGRect(
24                                        x: x,
25                                        y: y,
26                                        width: 0.94 * w / CGFloat(cols),
27                                        height: 0.94 * h / CGFloat(rows)
28                                    ),
29                                    cornerRadius: w/CGFloat(cols*10)),
30                                with: .color(n%3 == 0 ? .green : .gray))
31                        }
32                    }
33                }
34                .background(.black)
35                .frame(width: 300, height: 300)
36                .border(Color.black)
37            }
38            
39            Spacer()
40                .frame(height: 20)
41            
42            Divider()
43            
44            VStack(spacing: 5) {
45                Text("Canvas 50 * 50")
46                    .font(.largeTitle)
47                    .fontWeight(.bold)
48                Canvas { context, size in
49                    let w = size.width
50                    let h = size.height
51                    let rows = 50
52                    let cols = 50
53                    let offset = 0.03 * w / CGFloat(cols)
54                    
55                    for r in 0..<rows {
56                        for c in 0..<cols {
57                            let n = Int.random(in: 1..<10)
58
59                            let x = w / CGFloat(cols) * CGFloat(c) + offset
60                            let y = h / CGFloat(rows) * CGFloat(r) + offset
61                            context.fill(
62                                Path(
63                                    roundedRect: CGRect(
64                                        x: x,
65                                        y: y,
66                                        width: 0.94 * w / CGFloat(cols),
67                                        height: 0.94 * h / CGFloat(rows)
68                                    ),
69                                    cornerRadius: w/CGFloat(cols*10)),
70                                with: .color(n%9 == 0 ? .green : .gray))
71                        }
72                    }
73                }
74                .background(.black)
75                .frame(width: 300, height: 300)
76                .border(Color.black)
77                
78                Spacer()
79            }
80        }
81    }
82}

Using Canvas to layout rectangles to represent cells

Canvas to display from 2D array

The CanvasFromArrayView uses a Canvas to layout a grid of rounded rectangles and sets the color of each cell corresponding to a 2D array of values for the cells.

CanvasFromArrayView

 1struct CanvasFromArrayView: View {
 2    
 3    let gridData = [
 4        [1,1,0,0,0],
 5        [0,1,0,1,0],
 6        [0,0,0,0,1],
 7        [0,1,0,1,0],
 8        [0,0,0,1,0]
 9    ]
10    
11    var body: some View {
12        VStack {
13            VStack(spacing: 5) {
14                Text("Canvas from 2D array")
15                    .font(.largeTitle)
16                    .fontWeight(.bold)
17                Canvas { context, size in
18                    let w = size.width
19                    let h = size.height
20                    let rows = gridData.count
21                    let cols = gridData[0].count
22                    let offset = 0.03 * w / CGFloat(cols)
23                    
24                    for r in 0..<rows {
25                        for c in 0..<cols {
26                            let x = w / CGFloat(cols) * CGFloat(c) + offset
27                            let y = h / CGFloat(rows) * CGFloat(r) + offset
28                            context.fill(
29                                Path(
30                                    roundedRect: CGRect(
31                                        x: x,
32                                        y: y,
33                                        width: 0.94 * w / CGFloat(cols),
34                                        height: 0.94 * h / CGFloat(rows)
35                                    ),
36                                    cornerRadius: w/CGFloat(cols*10)),
37                                with: .color(gridData[r][c] == 1 ? .green: .gray))
38                        }
39                    }
40                }
41                .background(.black)
42                .frame(width: 300, height: 300)
43                .border(Color.black)
44            }
45            Spacer()
46                .frame(height: 40)
47            
48            Divider()
49            
50            VStack(spacing: 5) {
51                Text("Values in 2D array")
52                    .font(.largeTitle)
53                    .fontWeight(.bold)
54                Grid(alignment: .center, horizontalSpacing: 3, verticalSpacing: 3) {
55                    ForEach(0..<gridData.count, id:\.self) { r in
56                        GridRow {
57                            ForEach(0..<gridData[r].count,  id:\.self) { c in
58                                Rectangle().fill(.quaternary)
59                                    .overlay(
60                                        Text("\(gridData[r][c])")
61                                            .font(.title2)
62                                            .fontWeight(.bold)
63                                    )
64                            }
65                        }
66                    }
67                }
68                .background(.quaternary)
69                .frame(width: 200, height: 200)
70                
71                Spacer()
72            }
73        }
74    }
75}

Using Canvas to layout cells based on values in 2D array

Game Of Life Model and ViewModel

The LifeModel is used to contain and control the essence of the Game of Life. It can be created with a variable number of cells, which form a square grid. Conceptually the grid is setup to warp around, so that the cells on the top row are neighbours to cells on the bottom row and so on.

The LifeViewModel is used to bridge between the model and the views following the MVVM pattern - see MVVM in SwiftUI for more information on MVVM.

The CanvasFromModelView is used to test the display of the data from the LifeModel in a SwiftUI view using the Canvas to layout the cells. A button is added to the view to reset the model and ensure the data is reflected in the view.

LifeModel

  1struct LifeModel {
  2    private(set) var cellCount:Int
  3    var grid:[[Int]]
  4    private(set) var numberOfCycles: Int
  5    
  6    init(cells:Int){
  7        cellCount = cells
  8        grid = Array(repeating: Array(repeating: 0, count: cellCount), count: cellCount)
  9        self.numberOfCycles = 0
 10        self.randomise()
 11    }
 12    
 13    mutating func randomise() {
 14        for r in 0..<cellCount {
 15            for c in 0..<cellCount {
 16                grid[r][c] = (Int.random(in: 1..<100))%3 == 0 ? 1 : 0
 17            }
 18        }
 19    }
 20    
 21    mutating func step() {
 22        let newGrid = nextGrid(currentGrid: self.grid)
 23        if self.grid != newGrid {
 24            self.grid = newGrid
 25            numberOfCycles += 1
 26        }
 27    }
 28    
 29    mutating func performStepDelay() async -> Bool {
 30        var gridIsDifferent = true
 31        let newGrid = nextGrid(currentGrid: self.grid)
 32        if self.grid == newGrid {
 33            gridIsDifferent = false
 34        } else {
 35            self.grid = newGrid
 36            numberOfCycles += 1
 37        }
 38
 39        usleep(300000)
 40        return gridIsDifferent
 41    }
 42        
 43    func nextGrid(currentGrid:[[Int]]) -> [[Int]] {
 44        // initialise the next grid with all zeros
 45        var nextGrid = Array(repeating: Array(repeating: 0, count: cellCount), count: cellCount)
 46
 47        for row in 0..<(currentGrid.count) {
 48            for col in 0..<(currentGrid[row].count) {
 49                // Create a 3x3 grid for cells surrounding the current cell
 50                let surroundingGrid: [[Int]] = [
 51                    [
 52                        currentGrid[(row-1+currentGrid.count)%currentGrid.count][(col-1+currentGrid[row].count)%currentGrid[row].count],
 53                        currentGrid[(row-1+currentGrid.count)%currentGrid.count][col],
 54                        currentGrid[(row-1+currentGrid.count)%currentGrid.count][(col+1+currentGrid[row].count)%currentGrid[row].count]
 55                    ],
 56                    [
 57                        currentGrid[row][(col-1+currentGrid[row].count)%currentGrid[row].count],
 58                        currentGrid[row][col],
 59                        currentGrid[row][(col+1+currentGrid[row].count)%currentGrid[row].count]
 60                    ],
 61                    [
 62                        currentGrid[(row+1+currentGrid.count)%currentGrid.count][(col-1+currentGrid[row].count)%currentGrid[row].count],
 63                        currentGrid[(row+1+currentGrid.count)%currentGrid.count][col],
 64                        currentGrid[(row+1+currentGrid.count)%currentGrid.count][(col+1+currentGrid[row].count)%currentGrid[row].count]
 65                    ]
 66                ]
 67                let cellValue:Int = determineCellValue(threeGrid: surroundingGrid)
 68
 69                nextGrid[row][col] = cellValue
 70            }
 71        }
 72        
 73        return nextGrid
 74    }
 75    
 76    ///  Rules
 77    ///  1.   Any live cell with fewer than two live neighbours dies, as if by underpopulation.
 78    ///  2.   Any live cell with two or three live neighbours lives on to the next generation.
 79    ///  3 .  Any live cell with more than three live neighbours dies, as if by overpopulation.
 80    ///  4.   Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.
 81    func determineCellValue(threeGrid:[[Int]]) -> Int {
 82        let currentCellValue = threeGrid[1][1]
 83        let neighbourCount = threeGrid.flatMap { $0 }.reduce(0, +) - currentCellValue
 84        var cellValue = 0
 85        switch neighbourCount {
 86        case 0..<2 :
 87            cellValue = 0
 88        case 2:
 89            cellValue = currentCellValue==1 ? 1 : 0
 90        case 3:
 91            cellValue = 1
 92        case 4..<9 :
 93            cellValue = 0
 94        default:
 95            cellValue = 0
 96        }
 97        return cellValue
 98    }
 99    
100}

LifeViewModel

 1@Observable class LifeViewModel {
 2    var lifeModel = LifeModel(cells: 10)
 3    private(set) var isRunning: Bool
 4
 5    init() {
 6        self.isRunning = false
 7    }
 8
 9    var numberOfCycles:  Int  {
10        return lifeModel.numberOfCycles
11    }
12    
13    func reset(gridSize: Int = 10) {
14        self.isRunning = false
15        self.lifeModel = LifeModel(cells: gridSize)
16    }
17    
18    func step() {
19        lifeModel.step()
20    }
21    
22    func setGridSize(cellNumber:Int) {
23        self.lifeModel = LifeModel(cells: cellNumber)
24    }
25    
26    @MainActor
27    func performNumberOfCycles(number: Int) async {
28        self.isRunning = true
29        for _ in 1...number {
30            let different = await lifeModel.performStepDelay()
31            if !different || !self.isRunning {
32                break
33            }
34        }
35        self.isRunning = false
36    }
37    
38    @MainActor
39    func stop() async {
40        self.isRunning = false
41    }
42}

CanvasFromModelView

 1struct CanvasFromModelView: View {
 2    @Environment(LifeViewModel.self) private var lifeViewModel
 3
 4    var body: some View {
 5        let gridData = lifeViewModel.lifeModel.grid
 6        
 7        VStack {
 8            VStack(spacing: 5) {
 9                Text("Canvas from Model")
10                    .font(.largeTitle)
11                    .fontWeight(.bold)
12                Canvas { context, size in
13                    let w = size.width
14                    let h = size.height
15                    let rows = gridData.count
16                    let cols = gridData[0].count
17                    let offset = 0.03 * w / CGFloat(cols)
18                    
19                    for r in 0..<rows {
20                        for c in 0..<cols {
21                            let x = w / CGFloat(cols) * CGFloat(c) + offset
22                            let y = h / CGFloat(rows) * CGFloat(r) + offset
23                            context.fill(
24                                Path(
25                                    roundedRect: CGRect(
26                                        x: x,
27                                        y: y,
28                                        width: 0.94 * w / CGFloat(cols),
29                                        height: 0.94 * h / CGFloat(rows)
30                                    ),
31                                    cornerRadius: w/CGFloat(cols*10)),
32                                with: .color(gridData[r][c] == 1 ? .green: .gray))
33                        }
34                    }
35                }
36                .background(.black)
37                .frame(width: 300, height: 300)
38                .border(Color.black)
39            }
40            Spacer()
41                .frame(height: 40)
42            
43            Divider()
44            
45            VStack(spacing: 5) {
46                Text("Values in Model")
47                    .font(.largeTitle)
48                    .fontWeight(.bold)
49                
50                Grid(alignment: .center, horizontalSpacing: 2, verticalSpacing: 2) {
51                    ForEach(0..<gridData.count, id:\.self) { r in
52                        GridRow {
53                            ForEach(0..<gridData[r].count,  id:\.self) { c in
54                                Rectangle().fill(.quaternary)
55                                    .overlay(
56                                        Text("\(gridData[r][c])")
57                                            .font(.title3)
58                                            .fontWeight(.bold)
59                                            .foregroundColor(
60                                                gridData[r][c] == 1 ?  .primary : .secondary
61                                            )
62                                    )
63                            }
64                        }
65                    }
66                }
67                .background(.quaternary)
68                .frame(width: 250, height: 250)
69                
70                Spacer()
71            }
72            
73            Button("Randomise") { lifeViewModel.reset() }
74                .buttonStyle(.borderedProminent)
75        }
76    }
77}

Using Canvas to layout cells from ViewModel

Play Game of Life

Now that all the pieces are in place, we can create the Game of Life view. A [picker][] is used to provide different options for the number of cells on a side of the grid. A Reset button is to reset the grid with a random number of cells alive. A step button performs one iteration of the game. The start button starts the game with the grid updating automatically. A delay is incorporated in the model to allow time for the view to update and the update is called asynchronously.

GameOfLifeView

  1struct GameOfLifeView: View {
  2    @Environment(LifeViewModel.self) private var lifeViewModel
  3    @State var gridSize: Int
  4    
  5    let repeatOptions = [5, 10, 20, 50, 100]
  6    
  7    var body: some View {
  8        let gridData = lifeViewModel.lifeModel.grid
  9        
 10        VStack {
 11            VStack(spacing: 5) {
 12                Text("Conway's Game of Life")
 13                    .font(.title)
 14                    .fontWeight(.bold)
 15                Canvas { context, size in
 16                    let w = size.width
 17                    let h = size.height
 18                    let rows = gridData.count
 19                    let cols = gridData[0].count
 20                    let offset = 0.03 * w / CGFloat(cols)
 21                    
 22                    for r in 0..<rows {
 23                        for c in 0..<cols {
 24                            let x = w / CGFloat(cols) * CGFloat(c) + offset
 25                            let y = h / CGFloat(rows) * CGFloat(r) + offset
 26                            context.fill(
 27                                Path(
 28                                    roundedRect: CGRect(
 29                                        x: x,
 30                                        y: y,
 31                                        width: 0.94 * w / CGFloat(cols),
 32                                        height: 0.94 * h / CGFloat(rows)
 33                                    ),
 34                                    cornerRadius: w/CGFloat(cols*10)),
 35                                with: .color(gridData[r][c] == 1 ? .green: .gray))
 36                        }
 37                    }
 38                }
 39                .background(.black)
 40                .frame(width: 350, height: 350)
 41                .border(Color.black)
 42            }
 43            
 44            Divider()
 45                .frame(height: 50)
 46
 47            VStack {
 48                GroupBox {
 49                    Text("Grid Size:")
 50                        .font(.custom("Helvetica Neue", size: 22, relativeTo: .largeTitle))
 51                        .fontWeight(.bold)
 52                    
 53                    
 54                    Picker("", selection: $gridSize) {
 55                        ForEach(repeatOptions, id: \.self) {
 56                            Text("\($0)")
 57                                .fontWeight(.heavy)
 58                        }
 59                    }
 60                    .onChange(of: gridSize) {
 61                        lifeViewModel.setGridSize(cellNumber: gridSize)
 62                    }
 63                    .pickerStyle(.segmented)
 64                    .background(Color(hue: 0.10, saturation: 0.10, brightness: 0.98))
 65                    .disabled(lifeViewModel.isRunning)
 66                }
 67                .groupBoxStyle(YellowGroupBoxStyle())
 68            }
 69            
 70            Divider()
 71            
 72            VStack {
 73                Text("Number of Cycles: \(lifeViewModel.numberOfCycles)")
 74                    .font(.custom("Helvetica Neue", size: 22, relativeTo: .largeTitle))
 75                    .fontWeight(.bold)
 76            }
 77            
 78            HStack {
 79                Button("Reset") { lifeViewModel.reset(gridSize: self.gridSize) }
 80                    .buttonStyle(ActionButtonStyle())
 81                    .disabled(lifeViewModel.isRunning)
 82                
 83                Button("Step") { lifeViewModel.step() }
 84                    .buttonStyle(ActionButtonStyle())
 85                    .disabled(lifeViewModel.isRunning)
 86            }
 87            
 88            HStack {
 89                Button("Start") {
 90                    Task {
 91                        await lifeViewModel.performNumberOfCycles(number: 1000)
 92                    }
 93                }
 94                .buttonStyle(ActionButtonStyle())
 95                .disabled(lifeViewModel.isRunning)
 96                
 97                Button("Stop") {
 98                    Task {
 99                        await lifeViewModel.stop()
100                    }
101                }
102                .buttonStyle(ActionButtonStyle())
103                .disabled(!lifeViewModel.isRunning)
104                
105                
106            }
107            
108            Spacer()
109        }
110    }
111}

GameOfLifeAppApp

 1struct GameOfLifeAppApp: App {
 2    
 3    /// The app's state.
 4    @State private var lifeViewModel = LifeViewModel()
 5
 6    var body: some Scene {
 7        WindowGroup {
 8            ContentView()
 9                .environment(lifeViewModel)
10        }
11    }
12}

Conway's game of life view

Conway's game of life

Conclusion

It is possible to implement Conway's Game of Life in SwiftUI and there are a number of ways to implement it. This article showed how to use a Canvas to represent the grid for the game and to store the state of the game in a 2D array of Ints.

I find watching the game mesmerising. There is lots of room for improvement in this representation of the game, such as; having set starting patterns; being able to pause the game and manually change the state of some of the cells just to see the effect; or a mechanism to set the speed of the game.

The source code for GameOfLifeApp is available on GitHub.

Create a Pie or Donut chart with SwiftUI Charts in iOS 17

Eric Callanan — Sunday, 22 Oct 2023

A pie chart is a circular graph that represents data as slices of a whole. Each slice, or “wedge”, represents a portion or percentage of the whole data set. Pie charts can be used to show the composition of a categorical data set, where each category’s size is proportional to its percentage of the whole. This article shows how to create a pie chart and a donut chart and how to customise the appearance of these charts using swift charts.

I have not written an article for a while as I was distracted and I'm training for my first marathon at the end of October. Earlier this year, my brother passed away from cancer and I decided to run the Dublin city Marathon to raise money for the Irish Cancer Society. Here is my fund raising page if you would like to donate to this worthy cause.

In the meantime, iOS 17 has come out and Apple has enhanced the charting capabilities of swift charts. In this article information from the Irish Cancer societies annual report is used to explore the creation and customisation of Pie charts and donut charts in Swift charts.

Related articles on Swift Charts:

Create a line chart with SwiftUI Charts in iOS 16

Customise a line chart with SwiftUI Charts in iOS 16

Create a bar chart with SwiftUI Charts in iOS 16

Visualise the Matthew Effect with Swift Charts

Display top section of Bar Charts with Swift Charts

Add horizontal scroll to charts with SwiftUI Charts in iOS 16

Charts before Swift Charts:

How to create a pie chart in SwiftUI

Bar chart of the data

Start with a bar chart using Swift Charts, which was introduced in 2022 with iOS 16. The data used in this article is from the Irish Cancer Society Annual Report 2022. The breakdown of the income data in the following tables is used for the pie and donut charts.

First the date is defined as an array of IncomeData that contains a category and an amount. Swift Chart iterates over the array and creates a BarMark for each item.

Income for Irish Cancer Society from different sources in 2021 and 2022

Income	2021	2022
Donations and legacies	€22.0m	€19.8m
Trading activities	€2.5m	€4.2m
Charitable activities	€1.7m	€2.4m
Other and investment	€0.4m	€0.2m
=======================	==========	==========
Total income	€26.6m	€26.6m

Breakdown of income in Donations and legacies in 2022

Income	2022
Legacies	€2.4m
Individual giving	€3.2m
Philanthropy and corporate partnerships	€4.0m
Daffodil Day	€4.7m
Other national campaigns and donations	€5.5m
============================================	==========
Total Donations and legacies	€19.8m

Income Data

 1struct IncomeData: Identifiable, Equatable {
 2    var category: String
 3    var amount: Double
 4    var id = UUID()
 5}
 6
 7let totalIncomeData: [IncomeData] = [
 8    .init(category: "Donations and legacies", amount: 19.8),
 9    .init(category: "Trading activities", amount: 4.2),
10    .init(category: "Charitable activities", amount: 2.4),
11    .init(category: "Other and investment", amount: 0.2)
12]
13
14let donationsIncomeData: [IncomeData] = [
15    .init(category: "Legacies", amount: 2.4),
16    .init(category: "Other national campaigns and donations", amount: 5.5),
17    .init(category: "Daffodil Day", amount: 4.7),
18    .init(category: "Philanthropy and corporate partnerships", amount: 4.0),
19    .init(category: "Individual giving", amount: 3.2)
20]

BarChartView

 1struct BarChartView: View {
 2    var body: some View {
 3        VStack {
 4            GroupBox ( "Bar Chart - 2022 Income (€ million)") {
 5                Chart(totalIncomeData) {
 6                    BarMark(
 7                        x: .value("Category", $0.category),
 8                        y: .value("Amount", $0.amount)
 9                    )
10                }
11            }
12            .frame(height: 300)
13            
14            GroupBox ("2022 Donations and legacies (€ million)") {
15                Chart(donationsIncomeData) {
16                    BarMark(
17                        x: .value("Category", $0.category),
18                        y: .value("Amount", $0.amount)
19                    )
20                }
21            }
22            .frame(height: 300)
23
24            Spacer()
25        }
26        .padding()
27    }
28}

Swift Bar Chart showing income for Irish Cancer Society for 2022

Use SectorMark to create a Pie Chart

The reason to start with the Bar chart is that is is easy to convert it to a Pie chart by replacing BarMark with SectorMark for each item in the array. The size of each sector is calculated as a percentage of the whole automatically. The sectors in the pie chart start at 12 o'clock and move in a clockwise direction.

BarAndPieChartView

 1struct BarAndPieChartView: View {
 2    var body: some View {
 3        VStack {
 4            GroupBox ( "Bar Chart - 2022 Donations and legacies (€ million)") {
 5                Chart(donationsIncomeData) {
 6                    BarMark(
 7                        x: .value("Amount", $0.amount),
 8                        stacking: .normalized
 9                    )
10                    .foregroundStyle(by: .value("category", $0.category))
11                }
12            }
13            .frame(height: 200)
14            
15            GroupBox ( "Pie Chart - 2022 Donations and legacies (€ million)") {
16                Chart(donationsIncomeData) {
17                    SectorMark(
18                        angle: .value("Amount", $0.amount)
19                    )
20                    .foregroundStyle(by: .value("category", $0.category))
21                }
22            }
23            .frame(height: 500)
24            
25            Spacer()
26        }
27        .padding()
28    }
29}

Swift Bar and Pie charts showing income for Irish Cancer Society for 2022

Add Spaces and rounded corners

A space can be added between the sectors of a pie chart by specifying a value for angularInset, which takes an optional CGFloat. The angularInset specifies the space that the inner lines of a Sector can be set. It is not clear what units this value is in and the documentation states "A radius for the corners of the sector." - which I believe should be the description for the cornerRadius. I found that the angularInset can be set to any value between 0.0 and 8.2, well it can be set to any value but only values between 0.0 and 8.8 have any impact on the Pie Chart.

The cornerRadius modifier is used to apply a rounded corner to the outer curve of the sector.

RoundedSectorSpaceView

 1struct RoundedSectorSpaceView: View {
 2    var body: some View {
 3        VStack {
 4            GroupBox ( "2022 Donations and Legacies (€ million)") {
 5                Chart(donationsIncomeData) {
 6                    SectorMark(
 7                        angle: .value("Amount", $0.amount),
 8                        angularInset: 3.0
 9                    )
10                    .cornerRadius(6.0)
11                    .foregroundStyle(by: .value("category", $0.category))
12                }
13            }
14            .frame(height: 500)
15            
16            Spacer()
17        }
18        .padding()
19    }
20}

Swift Pie chart with spaces between sectors and rounded corners

Create Donut chart

A donut chart (or doughnut chart) a variation of the pie chart and is often used to display data in a way that emphasizes the parts of a whole and their relationships. Donut charts are popular in data analysis, business presentations, and reports. A Pie chart can easily be displayed as a Donut chart in Swift Charts by specifying an innerRadius for each SectorMark. This is a MarkDimension and can be set as a size in points, or a .ratio or .inset relative to the outer radius.

View

 1struct DonutChartView: View {
 2    var body: some View {
 3        VStack {
 4            GroupBox ( "2022 Donations and Legacies (€ million)") {
 5                Chart(donationsIncomeData) {
 6                    SectorMark(
 7                        angle: .value("Amount", $0.amount),
 8                        innerRadius: .ratio(0.6),
 9                        angularInset: 3.0
10                    )
11                    .cornerRadius(6.0)
12                    .foregroundStyle(by: .value("category", $0.category))
13                }
14            }
15            .frame(height: 500)
16            
17            Spacer()
18        }
19        .padding()
20    }
21}

Swift donut chart with spaces between sectors and rounded corners

Use custom colors

The default colors in Swift Charts are great, but sometimes it can be good to use a set of colors customised to the App. Like other charts, there are a number of ways to set the colors. One way is to set the color for each SectorMark, but this can be tricky to use when different charts will have different number of categories. An alternative is to specify an array or colors as shown below. Then use chartForegroundStyleScale to bind the categories to the range of colors. Here just 10 colors are set as Pie charts with more than 5 or so sectors are difficult to interpret. The good news is that even if a chart is created with more than 10 categories, the colors simply roll around to the first color again.

chartColors

 1let chartColors: [Color] = [
 2    Color(red: 0.55, green: 0.83 , blue: 0.78),
 3    Color(red: 1.00, green: 1.00 , blue: 0.70),
 4    Color(red: 0.75, green: 0.73 , blue: 0.85),
 5    Color(red: 0.98, green: 0.50 , blue: 0.45),
 6    Color(red: 0.50, green: 0.69 , blue: 0.83),
 7    Color(red: 0.99, green: 0.71 , blue: 0.38),
 8    Color(red: 0.70, green: 0.87 , blue: 0.41),
 9    Color(red: 0.99, green: 0.80 , blue: 0.90),
10    Color(red: 0.85, green: 0.85 , blue: 0.85),
11    Color(red: 0.74, green: 0.50 , blue: 0.74),
12    Color(red: 0.80, green: 0.92 , blue: 0.77),
13    Color(red: 1.00, green: 0.93 , blue: 0.44)
14]

PieChartColorsView

 1struct PieChartColorsView: View {
 2    var body: some View {
 3        VStack {
 4            GroupBox ( "2022 Donations and Legacies (€ million)") {
 5                Chart(donationsIncomeData) {
 6                    SectorMark(
 7                        angle: .value("Amount", $0.amount),
 8                        angularInset: 3.0
 9                    )
10                    .cornerRadius(6.0)
11                    .foregroundStyle(by: .value("category", $0.category))
12                }
13                // Set color for each data in the chart
14                .chartForegroundStyleScale(
15                    domain: donationsIncomeData.map  { $0.category },
16                    range: chartColors
17                )
18
19                // Position the Legend
20                .chartLegend(position: .top, alignment: .center)
21            }
22            .frame(height: 500)
23            
24            Spacer()
25        }
26        .padding()
27    }
28}

Specify custom colors for Pie chart in Swift Charts

Make donut chart interactive

The advantage of a touch screen is the ability for Apps to come to life when they are touched. Charts can display more information when sections of the chart are touched. chartAngleSelection is used in Pie and Donut charts to identify where in the chart data has been selected. This is similar to chartXSelection or chartYSelection in line or bar charts. chartAngleSelection can be a little confusing to use at first. There is a commented out section of the code below to display the currently selected angle in a Text view to help understand what is happening. The selected angle is automatically converted from an angle to a value representing the cumulative sum of the amounts to that point. A state variable is used to bind to the current selected angle and a computed property is used to convert this value to the appropriate incomeData sector of the chart.

InteractiveDonutView

 1struct InteractiveDonutView: View {
 2    @State private var selectedAmount: Double? = nil
 3    let cumulativeIncomes: [(category: String, range: Range<Double>)]
 4
 5    init() {
 6        var cumulative = 0.0
 7        self.cumulativeIncomes = donationsIncomeData.map {
 8            let newCumulative = cumulative + Double($0.amount)
 9            let result = (category: $0.category, range: cumulative ..< newCumulative)
10            cumulative = newCumulative
11            return result
12        }
13    }
14
15    var selectedCategory: IncomeData? {
16        if let selectedAmount,
17           let selectedIndex = cumulativeIncomes
18            .firstIndex(where: { $0.range.contains(selectedAmount) }) {
19            return donationsIncomeData[selectedIndex]
20        }
21        return nil
22    }
23    
24    var body: some View {
25        VStack {
26            GroupBox ( "2022 Donations and Legacies (€ million)") {
27                Chart(donationsIncomeData) {
28                    SectorMark(
29                        angle: .value("Amount", $0.amount),
30                        innerRadius: .ratio(selectedCategory == $0 ? 0.5 : 0.6),
31                        outerRadius: .ratio(selectedCategory == $0 ? 1.0 : 0.9),
32                        angularInset: 3.0
33                    )
34                    .cornerRadius(6.0)
35                    .foregroundStyle(by: .value("category", $0.category))
36                    
37                    .opacity(selectedCategory == $0 ? 1.0 : 0.9)
38                }
39                // Set color for each data in the chart
40                .chartForegroundStyleScale(
41                    domain: donationsIncomeData.map  { $0.category },
42                    range: chartColors
43                )
44                
45                // Position the Legend
46                .chartLegend(position: .bottom, alignment: .center)
47                
48                // Select a sector
49                .chartAngleSelection(value: $selectedAmount)
50                
51                // Display data for selected sector
52                .chartBackground { chartProxy in
53                    GeometryReader { geometry in
54                        let frame = geometry[chartProxy.plotFrame!]
55                        VStack(spacing: 0) {
56                            Text(selectedCategory?.category ?? "")
57                                .multilineTextAlignment(.center)
58                                .font(.body)
59                                .foregroundStyle(.secondary)
60                                .frame(width: 120, height: 80)
61                            Text("€\(selectedCategory?.amount ?? 0, specifier: "%.1f") M")
62                                .font(.title.bold())
63                                .foregroundColor((selectedCategory != nil) ? .primary : .clear)
64                        }
65                        .position(x: frame.midX, y: frame.midY)
66                    }
67                }
68                
69            }
70            .frame(height: 500)
71            
72//            // Testing chartAngleSelection
73//            Text("SelectedAmount")
74//            Text(selectedAmount?.formatted() ?? "none")
75
76            Spacer()
77        }
78        .padding()
79    }
80}

Interactive Donut chart in Swift Charts

Pie or Donut chart with sorted data

The convention of displaying data in a Pie chart is to arrange the sectors from largest to smallest. It would have been good to have some property in the pie chart to sort the data, but there does not appear to be one. The work around is to create a copy of the data and sort it before creating the Pie/Donut chart. In a production app, the data would likely be in a model, which could possibly return the data in a sorted manner. This shows the largest sector on the top right at 12 o'clock, with the next sector following in a clockwise direction.

DonutChartSortedView

 1struct DonutChartSortedView: View {
 2    @State private var selectedAmount: Double? = nil
 3    let cumulativeIncomes: [(category: String, range: Range<Double>)]
 4    
 5    var donationsIncomeDataSorted = donationsIncomeData
 6    
 7    init() {
 8        donationsIncomeDataSorted.sort {
 9            $0.amount > $1.amount
10        }
11
12        var cumulative = 0.0
13        self.cumulativeIncomes = donationsIncomeDataSorted.map {
14            let newCumulative = cumulative + Double($0.amount)
15            let result = (category: $0.category, range: cumulative ..< newCumulative)
16            cumulative = newCumulative
17            return result
18        }
19    }
20
21    var selectedCategory: IncomeData? {
22        if let selectedAmount,
23           let selectedIndex = cumulativeIncomes
24            .firstIndex(where: { $0.range.contains(selectedAmount) }) {
25            return donationsIncomeDataSorted[selectedIndex]
26        }
27        return nil
28    }
29    
30    var body: some View {
31        VStack {
32            GroupBox ( "2022 Donations and Legacies (€ million)") {
33                Chart(donationsIncomeDataSorted) {
34                    SectorMark(
35                        angle: .value("Amount", $0.amount),
36                        innerRadius: .ratio(selectedCategory == $0 ? 0.5 : 0.6),
37                        outerRadius: .ratio(selectedCategory == $0 ? 1.0 : 0.9),
38                        angularInset: 3.0
39                    )
40                    .cornerRadius(6.0)
41                    .foregroundStyle(by: .value("category", $0.category))
42                    
43                    .opacity(selectedCategory == $0 ? 1.0 : 0.8)
44                }
45                // Set color for each data in the chart
46                .chartForegroundStyleScale(
47                    domain: donationsIncomeDataSorted.map  { $0.category },
48                    range: chartColors
49                )
50                
51                // Position the Legend
52                .chartLegend(position: .top, alignment: .center)
53                
54                // Select a sector
55                .chartAngleSelection(value: $selectedAmount)
56                
57                .chartBackground { chartProxy in
58                    GeometryReader { geometry in
59                        let frame = geometry[chartProxy.plotFrame!]
60                        VStack(spacing: 0) {
61                            Text(selectedCategory?.category ?? "")
62                                .multilineTextAlignment(.center)
63                                .font(.body)
64                                .foregroundStyle(.secondary)
65                                .frame(width: 120, height: 80)
66                            Text("\(selectedCategory?.amount ?? 0, specifier: "%.1f")")
67                                .font(.title.bold())
68                                .foregroundColor((selectedCategory != nil) ? .primary : .clear)
69                        }
70                        .position(x: frame.midX, y: frame.midY)
71                    }
72                }
73                
74            }
75            .frame(height: 500)
76            
77            Spacer()
78        }
79        .padding()
80    }
81}

Interactive Donut chart displaying data sorted from largest to smallest in Swift Charts

Add Text onto the Pie chart

Finally, annotations can be used on Pie/Donut charts in a similar mechanism to other Swift Charts. Here an overlay is added for each sector displaying the value for each sector.

DonutWithLabelsView

 1struct DonutWithLabelsView: View {
 2    @State private var selectedAmount: Double? = nil
 3    let cumulativeIncomes: [(category: String, range: Range<Double>)]
 4    
 5    var donationsIncomeDataSorted = donationsIncomeData
 6    
 7    init() {
 8        donationsIncomeDataSorted.sort {
 9            $0.amount > $1.amount
10        }
11
12        var cumulative = 0.0
13        self.cumulativeIncomes = donationsIncomeDataSorted.map {
14            let newCumulative = cumulative + Double($0.amount)
15            let result = (category: $0.category, range: cumulative ..< newCumulative)
16            cumulative = newCumulative
17            return result
18        }
19    }
20
21    var selectedCategory: IncomeData? {
22        if let selectedAmount,
23           let selectedIndex = cumulativeIncomes
24            .firstIndex(where: { $0.range.contains(selectedAmount) }) {
25            return donationsIncomeDataSorted[selectedIndex]
26        }
27        return nil
28    }
29    
30    var body: some View {
31        VStack {
32            GroupBox ( "2022 Donations and Legacies (€ million)") {
33                Chart(donationsIncomeDataSorted) { income in
34                    let amountStr = "\(income.amount)"
35                    SectorMark(
36                        angle: .value("Amount", income.amount),
37                        innerRadius: .ratio(selectedCategory == income ? 0.5 : 0.6),
38                        outerRadius: .ratio(selectedCategory == income ? 1.0 : 0.9),
39                        angularInset: 3.0
40                    )
41                    .cornerRadius(6.0)
42                    .foregroundStyle(by: .value("category", income.category))
43                    .opacity(selectedCategory == income ? 1.0 : 0.8)
44                    .annotation(position: .overlay) {
45                        Text(amountStr)
46                            .font(selectedCategory == income ? .title : .headline)
47                            .fontWeight(.bold)
48                            .padding(5)
49                            .background(Color.white.opacity(0.4))
50                    }
51                }
52                // Set color for each data in the chart
53                .chartForegroundStyleScale(
54                    domain: donationsIncomeDataSorted.map  { $0.category },
55                    range: chartColors
56                )
57                
58                // Position the Legend
59                .chartLegend(position: .top, alignment: .center)
60                
61                // Select a sector
62                .chartAngleSelection(value: $selectedAmount)
63                
64                .chartBackground { chartProxy in
65                    GeometryReader { geometry in
66                        let frame = geometry[chartProxy.plotFrame!]
67                        VStack(spacing: 0) {
68                            Text(selectedCategory?.category ?? "")
69                                .multilineTextAlignment(.center)
70                                .font(.body)
71                                .foregroundStyle(.secondary)
72                                .frame(width: 120, height: 80)
73                            Text("\(selectedCategory?.amount ?? 0, specifier: "%.1f")")
74                                .font(.title.bold())
75                                .foregroundColor((selectedCategory != nil) ? .primary : .clear)
76                        }
77                        .position(x: frame.midX, y: frame.midY)
78                    }
79                }
80                
81            }
82            .frame(height: 500)
83            
84            Spacer()
85        }
86        .padding()
87    }
88}

Interactive Donut chart with Sector labels in Swift Charts

Conclusion

Pie charts are useful for visualizing data with a small number of categories and are commonly used in presentations and reports to make data more accessible and understandable. Pie Charts seemed a bit of an omission from Swift Charts when they were released in iOS 16 and this has now been rectified in iOS 17. A donut chart is a variation on a pie chart where the centre of the pie is removed.

Creating pie charts is similar to other Swift Charts with use of the SectorMark that was added in iOS 17. Each sector represents a category of the data and they are arranged clockwise from 12 o'clock. A Donut chart can be created by specifying an innerRadius to cut out the inner part of the pie chart. This center space can be used to display additional information. The pie/Donut chart can be customised like other Swift Charts, such as changing the colors, moving or hiding the legend. The Pie and Donut charts are a great addition to Swift Charts.

The source code for PieChartApp is available on GitHub.

Animate background with color gradient in SwiftUI

Eric Callanan — Sunday, 30 Jul 2023

Animating the background of an app with a color gradient in SwiftUI can be a great way to enhance your app. By animating a change in the color gradient of the background, you can make your app feel more dynamic and engaging. One way to achieve this effect is by using AngularGradient to keep the background moving. However, other color gradients could easily be used instead.

Related articles on color gradients in SwiftUI:

LinearGradient in SwiftUI

AngularGradient in SwiftUI

RadialGradient in SwiftUI

Animate background with color gradient in SwiftUI

AngularGradient in a rectangle

Let's start with a simple AngularGradient such as that described in Simple AngularGradient in SwiftUI. The center point of the AngularGradient is animated to move through a list of UnitPoints every two seconds. The UnitPoints are relative to the frame containing the AngularGradient. The colors and the duration of the animation can be modified to achieve the desired effect.

 1struct AngularGradientView: View {
 2    @State private var centerPointIndex = 0
 3    
 4    let timer = Timer.publish(every: 2,
 5                              on: .main,
 6                              in: .common).autoconnect()
 7    
 8    let oneColor = [Color(hue: 0.01, saturation: 0.2, brightness: 0.9),
 9                    Color(hue: 0.01, saturation: 1.0, brightness: 0.9)]
10    
11    let unitPoints: [UnitPoint] = [
12        .init(x:0.2, y: 0.8),
13        .init(x:0.5, y: 0.2),
14        .init(x:0.8, y: 0.9)]
15    
16    var body: some View {
17        VStack {
18            Rectangle()
19                .fill(
20                    AngularGradient(colors: oneColor,
21                                    center: unitPoints[centerPointIndex])
22                )
23                .animation(Animation.easeInOut.speed(0.2),
24                           value: centerPointIndex)
25                .frame(width: 400, height: 400)
26                .onReceive(timer) { input in
27                    centerPointIndex = (centerPointIndex + 1) % unitPoints.count
28                }
29        }
30        .padding()
31    }
32}

Animate moving the center of an AngularGradient in SwiftUI

Full background

Place the AngularGradient in a ZStack and modify the view to ignore the safe areas to use it as a background in SwiftUI. This will ensure that the gradient fills the entire screen and moves as the background.

 1struct FullBackgroundView: View {
 2    @State private var centerPointIndex = 0
 3    
 4    let timer = Timer.publish(every: 2,
 5                              on: .main,
 6                              in: .common).autoconnect()
 7    
 8    let oneColor = [Color(hue: 0.01, saturation: 0.2, brightness: 0.9),
 9                    Color(hue: 0.01, saturation: 1.0, brightness: 0.9)]
10    
11    let unitPoints: [UnitPoint] = [
12        .init(x:0.2, y: 0.8),
13        .init(x:0.5, y: 0.2),
14        .init(x:0.8, y: 0.9)]
15    
16    var body: some View {
17        ZStack {
18            Rectangle()
19                .fill(
20                    AngularGradient(colors: oneColor,
21                                    center: unitPoints[centerPointIndex])
22                )
23                .animation(Animation.easeInOut.speed(0.20),
24                           value: centerPointIndex)
25                .onReceive(timer) { input in
26                    centerPointIndex = (centerPointIndex + 1) % unitPoints.count
27                }
28                .edgesIgnoringSafeArea(.all)
29        }
30    }
31}

Animate AngularGradient for entire background in SwiftUI

Purple color

Tweak the colors to use an array of alternating colors to create a star like pattern and adjust the time slightly.

 1struct PurpleBackgroundView: View {
 2    @State private var centerPointIndex = 0
 3    
 4    let timer = Timer.publish(every: 3,
 5                              on: .main,
 6                              in: .common).autoconnect()
 7    
 8    let oneColor = [Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0),
 9                    Color(hue: 285.0/360.0, saturation: 0.4, brightness: 1.0),
10                    Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0),
11                    Color(hue: 285.0/360.0, saturation: 0.4, brightness: 1.0),
12                    Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0),
13                    Color(hue: 285.0/360.0, saturation: 0.4, brightness: 1.0),
14                    Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0)]
15    
16    let unitPoints: [UnitPoint] = [
17        .init(x:0.2, y: 0.8),
18        .init(x:0.1, y: 0.3),
19        .init(x:0.9, y: 0.1),
20        .init(x:0.8, y: 0.9)]
21
22    var body: some View {
23        ZStack {
24            Rectangle()
25                .fill(
26                    AngularGradient(colors: oneColor,
27                                    center: unitPoints[centerPointIndex])
28                )
29                .backgroundStyle(.regularMaterial)
30                .animation(Animation.easeInOut.speed(0.08),
31                           value: centerPointIndex)
32                .onReceive(timer) { input in
33                    centerPointIndex = (centerPointIndex + 1) % unitPoints.count
34                }
35                .edgesIgnoringSafeArea(.all)
36        }
37    }
38}

Use alternating colors in AngularGradient for star effect in SwiftUI

Use Material

A blur effect can be applied over the animated AngularGradient with the use of Material in SwiftUI. This adds a layer over the background and tones down the animation so it is not too distracting. This does seem to hide the animation too much.

 1    struct MaterialBackgroundView: View {
 2    @State private var centerPointIndex = 0
 3    
 4    let timer = Timer.publish(every: 3,
 5                              on: .main,
 6                              in: .common).autoconnect()
 7    
 8    let oneColor = [Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0),
 9                    Color(hue: 285.0/360.0, saturation: 0.4, brightness: 1.0),
10                    Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0),
11                    Color(hue: 285.0/360.0, saturation: 0.4, brightness: 1.0),
12                    Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0),
13                    Color(hue: 285.0/360.0, saturation: 0.4, brightness: 1.0),
14                    Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0)]
15    
16    let unitPoints: [UnitPoint] = [
17        .init(x:0.2, y: 0.8),
18        .init(x:0.1, y: 0.3),
19        .init(x:0.9, y: 0.1),
20        .init(x:0.8, y: 0.9)]
21    
22    var body: some View {
23        ZStack {
24            Rectangle()
25                .fill(
26                    AngularGradient(colors: oneColor,
27                                    center: unitPoints[centerPointIndex])
28                )
29                .backgroundStyle(.regularMaterial)
30                .animation(Animation.easeInOut.speed(0.08),
31                           value: centerPointIndex)
32                .onReceive(timer) { input in
33                    centerPointIndex = (centerPointIndex + 1) % unitPoints.count
34                }
35                .edgesIgnoringSafeArea(.all)
36
37            Rectangle()
38                .background(.ultraThinMaterial)
39                .edgesIgnoringSafeArea(.all)
40        }
41    }
42}

Use material layer over the animated AngularGradient change in SwiftUI

Use Color with Opacity

An alternative way to tone down the animation is to place a color layer over the background and controll how much of the background is seen with the opacity setting.

 1struct ColorBackgroundView: View {
 2    @State private var centerPointIndex = 0
 3    
 4    let timer = Timer.publish(every: 3,
 5                              on: .main,
 6                              in: .common).autoconnect()
 7    
 8    let oneColor = [Color(hue: 285.0/360.0, saturation: 0.7, brightness: 1.0),
 9                    Color(hue: 285.0/360.0, saturation: 0.9, brightness: 1.0),
10                    Color(hue: 285.0/360.0, saturation: 0.7, brightness: 1.0),
11                    Color(hue: 285.0/360.0, saturation: 0.9, brightness: 1.0),
12                    Color(hue: 285.0/360.0, saturation: 0.7, brightness: 1.0),
13                    Color(hue: 285.0/360.0, saturation: 0.9, brightness: 1.0),
14                    Color(hue: 285.0/360.0, saturation: 0.7, brightness: 1.0)]
15    
16    let unitPoints: [UnitPoint] = [
17        .init(x:0.2, y: 0.8),
18        .init(x:0.1, y: 0.3),
19        .init(x:0.9, y: 0.1),
20        .init(x:0.8, y: 0.9)]
21    
22    var body: some View {
23        ZStack {
24            Rectangle()
25                .fill(
26                    AngularGradient(colors: oneColor,
27                                    center: unitPoints[centerPointIndex])
28                )
29                .backgroundStyle(.regularMaterial)
30                .animation(Animation.easeInOut.speed(0.08),
31                           value: centerPointIndex)
32                .onReceive(timer) { input in
33                    centerPointIndex = (centerPointIndex + 1) % unitPoints.count
34                }
35                .edgesIgnoringSafeArea(.all)
36
37            Rectangle()
38                .fill(.white.opacity(0.5))
39                .edgesIgnoringSafeArea(.all)
40        }
41    }
42}

Use color layer over the animated AngularGradient change in SwiftUI

Cards with material background

This is an example of series of cards, showing images, over the animated background that is behind a material.

 1struct MaterialCardsView: View {
 2    @State private var centerPointIndex = 0
 3    
 4    let timer = Timer.publish(every: 3,
 5                              on: .main,
 6                              in: .common).autoconnect()
 7    
 8    let oneColor = [Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0),
 9                    Color(hue: 285.0/360.0, saturation: 0.4, brightness: 1.0),
10                    Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0),
11                    Color(hue: 285.0/360.0, saturation: 0.4, brightness: 1.0),
12                    Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0),
13                    Color(hue: 285.0/360.0, saturation: 0.4, brightness: 1.0),
14                    Color(hue: 285.0/360.0, saturation: 0.2, brightness: 1.0)]
15    
16    let unitPoints: [UnitPoint] = [
17        .init(x:0.2, y: 0.8),
18        .init(x:0.1, y: 0.3),
19        .init(x:0.9, y: 0.1),
20        .init(x:0.8, y: 0.9)]
21    
22    let imageList = ["castle1", "mountain4", "mountain1", "mountain2", "mountain3", "castle2", "mountain5"]
23    
24    var body: some View {
25        ZStack {
26            Rectangle()
27                .fill(
28                    AngularGradient(colors: oneColor,
29                                    center: unitPoints[centerPointIndex])
30                )
31                .backgroundStyle(.regularMaterial)
32                .animation(Animation.easeInOut.speed(0.08),
33                           value: centerPointIndex)
34                .onReceive(timer) { input in
35                    centerPointIndex = (centerPointIndex + 1) % unitPoints.count
36                }
37                .edgesIgnoringSafeArea(.all)
38            
39            Rectangle()
40                .background(.ultraThinMaterial)
41                .edgesIgnoringSafeArea(.all)
42            
43            ScrollView {
44                VStack(spacing: 30) {
45                    ForEach(0..<imageList.count, id: \.self) { index in
46                        CardView(imageName: imageList[index])
47                            .frame(width: 350, height: 200)
48                    }
49                    Spacer()
50                }
51                .padding()
52            }
53        }
54    }
55}

Display cards on material over animated background

Cards with color background

This is an example of series of cards, showing images, over the animated background that is behind an opaque color layer. The use of opacity can be a great way to control how much of the animation is seen.

 1struct ColorWithCardsView: View {
 2    @State private var centerPointIndex = 0
 3    
 4    let timer = Timer.publish(every: 3,
 5                              on: .main,
 6                              in: .common).autoconnect()
 7    
 8    let oneColor = [Color(hue: 285.0/360.0, saturation: 0.7, brightness: 1.0),
 9                    Color(hue: 285.0/360.0, saturation: 0.9, brightness: 1.0),
10                    Color(hue: 285.0/360.0, saturation: 0.7, brightness: 1.0),
11                    Color(hue: 285.0/360.0, saturation: 0.9, brightness: 1.0),
12                    Color(hue: 285.0/360.0, saturation: 0.7, brightness: 1.0),
13                    Color(hue: 285.0/360.0, saturation: 0.9, brightness: 1.0),
14                    Color(hue: 285.0/360.0, saturation: 0.7, brightness: 1.0)]
15    
16    let unitPoints: [UnitPoint] = [
17        .init(x:0.2, y: 0.8),
18        .init(x:0.1, y: 0.3),
19        .init(x:0.9, y: 0.1),
20        .init(x:0.8, y: 0.9)]
21    
22    let imageList = ["castle1", "mountain4", "mountain1", "mountain2", "mountain3", "castle2", "mountain5"]
23    
24    var body: some View {
25        ZStack {
26            Rectangle()
27                .fill(
28                    AngularGradient(colors: oneColor,
29                                    center: unitPoints[centerPointIndex])
30                )
31                .backgroundStyle(.regularMaterial)
32                .animation(Animation.easeInOut.speed(0.08),
33                           value: centerPointIndex)
34                .onReceive(timer) { input in
35                    centerPointIndex = (centerPointIndex + 1) % unitPoints.count
36                }
37                .edgesIgnoringSafeArea(.all)
38
39            Rectangle()
40                .fill(.white.opacity(0.5))
41                .edgesIgnoringSafeArea(.all)
42            
43            
44            ScrollView {
45                VStack(spacing: 30) {
46                    ForEach(0..<3, id: \.self) { index in
47                        CardView(imageName: imageList[index])
48                            .frame(width: 350, height: 200)
49                    }
50                    Spacer()
51                }
52                .padding()
53            }
54        }
55    }
56}

Display cards on color over animated background

Conclusion

Animating a change in the color gradient of the background can make your app feel more dynamic and engaging. This article demonstrated one way to achieve this effect is by using AngularGradient to keep the background moving. There is a balance between animation to make the app engaging and animation that can be distracting. A Material layer can be used to tone down the background, but this seems to hide the background too much. A color layer seems a better fit with control of how much of the background animation is shown controlled by the opacity level.

The source code for ColorGradientApp is available on GitHub.

RadialGradient in SwiftUI

Eric Callanan — Sunday, 09 Jul 2023

RadialGradient in SwiftUI is used to create a color gradient of two or more colors where the colors change as distance increases from a center point outwards. The colors are scaled to fit within the defined start and end radii.

The RadialGradient object is initialized with an array of colors that are shown in increasing concentric circles ordered from a center point, with the initial color filling in from the center point to the startRadius and the final color filling the view outside the endRadius. SwiftUI automatically interpolates between the colors as the circles increase. RadialGradient can be adjusted by changing its center and the startRadius and endRadius parameters to create different effects.

Related articles on color gradients in SwiftUI:

LinearGradient in SwiftUI

AngularGradient in SwiftUI

RadialGradient in SwiftUI

Animate background with color gradient in SwiftUI

Simple Radial Gradient

We'll reuse the arrays of colors defined in LinearGradient in SwiftUI. The view shows RadialGradient with two colors and with seven colors, specifying the center point of the gradient as the center of the view. The initial color starts at the center (startRadius of 0) and moves outwards from the center to edge of the frame (endRadius of 150) in a frame that 300 by 300.

AppColors

 1struct AppColors {
 2    static let oneColor = [Color(hue: 0.01, saturation: 0.2, brightness: 0.9),
 3                           Color(hue: 0.01, saturation: 1.0, brightness: 0.9)]
 4
 5    static let twoColors = [Color.blue, .yellow]
 6
 7    static let rainbow = [
 8        Color.red,
 9        .orange,
10        .yellow,
11        .green,
12        .blue,
13        Color(hue: 0.773, saturation: 1.0, brightness: 0.51),
14        Color(hue: 0.771, saturation: 1.0, brightness: 1.00)
15    ]
16
17    static let rainbowClear = [
18        Color.clear,
19        .red,
20        .orange,
21        .yellow,
22        .green,
23        .blue,
24        Color(hue: 0.773, saturation: 1.0, brightness: 0.51),
25        Color(hue: 0.771, saturation: 1.0, brightness: 1.00),
26        .clear
27    ]
28}

StartRadialGradientView

 1struct StartRadialGradientView: View {
 2    var body: some View {
 3        VStack {
 4            Text("RadialGradient")
 5                .font(.largeTitle)
 6                .fontWeight(.bold)
 7            Divider()
 8            
 9            VStack(spacing: 0) {
10                Text("Two colors")
11                    .font(.title)
12                    .fontWeight(.bold)
13                
14                RoundedRectangle(cornerRadius: 20)
15                    .fill(
16                        RadialGradient(colors: AppColors.twoColors,
17                                       center: .center,
18                                       startRadius: 0,
19                                       endRadius: 150)
20                    )
21                    .frame(width: 300, height: 300)
22            }
23            Divider()
24
25            VStack(spacing: 0) {
26                Text("Seven colors")
27                    .font(.title)
28                    .fontWeight(.bold)
29                
30                RoundedRectangle(cornerRadius: 20)
31                    .fill(
32                        RadialGradient(colors: AppColors.rainbow,
33                                       center: .center,
34                                       startRadius: 0,
35                                       endRadius: 150)
36                    )
37                    .frame(width: 300, height: 300)
38            }
39            
40            Spacer()
41        }
42    }
43}

Simple Radial Gradient specifying the colors, center and radii in SwiftUI

Standard center options of RadialGradient

An array of colors and a start and end radii are required to initialise a RadialGradient. This code displays how the seven colors are shown using the different standard center point options. The last color in the array of colors (violet) is used to fill in all the remaining area in the frame outside the endRadius.

RadialGradientView

 1struct RadialGradientView: View {
 2    var center: UnitPointType
 3
 4    var body: some View {
 5        HStack {
 6            VStack {
 7                Text("\(center.rawValue)").font(.title2)
 8            }
 9            RoundedRectangle(cornerRadius: 20)
10                .fill(
11                    RadialGradient(colors: AppColors.rainbow,
12                                   center: center.unitPoint,
13                                   startRadius: 0,
14                                   endRadius: 50)
15                )
16                .frame(width: 100, height: 100)
17        }
18    }
19}

CenterOptionsView

 1struct CenterOptionsView: View {
 2    var body: some View {
 3        ScrollView {
 4            VStack {
 5                Text("All Center Options")
 6                    .font(.largeTitle)
 7                    .fontWeight(.bold)
 8                Divider()
 9                
10                VStack(alignment: .trailing) {
11                    ForEach(UnitPointType.allCases, id: \.self) { endinging in
12                        RadialGradientView(center: endinging)
13                    }
14                }
15            }
16        }
17    }
18}

Standard center options for Radial Gradient in SwiftUI

Animate movement of center of RadialGradient

It can be easier to see the effect of setting the center point of the RadialGradient by animating the change from one center point to another.

AnimateCenterView

 1struct AnimateCenterView: View {
 2    @State private var centerPointIndex = 4
 3    
 4    let timer = Timer.publish(every: 2,
 5                              on: .main,
 6                              in: .common).autoconnect()
 7    
 8    var body: some View {
 9        VStack {
10            Text("Move center")
11                .font(.largeTitle)
12                .fontWeight(.bold)
13            
14            Rectangle()
15                .fill(
16                    RadialGradient(colors: AppColors.rainbow,
17                                   center: UnitPointType.allCases[centerPointIndex].unitPoint,
18                                   startRadius: 5,
19                                   endRadius: 250)
20                )
21                .animation(Animation.easeInOut.speed(0.2),
22                           value: centerPointIndex)
23                .frame(width: 400, height: 400)
24                .onReceive(timer) { input in
25                    centerPointIndex = (centerPointIndex + 1) % UnitPointType.allCases.count
26                }
27            
28            
29            VStack(alignment: .leading)  {
30                HStack() {
31                    Text("center: ")
32                    Text(" \(UnitPointType.allCases[centerPointIndex].rawValue)")
33                        .animation(Animation.easeInOut.speed(0.6),
34                               value: centerPointIndex)
35                    Spacer()
36                }
37                .padding()
38                .font(.title)
39                .fontWeight(.bold)
40            }
41            
42            Spacer()
43        }
44        .padding()
45    }
46}

Animate movement of center of Radial Gradient in SwiftUI

Setting start radius and end radius of RadialGradient

This code keeps the center point of the RadialGradient in the center of the frame and shows the effect of setting different start and end radii. The color from the center point to the startRadius is filled in with the initial color in the color array, while any area outside the endRadius is filled with the last color.

StartEndRadiusView

 1struct StartEndRadiusView: View {
 2    var body: some View {
 3        VStack(spacing: 30) {
 4            Text("Start and End Radius")
 5                .font(.title)
 6                .fontWeight(.bold)
 7            
 8            VStack(alignment: .trailing) {
 9                HStack {
10                    Spacer()
11                    VStack(alignment: .trailing)  {
12                        Text("Start Radius =   0")
13                        Text("End Radius = 50")
14                    }
15                    RoundedRectangle(cornerRadius: 20)
16                        .fill(
17                            RadialGradient(colors: AppColors.rainbow,
18                                           center: .center,
19                                           startRadius: 0,
20                                           endRadius: 50)
21                        )
22                        .frame(width: 200, height: 200)
23                }
24            }
25            
26            VStack(alignment: .trailing) {
27                HStack {
28                    Spacer()
29                    VStack(alignment: .trailing)  {
30                        Text("Start Radius =   50")
31                        Text("End Radius = 150")
32                    }
33                    RoundedRectangle(cornerRadius: 20)
34                        .fill(
35                            RadialGradient(colors: AppColors.rainbow,
36                                           center: .center,
37                                           startRadius: 50,
38                                           endRadius: 150)
39                        )
40                        .frame(width: 200, height: 200)
41                }
42            }
43            
44            VStack(alignment: .trailing) {
45                HStack {
46                    Spacer()
47                    VStack(alignment: .trailing)  {
48                        Text("Center = (0.2, 0.8)")
49                        Text("Start Radius =   0")
50                        Text("End Radius = 50")
51                    }
52                    RoundedRectangle(cornerRadius: 20)
53                        .fill(
54                            RadialGradient(colors: AppColors.rainbow,
55                                           center: UnitPoint(x: 0.2, y: 0.8),
56                                           startRadius: 0,
57                                           endRadius: 50)
58                        )
59                        .frame(width: 200, height: 200)
60                }
61            }
62
63            Spacer()
64            
65        }
66        .padding()
67    }
68}

AnimateRadiiView

 1struct AnimateRadiiView: View {
 2    @State private var startRadius:CGFloat = 0
 3    @State private var endRadius:CGFloat = 100
 4    
 5    let timer = Timer.publish(every: 2,
 6                              on: .main,
 7                              in: .common).autoconnect()
 8    
 9    func randomRadii() -> (CGFloat, CGFloat) {
10        let radius1 = CGFloat(Double.random(in: 0...100))
11        let radius2 = CGFloat(Double.random(in: 0...200))
12        
13        return (min(radius1, radius2), max(radius1, radius2))
14    }
15    
16    var body: some View {
17        VStack {
18            Text("Change Start & End Radii")
19                .font(.title)
20                .fontWeight(.bold)
21            
22            Rectangle()
23                .fill(
24                    RadialGradient(colors: AppColors.rainbow,
25                                   center: .center,
26                                   startRadius: startRadius,
27                                   endRadius: endRadius)
28                )
29                .animation(Animation.easeInOut.speed(0.2),
30                           value: startRadius)
31                .frame(width: 400, height: 400)
32                .onReceive(timer) { _ in
33                    (startRadius, endRadius) = randomRadii()
34                }
35            
36            
37            VStack(alignment: .trailing)  {
38                HStack() {
39                    Spacer()
40                    Text("Start Radius: ")
41                        .font(.title2)
42                    Text("\(startRadius, specifier: "%.2F")")
43                        .font(.title)
44                        .frame(width: 130)
45                        .animation(Animation.easeInOut.speed(0.6),
46                                   value: startRadius)
47                }
48                HStack() {
49                    Spacer()
50                    Text("End Radius: ")
51                        .font(.title2)
52                    Text("\(endRadius, specifier: "%.2F")")
53                        .font(.title)
54                        .frame(width: 130)
55                        .animation(Animation.easeInOut.speed(0.6),
56                                   value: endRadius)
57                }
58            }
59            .padding()
60            .fontWeight(.bold)
61            
62            
63            Spacer()
64        }
65        .padding()
66    }
67}

setting values for start and end radii of Radial Gradient in SwiftUI

changing values for start and end radii of Radial Gradient in SwiftUI

Animate change of center, start and end radii of RadialGradient

This code shows the effect of changine the center point as well as changing the start and end radii.

View

 1struct AnimateCenterRadiiView: View {
 2    @State private var centerPoint = UnitPoint(x: 0.5, y: 0.5)
 3    @State private var startRadius:CGFloat = 0
 4    @State private var endRadius:CGFloat = 100
 5    
 6    let timer = Timer.publish(every: 2,
 7                              on: .main,
 8                              in: .common).autoconnect()
 9    
10    func randomRadii() -> (CGFloat, CGFloat) {
11        let radius1 = CGFloat(Double.random(in: 0...100))
12        let radius2 = CGFloat(Double.random(in: 0...200))
13        
14        return (min(radius1, radius2), max(radius1, radius2))
15    }
16    
17    func randomPoint() -> UnitPoint {
18        return UnitPoint(x: Double.random(in: 0...1),
19                         y: Double.random(in: 0...1))
20    }
21    
22    var body: some View {
23        VStack {
24            Text("Change \nCenter, \nStart & End Radii")
25                .font(.title)
26                .fontWeight(.bold)
27            
28            Rectangle()
29                .fill(
30                    RadialGradient(colors: AppColors.rainbow,
31                                   center: centerPoint,
32                                   startRadius: startRadius,
33                                   endRadius: endRadius)
34                )
35                .animation(Animation.easeInOut.speed(0.2),
36                           value: startRadius)
37                .frame(width: 400, height: 400)
38                .onReceive(timer) { _ in
39                    (startRadius, endRadius) = randomRadii()
40                    centerPoint = randomPoint()
41                }
42            
43            
44            VStack(alignment: .trailing)  {
45                HStack() {
46                    Spacer()
47                    Text("Center: ")
48                        .font(.title2)
49                    Text("(\(centerPoint.x, specifier: "%.2F"), \(centerPoint.y, specifier: "%.2F"))")
50                        .font(.title)
51                        .frame(width: 200)
52                        .animation(Animation.easeInOut.speed(0.6),
53                                   value: centerPoint)
54                }
55                HStack() {
56                    Spacer()
57                    Text("Start Radius: ")
58                        .font(.title2)
59                    Text("\(startRadius, specifier: "%.2F")")
60                        .font(.title)
61                        .frame(width: 200)
62                        .animation(Animation.easeInOut.speed(0.6),
63                                   value: startRadius)
64                }
65                HStack() {
66                    Spacer()
67                    Text("End Radius: ")
68                        .font(.title2)
69                    Text("\(endRadius, specifier: "%.2F")")
70                        .font(.title)
71                        .frame(width: 200)
72                        .animation(Animation.easeInOut.speed(0.6),
73                                   value: endRadius)
74                }
75            }
76            .padding()
77            .fontWeight(.bold)
78            
79            
80            Spacer()
81        }
82        .padding()
83    }
84}

Radial Gradient - animating changine center, start and end radii in SwiftUI

Iterate through colors

I find this view unpleasant to look at, it moves the colors out from the center to the outside by creating a new array of colors with the colors offset by 1.

HypnoticView

 1struct HypnoticView: View {
 2    @State private var colorIndex = 0
 3    @State private var colors = AppColors.rainbow
 4    
 5    let timer = Timer.publish(every: 0.12,
 6                              on: .main,
 7                              in: .common).autoconnect()
 8    func colorList() -> [Color] {
 9        colorIndex += 1
10        return AppColors.rainbow.indices.map  { AppColors.rainbow.wrap(index: (colorIndex - $0)) }
11    }
12    
13    var body: some View {
14        VStack(alignment: .trailing) {
15            
16            Circle()
17                .fill(
18                    RadialGradient(colors: colors,
19                                   center: .center,
20                                   startRadius: 10,
21                                   endRadius: 200)
22                )
23                .animation(Animation.easeInOut.speed(0.12),
24                           value: colorIndex)
25                .frame(width: 400, height: 400)
26                .onReceive(timer) { _ in
27                    colors = colorList()
28                }
29        }
30    }
31}
32
33
34extension Array {
35    func wrap(index: Int) -> Element {
36        let wrappedIndex = index >= 0 ? index % self.count : self.count + index % self.count
37        return self[wrappedIndex]
38    }
39}

Radial Gradient iterating through colors in SwiftUI

Create rainbow with RadialGradient

Finally, RadialGradient can be used to show a rainbow. It requires the array of colors to begin and end with a clear color as well as setting the center point of the RadialGradient outside the frame.

RainbowView

 1struct RainbowView: View {
 2    var body: some View {
 3        VStack(spacing: 100) {
 4            RoundedRectangle(cornerRadius: 20)
 5                .fill(
 6                    RadialGradient(colors: AppColors.rainbowClear.reversed(),
 7                                   center: .bottom,
 8                                   startRadius: 150,
 9                                   endRadius: 200)
10                )
11                .frame(width: 400, height: 200)
12
13
14            RoundedRectangle(cornerRadius: 20)
15                .fill(
16                    RadialGradient(colors: AppColors.rainbowClear.reversed(),
17                                   center: UnitPoint(x: 0.5, y: 1.6),
18                                   startRadius: 150,
19                                   endRadius: 300)
20                )
21                .frame(width: 400, height: 200)
22        }
23    }
24}

Creating a rainbow with Radial Gradient in SwiftUI

Conclusion

RadialGradient is used to transition from one color to another, optionally through a range of colors in a circular pattern radiating outwards from a center point. This article explored the effect of setting different center points as well as specifying a range of start and end radii for the gradients. RadialGradient can be used to create visually compelling effects in SwiftUI views, especially when used in circular shapes or combined with other colors.

The source code for RadialGradientApp is available on GitHub.

AngularGradient in SwiftUI

Eric Callanan — Sunday, 18 Jun 2023

AngularGradient in SwiftUI is used to create a color gradient of two or more colors where the colors radiate around a center point. The AngularGradient object is initialized with an array of colors that are shown in order around a center point. SwiftUI automatically interpolates between the colors as it goes around the circle.

AngularGradient can be adjusted by changing its center and the startAngle and endAngle parameters to create different effects.

Related articles on color gradients in SwiftUI:

LinearGradient in SwiftUI

AngularGradient in SwiftUI

RadialGradient in SwiftUI

Animate background with color gradient in SwiftUI

Simple Angular Gradient

We'll reuse the arrays of colors defined in LinearGradient in SwiftUI. The view shows AngularGradient with two colors and with seven colors, specifying the center point of the gradient as the center of the view. The initial color starts at 3 o clock and moves in clockwise direction to complete 360 degrees.

AppColors

 1struct AppColors {
 2    static let oneColor = [Color(hue: 0.01, saturation: 0.2, brightness: 0.9),
 3                           Color(hue: 0.01, saturation: 1.0, brightness: 0.9)]
 4
 5    static let twoColors = [Color.blue, .yellow]
 6
 7    static let rainbow = [
 8        Color.red,
 9        .orange,
10        .yellow,
11        .green,
12        .blue,
13        Color(hue: 0.773, saturation: 1.0, brightness: 0.51),
14        Color(hue: 0.771, saturation: 1.0, brightness: 1.00)
15    ]
16}

StartAngularGradientView

 1struct StartAngularGradientView: View {
 2    var body: some View {
 3        VStack {
 4            Text("AngularGradient")
 5                .font(.largeTitle)
 6                .fontWeight(.bold)
 7            Divider()
 8            
 9            VStack(spacing: 0) {
10                Text("Two colors")
11                    .font(.title)
12                    .fontWeight(.bold)
13                
14                RoundedRectangle(cornerRadius: 20)
15                    .fill(
16                        AngularGradient(colors: AppColors.twoColors,
17                                        center: .center)
18                    )
19                    .frame(width: 300, height: 300)
20            }
21            Divider()
22
23            VStack(spacing: 0) {
24                Text("Seven colors")
25                    .font(.title)
26                    .fontWeight(.bold)
27                
28                RoundedRectangle(cornerRadius: 20)
29                    .fill(
30                        AngularGradient(colors: AppColors.rainbow,
31                                        center: .center)
32                    )
33                    .frame(width: 300, height: 300)
34            }
35            
36            Spacer()
37        }
38    }
39}

Simple Angular Gradient specifying the colors and the center in SwiftUI

Standard Center Options

An array of colors and a center point are required to initialise an AngularGradient. This code displays how the seven colors are shown using the different standard center point options.

AngularGradientView

 1struct AngularGradientView: View {
 2    var center: UnitPointType
 3
 4    var body: some View {
 5        HStack {
 6            VStack {
 7                Text("\(center.rawValue)").font(.title2)
 8            }
 9            RoundedRectangle(cornerRadius: 20)
10                .fill(
11                    AngularGradient(colors: AppColors.rainbow,
12                                    center: center.unitPoint)
13                )
14                .frame(width: 100, height: 100)
15        }
16    }
17}

CenterOptionsView

 1struct CenterOptionsView: View {
 2    var body: some View {
 3        ScrollView {
 4            VStack {
 5                Text("All Center Options")
 6                    .font(.largeTitle)
 7                    .fontWeight(.bold)
 8                Divider()
 9                
10                VStack(alignment: .trailing) {
11                    ForEach(UnitPointType.allCases, id: \.self) { endinging in
12                        AngularGradientView(center: endinging)
13                    }
14                }
15            }
16        }
17    }
18}

Standard center options for Angular Gradient in SwiftUI

Four Corners

It can be seen in the previous examples that some of the colors are not displayed when a center point is set at one of the edges of the view. This code shows that setting the center as the bottomTrailing the top right corner of the full color gradient is shown - if the center had been chosen. A full 360 degree circle of color gradient is generated around the center point using the specified colors when there is no start or end angle specified - even if some of these colors are not visible in the view because of the position of the center point.

FourCornersView

 1struct FourCornersView: View {
 2    var body: some View {
 3        VStack {
 4            Text("Four Corners")
 5                .font(.largeTitle)
 6                .fontWeight(.bold)
 7            
 8            Rectangle()
 9                .fill(
10                    AngularGradient(colors: AppColors.rainbow,
11                                    center: .center)
12                )
13                .frame(width: 300, height: 300)
14
15            VStack(spacing: 40) {
16                HStack(spacing: 40) {
17                    Rectangle()
18                        .fill(
19                            AngularGradient(colors: AppColors.rainbow,
20                                            center: .bottomTrailing)
21                        )
22                        .frame(width: 150, height: 150)
23                    Rectangle()
24                        .fill(
25                            AngularGradient(colors: AppColors.rainbow,
26                                            center: .bottomLeading)
27                        )
28                        .frame(width: 150, height: 150)
29                }
30                HStack(spacing: 40) {
31                    Rectangle()
32                        .fill(
33                            AngularGradient(colors: AppColors.rainbow,
34                                            center: .topTrailing)
35                        )
36                        .frame(width: 150, height: 150)
37                    Rectangle()
38                        .fill(
39                            AngularGradient(colors: AppColors.rainbow,
40                                            center: .topLeading)
41                        )
42                        .frame(width: 150, height: 150)
43                }
44            }
45            .padding()
46            Spacer()
47        }    
48    }
49}

Selecting a corner as the center on an AngularGradient will exclude some colors from the view

Animate movement of center point

The effect of changing the center point of the AngularGradient is illustrated by animating through the standard UnitPoints. This illustrates how the gradient changes with the setting of the center point.

enum UnitPointType

 1enum UnitPointType: String, CaseIterable {
 2    case topLeading = "topLeading"
 3    case top = "top"
 4    case topTrailing = "topTrailing"
 5    case leading = "leading"
 6    case center = "center"
 7    case trailing = "trailing"
 8    case bottomLeading = "bottomLeading"
 9    case bottom = "bottom"
10    case bottomTrailing = "bottomTrailing"
11
12    var unitPoint: UnitPoint {
13        switch self {
14        case .topLeading:
15            return UnitPoint.topLeading
16        case .top:
17            return UnitPoint.top
18        case .topTrailing:
19            return UnitPoint.topTrailing
20        case .leading:
21            return UnitPoint.leading
22        case .center:
23            return UnitPoint.center
24        case .trailing:
25            return UnitPoint.trailing
26        case .bottomLeading:
27            return UnitPoint.bottomLeading
28        case .bottom:
29            return UnitPoint.bottom
30        case .bottomTrailing:
31            return UnitPoint.bottomTrailing
32        }
33    }
34}

AnimateCenterView

 1struct AnimateCenterView: View {
 2    @State private var centerPointIndex = 4
 3    
 4    let timer = Timer.publish(every: 2,
 5                              on: .main,
 6                              in: .common).autoconnect()
 7    
 8    var body: some View {
 9        VStack {
10            Text("Move center")
11                .font(.largeTitle)
12                .fontWeight(.bold)
13            
14            Rectangle()
15                .fill(
16                    AngularGradient(colors: AppColors.rainbow,
17                                    center: UnitPointType.allCases[centerPointIndex].unitPoint)
18                )
19                .animation(Animation.easeInOut.speed(0.2),
20                           value: centerPointIndex)
21                .frame(width: 400, height: 400)
22                .onReceive(timer) { input in
23                    centerPointIndex = (centerPointIndex + 1) % UnitPointType.allCases.count
24                }
25            
26            
27            VStack(alignment: .leading)  {
28                HStack() {
29                    Text("center: ")
30                    Text(" \(UnitPointType.allCases[centerPointIndex].rawValue)")
31                        .animation(Animation.easeInOut.speed(0.6),
32                               value: centerPointIndex)
33                    Spacer()
34                }
35                .padding()
36                .font(.title)
37                .fontWeight(.bold)
38            }
39            
40            Spacer()
41        }
42        .padding()
43    }
44}

Animate a change in center of AngularGradient shows how the colors change

Setting Start and End angles in AngularGradient

In addition to specifying the center of an AngularGradient, it is also possible to specify the start and end angles where the gradient will begin and end. When the angle difference between the start and end is less than 360 degrees, the missing area is filled in with the colors at the beginning and end. Note that the center does not have to be one of the standard UnitPoints, but can be specified as any (x,y) coordinate values between 0 and 1.

StartEndAngleView

 1struct StartEndAngleView: View {
 2    var body: some View {
 3        VStack(spacing: 30) {
 4            Text("Start and End Angle")
 5                .font(.title)
 6                .fontWeight(.bold)
 7            
 8            VStack(alignment: .trailing) {
 9                HStack {
10                    Spacer()
11                    VStack(alignment: .trailing)  {
12                        Text("Start Angle =   0")
13                        Text("End Angle = 90")
14                    }
15                    RoundedRectangle(cornerRadius: 20)
16                        .fill(
17                            AngularGradient(colors: AppColors.rainbow,
18                                            center: .center,
19                                            startAngle: Angle(degrees: 0),
20                                            endAngle: Angle(degrees: 90))
21                        )
22                        .frame(width: 200, height: 200)
23                }
24            }
25            
26            VStack(alignment: .trailing) {
27                HStack {
28                    Spacer()
29                    VStack(alignment: .trailing)  {
30                        Text("Start Angle = -90")
31                        Text("End Angle =   90")
32                    }
33                    RoundedRectangle(cornerRadius: 20)
34                        .fill(
35                            AngularGradient(colors: AppColors.rainbow,
36                                            center: .center,
37                                            startAngle: Angle(degrees: -90),
38                                            endAngle: Angle(degrees: 90))
39                        )
40                        .frame(width: 200, height: 200)
41                }
42            }
43            
44            VStack(alignment: .trailing) {
45                HStack {
46                    Spacer()
47                    VStack(alignment: .trailing)  {
48                        Text("Center = (0.2, 0.8)")
49                        Text("Start Angle =          -90")
50                        Text("End Angle =            90")
51                    }
52                    RoundedRectangle(cornerRadius: 20)
53                        .fill(
54                            AngularGradient(colors: AppColors.rainbow,
55                                            center: UnitPoint(x: 0.2, y: 0.8),
56                                            startAngle: Angle(degrees: -90),
57                                            endAngle: Angle(degrees: 90))
58                        )
59                        .frame(width: 200, height: 200)
60                }
61            }
62            Spacer()            
63        }
64        .padding()
65    }
66}

Setting Start and End angles in AngularGradient in SwiftUI

Animate Start and End angles in AngularGradient

The effect of changing the startAngle and endAngle of the AngularGradient is illustrated by animating through random values for the angles. This illustrates how the gradient changes with the setting of the angles around a fixed center point.

AnimateAnglesView

 1struct AnimateAnglesView: View {
 2    @State private var startAngle = Angle(degrees: 0)
 3    @State private var endAngle = Angle(degrees: 90)
 4    
 5    let timer = Timer.publish(every: 2,
 6                              on: .main,
 7                              in: .common).autoconnect()
 8    
 9    func randomAngles() -> (Angle, Angle) {
10        let angle1 = Angle(degrees: Double.random(in: 0...360))
11        let angle2 = Angle(degrees: Double.random(in: 0...360))
12        
13        return (min(angle1, angle2), max(angle1, angle2))
14    }
15    
16    var body: some View {
17        VStack {
18            Text("Move Angles")
19                .font(.largeTitle)
20                .fontWeight(.bold)
21            
22            Rectangle()
23                .fill(
24                    AngularGradient(colors: AppColors.rainbow,
25                                    center: .center,
26                                    startAngle: startAngle,
27                                    endAngle: endAngle)
28                )
29                .animation(Animation.easeInOut.speed(0.2),
30                           value: startAngle)
31                .frame(width: 400, height: 400)
32                .onReceive(timer) { _ in
33                    (startAngle, endAngle) = randomAngles()
34                }
35            
36            
37            VStack(alignment: .trailing)  {
38                HStack() {
39                    Spacer()
40                    Text("Start Angle: ")
41                        .font(.title2)
42                    Text("\(startAngle.degrees, specifier: "%.2F")")
43                        .font(.title)
44                        .frame(width: 130)
45                        .animation(Animation.easeInOut.speed(0.6),
46                                   value: startAngle)
47                }
48                HStack() {
49                    Spacer()
50                    Text("End Angle: ")
51                        .font(.title2)
52                    Text("\(endAngle.degrees, specifier: "%.2F")")
53                        .font(.title)
54                        .frame(width: 130)
55                        .animation(Animation.easeInOut.speed(0.6),
56                                   value: endAngle)
57                }
58            }
59            .padding()
60            .fontWeight(.bold)
61            
62            
63            Spacer()
64        }
65        .padding()
66    }
67}

Animate changes in Start and End angles of AngularGradient shows how the colors change

Animate changing of center and angles

This animates changing the center point as well as the start and end angles every 2 seconds - just for fun.

AnimateCenterAnglesView

 1struct AnimateCenterAnglesView: View {
 2    @State private var centerPoint = UnitPoint(x: 0.5, y: 0.5)
 3    @State private var startAngle = Angle(degrees: 0)
 4    @State private var endAngle = Angle(degrees: 90)
 5    
 6    let timer = Timer.publish(every: 2,
 7                              on: .main,
 8                              in: .common).autoconnect()
 9    
10    func randomAngles() -> (Angle, Angle) {
11        let angle1 = Angle(degrees: Double.random(in: 0...360))
12        let angle2 = Angle(degrees: Double.random(in: 0...360))
13        return (min(angle1, angle2), max(angle1, angle2))
14    }
15    
16    func randomPoint() -> UnitPoint {
17        return UnitPoint(x: Double.random(in: 0...1),
18                         y: Double.random(in: 0...1))
19    }
20    
21    var body: some View {
22        VStack {
23            Text("Move Center & Angles")
24                .font(.largeTitle)
25                .fontWeight(.bold)
26            
27            Rectangle()
28                .fill(
29                    AngularGradient(colors: AppColors.rainbow,
30                                    center: centerPoint,
31                                    startAngle: startAngle,
32                                    endAngle: endAngle)
33                )
34                .animation(Animation.easeInOut.speed(0.2),
35                           value: startAngle)
36                .frame(width: 400, height: 400)
37                .onReceive(timer) { _ in
38                    (startAngle, endAngle) = randomAngles()
39                    centerPoint = randomPoint()
40                }
41            
42            
43            VStack(alignment: .trailing)  {
44                HStack() {
45                    Spacer()
46                    Text("Center: ")
47                        .font(.title2)
48                    Text("(\(centerPoint.x, specifier: "%.2F"), \(centerPoint.y, specifier: "%.2F"))")
49                        .font(.title)
50                        .frame(width: 200)
51                        .animation(Animation.easeInOut.speed(0.6),
52                                   value: centerPoint)
53                }
54                HStack() {
55                    Spacer()
56                    Text("Start Angle: ")
57                        .font(.title2)
58                    Text("\(startAngle.degrees, specifier: "%.0F")")
59                        .font(.title)
60                        .frame(width: 200)
61                        .animation(Animation.easeInOut.speed(0.6),
62                                   value: startAngle)
63                }
64                HStack() {
65                    Spacer()
66                    Text("End Angle: ")
67                        .font(.title2)
68                    Text("\(endAngle.degrees, specifier: "%.0F")")
69                        .font(.title)
70                        .frame(width: 200)
71                        .animation(Animation.easeInOut.speed(0.6),
72                                   value: endAngle)
73                }
74            }
75            .padding()
76            .fontWeight(.bold)
77            
78            
79            Spacer()
80        }
81        .padding()
82    }
83}

Animate changes in Center as well as Start and End angles of AngularGradient

AngularGradient on a circular shape

The result of the angular gradient on the square shapes is good to illustrate the result of specifying different center points and angles. Realistically makes more sense on a circular structure, where the area outside the specified angles is trimmed away. Here is a circle where the AngularGradient is used to color the rim of the circle with the specified array of seve colors.

CircleView

 1struct CircleView: View {
 2    @State private var startAngle = Angle(degrees: 0)
 3    @State private var endAngle = Angle(degrees: 90)
 4    
 5    let timer = Timer.publish(every: 2,
 6                              on: .main,
 7                              in: .common).autoconnect()
 8    
 9    func randomAngles() -> (Angle, Angle) {
10        let angle1 = Angle(degrees: Double.random(in: 0...360))
11        let angle2 = Angle(degrees: Double.random(in: 0...360))
12        return (min(angle1, angle2), max(angle1, angle2))
13    }
14    
15    var body: some View {
16        VStack {
17            Text("Circle")
18                .font(.largeTitle)
19                .fontWeight(.bold)
20            Text("Anglular Gradient")
21                .font(.title)
22                .fontWeight(.bold)
23            
24            Spacer()
25                .frame(height: 50)
26            
27            ZStack {
28                Circle()
29                    .strokeBorder(Color(hue: 0, saturation: 0, brightness: 0.85),
30                                  style: StrokeStyle(lineWidth: 60))
31                
32                Circle()
33                    .trim(from: startAngle.degrees/360.0, to: endAngle.degrees/360.0)
34                    .stroke(AngularGradient(colors: AppColors.rainbow,
35                                            center: .center,
36                                            startAngle: startAngle,
37                                            endAngle: endAngle),
38                            style: StrokeStyle(lineWidth: 60,
39                                               lineCap: .round))
40                    .padding(30)
41                    .animation(Animation.easeInOut.speed(0.2),
42                               value: startAngle)
43                    .onReceive(timer) { _ in
44                        (startAngle, endAngle) = randomAngles()
45                    }
46                
47                VStack()  {
48                    HStack() {
49                        Text("Start: ")
50                            .font(.title2)
51                            .frame(width: 60)
52                        Text("\(startAngle.degrees, specifier: "%.0F")")
53                            .font(.title)
54                            .frame(width: 60)
55                            .animation(Animation.easeInOut.speed(0.6),
56                                       value: startAngle)
57                    }
58                    HStack() {
59                        Text("End: ")
60                            .font(.title2)
61                            .frame(width: 60)
62                        Text("\(endAngle.degrees, specifier: "%.0F")")
63                            .font(.title)
64                            .frame(width: 60)
65                            .animation(Animation.easeInOut.speed(0.6),
66                                       value: endAngle)
67                    }
68                }
69                .padding()
70                .fontWeight(.bold)
71            }
72            .frame(width: 380, height: 380)
73            
74            
75            Spacer()
76        }
77        .padding()
78    }
79}

Changes in Start and End angles of AngularGradient on a circle

Animate changes in Start and End angles of AngularGradient on a circle

Conclusion

AngularGradient is used to transition from one color to another, optionally through a range of colors in a radial pattern around a specified center point. This article explored the effect of setting different center points as well as specifying a range of start and end angles for the gradients. AngularGradient can be used to create visually compelling effects in SwiftUI views, especially when used in circular shapes or arcs.

The source code for AngularGradientApp is available on GitHub.

LinearGradient in SwiftUI

Eric Callanan — Sunday, 28 May 2023

LinearGradient in SwiftUI is used to create a gradient color effect of two or more colors. It is used to fill an area or object with a linear color transition from one point to another in a straight line. This article explores the use of LinearGradient and how to use it to improve the color tip on the color pencil.

Related articles on color gradients in SwiftUI:

LinearGradient in SwiftUI

AngularGradient in SwiftUI

RadialGradient in SwiftUI

Animate background with color gradient in SwiftUI

Simple Linear Gradient

Start by defining arrays of colors that can be used in the App to more easily compare different gradients. The view shows LinearGradient from leading to trailing with two colors and with seven colors.

Colors

 1struct AppColors {
 2    static let twoColors = [Color.blue, .yellow]
 3
 4    static let rainbow = [
 5        Color.red,
 6        .orange,
 7        .yellow,
 8        .green,
 9        .blue,
10        Color(hue: 0.773, saturation: 1.0, brightness: 0.51),
11        Color(hue: 0.771, saturation: 1.0, brightness: 1.00)
12    ]
13}

View

 1struct StartLinearGradientView: View {
 2    var body: some View {
 3        VStack {
 4            Text("LinearGradient")
 5                .font(.largeTitle)
 6                .fontWeight(.bold)
 7            Divider()
 8            
 9            VStack(spacing: 0) {
10                Text("Two colors")
11                    .font(.title)
12                    .fontWeight(.bold)
13                
14                RoundedRectangle(cornerRadius: 20)
15                    .fill(
16                        LinearGradient(colors: AppColors.twoColors,
17                                       startPoint: .leading,
18                                       endPoint: .trailing)
19                    )
20                    .frame(width: 300, height: 300)
21            }
22            Divider()
23
24            VStack(spacing: 0) {
25                Text("Seven colors")
26                    .font(.title)
27                    .fontWeight(.bold)
28                
29                RoundedRectangle(cornerRadius: 20)
30                    .fill(
31                        LinearGradient(colors: AppColors.rainbow,
32                                       startPoint: .leading,
33                                       endPoint: .trailing)
34                    )
35                    .frame(width: 300, height: 300)
36            }
37            
38            Spacer()
39        }
40    }
41}

Horizontal LinearGradients with two colors and seven colors

Different Start and End points

Explore how the color gradient changes when we use different start and end points for the LinearGradient. An enum for UnitPointType is defined to make it easier to set the start and end points with text and associated UnitPoint. A subview is created to display the start and endpoints as well as display the color gradient in a rounded rectangle.

enum UnitPointType

 1enum UnitPointType: String, CaseIterable {
 2    case topLeading = "topLeading"
 3    case top = "top"
 4    case topTrailing = "topTrailing"
 5    case leading = "leading"
 6    case center = "center"
 7    case trailing = "trailing"
 8    case bottomLeading = "bottomLeading"
 9    case bottom = "bottom"
10    case bottomTrailing = "bottomTrailing"
11
12    var unitPoint: UnitPoint {
13        switch self {
14        case .topLeading:
15            return UnitPoint.topLeading
16        case .top:
17            return UnitPoint.top
18        case .topTrailing:
19            return UnitPoint.topTrailing
20        case .leading:
21            return UnitPoint.leading
22        case .center:
23            return UnitPoint.center
24        case .trailing:
25            return UnitPoint.trailing
26        case .bottomLeading:
27            return UnitPoint.bottomLeading
28        case .bottom:
29            return UnitPoint.bottom
30        case .bottomTrailing:
31            return UnitPoint.bottomTrailing
32        }
33    }
34}

LinearGradientView

 1struct LinearGradientView: View {
 2    var start: UnitPointType
 3    var end: UnitPointType
 4
 5    var body: some View {
 6        HStack {
 7            VStack {
 8                Text("\(start.rawValue)").font(.title2)
 9                Text("\(end.rawValue)").font(.title2)
10            }
11            RoundedRectangle(cornerRadius: 20)
12                .fill(
13                    LinearGradient(colors: AppColors.rainbow,
14                                   startPoint: start.unitPoint,
15                                   endPoint: end.unitPoint)
16                )
17                .frame(width: 100, height: 100)
18        }
19    }
20}

StartEndLinearView

 1struct StartEndLinearView: View {
 2    var body: some View {
 3        ScrollView {
 4            VStack {
 5                Text("Start & Stop values")
 6                    .font(.largeTitle)
 7                    .fontWeight(.bold)
 8                
 9                VStack(alignment: .trailing) {
10                    LinearGradientView(start: .leading,
11                                       end: .trailing)
12                    LinearGradientView(start: .top,
13                                       end: .bottom)
14                    LinearGradientView(start: .topLeading,
15                                       end: .bottomTrailing)
16                    LinearGradientView(start: .topLeading,
17                                       end: .trailing)
18                    LinearGradientView(start: .topLeading,
19                                       end: .center)
20                    LinearGradientView(start: .topLeading,
21                                       end: .bottom)
22                    LinearGradientView(start: .topLeading,
23                                       end: .leading)
24                    LinearGradientView(start: .top,
25                                       end: .center)
26                }
27                .padding(.horizontal, 50)
28                
29                Spacer()
30            }
31        }
32    }
33}

Effect of setting different start and end points on LinearGradients

All variations of Start and End points

It is possible to iterate over all the start point and end point options and display all the possible linear gradient options in a grid. This view is better displayed on an iPad, but can be scrolled on an iPhone as well. This can be convenient to see all the different combinations of start and end points.

LinearGradientView2

 1struct LinearGradientView2: View {
 2    var start: UnitPointType
 3    var end: UnitPointType
 4    
 5    var body: some View {
 6        RoundedRectangle(cornerRadius: 10)
 7            .fill(
 8                LinearGradient(colors: AppColors.rainbow,
 9                               startPoint: start.unitPoint,
10                               endPoint: end.unitPoint)
11            )
12    }
13}

AllStartEndLinearView

 1struct AllStartEndLinearView: View {
 2    var body: some View {
 3        ScrollView([.vertical, .horizontal]) {
 4            HStack {
 5                VStack{
 6                    Rectangle()
 7                        .fill(.black)
 8                        .frame(width: 150, height: 5)
 9                        .rotationEffect(Angle(degrees: 30))
10                        .overlay(
11                            Text("StartPoint")
12                                .fontWeight(.bold)
13                                .offset(x:40, y: -20)
14                        )
15                        .overlay(
16                            Text("EndPoint")
17                                .fontWeight(.bold)
18                                .offset(x:-40, y: 20)
19                        )
20                    ForEach(UnitPointType.allCases, id: \.self) { endinging in
21                        Text("\(endinging.rawValue)")
22                            .font(.footnote)
23                            .frame(width: 120, height: 90)
24                    }
25                }
26                
27                ForEach(UnitPointType.allCases, id: \.self) { starting in
28                    VStack{
29                        Text("\(starting.rawValue)")
30                            .font(.footnote)
31                            .frame(height: 50)
32                        ForEach(UnitPointType.allCases, id: \.self) { endinging in
33                            LinearGradientView2(start: starting,
34                                                end: endinging)
35                            .frame(width: 90, height: 90)
36                        }
37                    }
38                }                
39            }
40        }
41    }
42}

LinearGradients with all combinations of start and end points

Coordinate Start and End points

All the standard start ans end point combinations are shown above. It is also possible to specify x and y coordinates for the start and end points. These can be any value between 0 and 1. Here are just two examples as the possible combinations are endless. When the y values are the same, the result will be a horizontal gradient regardless of the specific values.

PointCoordinateView

 1struct PointCoordinateView: View {
 2    var body: some View {
 3        VStack(spacing: 30) {
 4            Text("Point Coordinates")
 5                .font(.largeTitle)
 6                .fontWeight(.bold)
 7            Divider()
 8            
 9            VStack(spacing: 0) {
10                Text("Start Point: (0.6, 0.2)  ")
11                    .font(.title)
12                Text("End Point: (0.2, 0.6)  ")
13                    .font(.title)
14
15                RoundedRectangle(cornerRadius: 20)
16                    .fill(
17                        LinearGradient(colors: AppColors.twoColors,
18                                       startPoint: UnitPoint(x: 0.6, y: 0.2),
19                                       endPoint: UnitPoint(x: 0.2, y: 0.6))
20                    )
21                    .frame(width: 200, height: 200)
22            }
23            Divider()
24
25            VStack(spacing: 0) {
26                Text("Start Point: (0.7, 0.5)  ")
27                    .font(.title)
28                Text("End Point: (0.9, 0.5)  ")
29                    .font(.title)
30                RoundedRectangle(cornerRadius: 20)
31                    .fill(
32                        LinearGradient(colors: AppColors.rainbow,
33                                       startPoint: UnitPoint(x: 0.7, y: 0.5),
34                                       endPoint: UnitPoint(x: 0.9, y: 0.5))
35                    )
36                    .frame(width: 200, height: 200)
37            }
38            
39            Spacer()
40        }
41    }
42}

Setting start and end points on LinearGradients using x,y coordinates

Linear gradient on color pencil tip

The start and end point coordinates can be used to create a reflection effect on the color tip of the color pencil defined in Create a color pencil in SwiftUI. The pencil on the left shows the original and the one on the right shows the new version. The view in the middle shows the color gradient across the entire frame with an outline of the pencil tip. The SwiftUI preview updates in real time to show the effect of setting different start and end coordinates in the getTipColorGradient function.

PencilTipGradientView

 1struct PencilTipGradientView: View {
 2    let color = Color.blue
 3    
 4    var body: some View {
 5        VStack {
 6            HStack(spacing: 30) {
 7                ZStack {
 8                    PencilTipShape()
 9                        .fill(getColorGradient(color))
10                    PencilTimberShape()
11                        .fill(Color(hue: 0.07, saturation: 0.4, brightness: 0.9))
12                    PencilBodyShape()
13                        .fill(getColorGradient(color))
14                }
15                .frame(width: 100, height: 600)
16
17                ZStack {
18                    Rectangle()
19                        .fill(getTipColorGradient(color))
20                    PencilTipShape()
21                        .stroke(Color.red, lineWidth: 5)
22                }
23                .frame(width: 100, height: 600)
24                
25                ZStack {
26                    PencilTipShape()
27                        .fill(getTipColorGradient(color))
28                    PencilTimberShape()
29                        .fill(Color(hue: 0.07, saturation: 0.4, brightness: 0.9))
30                    PencilBodyShape()
31                        .fill(getColorGradient(color))
32                }
33                .frame(width: 100, height: 600)
34            }
35        }
36    }
37
38    func getColorGradient(_ col: Color) -> LinearGradient {
39        var hue: CGFloat  = 0.0
40        var saturation: CGFloat = 0.0
41        var brightness: CGFloat = 0.0
42        var alpha: CGFloat = 0.0
43        
44        let uiColor = UIColor(col)
45        uiColor.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
46        
47        return LinearGradient(
48            colors: [
49                Color(hue: hue, saturation: saturation * 1.0, brightness: brightness * 0.4),
50                Color(hue: hue, saturation: saturation * 1.0, brightness: brightness * 0.8),
51                Color(hue: hue, saturation: saturation * 1.0, brightness: brightness * 1.0),
52                Color(hue: hue, saturation: saturation * 0.6, brightness: brightness * 1.0),
53                Color(hue: hue, saturation: saturation * 0.8, brightness: brightness * 0.9)
54            ],
55            startPoint: .leading,
56            endPoint: .trailing)
57    }
58    
59    func getTipColorGradient(_ col: Color) -> LinearGradient {
60        var hue: CGFloat  = 0.0
61        var saturation: CGFloat = 0.0
62        var brightness: CGFloat = 0.0
63        var alpha: CGFloat = 0.0
64        
65        let uiColor = UIColor(col)
66        uiColor.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
67        
68        return LinearGradient(
69            colors: [
70                Color(hue: hue, saturation: saturation * 1.0, brightness: brightness * 0.4),
71                Color(hue: hue, saturation: saturation * 1.0, brightness: brightness * 0.8),
72                Color(hue: hue, saturation: saturation * 1.0, brightness: brightness * 1.0),
73                Color(hue: hue, saturation: saturation * 0.6, brightness: brightness * 1.0),
74                Color(hue: hue, saturation: saturation * 0.8, brightness: brightness * 0.9)
75            ],
76            startPoint: UnitPoint(x: 0.3, y: 0.13),
77            endPoint: UnitPoint(x: 0.7, y: 0.115))
78    }
79}

Determining the best start and end points for a LinearGradient on color pencil tip

New Color Pencil

The final views show the result of using the different LinearGradient on the pencil color tip and the pencil body.

BlueColorPencilView

 1struct BlueColorPencilView: View {
 2    var body: some View {
 3        VStack {
 4            Text("Blue Pencil")
 5                .font(.largeTitle)            
 6            ColorPencilView(color: .blue)
 7                .frame(width: 100, height: 600)
 8        }
 9    }
10}

PencilSetView

 1struct PencilSetView: View {
 2    var body: some View {
 3        VStack {
 4            Text("Color Pencils")
 5                .font(.largeTitle)
 6            HStack {
 7                ForEach(AppColors.rainbow, id: \.self) {
 8                    ColorPencilView(color: $0)
 9                        .frame(width: 50, height: 300)
10                }
11            }
12            Spacer()
13        }
14    }
15}

Blue color pencil with different linear gradients for body and tip in SwiftUI

Color pencil set with different linear gradients for body and tip in SwiftUI

Conclusion

LinearGradient is used to transition from one color to another in an object in SwiftUI. It takes an array of colors and points for the start end of the transition. The color smoothly transitions from the start in a linear manner in the direction of the end along a straight line. There are some standard points set, but any coordinates can be used between 0 and 1.

Using specific coordinates, the color pencil was updated with a color gradient set at an angle across the tip of the pencil.

The source code for LinearGradientApp is available on GitHub.

Create a color pencil in SwiftUI

Eric Callanan — Sunday, 14 May 2023

SwiftUI can be used to simulate real-world objects, such as selecting a color by selecting a specific colored pencil rather than from a colored rectangle. This can provide a more intuitive user experience, especially in a drawing or note-taking app. This article defines a SwiftUI view for a color pencil using the Path and Shape protocols for the components of the pencil.

Initial Pencil

Start with a pencil composed of three shapes for the pencil tip, the pencil timber and the pencil body. Each of these shapes are defined as Path objects to fit inside their containing frame. First define the x,y coordinates of the desired points inside a 1.0 by 1.0 grid. Then simply multiply the containing rect maxX and maxY to get the specific points. The three shapes are combined together in a ZStack to display the pencil.

PencilTipShape

 1struct PencilTipShape: Shape {
 2    func path(in rect: CGRect) -> Path {
 3        let path = Path { path in
 4            path.move(to: CGPoint(x: 0.470 * rect.maxX, y: 0.035 * rect.maxY))
 5            path.addLine(to: CGPoint(x: 0.530 * rect.maxX, y: 0.020 * rect.maxY))
 6            path.addLine(to: CGPoint(x: 0.670 * rect.maxX, y: 0.106 * rect.maxY))
 7            path.addCurve(to: CGPoint(x: 0.330 * rect.maxX, y: 0.106 * rect.maxY),
 8                          control1: CGPoint(x: 0.580 * rect.maxX, y: 0.120 * rect.maxY),
 9                          control2: CGPoint(x: 0.420 * rect.maxX, y: 0.120 * rect.maxY))
10            path.closeSubpath()
11        }
12        return path
13    }
14}

PencilTimberShape

 1struct PencilTimberShape: Shape {
 2    func path(in rect: CGRect) -> Path {
 3        let path = Path { path in
 4            path.move(to: CGPoint(x: 0.330 * rect.maxX, y: 0.106 * rect.maxY))
 5            path.addCurve(to: CGPoint(x: 0.670 * rect.maxX, y: 0.106 * rect.maxY),
 6                          control1: CGPoint(x: 0.420 * rect.maxX, y: 0.120 * rect.maxY),
 7                          control2: CGPoint(x: 0.580 * rect.maxX, y: 0.120 * rect.maxY))
 8            path.addLine(to: CGPoint(x: 0.980 * rect.maxX, y: 0.270 * rect.maxY))
 9            path.addCurve(to: CGPoint(x: 0.020 * rect.maxX, y: 0.270 * rect.maxY),
10                          control1: CGPoint(x: 0.700 * rect.maxX, y: 0.320 * rect.maxY),
11                          control2: CGPoint(x: 0.300 * rect.maxX, y: 0.320 * rect.maxY))
12            path.closeSubpath()
13        }
14        return path
15    }
16}

PencilBodyShape

 1struct PencilBodyShape: Shape {
 2    func path(in rect: CGRect) -> Path {
 3        let path = Path { path in
 4            path.move(to: CGPoint(x: 0.020 * rect.maxX, y: 0.270 * rect.maxY))
 5            path.addCurve(to: CGPoint(x: 0.980 * rect.maxX, y: 0.270 * rect.maxY),
 6                          control1: CGPoint(x: 0.300 * rect.maxX, y: 0.320 * rect.maxY),
 7                          control2: CGPoint(x: 0.700 * rect.maxX, y: 0.320 * rect.maxY))
 8            path.addLine(to: CGPoint(x: 0.980 * rect.maxX, y: 0.900 * rect.maxY))
 9            path.addCurve(to: CGPoint(x: 0.020 * rect.maxX, y: 0.900 * rect.maxY),
10                          control1: CGPoint(x: 0.700 * rect.maxX, y: 0.950 * rect.maxY),
11                          control2: CGPoint(x: 0.300 * rect.maxX, y: 0.950 * rect.maxY))
12            path.closeSubpath()
13        }
14        return path
15    }
16}

GrayPencilView

 1struct GrayPencilView: View {
 2    var body: some View {
 3        VStack {
 4            Text("Gray Pencil")
 5                .font(.largeTitle)
 6            
 7            ZStack {
 8                PencilTipShape()
 9                    .fill(.gray)
10                PencilTimberShape()
11                    .fill(.orange.opacity(0.3))
12                PencilBodyShape()
13                    .fill(.red.opacity(0.9))
14            }
15            .frame(width: 100, height: 400)
16        }
17    }
18}

Pencil defined using three shapes in SwiftUI

Color Pencil

Create a color pencil SwiftUI view that takes a Color as a parameter and is composed of the three pencil component shapes. The color of the tip and the body are set to the specified color. The color of the timber shape is also changed to remove the opacity as this would not have a consistent color depending on the background.

ColorPencilView1

 1struct ColorPencilView1: View {
 2    var color: Color
 3    
 4    var body: some View {
 5        ZStack {
 6            PencilTipShape()
 7                .fill(color)
 8            PencilTimberShape()
 9                .fill(Color(hue: 0.07, saturation: 0.4, brightness: 0.9))
10            PencilBodyShape()
11                .fill(color)
12        }
13    }
14}

BluePencilView

 1struct BluePencilView: View {
 2    var body: some View {
 3        VStack {
 4            Text("Blue Pencil")
 5                .font(.largeTitle)
 6            
 7            ColorPencilView1(color: .blue)
 8                .frame(width: 100, height: 400)
 9        }
10    }
11}

Color pencil view that takes a color and creates the pencil within the frame

Use Linear Gradient

The color pencil is looking better, but it appears a bit flat. The appearance of 3D can be added by using a color gradient with the pencil getting brighter at one point. A linear gradient can be created with variations of the specified color using getHue function of UIColor as described in Convert color from RGB to HSB in Swift. The gradient is created using the same Hue and changing the Saturation and Brightness to give the impression of light being reflected off the round body of the pencil.

ColorPencilView

 1struct ColorPencilView: View {
 2    var color: Color
 3    
 4    func getColorGradient(_ col: Color) -> LinearGradient {
 5        var hue: CGFloat  = 0.0
 6        var saturation: CGFloat = 0.0
 7        var brightness: CGFloat = 0.0
 8        var alpha: CGFloat = 0.0
 9        
10        let uiColor = UIColor(col)
11        uiColor.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
12        
13        return LinearGradient(
14            colors: [
15                Color(hue: hue, saturation: saturation * 1.0, brightness: brightness * 0.4),
16                Color(hue: hue, saturation: saturation * 1.0, brightness: brightness * 0.8),
17                Color(hue: hue, saturation: saturation * 1.0, brightness: brightness * 1.0),
18                Color(hue: hue, saturation: saturation * 0.6, brightness: brightness * 1.0),
19                Color(hue: hue, saturation: saturation * 0.8, brightness: brightness * 0.9)
20            ],
21            startPoint: .leading,
22            endPoint: .trailing)
23    }
24    
25    var body: some View {
26        ZStack {
27            PencilTipShape()
28                .fill(getColorGradient(color))
29            PencilTimberShape()
30                .fill(Color(hue: 0.07, saturation: 0.4, brightness: 0.9))
31            PencilBodyShape()
32                .fill(getColorGradient(color))
33        }
34    }
35}

BlueGradientPencilView

 1struct BlueGradientPencilView: View {
 2    var body: some View {
 3        VStack {
 4            Text("Blue Pencil")
 5                .font(.largeTitle)
 6            Text("Color gradient")
 7                .font(.title)
 8
 9            HStack {
10                ColorPencilView(color: .blue)
11                    .frame(width: 100, height: 400)
12            }
13        }
14    }
15}

Add color gradient to pencil based on specified color using Hue

Rainbow Pencils

Finally we create a set of color pencils for the seven colors of the rainbow.

ColorPencilSetView

 1struct ColorPencilSetView: View {
 2    var body: some View {
 3        VStack {
 4            Text("Rainbow Pencil Set")
 5                .font(.largeTitle)
 6
 7            HStack {
 8                ColorPencilView(color: .red)
 9                ColorPencilView(color: .orange)
10                ColorPencilView(color: .yellow)
11                ColorPencilView(color: .green)
12                ColorPencilView(color: .blue)
13                ColorPencilView(color: Color(hue: 0.773, saturation: 1.0, brightness: 0.51))
14                ColorPencilView(color: Color(hue: 0.771, saturation: 1.0, brightness: 1.00))
15            }
16            .frame(width: 400, height: 300)
17        }
18    }
19}

Create a set of color pencils in SwiftUI

Conclusion

The color pencil is defined as being composed of three shapes for the pencil tip, the pencil timber and the pencil body. A 3D effect is added by getting the hue of the specified color and creating a linear color gradient across the body of the pencil. There are numerous improvements that could be done to the pencil such as making the edges of the timber section more jagged, adding an angled light reflection to the colored tip of the pencil and so on.

The source code for ColorPencilsApp is available on GitHub.

Convert color from RGB to HSB in Swift

Eric Callanan — Sunday, 30 Apr 2023

HSB (Hue, Saturation, and Brightness) represents color in a more human-understandable way, which closely mimics how colors are perceived in real life. Defining color using HSB instead of RGB (Red, Green, and Blue) in App design can result in a more intuitive design with the creation of harmonious color schemes and color gradients. This article shows how to convert color to HSB and RGV values using UIColor.

It is worth noting that HSB is less precise than RGB when it comes to representing the full range of colors available on modern displays. Converting colors from RGB to HSB may result in some loss of precision, however, the benefits of working with HSB in terms of usability and understandability outweigh the drawbacks.

Related articles on HSB:

Define colors with Hue, Saturation and Brightness rather than Red, Green and Blue properties

Color Description

At first glance, the SwiftUI Color description property give the hex color values in the form of #RRGGBBAA representing the Red, Green, Blue and Alpha components of the color. These could be used to identify the RGB values of a color and apply a formula to convert to a corresponding HSB values for the color. The problem with this approach is that description property varies depending on how the color was defined in SwiftUI.

The description of a SwiftUI Color defined with RGB values show the RGBA hex values, whereas one of the named colors in SwiftUI returns the name. The description of a color selected from ColorPicker shows the namespace and the RGB values in decimal format.

DescriptionView

 1struct DescriptionView: View {
 2    @State var selectedColor: Color = .blue
 3    var body: some View {
 4        let color1 = Color(red: 155/255, green: 100/255, blue: 200/255)
 5        let color2 = Color.purple
 6        let color3 = Color(hue: 0.76, saturation: 0.70, brightness: 0.8)
 7
 8        VStack(alignment: .leading) {
 9            Text("Color Description")
10                .font(.largeTitle)
11                .fontWeight(.heavy)
12            Spacer().frame(height: 50)
13            
14            ColorView(title: "RGB: (155, 100, 200)", color: color1)
15            ColorView(title: "Color.purple", color: color2)
16            ColorView(title: "HSB: (0.76, 0.70, 0.80)", color: color3)
17            ColorPicker("Select a Color", selection: $selectedColor)
18                .frame(width: 250, height: 50)
19            ColorView(title: "Selected Color", color: selectedColor)
20
21            Spacer()
22        }
23        .padding(50)
24    }
25}

ColorView

 1struct ColorView: View {
 2    var title: String
 3    var color: Color
 4    
 5    var body: some View {
 6        Text(title)
 7            .font(.title)
 8        HStack {
 9            RoundedRectangle(cornerRadius: 10)
10                .fill(color)
11                .frame(width: 200, height: 50)
12            VStack(alignment: .leading) {
13                Text("description")
14                Text("\(color.description)")
15                    .fontWeight(.bold)
16            }
17        }
18        Divider()
19    }
20}

SwiftUI Color description does not always show hex values for RGB

UIColor - getHue to get Hue, Saturation & Brightness

Conversion of color from any SwiftUI color to HSB values is more easily achieved with the use of UIColor from UIKit. The color is first converted to a UIColor and the getHue(_:saturation:brightness:alpha:) method is used to set in/out properties for the hue, saturation, brightness & alpha components of the color.

ColorHueView

 1struct ColorHueView: View {
 2    var title: String
 3    var color: Color
 4    
 5    func getHsb(_ col: Color) -> (CGFloat, CGFloat, CGFloat, CGFloat) {
 6        var hue: CGFloat  = 0.0
 7        var saturation: CGFloat = 0.0
 8        var brightness: CGFloat = 0.0
 9        var alpha: CGFloat = 0.0
10        
11        let uiColor = UIColor(col)
12        uiColor.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
13        
14        return (hue, saturation, brightness, alpha)
15    }
16    
17    var body: some View {
18        let hsb = getHsb(color)
19        Text(title)
20            .font(.title)
21        HStack {
22            RoundedRectangle(cornerRadius: 10)
23                .fill(color)
24                .frame(width: 200, height: 50)
25            VStack(alignment: .trailing) {
26                Text("Hue: \(hsb.0, specifier: "%.3F")")
27                Text("Saturation: \(hsb.1, specifier: "%.3F")")
28                Text("Brightness: \(hsb.2, specifier: "%.3F")")
29            }
30        }
31        Divider()
32    }
33}

GetHueView

 1struct GetHueView: View {
 2    var body: some View {
 3        let color1 = Color(red: 155/255, green: 100/255, blue: 200/255)
 4        let color2 = Color.purple
 5        let color3 = Color(hue: 0.76, saturation: 0.70, brightness: 0.8)
 6        
 7        VStack(alignment: .leading) {
 8            Text("UIColor - getHue")
 9                .font(.largeTitle)
10                .fontWeight(.heavy)
11            Spacer().frame(height: 50)
12            
13            ColorHueView(title: "RGB: (155, 100, 200)", color: color1)
14            ColorHueView(title: "Color.purple", color: color2)
15            ColorHueView(title: "HSB: (0.76, 0.70, 0.80)", color: color3)
16            
17            Spacer()
18        }
19        .padding(40)
20    }
21}

Use UIColor.getHue to get the Hue, Saturation and Brightness components of any color

UIColor - getRed to get Red, Green & Blue

There is also a method getRed(_:green:blue:alpha:) to get the red, green, blue & alpha components from a UIColor.

ColorRedView

 1struct ColorRedView: View {
 2    var title: String
 3    var color: Color
 4    
 5    func getRgb(_ col: Color) -> (CGFloat, CGFloat, CGFloat, CGFloat) {
 6        var red: CGFloat  = 0.0
 7        var green: CGFloat = 0.0
 8        var blue: CGFloat = 0.0
 9        var alpha: CGFloat = 0.0
10
11        let uiColor = UIColor(col)
12        uiColor.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
13        
14        return (red, green, blue, alpha)
15    }
16    
17    var body: some View {
18        let rgb = getRgb(color)
19        Text(title)
20            .font(.title)
21        HStack {
22            RoundedRectangle(cornerRadius: 10)
23                .fill(color)
24                .frame(width: 200, height: 50)
25            VStack(alignment: .trailing) {
26                Text("Red: \(rgb.0, specifier: "%.3F")")
27                Text("Green: \(rgb.1, specifier: "%.3F")")
28                Text("Blue: \(rgb.2, specifier: "%.3F")")
29            }
30        }
31        Divider()
32    }
33}

GetRedView

 1struct GetRedView: View {
 2    var body: some View {
 3        let color1 = Color(red: 155/255, green: 100/255, blue: 200/255)
 4        let color2 = Color.purple
 5        let color3 = Color(hue: 0.76, saturation: 0.70, brightness: 0.8)
 6
 7        VStack(alignment: .leading) {
 8            Text("UIColor - getRed")
 9                .font(.largeTitle)
10                .fontWeight(.heavy)
11            Spacer().frame(height: 50)
12
13            ColorRedView(title: "RGB: (155, 100, 200)", color: color1)
14            ColorRedView(title: "Color.purple", color: color2)
15            ColorRedView(title: "HSB: (0.76, 0.70, 0.80)", color: color3)
16            
17            Spacer()
18        }
19        .padding(40)
20    }
21}

Use UIColor.getRed to get the Red, Green and Blue components of any color

Color Extension

The methods to get the HSB components from a color could be added as extensions to the Color struct if they were to be used frequently in an App.

Color+Hsb+Rgb

 1extension Color {
 2    func getHsb() -> (CGFloat, CGFloat, CGFloat, CGFloat) {
 3        var hue: CGFloat  = 0.0
 4        var saturation: CGFloat = 0.0
 5        var brightness: CGFloat = 0.0
 6        var alpha: CGFloat = 0.0
 7        
 8        let uiColor = UIColor(self)
 9        uiColor.getHue(&hue, saturation: &saturation, brightness: &brightness, alpha: &alpha)
10        
11        return (hue, saturation, brightness, alpha)
12    }
13    
14    func getRgb() -> (CGFloat, CGFloat, CGFloat, CGFloat) {
15        var red: CGFloat  = 0.0
16        var green: CGFloat = 0.0
17        var blue: CGFloat = 0.0
18        var alpha: CGFloat = 0.0
19
20        let uiColor = UIColor(self)
21        uiColor.getRed(&red, green: &green, blue: &blue, alpha: &alpha)
22        
23        return (red, green, blue, alpha)
24    }
25}

ColorHueView2

 1struct ColorHueView2: View {
 2    var title: String
 3    var color: Color
 4    
 5    var colorHsb: (CGFloat, CGFloat, CGFloat, CGFloat) {
 6        color.getHsb()
 7    }
 8    var body: some View {
 9        Text(title)
10            .font(.title)
11        HStack {
12            RoundedRectangle(cornerRadius: 10)
13                .fill(color)
14                .frame(width: 200, height: 50)
15            VStack(alignment: .trailing) {
16                Text("Hue: \(colorHsb.0, specifier: "%.3F")")
17                Text("Saturation: \(colorHsb.1, specifier: "%.3F")")
18                Text("Brightness: \(colorHsb.2, specifier: "%.3F")")
19            }
20        }
21        Divider()
22    }
23}

HsbExtensionView

 1struct HsbExtensionView: View {
 2    @State var selectedColor: Color = .blue
 3    var body: some View {
 4        VStack(alignment: .center) {
 5            Text("Selecte a Color").font(.title)
 6            ColorPicker("Select a Color", selection: $selectedColor)
 7                .frame(width: 200, height: 50)
 8            Divider()
 9            
10            Text("Color + getHsb()")
11                .font(.largeTitle)
12                .fontWeight(.heavy)
13            Spacer().frame(height: 50)
14            
15            ColorHueView2(title: "\(selectedColor.description)",
16                          color: selectedColor)
17            Spacer()
18        }
19        .padding(40)
20    }
21}

Use getHsb extension on Color to get the Hue, Saturation and Brightness components of any color

Color Saturation and Brightness

One reason to convert a color to HSB values is that it can be more intuitive to get similar colors based on the original Hue or keep the same Hue and alter the Saturation and/or brightness. This view allows the selection of any color and the effect of reducing the Saturation and Brightness relative to the selected color.

SaturationView

 1struct SaturationView: View {
 2    var hue: CGFloat
 3    var saturation: CGFloat
 4    var brightness: CGFloat
 5    var alpha: CGFloat = 0.0
 6    
 7    var body: some View {
 8        HStack(spacing: 5) {
 9            ForEach([1.0, 0.8, 0.6, 0.4, 0.2, 0.1], id: \.self) { factor in
10                let adjustedSaturation = saturation * factor
11                VStack {
12                    RoundedRectangle(cornerRadius: 2)
13                        .fill(Color(hue: hue,
14                                    saturation: adjustedSaturation,
15                                    brightness: brightness,
16                                    opacity: alpha))
17                        .frame(width: 50, height: 80)
18                    
19                    Text("\(adjustedSaturation, specifier: "%.2F")")
20                        .font(.footnote)
21                }
22            }
23        }
24    }
25}

BrightnessView

 1struct BrightnessView: View {
 2    var hue: CGFloat
 3    var saturation: CGFloat
 4    var brightness: CGFloat
 5    var alpha: CGFloat = 0.0
 6    
 7    var body: some View {
 8        HStack(spacing: 5) {
 9            ForEach([1.0, 0.8, 0.6, 0.4, 0.2, 0.1], id: \.self) { factor in
10                let adjustedBrightness = brightness * factor
11                VStack {
12                    RoundedRectangle(cornerRadius: 2)
13                        .fill(Color(hue: hue,
14                                    saturation: saturation,
15                                    brightness: adjustedBrightness,
16                                    opacity: alpha))
17                        .frame(width: 50, height: 80)
18                    
19                    Text("\(adjustedBrightness, specifier: "%.2F")")
20                        .font(.footnote)
21                }
22            }
23        }
24    }
25}

SaturationAndBrightnessView

 1struct SaturationAndBrightnessView: View {
 2    @State var selectedColor: Color = .blue
 3    
 4    var body: some View {
 5        VStack {
 6            Text("Selecte a Color").font(.title)
 7            ColorPicker("", selection: $selectedColor)
 8                .frame(width: 20, height: 50)
 9            
10            let hsb = selectedColor.getHsb()
11            ColorHueView2(title: "Selected HSB", color: selectedColor)
12            Text("Adjusting Saturation").font(.title)
13            SaturationView(hue: hsb.0, saturation: hsb.1, brightness: hsb.2, alpha: hsb.3)
14            Divider()
15            Text("Adjusting Brightness").font(.title)
16            BrightnessView(hue: hsb.0, saturation: hsb.1, brightness: hsb.2, alpha: hsb.3)
17            Spacer()
18        }
19        .padding(40)
20    }
21}

Adjust the Saturation and Brightness of any color

Conclusion

Working with the Hue, Saturation and Brightness of a color can be more intuitive that working with Red, Green & Blue values. Reducing the saturation of color can be used to improve readability such as using a desaturated shade of blue as a background color for a text box can improve the contrast with white or black text.

Modifying Saturation and Brightness can be used to create a minimalist design, with a consistent color scheme throughout the app, resulting in a more cohesive and polished design. Reduced brightness can be used to create a sense of depth or dimension in the UI, such as using a darker shade of a color for the background of a card or button to give the appearance of elevation or depth. Brightness can also be used to indicate that a UI element is active or selected, such as a button might darken when pressed, signifying the active state.

This article showed how to convert any color in SwiftUI to its Hue, Saturation & Brightness component values with the use of UIColor from UIKit.

The source code for ColorConverterApp is available on GitHub.

Create a circular slider in SwiftUI with ChatGPT

Eric Callanan — Sunday, 16 Apr 2023

It may have been too ambitious to ask ChatGPT to create an iOS app. So in this article, I ask ChatGPT to create a circular slider in SwiftUI. It can take a while and the more information provided to ChatGPT the better, but it is possible to get useable code from ChatGPT.

Related articles on ChatGPT and SwiftUI:

Can ChatGPT create an iOS app in SwiftUI - part 1

Can ChatGPT create an iOS app in SwiftUI - part 2

Create a circular slider in SwiftUI with ChatGPT

See related article on how to Create a circular slider in SwiftUI.

Ask ChatGPT to create a Circular Slider - Circular Slider 1

Let's give ChatGPT as much information as we can on what we want for a circular slider. The following prompt is given to ChatGPT to get it to generate the SwiftUI code.

First prompt to create a circular slider

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

First, you'll need to create a custom CircularSlider view that can handle the drawing and interaction. Here's a SwiftUI implementation of the circular slider you described:

 1import SwiftUI
 2
 3struct ContentView: View {
 4    @State private var sliderValue: Double = 0
 5
 6    var body: some View {
 7        VStack {
 8            CircularSlider(value: $sliderValue)
 9            Text("Current Value: \(sliderValue, specifier: "%.2f")")
10                .padding()
11        }
12    }
13}
14
15struct CircularSlider: View {
16    @Binding var value: Double
17    private let lineWidth: CGFloat = 20
18    private let thumbSize: CGFloat = 30
19
20    var body: some View {
21        ZStack {
22            Circle()
23                .stroke(Color.gray, lineWidth: lineWidth)
24            
25            Circle()
26                .trim(from: 0, to: CGFloat(value / 100))
27                .stroke(Color.blue, lineWidth: lineWidth)
28                .rotationEffect(.degrees(-90))
29
30            Circle()
31                .fill(Color.yellow)
32                .frame(width: thumbSize, height: thumbSize)
33                .padding(lineWidth / 2)
34                .rotationEffect(.degrees(-90 + value * 3.6))
35                .gesture(DragGesture(minimumDistance: 0)
36                            .onChanged(updateValue(from:)))
37
38            Text("\(value, specifier: "%.0f")")
39                .font(.largeTitle)
40                .fontWeight(.bold)
41        }
42    }
43
44    private func updateValue(from drag: DragGesture.Value) {
45        let vector = CGVector(dx: drag.location.x - lineWidth - thumbSize / 2, dy: drag.location.y - lineWidth - thumbSize / 2)
46        let angle = atan2(vector.dy, vector.dx) + .pi / 2
47        let fixedAngle = angle < 0 ? angle + 2 * .pi : angle
48        value = Double(fixedAngle / (2 * .pi) * 100)
49    }
50}
51
52struct ContentView_Previews: PreviewProvider {
53    static var previews: some View {
54        ContentView()
55    }
56}

This code defines a CircularSlider struct that takes a binding to a value variable. The slider is drawn using a combination of Circle and Text views, and a DragGesture is used to update the value based on user interaction. The thumb is a yellow circle on the circular slider, and the current slider value is displayed in large text in the center of the slider. The progress is measured in a clockwise direction, starting at 12 o'clock, with the color changing from gray to blue as the slider is completed.

This is not bad, but it doesn't work. There is a gray circle for the slider and the progress value is displayed in the center. There is an additional text field showing the current value below the circular indicator, which is not required. The progress does change and display in blue and the progress value does update in real time. The problem is the drag gesture works somewhere very close to the center of the circular slider and the yellow circle for the thumb is in the center and remains in the center.

First Circular Slider with thumb in the wrong place and the gesture not working - code generated by ChatGPT 4

First Circular Slider with thumb in the wrong place and the gesture not working - code generated by ChatGPT 4

First Circular Slider with thumb in the wrong place and the gesture not working - code generated by ChatGPT 4

Regenerate response - Circular Slider 2

Rather than try and get ChatGPT to fix the issues, let's just select Regenerate response to see what else we might get.

Prompt to ChatGPT

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

To create a circular slider in SwiftUI, you can create a custom view that represents the circular slider and use a drag gesture to update the slider's value. Here's the code for the CircularSlider view:

CircularSlider

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var sliderValue: Double = 0
 5    @State private var dragOffset = CGSize.zero
 6    private let circleWidth: CGFloat = 5
 7    
 8    private var circleProgress: Double {
 9        return sliderValue / 100
10    }
11    
12    private var rotationAngle: Double {
13        return 360 * circleProgress
14    }
15    
16    var body: some View {
17        ZStack {
18            Circle()
19                .stroke(Color.gray, lineWidth: circleWidth)
20            
21            Circle()
22                .trim(from: 0, to: CGFloat(circleProgress))
23                .stroke(Color.blue, lineWidth: circleWidth)
24                .rotation(Angle(degrees: -90))
25            
26            Circle()
27                .fill(Color.yellow)
28                .frame(width: circleWidth * 3, height: circleWidth * 3)
29                .offset(x: -radius, y: 0)
30                .rotationEffect(Angle(degrees: rotationAngle - 90))
31                .gesture(
32                    DragGesture(minimumDistance: 0)
33                        .onChanged(updateSliderValue(from:))
34                )
35            
36            Text("\(Int(sliderValue))")
37                .font(.largeTitle)
38                .fontWeight(.bold)
39        }
40    }
41    
42    private var radius: CGFloat {
43        return circleWidth * 20
44    }
45    
46    private func updateSliderValue(from drag: DragGesture.Value) {
47        let vector = CGVector(dx: drag.location.x - radius, dy: drag.location.y - radius)
48        let angle = atan2(vector.dy, vector.dx)
49        let fixedAngle = angle < 0 ? angle + 2 * CGFloat.pi : angle
50        sliderValue = Double(fixedAngle / (2 * CGFloat.pi)) * 100
51    }
52}

To use the CircularSlider view, include it in your main view:

ContentView

 1import SwiftUI
 2
 3struct ContentView: View {
 4    var body: some View {
 5        CircularSlider()
 6            .frame(width: 200, height: 200)
 7            .padding()
 8    }
 9}
10
11struct ContentView_Previews: PreviewProvider {
12    static var previews: some View {
13        ContentView()
14    }
15}

This code will create a circular slider with the specified colors and interaction. The slider will start at the 12 o'clock position and progress clockwise, with a yellow thumb indicator. The current slider value will be displayed in the center of the circular slider.

This is worse than the first attempt with a compile error in the CircularSlider struct. This is caused by the the use of rotation instead of rotationEffect on a circle.

Compile error in code for Circular Slider 2 - code generated by ChatGPT 4

Let's feedback the compile error to ChatGPT

PROMPT:  
There is a compile error in line ".rotation(Angle(degrees: -90))" - error =
"Value of type 'some View' has no member 'rotation'"

Response from chatGPT

Apologies for the confusion. I made a mistake in the code. The correct function name should be rotationEffect. Here's the corrected code snippet:

CircularSlider and ContentView

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var sliderValue: CGFloat = 0
 5    @State private var angle: Double = 0
 6    
 7    var body: some View {
 8        ZStack {
 9            Circle()
10                .stroke(Color.gray, lineWidth: 20)
11                .frame(width: 200, height: 200)
12            
13            Circle()
14                .trim(from: 0, to: sliderValue / 100)
15                .stroke(Color.blue, lineWidth: 20)
16                .frame(width: 200, height: 200)
17                .rotationEffect(.degrees(-90))
18            
19            Circle()
20                .fill(Color.yellow)
21                .frame(width: 30, height: 30)
22                .offset(y: -100)
23                .rotationEffect(Angle.degrees(Double(sliderValue / 100 * 360 - 90)))
24                .gesture(
25                    DragGesture(minimumDistance: 0)
26                        .onChanged { value in
27                            let vector = CGVector(dx: value.location.x - 100, dy: value.location.y - 100)
28                            let angle = atan2(vector.dy, vector.dx)
29                            let degree = Double(angle) * 180 / .pi
30                            let newValue = (degree + 90) * 100 / 360
31                            sliderValue = CGFloat(max(min(newValue, 100), 0))
32                        }
33                )
34            
35            Text("\(Int(sliderValue))")
36                .font(.system(size: 50, weight: .bold, design: .rounded))
37                .foregroundColor(.blue)
38        }
39    }
40}
41
42struct ContentView: View {
43    var body: some View {
44        CircularSlider()
45            .padding()
46    }
47}
48
49struct ContentView_Previews: PreviewProvider {
50    static var previews: some View {
51        ContentView()
52    }
53}

Now, the code should compile and work as expected.

Circular Slider 2 with wierd behavior on drag gesture - code generated by ChatGPT 4

Regenerate response - Circular Slider 3

We can't just use Regenerate response as this will just rerun the last prompt, which was to address the compile error. In order to regenerate a response on the original request, it is necessary to edit the request and then select Save & Submit. I just added a space at the end as I want to stick with the original request and see the different responses we get.

Prompt to ChatGPT

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

To create a circular slider in SwiftUI, you can create a custom view that combines the drag gesture and drawing the desired shapes. Here's a basic implementation for the slider you described:

CircularSlider and ContentView

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var sliderValue: CGFloat = 0
 5    private let maxValue: CGFloat = 100
 6    
 7    var body: some View {
 8        ZStack {
 9            Circle()
10                .stroke(Color.gray, lineWidth: 20)
11            
12            Circle()
13                .trim(from: 0, to: sliderValue / maxValue)
14                .stroke(Color.blue, lineWidth: 20)
15                .rotationEffect(.degrees(-90))
16            
17            Text("\(Int(sliderValue))")
18                .font(.largeTitle)
19                .fontWeight(.bold)
20            
21            Circle()
22                .fill(Color.yellow)
23                .frame(width: 24, height: 24)
24                .offset(y: -130)
25                .rotationEffect(.degrees(Double(sliderValue / maxValue * 360 - 90)))
26                .gesture(
27                    DragGesture(minimumDistance: 0)
28                        .onChanged { value in
29                            let vector = CGVector(dx: value.location.x - 130, dy: value.location.y - 130)
30                            let angle = atan2(vector.dy, vector.dx)
31                            let normalizedAngle = angle < 0 ? angle + 2 * .pi : angle
32                            sliderValue = max(0, min(maxValue, normalizedAngle * maxValue / (2 * .pi)))
33                        }
34                )
35        }
36        .frame(width: 260, height: 260)
37    }
38}
39
40struct ContentView: View {
41    var body: some View {
42        CircularSlider()
43    }
44}
45
46struct ContentView_Previews: PreviewProvider {
47    static var previews: some View {
48        ContentView()
49    }
50}

This code creates a circular slider with a gray background circle, a blue progress circle, a yellow thumb indicator, and the slider value displayed in the center. The slider interaction is achieved using a drag gesture, and the slider value updates as you move the thumb indicator around the circle.

Circular Slider 3 with wierd behavior on drag gesture - code generated by ChatGPT 4

Regenerate response - Circular Slider 4

Select Regenerate response to see another version.

Prompt to ChatGPT

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

To create a custom SwiftUI circular slider, you can define a custom view CircularSlider that takes care of drawing the background circle, progress circle, and the thumb indicator. To handle the gesture, you'll use the DragGesture SwiftUI gesture.

Here's the code for the custom circular slider:

CircularSlider and ContentView

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var sliderValue: Double = 0
 5    @State private var angle: Angle = .degrees(0)
 6    let circleWidth: CGFloat = 10
 7    let thumbRadius: CGFloat = 15
 8
 9    var body: some View {
10        GeometryReader { geometry in
11            let circleRadius = min(geometry.size.width, geometry.size.height) / 2 - thumbRadius
12            let circleCenter = CGPoint(x: geometry.size.width / 2, y: geometry.size.height / 2)
13
14            ZStack {
15                // Background circle
16                Circle()
17                    .stroke(Color.gray, lineWidth: circleWidth)
18
19                // Progress circle
20                Circle()
21                    .trim(from: 0, to: CGFloat(sliderValue / 100))
22                    .stroke(Color.blue, lineWidth: circleWidth)
23                    .rotation(Angle.degrees(-90))
24
25                // Thumb indicator
26                Circle()
27                    .fill(Color.yellow)
28                    .frame(width: thumbRadius * 2, height: thumbRadius * 2)
29                    .position(x: circleCenter.x + circleRadius * cos(CGFloat(angle.radians - Double.pi / 2)),
30                              y: circleCenter.y + circleRadius * sin(CGFloat(angle.radians - Double.pi / 2)))
31
32                // Current value text
33                Text("\(Int(sliderValue))")
34                    .font(.largeTitle)
35                    .fontWeight(.bold)
36                    .foregroundColor(Color.blue)
37            }
38            .gesture(
39                DragGesture(minimumDistance: 0)
40                    .onChanged { value in
41                        let angleInRadians = atan2(value.location.y - circleCenter.y, value.location.x - circleCenter.x)
42                        angle = Angle(radians: Double(angleInRadians) + Double.pi / 2)
43
44                        let percent = (angle.degrees + 90) / 360
45                        sliderValue = max(min(percent * 100, 100), 0)
46                    }
47            )
48        }
49        .aspectRatio(1, contentMode: .fit)
50    }
51}
52
53struct ContentView: View {
54    var body: some View {
55        CircularSlider()
56            .padding()
57    }
58}
59
60struct ContentView_Previews: PreviewProvider {
61    static var previews: some View {
62        ContentView()
63    }
64}

This is really close. The yellow circle for the thumb indicator tracks the gesture and moves back and forth with the gesture. The issue is the progress of the slider is off by an angle of 90 degrees. The thumb also jumps to any position on the circular slider on the initialization of a drag gesture. It is good to see the progress color on the circular slider updating in real time and the and to see the value in the center updating in synch. It is a bit disconcerting to see the progress is always ahead of the expected progress. In addition, the thumb circle is displayed inside the circular slider rather than on top.

Circular Slider 4 with thumb and progress off by 90 degrees - code generated by ChatGPT 4

Regenerate response - Circular Slider 5

Once again, select Regenerate response to see another version.

Prompt to ChatGPT

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

To create a custom SwiftUI circular slider, you can use a combination of shapes, gestures, and SwiftUI views. Here's a starting point for your circular slider:

CircularSlider and ContentView

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var sliderValue: Double = 0
 5    private let sliderRange = 0.0...100.0
 6
 7    var body: some View {
 8        ZStack {
 9            Circle()
10                .stroke(Color.gray, lineWidth: 20)
11            
12            Circle()
13                .trim(from: 0, to: CGFloat(sliderValue / 100))
14                .stroke(Color.blue, lineWidth: 20)
15                .rotationEffect(.degrees(-90))
16            
17            Circle()
18                .fill(Color.yellow)
19                .frame(width: 30, height: 30)
20                .offset(y: -150)
21                .rotationEffect(.degrees(-90 + sliderValue * 3.6))
22
23            Text("\(Int(sliderValue))")
24                .font(.largeTitle)
25                .fontWeight(.bold)
26        }
27        .frame(width: 300, height: 300)
28        .gesture(
29            DragGesture(minimumDistance: 0)
30                .onChanged { value in
31                    let vector = CGVector(dx: value.location.x - 150, dy: value.location.y - 150)
32                    let angle = atan2(vector.dy, vector.dx) + .pi / 2
33                    let value = angle >= 0 ? angle : angle + 2 * .pi
34                    sliderValue = max(sliderRange.lowerBound, min(sliderRange.upperBound, Double(value) * 100 / (2 * .pi)))
35                }
36        )
37    }
38}
39
40struct ContentView: View {
41    var body: some View {
42        CircularSlider()
43    }
44}
45
46struct ContentView_Previews: PreviewProvider {
47    static var previews: some View {
48        ContentView()
49    }
50}

This code defines a CircularSlider view that has a gray background circle and a blue progress circle, with a yellow draggable thumb indicator. The current value of the slider is displayed in large text in the center. The slider value ranges from 0 to 100, with 0 at the 12 o'clock position and progress going clockwise.

This is also really close, except in this version the progress is matching the touch position in the drag gesture and it is the thumb that is lagging behind by 90 degrees. Circular Slider 5 is arguably better than Circular Slider 4 in a number of ways. For the first time ehe thumb is placed centered over the top of the circular slider. It also feels better to use when the progress matches the touch position. However, the thumb position is off by 90 degrees.

Circular Slider 5 with drag matching progress - code generated by ChatGPT 4

Regenerate response - Circular Slider 6

Once again, select Regenerate response to see another version.

Prompt to ChatGPT

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

To create a circular slider in SwiftUI, you can use the following code snippet. This code demonstrates how to create a custom view that acts as a circular slider with the specified properties. Make sure to import SwiftUI to use this code:

CircularSlider and ContentView

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var currentValue: CGFloat = 0
 5    
 6    var body: some View {
 7        GeometryReader { geometry in
 8            let radius = min(geometry.size.width, geometry.size.height) / 2
 9            
10            ZStack {
11                Circle()
12                    .stroke(Color.gray, lineWidth: 10)
13                
14                Circle()
15                    .trim(from: 0, to: currentValue / 100)
16                    .stroke(Color.blue, lineWidth: 10)
17                    .rotationEffect(.degrees(-90))
18                
19                Circle()
20                    .fill(Color.yellow)
21                    .frame(width: 20, height: 20)
22                    .offset(x: 0, y: -radius + 10)
23                    .rotationEffect(.degrees(Double(currentValue / 100) * 360 - 90))
24                    .gesture(
25                        DragGesture(minimumDistance: 0)
26                            .onChanged { value in
27                                let vector = CGVector(dx: value.location.x - geometry.size.width / 2, dy: value.location.y - geometry.size.height / 2)
28                                let angle = atan2(vector.dy, vector.dx) + .pi / 2
29                                let fixedAngle = angle < 0 ? angle + 2 * .pi : angle
30                                currentValue = min(max(0, fixedAngle / (2 * .pi) * 100), 100)
31                            }
32                    )
33                
34                Text("\(Int(currentValue))")
35                    .font(.system(size: 50))
36                    .fontWeight(.bold)
37                    .foregroundColor(.black)
38            }
39        }
40        .aspectRatio(1, contentMode: .fit)
41    }
42}
43
44struct ContentView: View {
45    var body: some View {
46        CircularSlider()
47            .padding()
48    }
49}
50
51struct ContentView_Previews: PreviewProvider {
52    static var previews: some View {
53        ContentView()
54    }
55}

This code creates a custom CircularSlider view that displays a circular slider with a grey background, blue progress, and a yellow thumb indicator. The slider value is displayed in the center of the circular slider. The slider uses a drag gesture to interact with it, and you can adjust the progress value from 0 to 100 by dragging the thumb indicator.

This is worse than previous versions. This is reassuring in some ways, as I was wondering why ChatGPT was getting better simply by selecting Regenerate response. I would expect that without any feedback, there is no way for ChatGPT to improve.

Circular Slider 6 with drag not working - code generated by ChatGPT 4

Regenerate response - Circular Slider 7

Once again, select Regenerate response to see another version.

Prompt to ChatGPT

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

To create a circular slider in SwiftUI, you'll need to create a custom view that combines a few different elements. Here's an example implementation of the circular slider you described:

CircularSlider with extension on CGPoint

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var sliderValue: Double = 0
 5    @GestureState private var dragOffset: CGFloat = 0
 6    
 7    var body: some View {
 8        GeometryReader { geometry in
 9            let radius = min(geometry.size.width, geometry.size.height) / 2
10            let dragGesture = DragGesture()
11                .updating($dragOffset) { value, state, _ in
12                    state = angleBetweenPoints(radius: radius, center: geometry.frame(in: .local).midPoint, point: value.location)
13                }
14                .onEnded { value in
15                    sliderValue = Double(angleBetweenPoints(radius: radius, center: geometry.frame(in: .local).midPoint, point: value.location)) * 100 / 360
16                }
17            
18            ZStack {
19                // Grey background circle
20                Circle()
21                    .stroke(Color.gray, lineWidth: 20)
22                
23                // Blue progress circle
24                Circle()
25                    .trim(from: 0, to: CGFloat(sliderValue / 100))
26                    .stroke(Color.blue, lineWidth: 20)
27                    .rotationEffect(.degrees(-90))
28                
29                // Yellow thumb indicator
30                Circle()
31                    .fill(Color.yellow)
32                    .frame(width: 20, height: 20)
33                    .offset(x: 0, y: -radius + 10)
34                    .rotationEffect(.degrees(-90 + sliderValue * 360 / 100))
35                
36                // Slider value text
37                Text("\(Int(sliderValue))")
38                    .font(.system(size: 50, design: .rounded))
39            }
40            .gesture(dragGesture)
41        }
42    }
43    
44    private func angleBetweenPoints(radius: CGFloat, center: CGPoint, point: CGPoint) -> CGFloat {
45        let angle = atan2(point.y - center.y, point.x - center.x)
46        let degree = angle >= 0 ? Double(angle) : (2 * Double.pi + Double(angle))
47        return CGFloat(degree * 180 / Double.pi)
48    }
49}
50
51extension CGPoint {
52    var midPoint: CGPoint {
53        return CGPoint(x: x / 2, y: y / 2)
54    }
55}
56
57struct CircularSlider_Previews: PreviewProvider {
58    static var previews: some View {
59        CircularSlider()
60            .frame(width: 300, height: 300)
61    }
62}

This code defines a CircularSlider view that displays a circular slider with a grey background, blue progress circle, yellow thumb indicator, and a centered text showing the current slider value. The slider accepts a drag gesture to interact with it and update its value.

There is a compile error in this code with midPoint being called on CGRect and the property is added as an extension on CGPoint

PROMPT:  
Compile errors - "Value of type 'CGRect' has no member 'midPoint'"

Response from chatGPT

Apologies for the confusion. It seems I made a mistake in the extension for CGPoint. Please use the following code instead:

CircularSlider and ContentView

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var sliderValue: Double = 0
 5    @GestureState private var dragOffset: CGFloat = 0
 6    
 7    var body: some View {
 8        GeometryReader { geometry in
 9            let radius = min(geometry.size.width, geometry.size.height) / 2
10            let dragGesture = DragGesture()
11                .updating($dragOffset) { value, state, _ in
12                    state = angleBetweenPoints(radius: radius, center: geometry.frame(in: .local).center, point: value.location)
13                }
14                .onEnded { value in
15                    sliderValue = Double(angleBetweenPoints(radius: radius, center: geometry.frame(in: .local).center, point: value.location)) * 100 / 360
16                }
17            
18            ZStack {
19                // Grey background circle
20                Circle()
21                    .stroke(Color.gray, lineWidth: 20)
22                
23                // Blue progress circle
24                Circle()
25                    .trim(from: 0, to: CGFloat(sliderValue / 100))
26                    .stroke(Color.blue, lineWidth: 20)
27                    .rotationEffect(.degrees(-90))
28                
29                // Yellow thumb indicator
30                Circle()
31                    .fill(Color.yellow)
32                    .frame(width: 20, height: 20)
33                    .offset(x: 0, y: -radius + 10)
34                    .rotationEffect(.degrees(-90 + sliderValue * 360 / 100))
35                
36                // Slider value text
37                Text("\(Int(sliderValue))")
38                    .font(.system(size: 50, design: .rounded))
39            }
40            .gesture(dragGesture)
41        }
42    }
43    
44    private func angleBetweenPoints(radius: CGFloat, center: CGPoint, point: CGPoint) -> CGFloat {
45        let angle = atan2(point.y - center.y, point.x - center.x)
46        let degree = angle >= 0 ? Double(angle) : (2 * Double.pi + Double(angle))
47        return CGFloat(degree * 180 / Double.pi)
48    }
49}
50
51extension CGRect {
52    var center: CGPoint {
53        return CGPoint(x: midX, y: midY)
54    }
55}
56
57struct CircularSlider_Previews: PreviewProvider {
58    static var previews: some View {
59        CircularSlider()
60            .frame(width: 300, height: 300)
61    }
62}

In this corrected code, I changed the extension from CGPoint to CGRect and replaced the "midPoint" property with "center" property, which calculates the center point of the CGRect correctly.

This code compiles and runs. It looks and behaves worse than it is. The progress is off by 90 degrees from the touch point and the thumb is off by 180 degrees from the touch point. The progress and the thumb are not update until the drag gesture is complete, which gives the impression that it is not working at all. Circular Slider 7 is still worse than Circular Slider 5.

Circular Slider 7 with progress and thumb off and drag not animated - code generated by ChatGPT 4

Regenerate response - Circular Slider 8

Once again, because we had to prompt to correct the compile errror, we need to edit the original prompt and select Save & Submit to regenerate a response to see another version.

Prompt to ChatGPT

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

To create a custom circular slider in SwiftUI, you can create a reusable CircularSlider view. Here's the complete code for the slider:

CircularSlider and ContentView

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @Binding var value: Double
 5    let startAngle: Double = -90
 6    let lineWidth: CGFloat = 10
 7    
 8    var body: some View {
 9        ZStack {
10            Circle()
11                .stroke(Color.gray, style: StrokeStyle(lineWidth: lineWidth))
12            
13            Circle()
14                .trim(from: 0, to: CGFloat(value / 100))
15                .stroke(Color.blue, style: StrokeStyle(lineWidth: lineWidth, lineCap: .round))
16                .rotationEffect(Angle(degrees: startAngle))
17            
18            Circle()
19                .fill(Color.yellow)
20                .frame(width: lineWidth * 2, height: lineWidth * 2)
21                .offset(y: -lineWidth * 5)
22                .rotationEffect(Angle(degrees: startAngle + value * 360 / 100))
23            
24            Text(String(format: "%.0f", value))
25                .font(.system(size: 60))
26                .fontWeight(.bold)
27                .foregroundColor(.black)
28        }
29        .frame(width: lineWidth * 10, height: lineWidth * 10)
30        .gesture(DragGesture(minimumDistance: 0)
31                    .onChanged { gesture in
32                        let angle = calculateAngle(from: gesture.location)
33                        value = Double(angle + 90) / 360 * 100
34                    })
35    }
36    
37    private func calculateAngle(from point: CGPoint) -> Double {
38        let center = CGPoint(x: lineWidth * 5, y: lineWidth * 5)
39        let angle = atan2(point.y - center.y, point.x - center.x) * 180 / .pi
40        return angle < 0 ? angle + 360 : angle
41    }
42}
43
44struct ContentView: View {
45    @State private var sliderValue: Double = 0
46    
47    var body: some View {
48        VStack {
49            CircularSlider(value: $sliderValue)
50        }
51    }
52}
53
54struct ContentView_Previews: PreviewProvider {
55    static var previews: some View {
56        ContentView()
57    }
58}

This code defines a CircularSlider view that takes a binding value as input. The circle has a gray background, and the progress is shown with the color turning blue when complete. The progress is measured in a clockwise direction, with a starting value of 0 at 12 o'clock and progress clockwise to an end value of 100. The thumb indicator is a yellow circle on the circular slider. The current slider value is displayed in large text in the center of the circular slider.

Once again, probably not better than Circular Slider 5, but better than Circular Slider 7. The progress follows the touch point and is animated. The thumb is off by 90 degrees and the progress values seem to go from 25 to 125 rather than 0 to 100. In addition, the size of the circular slider is too small and the progress value is truncated at the larger values.

Circular Slider 8 - drag matches progress, but thumb is off and values incorrect - code generated by ChatGPT 4

Regenerate response - Circular Slider 9

Once again, select Regenerate response to see another version.

Prompt to ChatGPT

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

To create a circular slider in SwiftUI, you can create a custom view that represents the circular slider with the specified requirements. Here's the code:

CircularSlider and ContentView

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var sliderValue: Double = 0
 5    private let maxValue: Double = 100
 6    
 7    var body: some View {
 8        ZStack {
 9            Circle()
10                .stroke(Color.gray, lineWidth: 10)
11                .frame(width: 200, height: 200)
12            
13            Circle()
14                .trim(from: 0, to: CGFloat(sliderValue / maxValue))
15                .stroke(Color.blue, lineWidth: 10)
16                .rotation(Angle(degrees: -90))
17                .frame(width: 200, height: 200)
18            
19            Circle()
20                .fill(Color.yellow)
21                .frame(width: 20, height: 20)
22                .offset(y: -100)
23                .rotationEffect(Angle(degrees: (360 * sliderValue / maxValue) - 90))
24                .gesture(
25                    DragGesture(minimumDistance: 0)
26                        .onChanged({ value in
27                            let angle = atan2(value.location.y - 100, value.location.x - 100) + .pi
28                            sliderValue = max(0, min(maxValue, Double(angle) / (2 * .pi) * maxValue))
29                        })
30                )
31            
32            Text("\(Int(sliderValue))")
33                .font(.largeTitle)
34                .fontWeight(.bold)
35                .foregroundColor(.black)
36        }
37    }
38}
39
40struct ContentView: View {
41    var body: some View {
42        CircularSlider()
43            .padding()
44    }
45}
46
47struct ContentView_Previews: PreviewProvider {
48    static var previews: some View {
49        ContentView()
50    }
51}

This code creates a custom CircularSlider view with the following elements:

A gray background circle.

A blue progress circle.

A yellow thumb indicator that moves along the circular slider as the user interacts with it.

A drag gesture that updates the slider value.

A text view in the center of the circular slider displaying the current slider value.

You can use this custom CircularSlider view in your app by including it in your SwiftUI view hierarchy.

Once again, this has the compile error for use of rotation instead of rotationEffect. Correcting this error gets Circular Slider 9 displaying, but the drag behavior is weird. Circular Slider 9 is not better than Circular Slider 5.

Circular Slider 9 - odd drag behavior with progress animated - code generated by ChatGPT 4

Regenerate response - Circular Slider 10

Once again, select Regenerate response to see another version.

Prompt to ChatGPT

PROMPT:  
Write the swiftui code to create a circular slider. The circle should have a grey
background and progress is shown with the color turning blue when complete. the
progress is measured in a clockwise direction with a starting value of zero at 12
o clock and progress clockwise to an end value of 100. A drag gesture should be
used to interact with the circular slider. The thumb indicator should be a yellow
circle on the circular slider. The current Slider value should be displayed in
large text in the centre of the circular slider

Response from chatGPT

To create a circular slider in SwiftUI, you will need to create a custom component that combines a few built-in SwiftUI views and modifiers. The code below demonstrates how to create a circular slider with the specified requirements:

CircularProgressView and ContentView

 1import SwiftUI
 2
 3struct CircularProgressView: View {
 4    @Binding var progress: Double
 5    let circleWidth: CGFloat = 30
 6    
 7    var body: some View {
 8        ZStack {
 9            Circle()
10                .stroke(lineWidth: circleWidth)
11                .fill(Color.gray)
12            
13            Circle()
14                .trim(from: 0.0, to: CGFloat(min(self.progress, 1.0)))
15                .stroke(lineWidth: circleWidth)
16                .fill(Color.blue)
17                .rotationEffect(Angle(degrees: -90))
18            
19            Text("\(Int(progress * 100))")
20                .font(.system(size: 50))
21                .fontWeight(.bold)
22            
23            Circle()
24                .fill(Color.yellow)
25                .frame(width: circleWidth, height: circleWidth)
26                .offset(y: -100)
27                .rotationEffect(Angle(degrees: 360 * progress - 90))
28        }
29        .gesture(DragGesture(minimumDistance: 0)
30                    .onChanged(updateProgress(from:to:)))
31    }
32    
33    private func updateProgress(from startPoint: DragGesture.Value, to endPoint: DragGesture.Value) {
34        let width = endPoint.location.x - startPoint.location.x
35        let height = endPoint.location.y - startPoint.location.y
36        let distanceFromCenter = sqrt(width * width + height * height)
37        
38        if distanceFromCenter > 25 && distanceFromCenter < 150 {
39            let angle = atan2(height, width)
40            let progress = 1.0 - Double(angle / (2 * CGFloat.pi))
41            self.progress = (progress + 0.25).truncatingRemainder(dividingBy: 1.0)
42        }
43    }
44}
45
46struct ContentView: View {
47    @State private var progress: Double = 0
48    
49    var body: some View {
50        CircularProgressView(progress: $progress)
51            .frame(width: 200, height: 200)
52            .padding()
53    }
54}
55
56struct ContentView_Previews: PreviewProvider {
57    static var previews: some View {
58        ContentView()
59    }
60}

This code defines a custom CircularProgressView that takes a binding to a progress value between 0 and 1. The slider is rendered using two circles, one for the background and one for the progress, along with a text view to display the current progress value. The thumb indicator is created using another circle view that rotates based on the progress value. A drag gesture is added to allow interaction with the slider.

This code has a compile error, so we fee that back to ChatGPT.

Prompt to ChatGPT

PROMPT:  
compile error on line ".onChanged(updateProgress(from:to:)))" - error = "Cannot
convert value of type '(DragGesture.Value, DragGesture.Value) -> ()' to expected
argument type '(DragGesture.Value) -> Void'"

Response from chatGPT

Apologies for the confusion. The error is due to a mistake in the syntax of the DragGesture onChanged closure. Here's the corrected version of the CircularProgressView:

code updates to CircularProgressView

 1    // ...
 2        .gesture(DragGesture(minimumDistance: 0)
 3            .onChanged { value in updateProgress(from: value.startLocation, to: value.location) })    
 4    // ...
 5    
 6    private func updateProgress(from startPoint: CGPoint, to endPoint: CGPoint) {
 7        let width = endPoint.x - startPoint.x
 8        let height = endPoint.y - startPoint.y
 9        let distanceFromCenter = sqrt(width * width + height * height)
10        
11        if distanceFromCenter > 25 && distanceFromCenter < 150 {
12            let angle = atan2(height, width)
13            let progress = 1.0 - Double(angle / (2 * CGFloat.pi))
14            self.progress = (progress + 0.25).truncatingRemainder(dividingBy: 1.0)
15        }
16    }
17
18    // ...

The change is in the .gesture modifier. Instead of using updateProgress(from:to:), we use a closure { value in updateProgress(from: value.startLocation, to: value.location) } to correctly handle the onChanged event. This should resolve the compile error.

This does resolve the compile error and Circular Slider 10 is displayed, however, the drag gesture results in odd behavior off the circular slider and does not appear to be any better than previous versions.

Circular Slider 10 - odd drag behavior with progress animated - code generated by ChatGPT 4

Work with Circular Slider 5

All of the code from ChatGPT is from one chat, so we look to go back to the answer that gave us the code for Circular Slider 5 to see if we can improve this rather than generating new samples. In the chat we can see that the prompt has been adjusted 4 times and each promot has given multiple responses. Navigate to the third prompt (3/4) and the fourth response to this prompt (4/6) to get to the code for Circular Slider 5.

Navigate to a previous prompt and response from ChatGPT 4

Prompt to ChatGPT

PROMPT:  
This is really close. The progress matches the drag gesture, but the thumb is off
by an angle of 90 degrees in an anticlockwise direction. So when the progress is
at 3 o clock the thumb is at 12 o clock. can the code be adjusted so the thumb
tracks with the progress and the drag gesture?

Response from chatGPT

I apologize for the mistake in my previous response. Here is the updated code with the thumb position corrected:

Update to CircularSlider

1// ...
2            Circle()
3                .fill(Color.yellow)
4                .frame(width: 30, height: 30)
5                .offset(y: -150)
6                .rotationEffect(.degrees(sliderValue * 3.6 - 90))
7// ...

The only change is in the rotation effect of the thumb indicator:

1.rotationEffect(.degrees(sliderValue * 3.6 - 90))

Now, the thumb should correctly track with the progress and the drag gesture.

This does not change anything as the change is from (-90 + sliderValue * 3.6) to (sliderValue * 3.6 - 90). The correct change would be to remove the -90 and the thumb would match the sliderValue.

Let's try a Regenerate response to see another response.

Prompt to ChatGPT

PROMPT:  
This is really close. The progress matches the drag gesture, but the thumb is off
by an angle of 90 degrees in an anticlockwise direction. So when the progress is
at 3 o clock the thumb is at 12 o clock. can the code be adjusted so the thumb
tracks with the progress and the drag gesture?

Response from chatGPT

I apologize for the confusion. To fix the issue with the thumb tracking, you can adjust the rotation effect of the thumb indicator circle. Here's the updated code with the correct thumb position:

Update to CircularSlider

1// ...
2            Circle()
3                .fill(Color.yellow)
4                .frame(width: 30, height: 30)
5                .offset(y: -150)
6                .rotationEffect(.degrees(sliderValue * 3.6 - 90))
7// ...

In this updated code, I modified the rotation effect of the thumb indicator circle from .rotationEffect(.degrees(-90 + sliderValue * 3.6)) to .rotationEffect(.degrees(sliderValue * 3.6 - 90)). Now the thumb should track correctly with the progress and the drag gesture.

This is fascinating, wrong, but fascinating. ChatGPT has given the exact same response and even highlighted the change. But the math logic in the change shows that there is no change.

Let's try and be more suggestive in the correction.

Prompt to ChatGPT

PROMPT:  
This change does not fix the issue. perhaps the "- 90" could be removed from the
rotationEffect on the thumb as we want the thumb to track with the progress and
the drag gesture?

Response from chatGPT

You're right, my apologies for the confusion. The rotation effect for the thumb indicator should match the rotation of the progress circle. Here's the corrected code with the appropriate rotation effect:

Update to CircularSlider

1// ...
2            Circle()
3                .fill(Color.yellow)
4                .frame(width: 30, height: 30)
5                .offset(y: -150)
6                .rotationEffect(.degrees(sliderValue * 3.6)) // Corrected rotation effect
7// ...

In this updated code, I modified the rotation effect of the thumb indicator circle from .rotationEffect(.degrees(sliderValue * 3.6 - 90)) to .rotationEffect(.degrees(sliderValue * 3.6)). Now the thumb should correctly track the progress and the drag gesture.

What an inspired answer from ChatGPT! This does fix the issue and the CircularSlider works as expected.

Circular Slider 5b - with drag gesture behavior as expected - code generated by ChatGPT 4

Make the size adjustable

The CircularSlider works, but it has its size fixed within CircularSlider5a to 300 by 300. This is very limiting for a UI control and I just can't leave it.

Let's ask ChatGPT for help.

Prompt to ChatGPT

PROMPT:  
This circular slider works great, but the size is fixed at 300 by 300. could the
CircularSlider be adjusted to work for any size so that it could be used in
different views?

Response from chatGPT

Sure, you can modify the CircularSlider view to accept a custom size parameter and adjust its internal components accordingly. Here's the updated code that allows you to set a custom size for the circular slider:

updates to CircularSlider and ContentView

 1import SwiftUI
 2
 3struct CircularSlider: View {
 4    @State private var sliderValue: Double = 0
 5    private let sliderRange = 0.0...100.0
 6    let size: CGFloat
 7
 8    var body: some View {
 9        ZStack {
10            Circle()
11                .stroke(Color.gray, lineWidth: size * 0.067)
12            
13            Circle()
14                .trim(from: 0, to: CGFloat(sliderValue / 100))
15                .stroke(Color.blue, lineWidth: size * 0.067)
16                .rotationEffect(.degrees(-90))
17            
18            Circle()
19                .fill(Color.yellow)
20                .frame(width: size * 0.1, height: size * 0.1)
21                .offset(y: -size * 0.5)
22                .rotationEffect(.degrees(sliderValue * 3.6))
23
24            Text("\(Int(sliderValue))")
25                .font(.system(size: size * 0.2))
26                .fontWeight(.bold)
27        }
28        .frame(width: size, height: size)
29        .gesture(
30            DragGesture(minimumDistance: 0)
31                .onChanged { value in
32                    let vector = CGVector(dx: value.location.x - size / 2, dy: value.location.y - size / 2)
33                    let angle = atan2(vector.dy, vector.dx) + .pi / 2
34                    let value = angle >= 0 ? angle : angle + 2 * .pi
35                    sliderValue = max(sliderRange.lowerBound, min(sliderRange.upperBound, Double(value) * 100 / (2 * .pi)))
36                }
37        )
38    }
39}
40
41struct ContentView: View {
42    var body: some View {
43        CircularSlider(size: 200) // Set the custom size here
44    }
45}
46
47struct ContentView_Previews: PreviewProvider {
48    static var previews: some View {
49        ContentView()
50    }
51}

In this version, the CircularSlider view has a new size parameter. I've adjusted the lineWidth, frame, offset, and font size of the internal components based on the custom size. You can now use the CircularSlider(size: CGFloat) initializer to create sliders of different sizes. For example, to create a slider with a size of 200, you can call CircularSlider(size: 200).

This is one approach, where the size is passed into the CircularSlider and this allows the use of the CircularSlider in different sizes to match a particular UI layout. A nice touch here is the adjustment of the font size of the progress value displayed in the center of the CircularSlider. This is set as a factor of the size passed into the CircularSlider.

Multiple Circular Sliders of different sizes - code generated by ChatGPT 4

Conclusion

I was looking for ChatGPT to generate SwiftUI code for a circular slider. I asked ChatGPT to regenerate its response 10 times and none of the samples of code just worked as expected. Some samples came very close, so I focussed on one sample (Circular Slider 5) and prompted ChatGPT to address the issue of the thumb not matching the progress. This failed twice until I prompted ChatGPT with the fix, which it agreed with and generated the code.

In a number of samples, the first iteration of code does not compile, but ChatGPT was able to resolve these issues when the details of the compile error are fed back to it. There are lessons to learn from the different samples, such as some of the samples of code generated put the drag gesture on the thumb circle, while the ones with better behavior have the drag gesture on the overall ZStack for the circular slider.

There are still some outstanding issues regarding overall size of the Circular Slider and how it will extend outside of the frame in which it is placed, but this could be addressed in a number of ways.

The final code has the same calculations as in my original article on Create a circular slider in SwiftUI, but arguably the code is neater. Although not commented and may be more difficult to read, debug and maintain.

Overall, ChatGPT cannot just generate code that can be used without question, but it can generate code that can be examined, reviewed and tweaked to work in SwiftUI development.

All this code was generated with ChatGPT version 4 - so it will be interesting to see where this goes in the next version of ChatGPT.

The source code for CircularSliderWithChatGpt4 is available on GitHub.

Can ChatGPT create an iOS app in SwiftUI - part 2

Eric Callanan — Sunday, 02 Apr 2023

The initial Task Manager app created with code from ChatGPT did not quite work correctly. In this article, I work with ChatGPT to resolve the issues and then add the ability to persist the tasks when the app is closed.

It is worth noting that this experiment was started with ChatGPT version 3.5, but by the time part-1 was published, a newer version was released. ChatGPT version 4.0 (GPT-4) was released on March 14th and is publicly available in a limited form to ChatGPT Plus subscribers. I suspect this may be the nature of working with ChatGPT with newer versions coming at an ever increasing rate. I have started playing around with GPT-4, but I'll leave that for another day.

Related articles on ChatGPT and SwiftUI:

Can ChatGPT create an iOS app in SwiftUI - part 1

Can ChatGPT create an iOS app in SwiftUI - part 2

Create a circular slider in SwiftUI with ChatGPT

Issues with editing tasks in the Task Manager App

In part 1 ChatGPT had created the bones of a Task Manager app, albeit with one small defect, in that the app did not save the edits to the tasks. The Edit button appeared to allow the user to edit any and all of the tasks, but when the done button was selected, the edits were not displayed and the tasks seemed to revert to their original content.

Digging into the code that was created shows a couple of errors:

The code in EditableTaskView creates a local copy of the dueDate and does not set the selected value back to the Task dueDate.

Changes made in EditableTaskView for Title and Status are saved to the TaskViewModel but these are not shown in the main list by TaskView.

There is a relatively easy fix for both of these issues using the relatively new element binding syntax introduced in 2021 with Xcode 13.

It is not clear how to get ChatGPT to create this code. Neither is it clear how I could progress with ChatGPT with further enhancements if I manually make these code changes. How should I inform ChatGPT that the code has been modified?

The following are a number of interactions with ChatGPT to try and get the app working. One great advantage with ChatGPT is that you can ask it to Regenerate a response over and over again.

First prompt to fix the problem

done button in ContentView does not display the edits to the tasks

Response from chatGPT

It's likely that the updateTask method in the TaskListViewModel is not properly updating the task with the edited values.

When the user taps the "Done" button in the EditTaskView, the updateTask method is called with the edited Task instance. This method should then find the corresponding task in the tasks array and update its properties with the new values...

The update code suggested by ChatGPT includes use of TaskListViewModel, but there is no TaskListViewModel in the code. The code seems to be referring to a variation of TaskViewModel, but would require further refactoring to get it to work.

Second prompt to fix the problem

EditableTaskView does not save task changes back to the ViewModel when done
button in ContentView is selected

Response from chatGPT

To make the EditableTaskView save task changes back to the ViewModel when the "Done" button in the ContentView is selected, you can add a completion handler to the EditableTaskView and call it when the user taps the "Done" button. Here's an updated version of the EditableTaskView:...

This solution of the code from ChatGPT also refers to taskListViewModel in the ContentView, which does not exist in the App code.

After some debugging into the code, I realise that my previous prompt is incorrect. The edits for title and status are saved to the ViewModel, but these changes are not displayed by the TaskView. I update the prompt to ChatGPT to the following.

Third prompt to fix the problem

EditableTaskView saves the task changes except for the date to the ViewModel when
done button in ContentView is selected. However the changes in the ViewModel are
not shown in the TaskView views

Response from chatGPT

If the changes to the Task instances in the TaskViewModel are not reflected in the TaskView views after editing a task, it's likely because the TaskView views are not observing the changes in the TaskViewModel. Here's how you can fix this issue:

Step 1: Add an id property to the TaskView struct.

TaskView.swift

 1struct TaskView: View {
 2    let task: Task
 3    let id: UUID
 4    
 5    var body: some View {
 6        VStack(alignment: .leading) {
 7            Text(task.title)
 8            if let dueDate = task.dueDate {
 9                Text("Due date: \(dueDate, formatter: ContentView.taskDateFormat)")
10                    .font(.caption)
11            }
12            Text("Status: \(task.status.rawValue)")
13        }
14        .foregroundColor(task.completed ? .gray : .primary)
15        .opacity(task.completed ? 0.5 : 1)
16        .id(id) // Add id
17    }
18}

Step 2: Modify the ForEach loop in the ContentView to pass the id of each task to the TaskView.

ContentView.swift

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    static let taskDateFormat: DateFormatter = {
 5        let formatter = DateFormatter()
 6        formatter.dateStyle = .medium
 7        return formatter
 8    }()
 9    
10    var body: some View {
11        NavigationView {
12            List {
13                ForEach(viewModel.tasks) { task in
14                    if viewModel.isEditing {
15                        EditableTaskView(task: $viewModel.tasks[viewModel.tasks.firstIndex(of: task)!])
16                    } else {
17                        TaskView(task: task, id: task.id) // Pass id to TaskView
18                    }
19                }
20                .onDelete { indexSet in
21                    self.viewModel.tasks.remove(atOffsets: indexSet)
22                }
23            }
24            .navigationTitle("Tasks")
25            .navigationBarItems(
26                trailing: HStack {
27                    if viewModel.isEditing {
28                        Button("Done") {
29                            self.viewModel.isEditing.toggle()
30                        }
31                    } else {
32                        Button(action: {
33                            self.viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: .notStarted))
34                        }) {
35                            Image(systemName: "plus")
36                        }
37                        Button("Edit") {
38                            self.viewModel.isEditing.toggle()
39                        }
40                    }
41                }
42            )
43        }
44    }
45}

Step 3: Make sure that the TaskView is observing the Task instance using the @ObservedObject property wrapper.

TaskView.swift

 1struct TaskView: View {
 2    @ObservedObject var task: Task // Use @ObservedObject property wrapper instead of let
 3    let id: UUID
 4    
 5    var body: some View {
 6        VStack(alignment: .leading) {
 7            Text(task.title)
 8            if let dueDate = task.dueDate {
 9                Text("Due date: \(dueDate, formatter: ContentView.taskDateFormat)")
10                    .font(.caption)
11            }
12            Text("Status: \(task.status.rawValue)")
13        }
14        .foregroundColor(task.completed ? .gray : .primary)
15        .opacity(task.completed ? 0.5 : 1)
16        .id(id)
17    }
18}

With these changes, the TaskView instances will observe changes to their associated Task instances, so any updates made to the Task instances in the TaskViewModel will be reflected in the UI.

Overall, this is not a good idea. There are two versions of TaskView generated and Task was defined as a Struct and not an ObservableObject class. This would require more code changes to get the code to compile and even then, it may still not work. Let's try and regenerate the response to see what other solutions ChatGPT can provide.

This code does not compile.

Compile error with using Task as ObserverObject - code generated by ChatGPT

Same prompt to fix the problem - second response

EditableTaskView saves the task changes except for the date to the ViewModel when
done button in ContentView is selected. However the changes in the ViewModel are
not shown in the TaskView views

Response from chatGPT

If I understand your question correctly, you're saying that the changes made to a Task in the EditableTaskView are not reflected in the TaskView instances that display the same task, even though the changes are correctly saved to the TaskViewModel. If that's the case, here's how you can fix it:

Step 1: Modify the TaskView to use a Binding for the Task instance, instead of a constant value.

TaskView.swift

 1struct TaskView: View {
 2    @Binding var task: Task // change to a binding
 3    
 4    var body: some View {
 5        VStack(alignment: .leading) {
 6            Text(task.title)
 7            if let dueDate = task.dueDate {
 8                Text("Due date: \(dueDate, formatter: ContentView.taskDateFormat)")
 9                    .font(.caption)
10            }
11            Text("Status: \(task.status.rawValue)")
12        }
13        .foregroundColor(task.completed ? .gray : .primary)
14        .opacity(task.completed ? 0.5 : 1)
15    }
16}

Step 2: Update the ForEach loop in ContentView to use a Binding for each Task.

ContentView.swift

 1    . . .
 2
 3    List {
 4        ForEach($viewModel.tasks) { $task in // use a binding
 5            if viewModel.isEditing {
 6                EditableTaskView(task: $task)
 7            } else {
 8                TaskView(task: $task) // use a binding
 9            }
10        }
11        .onDelete { indexSet in
12            self.viewModel.tasks.remove(atOffsets: indexSet)
13        }
14    }
15
16    . . .

Step 3: In EditableTaskView, use the Binding passed in as the task parameter directly when modifying the Task instance.

EditableTaskView.swift

 1struct EditableTaskView: View {
 2    @Binding var task: Task
 3    
 4    var body: some View {
 5        VStack(alignment: .leading) {
 6            TextField("Title", text: $task.title)
 7            if let dueDate = task.dueDate {
 8                DatePicker("Due date", selection: Binding<Date>(
 9                    get: { dueDate },
10                    set: { newValue in self.task.dueDate = newValue } // use the binding directly
11                ), displayedComponents: .date)
12            }
13            Picker("Task Status", selection: $task.status) {
14                ForEach(TaskStatus.allCases, id: \.self) { status in
15                    Text(status.rawValue).tag(status)
16                }
17            }
18            .pickerStyle(SegmentedPickerStyle())
19        }
20        .foregroundColor(task.completed ? .gray : .primary)
21        .opacity(task.completed ? 0.5 : 1)
22    }
23}

With these changes, the TaskView instances will use Bindings to the Task instances in the TaskViewModel, so any changes made to a Task in the EditableTaskView will be reflected in the corresponding TaskView instances.

I have to admit - I was stunned. These are exactly the changes I had made manually to get the app to work.

Edits made to Tasks are shown in task view - code generated by ChatGPT

Persist the Tasks for the app - 1

The tasks can be edited and new tasks can be added, but the app restores to the default three tasks whenever it is restarted. The tasks need to be persisted to make the app useful.

Prompt to persist the task list

Persist the list of tasks when the iOS app is closed using userdefaults

Response from chatGPT

Sure! Here's an example of how you could modify the TaskViewModel to persist the list of tasks in UserDefaults when the app is closed, and to load the saved tasks when the app is launched again.

Step 1: Add a UserDefaults property to TaskViewModel to hold the shared UserDefaults instance.

TaskViewModel.swift

1class TaskViewModel: ObservableObject {
2    private let userDefaults = UserDefaults.standard
3    // ...
4}

Step 2: Modify the init method of TaskViewModel to load the saved tasks from UserDefaults, if available.

TaskViewModel.swift

 1class TaskViewModel: ObservableObject {
 2    // ...
 3    
 4    init() {
 5        if let savedTasksData = userDefaults.data(forKey: "tasks"),
 6           let savedTasks = try? JSONDecoder().decode([Task].self, from: savedTasksData) {
 7            self.tasks = savedTasks
 8        }
 9    }
10    
11    // ...
12}

In this modification, we use the data(forKey:) method of UserDefaults to retrieve the saved data for the "tasks" key, and then use JSONDecoder to decode the data as an array of Task instances. If the decoding succeeds, we set the tasks property to the decoded value.

Step 3: Modify the TaskViewModel method that saves the list of tasks to UserDefaults to be called whenever the list changes, as well as when the app is closed.

TaskViewModel.swift

 1class TaskViewModel: ObservableObject {
 2    // ...
 3    
 4    func saveTasks() {
 5        if let encodedTasks = try? JSONEncoder().encode(tasks) {
 6            userDefaults.set(encodedTasks, forKey: "tasks")
 7        }
 8    }
 9    
10    // ...
11}

In this modification, we encode the current list of tasks using JSONEncoder, and then save the encoded data to UserDefaults using the "tasks" key.

Step 4: Add a ScenePhase property to ContentView to detect when the app is closing, and call the TaskViewModel method that saves the list of tasks.

TasksAppWithChatGptApp.swift

 1@main
 2struct TaskManagerApp: App {
 3    @Environment(\.scenePhase) private var scenePhase
 4    
 5    var body: some Scene {
 6        WindowGroup {
 7            ContentView()
 8                .environmentObject(TaskViewModel())
 9        }
10        .onChange(of: scenePhase) { newScenePhase in
11            if newScenePhase == .inactive || newScenePhase == .background {
12                let taskViewModel = TaskViewModel()
13                taskViewModel.saveTasks()
14            }
15        }
16    }
17}

In this modification, we use the onChange(of:) modifier to detect changes in the ScenePhase environment value, and call the TaskViewModel method that saves the list of tasks when the app is closing (i.e. when scenePhase is set to .inactive or .background).

With these modifications, the list of tasks will be saved to UserDefaults whenever the app is closed, and loaded from UserDefaults when the app is launched again.

This code does not compile with errors on encoding and decoding tasks.

Errors with json encoding/decoding tasks - code generated by ChatGPT

Prompt to fix the encoding errors

Two errorsClass 'JSONDecoder' requires that 'Task' conform to 'Decodable'

Here, I mis-typed the prompt, but ChatGPT gave the correct response anyway.

Response from chatGPT

The error message indicates that the Task struct does not conform to the Decodable protocol, which is required in order to be able to decode it from JSON using JSONDecoder.

To fix this error, you need to make sure that Task conforms to Decodable. Here's an example of how you could modify the Task struct to conform to Decodable:

Task.swift

 1struct Task: Identifiable, Equatable, Codable {
 2    var id = UUID()
 3    var title: String
 4    var dueDate: Date?
 5    var status: TaskStatus
 6    var completed = false
 7    
 8    enum CodingKeys: String, CodingKey {
 9        case id, title, dueDate, status, completed
10    }
11    
12    init(id: UUID = UUID(), title: String, dueDate: Date?, status: TaskStatus, completed: Bool = false) {
13        self.id = id
14        self.title = title
15        self.dueDate = dueDate
16        self.status = status
17        self.completed = completed
18    }
19    
20    init(from decoder: Decoder) throws {
21        let container = try decoder.container(keyedBy: CodingKeys.self)
22        id = try container.decode(UUID.self, forKey: .id)
23        title = try container.decode(String.self, forKey: .title)
24        dueDate = try container.decodeIfPresent(Date.self, forKey: .dueDate)
25        status = try container.decode(TaskStatus.self, forKey: .status)
26        completed = try container.decode(Bool.self, forKey: .completed)
27    }
28    
29    func encode(to encoder: Encoder) throws {
30        var container = encoder.container(keyedBy: CodingKeys.self)
31        try container.encode(id, forKey: .id)
32        try container.encode(title, forKey: .title)
33        try container.encodeIfPresent(dueDate, forKey: .dueDate)
34        try container.encode(status, forKey: .status)
35        try container.encode(completed, forKey: .completed)
36    }
37}

In this modified version of the Task struct, we've added conformance to Codable, which is a protocol that combines Encodable and Decodable conformance. We've also implemented the init(from:) and encode(to:) methods required by Decodable and Encodable, respectively.

With these modifications, you should be able to decode Task instances from JSON using JSONDecoder.

This appears to fix the Codable issues with Tasks, but reveals an initialisation error with TaskViewModel.

TaskViewModel initialisation Errors - code generated by ChatGPT

Prompt to fix the initialisation error

error in TaskViewModel - Return from initializer without initializing all stored
properties

Response from chatGPT

This error message indicates that there is a code path in the init method of TaskViewModel that doesn't initialize all the stored properties of the class.

To fix this error, you need to make sure that all stored properties of TaskViewModel are initialized in the init method. Here's an example of how you could modify the init method to ensure that all stored properties are initialized:

TaskViewModel.swift

 1class TaskViewModel: ObservableObject {
 2    private let userDefaults: UserDefaults
 3    @Published var tasks: [Task]
 4    @Published var isEditing = false
 5    
 6    init() {
 7        self.userDefaults = UserDefaults.standard
 8        self.tasks = []
 9        
10        if let savedTasksData = userDefaults.data(forKey: "tasks"),
11           let savedTasks = try? JSONDecoder().decode([Task].self, from: savedTasksData) {
12            self.tasks = savedTasks
13        }
14    }
15    
16    func saveTasks() {
17        if let encodedTasks = try? JSONEncoder().encode(tasks) {
18            userDefaults.set(encodedTasks, forKey: "tasks")
19        }
20    }
21    
22    // ...
23}

In this modified version of TaskViewModel, we've added explicit initialization for both the userDefaults and tasks properties in the init method. We also removed the @State property wrapper from isEditing, since it's not used in a View.

With these modifications, the init method should initialize all stored properties of TaskViewModel, and the "Return from initializer without initializing all stored properties" error should be resolved.

Compiling the app now reveals 4 errors. Two of these errors are in TaskView_Previews, which ChatGPT does not know about - so I could comment out the preview or just fix them. The errors in Task should have really been addressed when making Task codable. The property for Status is an enum and this should also have been marked as codable.

So I pass this error back to ChatGPT.

Error because TaskStatus enum is not codable - code generated by ChatGPT

Prompt to fix TaskStatus codable error

error in Task - Instance method 'decode(_:forKey:)' requires that 'TaskStatus'
conform to 'Decodable'

Response from chatGPT

The error message indicates that the TaskStatus enum does not conform to the Decodable protocol, which is required in order to be able to decode it from JSON using JSONDecoder.

To fix this error, you need to make sure that TaskStatus conforms to Decodable. Here's an example of how you could modify the TaskStatus enum to conform to Decodable:

Task.swift

1enum TaskStatus: String, Codable {
2    case notStarted = "Not Started"
3    case inProgress = "In Progress"
4    case complete = "Complete"
5}

In this modified version of TaskStatus, we've added conformance to Codable, which is a protocol that combines Encodable and Decodable conformance.

With this modification, you should be able to decode Task instances from JSON using JSONDecoder.

This code is technically wrong as it removes CaseIterable, which is used to iterate through the Status options. So I just add Codable.

1enum TaskStatus: String, CaseIterable, Codable {
2    case notStarted = "Not started"
3    case inProgress = "In progress"
4    case complete = "Complete"
5}

The code now compiles and runs. Tasks can be added and edited.

However, all the tasks disappear when the user switches App and the tasks are not persisted.

All Tasks disappear when switching apps - code generated by ChatGPT

Persist the Tasks for the app - 2

A review of the code shows that there is a new instance of TaskViewModel is created in TaskManagerApp in the onChange(of: scenePhase). A new instance TaskViewModel loads the Tasks fron UserDefaults or uses an empty list. So the list id always empty.

Prompt to address the issue in TaskManagerApp

problem in TaskManagerApp - a new TaskViewModel is created in .onChange(of:
scenePhase)

Response from chatGPT

You are correct. In the onChange(of:scenePhase:) modifier in the TaskManagerApp struct, a new instance of TaskViewModel is created instead of using the existing instance.

To fix this problem, you can modify TaskManagerApp to pass the existing instance of TaskViewModel to the ContentView and use that instance throughout the app. Here's an example of how you can modify TaskManagerApp to achieve this:

View

 1@main
 2struct TaskManagerApp: App {
 3    @Environment(\.scenePhase) private var scenePhase
 4    
 5    let taskViewModel = TaskViewModel()
 6    
 7    var body: some Scene {
 8        WindowGroup {
 9            ContentView()
10                .environmentObject(taskViewModel)
11        }
12        .onChange(of: scenePhase) { newScenePhase in
13            if newScenePhase == .inactive || newScenePhase == .background {
14                taskViewModel.saveTasks()
15            }
16        }
17    }
18}

In this modified version of TaskManagerApp, we create a single instance of TaskViewModel and pass it to ContentView using the environmentObject(_:) method. This ensures that the same instance of TaskViewModel is used throughout the app, including in the onChange(of:scenePhase:) modifier.

With this modification, you should be able to use the existing instance of TaskViewModel to save and load tasks from UserDefaults, without creating a new instance of TaskViewModel each time the app enters the background.

This does not fix the problem as it looks like ContentView is still creating a new instance of TaskViewModel rather than using the environmentObject one. So this is what we feedback to ChatGPT.

All Tasks disappear when switching apps - code generated by ChatGPT

Prompt to fix ContentView to use environmentObject

it looks like ContentView is still creating a new instance of TaskViewModel
rather than using the environmentObject one

Response from chatGPT

You're right. In the ContentView struct, a new instance of TaskViewModel is created using the TaskViewModel() initializer, which creates a new instance of UserDefaults. This will prevent ContentView from accessing the same data as the rest of the app, which is stored in the shared instance of TaskViewModel.

To fix this, you should modify the ContentView struct to use the @EnvironmentObject property wrapper to access the existing instance of TaskViewModel that was passed down from TaskManagerApp. Here's an example of how you can modify the ContentView struct:

ContentView.swift

1struct ContentView: View {
2    @EnvironmentObject var viewModel: TaskViewModel
3    
4    // ...
5}

In this modified version of ContentView, we've added the @EnvironmentObject property wrapper to viewModel, which tells SwiftUI to look up the existing instance of TaskViewModel that was passed down from TaskManagerApp. This ensures that ContentView uses the same instance of TaskViewModel as the rest of the app, rather than creating a new instance with its own UserDefaults.

With this modification, ContentView should be able to access the same data as the rest of the app, and any changes made to the task list should be reflected across all views.

It works. This took a bit of time and a bit of back and forth with ChatGPT that when it finally worked, I had almost forgotten how ugly it is.

Adding and editing tasks in Task Manager App - code generated by ChatGPT

Adding, Editing and persisting tasks work in Task Manager App - code generated by ChatGPT

There is also some rudimentary support for dark mode as well as swipe to delete.

Task Manager App supports light and dark modes - code generated by ChatGPT

Conclusion

As humans, we tend to personify many things and it is very easy to fall into this with ChatGPT. After all, I am asking questions and it is responding and it seems to be building on what has already been discussed in the chat. Although, there are responses that seem to imply it may have forgotten. I think it is better to think of ChatGPT as a type of autocomplete, although a very sophisticated version of autocomplete.

This took a bit more work than I thought, but ChatGPT arguably created the iOS app to manage tasks. I also had to debug and identify the root cause of issues and essentially solve them first and then use this knowledge to try and coax ChatGPT to give me the right solution. There are a number of things I would do differently next time. The first of which is to not use Tasks and instead perhaps call it a TODO list manager. I don’t think I would ever create a Struct or Class named Task because of the use of Tasks in Swift.

ChatGPT is great for a whole load of things, but it might be too early to get rid of all you software engineers just yet 😀. There are increasing quality levels that the code for any application needs to meet and I think ChatGPT is currently struggling with level 1 and 2. It is likely that tools like ChatGPT will get to levels 3 & 4, but I'm not sure on levels 5 & 6 - hang on to your designers 😀. It is also conceivable that in the future some Machine Learning functionality is baked into IDEs like Xcode freeing up the humans to focus on levels 5 and 6 of the applications.

Increasing Quality Levels

Code that is readable and maintainable.

Code that compiles without warnings or errors.

App that provides the required functionality.

Code that is performant.

App that looks good while providing the required functionality.

App that excites and delights the customer.

I think everyone should start using tools like ChatGPT, but don’t rely on it to get everything right or to produce the most performant code and certainly not the best-looking User Interface. Use ChatGPT to generate multiple solutions to a problem then read and study the sample code and learn from it to write your code to solve the problem. Paul Hudson has published a great video on Man VS Machine in Can ChatGPT write better SwiftUI code than you? that is well worth viewing.

To revisit the question - "Can ChatGPT create an iOS app in SwiftUI?".

My answer today is “Not Yet” and it would be interesting to revisit this again in a year.

Here is a list of all the commands in part-1 and part-2

Part 1

Create task management app in SwiftUI using MVVM design for iPhone

add a due date to the task and a task status field

Add unit tests

change task status to be one of "not started" "in progress" or "complete”

modify Task to conform to Equatable

make a task editable

Cannot convert value of type 'Binding<Date?>' to expected argument type 'Binding'

Update unit tests

Add unit tests for Task

test testTaskEquality fails because task1 is not equal to task3

test testTaskEquality still fails because the tasks have different id

Part 2

done button in ContentView does not display the edits to the tasks

EditableTaskView does not save task changes back to the ViewModel when done button in ContentView is selected

EditableTaskView saves the task changes except for the date to the ViewModel when done button in ContentView is selected. However the changes in the ViewModel are not shown in the TaskView views

Regenerate Response

Persist the list of tasks when the iOS app is closed using userdefaults

Two errorsClass 'JSONDecoder' requires that 'Task' conform to 'Decodable’

error in TaskViewModel - Return from initializer without initializing all stored properties

error in Task - Instance method 'decode(_:forKey:)' requires that 'TaskStatus' conform to 'Decodable'

problem in TaskManagerApp - a new TaskViewModel is created in .onChange(of: scenePhase)

it looks like ContentView is still creating a new instance of TaskViewModel rather than using the environmentObject one

The source code for TasksAppWithChatGpt is available on GitHub.

Can ChatGPT create an iOS app in SwiftUI - part 1

Eric Callanan — Sunday, 19 Mar 2023

Artificial Intelligence is trending at the moment with applications like DALL-E and Canva able to create images in certain styles and ChatGPT able to generate text. This article explores if ChatGPT can do more than childrens homework and see can ChatGPT create an iOS task app in SwiftUI. So I asked it to create a task manager app.

The ChatGPT site can get busy and you may frequently get a message that "ChatGPT is at capacity right now".

Related articles on ChatGPT and SwiftUI:

Can ChatGPT create an iOS app in SwiftUI - part 1

Can ChatGPT create an iOS app in SwiftUI - part 2

Create a circular slider in SwiftUI with ChatGPT

Tips on using chatGPT to generate code

Use version control and commit the code when it compiles

Compile the code after every change from chatGPT

Use 'Regenerate response' if not happy with the code generated

Feedback compile errors to chatGPT for a possible solution

Be prepared to roll back to a previous version and edit the request to chatGPT from there and try again

Ask chatGPT to create an app

It is necessary to create an account with ChatGPT and log in to start a conversation. I simply ask chatGPT to create an app in SwiftUI.

First prompt to create the app

Create task management app in SwiftUI using MVVM design for iPhone

Response from chatGPT

Sure, I can guide you on how to create a task management app in SwiftUI using the MVVM design pattern for iPhone. Here are the steps to follow:
Step 1: Create a new SwiftUI project in Xcode.
Step 2: Create a new file for the model, Task.swift.

Model

1struct Task: Identifiable {
2    var id = UUID()
3    var title: String
4    var completed: Bool = false
5}

Step 3: Create a new file for the ViewModel, TaskViewModel.swift.

ViewModel

1class TaskViewModel: ObservableObject {
2    @Published var tasks = [
3        Task(title: "Task 1"),
4        Task(title: "Task 2"),
5        Task(title: "Task 3")
6    ]
7}

Step 4: Create a new file for the View, ContentView.swift.

View

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    var body: some View {
 5        NavigationView {
 6            List(viewModel.tasks) { task in
 7                Text(task.title)
 8            }
 9            .navigationTitle("Tasks")
10        }
11    }
12}

Step 5: Run the app on an iPhone simulator to see the list of tasks.

Step 6: Add a button to mark a task as completed in the ContentView.

View

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    var body: some View {
 5        NavigationView {
 6            List(viewModel.tasks) { task in
 7                Button(action: {
 8                    if let index = self.viewModel.tasks.firstIndex(where: { $0.id == task.id }) {
 9                        self.viewModel.tasks[index].completed.toggle()
10                    }
11                }) {
12                    HStack {
13                        Image(systemName: task.completed ? "checkmark.circle.fill" : "circle")
14                        Text(task.title)
15                    }
16                }
17            }
18            .navigationTitle("Tasks")
19        }
20    }
21}

Step 7: Run the app again to see the checkmarks appearing when tasks are completed.

Step 8: Add a new task button to the ContentView.

View

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    var body: some View {
 5        NavigationView {
 6            List(viewModel.tasks) { task in
 7                Button(action: {
 8                    if let index = self.viewModel.tasks.firstIndex(where: { $0.id == task.id }) {
 9                        self.viewModel.tasks[index].completed.toggle()
10                    }
11                }) {
12                    HStack {
13                        Image(systemName: task.completed ? "checkmark.circle.fill" : "circle")
14                        Text(task.title)
15                    }
16                }
17            }
18            .navigationTitle("Tasks")
19            .navigationBarItems(trailing: Button(action: {
20                self.viewModel.tasks.append(Task(title: "New Task"))
21            }) {
22                Image(systemName: "plus")
23            })
24        }
25    }
26}

Step 9: Run the app again to see the new task button appearing in the navigation bar.

That's it! You have successfully created a task management app in SwiftUI using the MVVM design pattern for iPhone.

Initial task app from SwiftUI code generated by ChatGPT

Initial task app from SwiftUI code generated by ChatGPT

Add more details to a Task

Well, so far so good, but the Task model just has a title. Let's see if we can add more details to the Tasks.

Next prompt to chatGPT

add a due date to the task and a task status field

Response from chatGPT

Sure, here are the steps to add a due date and a task status field to the task management app:

Step 1: Update the Task model in Task.swift to include the due date and the task status fields.

Task.swift

1struct Task: Identifiable {
2    var id = UUID()
3    var title: String
4    var completed: Bool = false
5    var dueDate: Date? // new field for due date
6    var status: String? // new field for task status
7}

Step 2: Update the TaskViewModel class in TaskViewModel.swift to include the due date and the task status fields.

TaskViewModel.swift

1class TaskViewModel: ObservableObject {
2    @Published var tasks = [
3        Task(title: "Task 1", dueDate: Date(), status: "In progress"),
4        Task(title: "Task 2", dueDate: Date().addingTimeInterval(86400), status: "Not started"),
5        Task(title: "Task 3", dueDate: nil, status: "Complete")
6    ]
7}

Step 3: Update the ContentView to display the due date and the task status in the list.

ContentView.swift

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    static let taskDateFormat: DateFormatter = {
 5        let formatter = DateFormatter()
 6        formatter.dateStyle = .medium
 7        return formatter
 8    }()
 9    
10    var body: some View {
11        NavigationView {
12            List(viewModel.tasks) { task in
13                VStack(alignment: .leading) {
14                    Text(task.title)
15                    if let dueDate = task.dueDate {
16                        Text("Due date: \(dueDate, formatter: Self.taskDateFormat)")
17                            .font(.caption)
18                    }
19                    if let status = task.status {
20                        Text("Status: \(status)")
21                            .font(.caption)
22                    }
23                }
24                .foregroundColor(task.completed ? .gray : .primary)
25                .opacity(task.completed ? 0.5 : 1)
26                .onTapGesture {
27                    if let index = self.viewModel.tasks.firstIndex(where: { $0.id == task.id }) {
28                        self.viewModel.tasks[index].completed.toggle()
29                    }
30                }
31            }
32            .navigationTitle("Tasks")
33            .navigationBarItems(trailing: Button(action: {
34                self.viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: "Not started"))
35            }) {
36                Image(systemName: "plus")
37            })
38        }
39    }
40}

Step 4: Run the app on an iPhone simulator to see the due date and the task status appearing in the list.

Step 5: Update the new task button to include the due date and the task status fields.

Step 6: Run the app again to see the new task button creating tasks with the due date and the task status fields.

That's it! You have successfully added a due date and a task status field to the task management app.

Updated tasks to include a due date and a status - code generated by ChatGPT

Updated tasks to include a due date and a status - code generated by ChatGPT

Add unit tests

Now that I have the beginings of an app, I decide to go mad and ask chatGPT to add unit tests.

Next prompt to chatGPT

Add unit tests

Response from chatGPT

Sure, adding unit tests to the task management app is a great way to ensure that the code is working as expected and to catch any issues before they reach production. Here are the steps to add unit tests to the app:

Step 1: Create a new file called TaskViewModelTests.swift in the same directory as TaskViewModel.swift.

Step 2: In TaskViewModelTests.swift, import XCTest and the app's code.

TaskViewModelTests.swift

1import XCTest
2@testable import TaskManager

Step 3: Define a class for the unit tests and a variable for the TaskViewModel.

TaskViewModelTests.swift

1class TaskViewModelTests: XCTestCase {
2    var viewModel: TaskViewModel!
3}

Step 4: Override the setUp() method to create a new instance of TaskViewModel.

TaskViewModelTests.swift

1override func setUp() {
2    viewModel = TaskViewModel()
3}

Step 5: Write a unit test for the add task functionality.

TaskViewModelTests.swift

1func testAddTask() {
2    let initialCount = viewModel.tasks.count
3    viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: "Not started"))
4    let finalCount = viewModel.tasks.count
5    XCTAssertEqual(finalCount, initialCount + 1)
6}

Step 6: Write a unit test for the toggle completed functionality.

TaskViewModelTests.swift

1func testToggleCompleted() {
2    let task = Task(title: "Task", dueDate: Date(), status: "In progress")
3    viewModel.tasks.append(task)
4    viewModel.tasks[0].completed.toggle()
5    XCTAssertTrue(viewModel.tasks[0].completed)
6}

Step 7: Write a unit test for the due date and the task status fields.

TaskViewModelTests.swift

1func testDueDateAndStatus() {
2    let task = Task(title: "Task", dueDate: Date(), status: "In progress")
3    viewModel.tasks.append(task)
4    XCTAssertNotNil(viewModel.tasks[0].dueDate)
5    XCTAssertEqual(viewModel.tasks[0].status, "In progress")
6}

Step 8: Override the tearDown() method to set the TaskViewModel to nil.

TaskViewModelTests.swift

1override func tearDown() {
2    viewModel = nil
3}

Step 9: Run the unit tests and ensure that they all pass.

That's it! You have successfully added unit tests to the task management app. You can continue to add more unit tests as needed to ensure that the code is working as expected.

Added unit tests to Task Manager app - code generated by ChatGPT

Added unit tests to Task Manager app - code generated by ChatGPT

Change Task Status to be ENUM

The Status property in Task was created as an optional string, it would be better if this was an enum.

Next prompt to chatGPT

change task status to be one of "not started" "in progress" or "complete"

Response from chatGPT

Sure, here are the steps to change the task status to be one of "not started", "in progress", or "complete" in the task management app:

Step 1: Update the Task model in Task.swift to use an enumeration for the task status.

Task.swift

 1enum TaskStatus: String, CaseIterable {
 2    case notStarted = "Not started"
 3    case inProgress = "In progress"
 4    case complete = "Complete"
 5}
 6
 7struct Task: Identifiable {
 8    var id = UUID()
 9    var title: String
10    var completed: Bool = false
11    var dueDate: Date?
12    var status: TaskStatus = .notStarted // update status field to use enumeration
13}

Step 2: Update the TaskViewModel class in TaskViewModel.swift to use the TaskStatus enumeration and to initialize the task status field to .notStarted.

TaskViewModel.swift

1class TaskViewModel: ObservableObject {
2    @Published var tasks = [
3        Task(title: "Task 1", dueDate: Date(), status: .inProgress),
4        Task(title: "Task 2", dueDate: Date().addingTimeInterval(86400), status: .notStarted),
5        Task(title: "Task 3", dueDate: nil, status: .complete)
6    ]
7}

Step 3: Update the ContentView to use the TaskStatus enumeration and to update the task status based on user selection.

ContentView.swift

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    static let taskDateFormat: DateFormatter = {
 5        let formatter = DateFormatter()
 6        formatter.dateStyle = .medium
 7        return formatter
 8    }()
 9    
10    var body: some View {
11        NavigationView {
12            List(viewModel.tasks) { task in
13                VStack(alignment: .leading) {
14                    Text(task.title)
15                    if let dueDate = task.dueDate {
16                        Text("Due date: \(dueDate, formatter: Self.taskDateFormat)")
17                            .font(.caption)
18                    }
19                    Text("Status:")
20                    Picker("Task Status", selection: $viewModel.tasks[viewModel.tasks.firstIndex(of: task)!].status) {
21                        ForEach(TaskStatus.allCases, id: \.self) { status in
22                            Text(status.rawValue).tag(status)
23                        }
24                    }
25                    .pickerStyle(SegmentedPickerStyle())
26                }
27                .foregroundColor(task.completed ? .gray : .primary)
28                .opacity(task.completed ? 0.5 : 1)
29                .onTapGesture {
30                    if let index = self.viewModel.tasks.firstIndex(where: { $0.id == task.id }) {
31                        self.viewModel.tasks[index].completed.toggle()
32                    }
33                }
34            }
35            .navigationTitle("Tasks")
36            .navigationBarItems(trailing: Button(action: {
37                self.viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: .notStarted))
38            }) {
39                Image(systemName: "plus")
40            })
41        }
42    }
43}

Step 4: Run the app on an iPhone simulator to see the updated task status options in the list and the ability to update the task status.

Step 5: Update the unit tests to ensure that the new task status enumeration is being used correctly.

That's it! You have successfully changed the task status to be one of "not started", "in progress", or "complete" in the task management app.

Next prompt to chatGPT

modify Task to conform to Equatable

Response from chatGPT

Sure, here's how you can modify the Task struct in Task.swift to conform to the Equatable protocol:

Task.swift

 1struct Task: Identifiable, Equatable {
 2    var id = UUID()
 3    var title: String
 4    var completed: Bool = false
 5    var dueDate: Date?
 6    var status: TaskStatus = .notStarted
 7    
 8    static func == (lhs: Task, rhs: Task) -> Bool {
 9        return lhs.id == rhs.id
10    }
11}

In this modified implementation, we added Equatable protocol conformance to the Task struct by adding the protocol name after Identifiable, separated by a comma. Then we implemented the == operator function, which compares two Task instances for equality based on their id properties.

Added due date and status to tasks - code generated by ChatGPT

Added due date and status to tasks - code generated by ChatGPT

Allow Tasks to be changed

The app can now display a list of tasks with a title, due Date and a status and new tasks can be added to the list. The next step is to make the Tasks editable.

Next prompt to chatGPT

make a task editable

Response from chatGPT

Sure, here's how you can make a task editable in the task management app:

Step 1: Add an isEditing property to the TaskViewModel class in TaskViewModel.swift.

TaskViewModel.swift

1class TaskViewModel: ObservableObject {
2    @Published var tasks = [
3        Task(title: "Task 1", dueDate: Date(), status: .inProgress),
4        Task(title: "Task 2", dueDate: Date().addingTimeInterval(86400), status: .notStarted),
5        Task(title: "Task 3", dueDate: nil, status: .complete)
6    ]
7    @Published var isEditing = false // add isEditing property
8}

Step 2: Add an Edit button to the ContentView that toggles the isEditing property.

ContentView.swift

 1struct ContentView: View {
 2    @ObservedObject var viewModel = TaskViewModel()
 3    
 4    static let taskDateFormat: DateFormatter = {
 5        let formatter = DateFormatter()
 6        formatter.dateStyle = .medium
 7        return formatter
 8    }()
 9    
10    var body: some View {
11        NavigationView {
12            List {
13                ForEach(viewModel.tasks) { task in
14                    if viewModel.isEditing {
15                        EditableTaskView(task: $viewModel.tasks[viewModel.tasks.firstIndex(of: task)!])
16                    } else {
17                        TaskView(task: task)
18                    }
19                }
20                .onDelete { indexSet in
21                    self.viewModel.tasks.remove(atOffsets: indexSet)
22                }
23            }
24            .navigationTitle("Tasks")
25            .navigationBarItems(
26                trailing: HStack {
27                    if viewModel.isEditing {
28                        Button("Done") {
29                            self.viewModel.isEditing.toggle()
30                        }
31                    } else {
32                        Button(action: {
33                            self.viewModel.tasks.append(Task(title: "New Task", dueDate: Date(), status: .notStarted))
34                        }) {
35                            Image(systemName: "plus")
36                        }
37                        Button("Edit") {
38                            self.viewModel.isEditing.toggle()
39                        }
40                    }
41                }
42            )
43        }
44    }
45}

TaskView.swift

 1struct TaskView: View {
 2    let task: Task
 3    
 4    var body: some View {
 5        VStack(alignment: .leading) {
 6            Text(task.title)
 7            if let dueDate = task.dueDate {
 8                Text("Due date: \(dueDate, formatter: ContentView.taskDateFormat)")
 9                    .font(.caption)
10            }
11            Text("Status: \(task.status.rawValue)")
12        }
13        .foregroundColor(task.completed ? .gray : .primary)
14        .opacity(task.completed ? 0.5 : 1)
15    }
16}

EditableTaskView.swift

 1struct EditableTaskView: View {
 2    @Binding var task: Task
 3    
 4    var body: some View {
 5        VStack(alignment: .leading) {
 6            TextField("Title", text: $task.title)
 7            if let dueDate = task.dueDate {
 8                DatePicker("Due date", selection: $task.dueDate, displayedComponents: .date)
 9            }
10            Picker("Task Status", selection: $task.status) {
11                ForEach(TaskStatus.allCases, id: \.self) { status in
12                    Text(status.rawValue).tag(status)
13                }
14            }
15            .pickerStyle(SegmentedPickerStyle())
16        }
17        .foregroundColor(task.completed ? .gray : .primary)
18        .opacity(task.completed ? 0.5 : 1)
19    }
20}

Step 3: Create two new views, TaskView and EditableTaskView, that will display the task information in read-only and editable mode, respectively. In EditableTaskView, use a Binding to allow the task to be edited and modified in place.

Step 4: Update the ContentView to display the EditableTaskView when the isEditing property is true

Error in the EditableTaskView on initial code to make a task editable - code generated by ChatGPT

Error in the EditableTaskView on initial code to make a task editable - code generated by ChatGPT

Fix Data Binding Error in EditableTaskView

The code generated to make the Task editable does not compile. There are a number of options with charGPT, the easiest of which is to just regenerate the code from the previous request. Alternatively, we can prompt chatGPT with the error message to see if it can provide a solution.

Next prompt to chatGPT

Cannot convert value of type 'Binding<Date?>' to expected argument type
'Binding<Date>'

Response from chatGPT

The error message "Cannot convert value of type 'Binding<Date?>' to expected argument type 'Binding'" occurs because a Binding<Date?> cannot be directly assigned to a Binding.

Here's how you can fix the error in the EditableTaskView:

Step 1: Declare a new Date property in EditableTaskView that will be used to store the current value of the due date.

EditableTaskView.swift

1struct EditableTaskView: View {
2    @Binding var task: Task
3    @State private var dueDate: Date? // Add new property
4    
5    var body: some View {
6        // ...
7    }
8}

Step 2: In the initializer of EditableTaskView, assign the value of the task's due date to the dueDate property.

EditableTaskView.swift

 1struct EditableTaskView: View {
 2    @Binding var task: Task
 3    @State private var dueDate: Date?
 4    
 5    init(task: Binding<Task>) {
 6        _task = task
 7        _dueDate = State(initialValue: task.wrappedValue.dueDate) // Assign initial value to dueDate
 8    }
 9    
10    var body: some View {
11        // ...
12    }
13}

Step 3: Use the dueDate property to create a Binding in the DatePicker.

EditableTaskView.swift

 1struct EditableTaskView: View {
 2    @Binding var task: Task
 3    @State private var dueDate: Date?
 4    
 5    init(task: Binding<Task>) {
 6        _task = task
 7        _dueDate = State(initialValue: task.wrappedValue.dueDate)
 8    }
 9    
10    var body: some View {
11        VStack(alignment: .leading) {
12            TextField("Title", text: $task.title)
13            if let dueDate = dueDate {
14                DatePicker("Due date", selection: Binding<Date>(
15                    get: { dueDate },
16                    set: { newValue in self.dueDate = newValue }
17                ), displayedComponents: .date)
18            }
19            Picker("Task Status", selection: $task.status) {
20                ForEach(TaskStatus.allCases, id: \.self) { status in
21                    Text(status.rawValue).tag(status)
22                }
23            }
24            .pickerStyle(SegmentedPickerStyle())
25        }
26        .foregroundColor(task.completed ? .gray : .primary)
27        .opacity(task.completed ? 0.5 : 1)
28    }
29}

With these changes, the dueDate property is used as an intermediary between the Binding<Date?> and the Binding, allowing you to modify the due date value in place.

SwiftUI App with an Editable list of Tasks - code generated by ChatGPT

SwiftUI App with an Editable list of Tasks - code generated by ChatGPT

Task App broke

Now that there have been a number of changes to tasks, I asked chatGPT to update the unit tests.

Update unit tests

I will not detail the back and forth here as there were unit tests added that did not match the app. The resoltion of these compile errors led to modifying the structs and classes such as the addition of a TaskListViewModel and then some confucion on what was in a TaskViewModel and TaskListViewModel. I eventually got the app to compile again, but the ContentView had changed too much and the app had lost some functionality. In addition clicking on a Task seemed to navigate to a subview withthe same list of tasks and son on recursively. I did not spend too much time debugging and instead chose to roll back the code to when it was last working.

Task App broke after resolving errors on unit tests on ViewModel - code generated by ChatGPT

Task App broke after resolving errors on unit tests on ViewModel - code generated by ChatGPT

Add unit tests to Task

It is possible to "Regenerate response" for every response in ChatGPT with an option to toggle between the different responses. It is also possible to go back to a previous request and edit it and then save and submit. This removes the previous response and any subsequent request and responses.

After getting so lost with resolving compile errors with the updated unit tests and the introduction of new ViewModels and ultimately loosing functionality in the app I went back to the request to update the unit tests. This time, I specified to just add unit tests for Task. I also rolled back the code from git. Even adding these unit tests took a couple of attempts.

Next prompt to chatGPT

Add unit tests for Task

Response from chatGPT

Sure! Here's an example of how you could write some unit tests for the Task struct.

TaskTests.swift

 1import XCTest
 2@testable import TaskManager
 3
 4class TaskTests: XCTestCase {
 5    
 6    // Test task creation
 7    func testTaskCreation() {
 8        let title = "Test Task"
 9        let dueDate = Date()
10        let status: TaskStatus = .notStarted
11        
12        let task = Task(title: title, dueDate: dueDate, status: status)
13        
14        XCTAssertEqual(task.title, title)
15        XCTAssertEqual(task.dueDate, dueDate)
16        XCTAssertEqual(task.status, status)
17        XCTAssertFalse(task.completed)
18    }
19    
20    // Test task completion
21    func testTaskCompletion() {
22        var task = Task(title: "Test Task", dueDate: nil, status: .notStarted)
23        
24        XCTAssertFalse(task.completed)
25        
26        task.completed = true
27        
28        XCTAssertTrue(task.completed)
29    }
30    
31    // Test task status updates
32    func testTaskStatusUpdates() {
33        var task = Task(title: "Test Task", dueDate: nil, status: .notStarted)
34        
35        XCTAssertEqual(task.status, .notStarted)
36        
37        task.status = .inProgress
38        
39        XCTAssertEqual(task.status, .inProgress)
40        
41        task.status = .complete
42        
43        XCTAssertEqual(task.status, .complete)
44    }
45    
46    // Test task equality
47    func testTaskEquality() {
48        let task1 = Task(title: "Task 1", dueDate: nil, status: .notStarted)
49        let task2 = Task(title: "Task 2", dueDate: nil, status: .notStarted)
50        let task3 = Task(title: "Task 1", dueDate: nil, status: .notStarted)
51        
52        XCTAssertNotEqual(task1, task2)
53        XCTAssertEqual(task1, task3)
54    }
55}

In this example, we have four test methods that cover some basic functionality of the Task struct:

testTaskCreation: tests that a task is created with the expected properties and that completed is initially set to false.

testTaskCompletion: tests that completed can be set to true and that the value is stored correctly.

testTaskStatusUpdates: tests that the status property can be updated to each of the three possible values (notStarted, inProgress, and complete) and that the value is stored correctly.

testTaskEquality: tests the implementation of Equatable by creating three tasks with different titles but the same values for dueDate, status, and completed. The test asserts that the two tasks with the same title are considered equal, while the one with a different title is not.

Of course, you could write additional tests to cover other scenarios or edge cases, but this should give you a good starting point.

ChatGPT allows you to Regenerate response with a mechanism to toggle between the responses

ChatGPT allows you to Regenerate response with a mechanism to toggle between the responses

Fix Failing unit test

One of the unit tests fails. Let's feed that back to ChatGPT to see what it recommends.

Next prompt to chatGPT

test testTaskEquality fails because task1 is not equal to task3

Response from chatGPT

I apologize for the mistake in my previous response. You are correct that the testTaskEquality test case should fail because the Task instances with different titles should not be considered equal. Here's the corrected test case:

TaskTests.swift

1func testTaskEquality() {
2    let task1 = Task(title: "Task 1", dueDate: nil, status: .notStarted)
3    let task2 = Task(title: "Task 2", dueDate: nil, status: .notStarted)
4    let task3 = Task(title: "Task 1", dueDate: nil, status: .notStarted)
5    
6    XCTAssertNotEqual(task1, task2)
7    XCTAssertNotEqual(task1, task2)
8    XCTAssertEqual(task1, task3)
9}

In this corrected test case, we expect task1 and task3 to be equal because they have the same values for dueDate, status, and completed, even though their title properties are different. The assertion XCTAssertNotEqual(task1, task2) ensures that tasks with different titles are not considered equal, while the assertion XCTAssertEqual(task1, task3) ensures that tasks with the same values for the other properties are considered equal, regardless of their titles.

Unit Test is still failing.

Next prompt to chatGPT

test testTaskEquality still fails because the tasks have different id

Response from chatGPT

I apologize again for the mistake in my previous response. You are correct that the Task instances in the test cases have different id properties, which will cause the equality check to fail even if all other properties are equal.

To fix the testTaskEquality test case, you can create the Task instances with explicit id values that are the same for the two tasks with the same title:

TaskTests.swift

 1func testTaskEquality() {
 2    let id1 = UUID()
 3    let id2 = UUID()
 4    
 5    let task1 = Task(id: id1, title: "Task 1", dueDate: nil, status: .notStarted)
 6    let task2 = Task(id: id2, title: "Task 2", dueDate: nil, status: .notStarted)
 7    let task3 = Task(id: id1, title: "Task 1", dueDate: nil, status: .notStarted)
 8    
 9    XCTAssertNotEqual(task1, task2)
10    XCTAssertNotEqual(task2, task3)
11    XCTAssertEqual(task1, task3)
12}

In this version of the test case, we create two UUIDs (id1 and id2) and use id1 for both task1 and task3, so they will have the same id value. We also modify the assertions to use XCTAssertNotEqual for both task1 and task2 and XCTAssertEqual for task1 and task3, to ensure that tasks are only considered equal if they have the same id and all other properties are equal.

Unit tests on Task struct passing - code generated by ChatGPT

Unit tests on Task struct passing - code generated by ChatGPT

Editing tasks does not work

The App is now stable and it displays a list of tasks. Functionality like swipe to delete works as well as adding new tasks. However, editing the tasks appears to work until the done button is selected. Selecting edit again does show the previous edits, but these are not persisted back to the model.

I'll continue this in the next article.

Edits to the Tasks are not shown in the task list - code generated by ChatGPT

Edits to the Tasks are not shown in the task list - code generated by ChatGPT

Conclusion

I was pleasantly surprised by how much code chatGPT can generate. ChatGPT or other artificial intelligence tools are not likely to replace developers in the near future. However, I think a lot of work can be done by combining the artificial intelligence in a tool like chatGPT with the human ability to problem solve and design.

I think everyone should have a go at generating something with chatGPT. Perhaps this is the next version of auto complete, but it seems so much more as it is generating text or code and can be used to help solve technical problems

It is likely that we will get to the stage where there are those who use and work with Artificial Intelligence and those who don't and the advantage will be with those who embrace its use and learn to work with it. Of course, there are still a number of open questions with regard to copyright infringements and the law has not yet caught up all the technology we use. Is using code from chatGPT any different than searching for code on the Internet or GitHub and using that to help develop an application?

Working with chatGPT is very exciting and frightening at the same time. It has certainly given me pause to writing technical articles on solving issues that chatGPT could just spit out the answer for you whenever you need it. Although, the answers at the moment are not always right.

To answer the question "Can ChatGPT create an iOS app in SwiftUI?"

Yes and No

Yes chatGPT can generate code to create an App.
No because the user experience of using the App will not be good and the code may not work.

I would say currently that using chatGPT to help you write an app takes more time that writing the code yourself. As other people have stated chatGPT will give an answer with confidence, even when that answer is incorrect.

I am curious to continue working with chatGPT to further develop this TaskManager app. First to see how chatGPT suggests resolving the editing issue and then to persist the task data when the app is closed.

Source code for TasksAppWithChatGpt is available on GitHub.

How to cancel a background task in Swift

Eric Callanan — Sunday, 29 Jan 2023

The async/await syntax, introduced in Swift 5.5, allows a readable way to write asynchronous code. Asynchronous programming can improve performance of an app, but it is important to cancel unneeded tasks to ensure unwanted background tasks do not interfere with the app. This article demonstrates how to cancel a task explicitly and shows how the child tasks are automatically cancelled.

The code builds on the AsyncLetApp initiated in Use async let to run background tasks in parallel in Swift.

Why cancel a background tasks

Interaction with a view may trigger a background task to run and further interaction may make the initial request obsolete and trigger a subsequent background task to run. Aside from a waste of resources, not cancelling the initial task may result in intermittent and unexpected behaviour in your app.

A cancel button is added to the View with the action to call cancel in the ViewModel. Some logging is added to the ViewModel to print out when the file download is incremented and when the file isDownloading property is set to false. It can be seen that, after the download is cancelled, the task continues and eventually sets the isDownloading property to false. This can cause a problem in the UI if a download is cancelled and a subsequent download is started quickly. The isDownloading property from the first task is set to false with the effect of stopping the second download.

View

 1struct NaiveCancelView: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel5
 3    @State var fileCount = 0
 4    
 5    init() {
 6        dataFiles = DataFileViewModel5()
 7    }
 8    
 9    var body: some View {
10        ScrollView {
11            VStack {
12                TitleView(title: ["Naive Cancel"])
13                
14                HStack {
15                    Button("Download All") {
16                        Task {
17                            let num = await dataFiles.downloadFile()
18                            fileCount += num
19                        }
20                    }
21                    .buttonStyle(BlueButtonStyle())
22                .disabled(dataFiles.file.isDownloading)
23                    Button("Cancel") {
24                        dataFiles.cancel()
25                    }
26                    .buttonStyle(BlueButtonStyle())
27                    .disabled(!dataFiles.file.isDownloading)
28                }
29                
30                Text("Files Downloaded: \(fileCount)")
31                
32                HStack(spacing: 10) {
33                    Text("File 1:")
34                    ProgressView(value: dataFiles.file.progress)
35                        .frame(width: 180)
36                    Text("\((dataFiles.file.progress * 100), specifier: "%0.0F")%")
37                    
38                    ZStack {
39                        Color.clear
40                            .frame(width: 30, height: 30)
41                        if dataFiles.file.isDownloading {
42                            ProgressView()
43                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
44                        }
45                    }
46                }
47                .padding()
48
49                .onDisappear {
50                    dataFiles.cancel()
51                }
52                
53                Spacer().frame(height: 200)
54                
55                Button("Reset") {
56                    dataFiles.reset()
57                }
58                .buttonStyle(BlueButtonStyle())
59                
60                Spacer()
61            }
62            .padding()
63        }
64    }
65}

ViewModel

 1class DataFileViewModel5: ObservableObject {
 2    @Published private(set) var file: DataFile
 3    
 4    init() {
 5        self.file = DataFile(id: 1, fileSize: 10)
 6    }
 7    
 8    func downloadFile() async -> Int {
 9        await MainActor.run {
10            file.isDownloading = true
11        }
12        
13        for _ in 0..<file.fileSize {
14            await MainActor.run {
15                guard file.isDownloading else { return }
16                file.increment()
17                print("  --   Downloading file - \(file.progress * 100) %")
18            }
19            usleep(300000)
20        }
21        
22        await MainActor.run {
23            file.isDownloading = false
24            print(" ***** File : \(file.id) setting isDownloading to FALSE")
25        }
26        
27        return 1
28    }
29    
30    func cancel() {
31        file.isDownloading = false
32        self.file = DataFile(id: 1, fileSize: 10)
33    }
34        
35    func reset() {
36        self.file = DataFile(id: 1, fileSize: 10)
37    }
38}

The second download task is stopped by the completion of the first background task

The second download task is stopped by the completion of the first background task

Use Cancel Flag

There are a number of approaches to cancel work in a background task. One mechanism is to add a status flag to the object with the asynchronous task and to monitor this flag while the task is running. There are no changes to the View required, the cancel button still calls the Cancel function in the ViewModel.

The changes to the ViewModel include the addition of a cancelFlag boolean property, which has to be marked with MainActor as it needs to be updated on the main UI thread. The loop that is simulating a file download is updated from a for loop to a while loop dependent on two conditions:

the cancel flag is false
the file is downloading

This fixes the problem, but it seems excessive to have an extra flag for cancelling a download.

View

 1struct CancelFlagView: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel6
 3    @State var fileCount = 0
 4
 5    init() {
 6        dataFiles = DataFileViewModel6()
 7    }
 8    
 9    var body: some View {
10        ScrollView {
11            VStack {
12                TitleView(title: ["Use Cancel Flag"])
13                
14                HStack {
15                    Button("Download All") {
16                        Task {
17                            let num = await dataFiles.downloadFile()
18                            fileCount += num
19                        }
20                    }
21                    .buttonStyle(BlueButtonStyle())
22                .disabled(dataFiles.file.isDownloading)
23                    Button("Cancel") {
24                        dataFiles.cancel()
25                    }
26                    .buttonStyle(BlueButtonStyle())
27                    .disabled(!dataFiles.file.isDownloading)
28                }
29                
30                Text("Files Downloaded: \(fileCount)")
31                
32                HStack(spacing: 10) {
33                    Text("File 1:")
34                    ProgressView(value: dataFiles.file.progress)
35                        .frame(width: 180)
36                    Text("\((dataFiles.file.progress * 100), specifier: "%0.0F")%")
37                    
38                    ZStack {
39                        Color.clear
40                            .frame(width: 30, height: 30)
41                        if dataFiles.file.isDownloading {
42                            ProgressView()
43                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
44                        }
45                    }
46                }
47                .padding()
48                
49                .onDisappear {
50                    dataFiles.cancel()
51                }
52
53                Spacer().frame(height: 200)
54                
55                Button("Reset") {
56                    dataFiles.reset()
57                }
58                .buttonStyle(BlueButtonStyle())
59                
60                Spacer()
61            }
62            .padding()
63        }
64    }
65}

ViewModel

 1class DataFileViewModel6: ObservableObject {
 2    @Published private(set) var file: DataFile
 3    
 4    @MainActor var cancelFlag = false
 5    
 6    init() {
 7        self.file = DataFile(id: 1, fileSize: 10)
 8    }
 9    
10    func downloadFile() async -> Int {
11        await MainActor.run {
12            file.isDownloading = true
13        }
14        
15        while await !cancelFlag, file.isDownloading {
16            await MainActor.run {
17                print("  --   Downloading file - \(file.progress * 100) %")
18                file.increment()
19            }
20            usleep(300000)
21        }
22        
23        await MainActor.run {
24            file.isDownloading = false
25            print(" ***** File : \(file.id) setting isDownloading to FALSE")
26        }
27        
28        return 1
29    }
30  
31    @MainActor
32    func cancel() {
33        self.cancelFlag = true
34        print(" ***** File : \(file.id) setting cancelFlag to TRUE")
35        self.reset()
36    }
37        
38    @MainActor
39    func reset() {
40        self.file = DataFile(id: 1, fileSize: 10)
41        self.cancelFlag = false
42    }
43}

Use of cancel flag in ViewModel to end the background loop

Use of cancel flag in ViewModel to end the background loop

Cancel the task instance - Task.checkCancellation()

A more elegant solution is to create a State property for the Task and assign the task to this property in the view for the Download button action. The Cancel button can then cancel this task. That sounds simple, right! Well, there's a little more to do because, as the documentation says:

Tasks include a shared mechanism for indicating cancellation, but not a shared implementation for how to handle cancellation.

This is because how a task is cancelled will vary depending on what the task is doing.

In this example, the downloadFile function in the ViewModel is changed to use checkCancellation within the loop of the download. This checks for cancellation and will throw an error if the task has been cancelled. When this error is thrown, the isDownloading flag can be set to false and optionally, the ViewModel can be reset.

In this case, the Cancel Flag and all the associated code can be removed completely from the ViewModel.

View

 1struct CancelTaskView: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel7
 3    @State var fileCount = 0
 4    
 5    @State var fileDownloadTask: Task<Void, Error>?
 6    
 7    init() {
 8        dataFiles = DataFileViewModel7()
 9    }
10    
11    var body: some View {
12        ScrollView {
13            VStack {
14                TitleView(title: ["Cancel Task", "", "<checkCancellation()>"])
15                
16                HStack {
17                    Button("Download All") {
18                        fileDownloadTask = Task {
19                            let num = await dataFiles.downloadFile()
20                            fileCount += num
21                        }
22                    }
23                    .buttonStyle(BlueButtonStyle())
24                    .disabled(dataFiles.file.isDownloading)
25                    Button("Cancel") {
26                        fileDownloadTask?.cancel()
27                    }
28                    .buttonStyle(BlueButtonStyle())
29                    .disabled(!dataFiles.file.isDownloading)
30                }
31                
32                Text("Files Downloaded: \(fileCount)")
33                
34                HStack(spacing: 10) {
35                    Text("File 1:")
36                    ProgressView(value: dataFiles.file.progress)
37                        .frame(width: 180)
38                    Text("\((dataFiles.file.progress * 100), specifier: "%0.0F")%")
39                    
40                    ZStack {
41                        Color.clear
42                            .frame(width: 30, height: 30)
43                        if dataFiles.file.isDownloading {
44                            ProgressView()
45                                .progressViewStyle(CircularProgressViewStyle(tint: .blue))
46                        }
47                    }
48                }
49                .padding()
50                
51                .onDisappear {
52                    fileDownloadTask?.cancel()
53                    dataFiles.reset()
54                }
55                
56                Spacer().frame(height: 200)
57                
58                Button("Reset") {
59                    fileDownloadTask?.cancel()
60                    dataFiles.reset()
61                }
62                .buttonStyle(BlueButtonStyle())
63                
64                Spacer()
65            }
66            .padding()
67        }
68    }
69}

ViewModel

 1class DataFileViewModel7: ObservableObject {
 2    @Published private(set) var file: DataFile
 3    
 4    init() {
 5        self.file = DataFile(id: 1, fileSize: 10)
 6    }
 7    
 8    func downloadFile() async  -> Int {
 9        await MainActor.run {
10            file.isDownloading = true
11        }
12        
13        while file.isDownloading {
14            do {
15                try await MainActor.run {
16                    try Task.checkCancellation()
17                    
18                    print("  --   Downloading file - \(file.progress * 100) %")
19
20                    file.increment()
21                }
22                usleep(300000)
23            } catch {
24                print(" *************** Catch - The task has been cancelled")
25                // Set the isDownloading flag to false
26                await MainActor.run {
27                    file.isDownloading = false
28                    // reset()
29                }
30            }
31        }
32        
33        await MainActor.run {
34            file.isDownloading = false
35            print(" ***** File : \(file.id) setting isDownloading to FALSE")
36        }
37        
38        return 1
39    }
40        
41    @MainActor
42    func reset() {
43        self.file = DataFile(id: 1, fileSize: 10)
44    }
45}

Cancel a Task instance in SwiftUI

Cancel a Task instance in SwiftUI

Task cancellation propagates to child tasks - Task.isCancelled

An alternative to raising an exception with checkCancellation is to use isCancelled to see if a task has been cancelled or not.

This approach still uses a State property for the Task. This is assigned to the downloadFiles function in the download button and the task is cancelled with the cancel button in the view.

The difference is in the ViewModel where the while loop includes a check for !Task.isCancelled so that the download continues if it has not been cancelled. This approach can be used for the single file download or as the code below demonstrates for the multiple file download.

Note that the Task that is cancelled is the main downloadFiles, which has multiple async calls to download multiple files. When the main task is cancelled, the cancellation propagates to all of the child tasks automatically in Swift.

View

 1struct CancelTaskMultipleView: View {
 2    @ObservedObject private var dataFiles: DataFileViewModel8
 3    
 4    @State var fileDownloadTask: Task<Void, Error>?
 5    
 6    init() {
 7        dataFiles = DataFileViewModel8()
 8    }
 9    
10    var body: some View {
11        ScrollView {
12            VStack {
13                TitleView(title: ["Cancel Task", "", "<Task.isCancelled>"])
14                
15                HStack {
16                    Button("Download All") {
17                        fileDownloadTask = Task {
18                            await dataFiles.downloadFiles()
19                        }
20                    }
21                    .buttonStyle(BlueButtonStyle())
22                    .disabled(dataFiles.isDownloading)
23                    
24                    Button("Cancel") {
25                        fileDownloadTask?.cancel()
26                    }
27                    .buttonStyle(BlueButtonStyle())
28                    .disabled(!dataFiles.isDownloading)
29                }
30                
31                Text("Files Downloaded: \(dataFiles.fileCount)")
32                
33                ForEach(dataFiles.files) { file in
34                    HStack(spacing: 10) {
35                        Text("File \(file.id):")
36                        ProgressView(value: file.progress)
37                            .frame(width: 180)
38                        Text("\((file.progress * 100), specifier: "%0.0F")%")
39                        
40                        ZStack {
41                            Color.clear
42                                .frame(width: 30, height: 30)
43                            if file.isDownloading {
44                                ProgressView()
45                                    .progressViewStyle(CircularProgressViewStyle(tint: .blue))
46                            }
47                        }
48                    }
49                }
50                .padding()
51                
52                .onDisappear {
53                    fileDownloadTask?.cancel()
54                    dataFiles.reset()
55                }
56                
57                Spacer().frame(height: 150)
58                
59                Button("Reset") {
60                    fileDownloadTask?.cancel()
61                    dataFiles.reset()
62                }
63                .buttonStyle(BlueButtonStyle())
64                
65                Spacer()
66            }
67            .padding()
68        }
69    }
70}

ViewModel

 1class DataFileViewModel8: ObservableObject {
 2    @Published private(set) var files: [DataFile]
 3    @Published private(set) var fileCount = 0
 4    
 5    init() {
 6        files = [
 7            DataFile(id: 1, fileSize: 10),
 8            DataFile(id: 2, fileSize: 20),
 9            DataFile(id: 3, fileSize: 5)
10        ]
11    }
12    
13    var isDownloading : Bool {
14        files.filter { $0.isDownloading }.count > 0
15    }
16    
17    func downloadFiles() async {
18        async let num1 = await downloadFile(0)
19        async let num2 = await downloadFile(1)
20        async let num3 = await downloadFile(2)
21        let (result1, result2, result3) = await (num1, num2, num3)
22        await MainActor.run {
23            fileCount = result1 + result2 + result3
24        }
25    }
26    
27    private func downloadFile(_ index: Array<DataFile>.Index) async -> Int {
28        await MainActor.run {
29            files[index].isDownloading = true
30        }
31        
32        while files[index].isDownloading, !Task.isCancelled {
33            await MainActor.run {
34                print("  --   Downloading file \(files[index].id) - \(files[index].progress * 100) %")
35                files[index].increment()
36            }
37            usleep(300000)
38        }
39        
40        await MainActor.run {
41            files[index].isDownloading = false
42            print(" ***** File : \(files[index].id) setting isDownloading to FALSE")
43        }
44        return 1
45    }
46    
47    @MainActor
48    func reset() {
49        files = [
50            DataFile(id: 1, fileSize: 10),
51            DataFile(id: 2, fileSize: 20),
52            DataFile(id: 3, fileSize: 5)
53        ]
54    }
55}

Cancelling a task instance cancels child tasks in SwiftUI

Cancelling a task instance cancels child tasks in SwiftUI

Cancelling and resuming background tasks in SwiftUI

Cancelling and resuming background tasks in SwiftUI

Conclusion

In Asynchronous programming, it is important to stop any unneeded background tasks to save resources and avoid any unwanted side-effects from background tasks interfering with the App. The Swift Async framework provides a number of ways to indicate that a task has been cancelled, but it is up to the implementer of the code in the task to respond appropriately when the task has been cancelled. Once a task has been cancelled, it cannot be uncancelled. One way to check if a task has been cancelled is to use checkCancellation, which will throw an error. Another is to simply use isCancelled as aboolean flag to see if the task has been cancelled.

Source code for AsyncLetApp is available on GitHub.