taler-ios

Buttons.swift (16269B)

---

 /*
  * This file is part of GNU Taler, ©2022-26 Taler Systems S.A.
  * See LICENSE.md
  */
 /**
  * @author Marc Stibane
  */
 import SwiftUI
 import Foundation
 import AVFoundation
 
 extension ShapeStyle where Self == Color {
     static var random: Color {
         Color(
             red: .random(in: 0...1),
             green: .random(in: 0...1),
             blue: .random(in: 0...1)
         )
     }
 }
 
 struct HamburgerButton : View  {
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             Image(systemName: HAMBURGER)
 //            Image(systemName: "sidebar.squares.leading")      // 􀱦
         }
         .talerFont(.title)
         .accessibilityLabel(Text("Main Menu", comment: "a11y"))
         .accessibilityIdentifier(A11yID.hamburgerButton)
     }
 }
 
 struct LinkButton: View {
     let destination: URL
     let hintTitle: String
     let buttonTitle: String
     let a11yHint: String
     let badge: String
 
     @AppStorage("minimalistic") var minimalistic: Bool = false
 
     var body: some View {
         VStack(alignment: .leading) {
             if !minimalistic {      // show hint that the user should authorize on bank website
                 Text(hintTitle)
                     .fixedSize(horizontal: false, vertical: true)       // wrap in scrollview
                     .multilineTextAlignment(.leading)                   // otherwise
                     .listRowSeparator(.hidden)
             }
             Link(destination: destination) {
                 HStack(spacing: 8.0) {
                     Image(systemName: LINK)
                     Text(buttonTitle)
                 }
             }
             .buttonStyle(TalerButtonStyle(type: .prominent, badge: badge))
             .accessibilityHint(a11yHint)
         }
     }
 }
 
 struct QRButton : View  {
     let hideTitle: Bool
     let action: () -> Void
 
     @AppStorage("minimalistic") var minimalistic: Bool = false
     @State private var showCameraAlert: Bool = false
 
     private var openSettingsButton: some View {
         Button("Open Settings") {
             showCameraAlert = false
             UIApplication.shared.open(URL(string: UIApplication.openSettingsURLString)!)
         }
     }
     let closingAnnouncement = String(localized: "Closing Camera", comment: "a11y")
 
     var defaultPriorityAnnouncement = String(localized: "Opening Camera", comment: "a11y")
 
     var highPriorityAnnouncement: AttributedString {
         var highPriorityString = AttributedString(localized: "Camera Active", comment: "a11y")
         if #available(iOS 17.0, *) {
             highPriorityString.accessibilitySpeechAnnouncementPriority = .high
         }
         return highPriorityString
     }
     @MainActor
     private func checkCameraAvailable() -> Void {
         // Open Camera when QR-Button was tapped
         announce(defaultPriorityAnnouncement)
 
         AVCaptureDevice.requestAccess(for: .video, completionHandler: { (granted: Bool) -> Void in
             if granted {
                 action()
                 if #available(iOS 17.0, *) {
                     AccessibilityNotification.Announcement(highPriorityAnnouncement).post()
                 } else {
                     let cameraActive = String(localized: "Camera Active", comment: "a11y")
                     announce(cameraActive)
                 }
             } else {
                 showCameraAlert = true
             }
         })
     }
 
     var body: some View {
         let dismissAlertButton = Button("Cancel", role: .cancel) {
             announce(closingAnnouncement)
             showCameraAlert = false
         }
         let scanText = String(localized: "Scan QR code", comment: "Button title, a11y")
         let qrImage = Image(systemName: QRBUTTON)
         let qrText = Text(qrImage)
         Button(action: checkCameraAvailable) {
             if hideTitle {
                 qrImage
                     .resizable()
                     .scaledToFit()
                     .foregroundStyle(WalletColors().primaryAccent)
             } else if minimalistic {
                 let width = UIScreen.screenWidth / 7
                 qrText.talerFont(.largeTitle)
                     .padding(.horizontal, width)
             } else {
                 HStack(spacing: 16) {
                     qrText.talerFont(.title)
                     Text(scanText)
                 }.padding(.horizontal)
             }
         }
         .accessibilityLabel(scanText)
         .accessibilityIdentifier(A11yID.qrButton)
         .alert("Scanning QR-codes requires access to the camera",
                isPresented: $showCameraAlert,
                    actions: {   openSettingsButton
                                 dismissAlertButton },
                    message: {   Text("Please allow camera access in Settings.") }) // Scanning QR-codes
     }
 }
 
 struct DoneButton : View  {
     let titleStr: String?
     let accessibilityLabelStr: String
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             if let titleStr {
                 Text(titleStr)
             } else {
                 Image(systemName: CHECKMARK)    // 􀆅
             }
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.title)
         .accessibilityLabel(accessibilityLabelStr)
         .accessibilityIdentifier(A11yID.doneButton)
     }
 }
 
 struct PlusButton : View  {
     let accessibilityLabelStr: String
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             Image(systemName: PLUS)
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.title)
         .accessibilityLabel(accessibilityLabelStr)
         .accessibilityIdentifier(A11yID.plusButton)
     }
 }
 
 struct MoreButton : View  {
     let accessibilityLabelStr: String
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             Image(systemName: MORE)
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.title)
         .accessibilityLabel(accessibilityLabelStr)
         .accessibilityIdentifier(A11yID.moreButton)
     }
 }
 
 @available(iOS 26.0, *)
 struct SettingsButton26 : View  {
     let sortPriority: Double
 
     var body: some View {
         Button {
             // will trigger NavigationLink
             NotificationCenter.default.post(name: .SettingsAction, object: nil)
         } label: {
             Label(TalerTab.settings.title, systemImage: TalerTab.settings.sysImg)
                 .labelStyle(.iconOnly)
         }
 //        .padding()
         .buttonStyle(.glass)
         .accessibilitySortPriority(sortPriority)
     }
 }
 
 struct SettingsButton : View  {
     let accessibilityLabelStr: String
     let action: () -> Void
 
     var body: some View {
         let button = Button(action: action) {
             Image(systemName: SETTINGS)
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.title)
         .accessibilityLabel(accessibilityLabelStr)
         .accessibilityIdentifier(A11yID.settingsButton)
 //        if #available(iOS 26.0, *) {
 //            return button.buttonStyle(.glass)
 //        }
         return button
     }
 }
 struct TalerPasteButton : View  {
     let accessibilityLabelStr: String
     let action: () -> Void
 
     var body: some View {
         let button = Button(action: action) {
             Image(systemName: PASTE)
         }
             .tint(WalletColors().primaryAccent)
             .talerFont(.title)
             .accessibilityLabel(accessibilityLabelStr)
             .accessibilityIdentifier(A11yID.pasteButton)
 //        if #available(iOS 26.0, *) {
 //            return button.buttonStyle(.glass)
 //        }
         return button
     }
 }
 
 struct ZoomInButton : View  {
     let accessibilityLabelStr: String
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             Image(ICONNAME_ZOOM_IN, SYSTEM_ZOOM_IN)
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.title)
         .accessibilityLabel(accessibilityLabelStr)
         .accessibilityIdentifier(A11yID.zoomInButton)
     }
 }
 
 struct ZoomOutButton : View  {
     let accessibilityLabelStr: String
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             Image(ICONNAME_ZOOM_OUT, SYSTEM_ZOOM_OUT)
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.title)
         .accessibilityLabel(accessibilityLabelStr)
         .accessibilityIdentifier(A11yID.zoomOutButton)
     }
 }
 
 struct BackButton : View  {
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             let name = ICONNAME_INCOMING + ICONNAME_FILL
             let sysName = SYSTEM_INCOMING4 + ICONNAME_FILL
             Image(name, sysName, fallback: FALLBACK_INCOMING)
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.largeTitle)
         .accessibilityLabel(Text("Back", comment: "a11y"))
         .accessibilityIdentifier(A11yID.backButton)
     }
 }
 
 struct ForwardButton : View  {
     let enabled: Bool
     let action: () -> Void
 
     var body: some View {
         let myAction = {
             if enabled {
                 action()
             }
         }
         Button(action: myAction) {
             let imageName = enabled ? ICONNAME_OUTGOING + ICONNAME_FILL
                                     : ICONNAME_OUTGOING
             let sysName   = enabled ? SYSTEM_OUTGOING4 + ICONNAME_FILL
                                     : SYSTEM_OUTGOING4
             Image(imageName, sysName, fallback: FALLBACK_OUTGOING)
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.largeTitle)
         .accessibilityLabel(Text("Continue", comment: "a11y"))
         .accessibilityIdentifier(A11yID.forwardButton)
     }
 }
 
 struct ArrowUpButton : View  {
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             Image(systemName: ARROW_TOP)       // 􀄿
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.title2)
         .accessibilityLabel(Text("Scroll up", comment: "a11y"))
         .accessibilityIdentifier(A11yID.arrowUpButton)
     }
 }
 
 struct ArrowDownButton : View  {
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             Image(systemName: ARROW_BOT)        // 􀅀
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.title2)
         .accessibilityLabel(Text("Scroll down", comment: "a11y"))
         .accessibilityIdentifier(A11yID.arrowDownButton)
     }
 }
 
 struct ReloadButton : View  {
     let disabled: Bool
     let action: () -> Void
 
     var body: some View {
         Button(action: action) {
             Image(systemName: RELOAD)           // 􀅈
         }
         .tint(WalletColors().primaryAccent)
         .talerFont(.title)
         .accessibilityLabel(Text("Reload", comment: "a11y"))
         .accessibilityIdentifier(A11yID.reloadButton)
         .disabled(disabled)
     }
 }
 
 enum TalerButtonStyleType {
     case plain
     case bordered
     case prominent
 }
 struct TalerButtonStyle: ButtonStyle {
     var type: TalerButtonStyleType = .plain
     var dimmed: Bool = false
     var narrow: Bool = false
     var one: Bool = false
     var disabled: Bool = false
     var aligned: TextAlignment = .center
     var badge: String = EMPTYSTRING
 
     @Environment(\.colorScheme) private var colorScheme
     @Environment(\.colorSchemeContrast) private var colorSchemeContrast
 
     public func makeBody(configuration: ButtonStyleConfiguration) -> some View {
         //        configuration.role = type == .prominent ? .primary : .normal          Only on macOS
         MyBigButton(foreColor: foreColor(type: type, pressed: configuration.isPressed,
                                        scheme: colorScheme, contrast: colorSchemeContrast, disabled: disabled),
                     backColor: backColor(type: type, pressed: configuration.isPressed, disabled: disabled),
                        dimmed: dimmed,
                 configuration: configuration,
                      disabled: disabled,
                        narrow: narrow,
                           one: one,
                       aligned: aligned,
                         badge: badge,
                        scheme: colorScheme,
                      contrast: colorSchemeContrast)
     }
 
     func foreColor(type: TalerButtonStyleType,
                 pressed: Bool,
                  scheme: ColorScheme,
                contrast: ColorSchemeContrast,
                disabled: Bool) -> Color {
         if type == .plain {
             return WalletColors().fieldForeground      // primary text color
         }
         return WalletColors().buttonForeColor(pressed: pressed,
                                              disabled: disabled,
                                                scheme: scheme,
                                              contrast: contrast,
                                             prominent: type == .prominent)
     }
     func backColor(type: TalerButtonStyleType, pressed: Bool, disabled: Bool) -> Color {
         if type == .plain && !pressed {
             return Color.clear
         }
         return WalletColors().buttonBackColor(pressed: pressed,
                                              disabled: disabled,
                                             prominent: type == .prominent)
     }
 
     struct BackgroundView: View {
         let color: Color
         let dimmed: Bool
         var body: some View {
             RoundedRectangle(
                 cornerRadius: 15,
                 style: .continuous
             )
             .fill(color)
             .opacity(dimmed ? 0.6 : 1.0)
         }
     }
 
     struct MyBigButton: View {
 //        var type: TalerButtonStyleType
         let foreColor: Color
         let backColor: Color
         let dimmed: Bool
         let configuration: ButtonStyle.Configuration
         let disabled: Bool
         let narrow: Bool
         let one: Bool
         let aligned: TextAlignment
         var badge: String
         var scheme: ColorScheme
         var contrast: ColorSchemeContrast
 
         var body: some View {
             let aligned2: Alignment = (aligned == .center) ? Alignment.center
                                     : (aligned == .leading) ? Alignment.leading
                                     : Alignment.trailing
             let hasBadge = !badge.isEmpty
             let buttonLabel = configuration.label
                                 .multilineTextAlignment(aligned)
                                 .lineLimit(one ? 1 : 3)
                                 .talerFont(.title3)         //   narrow ? .title3 : .title2
                                 .frame(maxWidth: narrow ? nil : .infinity, alignment: aligned2)
                                 .padding(.vertical, 10)
                                 .padding(.horizontal, hasBadge ? 0 : 6)
                                 .foregroundColor(foreColor)
                                 .background(BackgroundView(color: backColor, dimmed: dimmed))
                                 .contentShape(Rectangle())      // make sure the button can be pressed even if backgroundColor == clear
                                 .scaleEffect(configuration.isPressed ? 0.95 : 1)
                                 .animation(.spring(response: 0.1), value: configuration.isPressed)
                                 .disabled(disabled)
             if hasBadge {
                 let badgeColor: Color = (badge == CONFIRM_BANK) ? WalletColors().confirm
                                                                 : WalletColors().attention
                 let badgeV = Image(systemName: badge)
                                 .talerFont(.caption)
                 HStack(alignment: .top, spacing: 0) {
                     badgeV.foregroundColor(.clear)
                     buttonLabel
                     badgeV.foregroundColor(badgeColor)
                 }
             } else {
                 buttonLabel
             }
         }
     }
 }
 // MARK: -
 #if DEBUG
 fileprivate struct ContentView_Previews: PreviewProvider {
     static var previews: some View {
         let testButtonTitle = String("Placeholder")
         Button(testButtonTitle) {}
             .buttonStyle(TalerButtonStyle(type: .bordered, aligned: .trailing))
     }
 }
 #endif