Ramiro Rafart

SwiftUI‘s shapes can be all consolidated in different ways to make new shapes, including association (a filled district blending the two shapes), crossing point (a filled locale containing areas normal in the two shapes), line convergence (returns the line of one shape covers the fill of another), and the sky is the limit from there.

For instance, this combine a circle with a capsule inset by 150, then fills the outcome blue:

                Circle()
                .union(.capsule.inset(by: 150))
                .fill(.red)

We use the instance method union which returns a new shape with filled regions in either this shape or the given shape.

The benefit to having a solitary shape is that the outcome mixes well when you add mistiness – you’re not delivering two covering shapes separately, however consolidating them both into a solitary shape and delivering that.

Essentially, we could utilize lineSubtraction() to remove a square’s shape from a circle, then, at that point, stroke the rest of an adjusted cap:

Circle()
                .lineSubtraction(.rect.inset(by: 20))
                .stroke(style: .init(lineWidth: 30, lineCap: .round))
                .padding()

The result in XCode will be:

Or on the other hand we could put one circle off to the left, then deduct one more circle offset to the right:

   Circle()
                .offset(x: -10)
                .symmetricDifference(.circle.offset(x: 10))
                .fill(.red)
                .padding()

Creating exquisite, feature-rich user interfaces can be a mind-blowing test of rules and estimates. For some, it is a daunting task. Be that as it may, it doesn’t have to be that way.

Today we will investigate one of the most basic parts of the plan in SwiftUI: shapes. In terms of user interface, using manifolds is one of the best ways to convey data, achieve visual order, and improve the overall look of an application. What’s more, taking care of business has never been easier.

This article will explain different approaches to incorporating shapes into SwiftUI, incorporating working with frame tones, creating custom tones, and applying various styles to text and shapes.

Most underlying shapes in SwiftUI recognize their proposed size and fill the proposed size. The circle is the special case; will continually report a square size. We can see the detailed sizes in the following example by enabling the line, which displays the shape’s jump box.

Naturally, a shape is filled using the closest view style. We can use fill or add a stroke to the shape. A stroke follows the shape, drawing half the width of the line beyond the boundaries.

Unlike stacks, shapes take up the most extreme space. To vary them, use fill and foreground color instead of base. They are perfect for cutting substance and establishing a borderline style.

SwiftUI provides us with five frequently used built-in shapes: capsule, circle, ellipse, rectangle, rounded rectangle. Depending on the sizes you choose, these last three in particular act slightly differently, but we can show you all the alternatives with just one example:

truct ContentView: View {
    var body: some View {
        VStack {
            Rectangle()
                .fill(.red)
                .frame(width: 200, height: 200)

            RoundedRectangle(cornerRadius: 25)
                .fill(.green)
                .frame(width: 200, height: 200)

            UnevenRoundedRectangle(cornerRadii: .init(topLeading: 100, topTrailing: 100))
                .fill(.orange)
                .frame(width: 100, height: 100)

            Capsule()
                .fill(.yellow)
                .frame(width: 100, height: 50)

            Ellipse()
                .fill(.blue)
                .frame(width: 100, height: 50)

            Circle()
                .fill(.white)
                .frame(width: 100, height: 50)
        }
    }
}

That illustrates the six ways. However, all five shapes will be seen in the output due to variations in the drawing behavior of the shapes.

In XCode it would look like this:

Rectangle creates a box with precisely the measurements you provide. While most SwiftUI components, for example stacks, colors, and angles, start out as square shapes, they are not shapes.

RoundedRectangle does the same functions, but allows you to adjust how much to round the corners. You can choose between Apple’s significantly softer corners (.continuous) or traditional rounded corners (.circular) with its second option, style. From iOS 13 to iOS 16, the default was circular; However, starting with iOS 17, this changes to continuous. RoundedRectangle accompanies valuable style and cornerRadius properties. It’s perfect for creating buttons and producing the smooth corners of iOS.

An UnevenRoundedRectangle with only some rounded corners is called an uneven rounded rectangle. For each corner, the default value is 0, but you can override as many as you want to create a unique effect.

Depending on which is larger, the capsule creates a box with a completely rounded edge axis. Since our shape is 100 by 50, its top and bottom edges will be straight and its left and right edges will be rounded.

Ellipse creates an ellipse with the precise measurements you provide. The ellipse looks like a circle, although without the ideal 1:1 ratio. When the width and level are different, it will occupy the space and be deformed.

Capsule, like RoundedRectangle, the case is pill-shaped. Each end of the box is formed by a semicircle. You can use them for buttons.

Circle creates an ellipse with equal height and width, so if we give the space 100 by 50, we will actually receive 50 by 50. The circle allows you to draw an ideal round shape. The round shape will have a width equivalent to the smallest number between width and level.

In this article we are going to see the font and text modifiers in SwiftUI and how to use them for our text views in our iOS apps. Typography and fonts play an important and fundamental role in our User Interface design, influencing the user experience of our app.

It is important that in our iOS app the user interface is intuitive.

