Examples and Projects - SwiftUI for Masterminds 3rd Edition

HOME BOOKS QUICK GUIDES VIDEO COURSES

NEWSLETTER CONTACT

SwiftUI for Masterminds

How to take advantage of SwiftUI to create insanely great apps for iPhones, iPads, and Macs

3rd Edition 2022
ISBN: 978-1-7779782-2-8

There is a new edition of this book available!
Click here for more information.

Information

3rd Edition 2022

ISBN: 978-1-7779782-2-8

More than 800 Codes Explained!

More than 300 Projects!

Examples and Projects

Although writing down the examples can help you remember what you are learning, sometimes it can be time consuming. To speed up the process, you can download the codes in TXT files, all Xcode projects, or open the codes you want to see from the links below.

Download TXT Files
411.0 KBytes

Download Projects
546.7 MBytes

CHAPTER 1 - APP DEVELOPMENT

There are no Examples in this Chapter

CHAPTER 2 - INTRODUCTION TO SWIFT

Listing 2-1: Playground template

Listing 2-2: Declaring variables

Listing 2-3: Initializing variables

Listing 2-4: Declaring and initializing variables in the same statement

Listing 2-5: Assigning a new value to a variable

Listing 2-6: Declaring variables of different data types

Listing 2-7: Declaring variables without specifying the data type

Listing 2-8: Assigning variables to variables

Listing 2-9: Assigning the result of an operation to a variable

Listing 2-10: Performing operations in variables of different type

Listing 2-11: Inferring the data type from an operation

Listing 2-12: Calculating the remainder

Listing 2-13: Adding numbers to variables

Listing 2-14: Performing operations on the variable's current value

Listing 2-15: Modifying the value of a variable using incremental operators

Listing 2-16: Declaring and initializing a constant

Listing 2-17: Declaring and initializing a Character variable

Listing 2-18: Declaring and initializing a String variable

Listing 2-19: Concatenating strings

Listing 2-20: Concatenating strings with the + and += operators

Listing 2-21: Including variables in strings

Listing 2-22: Performing operations inside strings

Listing 2-23: Including special characters in a string

Listing 2-24: Generating multiple lines of text

Listing 2-25: Declaring a Boolean variable

Listing 2-26: Declaring an optional variable of type Int

Listing 2-27: Assigning new values to optional variables

Listing 2-28: Using nil to empty an optional variable

Listing 2-29: Unwrapping an optional variable

Listing 2-30: Assigning an optional to another optional

Listing 2-31: Declaring Implicitly Unwrapped Optionals

Listing 2-32: Declaring a tuple with two values

Listing 2-33: Declaring a tuple with values of different type

Listing 2-34: Reading the values of a tuple

Listing 2-35: Modifying the value of a tuple

Listing 2-36: Declaring names for the values of a tuple

Listing 2-37: Creating multiple variables from the values of a tuple

Listing 2-38: Ignoring some of the values of a tuple

Listing 2-39: Comparing two values with if

Listing 2-40: Comparing two values with the <= operator

Listing 2-41: Conditions with Boolean values

Listing 2-42: Using logical operators

Listing 2-43: Using logical operators to check multiple conditions

Listing 2-44: Checking whether an optional contains a value or not

Listing 2-45: Using Optional Binding to unwrap an optional variable

Listing 2-46: Using the same name to unwrap a value

Listing 2-47: Unwrapping an optional value of the same name

Listing 2-48: Checking multiple conditions with Optional Binding

Listing 2-49: Using if else to respond to both states of the condition

Listing 2-50: Concatenating if else instructions

Listing 2-51: Implementing a ternary operator

Listing 2-52: Unwrapping an optional with a ternary operator

Listing 2-53: Unwrapping an optional with the nil-coalescing operator

Listing 2-54: Checking conditions with switch

Listing 2-55: Checking multiple conditions per case

Listing 2-56: Matching a tuple in a switch statement

Listing 2-57: Matching only the second value of a tuple

Listing 2-58: Capturing values with constants

Listing 2-59: Comparing values with where

Listing 2-60: Using while to create a loop

Listing 2-61: Using repeat while to create a loop

Listing 2-62: Using for in to iterate over the characters of a string

Listing 2-63: Iterating over a string without reading the characters

Listing 2-64: Adding a condition to a loop

Listing 2-65: Jumping to the next cycle of the loop

Listing 2-66: Interrupting the loop

Listing 2-67: Ignoring values in a switch statement

Listing 2-68: Interrupting a loop with guard

CHAPTER 3 - SWIFT PARADIGM

Listing 3-1: Declaring and calling functions

Listing 3-2: Calling functions from a loop

Listing 3-3: Sending values to a function

Listing 3-4: Sending multiple values to a function

Listing 3-5: Sending different values to a function

Listing 3-6: Returning a value from a function

Listing 3-7: Returning a tuple

Listing 3-8: Interrupting the execution of a function with guard

Listing 3-9: Removing the return keyword

Listing 3-10: Modifying external variables from a function

Listing 3-11: Declaring argument labels

Listing 3-12: Removing argument labels

Listing 3-13: Declaring default values for parameters

Listing 3-14: Declaring different functions with the same name

Listing 3-15: Defining generic functions

Listing 3-16: Printing values on the console with print()

Listing 3-17: Creating collections of values

Listing 3-18: Using variables and constants of different scopes

Listing 3-19: Assigning closures to variables

Listing 3-20: Initializing a variable with the value returned by a closure

Listing 3-21: Simplifying a closure

Listing 3-22: Sending a closure to a function

Listing 3-23: Assigning the closure to the function's argument

Listing 3-24: Using Trailing Closures

Listing 3-25: Inferring the closure's data types

Listing 3-26: Declaring escaping closures

Listing 3-27: Defining a structure

Listing 3-28: Declaring a variable of type Item

Listing 3-29: Assigning new values to the properties of a structure

Listing 3-30: Structures inside structures

Listing 3-31: Accessing optional properties

Listing 3-32: Creating key paths

Listing 3-33: Using read and write key paths

