// AppKit runs on the process's main thread and nowhere else, and the main

// goroutine only stays on that thread if it is locked there before main

// starts. gogpu and Ebitengine do the same in their own darwin packages;

// this is what keeps it true in a build that leaves both of them out.

runtime.LockOSThread()

if v, ok := cocoaHosts.Load(id); ok {

return v.(*CocoaGuiHost)

}

return nil

cocoaRT.once.Do(func() {

cocoaRT.err = loadCocoaOnce()

})

return cocoaRT.err

// With cgo off nothing links the frameworks in, so the classes do not

// exist until the frameworks are loaded by hand.

if _, err := purego.Dlopen("/System/Library/Frameworks/AppKit.framework/AppKit", purego.RTLD_LAZY|purego.RTLD_GLOBAL); err != nil {

return fmt.Errorf("cocoa: loading AppKit: %w", err)

}

cg, err := purego.Dlopen("/System/Library/Frameworks/CoreGraphics.framework/CoreGraphics", purego.RTLD_LAZY|purego.RTLD_GLOBAL)

if err != nil {

return fmt.Errorf("cocoa: loading CoreGraphics: %w", err)

}

libobjc, err := purego.Dlopen("/usr/lib/libobjc.A.dylib", purego.RTLD_LAZY|purego.RTLD_GLOBAL)

if err != nil {

return fmt.Errorf("cocoa: loading libobjc: %w", err)

}

libSystem, err := purego.Dlopen("/usr/lib/libSystem.B.dylib", purego.RTLD_LAZY|purego.RTLD_GLOBAL)

if err != nil {

return fmt.Errorf("cocoa: loading libSystem: %w", err)

}

for _, fn := range []struct {

lib uintptr

name string

ptr any

}{

{cg, "CGColorSpaceCreateDeviceRGB", &cgColorSpaceCreateDeviceRGB},

{cg, "CGColorSpaceCreateWithName", &cgColorSpaceCreateWithName},

{cg, "CGBitmapContextCreate", &cgBitmapContextCreate},

{cg, "CGBitmapContextGetData", &cgBitmapContextGetData},

{cg, "CGBitmapContextGetBytesPerRow", &cgBitmapContextGetBytesPerRow},

{cg, "CGBitmapContextCreateImage", &cgBitmapContextCreateImage},

{cg, "CGContextRelease", &cgContextRelease},

{cg, "CGImageRelease", &cgImageRelease},

{libobjc, "objc_autoreleasePoolPush", &objcAutoreleasePoolPush},

{libobjc, "objc_autoreleasePoolPop", &objcAutoreleasePoolPop},

{libSystem, "pthread_main_np", &pthreadMainNP},

} {

sym, err := purego.Dlsym(fn.lib, fn.name)

if err != nil {

return fmt.Errorf("cocoa: resolving %s: %w", fn.name, err)

}

purego.RegisterFunc(fn.ptr, sym)

}

s := &cocoaSel

