swiftPunk's questions

在下面的代码中，我正在读取预定义路径并将轴系统从 SwiftUI 转换为数学轴。到目前为止一切顺利。当我向此路径添加拖动手势时，问题出现了。该手势仅适用于形状的特定部分（如照片所示），而不适用于路径的其余部分。如何在不改变预定义路径的情况下解决此问题？

import SwiftUI

struct ContentView: View {
    
    @State private var pathCurrentOffset: CGSize = CGSize()
    @State private var pathLastOffset: CGSize = CGSize()
    
    var body: some View {
        
        GeometryReader { geometryValue in
            
            Color.white
            
            myCustomPathTest
                .scale(x: 1.0, y: -1.0)
                .stroke(Color.black, lineWidth: 5.0)
                .offset(x: pathCurrentOffset.width + geometryValue.size.width/2.0,
                        y: -pathCurrentOffset.height - geometryValue.size.height/2.0)
                .gesture(pathDragGesture)

        }
        .padding()
    }
    
    private var pathDragGesture: some Gesture {
        
        return DragGesture(minimumDistance: 0.0, coordinateSpace: .local)
            .onChanged() { gestureValue in
                
                pathCurrentOffset = CGSize(width: gestureValue.translation.width + pathLastOffset.width,
                                           height: -gestureValue.translation.height + pathLastOffset.height)
            }
            .onEnded() { gestureValue in
                pathLastOffset = pathCurrentOffset

            }
        
    }
}

let myCustomPathTest: Path = {
    return Path { path in
        path.move(to: .zero)
        path.addLine(to: CGPoint(x: 50.0, y: 50.0))
        path.addEllipse(in: CGRect(origin: CGPoint(x: -50.0, y: -50.0), size: CGSize(width: 100.0, height: 100.0)))
    }
}()

路径上的工作部分是：

我想创建一个解决方案，告诉我用户何时完成视图大小调整。目前，我为此使用了一个计时器，但我对我的方法并不满意，因为它感觉不像惯用的 SwiftUI 编码。我正在寻找一种更原生的方法来检测调整大小结束时视图的最终大小。当我们改变窗口大小时，我们的视图大小也会改变。

import SwiftUI

struct ContentView: View {
    
    @State private var resizeTimer: Timer? = nil
    
    var body: some View {
        GeometryReader { geometryValue in
            Color.white
                .onChange(of: geometryValue.size) { newValue in

                    // Invalidate any existing timer
                    resizeTimer?.invalidate()

                    // Start a new timer to detect when resizing ends
                    resizeTimer = Timer.scheduledTimer(withTimeInterval: 0.01, repeats: false) {  _ in // [weak self]
                        didEndResizing(size: newValue)
                    }
                }
        }
        .padding()
    }
    
    private func didEndResizing(size: CGSize) {
        print("View resizing ended. Final size: \(size)")
    }
}

我正在尝试完成一个自定义滑块，它不是普通的滑块。它涉及通过在屏幕上拖动圆圈来按压内部和外部。圆圈的拖动量缩小了 10 倍。我已经完成了圆圈拖动部分，自定义滑块在拖动圆圈时的工作方式与我预期的一样。

但是，当我尝试通过拖动自定义滑块本身来逆转该过程时，问题就出现了。除了对 CustomSliderView 中的 .onChange(of: percentageDX) 部分进行逆向工程外，我已经完成了所有部分。我为此苦苦挣扎了几个小时，尝试了大约 50 次不同的反复试验，但我无法理解。我需要帮助来完成 CustomSliderView 中旋钮手势缺失的部分。

以下是代码工作原理的一些背景信息：我在应用程序中有一个屏幕，用作测量工具，用于找出圆圈阻力的百分比。然后，我将这个百分比发送给 CustomSliderView 并将其缩小 10 倍。此操作将滑块上的位移量减少了 10 倍，使其能够与圆圈的拖动一起正常工作。您可以尝试拖动圆圈，以查看当圆圈向左或向右的阻力或位移为零时，滑块为 100%。当圆圈开始向左或向右移动时，滑块开始向相反方向按压。

现在，我想要通过拖动滑块来逆转这个按下过程，让它在圆圈回到原来的位置时逐渐压回到 100％。

import SwiftUI

struct ContentView: View {
    
    @State private var lastCircleOffset: CGSize = CGSize()
    @State private var currentCircleOffset: CGSize = CGSize()
    @State private var circleIsDragging: Bool = Bool()
    @State private var dxKnobIsDragging: Bool = Bool()
    @State private var percentageDX: CGFloat? = nil
    
    private let maxScreenVisibilitySize: CGSize = CGSize(width: 400.0, height: 300.0)
    