Listing 3-34: Defining methods

Listing 3-35: Assigning new values to properties from inside the structure

Listing 3-36: Initializing properties

Listing 3-37: Using memberwise initializers to provide the initial values of a structure

Listing 3-38: Initializing properties from the init() method

Listing 3-39: Declaring the parameters to initialize the structure

Listing 3-40: Declaring multiple init() methods

Listing 3-41: Declaring computed properties

Listing 3-42: Defining read-only properties

Listing 3-43: Adding the set method to set a new value

Listing 3-44: Using a different name for the parameter of the set method

Listing 3-45: Adding observers to a store property

Listing 3-46: Defining type properties

Listing 3-47: Defining type methods

Listing 3-48: Defining generic structures

Listing 3-49: Using generic structures

Listing 3-50: Initializing variables with standard initializers

Listing 3-51: Casting a variable

Listing 3-52: Extracting numbers from strings

Listing 3-53: Checking the maximum possible value for the Int8 type

Listing 3-54: Rounding floating-point values

Listing 3-55: Modifying the value of a Bool variable

Listing 3-56: Using for in to iterate over a range

Listing 3-57: Inverting a range

Listing 3-58: Using range operators in a switch statement

Listing 3-59: Calculating random numbers

Listing 3-60: Converting a number into a string

Listing 3-61: Processing the string's characters

Listing 3-62: Calculating a specific index

Listing 3-63: Getting the next index

Listing 3-64: Inserting a character in a string

Listing 3-65: Removing a character

Listing 3-66: Getting a range of characters

Listing 3-67: Working with ranges of characters

Listing 3-68: Implementing String methods

Listing 3-69: Declaring arrays

Listing 3-70: Declaring arrays with type inference

Listing 3-71: Reading the array's elements

Listing 3-72: Assigning a new value to an element

Listing 3-73: Adding new elements to an array

Listing 3-74: Concatenating two arrays

Listing 3-75: Creating multidimensional arrays

Listing 3-76: Reading values from a multidimensional array

Listing 3-77: Removing the elements of an array

Listing 3-78: Reading an array with a for in loop

Listing 3-79: Reading indexes and values of an array

Listing 3-80: Checking whether an array contains a value in a specific index

Listing 3-81: Adding and removing elements

Listing 3-82: Removing all the elements that meet a condition

Listing 3-83: Finding if an element meets a condition

Listing 3-84: Selecting a random value from an array

Listing 3-85: Changing the order of the elements of an array

Listing 3-86: Reading a range of elements

Listing 3-87: Casting arrays of type ArraySlice

Listing 3-88: Removing and replacing elements

Listing 3-89: Initializing an array with elements of the same value

Listing 3-90: Filtering the values of an array

Listing 3-91: Mapping an array

Listing 3-92: Converting the elements of an array into strings

Listing 3-93: Using a structure initializer with the map() method

Listing 3-94: Reducing an array

Listing 3-95: Reversing the elements of an array

Listing 3-96: Sorting the elements of an array

Listing 3-97: Sorting the elements of an array in a custom order

Listing 3-98: Sorting an array of integers

Listing 3-99: Sorting strings according to the number of characters

Listing 3-100: Getting the largest element

Listing 3-101: Getting the first value of an array

Listing 3-102: Getting the index of a specific value

Listing 3-103: Getting the index of a value that meets a condition

Listing 3-104: Creating an empty set of integers

Listing 3-105: Creating a set of integers

Listing 3-106: Using contains() to find an element in a set

Listing 3-107: Inserting a new element in a set

Listing 3-108: Removing an element from a set

Listing 3-109: Sorting the elements of a set

Listing 3-110: Combining sets

Listing 3-111: Comparing sets

Listing 3-112: Declaring a dictionary with initial values

Listing 3-113: Declaring a dictionary with type inference

Listing 3-114: Assigning a new value to an element of a dictionary

Listing 3-115: Adding a new element to a dictionary

Listing 3-116: Reading an element that does not exist

Listing 3-117: Reading a value in a dictionary

Listing 3-118: Removing an element from a dictionary

Listing 3-119: Using for in to iterate over a dictionary

Listing 3-120: Combining dictionaries with arrays

Listing 3-121: Reading arrays inside dictionaries

Listing 3-122: Grouping values by a key

Listing 3-123: Adding and removing elements from a dictionary

Listing 3-124: Sorting the values of a dictionary

Listing 3-125: Iterating over the dictionary's keys

Listing 3-126: Reading the keys of a dictionary

Listing 3-127: Defining an enumeration type

Listing 3-128: Declaring the enumeration values in one statement

Listing 3-129: Initializing an instance of an enumeration

Listing 3-130: Assigning a new value to a variable of type Number

Listing 3-131: Using switch with an enumeration type

Listing 3-132: Assigning raw values to enumeration values

Listing 3-133: Reading raw values

Listing 3-134: Creating an enumeration from a raw value

Listing 3-135: Adding methods to an enumeration

Listing 3-136: Associating values

Listing 3-137: Reading associated values from an if statement

Listing 3-138: Defining a class

Listing 3-139: Creating an object from a class

Listing 3-140: Modifying properties from the object's methods

Listing 3-141: Declaring a type method for a class

Listing 3-142: Referring to the object with self

Listing 3-143: Referring to the data type with self

Listing 3-144: Referencing one object from another

Listing 3-145: Assigning weak references

Listing 3-146: Defining a basic class

Listing 3-147: Inheriting properties and methods from another class

Listing 3-148: Creating objects from a subclass

Listing 3-149: Overriding an inherited method

Listing 3-150: Calling a method on the superclass

Listing 3-151: Creating an array of objects from different subclasses

Listing 3-152: Identifying the object's data type

Listing 3-153: Casting an object

Listing 3-154: Casting an object with the as? operator

Listing 3-155: Casting an object on the fly

Listing 3-156: Working with objects of AnyObject type

Listing 3-157: Declaring a Designated Initializer

Listing 3-158: Declaring a Convenience Initializer