for _, sel := range []struct {

dst *objc.SEL

name string

}{

{&s.alloc, "alloc"}, {&s.init, "init"}, {&s.release, "release"},

{&s.sharedApplication, "sharedApplication"},

{&s.setActivationPolicy, "setActivationPolicy:"},

{&s.activateIgnoringOtherApps, "activateIgnoringOtherApps:"},

{&s.run, "run"}, {&s.stop, "stop:"},

{&s.postEventAtStart, "postEvent:atStart:"},

{&s.mainMenu, "mainMenu"}, {&s.setMainMenu, "setMainMenu:"},

{&s.delegate, "delegate"}, {&s.setDelegate, "setDelegate:"},

{&s.mainScreen, "mainScreen"}, {&s.screens, "screens"},

{&s.objectAtIndex, "objectAtIndex:"},

{&s.backingScaleFactor, "backingScaleFactor"}, {&s.frame, "frame"},

{&s.initWithContentRect, "initWithContentRect:styleMask:backing:defer:"},

{&s.setTitle, "setTitle:"}, {&s.setContentView, "setContentView:"},

{&s.makeFirstResponder, "makeFirstResponder:"},

{&s.setAcceptsMouseMovedEvents, "setAcceptsMouseMovedEvents:"},

{&s.setReleasedWhenClosed, "setReleasedWhenClosed:"},

{&s.setRestorable, "setRestorable:"},

{&s.center, "center"}, {&s.makeKeyAndOrderFront, "makeKeyAndOrderFront:"},

{&s.orderOut, "orderOut:"},

{&s.setContentSize, "setContentSize:"},

{&s.setContentMinSize, "setContentMinSize:"},

{&s.setContentResizeIncrements, "setContentResizeIncrements:"},

{&s.zoom, "zoom:"}, {&s.close, "close"},

{&s.setFrame, "setFrame:display:"},

{&s.setFrameTopLeftPoint, "setFrameTopLeftPoint:"},

{&s.setBackgroundColor, "setBackgroundColor:"},

{&s.blackColor, "blackColor"},

{&s.respondsToSelector, "respondsToSelector:"},

{&s.setTabbingMode, "setTabbingMode:"},

{&s.convertRectFromScreen, "convertRectFromScreen:"},

{&s.window, "window"},

{&s.initWithFrame, "initWithFrame:"},

{&s.setWantsLayer, "setWantsLayer:"}, {&s.layer, "layer"},

{&s.setLayerContentsRedrawPolicy, "setLayerContentsRedrawPolicy:"},

{&s.setLayerContentsPlacement, "setLayerContentsPlacement:"},

{&s.setNeedsDisplay, "setNeedsDisplay:"}, {&s.bounds, "bounds"},

{&s.convertPoint, "convertPoint:fromView:"},

{&s.performOnMain, "performSelectorOnMainThread:withObject:waitUntilDone:"},

{&s.setContents, "setContents:"},

{&s.setContentsScale, "setContentsScale:"},

{&s.keyCode, "keyCode"}, {&s.modifierFlags, "modifierFlags"},

{&s.characters, "characters"},

{&s.charactersIgnoringModifiers, "charactersIgnoringModifiers"},

{&s.eventType, "type"},

{&s.locationInWindow, "locationInWindow"},

{&s.clickCount, "clickCount"}, {&s.buttonNumber, "buttonNumber"},

{&s.scrollingDeltaY, "scrollingDeltaY"},

{&s.hasPreciseScrollingDeltas, "hasPreciseScrollingDeltas"},

{&s.otherEvent, "otherEventWithType:location:modifierFlags:timestamp:windowNumber:context:subtype:data1:data2:"},

{&s.initWithUTF8String, "initWithUTF8String:"},

{&s.lengthOfBytes, "lengthOfBytesUsingEncoding:"},

{&s.getCString, "getCString:maxLength:encoding:"},

{&s.initWithTitle, "initWithTitle:"}, {&s.addItem, "addItem:"},

{&s.addItemWithTitle, "addItemWithTitle:action:keyEquivalent:"},

{&s.separatorItem, "separatorItem"}, {&s.setSubmenu, "setSubmenu:"},

{&s.hide, "hide:"}, {&s.terminate, "terminate:"},

{&s.performKeyEquivalent, "performKeyEquivalent:"},

{&s.runQueued, "vtuiRunQueued:"},

{&s.replyToApplicationShouldTerminate, "replyToApplicationShouldTerminate:"},

{&s.vtuiReplyTerminate, "vtuiReplyTerminate:"},

} {

*sel.dst = objc.RegisterName(sel.name)

}

for _, c := range []struct {

dst *objc.Class

name string

}{

{&cocoaRT.classNSApplication, "NSApplication"},

{&cocoaRT.classNSWindow, "NSWindow"},

{&cocoaRT.classNSEvent, "NSEvent"},

{&cocoaRT.classNSString, "NSString"},

{&cocoaRT.classNSScreen, "NSScreen"},

{&cocoaRT.classNSMenu, "NSMenu"},

{&cocoaRT.classNSMenuItem, "NSMenuItem"},

{&cocoaRT.classNSColor, "NSColor"},

} {

if *c.dst = objc.GetClass(c.name); *c.dst == 0 {

return fmt.Errorf("cocoa: class %s not found", c.name)

}

}

if err := registerCocoaClasses(); err != nil {

return err

}

// sRGB, so a palette colour means on screen what it means in every

// terminal; the name is compared by value, so an NSString of our own

// stands in for the kCGColorSpaceSRGB constant.

name := cocoaNSString("kCGColorSpaceSRGB")

cocoaRT.colorSpace = cgColorSpaceCreateWithName(uintptr(name))

name.Send(cocoaSel.release)