    var body: some View {
        
        ZStack {
            
            ZStack {
                
                Color.clear
                
                Color.white
                    .frame(width: maxScreenVisibilitySize.width, height: maxScreenVisibilitySize.height)
                
                Circle()
                    .fill(.red)
                    .frame(width: 50.0, height: 50.0)
                    .offset(x: currentCircleOffset.width, y: currentCircleOffset.height)
                    .gesture(circleGesture)
                
                if let unwrappedPercentageDX: CGFloat = percentageDX {
                    Text("percentageDX: \(String(format: "%.2f", unwrappedPercentageDX*100.0))%").bold().monospaced().foregroundStyle(.black).offset(y: 50)
                }
                
                
            }
            .clipped()
            .onChange(of: currentCircleOffset) { (oldValue, newValue) in
                
                if (!dxKnobIsDragging) && (oldValue != newValue) {
                    
                    percentageDX = (newValue.width/(maxScreenVisibilitySize.width/2.0))
                    
                }
                
            }
            .onChange(of: percentageDX) { (oldValue, newValue) in
                
                if (!circleIsDragging) && (dxKnobIsDragging) {
                    
                    if let unwrappedOldValue: CGFloat = oldValue, let unwrappedNewValue: CGFloat = newValue, (unwrappedOldValue != unwrappedNewValue) {
                        
                        // I may made mistake here!
                        
                        currentCircleOffset.width -= (unwrappedNewValue*maxScreenVisibilitySize.width)/2.0
                        
                    }
                    
                }
                
            }
            
            VStack {
                
                Spacer()
                
                CustomSliderView(percentageDX: $percentageDX, dxKnobIsDragging: $dxKnobIsDragging)
                
            }
            
        }
        .padding()
        
    }
    
    private var circleGesture: some Gesture {
        
        return DragGesture(minimumDistance: CGFloat.zero, coordinateSpace: .local)
            .onChanged() { value in
                
                circleIsDragging = true
                
                currentCircleOffset = CGSize(width: value.translation.width + lastCircleOffset.width,
                                             height: value.translation.height + lastCircleOffset.height)
                
            }
            .onEnded() { value in
                lastCircleOffset = currentCircleOffset
                circleIsDragging = false
            }
        
    }
    
}

struct CGSizePreferenceKey: PreferenceKey {
    static var defaultValue: CGSize { get { return CGSize() } }
    static func reduce(value: inout CGSize, nextValue: () -> CGSize) { value = nextValue() }
}


struct CustomSliderView: View {
    
    @Binding var percentageDX: CGFloat?
    @Binding var dxKnobIsDragging: Bool
    
    @State private var lastKnobOffset: CGFloat = CGFloat()
    @State private var currentKnobOffset: CGFloat = CGFloat()
    
    @State private var currentOffsetPercentage: CGFloat = CGFloat()
    
    @State private var maxWidthSize: CGFloat = CGFloat()
    @State private var knobWidth: CGFloat = CGFloat()
    private let knobHeight: CGFloat = 25.0
    
    
    var body: some View {
        
        GeometryReader { proxy in
            
            ZStack {
                
                Color.gray
                
                Color.white.opacity(knobWidth.isZero ? .zero : 0.85)
                    .frame(width: knobWidth)
                    .shadow(radius: 10)
                    .offset(x: currentKnobOffset)
                    .gesture(knobGesture)
                
            }
            .preference(key: CGSizePreferenceKey.self, value: proxy.size)
            
        }
        .frame(height: knobHeight)
        .onPreferenceChange(CGSizePreferenceKey.self) { newValue in
            
            maxWidthSize = newValue.width
            
            if percentageDX == nil {
                knobWidth = newValue.width
            }
            
            
        }
        .onChange(of: percentageDX) { (oldValue, newValue) in
            
            // This part is okay; it works as expected.
            
            if (!dxKnobIsDragging) {
                
                if let unwrappedOldValue: CGFloat = oldValue, let unwrappedNewValue: CGFloat = newValue, (unwrappedOldValue != unwrappedNewValue) {
                    
                    if let unwrappedNewValue: CGFloat = newValue {
                        
                        let newPercentageDX: CGFloat = abs(unwrappedNewValue)
                        
                        let knobScale: CGFloat = 10.0
                        
                        knobWidth = (maxWidthSize - (newPercentageDX*maxWidthSize)/knobScale)
                        
                        
                        if (unwrappedNewValue >= .zero) {
                            currentKnobOffset = -(newPercentageDX*maxWidthSize)/(2.0*knobScale)
                            lastKnobOffset = currentKnobOffset
                        }
                        else {
                            currentKnobOffset = (newPercentageDX*maxWidthSize)/(2.0*knobScale)
                            lastKnobOffset = currentKnobOffset
                        }
                        
                    }
                    
                }
                
            }
            
        }
        
    }
    
    private var knobGesture: some Gesture {
        
        return DragGesture(minimumDistance: CGFloat.zero, coordinateSpace: .local)
            .onChanged() { value in
                
                dxKnobIsDragging = true
                
                // I need to finish this part with the help of reverse coding on .onChange(of: percentageDX)
                
                
            }
            .onEnded() { value in
                
                lastKnobOffset = currentKnobOffset
                dxKnobIsDragging = false
                
            }
        
    }
}

我想为划线阶段添加动画，但遇到了动画缺陷。如何解决这些缺陷以实现给定线宽的流畅连续动画？

我更新了代码但没有改变原来的问题；我只是添加了一个按钮来启动和停止动画。

import SwiftUI

struct ContentView: View {
    
    let lineWidth: CGFloat = 90.0
    
    var body: some View {
        
        DashedCircleView(lineWidth: lineWidth)
        
    }
}

struct DashedCircleView: View {
    
    let lineWidth: CGFloat
    
    @State private var phaseAnimation: Bool = Bool()
    @State private var animation: Animation? = nil