Listing 3-159: Inheriting the Designated Initializer

Listing 3-160: Declaring a Designated Initializer for the subclass

Listing 3-161: Declaring a deinitializer

Listing 3-162: Defining lazy properties

Listing 3-163: Declaring private properties

Listing 3-164: Declaring a public getter and private setter

Listing 3-165: Defining a singleton

Listing 3-166: Defining protocols

Listing 3-167: Defining multiple structures that conform to the same protocol

Listing 3-168: Using protocols as data types

Listing 3-169: Accessing the instance's own properties

Listing 3-170: Returning values of a protocol type

Listing 3-171: Defining generic protocols

Listing 3-172: Conforming to the Equatable protocol

Listing 3-173: Letting the compiler create the protocol methods for us

Listing 3-174: Adding a type constraint to a generic function

Listing 3-175: Using the Numeric protocol to set a type constraint

Listing 3-176: Conforming to the Comparable protocol

Listing 3-177: Conforming to the Hashable protocol

Listing 3-178: Defining our own hash value

Listing 3-179: Conforming to the CaseIterable protocol

Listing 3-180: Extending a protocol

Listing 3-181: Extending data types

Listing 3-182: Extending custom data types

Listing 3-183: Defining a conditional extension

Listing 3-184: Customizing string interpolation

Listing 3-185: Delegating tasks

Listing 3-186: Delegating with protocols

Listing 3-187: Using different delegates

Listing 3-188: Getting an error inside a method

Listing 3-189: Throwing errors

Listing 3-190: Handling errors

Listing 3-191: Getting information about the error

Listing 3-192: Catching errors with try?

Listing 3-193: Ignoring the errors

Listing 3-194: Returning an error with a Result enumeration

Listing 3-195: Processing an error with the get() method

CHAPTER 4 - INTRODUCTION TO FRAMEWORKS

Listing 4-1: Applying math functions

Listing 4-2: Creating an NSString object

Listing 4-3: Casting a String value into an NSString object

Listing 4-4: Creating a formatted string

Listing 4-5: Formatting numbers

Listing 4-6: Comparing String values

Listing 4-7: Comparing String values with options

Listing 4-8: Comparing only a range of characters

Listing 4-9: Searching and replacing characters in a string

Listing 4-10: Creating and reading an NSRange value

Listing 4-11: Converting a range of string indexes

Listing 4-12: Working with NSNumber objects

Listing 4-13: Formatting a number

Listing 4-14: Rounding a number

Listing 4-15: Disabling grouping

Listing 4-16: Adding the sign

Listing 4-17: Formatting the number as a percentage value

Listing 4-18: Formatting currency values

Listing 4-19: Storing dates with Date structures

Listing 4-20: Comparing two dates

Listing 4-21: Extracting components from a date

Listing 4-22: Extracting multiple components from a date

Listing 4-23: Creating a new date from single components

Listing 4-24: Using a Gregorian calendar

Listing 4-25: Adding components to a date

Listing 4-26: Comparing dates

Listing 4-27: Finding a date in an interval

Listing 4-28: Formatting dates

Listing 4-29: Specifying a custom format

Listing 4-30: Including multiple date components

Listing 4-31: Specifying a different locale

Listing 4-32: Working with different time zones

Listing 4-33: Initializing Measurement structures

Listing 4-34: Adding the values of two Measurement structures

Listing 4-35: Adding two values of different units

Listing 4-36: Converting units

Listing 4-37: Formatting a measurement

Listing 4-38: Formatting a measurement for a specific purpose

Listing 4-39: Formatting the measurement's value

Listing 4-40: Formatting a measurement for a specific locale

Listing 4-41: Creating a non-repeating timer

Listing 4-42: Creating a repeating timer

Listing 4-43: Using regular expressions

Listing 4-44: Capturing values with subexpressions

Listing 4-45: Capturing multiple values

Listing 4-46: Processing multiple lines of text with a regular expression

Listing 4-47: Replacing the characters that match a regular expression

Listing 4-48: Defining a regular expression with a Regex Builder

Listing 4-49: Capturing a value from a Regex Builder

Listing 4-50: Transforming values to the right data type

Listing 4-51: Matching dates and currency

Listing 4-52: Initializing Core Graphics' structures

Listing 4-53: Using the CGRect convenience initializer

Listing 4-54: Accessing the structures inside a CGRect structure

Listing 4-55: Assigning empty structures to a CGRect variable

Listing 4-56: Calculating the coordinate at the center of the rectangle

CHAPTER 5 - SWIFTUI FRAMEWORK

Listing 5-1: Initializing the app

Listing 5-2: Defining a structure that conforms to the View protocol

Listing 5-3: Defining the Canvas preview

Listing 5-4: Returning values of complex data types

Listing 5-5: Returning opaque types

Listing 5-6: Displaying values with a Text view

Listing 5-7: Formatting the value for the Text view

Listing 5-8: Displaying a date with a Text view

Listing 5-9: Displaying a timer with a Text view

Listing 5-10: Applying modifiers to a view

Listing 5-11: Assigning a fixed size to a view

Listing 5-12: Creating flexible containers

Listing 5-13: Adding a padding to the view

Listing 5-14: Assigning a specific padding for each side

Listing 5-15: Assigning padding with Edge values

Listing 5-16: Assigning dynamic font types

Listing 5-17: Using the system font

Listing 5-18: Using standard fonts

Listing 5-19: Using custom fonts

Listing 5-20: Applying multiple styles to a text

Listing 5-21: Nesting Text views

Listing 5-22: Styling the font

Listing 5-23: Formatting text

Listing 5-24: Truncating text

Listing 5-25: Implementing Color views

Listing 5-26: Defining the color with RGB values

Listing 5-27: Assigning a dynamic color

Listing 5-28: Assigning a custom color

Listing 5-29: Assigning a color to the text of a Text view

Listing 5-30: Assigning a background color to a Text view

Listing 5-31: Assigning a background color to the view and the padding

Listing 5-32: Assigning a border to the view