if cocoaRT.colorSpace == 0 {

cocoaRT.colorSpace = cgColorSpaceCreateDeviceRGB()

}

if cocoaRT.colorSpace == 0 {

return fmt.Errorf("cocoa: no RGB colour space")

}

return nil

mouse := func(name string, btn uint32, down bool) objc.MethodDef {

return objc.MethodDef{

Cmd: objc.RegisterName(name),

Fn: func(self objc.ID, _ objc.SEL, event objc.ID) {

defer cocoaCallbackRecover(name)

if h := cocoaHostFor(self); h != nil {

h.handleMouseButton(self, event, btn, down)

}

},

}

}

motion := func(name string) objc.MethodDef {

return objc.MethodDef{

Cmd: objc.RegisterName(name),

Fn: func(self objc.ID, _ objc.SEL, event objc.ID) {

defer cocoaCallbackRecover(name)

if h := cocoaHostFor(self); h != nil {

h.handleMouseMotion(self, event)

}

},

}

}

yes := func(name string) objc.MethodDef {

return objc.MethodDef{Cmd: objc.RegisterName(name), Fn: func(objc.ID, objc.SEL) bool { return true }}

}

var err error

cocoaRT.classView, err = objc.RegisterClass("VtuiCocoaView", objc.GetClass("NSView"), nil, nil, []objc.MethodDef{

yes("acceptsFirstResponder"),

yes("canBecomeKeyView"),

yes("isOpaque"),

yes("wantsUpdateLayer"),

{Cmd: objc.RegisterName("acceptsFirstMouse:"), Fn: func(objc.ID, objc.SEL, objc.ID) bool { return true }},

{Cmd: objc.RegisterName("updateLayer"), Fn: func(self objc.ID, _ objc.SEL) {

defer cocoaCallbackRecover("updateLayer")

if h := cocoaHostFor(self); h != nil {

h.presentFrame(self)

}

}},

{Cmd: objc.RegisterName("keyDown:"), Fn: func(self objc.ID, _ objc.SEL, event objc.ID) {

defer cocoaCallbackRecover("keyDown:")

if h := cocoaHostFor(self); h != nil {

h.handleKeyDown(event)

}

}},

{Cmd: objc.RegisterName("keyUp:"), Fn: func(self objc.ID, _ objc.SEL, event objc.ID) {

defer cocoaCallbackRecover("keyUp:")

if h := cocoaHostFor(self); h != nil {

h.handleKeyUp(event)

}

}},

{Cmd: objc.RegisterName("flagsChanged:"), Fn: func(self objc.ID, _ objc.SEL, event objc.ID) {

defer cocoaCallbackRecover("flagsChanged:")

if h := cocoaHostFor(self); h != nil {

h.handleFlagsChanged(event)

}

}},

{Cmd: cocoaSel.performKeyEquivalent, Fn: func(self objc.ID, _ objc.SEL, event objc.ID) bool {

defer cocoaCallbackRecover("performKeyEquivalent:")

if h := cocoaHostFor(self); h != nil && h.claimsKeyEquivalent(event) {

h.handleKeyDown(event)

return true

}

// objc.SendSuper resolves the super class from self's dynamic

// class (object_getClass(self)), which is exactly what

// objc_msgSendSuper2 itself expects. That is safe as long as

// self's dynamic class is really VtuiCocoaView: the runtime

// then starts the search one level up, at NSView. But if this

// particular view instance ever gets isa-swizzled -- most

// commonly by Cocoa's KVO machinery, which installs a private

// NSKVONotifying_VtuiCocoaView subclass the moment an observer

// is added to it -- self's dynamic class becomes that

// subclass, and the same lookup would start one level up from

// *there*, landing back on VtuiCocoaView itself and calling

// straight back into this method: unbounded recursion. Guard

// against that by only forwarding to super while self is

// still exactly our own registered class; otherwise fall back

// to NSView's real default, which is simply to not handle the

// key equivalent.

if self.Class() == cocoaRT.classView {

return objc.SendSuper[bool](self, cocoaSel.performKeyEquivalent, event)

}

return false

}},

mouse("mouseDown:", uint32(vtinput.FromLeft1stButtonPressed), true),

mouse("mouseUp:", uint32(vtinput.FromLeft1stButtonPressed), false),

mouse("rightMouseDown:", uint32(vtinput.RightmostButtonPressed), true),

mouse("rightMouseUp:", uint32(vtinput.RightmostButtonPressed), false),

mouse("otherMouseDown:", 0, true),

mouse("otherMouseUp:", 0, false),

motion("mouseMoved:"),

motion("mouseDragged:"),

motion("rightMouseDragged:"),

motion("otherMouseDragged:"),

{Cmd: objc.RegisterName("scrollWheel:"), Fn: func(self objc.ID, _ objc.SEL, event objc.ID) {

defer cocoaCallbackRecover("scrollWheel:")

if h := cocoaHostFor(self); h != nil {

h.handleScroll(self, event)

}

}},

// Text that arrives without a key press of its own: the Character

// Viewer and the Services menu hand it to the first responder this

// way.

{Cmd: objc.RegisterName("insertText:"), Fn: func(self objc.ID, _ objc.SEL, text objc.ID) {

defer cocoaCallbackRecover("insertText:")

if h := cocoaHostFor(self); h != nil {

h.insertText(cocoaGoString(text))

}

}},

{Cmd: cocoaSel.runQueued, Fn: func(self objc.ID, _ objc.SEL, _ objc.ID) {

defer cocoaCallbackRecover("vtuiRunQueued:")

if h := cocoaHostFor(self); h != nil {

h.runQueued()

}

}},

})

