在Swift3中使用CGPattern回調時遇到麻煩

Question

我試圖在Swift中使用CGPattern創建一個彩色模式。 Apple在其Painting Colored Patterns的部分中的Quartz 2D Programming Guide中提供了一個很好的Objective-C示例。但是從Objective-C轉換所有的語法並不是直截了當的。另外我想在圖紙回調中使用info參數，並且沒有這樣做的例子。

這是我第一次嘗試：

class SomeShape { 
    func createPattern() -> CGPattern? { 
     let bounds = CGRect(x: 0, y: 0, width: someWidth, height: someHeight) 
     let matrix = CGAffineTransform.identity 
     var callbacks = CGPatternCallbacks(version: 0, drawPattern: nil, releaseInfo: nil) 

     let res = CGPattern(info: nil, bounds: bounds, matrix: matrix, xStep: bounds.width, yStep: bounds.height, tiling: .noDistortion, isColored: true, callbacks: &callbacks) 

     return res 
    } 
} 

顯然，這需要爲drawPattern參數CGPatternCallbacks一個合適的值，我需要通過self爲info參數爲CGPattern初始化。

完成此操作的正確語法是什麼？

Answer 1

如你說in your answer，CGPatternDrawPatternCallback定義爲：

typealias CGPatternDrawPatternCallback = 
           @convention(c) (UnsafeMutableRawPointer?, CGContext) -> Void 

的@convention(c)屬性（其僅出現在生成的頭會顯示）意味着使用的函數值必須是兼容C，因此無法捕獲任何上下文（因爲C函數值只不過是指向函數的原始指針，並且不存儲額外的上下文對象）。

因此，如果要在功能中使用上下文，則需要將自己的UnsafeMutableRawPointer?傳遞給參數CGPattern's initialiser的info:。這將作爲被調用的給定繪圖模式函數的第一個參數傳遞。

爲了將self傳遞給此參數，您可以使用Unmanaged。這允許您在引用和不透明指針之間進行轉換，並且與unsafeBitCast不同，它還允許您在執行此操作時控制引用的內存管理。

既然我們都難保的createPattern()主叫方將繼續保留self，我們不能只是將其傳遞到info:參數不保留它自己。如果通過時沒有保留（例如使用unsafeBitCast），然後在繪製模式之前解除分配 - 嘗試在繪圖回調中使用懸掛指針時，您會得到未定義的行爲。

隨着Unmanaged：

• 您可以通過參考作爲保留+1不透明指針與passRetained(_:).toOpaque()

• 你可以拿回這個指針與fromOpaque(_:).takeUnretainedValue()參考（和實例將保持保留）

• 然後，您可以使用fromOpaque(_:).release()消費+1保留。當CGPattern被釋放時，你會想要這樣做。

例如：

class SomeShape { 
    // the bounds of the shape to draw 
    let bounds = CGRect(x: 0, y: 0, width: 40, height: 40) 

    func createPattern() -> CGPattern? { 

     var callbacks = CGPatternCallbacks(version: 0, drawPattern: { info, ctx in 

      // cast the opaque pointer back to a SomeShape reference. 
      let shape = Unmanaged<SomeShape>.fromOpaque(info!).takeUnretainedValue() 

      // The code to draw a single tile of the pattern into "ctx"... 
      // (in this case, two vertical strips) 
      ctx.saveGState() 
      ctx.setFillColor(UIColor.red.cgColor) 
      ctx.fill(CGRect(x: 0, y: 0, 
          width: shape.bounds.width/2, height: shape.bounds.height)) 

      ctx.setFillColor(UIColor.blue.cgColor) 
      ctx.fill(CGRect(x: 20, y: 0, 
          width: shape.bounds.width/2, height: shape.bounds.height)) 
      ctx.restoreGState() 

     }, releaseInfo: { info in 
      // when the CGPattern is freed, release the info reference, 
      // consuming the +1 retain when we originally passed it to the CGPattern. 
      Unmanaged<SomeShape>.fromOpaque(info!).release() 
     }) 

     // retain self before passing it off to the info: parameter as an opaque pointer. 
     let unsafeSelf = Unmanaged.passRetained(self).toOpaque() 

     return CGPattern(info: unsafeSelf, bounds: bounds, matrix: .identity, 
         xStep: bounds.width, yStep: bounds.height, 
         tiling: .noDistortion, isColored: true, callbacks: &callbacks) 
    } 
} 

另外，如果你想爲SomeShape值語義更好的解決方案，你可以讓它變成一個struct。然後創建模式時，你可以把它包裝起來的Context堆分配箱其傳遞到info:參數之前：