    var body: some View {
        
        VStack {
            
            Spacer()
            
            Circle()
                .strokeBorder(Color.red, style: StrokeStyle(
                        lineWidth: lineWidth,
                        dash: [2*lineWidth],
                        dashPhase: phaseAnimation ? 4*lineWidth : .zero))
                .frame(width: 400, height: 400)
                .animation(animation, value: phaseAnimation)
            
            Spacer()

            Button("run Animation") {
                
                if (phaseAnimation) {
                    animation = Animation.interactiveSpring
                    phaseAnimation.toggle()
                }
                else {
                    animation = Animation.linear(duration: 1).repeatForever(autoreverses: false)
                    phaseAnimation.toggle()
                }
                
            }
            
        }
        .padding()
        
    }
}

更新：工作代码：

import SwiftUI

struct ContentView: View {
            
    var body: some View {
        
        DashedCircleView(lineWidth: 30.0, dashCount: 10, size: 400.0)
 
    }
}

struct DashedCircleView: View {
    
    let lineWidth: CGFloat
    let dashCount: Int
    let size: CGFloat
    
    @State private var phaseAnimation: Bool = Bool()
    
    var body: some View {
        
        VStack {
            
            Spacer()

            Circle()
                .strokeBorder(Color.red, style: StrokeStyle(lineWidth: lineWidth,
                                                            dash: [(size - lineWidth) * CGFloat.pi / (CGFloat(dashCount)*2.0)],
                                                            dashPhase: phaseAnimation ? (size - lineWidth) * CGFloat.pi / CGFloat(dashCount) : .zero))
                .frame(width: size, height: size)
                .animation(phaseAnimation ? Animation.linear(duration: 1).repeatForever(autoreverses: false) : Animation.interactiveSpring, value: phaseAnimation)
            
            Spacer()
            
            Button(phaseAnimation ? "Pause Animation" : "Run Animation") {
                phaseAnimation.toggle()
            }
            
        }
        .padding()
        
    }
}

我有一个定义点的数组，我使用这些点在每个位置绘制一颗星。星形视图应该简单地报告拖动手势以更新每个点的位置。目前，代码部分有效：拖动量不等于星星的位移。

我的目标是让星形视图尽可能简洁；我只想使用此视图读取拖动量。我希望在 ForEach 循环中更新点的位置。如何在 ForEach 中将 DragGesture 值正确转换为 CGPoint 以实现此目的？

import SwiftUI

struct ContentView: View {
    
    @State private var points: [CustomPoint] = [CustomPoint(x: 100, y: 100), CustomPoint(x: 200, y: 200), CustomPoint(x: 300, y: 100)]
    
    var body: some View {
        GeometryReader { proxy in
            
            Color.blue
            
            ForEach($points) { $point in
                
                DrawStarView(customPoint: point) { value in
                    point.cgPointValue = CGPoint(x: point.cgPointValue.x + value.width, y: point.cgPointValue.y + value.height)
                }
                
            }
            
            
        }
        .padding()
    }
}

struct CustomPoint: Identifiable {
    
    init(x: CGFloat, y: CGFloat) {
        self.cgPointValue = CGPoint(x: x, y: y)
    }

    let id: UUID = UUID()
    var cgPointValue: CGPoint
}


struct DrawStarView: View {
    
    init(customPoint: CustomPoint, action: @escaping (CGSize) -> Void) {
        self.customPoint = customPoint
        self.action = action
    }
    
    let customPoint: CustomPoint
    let action: (CGSize) -> Void
    
    
    var body: some View {
                
        return createStarPath(at: customPoint.cgPointValue)
            .fill(Color.white)
            .shadow(radius: 5)
            .gesture(dragGesture)
        
    }

    func createStarPath(at point: CGPoint, size: CGSize = CGSize(width: 100, height: 100)) -> Path {
        let outerRadius = size.width / 2
        let innerRadius = outerRadius / 2.5
        let center = point
        let pointsOnStar = 5
        let angleIncrement = .pi * 2 / CGFloat(pointsOnStar * 2)
        
        var path = Path()
        
        for i in 0..<pointsOnStar * 2 {
            let angle = angleIncrement * CGFloat(i) - .pi / 2
            let radius = (i % 2 == 0) ? outerRadius : innerRadius
            let x = center.x + radius * cos(angle)
            let y = center.y + radius * sin(angle)
            
            if i == 0 {
                path.move(to: CGPoint(x: x, y: y))
            } else {
                path.addLine(to: CGPoint(x: x, y: y))
            }
        }
        
        path.closeSubpath()
        return path
    }

    private var dragGesture: some Gesture {
        
        DragGesture(minimumDistance: 0)
            .onChanged { value in
                action(value.translation)
            }
            .onEnded { value in
                action(value.translation)
            }
        
    }

}

我想创建一个具有两个值a和b 的结构，其中a必须始终等于b + 5，而b必须始终等于a - 5。我尝试了不同的方法来实现这一点，但我不确定哪种方法最有效且最易于维护。你能帮我优化它并找到最佳解决方案吗？

struct MyType1 {
    
    init(a: Int) {
        self.a = a
        self.b = a - 5
    }
    
    init(b: Int) {
        self.b = b
        self.a = b - 5
    }
    
    var a: Int {
        didSet(oldValue) {
            print("didSet for a")
            if (oldValue != a) && (b != (a - 5)) {
                b = a - 5
            }
        }
    }
    
    var b: Int {
        didSet(oldValue) {
            print("didSet for b")
            if (oldValue != b) && (a != (b + 5)) {
                a = b + 5
            }
        }
    }
}

struct MyType2 {
    
    init(a: Int) {
        self.internalA = a
        self.internalB = a - 5
    }
    
    init(b: Int) {
        self.internalB = b
        self.internalA = b + 5
    }

    private var internalA: Int
    private var internalB: Int
    