Listing 5-33: Rounding corners

Listing 5-34: Displaying a view in front of another view

Listing 5-35: Applying a predefined gradient to a view

Listing 5-36: Applying a material

Listing 5-37: Applying a material to the view's content

Listing 5-38: Displaying an image

Listing 5-39: Clipping the image

Listing 5-40: Resizing the image

Listing 5-41: Resizing an image to fit the view

Listing 5-42: Resizing the image to fit within the view with the scaledToFit() modifier

Listing 5-43: Resizing and clipping the image to fill the view

Listing 5-44: Resizing image to fill the container

Listing 5-45: Applying style modifiers to an Image view

Listing 5-46: Applying visual effects to an Image view

Listing 5-47: Scaling an image to the selected font size

Listing 5-48: Displaying SF symbols

Listing 5-49: Styling a symbol

Listing 5-50: Storing the font in a constant

Listing 5-51: Assigning a variant to a symbol

Listing 5-52: Displaying multicolor symbols

Listing 5-53: Displaying a multicolor symbol with custom colors

Listing 5-54: Displaying a variable SF Symbol

Listing 5-55: Displaying a text with an SF Symbol

Listing 5-56: Performing a task when the view appears

Listing 5-57: Applying custom modifiers

Listing 5-58: Customizing a custom modifier

Listing 5-59: Creating a vertical stack of views

Listing 5-60: Aligning views in a vertical stack

Listing 5-61: Adding a space between the views

Listing 5-62: Creating a horizontal stack of views

Listing 5-63: Creating a ZStack

Listing 5-64: Setting the Z index of a view

Listing 5-65: Assigning modifiers to the stack and its content

Listing 5-66: Nesting stacks

Listing 5-67: Aligning the views with a flexible space

Listing 5-68: Aligning the views to the left and the top

Listing 5-69: Ignoring the safe area

Listing 5-70: Ignoring only the container safe area at the bottom

Listing 5-71: Expanding the safe area

Listing 5-72: Arranging the views with priorities by default

Listing 5-73: Assigning a higher priority to a view

Listing 5-74: Defining a view with a fixed size

Listing 5-75: Aligning images to the center with standard values

Listing 5-76: Aligning an image to the center with custom values

Listing 5-77: Aligning all images to the center with custom values

Listing 5-78: Defining custom alignment guides

Listing 5-79: Aligning views with custom alignment guides

Listing 5-80: Arranging the views in groups

Listing 5-81: Assigning different views to the body property

Listing 5-82: Defining a grid layout

Listing 5-83: Defining a multicolumn cell

Listing 5-84: Embedding a grid within another grid

Listing 5-85: Extracting views

Listing 5-86: Defining a custom layout

Listing 5-87: Selecting a layout

Listing 5-88: Wrapping views in an AnyView view

Listing 5-89: Constructing views with the @ViewBuilder property wrapper

Listing 5-90: Returning an empty view

Listing 5-91: Configuring the preview

Listing 5-92: Configuring the preview to represent multiple devices

Listing 5-93: Adapting the size of the preview to the size of the view

Listing 5-94: Activating dark mode

Listing 5-95: Generating multiple previews

CHAPTER 6 - DECLARATIVE USER INTERFACE

Listing 6-1: Defining a property wrapper

Listing 6-2: Using a property wrapper

Listing 6-3: Defining a state

Listing 6-4: Defining multiple states

Listing 6-5: Defining bidirectional binding

Listing 6-6: Using @Binding properties

Listing 6-7: Accessing the properties of a State structure

Listing 6-8: Initializing @State properties

Listing 6-9: Accessing the values of a @Binding property

Listing 6-10: Creating a Binding structure

Listing 6-11: Creating a Binding structure with an immutable value

Listing 6-12: Responding to updates in the states of the environment

Listing 6-13: Storing our data in an observable object

Listing 6-14: Initializing the observable object in the App structure

Listing 6-15: Working with the observable object from the views

Listing 6-16: Storing only the app's data in the model

Listing 6-17: Defining an observable object for a view

Listing 6-18: Initializing the view's observable object

Listing 6-19: Initializing the view's observable object when the views appear

Listing 6-20: Assigning the observable object to the view's environment

Listing 6-21: Getting a reference to the observable object from the environment

Listing 6-22: Defining an MVVM pattern

Listing 6-23: Accessing the model in an MVVM pattern

Listing 6-24: Implementing Button views

Listing 6-25: Using functions to organize the code

Listing 6-26: Referencing a method

Listing 6-27: Adding and removing views from the interface

Listing 6-28: Disabling a button

Listing 6-29: Defining the label of a button with an Image view

Listing 6-30: Styling buttons

Listing 6-31: Assigning a role

Listing 6-32: Scaling buttons

Listing 6-33: Defining custom styles for the button

Listing 6-34: Configuring a text field

Listing 6-35: Responding to the Done button

Listing 6-36: Responding to changes in focus

Listing 6-37: Closing the keyboard

Listing 6-38: Checking the values before storing

Listing 6-39: Disabling the button

Listing 6-40: Controlling user's input

Listing 6-41: Accepting only integer numbers

Listing 6-42: Defining a multiline text field

Listing 6-43: Using a secure text field

Listing 6-44: Implementing a text editor

Listing 6-45: Implementing a Toggle

Listing 6-46: Including a subtitle

Listing 6-47: Defining a custom label for the Toggle view

Listing 6-48: Implementing a toggle button

Listing 6-49: Defining a custom Toggle view

Listing 6-50: Creating a slider

Listing 6-51: Responding to the slider state

Listing 6-52: Showing progress

Listing 6-53: Simulating progress

Listing 6-54: Showing an activity indicator

Listing 6-55: Creating a stepper

Listing 6-56: Defining the steps of a stepper

Listing 6-57: Modifying the interface when the value is incremented or decremented

Listing 6-58: Defining a group of views

Listing 6-59: Detecting changes in the horizontal size class

Listing 6-60: Using a GeometryReader to detect orientation

Listing 6-61: Adapting an Image view to the size of its container

