SwiftUI में एक नया दृश्य प्रस्तुत करें

Question

मैं एक बटन पर क्लिक करना चाहता हूं और फिर present modallyUIKit में एक नया दृश्य प्रस्तुत करना चाहता हूं

मैंने पहले ही " शीट्स का उपयोग करके एक नया दृश्य कैसे प्रस्तुत करें " देखा है , लेकिन मैं इसे एक मुख्य शीट के रूप में मुख्य दृश्य के साथ संलग्न नहीं करना चाहता।

और मैं उपयोग नहीं करना चाहता NavigationLink, क्योंकि मैं एक नया दृश्य नहीं चाहता और पुराने दृश्य का नेविगेशन संबंध है।

आपकी सहायता के लिए धन्यवाद...

Comments

आप इसे एक मुख्य पत्रक के रूप में मुख्य दृश्य के साथ संलग्न क्यों नहीं करना चाहते हैं? यह एक मानक विधि भी है UIKit। क्या आपके पास कोई विशेष कारण है?

— मोजताबा होसेनी

मैं अपने विचारों को समझाने की कोशिश करता हूं ... अगर कुछ गलत है, तो कृपया मुझे सुधारें।

— सीएच विंग

ऐप्स में 3 दृश्य, 1: लॉगिन पृष्ठ 2: तालिका दृश्य 3: तालिका दृश्य पृष्ठ, तालिका दृश्य पृष्ठ और तालिका दृश्य पृष्ठ नेविगेशन संबंध है। लॉगिन करने के बाद टेबल व्यू पेज पर पेश किया जाएगा, टेबल व्यू पेज पर लॉगिन के बाद लॉगिन पेज के साथ कोई संबंध नहीं है

— सीएच विंग

तो आपको fullscreenसही होने की आवश्यकता है ?

— मोजताबा होसेनी

वाईएस! मैं चाहता हूँfullscreen

— सीएच विंग 8

Answer 1

एक मोडल दिखाने के लिए (iOS 13 स्टाइल)

आपको बस sheetखुद को खारिज करने की क्षमता के साथ एक सरल की आवश्यकता है:

struct ModalView: View {
    @Binding var presentedAsModal: Bool
    var body: some View {
        Button("dismiss") { self.presentedAsModal = false }
    }
}

और इसे इस तरह प्रस्तुत करें:

struct ContentView: View {
    @State var presentingModal = false

    var body: some View {
        Button("Present") { self.presentingModal = true }
        .sheet(isPresented: $presentingModal) { ModalView(presentedAsModal: self.$presentingModal) }
    }
}

_{ध्यान दें कि मैंने presentingModalमोडल को पारित कर दिया है ताकि आप इसे स्वयं मोडल से खारिज कर सकें, लेकिन आप इससे छुटकारा पा सकते हैं।}

---

वास्तव में इसे प्रस्तुत करने के लिए fullscreen(न केवल नेत्रहीन)

आप तक पहुँचने की जरूरत है ViewController। तो आपको कुछ सहायक कंटेनरों और पर्यावरण सामग्री की आवश्यकता है:

struct ViewControllerHolder {
    weak var value: UIViewController?
}

struct ViewControllerKey: EnvironmentKey {
    static var defaultValue: ViewControllerHolder {
        return ViewControllerHolder(value: UIApplication.shared.windows.first?.rootViewController)

    }
}

extension EnvironmentValues {
    var viewController: UIViewController? {
        get { return self[ViewControllerKey.self].value }
        set { self[ViewControllerKey.self].value = newValue }
    }
}

फिर आपको इस एक्सटेंशन को लागू करने का उपयोग करना चाहिए:

extension UIViewController {
    func present<Content: View>(style: UIModalPresentationStyle = .automatic, @ViewBuilder builder: () -> Content) {
        let toPresent = UIHostingController(rootView: AnyView(EmptyView()))
        toPresent.modalPresentationStyle = style
        toPresent.rootView = AnyView(
            builder()
                .environment(\.viewController, toPresent)
        )
        self.present(toPresent, animated: true, completion: nil)
    }
}

आखिरकार

आप इसे बना सकते हैं fullscreen:

struct ContentView: View {
    @Environment(\.viewController) private var viewControllerHolder: UIViewController?