if err != nil {

return fmt.Errorf("cocoa: registering the view class: %w", err)

}

cocoaRT.classWindowDelegate, err = objc.RegisterClass("VtuiCocoaWindowDelegate", objc.GetClass("NSObject"), nil, nil, []objc.MethodDef{

{Cmd: objc.RegisterName("windowShouldClose:"), Fn: func(self objc.ID, _ objc.SEL, _ objc.ID) bool {

defer cocoaCallbackRecover("windowShouldClose:")

h := cocoaHostFor(self)

if h == nil || h.isClosed() || FrameManager.IsShutdown() {

return true

}

// The application decides: it may ask about unsaved work

// first, and it quits through the same command a key would.

postQuitCommand()

return false

}},

{Cmd: objc.RegisterName("windowWillClose:"), Fn: func(objc.ID, objc.SEL, objc.ID) {

defer cocoaCallbackRecover("windowWillClose:")

cocoaStopApp()

}},

{Cmd: objc.RegisterName("windowDidResize:"), Fn: func(self objc.ID, _ objc.SEL, _ objc.ID) {

defer cocoaCallbackRecover("windowDidResize:")

if h := cocoaHostFor(self); h != nil {

h.updateGridSize()

}

}},

{Cmd: objc.RegisterName("windowDidBecomeKey:"), Fn: func(self objc.ID, _ objc.SEL, _ objc.ID) {

defer cocoaCallbackRecover("windowDidBecomeKey:")

if h := cocoaHostFor(self); h != nil {

h.sendEvent(&vtinput.InputEvent{Type: vtinput.FocusEventType, SetFocus: true})

}

}},

{Cmd: objc.RegisterName("windowDidResignKey:"), Fn: func(self objc.ID, _ objc.SEL, _ objc.ID) {

defer cocoaCallbackRecover("windowDidResignKey:")

if h := cocoaHostFor(self); h != nil {

// A button released over another window never reaches

// this one.

h.mouseBtn = 0

h.keys.reset()

h.sendEvent(&vtinput.InputEvent{Type: vtinput.FocusEventType, SetFocus: false})

}

}},

{Cmd: objc.RegisterName("windowDidChangeBackingProperties:"), Fn: func(self objc.ID, _ objc.SEL, _ objc.ID) {

defer cocoaCallbackRecover("windowDidChangeBackingProperties:")

if h := cocoaHostFor(self); h != nil && h.window != 0 {

// The font stays rasterised for the display the window

// opened on; Core Animation scales the frame for this one.

DebugLog("COCOA: backing scale factor is now %v (frames stay at %v)",

objc.Send[float64](h.window, cocoaSel.backingScaleFactor), h.pointScale)

h.view.Send(cocoaSel.setNeedsDisplay, true)

}

}},

})

if err != nil {

return fmt.Errorf("cocoa: registering the window delegate class: %w", err)

}

// No NSApplicationDelegate protocol is declared: on macOS 14 declaring

// it has been seen to crash AppKit inside nextEventMatchingMask:

