giik's questions

Usando o seguinte

@main
struct aspectratioApp: App {
  var body: some Scene {
    WindowGroup { ContentView().border(.blue, width: 2).padding() }
  }
}

e ContentViewsem o aspectRatiomodificador aplicado (veja abaixo), os resultados são como esperado, incl. Canvaspreenche o espaço disponível (que eu acho que é o comportamento padrão), gerando canvas size: (243.0, 78.0)no console:

Em seguida, vamos aplicar o .aspectRatio(isSquare ? 1 : nil, contentMode: isSquare ? .fit : .fill)modificador, que acredito que está dizendo para fazer Canvasum quadrado que se encaixe ou o que quer que preencha o espaço disponível (veja ContentView com aspectRatio abaixo). Logo de início, obtenho um quadrado Canvascomo este:

e um tamanho de tela quadrada impresso no console. A alternância isSquaremantém o quadrado da tela com um tamanho ligeiramente menor:

canvas size: (157.0, 157.0)
canvas size: (130.0, 130.0)

O que estou esquecendo aqui? A documentação para aspectRatio documenta o parâmetro aspectRatio da seguinte forma: A proporção de largura para altura a ser usada para a visualização resultante. Use nil para manter a proporção atual na visualização resultante. que eu interpreto como significando qualquer que seja a proporção se o modificador não for aplicado.

Não é assim que funciona? O modificador não é stateless, ou seja, ele se lembrou de que a tela era quadrada uma vez e está apenas mantendo isso para sempre, incl. em reinicializações do aplicativo?

ContentView sem AspectRatio

struct ContentView: View {
  @State private var isSquare = false
  var body: some View {
    VStack {
      Text("isSquare: \(isSquare)").padding()
      Canvas { _, size in print("canvas size: \(size)") }
        .border(.teal, width: 2)
        .padding()
      Toggle(isOn: $isSquare) { Text("Constrain to Square") }.padding()
    }
    .border(.yellow, width: 2)
    .padding()
  }
}

ContentView com proporção de aspecto

struct ContentView: View {
  @State private var isSquare = false
  var body: some View {
    VStack {
      Text("isSquare: \(isSquare)").padding()
      Canvas { _, size in print("canvas size: \(size)") }
        .aspectRatio(isSquare ? 1 : nil, contentMode: isSquare ? .fit : .fill)
        .border(.teal, width: 2)
        .padding()
      Toggle(isOn: $isSquare) { Text("Constrain to Square") }.padding()
    }
    .border(.yellow, width: 2)
    .padding()
  }
}

O código a seguir funcionou muito bem como esperado até que eu joguei uma Textvisualização adicional escrita abaixo do Toggle(está comentado no código abaixo). Quando faço isso, recebo um erro Geometry action is cycle between duplicate values. e o programa eventualmente trava (no X86 15.2). Ele não trava de verdade, mas parece preso em algum loop infinito de atualização consumindo 100% de um núcleo e comendo RAM. Mesmo erro no M3 15.1, exceto que ainda não consegui fazê-lo travar/travar.

Parece um novo erro, já que o Google não retorna resultados para ele.

Alguém viu algo parecido? Se sim, o que significa?

Há algum problema com o código ou isso é um sinal de um possível bug no SwiftUI?

struct CaptureSizeView: ViewModifier {
  @Binding var size: CGSize

  func body(content: Self.Content) -> some View {
    content
      .onGeometryChange(for: CGSize.self) { proxy in proxy.size }
      action: { newValue in size = newValue }
  }
}

public extension View {
  func captureSize(_ size: Binding<CGSize>) -> some View {
    modifier(CaptureSizeView(size: size))
  }
}

public extension CGSize {
  var aspectRatio: CGFloat { self.width / self.height }
}

struct ContentView: View {
  @State private var clearSize: CGSize = .zero
  @State private var isSquare: Bool = false

  var body: some View {
    HStack(alignment: .top) {
      VStack(alignment: .leading) {
        Toggle("Keep Square", isOn: $isSquare).toggleStyle(.switch)
//  Uncomment: error "Geometry action is cycling between duplicate values."
//        Text("available size: \(clearSize)")
      }
      .padding()

      Divider()

      VStack {
        Text("Canvas")
          .font(.largeTitle)
          .fontWeight(.black)
        Text("available size: \(clearSize)")

        ZStack {
          Color.clear
            .border(.green)
            .captureSize($clearSize)
            .overlay {
              Canvas { _, _ in
              }
              .aspectRatio(isSquare ? 1 : clearSize.aspectRatio, contentMode: .fit)
              .background(.yellow)
            }
        }
        .padding()
      }
    }
  }
}

Então, se você Canvasquiser saber o tamanho (caixa delimitadora) de um símbolo resolvido, por exemplo, para posicionamento relativo a outros símbolos ou caminhos desenhados diretamente nele, isso não é possível inspecionando a propriedade GraphicsContext.ResolvedSymbol.size ?

Isto é surpreendente. Não sou um bloqueador do que quero fazer, mas gostaria de entender o porquê desse comportamento específico, se alguém souber e puder explicar?

Exemplo trivial para reproduzir abaixo, ao alternar as saídas dos botões

canvas size: (400.0, 350.0); symbol size: (400.0, 350.0)
toggled
canvas size: (500.0, 450.0); symbol size: (500.0, 450.0)
toggled
canvas size: (400.0, 350.0); symbol size: (400.0, 350.0)

struct ContentView: View {
  @State private var large = false
  var body: some View {
    VStack {
      Button {
        large.toggle()
        print("toggled")
      } label: {
        Text("Toggle Size")
      }
      Spacer()
      Canvas { context, size in
        let s0 = context.resolveSymbol(id: 0)!
        print("canvas size: \(size); symbol size: \(s0.size)")
        context.draw(s0, in: CGRect(origin: .zero, size: size))
      } symbols: {
        Path(ellipseIn: CGRect(origin: .zero, size: CGSize(width: 300, height: 300)))
          .stroke(.green, lineWidth: 10)
          .border(.blue)
          .tag(0)
      }
      .frame(width: large ? 500 : 400, height: large ? 450 : 350)
    }.padding()
  }
}