Day 14 · 2부 · Transaction·제스처 + 14일 총정리

struct ScoreBoard: View {
    @State private var score = 0

    var body: some View {
        VStack(spacing: 16) {
            Text("\(score)")
                .font(.largeTitle)
                .transaction { $0.animation = nil }   // 숫자는 즉시
            Circle()
                .frame(width: 40 + CGFloat(score) * 4)  // 원은 bouncy
            Button("+1") {
                withAnimation(.bouncy) { score += 1 }
            }
            Button("리셋(애니메이션 없이)") {
                var transaction = Transaction()
                transaction.disablesAnimations = true     // .animation 모디파이어가 끼어들지 못하게
                withTransaction(transaction) { score = 0 }
            }
        }
    }
}

struct ElevatedAvatar: View {
    var selected: Bool

    var body: some View {
        Image(systemName: "bird.fill")
            .font(.system(size: 60))
            .animation(.bouncy) { content in
                content.scaleEffect(selected ? 1.5 : 1.0)     // 크기는 통통 튀게
            }
            .animation(.smooth) { content in
                content.shadow(radius: selected ? 12 : 0)     // 그림자는 차분하게
            }
    }
}

struct SnapBackCard: View {
    @GestureState(resetTransaction: Transaction(animation: .bouncy))
    private var dragOffset = CGSize.zero       // 손을 떼면 .bouncy로 .zero 복귀

    var body: some View {
        RoundedRectangle(cornerRadius: 16)
            .fill(.blue)
            .frame(width: 120, height: 160)
            .offset(dragOffset)
            .gesture(
                DragGesture()
                    .updating($dragOffset) { value, state, _ in
                        state = value.translation
                    }
            )
    }
}

struct DropPin: View {
    @State private var committed = CGSize.zero
    @State private var live = CGSize.zero

    var body: some View {
        Circle()
            .fill(.orange)
            .frame(width: 80, height: 80)
            .offset(x: committed.width + live.width,
                    y: committed.height + live.height)
            .gesture(
                DragGesture()
                    .onChanged { live = $0.translation }
                    .onEnded { value in
                        committed.width += value.translation.width
                        committed.height += value.translation.height
                        live = .zero                    // 같은 업데이트에서 넘겨주므로 튀지 않는다
                    }
            )
    }
}

struct PhotoTransform: View {
    @GestureState private var zoom = 1.0
    @GestureState private var rotation = Angle.zero

    var body: some View {
        Image(systemName: "photo")
            .font(.system(size: 120))
            .scaleEffect(zoom)
            .rotationEffect(rotation)
            .gesture(
                MagnifyGesture()
                    .updating($zoom) { value, state, _ in state = value.magnification }
                    .simultaneously(with:
                        RotateGesture()
                            .updating($rotation) { value, state, _ in state = value.rotation }
                    )
            )
    }
}

struct TapAndHold: View {
    @State private var zoomed = false
    @State private var pressing = false
    @State private var message = "대기"

    var body: some View {
        VStack(spacing: 24) {
            Image(systemName: "photo")
                .font(.system(size: 80))
                .scaleEffect(zoomed ? 1.6 : 1.0)
                .gesture(
                    TapGesture(count: 2)
                        .onEnded { withAnimation(.snappy) { zoomed.toggle() } }
                        .exclusively(before:              // 더블 탭이 실패해야 싱글 탭
                            TapGesture().onEnded { message = "한 번 탭" })
                )

            Text(message)
                .padding()
                .background(pressing ? Color.yellow : Color.gray.opacity(0.2))
                .onLongPressGesture(minimumDuration: 0.5) {
                    message = "길게 눌렀다"             // 0.5초를 채웠을 때
                } onPressingChanged: { isPressing in
                    pressing = isPressing              // 누르는 동안 true
                }
        }
    }
}

struct HoldThenDrag: View {
    enum DragState {
        case inactive
        case pressing
        case dragging(CGSize)

        var offset: CGSize {
            if case .dragging(let t) = self { return t }
            return .zero
        }
        var isActive: Bool {
            if case .inactive = self { return false }
            return true
        }
    }

    @GestureState private var dragState = DragState.inactive
    @State private var position = CGSize.zero

    var body: some View {
        let holdThenDrag = LongPressGesture(minimumDuration: 0.4)
            .sequenced(before: DragGesture())
            .updating($dragState) { value, state, _ in
                switch value {
                case .first(true):                    // 길게 누르는 중
                    state = .pressing
                case .second(true, let drag):         // 길게 누르기 성공 → 드래그
                    state = .dragging(drag?.translation ?? .zero)
                default:
                    state = .inactive
                }
            }
            .onEnded { value in
                guard case .second(true, let drag?) = value else { return }
                position.width += drag.translation.width
                position.height += drag.translation.height
            }

        Circle()
            .fill(dragState.isActive ? Color.orange : Color.blue)
            .frame(width: 90, height: 90)
            .scaleEffect(dragState.isActive ? 1.15 : 1.0)
            .offset(x: position.width + dragState.offset.width,
                    y: position.height + dragState.offset.height)
            .animation(.snappy, value: dragState.isActive)
            .gesture(holdThenDrag)
    }
}

struct ParentVsChild: View {
    var body: some View {
        HStack(spacing: 24) {
            Image(systemName: "heart.fill")
                .onTapGesture { print("하트") }       // 자식 제스처
            Text("행")
        }
        .highPriorityGesture(TapGesture().onEnded { print("행") })     // 하트를 눌러도 "행"만
        // .simultaneousGesture(TapGesture().onEnded { print("행") }) // 하트를 누르면 "하트"+"행"
    }
}

struct FakeButton: View {
    @State private var liked = false
    var body: some View {
        Image(systemName: liked ? "heart.fill" : "heart")
            .onTapGesture { liked.toggle() }   // 보조기술에 "버튼"으로 알려지지 않는다
    }
}

struct LikeButton: View {
    @State private var liked = false
    @Environment(\.accessibilityReduceMotion) private var reduceMotion

    var body: some View {
        Button {
            withAnimation(reduceMotion ? nil : .bouncy) { liked.toggle() }
        } label: {
            Image(systemName: liked ? "heart.fill" : "heart")
                .scaleEffect(liked ? 1.2 : 1.0)
        }
        .accessibilityLabel(liked ? "좋아요 취소" : "좋아요")
    }
}

import SwiftUI

struct LikeCounter: View {
    @State private var liked = false
    @State private var count = 41

    var body: some View {
        HStack {
            Image(systemName: liked ? "heart.fill" : "heart")
                .font(.largeTitle)
                .foregroundStyle(.pink)
            Text("\(count)")
                .font(.title.monospacedDigit())
        }
        .onTapGesture {
            liked.toggle()
            count += liked ? 1 : -1
        }
    }
}

#Preview { LikeCounter() }