// (Ebitengine issue #3451), and AppKit finds the methods through

// respondsToSelector: regardless.

cocoaRT.classApplicationDelegate, err = objc.RegisterClass("VtuiCocoaApplicationDelegate", objc.GetClass("NSObject"), nil, nil, []objc.MethodDef{

{Cmd: objc.RegisterName("applicationShouldTerminate:"), Fn: func(objc.ID, objc.SEL, objc.ID) uint {

defer cocoaCallbackRecover("applicationShouldTerminate:")

// Quit from the menu, or a logout, restart or shutdown. Never let

// AppKit call exit() under the application: ask it to quit as the

// close button does, or end the loop if it has already gone.

// AppKit is told to wait rather than refused outright (returning

// NSTerminateCancel here would otherwise refuse every logout,

// restart and shutdown for good); cocoaReplyOnceClosed answers it

// once that quit has actually finished.

h := cocoaActiveHost.Load()

if h == nil {

// Nothing is open: there is nothing left to shut down, so

// there is nothing to wait for either.

return nsTerminateNow

}

if h.isClosed() || FrameManager.IsShutdown() {

cocoaStopApp()

} else {

postQuitCommand()

}

go cocoaReplyOnceClosed(h)

return nsTerminateLater

}},

{Cmd: cocoaSel.vtuiReplyTerminate, Fn: func(objc.ID, objc.SEL, objc.ID) {

defer cocoaCallbackRecover("vtuiReplyTerminate:")

app := objc.ID(cocoaRT.classNSApplication).Send(cocoaSel.sharedApplication)

app.Send(cocoaSel.replyToApplicationShouldTerminate, true)

}},

{Cmd: objc.RegisterName("applicationShouldTerminateAfterLastWindowClosed:"), Fn: func(objc.ID, objc.SEL, objc.ID) bool {

return false

}},

{Cmd: objc.RegisterName("applicationDidFinishLaunching:"), Fn: func(objc.ID, objc.SEL, objc.ID) {

defer cocoaCallbackRecover("applicationDidFinishLaunching:")

// -run calls finishLaunching itself, the first time it runs, before

// it starts pumping events; this delegate method is where AppKit

// considers the app fully launched. Activating any earlier --

// right after setActivationPolicy: promotes this ordinary

// executable (no bundle, so no Info.plist to say it upfront) to a

// regular, Dock-visible app, and before -run had even been sent --

// asked the Window Server to bring a not-yet-fully-registered app

// to the front (vtui #1571).

app := objc.ID(cocoaRT.classNSApplication).Send(cocoaSel.sharedApplication)

app.Send(cocoaSel.activateIgnoringOtherApps, true)

}},

})

if err != nil {

return fmt.Errorf("cocoa: registering the application delegate class: %w", err)

}

return nil

r := recover()

if r == nil {

return

}

stack := debug.Stack()

DebugLog("FATAL PANIC in Cocoa callback %s: %v\n%s", where, r, stack)

crashPath := RecordCrash(r, nil)

fmt.Fprintf(os.Stderr, "\n[%s] FATAL PANIC in Cocoa callback %s: %v\n%s\n", AppName, where, r, stack)

if crashPath != "" {

fmt.Fprintf(os.Stderr, "[%s] Crash report saved to: %s\n", AppName, crashPath)

}

os.Exit(2)

if str == 0 {

return ""

}

n := objc.Send[uint](str, cocoaSel.lengthOfBytes, uint(nsUTF8StringEncoding))

if n == 0 {

return ""

}

buf := make([]byte, n+1)

if !objc.Send[bool](str, cocoaSel.getCString, &buf[0], uint(len(buf)), uint(nsUTF8StringEncoding)) {

return ""

}

return string(buf[:n])

runtime.LockOSThread()

defer runtime.UnlockOSThread()

pool := objcAutoreleasePoolPush()

defer objcAutoreleasePoolPop(pool)

target.Send(cocoaSel.performOnMain, sel, objc.ID(0), wait)

app := objc.ID(cocoaRT.classNSApplication).Send(cocoaSel.sharedApplication)

app.Send(cocoaSel.stop, objc.ID(0))

event := objc.Send[objc.ID](objc.ID(cocoaRT.classNSEvent), cocoaSel.otherEvent,

uint(nsEventTypeApplicationDefined), cocoaPoint{}, uint(0), float64(0), 0, objc.ID(0), uintptr(0), 0, 0)