struct SomeShape { 

    // the bounds of the shape to draw 
    let bounds = CGRect(x: 0, y: 0, width: 40, height: 40) 

    func createPattern() -> CGPattern? { 

     final class Context { 
      let shape: SomeShape 
      init(_ shape: SomeShape) { self.shape = shape } 
     } 

     var callbacks = CGPatternCallbacks(version: 0, drawPattern: { info, ctx in 

      // cast the opaque pointer back to a Context reference, 
      // and get the wrapped shape instance. 
      let shape = Unmanaged<Context>.fromOpaque(info!).takeUnretainedValue().shape 

      // ... 

     }, releaseInfo: { info in 
      // when the CGPattern is freed, release the info reference, 
      // consuming the +1 retain when we originally passed it to the CGPattern. 
      Unmanaged<Context>.fromOpaque(info!).release() 
     }) 

     // wrap self in our Context box before passing it off to the info: parameter as a 
     // +1 retained opaque pointer. 
     let unsafeSelf = Unmanaged.passRetained(Context(self)).toOpaque() 

     return CGPattern(info: unsafeSelf, bounds: bounds, matrix: .identity, 
         xStep: bounds.width, yStep: bounds.height, 
         tiling: .noDistortion, isColored: true, callbacks: &callbacks) 
    } 
} 

現在，這也需要的任何保留週期的擔憂護理。

Answer 2

我們先看CGPatternDrawPatternCallback。它被定義爲：

typealias CGPatternDrawPatternCallback = (UnsafeMutableRawPointer?, CGContext) -> Void 

所以這是一個封閉，它有兩個參數 - info和繪圖上下文。

有了這些信息，你可以創建CGPatternCallback如下：

var callbacks = CGPatternCallbacks(version: 0, drawPattern: { (info, ctx) in 
    // Drawing code here 
}, releaseInfo: { (info) in { 
    // Cleanup code here 
}) 

但還有這裏需要注意一些重要的事情。這些關閉的身體無法捕捉任何東西。如果試圖這樣做，你會得到以下錯誤：

A C function point cannot be formed from a closure that captures context

這就是爲什麼info參數需要使用。在創建圖案時，您可以傳遞self或其他一些對象作爲info參數，並在繪圖回調中使用該參數。但是這不是一個簡單的任務，因爲您不能簡單地通過self作爲info參數。您需要將其轉換爲所需的UnsafeMutableRawPointer，然後將其從圖形回調中的指針轉換回來。

下面是與所有設置的完整代碼：

class SomeShape { 
    func createPattern() -> CGPattern? { 
     let bounds = CGRect(x: 0, y: 0, width: someWidth, height: someHeight) // The size of each tile in the pattern 
     let matrix = CGAffineTransform.identity // adjust as needed 
     var callbacks = CGPatternCallbacks(version: 0, drawPattern: { (info, ctx) in 
      let shape = unsafeBitCast(info, to: SomeShape.self) 

      // The needed drawing code to draw one tile of the pattern into "ctx" 
     }, releaseInfo: { (info) in 
      // Any cleanup if needed 
     }) 

     let unsafeSelf = unsafeBitCast(self, to: UnsafeMutableRawPointer.self) 

     let res = CGPattern(info: unsafeSelf, bounds: bounds, matrix: matrix, xStep: bounds.width, yStep: bounds.height, tiling: .noDistortion, isColored: true, callbacks: &callbacks) 

     return res 
    } 
} 

，並利用該CGPattern，你可以做這樣的事情：

func draw(_ ctx: CGContext) { 
    // Any other needed setup 

    let path = CGPath(....) // some path 

    // Code to fill a path with the pattern 
    ctx.saveGState() 
    ctx.addPath(path) // The path to fill 

    // Setup the pattern color space for the colored pattern 
    if let cs = CGColorSpace(patternBaseSpace: nil) { 
     ctx.setFillColorSpace(cs) 
    } 

    // Create and apply the pattern and its opacity 
    if let fillPattern = someShapeInstance.createPattern() { 
     var fillOpacity = CGFloat(1.0) 
     ctx.setFillPattern(fillPattern, colorComponents: &strokeOpacity) 
    } 

    ctx.fillPath(using: theDesiredFillRule) 
    ctx.restoreGState() 

    // Any other drawing 
} 

當使用彩色模式（與一個模板，非彩色圖案），您必須在設置填充圖案之前設置填充顏色空間。

您還可以使用模式來描邊路徑。只需使用setStrokeColorSpace和setStrokePattern即可。