ひtoりgoと

import Cocoa

class CanvasView: NSView
{
    var cursorTrackingArea: NSTrackingArea!

    private func _commonInit()
    {
        layerContentsRedrawPolicy = .onSetNeedsDisplay
        cursorTrackingArea = NSTrackingArea(rect: .zero, options: [.activeInKeyWindow, .cursorUpdate, .inVisibleRect], owner: self, userInfo: nil)
        addTrackingArea(cursorTrackingArea)
    }
    override init(frame: NSRect)
    {
        super.init(frame: frame)
        _commonInit()
    }
    required init?(coder: NSCoder)
    {
        super.init(coder: coder)
        _commonInit()
    }
    deinit
    {
        removeTrackingArea(cursorTrackingArea)
    }

    //MARK: - View Flags

    override var wantsUpdateLayer: Bool { return true }
    override var isOpaque: Bool { return true }

    override var canBecomeKeyView: Bool { return true }
    override var acceptsFirstResponder: Bool { return true }

    //MARK: - Drawing

    override func updateLayer()
    {
        layer?.backgroundColor = NSColor.textBackgroundColor.cgColor
    }

    //MARK: - Hit Test

    override func hitTest(_ pointInSuperview: NSPoint) -> NSView?
    {
        if effectiveTool.interceptsDescendantEvents {
            guard let point = superview?.convert(pointInSuperview, to: self) else {
                return nil
            }
            return (isMousePoint(point, in: bounds) ? self : nil)
        } else {
            return super.hitTest(pointInSuperview)
        }
    }

    //MARK: - Mouse Events

    override func mouseDown(with event: NSEvent)
    {
        window?.makeFirstResponder(self)

        switch effectiveTool {
        case .hand:
            window?.trackEvents(matching: [.leftMouseDragged, .leftMouseUp], timeout: 0.5, mode: .eventTracking, handler: { (event, stopPtr) in
                //check the button state just in case.
                guard ((NSEvent.pressedMouseButtons & (1 << 0)) != 0) else {
                    stopPtr.pointee = true
                    return
                }
                guard let event = event else {
                    return
                }
                switch event.type {
                case .leftMouseUp:
                    stopPtr.pointee = true
                default:
                    //do some work for scroll here.
                    break
                }
            })
        default:
            break
        }
    }

    //MARK: - Keyboard Events

    override func keyDown(with event: NSEvent)
    {
        if (event.keyCode == 49/*space*/) {
            isSpaceBarPressed = true
        } else {
            isSpaceBarPressed = false
            super.keyDown(with: event)
        }
    }
    override func keyUp(with event: NSEvent)
    {
        if (event.keyCode == 49/*space*/) {
            isSpaceBarPressed = false
        } else {
            super.keyUp(with: event)
        }
    }

    //MARK: - Cursor Events

    override func cursorUpdate(with event: NSEvent)
    {
        effectiveTool.cursor.set()
    }

    //MARK: - Tool

    public enum Tool
    {
        case select
        case hand

        var cursor: NSCursor
        {
            switch self {
            case .select:
                return .arrow
            case .hand:
                return .openHand
            }
        }
        var interceptsDescendantEvents: Bool
        {
            switch self {
            case .hand:
                return true
            default:
                return false
            }
        }
    }

    /// Tool selected by user.
    public var tool = Tool.select
    {
        didSet { updateEffectiveTool() }
    }

    /// Actual effective tool which generally equals to `tool` but changes on some conditions.
    public private(set) var effectiveTool = Tool.select
    {
        didSet
        {
            if (oldValue != effectiveTool) {
                window?.invalidateCursorRects(for: self)
            }
        }
    }
    private func updateEffectiveTool()
    {
        if isSpaceBarPressed {
            effectiveTool = .hand
        } else {
            effectiveTool = tool
        }
    }

    //MARK: - Keyboard Flags

    private var isSpaceBarPressed = false
    {
        didSet { updateEffectiveTool() }
    }
}