if event != 0 {

app.Send(cocoaSel.postEventAtStart, event, true)

}

select {

case <-h.hostClosed:

case <-time.After(10 * time.Second):

DebugLog("COCOA: close() did not finish within 10s of a termination request; replying anyway")

}

if cocoaAppDelegate != 0 {

cocoaPerformOnMain(cocoaAppDelegate, cocoaSel.vtuiReplyTerminate, false)

}

screens := objc.ID(cocoaRT.classNSScreen).Send(cocoaSel.screens)

if screens == 0 {

return 0

}

f := objc.Send[cocoaRect](screens.Send(cocoaSel.objectAtIndex, uint(0)), cocoaSel.frame)

return f.Origin.Y + f.Size.Height

mu sync.Mutex

renderer *CocoaGuiRenderer

reader *vtinput.Reader

scr *ScreenBuf

cols int

rows int

closed bool

// cellW and cellH are the cell size in pixels. scale is the integer

// line-thickness factor the raster takes, pointScale the backing scale

// factor the window opened with: pixels per point. None of them change

// once the window exists.

cellW, cellH int

scale int

pointScale float64

app, window, view, windowDelegate objc.ID

// mainMu guards window, view and windowDelegate above, not just

// mainQueue and loopDone: close() zeroes all three under it once the

// loop has ended, so runOnMain's gate also keeps every other method from

// reading them once they are stale (vtui #1571).

mainMu sync.Mutex

mainQueue []func()

loopDone bool

// displayQueued keeps at most one display request in flight.

displayQueued atomic.Bool

// hostClosed is closed once close() has finished releasing the window,

// for applicationShouldTerminate: to wait on before it may tell AppKit a

// pending logout, restart or shutdown can proceed.

hostClosed chan struct{}

// mainOnly

bitmap uintptr

bitmapW int

bitmapH int

mouseBtn uint32

lastMouseCellX int16

lastMouseCellY int16

mouseCellKnown bool

wheelAcc float64

keys cocoaKeyTranslator

h.mu.Lock()

defer h.mu.Unlock()

return h.closed

if cocoaOnMainThread() {

h.mainMu.Lock()

done := h.loopDone

h.mainMu.Unlock()

if done {

return

}

fn()

return

}

h.mainMu.Lock()

view := h.view

if view == 0 || h.loopDone {

h.mainMu.Unlock()

return

}

h.mainQueue = append(h.mainQueue, fn)

h.mainMu.Unlock()

cocoaPerformOnMain(view, cocoaSel.runQueued, false)

if cocoaOnMainThread() {

h.mainMu.Lock()

done := h.loopDone

h.mainMu.Unlock()

if done {

return false

}

fn()

return true

}

done := make(chan struct{}, 1)

h.mainMu.Lock()

view := h.view

if view == 0 || h.loopDone {

h.mainMu.Unlock()

return false

}

h.mainQueue = append(h.mainQueue, func() {

fn()

done <- struct{}{}

})

h.mainMu.Unlock()

// Not waitUntilDone:YES: should the loop end before it gets to this,

// the caller would wait for ever.

cocoaPerformOnMain(view, cocoaSel.runQueued, false)

select {

case <-done:

return true

case <-time.After(2 * time.Second):

return false

}

h.mainMu.Lock()

queue := h.mainQueue

h.mainQueue = nil

h.mainMu.Unlock()

for _, fn := range queue {

fn()

}

if !h.displayQueued.CompareAndSwap(false, true) {

return

}

h.runOnMain(func() {

h.displayQueued.Store(false)

if h.view != 0 {

h.view.Send(cocoaSel.setNeedsDisplay, true)

}

})

full := WindowTitleWithBackend(title)

h.runOnMain(func() {

if h.window == 0 {

return

}

// A directory name off SMB/NFS/FUSE, or an OSC title set from a

// terminal session, is not guaranteed to be valid UTF-8;

// initWithUTF8String: returns nil for one that is not, and nil is

// not a title -setTitle: can take (vtui #1571).

s := cocoaNSString(strings.ToValidUTF8(full, "\uFFFD"))

if s == 0 {

return

}

h.window.Send(cocoaSel.setTitle, s)

s.Send(cocoaSel.release)

})

if cols <= 0 || rows <= 0 {

return

}

