SwiftUI

ContentView

import SwiftUI

struct ContentView: View {
    var body: some View {
        VStack(alignment: .leading) {
            Text("Turtle Rock")
                .font(.title)
            HStack {
                Text("Joshua Tree National Park")
                    .font(.subheadline)
                Spacer()
                Text("California")
                    .font(.subheadline)
            }
        }
        .padding()
    }
}

struct ContentView_Preview: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}

ContextMenu

Text("Rails").contextMenu {
    Button(action: {}){
        Text("LRT")
        Image(systemName: "globe")
    }
    Button(action: {}){
        Text("MRT")
        Image(systemName: "location.circle")
    }
}

MyPDFView

// MARK: - MyPDFView
fileprivate struct MyPDFView: UIViewRepresentable {
    @Binding var data: Data

    func makeUIView(context: UIViewRepresentableContext<MyPDFView>) -> UIView {
        let empty = UIView()
      //guard let provider = CGDataProvider(data: self.data as CFData) else {return empty}
      //guard let document = CGPDFDocument(provider) else {return empty}
        guard let url = URL(string: "https://api.chorke.org/academia/api/v1.0/health/card/01890600.pdf") else {return empty}
        guard let document = CGPDFDocument(url as CFURL) else {return empty}
        guard let page     = document.page(at: 1) else {return empty}
        let pageRect = page.getBoxRect(.mediaBox)
        let renderer = UIGraphicsImageRenderer(size: pageRect.size)
        let uiImage  = renderer.image { ctx in
            UIColor.white.set()
            ctx.fill(pageRect)
            ctx.cgContext.translateBy(x: 0.0, y: pageRect.size.height)
            ctx.cgContext.scaleBy(x: 1.0, y: -1.0)
            ctx.cgContext.drawPDFPage(page)
        }
        let view = UIImageView(image: uiImage)
        view.contentMode = .scaleAspectFill
        return view
    }

    func updateUIView(_ view: UIView, context: UIViewRepresentableContext<MyPDFView>) {
        // MARK: - TODO
    }
}

MyKDCalendar

MyKDCalendar().frame(minWidth: 200, minHeight: 350).background(ThemeColor.midnightBlue.color.opacity(0.5)).padding(.bottom, 20)

import SwiftUI
import KDCalendar

public struct MyKDCalendar: UIViewRepresentable {
    @State var date:Date = .init()
    let gregorian: Calendar = .init(identifier: .gregorian)
    let secondary: UIColor = .parse(0xE0B355)
    let tersiary : UIColor = .parse(0xE7EEEF)
    let primary  : UIColor = .parse(0x346C7C)
    
    public func makeUIView(context: Context) -> CalendarView {
        let style = self.getStyle(self.primary, self.secondary, self.tersiary)
        let calendar: CalendarView = .init()
        calendar.direction = .horizontal
        calendar.marksWeekends = true
        calendar.style = style
        
        calendar.setDisplayDate(date, animated: true)
        calendar.selectDate(date)
        calendar.dataSource = self
        calendar.delegate = self
        return calendar
    }
    
    public func updateUIView(_ calendar: CalendarView, context: Context) {
        calendar.selectDate(date)
    }
}

extension MyKDCalendar: CalendarViewDataSource {
    public func startDate() -> Date {
        return Date.init()
    }
    
    public func endDate() -> Date {
        return self.gregorian.date(byAdding: .month, value: 3, to: Date.init())!
    }
    
    public func headerString(_ date: Date) -> String? {
        return nil
    }
    
    private func getStyle(_ primary: UIColor, _ secondary: UIColor, _ tersiary: UIColor) -> CalendarView.Style {
        let style: CalendarView.Style = .init()
        style.cellSelectedBorderColor = secondary
        style.cellSelectedTextColor = tersiary
        style.cellSelectedColor = secondary
        style.firstWeekday = .sunday
        
        style.weekdaysBackgroundColor = primary
        style.headerBackgroundColor = primary
        style.weekdaysTextColor = tersiary
        style.headerTextColor = tersiary
        
        style.cellTextColorWeekend = secondary
        style.cellTextColorDefault = primary
        style.cellTextColorToday = tersiary
        
        style.cellColorOutOfRange = .systemGray
        style.cellColorDefault = tersiary
        style.cellColorToday = primary
        return style
    }
}