    var a: Int {
        get { return internalA }
        set(newValue) {
            internalA = newValue
            internalB = newValue - 5
        }
    }
    
    var b: Int {
        get { return internalB }
        set(newValue) {
            internalB = newValue
            internalA = newValue + 5
        }
    }
    
}

我有两个自定义类型，Student 和 Classroom，它们都符合 Identifiable 规范。当我更新班级中一名学生的姓名时，它会导致所有 Identifiable 视图（甚至数据没有变化的视图）更新并重新渲染。我预计，由于我的视图是 Identifiable 的，SwiftUI 会识别哪些视图需要更新并仅重新渲染那些视图。但是，使用下面的代码，如果我更改单个学生的姓名，所有视图都会更新并重新渲染，这不是我想要的。我只希望更新与更改的姓名相关的视图。我在这里做错了什么？

import SwiftUI

struct ContentView: View {
    
    @State private var school: [Classroom] = [classroom1, classroom2]
    
    var body: some View {
        
        VStack {

            Divider()

            ForEach(school) { classroom in

                ForEach(classroom.students) { student in
                    
                    StudentView(student: student, action: { value in

                        if let classroomIndex: Int = findIndex(item: classroom, array: school) {

                            if let studentIndex: Int = findIndex(item: student, array: classroom.students) {

                                school[classroomIndex].students[studentIndex].name = value

                            }
  
                        }

                    })

                }
                
                Divider()

            }

        }
        .padding()
    }
}

func findIndex<U: Identifiable>(item: U, array: [U]) -> Int? {
    return array.firstIndex(where: { element in (element.id == item.id) })
}


struct StudentView: View {
    let student: Student
    let action: (String) -> Void
    var body: some View {
        print("rendering for:", student.name)
       return Text(student.name)
            .onTapGesture {
                action(student.name + " updated! ")
            }
        
    }
}




struct Student: Identifiable {
    let id: UUID = UUID()
    var name: String
}

struct Classroom: Identifiable {
    let id: UUID = UUID()
    var name: String
    var students: [Student]
}

let classroom1: Classroom = Classroom(name: "Classroom 1", students: [Student(name: "a"), Student(name: "b"), Student(name: "c")])
let classroom2: Classroom = Classroom(name: "Classroom 2", students: [Student(name: "x"), Student(name: "y"), Student(name: "z")])

更新：

使用下面这个更新可以让代码正常工作而不存在额外渲染的问题：

struct StudentView: View, Equatable {
    let student: Student
    let action: (String) -> Void
    var body: some View {
        print("rendering for:", student.name)
       return Text(student.name)
            .onTapGesture {
                action(student.name + " updated! ")
            }
        
    }
    
    static func ==(lhs: Self, rhs: Self) -> Bool {
         lhs.student == rhs.student
     }
}

struct Student: Identifiable, Equatable {
    let id: UUID = UUID()
    var name: String
    
    static func ==(lhs: Self, rhs: Self) -> Bool {
        return (lhs.id == rhs.id) && (lhs.name == rhs.name)
    }
}

我正在读取一个随机路径，并将其提取到其 Path.Element 组件中。然后，我尝试反转该过程并将提取的 Path.Element 组件连接在一起以创建最终路径。目前，我的代码部分工作正常；它绘制了路径的某些部分，但对于其他部分，它会在 Xcode 控制台中显示如下错误：

CGPathAddCurveToPoint：没有当前点。

CGPathCloseSubpath：没有当前点。

CGPathAddLineToPoint：没有当前点。

我不知道如何解决这个问题。在此过程中，我将路径分解成各个部分，并在不更改值的情况下尝试将所有部分重新组合在一起。但是，这些错误和问题不断出现。

import SwiftUI

struct ContentView: View {
    
    @State private var myCustomPathComponents: [CustomPath] = pathComponents(path: comprehensivePath)
    
    @State private var myPath: Path = Path()
    
    var body: some View {
        
        VStack {

            GeometryReader { proxy in
                
                Color.white
                
                ForEach(myCustomPathComponents) { item in
                    
                    item.pathValue
                        .stroke(.black, lineWidth: 2.0)
                    
                }

            }

            GeometryReader { proxy in
                
                Color.white
  
                    ForEach(myCustomPathComponents) { item in
                        myFunc(value: item.pathElements)
                            .stroke(Color.red, lineWidth: 2.0)
                    }

            }
 
        }
        .padding()
        .onAppear {
            
            print("count:", myCustomPathComponents.count)
            print("- - - - - - - - - - -")
            
            for item in myCustomPathComponents {
                print(item.pathValue.cgPath)
                print("- - - - - - - - - - -")
            }
            
        }
        
    }
}



let comprehensivePath: Path = {
    var path = Path()
    
    // Line
    path.move(to: CGPoint(x: 20, y: 20))
    path.addLine(to: CGPoint(x: 120, y: 20))
    
    // Circle
    path.addEllipse(in: CGRect(x: 20, y: 30, width: 100, height: 100))
    
    // Rectangle
    path.addRect(CGRect(x: 150, y: 30, width: 100, height: 50))
    
    // Quadratic Curve
    path.move(to: CGPoint(x: 250, y: 20))
    path.addQuadCurve(to: CGPoint(x: 300, y: 120), control: CGPoint(x: 275, y: 0))
    
    // Cubic Curve
    path.move(to: CGPoint(x: 20, y: 150))
    path.addCurve(to: CGPoint(x: 120, y: 250), control1: CGPoint(x: 50, y: 100), control2: CGPoint(x: 90, y: 200))
    
    // Polygon (Triangle)
    path.move(to: CGPoint(x: 250, y: 150))
    path.addLine(to: CGPoint(x: 300, y: 150))
    path.addLine(to: CGPoint(x: 275, y: 200))
    path.closeSubpath()
    
    // Arc (part of a circle)
    path.move(to: CGPoint(x: 150, y: 200))
    path.addArc(center: CGPoint(x: 150, y: 200), radius: 50, startAngle: .degrees(0), endAngle: .degrees(180), clockwise: true)
    
    return path
}()