Typography and fonts are crucial elements of UI/UX design that have a huge impact on user experience. They help set the mood, convey information, and make using an app or website more enjoyable. Let’s take the detailed view of a recipe app as an example to understand why typography and fonts are important in our iOS app.

The app pays attention to typography. For titles, use a clean, modern font so they stand out and are organized. For the main text, choose a readable and attractive font for comfortable reading.

The app also uses different font weights to show the importance of the information. Recipe titles are bolded to attract attention, while the ingredient list and instructions use normal weight for easy reading.

By paying attention to the texts the app creates a better user experience.

Keep up with consistency: Consistency is key when it comes to text styles in your iOS app. Choose an essential text style or a text style that matches your app’s markup and stick to it throughout your app. Using predictable text styles creates a strong, clean customer experience.

Think about understandability: Focus on clarity when choosing text styles for your application. Make sure the selected text styles are clear and easy to read, even in different text sizes or on different devices. Avoid overly bright or disconcerting text styles that can block meaning.

Design a visual ordered progression: Use styles, loadings, and text style sizes to design a visual ordered progression at the endpoint of your application. Separate headings, titles, and important information from standard text using bolder fonts or larger sizes. Unmistakable visual order guides customers and improves the overall customer experience.

Opening Test: Make sure the textual styles you choose are available to clients with fluctuating visual abilities. Test your app’s text styles with various aperture settings, including dynamic sorting, to ensure that text remains decipherable and doesn’t lose its clarity or separation. Consider using text styles or quotes that can accommodate customers’ availability inclinations.

Embrace customization: While framework text styles provide consistency across iOS devices, be sure to integrate custom text styles when they align with your app’s design and markup goals. Custom text styles can add character and uniqueness to your application. Simply ensure that custom text styles remain consistent and coordinate consistently with the overall application plan.

I want to believe that I can push you to work with textual styles and texts. They are an important piece of daily improvement work. Now we should understand how they are used in SwiftUI.

How to style text font in SwiftUI

Text is a view that displays at least one line of text in SwiftUI.

Text("Hello, world!")

We can replace this default text style with a custom one. We can set a custom text style for a text view using the font(_:) modifier.

We should investigate various ways to modify a text in SwiftUI.

Text style is a way of communicating a text style with respect to its capability.

For example, if you need to set a text style for your view’s title text, you can set it to title text style without determining the dimension of the text. Apple does the difficult work of characterizing the ideal size for each text style.

Adopting text styling allows you to exploit dynamic sorting where your text consequently resizes, tracks and drives in view of the customer’s inclination.

Apple has 11 text styles right now: largeTitle, title, title2, title3, headline, body, callout, subheadline, footnote, caption, and caption2.

Text("Swift Programming")
                .font(.largeTitle)
            Text("Swift Programming")
                .font(.title)
            Text("Swift Programming")
                .font(.title2)
            Text("Swift Programming")
                .font(.title3)
            Text("Swift Programming")
                .font(.headline)
            Text("Swift Programming")
                .font(.body)
            Text("Swift Programming")
                .font(.callout)
            Text("Swift Programming")
                .font(.subheadline)
            Text("Swift Programming")
                .font(.footnote)
            Text("Swift Programming")
                .font(.caption)
            Text("Swift Programming")
                .font(.caption2)

Compiled in XCode

How to change text size in SwiftUI

We have four font designs to choose from:

default
monospaced
rounded
serif

We can configure it at the time we create a font.

If you want to customize the font design of a text style, you can set it like this:

Text("Hello, world!")
    .font(.system(.largeTitle, design: .serif))

Compiled in XCode

How to change font weight in SwiftUI

We can use the modifier weight(_:). This is a font instance method, because we use this in our font, not in a text.

We can use heavy, light or bold.

For example in:

     Text("Swift programming")
                .font(.largeTitle)
            Text("Swift programming")
                .font(
                    .largeTitle
                    .weight(.bold)

                )
            Text("Swift programming")
                .font(
                    .system(
                        .largeTitle,
                        design: .rounded
                    )
                    .weight(.light)

                )
            Text("Swift programming")
                .font(
                    .system(size: 34)
                    .weight(.heavy)

                )

In XCode

You can also use .weight in a custom font, but not all weights may be available in that font. The closest weight will be used as an alternative if the specification cannot be met.

Set the font weight with the Font initializer

You can set it when you initialize a custom system font. For example:

Text("Swift programming")
    .font(
        .system(size: 31, weight: .bold)
    )

Change the font weight with the fontWeight(_:) modifier

The text view also has a way to modify the font weight. You can set it with the fontWeight(_:) modifier.

Since it is a text instance method, we use it on a text, not a font.

Text("Swift programming")
    .font(
        .system(size: 31)
    )
    .fontWeight(.bold)

Change font weight with bold() modifier

The font and text view also has another method for applying a bold font weight to text, bold().

Text("Swift programming")
    .font(
        .system(size: 31)
    )
    .bold()