Listing 6-62: Reading the position of the GeometryReader view

Listing 6-63: Reading the position and size of a view

Listing 6-64: Setting and reading preferences

CHAPTER 7 - LISTS

Listing 7-1: Creating a list of views dynamically

Listing 7-2: Creating a list with a standard design

Listing 7-3: Defining a model to work with lists of views

Listing 7-4: Injecting the model into the environment

Listing 7-5: Creating a list of views with data from the model

Listing 7-6: Making a list of views scrollable

Listing 7-7: Configuring the scroll view

Listing 7-8: Scrolling the list of views horizontally

Listing 7-9: Scrolling the list programmatically

Listing 7-10: Creating a grid with a fixed number of items

Listing 7-11: Defining flexible items

Listing 7-12: Defining adaptive items

Listing 7-13: Creating a list of views with the List view

Listing 7-14: Creating a plain list

Listing 7-15: Customizing the rows

Listing 7-16: Assigning alternate backgrounds

Listing 7-17: Mixing static and dynamic content in a list

Listing 7-18: Dividing the content into sections

Listing 7-19: Configuring the section separators

Listing 7-20: Configuring the list from the environment

Listing 7-21: Providing an ordered list of values

Listing 7-22: Deleting rows

Listing 7-23: Activating the edit mode

Listing 7-24: Moving rows

Listing 7-25: Selecting a row

Listing 7-26: Selecting multiple rows

Listing 7-27: Customizing the edit mode

Listing 7-28: Customizing the selection

Listing 7-29: Storing the selection in the model

Listing 7-30: Defining custom swipe actions

Listing 7-31: Implementing a custom button to delete the rows

Listing 7-32: Refreshing the list

Listing 7-33: Defining the model and the view to create a hierarchical list

Listing 7-34: Implementing an OutlineGroup view

Listing 7-35: Defining a model to test tables

Listing 7-36: Creating a table with multiple columns

Listing 7-37: Sorting the values by column

Listing 7-38: Allowing the user to select items in a table

Listing 7-39: Using a context menu to process a row

Listing 7-40: Defining the content of a column with a Toggle view

Listing 7-41: Defining a custom sort comparator

Listing 7-42: Sorting Boolean values on a table

Listing 7-43: Defining a picker

Listing 7-44: Selecting an initial value

Listing 7-45: Listing values by index

Listing 7-46: Implementing a segmented picker

Listing 7-47: Defining a DatePicker to select a date

Listing 7-48: Limiting the DatePicker to a range of values

Listing 7-49: Presenting a picker with a spinning wheel

Listing 7-50: Picking multiple dates

Listing 7-51: Defining a form

Listing 7-52: Defining a custom label

Listing 7-53: Styling a form

Listing 7-54: Disclosing controls

CHAPTER 8 - NAVIGATION

Listing 8-1: Initiating a navigation stack

Listing 8-2: Setting the title mode

Listing 8-3: Adding a button to the navigation bar

Listing 8-4: Adding multiple buttons

Listing 8-5: Adding buttons to the bottom toolbar

Listing 8-6: Defining the buttons intent

Listing 8-7: Customizing the bar

Listing 8-8: Creating a popup menu

Listing 8-9: Filtering the data in the model

Listing 8-10: Displaying a search bar

Listing 8-11: Keeping the search bar on the screen

Listing 8-12: Performing the search when the Return/Done key is pressed

Listing 8-13: Suggesting terms to the user

Listing 8-14: Cancelling the search programmatically

Listing 8-15: Adding scope buttons

Listing 8-16: Searching by title and author

Listing 8-17: Adding tokens

Listing 8-18: Filtering books by author

Listing 8-19: Including a navigation link

Listing 8-20: Defining a second view

Listing 8-21: Dismissing the view from the environment

Listing 8-22: Selecting rows with a navigation link

Listing 8-23: Defining a Detail view

Listing 8-24: Defining custom navigation

Listing 8-25: Adding and removing views from the path

Listing 8-26: Going back to any view in the path

Listing 8-27: Adding values to the path

Listing 8-28: Displaying a sheet

Listing 8-29: Defining the view for the sheet

Listing 8-30: Disabling the interactive dismiss feature

Listing 8-31: Assigning a predefined height

Listing 8-32: Assigning a custom height

Listing 8-33: Presenting a sheet for every value on the list

Listing 8-34: Editing a book

Listing 8-35: Showing a popover

Listing 8-36: Defining the content of the popover

Listing 8-37: Displaying an alert view

Listing 8-38: Defining an Alert view with multiple buttons

Listing 8-39: Defining an action sheet

Listing 8-40: Defining a TabView

Listing 8-41: Defining the BooksView

Listing 8-42: Defining the SettingsView

Listing 8-43: Displaying a badge in a tab

Listing 8-44: Selecting the initial view

Listing 8-45: Updating the model

Listing 8-46: Designing the rows according to the app's configuration

Listing 8-47: Configuring the app

Listing 8-48: Configuring the TabView to show content in pages

Listing 8-49: Defining a two-column split view

Listing 8-50: Defining the view for the left column

Listing 8-51: Defining a placeholder view for the right column

Listing 8-52: Defining a Multiplatform Detail view

Listing 8-53: Showing an item by default

Listing 8-54: Enabling navigation in the right column

Listing 8-55: Creating a navigation path for the right column

Listing 8-56: Expanding the cover in a Multiplatform application

Listing 8-57: Adding navigation to the left column

Listing 8-58: Opening a view on the left column

Listing 8-59: Providing the list of authors

Listing 8-60: Defining a three-column layout

Listing 8-61: Showing the authors

Listing 8-62: Showing the books

Listing 8-63: Hiding columns programmatically

Listing 8-64: Configuring the columns

CHAPTER 9 - CONCURRENCY

Listing 9-1: Initiating an asynchronous task

Listing 9-2: Running multiple asynchronous processes

Listing 9-3: Defining a task explicitly

Listing 9-4: Cancelling a task

Listing 9-5: Reading a value returned by a task