struct CustomPath: Identifiable {
    let id: UUID = UUID()
    var pathValue: Path
    var pathElements: [Path.Element]
}



func pathComponents(path: Path) -> [CustomPath] {
    
    var components: [CustomPath] = []
    var currentPath = Path()
    var currentElements: [Path.Element] = []
    
    path.forEach { element in
        
        currentElements.append(element)
        
        switch element {
        case .move(to: let point):
            
            // Save the current path as a `CustomPath` before starting a new one
            if !currentPath.isEmpty {
                components.append(CustomPath(pathValue: currentPath, pathElements: currentElements))
                currentPath = Path()
                currentElements = []
            }
            
            currentPath.move(to: point)
            
        case .line(to: let point):
            currentPath.addLine(to: point)
            
        case .quadCurve(to: let endPoint, control: let controlPoint):
            currentPath.addQuadCurve(to: endPoint, control: controlPoint)
            
        case .curve(to: let endPoint, control1: let control1, control2: let control2):
            currentPath.addCurve(to: endPoint, control1: control1, control2: control2)
            
        case .closeSubpath:
            currentPath.closeSubpath()
            components.append(CustomPath(pathValue: currentPath, pathElements: currentElements))
            currentPath = Path()
            currentElements = []
        }
    }
    
    // Append any remaining path if it hasn't been added yet
    if !currentPath.isEmpty {
        components.append(CustomPath(pathValue: currentPath, pathElements: currentElements))
    }
    
    return components
}



func myFunc(value: [Path.Element]) -> Path {
    var finalPath = Path()
    
    for element in value {
        switch element {
        case .move(to: let point):
            finalPath.move(to: point)
            
        case .line(to: let point):
            finalPath.addLine(to: point)
            
        case .quadCurve(to: let endPoint, control: let controlPoint):
            finalPath.addQuadCurve(to: endPoint, control: controlPoint)
            
        case .curve(to: let endPoint, control1: let control1, control2: let control2):
            finalPath.addCurve(to: endPoint, control1: control1, control2: control2)
            
        case .closeSubpath:
            finalPath.closeSubpath()
        }
    }
    
    return finalPath
}

我有一段简单的代码，可以在视图中绘制路径，如下所示：

import SwiftUI

struct ContentView: View {
    
    var body: some View {
        
        GeometryReader { proxy in
            
            Color.yellow
            
            let proxyCGRect: CGRect = proxy.frame(in: .local)
            
            let dy = rectPath1.boundingRect.midY
            
            // way 1 with offsetBy:
            rectPath1
                .offsetBy(dx: .zero, dy: .zero)
                .fill(Color.blue)
                
            
            // way 2 with position:
            rectPath2
                .fill(Color.red)
                .position(x: 0, y: 0)
            
            
            // way 3 with offset:
            rectPath3
                .fill(Color.green)
                .offset(x: 0, y: 0)
            
        }
        
    }
}


func createRectPath(for rect: CGRect) -> Path {
    var path = Path()
    path.addRect(rect)
    return path
}

let rectPath1: Path = createRectPath(for: CGRect(x: 50, y: 50, width: 50, height: 100))
let rectPath2: Path = createRectPath(for: CGRect(x: 200, y: 100, width: 100, height: 100))
let rectPath3: Path = createRectPath(for: CGRect(x: 400, y: 300, width: 100, height: 100))

在视图中我们得到了要绘制的路径，我想将 SwiftUI 坐标系（如照片中所示）从黑色更改为蓝色。在 x 轴上，它会相同，但 y 轴会发生变化。我想制作一个函数，使用路径信息来绘制相同的东西，但在其他坐标系中，我们该怎么做？只需知道一件事，我们确实可以访问路径，而不是 cgrect！因为这个路径可以是任何形状，所以它不固定为 addRect，它是任何路径，但我们可以访问路径，并且可以使用它。

我有这个测试代码，我认为我编写的一切都正确，但由于某些原因它不起作用，我的意思是它没有应用修改。我不明白为什么会出现这个问题？

我的目标是停止重复输入修饰符的值并使用父视图值

import SwiftUI

struct ContentView: View {
    var body: some View {
        MyView(value: "Hello, world!", color: .red, border: true)
            .bordered()
    }
}

struct MyView: View {
    
    let value: String
    let color: Color
    let border: Bool
    
    var body: some View {
        Text(value)
            .foregroundStyle(color)
            .environment(\.borderColor, color)
            .environment(\.isBorderEnabled, border)

    }
}

struct BorderedModifier: ViewModifier {
    
    @Environment(\.borderColor) private var color
    @Environment(\.isBorderEnabled) private var border
    
    func body(content: Content) -> some View {
        Group {
            if (border) {
                content
                    .padding(5.0)
                    .overlay(
                        RoundedRectangle(cornerRadius: 4)
                            .stroke(color, lineWidth: 2)
                    )
            } else {
                content
            }
        }
    }
}

