```swift
import SwiftUI

enum ActiveAlert {

    case first, second

}

struct ContentView : View{

    var body : some View {

        NavigationView{

            VStack{

        NavigationLink(destination: BPView()) {

            Text("Format British Parliamentary")

                .foregroundColor(Color.blue);

        }

            NavigationLink(destination:cpView()) {

                Text("Format Canadien Parlementaire")

                .foregroundColor(Color.blue);

            }

            }}
    }

}
struct cpView: View {
    init(){
        debatCP = CP(modePM: $repartitionPM, modeCO:$repartitionCO)
    }
    var body: some View {
                VStack{
                    Button(action: {
                        self.showAlert(.first)
                        if self.enCours != "Recommencer"{
                            let chrono = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { (chrono) in 

/*
things happening here */
                            }
                                if self.debatCP.returnRound() <= 0 {
                                    self.enCours = "Canadien Parlementaire - Commencer"
                                    self.debatCP.reset();
                                    chrono.invalidate();
                 self.presentationMode.wrappedValue.dismiss()
                            }
                            else{
                                self.enCours = "Recommencer"
                            }
                        }
                        }
                        else{
                       /* ... */
                        }
                        self.mode = "CP"
                    }, label: {
                        Text(enCours)
                            .alert(isPresented: $showingAlert) {
                        /* ... */ }
                    Text(tempsString).font(.system(size:75))
                    HStack{
                        Button(action: {
                              self.debatCP.tourPrecdedent()
                        }, label: {
                            Image("backwards").renderingMode(.original)
                        })
                        Button(action: {

                            /* ... */

                            }
                        }) {
                   Image(self.pausePlay).renderingMode(.original)
                        }
                        Button(action: {
                                self.debatCP.prochainTour()
                        }, label: {
                            Image("forward").renderingMode(.original)
                        } )
                    }
}
    }
    func showAlert(_ active: ActiveAlert) -> Void {
          DispatchQueue.global().async {
              self.activeAlert = active
              self.showingAlert = true
          }
    }
}
struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
}
struct BPView :View {
    init(){
        debatBP = BP();
    }
    var body : some View {
        VStack{
            Button(action: {
                if self.enCours != "Recommencer"{
                    let chrono = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { (chrono) in
                       /* stuff going on */
                        if self.debatBP.returnRound() <= 0 {
                                               self.enCours = "BP - Commencer"
                                               chrono.invalidate()
                                               self.debatBP.reset();
                 self.presentationMode.wrappedValue.dismiss()
                                                                      }
                    }
                }
                else{
                  /* ... */
                }
                self.enCours = "Recommencer"
                self.mode = "BP"
            }, label: {Text(enCours)})
            Text(tempsString).font(.system(size:75))
            HStack{
                                    Button(action: {
                                          self.debatBP.tourPrecdedent()
                                    }, label: {
          Image("backwards").renderingMode(.original)
                                    })
                                    Button(action: {
                                        switch (self.pausePlay) {
                                        case "play" :
                                            self.pausePlay = "pause"
                                            break
                                        case "pause" :
                                            self.pausePlay = "play"
                                            break
                                        default:
                                            self.pausePlay = "Erreur"
                                        }
                                    }) {
         Image(self.pausePlay).renderingMode(.original)
                                    }
                                    Button(action: {
                                            self.debatBP.prochainTour()
                                    }, label: {
                                 Image("forward").renderingMode(.original)
                                    } )
                                }
            }
        }
}```