Listing 9-6: Defining asynchronous properties

Listing 9-7: Responding to errors

Listing 9-8: Defining a concurrent task

Listing 9-9: Defining an actor

Listing 9-10: Defining a non-isolated method

Listing 9-11: Defining a non-isolated method

Listing 9-12: Asking the compiler not to check conformity to the Sendable protocol

Listing 9-13: Executing a method in the Main Actor

Listing 9-14: Executing code in the Main Actor

Listing 9-15: Returning a value from the Main Actor

Listing 9-16: Defining an asynchronous sequence

Listing 9-17: Defining a task group

Listing 9-18: Loading an image asynchronously

Listing 9-19: Configuring the image after it is downloaded

CHAPTER 10 - STORAGE

Listing 10-1: Storing and reading values from User Defaults

Listing 10-2: Storing app settings in User Defaults

Listing 10-3: Managing the app's settings from the model

Listing 10-4: Adapting the interface to the app's settings

Listing 10-5: Modifying the app's settings

Listing 10-6: Accessing directories and creating files

Listing 10-7: Opening a sheet to add files to the model

Listing 10-8: Creating new files

Listing 10-9: Managing the app's files

Listing 10-10: Listing the files created by the user

Listing 10-11: Working with custom directories

Listing 10-12: Listing files from two directories

Listing 10-13: Moving and deleting files

Listing 10-14: Adding tools to move and delete files

Listing 10-15: Reading the file's attributes

Listing 10-16: Showing the file's attributes

Listing 10-17: Opening the details view

Listing 10-18: Loading and saving an image

Listing 10-19: Showing the image in the file

Listing 10-20: Displaying a list of images for the user to select

Listing 10-21: Reducing the size of an image

Listing 10-22: Storing text in a file

Listing 10-23: Editing the text stored in a file

Listing 10-24: Loading a file from the bundle

Listing 10-25: Displaying the text stored in a file in the bundle

Listing 10-26: Defining a document model

Listing 10-27: Creating a Document app

Listing 10-28: Editing the document

Listing 10-29: Exporting a document

Listing 10-30: Importing a document

Listing 10-31: Exporting multiple documents

Listing 10-32: Managing files and documents from the model

Listing 10-33: Exporting files from the list

Listing 10-34: Editing a file

Listing 10-35: Encoding and decoding data

Listing 10-36: Encoding and decoding a custom structure

Listing 10-37: Showing the values stored in the file

Listing 10-38: Allowing the user to insert new values

Listing 10-39: Storing multiple books

Listing 10-40: Showing all the values stored in the file

Listing 10-41: JSON file

Listing 10-42: Encoding and decoding the data with JSON

Listing 10-43: Defining nested structures

Listing 10-44: Nested data in JSON

Listing 10-45: Reading values in a nested structure

Listing 10-46: Showing the values of a nested structure

Listing 10-47: Initializing the Core Data stack from the model

Listing 10-48: Injecting the context into the environment

Listing 10-49: Fetching objects from the Persistent Store

Listing 10-50: Adding new objects to the Persistent Store

Listing 10-51: Defining a view model for the Core Data objects

Listing 10-52: Using the values from the view model

Listing 10-53: Selecting the author

Listing 10-54: Listing all the authors available

Listing 10-55: Inserting new authors

Listing 10-56: Creating a Persistent Store for previews

Listing 10-57: Accessing the Core Data context from the preview

Listing 10-58: Sorting the books by title

Listing 10-59: Sorting books by author and year

Listing 10-60: Sorting with a lexical comparator

Listing 10-61: Modifying the sorting criteria

Listing 10-62: Filtering books by year

Listing 10-63: Filtering books by author

Listing 10-64: Assigning new predicates to search for values inserted by the user

Listing 10-65: Filtering values with predicate keywords

Listing 10-66: Searching for characters in a string

Listing 10-67: Selecting an author

Listing 10-68: Listing books by author

Listing 10-69: Selecting the book to modify

Listing 10-70: Modifying the values of an object in the Persistent Store

Listing 10-71: Deleting objects

Listing 10-72: Counting the books available

Listing 10-73: Counting objects with the count() method

Listing 10-74: Counting the books of each author

Listing 10-75: Checking for duplicates

Listing 10-76: Fetching objects for sections

Listing 10-77: Storing the first letter of the book's title

Listing 10-78: Modifying the book's first letter

Listing 10-79: Sorting the books by letter

Listing 10-80: Creating a string with the name of the authors from the view model

Listing 10-81: Showing the list of authors

Listing 10-82: Assigning multiple authors to a book

Listing 10-83: Modifying the authors of a book

Listing 10-84: Selecting multiple authors

Listing 10-85: Fetching books by author

Listing 10-86: Systematically removing authors from books

CHAPTER 11 - GRAPHICS AND ANIMATIONS

Listing 11-1: Drawing standard shapes

Listing 11-2: Filling a shape with a color

Listing 11-3: Defining a border

Listing 11-4: Defining a custom border

Listing 11-5: Combining shapes with other views

Listing 11-6: Combining shapes with other views

Listing 11-7: Defining a linear gradient

Listing 11-8: Defining a linear gradient with custom stops

Listing 11-9: Defining a circular gradient

Listing 11-10: Defining a conic gradient

Listing 11-11: Adding a shadow to a view

Listing 11-12: Filling a shape with an image

Listing 11-13: Defining a custom path

Listing 11-14: Combining lines and arcs

Listing 11-15: Combining lines and ellipses

Listing 11-16: Creating complex curves

Listing 11-17: Adapting the size of the path to the size of the container

Listing 11-18: Creating a custom shape view

Listing 11-19: Implementing custom shape views

Listing 11-20: Displacing an image

Listing 11-21: Rotating the image

Listing 11-22: Clipping the image

Listing 11-23: Rotating a shape

Listing 11-24: Inverting a shape with the scale() modifier

Listing 11-25: Trimming a path

Listing 11-26: Drawing an image on the canvas

Listing 11-27: Drawing an image on the canvas