extension View {
    func bordered() -> some View {
        self.modifier(BorderedModifier())
    }
}


private struct BorderColorKey: EnvironmentKey {
    static let defaultValue: Color = .black
}

private struct BorderEnabledKey: EnvironmentKey {
    static let defaultValue: Bool = false
}

extension EnvironmentValues {
    var borderColor: Color {
        get { self[BorderColorKey.self] }
        set { self[BorderColorKey.self] = newValue }
    }
    
    var isBorderEnabled: Bool {
        get { self[BorderEnabledKey.self] }
        set { self[BorderEnabledKey.self] = newValue }
    }
}

我有一个类似以下代码的形状：

import SwiftUI

struct ContentView: View {
    var body: some View {
        
        let myCustomInsettableShape = HexagonShape(thickness: 100.0)
        
        ZStack {

            myCustomInsettableShape
                .fill(Color.blue)

            myCustomInsettableShape
             .strokeBorder(Color.black.opacity(0.5), style: StrokeStyle(lineWidth: 50.0, lineCap: .round, lineJoin: .miter))
            
        }
        .background(Color.red)
        .padding(50)
    }
}


struct HexagonShape: InsettableShape {
    
    var thickness: CGFloat
    var insetAmount: CGFloat = CGFloat.zero
    
    func path(in rect: CGRect) -> Path {
        
        var path: Path = Path()
        
        let halfThickness: CGFloat = thickness/2.0

        let dx: CGFloat
        let dy: CGFloat
        
        if (insetAmount > .zero) && (halfThickness > .zero) {
            let diagonal = sqrt((halfThickness * halfThickness) + (halfThickness * halfThickness))
            dx = insetAmount * diagonal / halfThickness
            dy = insetAmount * diagonal / halfThickness
        } else {
            dx = .zero
            dy = .zero
        }

        path.move(to: CGPoint(x: rect.minX + dx, y: rect.minY + halfThickness))
        path.addLine(to: CGPoint(x: rect.midX, y: rect.minY + dy))
        path.addLine(to: CGPoint(x: rect.maxX - dx, y: rect.minY + halfThickness))
        path.addLine(to: CGPoint(x: rect.maxX - dx, y: rect.maxY - halfThickness))
        path.addLine(to: CGPoint(x: rect.midX, y: rect.maxY - dy))
        path.addLine(to: CGPoint(x: rect.minX + dx, y: rect.maxY - halfThickness))
        path.closeSubpath()

        return path
        
    }
    
    func inset(by amount: CGFloat) -> some InsettableShape {
        var myShape: Self = self
        myShape.insetAmount += amount
        return myShape
    }
    
}

形状的结果如下：

蓝色填充的形状是我想要的，并且我希望我的 strokeBorder 具有相同的形状，但我不知道如何实现 insetAmount，thickness 是一个可以改变的值，显示和说明形状的形式。

我的代码存在一个问题，即 strokeBorder 没有在 Border 内描边，如果我对 Shape 使用填充，它会保留并尊重边框，但 strokeBorder 却不会这样做，如何解决这个问题？

import SwiftUI

struct ContentView: View {
    var body: some View {
        
        let myCustomInsettableShape = TestShape()
        
        ZStack {

            myCustomInsettableShape
                .fill(Color.white)

            myCustomInsettableShape
                .strokeBorder(Color.black.opacity(0.5), style: StrokeStyle(lineWidth: 50.0, lineCap: .round, lineJoin: .miter))
            
        }
        .background(Color.red)
        .padding(50)
    }
}

struct TestShape: InsettableShape {
    
    var insetAmount: CGFloat = .zero
    
    func path(in rect: CGRect) -> Path {
        
        // Adjust the rect to account for half the stroke width to ensure it stays inside
        let insetRect = rect.insetBy(dx: insetAmount, dy: insetAmount)
        
        // Create the path for the shape
        return Path { path in
            path.move(to: CGPoint(x: insetRect.minX, y: insetRect.midY))
            path.addLine(to: CGPoint(x: insetRect.midX, y: insetRect.minY))
            path.addLine(to: CGPoint(x: insetRect.maxX, y: insetRect.midY))
            path.addLine(to: CGPoint(x: insetRect.midX, y: insetRect.maxY))
            path.closeSubpath()
        }
        
    }
    
    func inset(by amount: CGFloat) -> some InsettableShape {
        var myShape = self
        myShape.insetAmount += amount
        return myShape
    }
    
}

我有一个来自形状的 Rect 视图。为了最终完成，我需要在添加自定义路径时使用 CGAffineTransform。当我使用 CGAffineTransform 时，需要在形状内计算和更新参数a和tx以保持整个最终路径可见。目前，我不知道在更改视图大小时让a和tx自行更新的确切方法。我必须使用滑块手动调整它们，滑块不是应用或程序的一部分 - 它只是一个调试工具。正如您在视频中看到的，通过更改a和tx的值，我可以将整个路径保持在框架内，但用户需要这自动发生。那么，如何才能让a和tx自动更新，同时将整个路径保持在框架内？

第 1 部分：

第 2 部分：

代码：

import SwiftUI

struct ContentView: View {

    @State private var a: Double = 0.8
    @State private var b: Double = 0
    @State private var c: Double = -0.17
    @State private var d: Double = 1
    @State private var tx: Double = 100
    @State private var ty: Double = 0

