[Xcode 8.1] サンプルコードからTouchBarのAPIを理解する#5 NSTouchBar CatalogのCustom Viewの構造と処理

import Cocoa

fileprivate extension NSTouchBarCustomizationIdentifier {
    static let customViewBar = NSTouchBarCustomizationIdentifier("com.TouchBarCatalog.customViewBar")
}

fileprivate extension NSTouchBarItemIdentifier {
    static let touchEvent = NSTouchBarItemIdentifier("com.TouchBarCatalog.TouchBarItem.touchEvent")
    static let panGR = NSTouchBarItemIdentifier("com.TouchBarCatalog.TouchBarItem.panGR")
}

fileprivate enum InteractionTypeButtonTag: Int {
    case touchEvent = 1000, panGR = 1001
}

class CustomViewViewController: NSViewController {

    @IBOutlet weak var feedbackLabel: NSTextField!

    var selectedItemIdentifier: NSTouchBarItemIdentifier = .touchEvent

    // MARK: NSTouchBar

    override func makeTouchBar() -> NSTouchBar? {
        let touchBar = NSTouchBar()
        touchBar.delegate = self
        touchBar.customizationIdentifier = .customViewBar
        touchBar.defaultItemIdentifiers = [selectedItemIdentifier]
        touchBar.customizationAllowedItemIdentifiers = [selectedItemIdentifier]

        return touchBar
    }

    // MARK: Action Functions

    @IBAction func choiceAction(_ sender: AnyObject) {
        guard let button = sender as? NSButton,
            let choice = InteractionTypeButtonTag(rawValue:button.tag) else { return }

        switch choice {
        case .touchEvent:
            selectedItemIdentifier = .touchEvent

        case .panGR:
            selectedItemIdentifier = .panGR
        }

        touchBar = nil
    }

    // MARK: Gesture Recognizer

    func panGestureHandler(_ sender: NSGestureRecognizer?) {
        guard let currentItem = self.touchBar?.item(forIdentifier: selectedItemIdentifier),
            let itemView = currentItem.view, let panGR = sender else { return }

        var feedbackStr = "Pan Gesture: "
        let state = sender!.state

        switch state {
        case .began:
            feedbackStr += "Began"

        case .changed:
            feedbackStr += "Changed"

        case .ended:
            feedbackStr += "Ended"

        default:
            break
        }

        let location = panGR.location(in: itemView)
        feedbackStr += String(format: " {x = %3.2f}", location.x)

        feedbackLabel.stringValue = feedbackStr;
    }

    deinit {
        feedbackLabel.unbind(NSValueBinding)
    }
}

// MARK: NSTouchBarDelegate

extension CustomViewViewController: NSTouchBarDelegate {

    func touchBar(_ touchBar: NSTouchBar, makeItemForIdentifier identifier: NSTouchBarItemIdentifier) -> NSTouchBarItem? {

        switch identifier {
        case NSTouchBarItemIdentifier.touchEvent:
            let canvasView = CanvasView()
            canvasView.wantsLayer = true
            canvasView.layer?.backgroundColor = NSColor.blue.cgColor
            canvasView.allowedTouchTypes = .direct

            feedbackLabel.unbind(NSValueBinding)
            feedbackLabel.bind(NSValueBinding, to: canvasView, withKeyPath: #keyPath(CanvasView.trackingLocationString))

            let custom = NSCustomTouchBarItem(identifier: identifier)
            custom.view = canvasView

            return custom

        case NSTouchBarItemIdentifier.panGR:
            let view = NSView()
            view.wantsLayer = true
            view.layer?.backgroundColor = NSColor.gray.cgColor

            let panGestureRecognizer = NSPanGestureRecognizer()
            panGestureRecognizer.target = self
            panGestureRecognizer.action = #selector(panGestureHandler(_:))
            panGestureRecognizer.allowedTouchTypes = .direct
            view.addGestureRecognizer(panGestureRecognizer)

            let custom = NSCustomTouchBarItem(identifier: identifier)
            custom.view = view
            return custom

        default:
            return nil
        }
    }
}

class CanvasView: NSView {

    // This is to keep the current tracking touch (figure). 
    // The Touch Bar supports multiple touches but since it has only 30-point height,
    // it is reasonable to only track one touch.
    var trackingTouchIdentity: AnyObject?

    // Marked as dynamic for this property to support KVO.
    dynamic var trackingLocationString = ""

    // NSView by default doesn't accept first responder, so override this to allow it.
    override var acceptsFirstResponder: Bool { return true }

    override func touchesBegan(with event: NSEvent) {
        // trackingTouchIdentity != nil:
        // We are already tracking a touch, so ignore this new touch.
        if trackingTouchIdentity == nil {
            if let touch = event.touches(matching: .began, in: self).first, touch.type == .direct {
                trackingTouchIdentity = touch.identity
                let location = touch.location(in: self)
                trackingLocationString = String(format: "Began at: {x = %3.2f}", location.x)
            }
        }

        super.touchesBegan(with: event)
    }

    override func touchesMoved(with event: NSEvent) {
        if let trackingTouchIdentity = self.trackingTouchIdentity {
            if let trackingTouch = event.touches(matching: .moved, in: self).filter({
                $0.type == .direct && $0.identity.isEqual(trackingTouchIdentity)}).first {

                let location = trackingTouch.location(in: self)
                trackingLocationString = String(format: "Moved at: {x = %3.2f}", location.x)
            }
        }

        super.touchesMoved(with: event)
    }

    override func touchesEnded(with event: NSEvent) {
        if let trackingTouchIdentity = self.trackingTouchIdentity {
            if let trackingTouch = event.touches(matching: .ended, in: self).filter({
                $0.type == .direct && $0.identity.isEqual(trackingTouchIdentity)}).first {

                self.trackingTouchIdentity = nil
                let location = trackingTouch.location(in: self)
                trackingLocationString = String(format: "Ended at: {x = %3.2f}", location.x)
            }
        }

        super.touchesEnded(with: event)
    }

    override func touchesCancelled(with event: NSEvent) {

        if let trackingTouchIdentity = self.trackingTouchIdentity {
            if let trackingTouch = event.touches(matching: .cancelled, in: self).filter({
                $0.type == .direct && $0.identity.isEqual(trackingTouchIdentity)}).first {

                self.trackingTouchIdentity = nil
                let location = trackingTouch.location(in: self)
                trackingLocationString = String(format: "Canceled at: {x = %3.2f}", location.x)

                // The touch will be cancelled, so roll back to the status before touchBegan
                //...
            }
        }

        super.touchesCancelled(with: event)
    }
}