extension MyKDCalendar: CalendarViewDelegate {
    public func calendar(_ calendar: CalendarView, didDeselectDate date: Date) {}
    public func calendar(_ calendar: CalendarView, didScrollToMonth date: Date) {}
    public func calendar(_ calendar: CalendarView, didSelectDate date: Date, withEvents events: [CalendarEvent]) {}
    public func calendar(_ calendar: CalendarView, didLongPressDate date: Date, withEvents events: [CalendarEvent]?) {}
    public func calendar(_ calendar: CalendarView, canSelectDate date: Date) -> Bool {
        return true
    }
}

MyFSCalendar

MyFSCalendar().frame(minWidth: 200, minHeight: 320).padding(.leading, 5)

import SwiftUI
import FSCalendar

struct MyFSCalendar: UIViewControllerRepresentable {
    func makeUIViewController(context: UIViewControllerRepresentableContext<MyFSCalendar>) -> MyFSCalendarController {
        let calendar: MyFSCalendarController = .init()
        return calendar
    }

    func updateUIViewController(_ calendar: MyFSCalendarController, context: UIViewControllerRepresentableContext<MyFSCalendar>) {
        // MARK: - TODO
    }
}

import UIKit
import FSCalendar

class MyFSCalendarController: UIViewController, FSCalendarDelegateAppearance {
    let secondary: UIColor = .parse(0xE0B355)
    let tersiary : UIColor = .parse(0xE7EEEF)
    let primary  : UIColor = .parse(0x346C7C)
    
    fileprivate let formatter: DateFormatter = {
        let formatter = DateFormatter()
        formatter.dateFormat = "yyyy-MM-dd"
        return formatter
    }()
    
    fileprivate weak var calendar: FSCalendar!
    
    override func loadView() {
        let width: CGFloat = UIScreen.main.bounds.width - 40
        let frame: CGRect  = .init(x: 0, y: 0, width: width, height: 300)
        let view:  UIView  = .init(frame: frame)
        self.view = view
        
        let calendar: FSCalendar = .init(frame: frame)
        calendar.allowsMultipleSelection = false
        calendar.dataSource = self
        calendar.delegate = self
        
        view.addSubview(calendar)
        self.calendar = calendar
        
        calendar.calendarHeaderView.backgroundColor = self.primary
        calendar.calendarWeekdayView.backgroundColor = self.primary
        calendar.appearance.headerTitleColor = self.tersiary
        calendar.appearance.weekdayTextColor = self.tersiary
        
        calendar.appearance.eventSelectionColor = self.tersiary
        calendar.appearance.eventDefaultColor = self.primary
        calendar.appearance.eventOffset = CGPoint(x: 0, y: -7)
        
        calendar.appearance.todaySelectionColor = self.primary
        calendar.appearance.selectionColor = self.secondary
        calendar.appearance.todayColor = self.primary
        
        calendar.appearance.titleWeekendColor = self.secondary
        calendar.appearance.titleDefaultColor = self.primary

        calendar.swipeToChooseGesture.isEnabled = true
        let scopeGesture = UIPanGestureRecognizer(target: calendar, action: #selector(calendar.handleScopeGesture(_:)));
        scopeGesture.delegate = self
        calendar.addGestureRecognizer(scopeGesture)
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        self.calendar.scope = .month
        self.calendar.select(Date.init())
        self.calendar.accessibilityIdentifier = "calendar"
    }
}

extension MyFSCalendarController: FSCalendarDataSource {
    func calendar(_ calendar: FSCalendar, didSelect date: Date, at monthPosition: FSCalendarMonthPosition) {
        debugPrint("did select date \(self.formatter.string(from: date))")
        let selectedDates = calendar.selectedDates.map({self.formatter.string(from: $0)})
        debugPrint("selected dates is \(selectedDates)")
        if monthPosition == .next || monthPosition == .previous {
            calendar.setCurrentPage(date, animated: true)
        }
    }
}

extension MyFSCalendarController: FSCalendarDelegate {
    func calendar(_ calendar: FSCalendar, boundingRectWillChange bounds: CGRect, animated: Bool) {
        self.calendar.frame.size.height = bounds.height
        self.view.layoutIfNeeded()
    }
}

extension MyFSCalendarController: UIGestureRecognizerDelegate {
    func gestureRecognizerShouldBegin(_ gestureRecognizer: UIGestureRecognizer) -> Bool {
        debugPrint("UIGestureRecognizer")
        return true
    }
}

Singleton

class NetworkManager {
    let baseURL: URL

    private init(baseURL: URL) {
        self.baseURL = baseURL
    }