    var body: some View {
        
        FinalShape(a: a, b: b, c: c, d: d, tx: tx, ty: ty)
            .strokeBorder(style: StrokeStyle(lineWidth: 5.0, lineCap: .round, lineJoin: .round))
            .background(Color.purple)
            .cornerRadius(5.0)
            .padding()

        VStack {

            HStack {
                Text("a:")
                Slider(value: $a, in: -1...1)
            }
            
            HStack {
                Text("b:")
                Slider(value: $b, in: -1...1)
            }
            
            HStack {
                Text("c:")
                Slider(value: $c, in: -1...1)
            }
            
            HStack {
                Text("d:")
                Slider(value: $d, in: -1...1)
            }
            
            HStack {
                Text("tx:")
                Slider(value: $tx, in: -200...200)
            }
            
            HStack {
                Text("ty:")
                Slider(value: $ty, in: -200...200)
            }
 
        }
        .padding()

        HStack {
            VStack(alignment: .leading) {
                Text("a:" + String(describing: a))
                Text("b:" + String(describing: b))
                Text("c:" + String(describing: c))
                Text("d:" + String(describing: d))
                Text("tx:" + String(describing: tx))
                Text("ty:" + String(describing: ty))
            }
            
            Spacer()
        }
        .padding()

    }
}


struct FinalShape: InsettableShape {

    var a: Double
    var b: Double
    var c: Double
    var d: Double
    var tx: Double
    var ty: Double
    
    var insetAmount: CGFloat = CGFloat.zero

    func path(in rect: CGRect) -> Path {
        return Path { path in

            let transform = CGAffineTransform(a: a, b: b, c: c, d: d, tx: tx, ty: ty)

            path.addPath(RecShape(insetAmount: insetAmount).path(in: CGRect(origin: CGPoint(x: rect.minX, y: rect.minY), size: rect.size)), transform: transform)

        }
    }
    
    func inset(by amount: CGFloat) -> some InsettableShape {
        var myShape: Self = self
        myShape.insetAmount += amount
        return myShape
    }
}


struct RecShape: InsettableShape {
    var insetAmount: CGFloat = CGFloat.zero
    func path(in rect: CGRect) -> Path {
        return Path { path in
            path.addRect(CGRect(origin: CGPoint(x: rect.minX + insetAmount, y: rect.minY + insetAmount), size: CGSize(width: rect.width - 2*insetAmount, height: rect.height - 2*insetAmount)))
        }
    }
    func inset(by amount: CGFloat) -> some InsettableShape {
        var myShape: Self = self
        myShape.insetAmount += amount
        return myShape
    }
}

我有一条带有以下代码和照片的六边形路径：

 struct HorizontalHexagon: InsettableShape {
    
    var insetAmount: CGFloat = CGFloat.zero

    func path(in rect: CGRect) -> Path {

        return Path { path in
            path.move(to: CGPoint(x: rect.minX + insetAmount, y: rect.midY))
            path.addLine(to: CGPoint(x: rect.maxX/4.0, y: rect.minY + insetAmount))
            path.addLine(to: CGPoint(x: rect.maxX - rect.maxX/4.0, y: rect.minY + insetAmount))
            
            path.addLine(to: CGPoint(x: rect.maxX - insetAmount, y: rect.midY))
            
            path.addLine(to: CGPoint(x: rect.maxX - rect.maxX/4.0, y: rect.maxY - insetAmount))
            path.addLine(to: CGPoint(x: rect.maxX/4.0, y: rect.maxY - insetAmount))
   
            path.closeSubpath()
            
        }
    }
    
    func inset(by amount: CGFloat) -> some InsettableShape {
        var myShape: Self = self
        myShape.insetAmount += amount
        return myShape
    }
    
}

但是，当我使用此定义的路径构建另一个形状时，会出现大小和形状变形。我没有在代码中看到任何错误，但由于某些未知原因，出现了此问题。

struct FinalShape: InsettableShape {
    
    var insetAmount: CGFloat = CGFloat.zero

    let size1: Double = 4.0
    
    func path(in rect: CGRect) -> Path {
        return Path { path in
            
            let makeSize1: Double = rect.width/size1
            let makeSize2: Double = rect.width - makeSize1
            let horizontalHexagon = HorizontalHexagon(insetAmount: insetAmount)

            path.addPath(horizontalHexagon.path(in: CGRect(origin: CGPoint(x: rect.minX + makeSize1/2, y: rect.minY), size: CGSize(width: makeSize2, height: makeSize1))))
            path.addPath(horizontalHexagon.path(in: CGRect(origin: CGPoint(x: rect.minX + makeSize1/2, y: rect.midY - makeSize1/2), size: CGSize(width: makeSize2, height: makeSize1))))
            path.addPath(horizontalHexagon.path(in: CGRect(origin: CGPoint(x: rect.minX + makeSize1/2, y: rect.maxY - makeSize1), size: CGSize(width: makeSize2, height: makeSize1))))
 
        }
    }
    
    func inset(by amount: CGFloat) -> some InsettableShape {
        var myShape: Self = self
        myShape.insetAmount += amount
        return myShape
    }
}

我的 ContentView 代码：

struct ContentView: View {
    var body: some View {
        
        FinalShape()
            .strokeBorder(style: StrokeStyle(lineWidth: 5, lineCap: .round, lineJoin: .round))
            .background(Color.purple)
            .cornerRadius(5.0)
            .padding()

    }
}

更新：

struct HorizontalHexagon: InsettableShape {
    