h.runOnMain(func() {

if h.window == 0 || h.view == 0 {

return

}

oldFrame := objc.Send[cocoaRect](h.window, cocoaSel.frame)

oldContent := objc.Send[cocoaRect](h.view, cocoaSel.bounds).Size

// The chrome (title bar, border) around the content view keeps its

// own size; only the content grows or shrinks.

chromeW := oldFrame.Size.Width - oldContent.Width

chromeH := oldFrame.Size.Height - oldContent.Height

newSize := cocoaSize{

Width: float64(cols*h.cellW)/h.pointScale + chromeW,

Height: float64(rows*h.cellH)/h.pointScale + chromeH,

}

newFrame := cocoaRect{

Origin: cocoaPoint{

X: oldFrame.Origin.X,

Y: oldFrame.Origin.Y + oldFrame.Size.Height - newSize.Height,

},

Size: newSize,

}

h.window.Send(cocoaSel.setFrame, newFrame, true)

})

h.mainMu.Lock()

done, window := h.loopDone, h.window

h.mainMu.Unlock()

if done || window == 0 {

return false

}

h.runOnMain(func() {

if h.window != 0 {

h.window.Send(cocoaSel.zoom, objc.ID(0))

}

})

return true

type position struct{ x, y int }

result := make(chan position, 1)

h.runOnMainAndWait(func() {

if h.window == 0 {

return

}

f := objc.Send[cocoaRect](h.window, cocoaSel.frame)

top := cocoaPrimaryScreenTop()

result <- position{int(math.Round(f.Origin.X)), int(math.Round(top - (f.Origin.Y + f.Size.Height)))}

})

select {

case p := <-result:

return p.x, p.y, true

default:

return 0, 0, false

}

h.runOnMain(func() {

if h.window == 0 {

return

}

h.window.Send(cocoaSel.setFrameTopLeftPoint, cocoaPoint{X: float64(x), Y: cocoaPrimaryScreenTop() - float64(y)})

})

h.mu.Lock()

h.closed = true

h.mu.Unlock()

h.runOnMain(cocoaStopApp)

h.mu.Lock()

var ch chan *vtinput.InputEvent

if !h.closed && h.reader != nil {

ch = h.reader.EventChan

}

h.mu.Unlock()

if ch == nil {

return

}

// The reader closes its channel as FrameManager.Run returns, and a

// callback can still be on its way here at that moment.

defer func() { _ = recover() }()

select {

case ch <- ev:

default:

if ev.Type == vtinput.MouseEventType && ev.MouseEventFlags&vtinput.MouseMoved != 0 {

return

}

DebugLog("COCOA: input queue full, dropped %s", ev.String())

}

if h.view == 0 {

return

}

b := objc.Send[cocoaRect](h.view, cocoaSel.bounds)

cols, rows := cocoaGridForPixels(

int(math.Round(b.Size.Width*h.pointScale)), int(math.Round(b.Size.Height*h.pointScale)),

h.cellW, h.cellH)

h.mu.Lock()

changed := cols != h.cols || rows != h.rows

h.cols, h.rows = cols, rows

h.mu.Unlock()

if changed {

h.sendEvent(&vtinput.InputEvent{Type: vtinput.ResizeEventType})

}

// The canvas follows the view even when the grid does not: the margin

// right of and below the grid has to be repainted.

h.view.Send(cocoaSel.setNeedsDisplay, true)

layer := view.Send(cocoaSel.layer)

if layer == 0 {

return

}

b := objc.Send[cocoaRect](view, cocoaSel.bounds)

w := int(math.Round(b.Size.Width * h.pointScale))

ht := int(math.Round(b.Size.Height * h.pointScale))

if w <= 0 || ht <= 0 {

return

}

if h.bitmap == 0 || h.bitmapW != w || h.bitmapH != ht {

if h.bitmap != 0 {

cgContextRelease(h.bitmap)

}

h.bitmap = cgBitmapContextCreate(nil, uintptr(w), uintptr(ht), 8, 0, cocoaRT.colorSpace, cgImageAlphaNoneSkipLast)

h.bitmapW, h.bitmapH = w, ht

if h.bitmap == 0 {

DebugLog("COCOA: CGBitmapContextCreate failed for %dx%d", w, ht)

return

}

}

data := cgBitmapContextGetData(h.bitmap)