    // MARK: - sharedNetworkManager
    private static var sharedNetworkManager: NetworkManager = {
        let networkManager = NetworkManager(baseURL: API.baseURL)
        return networkManager
    }()

    // MARK: - shared
    class func shared() -> NetworkManager {
        return Self.sharedNetworkManager
    }
}

State Variable

import SwiftUI

struct StateInitView: View {
    @State var isBusy: Bool = false
    var title: String
    
    init(_ title: String,_ isBusy: Bool = false) {
        self._isBusy = State(initialValue: isBusy)
        self.title = title
    }

    var body: some View {
        ZStack {
            if (self.isBusy){
                Text("Baking your cake!")
            } else {
                Text("Collect your cake.")
            }
        }
    }
}

Binding Variable

struct MyCheckGroup: View {
    @Binding var group : [ResourceLabel]
    var action: ((ResourceLabel) -> Void)? = nil
    
    var body: some View {
        HStack(alignment: .top, spacing: 20) {
            ForEach(Array(self.group.enumerated()), id: \.offset) { index, model in
                MyCheckBox(model: .constant(model), action: self.action)
            }
        }
    }
}

struct MyCheckBox: View {
    @Binding var model: ResourceLabel
    var action: ((ResourceLabel) -> Void)? = nil
    
    var body: some View {
        //TODO
    }
}

For Each

Id: ForEach(self.labels, id: \.id) { label in AccordionItem(label: label){ label in self.addAccordionView(label) } }

Offset: ForEach(Array(self.labels.enumerated()), id: \.offset) { index, label in AccordionItem(label: label){ label in self.addAccordionView(label) } }

References

Add Animations to Individual Views Composing Complex Interfaces Creating and Combining Views Building Lists and Navigation Drawing Paths and Shapes Working with UI Controls Creating a watchOS App Interfacing with UIKit Handling User Input SwiftUI Essentials

NavigationView without NavigationButton Add a bottom line on TextField Find Images by System Name Image Size and Resolution Apple Design Resources Pop Up View YouTube Navigation Drawer Launch Screen System Icons SF Symbols

Change the background color of a View Why does \.self work for ForEach? Create view using ForEach {H|V}Stack height width HStack Center Alignment Creating views in a loop SwiftUI Layout System SwiftUI Buttons Styles SwiftUI Divider Styles Floating Button

State Management Corrections @ObservedObject Property Wrappers Status Bar Color Navigation Link @Published Custom Style Toggle Style @Binding Grid View

---

UIHostingController inside an UIView Using the PreferenceKey Protocol Splash Screen With SwiftUI Add a SwiftUI View to UIKit SwiftUI Preferences SwiftUI Example Context Menu Radio Group CheckBox Tool Tips

Place View outside of the Safe Area SwiftUI Round Specific Corners Activity indicator in SwiftUI iPhone/iPad Device Model Programmatic Navigation Add a TextField to Alert TextField Font Weight SwiftUI Cheat Sheet Blur a background Return Key

SwiftUI View as a variable to another View Dynamic List of Views using SwiftUI Generic type conforms to Protocol Finding the custom URL scheme Loading Data Asynchronously @State variable initialization Passing data between Views POST Request Example URL Scheme Extension Alternative to switch

---

@ObservedObject, @State vs. @EnvironmentObject Set environment variable CG_PDF_VERBOSE Wrapping a UIViewController in a SwiftUI Error: Multiple commands produce Asynchronous vs Synchronous Identifiable items in SwiftUI Convert String to Double Alamofire Synchronous Adjust alpha of UIColor KDCalendar

After Delay asyncAfter() and perform() Cleaner Asynchronous Code Using Promise Dynamic View width of another View Get Current Location using SwiftUI Picker Selection by using Tag Singleton Object In Swift Postmortem of SwiftUI Padding a Swift String Promises in Swift SwiftUI Form

---

JSONDecoder use a default value instead of Optional Bind a grid of buttons of same width and height Inspecting the View Tree by PreferenceKey Triggering events repeatedly using a Timer Deprecation of keyWindow in iOS 13.0 Bind the view the size of another view GeometryReader to the Rescue Same Width Views in List Rows How to change ListStyle in List SwiftUI @Binding Initialise

Play audio using AVAudioPlayer in SwiftUI Automatically Merge XCode Project Play sound when press a button Audio not playing in SwiftUI WebKit WebView in SwiftUI Play MP3 Audio from URL