    var insetAmount: CGFloat = CGFloat.zero

    func path(in rect: CGRect) -> Path {

        return Path { path in
            path.move(to: CGPoint(x: rect.minX + insetAmount, y: rect.midY))
            path.addLine(to: CGPoint(x: rect.width/4, y: rect.minY + insetAmount))
            path.addLine(to: CGPoint(x: rect.maxX - rect.width/4, y: rect.minY + insetAmount))
            
            path.addLine(to: CGPoint(x: rect.maxX - insetAmount, y: rect.midY))
            
            path.addLine(to: CGPoint(x: rect.maxX - rect.width/4, y: rect.maxY - insetAmount))
            path.addLine(to: CGPoint(x: rect.width/4, y: rect.maxY - insetAmount))
   
            path.closeSubpath()
            
        }
    }
    
    func inset(by amount: CGFloat) -> some InsettableShape {
        var myShape: Self = self
        myShape.insetAmount += amount
        return myShape
    }
    
}

我有一个枚举，我想切换它。使用可以从枚举类型本身访问的这样的代码，我尝试使用此代码但没有解决问题：

enum MyEnum {
    case yes
    case no
    
    mutating func toggle() {
        switch self {
        case .yes:
            MyEnum.no
        default:
            MyEnum.yes
        }
    }
}

func ff() {
    var test: MyEnum = MyEnum.yes
    test.toggle()
}

我想更新嵌套项目数组中的项目，为了展示问题，我在下面编写了示例代码，这个问题的重点是更新嵌套项目而不是 SwiftUI 技巧。我想找到一个知道其 id 的项目，找到后尝试更新。在下面的代码中，我向您展示了更新第一层项目的示例，但只要层数更深，我们就无法猜测它可以是 2 层还是 10 层，我们不知道。我怎样才能更新item1、item2和item4？

    import SwiftUI


@main
struct findItem_testApp: App {
    var body: some Scene {
        WindowGroup {
            ContentView().environmentObject(ItemModel.shared)
        }
    }
}


    
    struct ContentView: View {
        
        @EnvironmentObject var itemModel: ItemModel
        
        var body: some View {
            
            VStack {
    
                MyView(item: itemModel.items[0])
                MyView(item: itemModel.items[1].nestedItems[0].nestedItems[0])
                MyView(item: itemModel.items[1].nestedItems[0])
                MyView(item: itemModel.items[1])
                MyView(item: itemModel.items[2].nestedItems[0])
                MyView(item: itemModel.items[2])
    
            }
    
        }
    }
    
    struct MyView: View {
        
        let item: ItemType
        
        var body: some View {
    
            Text(item.name)
                .bold()
                .padding()
                .onTapGesture {
                    print(item.name, item.id)
                    // need to update item.name from model
                    ItemModel.shared.updateName(id: item.id, value: item.name + " updated!")
                }
      
        }
    }
    
    
    
    struct ItemType: Identifiable {
    
        let id: UUID
        var name: String
        var nestedItems: [ItemType]
    
        init(name: String, nestedItems: [ItemType]) {
            self.id = UUID()
            self.name = name
            self.nestedItems = nestedItems
        }
        
    }
    
    let item0: ItemType = ItemType(name: "item0", nestedItems: [])
    
    let item1: ItemType = ItemType(name: "item1", nestedItems: [])
    let item2: ItemType = ItemType(name: "item2", nestedItems: [item1])
    let item3: ItemType = ItemType(name: "item3", nestedItems: [item2])
    
    let item4: ItemType = ItemType(name: "item4", nestedItems: [])
    let item5: ItemType = ItemType(name: "item5", nestedItems: [item4])
    
    
    class ItemModel: ObservableObject {
        
        static let shared: ItemModel = ItemModel()
        
        @Published var items: [ItemType] = [ItemType]()
        
        init() {
            self.items = [item0, item3, item5]
        }
    
        func updateName(id: UUID, value: String) {
    
            for i in (0 ..< self.items.count) {
    
                if (self.items[i].id == id) {
                    self.items[i].name = value
                    break
                }
    
            }
     
        }
    
    }

我正在使用此代码在我的 swiftui 应用程序中包含 1 行文本字符串。

 Text("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.")
  .lineLimit(1)

结果是：“Lorem ipsum dolor sat amet，consec...”

我想要这样的东西：“Lorem ipsum dolor sat ame...id est labourum”

我在代码中有一个这样的结构，它是可识别的并且也有嵌套项：

struct Item: Identifiable {
    
    let id: UUID = UUID()
    var nameOfItem: String
    var nestedItems: [Item]
    
    init(nameOfItem: String, nestedItems: [Item]) {
        self.nameOfItem = nameOfItem
        self.nestedItems = nestedItems
    }

}

var myArray: [Item] = [Item]()

我的问题是，在构建数组后，如果我需要更新某个项目，我知道该项目的 ID，但我不知道如何查找该 ID 并以正确的方式找到它。看这张照片，我可以查看 myArray 中的每个项目以找到与我的查找 ID 匹配的项目，如果 myArray 项目没有我要查找的项目，我必须开始在每个数组项目的嵌套项目中查找，这将花费大量时间。寻找是否有更快的方法来找到所需的项目。

我在开发应用程序时需要查看应用程序沙盒内部，例如查看创建的数据文件或删除旧书签等，Xcode 中是否有一个选项或按钮可以在 macOS 应用程序或 iOS 应用程序中显示我们应用程序的沙盒？