    var body: some View {
        Button("Login") {
            self.viewControllerHolder?.present(style: .fullScreen) {
                Text("Main") // Or any other view you like
            }
        }
    }
}

Comments

महान! आपके विस्तृत समाधान के लिए धन्यवाद

— CH विंग

मुझे पर्यावरण संपत्ति आवरण में यह त्रुटि मिलती है: निर्दिष्ट 'UIViewController' प्रकार के पर्यावरण 'UIViewController>' का मान परिवर्तित नहीं किया जा सकता है

— jsbeginnerNodeJS

इसे डिफ़ॉल्ट रूप से नियंत्रित किया जाना चाहिए, लेकिन ?वहां लाइन के अंत में जोड़ने का प्रयास करें । @jsbeginnerNodeJS

— Mojtaba Hosseini

जिसका दृश्य खिड़की पदानुक्रम में नहीं है `` `मैं कंसोल में इस त्रुटि मिलती है:` `` चेतावनी: वर्तमान <_TtGC7SwiftUI19UIHostingControllerVS_7AnyView_: 0x7fafd2641d30> करने का प्रयास पर <0x7fafd2611bd0 _TtGC7SwiftUI19UIHostingControllerVS_7AnyView_>!

— jsbeginnerNodeJS

आप इसे कैसे खारिज करते हैं?

— गैब्रिएलपिटरी

Answer 2

यहाँ एक आसान तरीका है - आगे के दृश्य। यह बहुत सीधा है।

        struct ChildView: View{
           private  let colors: [Color] = [.red, .yellow,.green,.white]
           @Binding var index : Int
           var body: some View {
           let next = (self.index+1)  % MyContainer.totalChildren
             return   ZStack{
                    colors[self.index  % colors.count]
                     Button("myNextView \(next)   ", action: {
                    withAnimation{
                        self.index = next
                    }
                    }
                )}.transition(.asymmetric(insertion: .move(edge: .trailing)  , removal:  .move(edge: .leading)  ))
            }
        }

        struct MyContainer: View {
            static var totalChildren = 10
            @State private var value: Int = 0
            var body: some View {
                    HStack{
                        ForEach(0..<(Self.totalChildren) ) { index in
                            Group{
                            if    index == self.value {
                                ChildView(index:  self.$value)
                                }}
                            }
                }
                }
        }

Answer 3

डिस्क्लेमर: नीचे वास्तव में "देशी मोडल" जैसा नहीं है, न तो व्यवहार करें और न ही देखें और महसूस करें, लेकिन अगर किसी को दूसरे पर एक दृश्य के कस्टम संक्रमण की आवश्यकता होगी, तो केवल शीर्ष एक को सक्रिय करना, निम्नलिखित दृष्टिकोण सहायक हो सकता है।

तो, अगर आप निम्नलिखित की तरह कुछ उम्मीद करते हैं

यहां डेमो के लिए एक सरल कोड है दृष्टिकोण (शाप एनीमेशन और संक्रमण मापदंडों की इच्छा से बदला जा सकता है)

struct ModalView : View {
    @Binding var activeModal: Bool
    var body : some View {
        VStack {
            Button(action: {
                withAnimation(.easeInOut(duration: 0.3)) {
                    self.activeModal = false
                }
            }) {
                Text("Hide modal")
            }
            Text("Modal View")
        }
        .frame(minWidth: 0, maxWidth: .infinity, minHeight: 0, maxHeight: .infinity, alignment: .center)
        .background(Color.green)
    }
}

struct MainView : View {
    @Binding var activeModal: Bool
    var body : some View {
        VStack {
            Button(action: {
                withAnimation(.easeInOut(duration: 0.3)) {
                    self.activeModal = true
                }
            }) {
                Text("Show modal")
            }
            Text("Main View")
        }
        .frame(minWidth: 0, maxWidth: .infinity, minHeight: 0, maxHeight: .infinity, alignment: .center)
        .background(Color.yellow)
    }
}

struct ModalContainer: View {
    @State var showingModal = false
    var body: some View {
        ZStack {
            MainView(activeModal: $showingModal)
                .allowsHitTesting(!showingModal)
            if showingModal {
                ModalView(activeModal: $showingModal)
                    .transition(.move(edge: .bottom))
                    .zIndex(1)
            }
        }
    }
}