Listing 11-28: Drawing shapes and text

Listing 11-29: Rotating the canvas

Listing 11-30: Rotating an image

Listing 11-31: Performing multiple transformations

Listing 11-32: Preparing images

Listing 11-33: Clipping the canvas

Listing 11-34: Working with different configurations

Listing 11-35: Applying filters to the graphics

Listing 11-36: Providing the data for a chart

Listing 11-37: Visualizing data with a bar chart

Listing 11-38: Visualizing data with a line chart

Listing 11-39: Defining a custom scale for the y axis

Listing 11-40: Drawing a line in the plot area

Listing 11-41: Assigning different styles based on a category

Listing 11-42: Representing the values with different types of marks

Listing 11-43: Representing the values with different types of marks

Listing 11-44: Visualizing two series of values

Listing 11-45: Visualizing two series of values with a bar chart

Listing 11-46: Defining the positions of the bars

Listing 11-47: Creating an image from a view

Listing 11-48: Animating a view

Listing 11-49: Applying a linear animation

Listing 11-50: Configuring the animation

Listing 11-51: Defining a custom animation

Listing 11-52: Animating multiple states at a time

Listing 11-53: Applying a different animation to each state

Listing 11-54: Instantiating a view with a value that can be animated

Listing 11-55: Defining an animatable path

Listing 11-56: Updating the interface

Listing 11-57: Animating the canvas

Listing 11-58: Creating a real animation

Listing 11-59: Adding and removing a view with a transition

Listing 11-60: Extending the AnyTransition structure

Listing 11-61: Defining an asymmetric transition

Listing 11-62: Combining transitions

Listing 11-63: Customizing the transition

Listing 11-64: Coordinating transitions

Listing 11-65: Coordinating views

CHAPTER 12 - GESTURES

Listing 12-1: Detecting a tap gesture on an image

Listing 12-2: Expanding the image

Listing 12-3: Detecting a long press gesture

Listing 12-4: Disabling the tap gesture

Listing 12-5: Defining the shape of the content

Listing 12-6: Defining a TapGesture recognizer

Listing 12-7: Defining a LongPressGesture recognizer

Listing 12-8: Controlling the states of a gesture with an enumeration

Listing 12-9: Defining a MagnificationGesture recognizer

Listing 12-10: Determining a minimum and a maximum scale

Listing 12-11: Defining a RotationGesture recognizer

Listing 12-12: Allowing the user to drag an image

Listing 12-13: Providing a custom preview for the gesture

Listing 12-14: Dropping images into an Image view

Listing 12-15: Processing the image as data

Listing 12-16: Dragging custom values

Listing 12-17: Using a custom content type

Listing 12-18: Dragging and dropping custom values

CHAPTER 13 - MAP KIT

Listing 13-1: Configuring the map from the model

Listing 13-2: Displaying a map

Listing 13-3: Showing the current latitude and longitude

Listing 13-4: Disabling panning

Listing 13-5: Defining an annotation

Listing 13-6: Displaying the annotations

Listing 13-7: Presenting the annotation with custom views

Listing 13-8: Presenting the annotation with images and text

Listing 13-9: Selecting annotations

Listing 13-10: Searching for pizza places

Listing 13-11: Conforming to the CLLocationManagerDelegate protocol

Listing 13-12: Requesting authorization and showing the user's location

Listing 13-13: Implementing the user location button

CHAPTER 14 - NOTIFICATIONS

Listing 14-1: Listening to notifications from the model

Listing 14-2: Listening to notifications

Listing 14-3: Adding new values to the model

Listing 14-4: Adding information to the notification

Listing 14-5: Reading the value in the notification

Listing 14-6: Cancelling the task

Listing 14-7: Interface to test the keyboard

Listing 14-8: Scrolling the interface to make room for the keyboard

Listing 14-9: Listening to keyboard notifications

Listing 14-10: Modifying the interface when the keyboard state changes

Listing 14-11: Detecting changes in the orientation

Listing 14-12: Adapting the interface to changes in the orientation

Listing 14-13: Asking permission to send notifications

Listing 14-14: Scheduling a notification

Listing 14-15: Playing a sound

Listing 14-16: Attaching an image to a notification

Listing 14-17: Scheduling provisional notifications

Listing 14-18: Checking the status of a provisional authorization

Listing 14-19: Showing notifications while the app is running

Listing 14-20: Organizing notifications into groups

Listing 14-21: Configuring a summary of notifications

Listing 14-22: Adding an action to a notification

Listing 14-23: Processing actions for notifications

Listing 14-24: Adding an input action to a notification

Listing 14-25: Processing the user's feedback

Listing 14-26: Detecting changes in the app's state

Listing 14-27: Defining a custom app delegate

Listing 14-28: Assigning the app delegate from a SwiftUI application

Listing 14-29: Defining a custom Scene delegate

Listing 14-30: Configuring a Scene

Listing 14-31: Defining the model as a singleton

Listing 14-32: Injecting the singleton into the environment

Listing 14-33: Modifying the model from the app delegate

Listing 14-34: Implementing a model created from a singleton

CHAPTER 15 - ICLOUD

Listing 15-1: Storing a value in iCloud

Listing 15-2: Defining the interface to store and read values from iCloud

Listing 15-3: Storing multiple values in iCloud

Listing 15-4: Reading multiple values from iCloud

Listing 15-5: Saving multiple values in iCloud

Listing 15-6: Creating the document

Listing 15-7: Initializing the model required to store a document in iCloud

Listing 15-8: Processing query results

Listing 15-9: Updating the document

Listing 15-10: Defining the main interface

Listing 15-11: Editing the document

Listing 15-12: Working with multiple documents

Listing 15-13: Processing the list of files in the container

Listing 15-14: Updating the container

Listing 15-15: Adding and removing documents from the container

Listing 15-16: Opening, saving, and closing a document

Listing 15-17: Listing the documents available in the container

Listing 15-18: Creating new documents

Listing 15-19: Displaying the document's content

Listing 15-20: Preparing Core Data to work with CloudKit