Tab bars are created in SwiftUI using the TabView container view and consist of a variety of child views that represent the screens that the user will navigate through in the tab bar.

A tab bar allows people to navigate between different areas of an app, such as the Alarm, Stopwatch, and Timer tabs in the Clock app. If you need to provide controls that act on elements of the current view, use a tab bar.

Make sure the tab bar is visible when people navigate to different areas of your app.

By default, TabView presents a tab bar at the bottom of the layout that contains the tab elements used to navigate between child views.

A tab element is applied to each content view using a modifier and can be customized to contain text and image views (other view types do not support tab elements).

The currently selected tab can also be controlled programmatically by adding tags to the tab elements.

Putting tabs in a TabView is as easy as using:

TabView {
    Text("Tab 1")
    Text("Tab 2")
}

Use tabItem(_:) to set a view as a tab bar item in TabView. I use Label as the content of a tab element that allows me to define the title and image.

So our code would look like this:

struct ContentView: View {
    var body: some View {
        TabView {
            Text("Home")
                .tabItem {

                    Label("Home", systemImage: "house")
                }
            Text("Search")
                .tabItem {

                    Label("Sun", systemImage: "sun.max")
                }
            Text("Location")
                .tabItem {

                    Label("Location", systemImage: "location")
                }
            Text("Settings")
                .tabItem {

                    Label("Settings", systemImage: "gearshape")
                }
        }
    }
}

Our app would look like this:

TabView can show a maximum of 5 tab items, so if we put more than five items, we can change the last item to “More…”, selecting the “More…” tab will present a list of all the missing items.

Due to the limited space on an iPhone screen, a TabView can only display a maximum of 5 tabs simultaneously on an iPhone with iOS as the operating system and 7 tabs on an iPad with iPadOS as the operating system.

This is how our code would look with more than 5 tabs, I am going to create an app with 8 tabs.

This would be the source code:

struct ContentView: View {
    var body: some View {
        TabView {
            Text("Home")
                .tabItem {

                    Label("Home", systemImage: "house")
                }
            Text("Search")
                .tabItem {

                    Label("Sun", systemImage: "sun.max")
                }
            Text("Notification")
                .tabItem {

                    Label("Notification", systemImage: "bell")
                }
            Text("Notification")
                .tabItem {

                    Label("Keyboard", systemImage: "keyboard")
                }
            Text("Printer")
                .tabItem {

                    Label("Printer", systemImage: "printer")
                }
            Text("Display")
                .tabItem {

                    Label("Display", systemImage: "display")
                }
            Text("Iphone")
                .tabItem {

                    Label("Iphone", systemImage: "iphone")
                }
       
        }
    }
}

And this would be the result in XCode:

If we select an extra tab, our view will be a navigation stack.

Creating tabs is as easy as putting different views inside a TabView instance, but to add an image and text to each view’s tab bar item we need to use the tabItem() modifier

So a tabView is a special view that switches between multiple child views using Element UI.

These UI elements are the tabItem.

To create a tabbed UI, we need to place the views in a TabView and apply the top element modifier.

How to add a SwiftUIView in a tab bar in XCode

To work and have everything well organized, it is advisable to have the views separated in different files in order to work better.

What we are going to do next is add a view to our project in XCode.

In our project we use the right button to add a new file to our project and select New File.

Next we are going to select a SwiftUI View and click Next, as you can see in the image

Once selected, a window like the one in the image will open in which we have to put the name of our file, we will name it SettingsView.swift

Our files will look like this:

The SettingsView.swift file has the following swift code:

import SwiftUI

struct SettingsView: View {
    var body: some View {
        Text(/*@START_MENU_TOKEN@*/"Hello, World!"/*@END_MENU_TOKEN@*/)
    }
}

#Preview {
    SettingsView()
}

So we are going to add this view in our ContenView.swift as follows:

SettingsView()

Our ContentView.swift file will look like this:

struct ContentView: View {
    var body: some View {
        TabView {
            Text("Home")
                .tabItem {

                    Label("Home", systemImage: "house")
                }
            SettingsView()
                .tabItem {
                   
                    Label("Settings", systemImage: "gearshape")
                }
            Text("Notification")
                .tabItem {

                    Label("Notification", systemImage: "bell")
                }
            Text("Notification")
                .tabItem {

                    Label("Keyboard", systemImage: "keyboard")
                }
            Text("Printer")
                .tabItem {

                    Label("Printer", systemImage: "printer")
                }
            Text("Display")
                .tabItem {

                    Label("Display", systemImage: "display")
                }
            Text("Iphone")
                .tabItem {

                    Label("Iphone", systemImage: "iphone")
                }
       
        }
    }
}

So the second tab of this tab bar (“Settings”) will target the SettingsView.swift file that we have added to our project in XCode, as you can see in the following image:

Summary of what you have learned

In this article you have learned:

-What is a tab bar

-To create a tab bar user interface, you just have to place the views in a TabView and apply the tabItem(_:) modifier to the content of each tab.

-Add views from a SwiftUI View file to a tab bar