Uncategorized

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

@main
struct MyNewStruct : App {
  var body: some Scene {
     WindowGroup {
       ContentView()
   }
  }
}

Xcode 12 shipped with Swift 5.3 which introduced the @main attribute.The @main attribute means this structure contains the entry point for the app. The App protocol takes care of generating the static main function that actually runs. When the app start, it displays this instance of ContentView, which is defined in the ContentView file. It’s a struct that conforms to the View protocol.

fsfdsfd
dsfsfsffsfafasa
fdsafsffasafsfsaf
fasdfsffdssfasfsf

hola

https://swiftprogramming.com/21-2/

Welcome to WordPress. This is your first post. Edit or delete it, then start writing!