Listing 15-21: Injecting the context into the environment

Listing 15-22: Listing the countries stored in the Persistent Store

Listing 15-23: Inserting new countries in the Persistent Store

Listing 15-24: Listing the cities stored in the Persistent Store

Listing 15-25: Inserting new cities in the Persistent Store

Listing 15-26: Defining a model for CloudKit

Listing 15-27: Listing the countries in the Private Database

Listing 15-28: Storing countries in the Private database

Listing 15-29: Listing the cities of a country

Listing 15-30: Storing cities in the Private Database

Listing 15-31: Storing assets

Listing 15-32: Preparing the image for the view

Listing 15-33: Opening a view to show the asset

Listing 15-34: Showing the asset

Listing 15-35: Processing Remote Notifications from a custom app delegate

Listing 15-36: Assigning the app's delegate

Listing 15-37: Defining the properties to control the subscription and the custom zone

Listing 15-38: Configuring the database

Listing 15-39: Initiating the process to get the updates from the server

Listing 15-40: Downloading the updates from the server

Listing 15-41: Storing the records in a custom zone

Listing 15-42: Checking CloudKit availability

Listing 15-43: Checking for errors

CHAPTER 16 - FRAMEWORK INTEGRATION

Listing 16-1: Preparing a UIKit view to work with SwiftUI

Listing 16-2: Showing a UIKit view within a SwiftUI view

Listing 16-3: Sending and receiving values from the SwiftUI view

Listing 16-4: Receiving and sending values to a UIKit view

Listing 16-5: Creating a UIKit view controller

Listing 16-6: Creating the representable view for a UIKit view controller

Listing 16-7: Loading a UIKit view controller from a SwiftUI view

CHAPTER 17 - WEB

Listing 17-1: Opening a website

Listing 17-2: Encoding URLs

Listing 17-3: Encoding custom URLs

Listing 17-4: Creating a Safari Browser

Listing 17-5: Opening a Safari Browser

Listing 17-6: Configuring the view controller

Listing 17-7: Preserving the bars at their original size

Listing 17-8: Assigning a delegate to the Safari View Controller

Listing 17-9: Disabling the button from the Safari View Controller delegate

Listing 17-10: Loading a website with a WebKit View

Listing 17-11: Showing the WebKit view

Listing 17-12: Allowing the user the insert a URL

Listing 17-13: Updating the WKWebView with the URLs inserted by the user

Listing 17-14: Providing buttons for navigation

Listing 17-15: Navigating back and forth in the navigation history

Listing 17-16: Loading a remote document

Listing 17-17: Displaying the document's content

Listing 17-18: Instantiating a custom session

Listing 17-19: Redirecting the user

Listing 17-20: Loading a JSON document

Listing 17-21: Listing the values from the document

CHAPTER 18 - MEDIA

Listing 18-1: Creating a Photo picker

Listing 18-2: Defining the model for multiple selection

Listing 18-3: Allowing the user to perform multiple selections

Listing 18-4: Creating the Image Picker Controller to take pictures

Listing 18-5: Defining the interface to take pictures

Listing 18-6: Showing an Alert view when a picture is saved

Listing 18-7: Sharing the image with other applications

Listing 18-8: Defining a UIView to show the camera's preview video

Listing 18-9: Defining the properties we need to manage the camera

Listing 18-10: Asking for permission to use the camera

Listing 18-11: Initializing the camera

Listing 18-12: Showing the video from the camera on the screen

Listing 18-13: Detecting the device's orientation

Listing 18-14: Taking a picture

Listing 18-15: Processing the image

Listing 18-16: Showing the image

Listing 18-17: Taking a picture

Listing 18-18: Preparing the video to be played

Listing 18-19: Playing a video

Listing 18-20: Automatically playing a video

Listing 18-21: Presenting views over the video

Listing 18-22: Building a custom video player

Listing 18-23: Building a custom video player

Listing 18-24: Showing a video

Listing 18-25: Preparing the video player

Listing 18-26: Playing and pausing the video

Listing 18-27: Executing an asynchronous method to detect the end of the video

Listing 18-28: Rewinding the video

Listing 18-29: Playing a list of videos

Listing 18-30: Showing a color picker

CHAPTER 19 - MULTIPLATFORM APPLICATIONS

Listing 19-1: Detecting the platform before compiling

Listing 19-2: Applying different modifiers to each platform

Listing 19-3: Defining a multiplatform interface

Listing 19-4: Adding a menu to the menu bar

Listing 19-5: Assigning a keyboard shortcut to a menu option

Listing 19-6: Adding options to a standard menu

Listing 19-7: Removing options

Listing 19-8: Defining a property in the model to store the index of the selected option

Listing 19-9: Adding a submenu

Listing 19-10: Adding predefined options to import resources

Listing 19-11: Importing an image form an external device

Listing 19-12: Defining a state to enable and disable a menu option

Listing 19-13: Enabling and disabling a menu option

Listing 19-14: Defining a TextField view to enable and disable the option

Listing 19-15: Storing a focus state in the FocusedValues structure

Listing 19-16: Passing the focus state to the FocusedValues structure

Listing 19-17: Disabling a menu option according to the focus state of a view

Listing 19-18: Defining a two-column interface

Listing 19-19: Adding items to the toolbar for a Mac application

Listing 19-20: Showing a tooltip for a button

Listing 19-21: Defining a model with data organized in sections

Listing 19-22: Defining a two columns interface

Listing 19-23: Defining collapsable sections

Listing 19-24: Highlighting alternate rows

Listing 19-25: Opening an auxiliary window

Listing 19-26: Opening a window programmatically

Listing 19-27: Configuring the auxiliary window

Listing 19-28: Defining a Settings Scene

Listing 19-29: Inserting a control in the system's menu bar

Listing 19-30: Defining a control to open a view

Listing 19-31: Defining the model to test multiple Scenes

Listing 19-32: Storing the state of the Scene

CHAPTER 20 - APP STORE

There are no Examples in this Chapter

TABLE OF CONTENTS