Duck's questions

Eu tenho este código:

import SwiftUI

struct ContentView: View {
  @State var show = false
  
  var tools = [Tool("document.on.document"), Tool("document.on.clipboard")]
  
  var body: some View {
    HStack{
      HStack {
        ForEach(tools,  id:\.id) { tool in
          Button(action: {
            print("toggle")
            show.toggle()
          }, label: {
            Image(systemName:tool.name)
              .imageScale(.large)
              .foregroundStyle(.black.gradient)
              .font(.system(size: 30))
          })
          .contentShape(Rectangle())
          .popover(isPresented: $show, arrowEdge: .top) {
            Color.red
              .frame(width:400, height:400)
              .onAppear{
                print("popover show")
              }
          }
        }

        
      }

      .padding()
    }
    .background(
      RoundedRectangle(cornerSize: CGSize(width: 50,height: 50))
        .fill(.red.opacity(0.5).gradient))
    
    .padding()
    
    
  }
}

#Preview {
  ContentView()
}

struct Tool: Identifiable, Equatable {
  let id = UUID()
  let name:String
  
  init(_ name: String) {
    self.name = name
  }
}

o popover não aparece. Eu fiz tudo.

Por que é que?

Eu gostaria de passar um objeto de ambiente para algo UIViewRepresentableassim:

DrawingUI()
  .environmentObject(toolbarModel)

Isso toolbarModeltem uma propriedade chamada selectedUIColorque preciso UIViewRepresentableatualizar.

Então eu tenho isso:

struct DrawingUI: UIViewRepresentable {
  @EnvironmentObject private var toolbarModel:ToolbarModel

...

let coordinator = Coordinator(!!!!!)

class Coordinator: NSObject, PKToolPickerObserver {
// for some reason I have to have this property
// again because I did not find a way to set the
// same property outside the coordinator
private var toolbarModel:ToolbarModel

private var selectedUIColor:UIColor {
  didSet {
    toolbarModel.selectedUIColor = selectedUIColor
  }
}

init(_ toolbarModel:ToolbarModel) {
  self.toolbarModel = toolbarModel
}

...

func makeCoordinator() -> PencilKitSwiftUI.Coordinator {
  return Coordinator(!!!!!)
}

Meu problema é: O que coloco nas !!!!!peças?

Considere este código:

import SwiftUI

struct ContentView: View {
  @State private var hidden = true
    var body: some View {
        HStack {
          Group{
            if !hidden {
              Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(Color.black)
                .font(.system(size: 50))
                .opacity(hidden ? 0 : 1)
                .animation(.easeInOut(duration: 0.5).delay(1), value: hidden)
            }
            Image(systemName: "globe")
              .imageScale(.large)
              .foregroundStyle(Color.white)
              .font(.system(size: 50))
            
            if !hidden {
              Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(Color.yellow)
                .font(.system(size: 50))
                .opacity(hidden ? 0 : 1)
                .animation(.easeInOut(duration: 0.5).delay(3), value: hidden)    
            }
          }
          .padding(.horizontal, 10)
          .padding(.vertical, 5)              
        }
        .onTapGesture {
          withAnimation{
            hidden.toggle()
          }
        }
        .background(
          RoundedRectangle(cornerSize: CGSize(width: 50,height: 50))
            .fill(.red)
        )
        .padding()
    }
}

#Preview {
    ContentView()
}

Este código mostra um globo branco sobre um círculo branco como este, inicialmente.

Quando você toca no círculo, o menu se expande para ser uma elipse com outros dois globos.

Os globos preto e amarelo aparecem desaparecendo ao mesmo tempo que a elipse se expande, mas não é isso que eu quero.

Quero que todos os globos sejam empilhados na mesma posição central. Neste ponto, apenas o globo central é visível e os outros dois são invisíveis. À medida que o círculo vermelho é tocado e começa a se expandir, quero que o globo 1 se mova para a esquerda e o globo 3 se mova para a direita, enquanto eles perseguiam a nova fronteira que está se expandindo. Ao mesmo tempo em que estão se movendo, estão mudando a transparência para 1.

Se a elipse agora for tocada, quero que aconteça o inverso.

como faço isso?

Estou construindo um pacote que contém muitas classes, extensões e módulos que venho construindo desde que comecei a desenvolver para iOS em 2008.

Como também desenvolvo para macOS, watchOS, iPadOS e tvOS, este pacote possui código para todos os tipos ou dispositivos Apple.

Neste pacote em particular, tenho coisas para iOS e tvOS.

O pacote é declarado como:

import PackageDescription

let package = Package(
  name: "MyPackage",
  platforms: [.iOS(.v16), .tvOS(.v13)],
  products: [
    // Products define the executables and libraries a package produces, making them visible to other packages.
    .library(
      name: "MyPackage",
      targets: ["MyPackage"]),
  ],
  targets: [
    .target(name: "MyPackage"),
    .testTarget(name: "MyPackageTests", dependencies: ["MyPackage"])
  ]
)

Importei este pacote para um projeto que tem dois destinos, um para iOS e outro para watchOS porque quero usar o material que ele contém para iOS no destino iOS.

Agora estou depurando o destino iOS. Mesmo assim, o Xcode apresenta muitos erros, pois está tentando compilar o pacote no destino watchOS.

Isso me obriga a adicionar #if !os("watchOS)e #endifem cada arquivo o pacote tem que isolar o código e evitar que ele seja compilado pelo Xcode para o destino watchOS. Isso é muito estúpido porque o pacote é declarado assim:

platforms: [.iOS(.v16), .tvOS(.v13)],

E porque o pacote acabou de ser adicionado para o destino iOS.

Existe alguma maneira de fazer o Xcode funcionar conforme o esperado e não compilar um pacote para um destino para o qual não foi declarado?

Eu tenho uma string assim:

let muString = "\n\nFebruary 11, 2012\n\nThis natural-color image showing Acme Inc\'s logo... bla bla bla “Mount Everest”... bla bla 'Black Viper' ... bla bla. \"Naja\""

Em outras palavras, tenho citações inteligentes

` ´ ' ' “ ”

(nota: SO não está renderizando corretamente os caracteres anteriores. Quero dizer, eles estão abrindo e fechando aspas simples e duplas).

e também aspas duplas e quero substituir tudo por uma única aspa ASCII simples.

Eu criei esta extensão:

extension String {
  func plainText() -> String {
    var newString = self.replacingOccurrences(of: "\u{0060}", with: "'")
    newString = self.replacingOccurrences(of: "\u{00b4}", with: "'")
    newString = self.replacingOccurrences(of: "\u{2018}", with: "'")
    newString = self.replacingOccurrences(of: "\u{2019}", with: "'")
    newString = self.replacingOccurrences(of: "\u{201c}", with: "'")
    newString = self.replacingOccurrences(of: "\u{201d}", with: "'")
    newString = self.replacingOccurrences(of: "\"", with: "'")
    return newString
  }
}

Mas fazendo

print (myString.plainText())

me dá o mesmo que myStringsozinho.

Em outras palavras, a extensão não limpa nada.

Alguma ideia?

Eu criei um estilo de botão para personalizar um botão. Algo assim:

struct BlueButtonStyle: ButtonStyle {
    func makeBody(configuration: Configuration) -> some View {
        configuration.label
            .padding()
            .background(Color(red: 0, green: 0, blue: 0.5))
            .foregroundStyle(.white)
            .clipShape(Capsule())
    }
}

Para usar isso, tenho que chamá-lo assim e está funcionando bem.

.buttonStyle(BlueButtonStyle(... my parameters))

NOTA: no meu caso estou passando parâmetros para ele.

Mas em vez disso, eu gostaria de chamá-lo assim

.blueButtonStyle(... my parameters)

Se esse fosse um modificador de visualização normal, eu faria o seguinte:

extension View {
  func blueButtonStyle(... my parameters) -> some View {
    self.modifier(BlueButtonStyle(... my parameters)
}

Isso compila bem, mas quando tento usar

.blueButtonStyle(... my parameters)

eu recebo

Value of type 'Button<some View>' has no member 'blueButtonStyle'

o que está errado?

Existem outras respostas no SO sobre esse problema, mas nenhuma resolveu o problema porque, no meu caso, estou usando uma NSViewRepresentablevisualização cacau, que não é exatamente uma visualização SwiftUI.

Eu tenho este código:

struct MyObject: Hashable, Identifiable {
  let id: UUID = UUID()
  var name, brand: String
  init(name: String = "", brand: String = "") {
    self.name = varName
    self.brand = brand
  }
}

final class Model:ObservableObject {
  @Published var objects = (0..<3).compactMap {_ in
    return MyObject()
  }
}

struct ContentView: View {
  
  private let columns = [GridItem(.flexible()), GridItem(.flexible())]
  @StateObject private var model = Model()
    
  var body: some View {
    VStack{
      LazyVGrid(
        columns: columns,
        alignment: .center,
        spacing: 10,
        pinnedViews: []
      ) {
        ForEach($model.objects, id:\.id) {$object in
          MyTextField($initObject)
        }
      }
      
    }
    .padding(20)
  }
}

struct MyTextField: View {
  @Binding private var initObject:InitObject
  
  init(_ initObject:Binding<InitObject>) {
    _initObject = initObject
  }
  
  var body: some View {
    AppKitTextField(property: $initObject.name,
                    placeholder: "name",
                    fontName:"Avenir-Medium",
                    fontSize:18) { text in
    }
    
    MyAppKitTextField(property: $initObject.type,
                    placeholder: "type",
                    fontName:"Avenir-Medium",
                    fontSize:18)
      
    }
  }

O problema é que MyAppKitTextField é um AppKit NSTextField NSViewRepresentable, assim:

public struct AppKitTextField: NSViewRepresentable {
  public typealias NSViewType = NSTextField
  @Binding var property: String

  public init(property: Binding<String>) {
    self._property = property
  }
    
  public class Coordinator: NSObject, NSTextFieldDelegate {
    @Binding private var text: String
    
    init(text: Binding<String>) {
      self._text = text
    }
  }

    public func makeNSView(context: NSViewRepresentableContext<AppKitTextField>) -> NSTextField {
        let textField = NSTextField()
        textField.delegate = context.coordinator
        textField.stringValue = property
        return textField
      }
      
      public func makeCoordinator() -> AppKitTextField.Coordinator {
        return Coordinator(text: $property)
      }
      
      public func updateNSView(_ nsView: NSTextField, context: Context) {
        nsView.stringValue = property
      }
    }
}

Meu problema é a linha

@Binding var property: String

Quando tento usar essa visualização, vejo este erro:

Accessing StateObject's object without being installed on a View. This will create a new instance each time.

Antigamente, quando você precisava controlar algo que está profundamente na hierarquia de visualização, você poderia simplesmente usar

NotificationCenter.default.addObserver

e, em seguida, poste notificações em seus objetos e eles serão alterados.

Agora com o SwiftUI, se você tiver apenas um nível de visualizações, você pode simplesmente passar a @Statevariável para a próxima visualização, que então fará uma ligação a ela.

Mas imagine uma visualização com 4 visualizações de profundidade.

View A > View B > View C > View D

Não acho que seria elegante passar a @Statevariável com 4 níveis de profundidade, então View Dposso alterá-la.

Outra maneira feia seria criar um @Observablesingleton com uma @Publishedvariável.

Qual é a prática comum para fazer isso?