devdraw: rewrite the Cocoa screen using Metal

Add a new macOS cocoa screen, cocoa-screen-metal.m.
Rewrite the macOS cocoa drawing code to use the builtin runloop,
and use Metal to push pixels with CAMetalLayer.

Remove all of the deprecated code, and simplify some of the logic.
Modify mkwsysrules.sh such that the new code is used only when
the system version is equal or higher than 10.14.

Allow touch events to simulate mouse clicks:
three finger tap for the middle mouse button;
four finger tap for the 2-1 chord.

Support Tresize.

Scale 16x16 Cursor up to 32x32 with an EPX algorithm.

Support macOS input sources including the basic dead keys and the
advanced CJK input methods.

Increase the communication buffers in cocoa-srv.c to allow more
input, especially for long sentences prepared by the macOS input
souces.

8 files changed, 1307 insertions, 21 deletions

diff --git a/src/cmd/devdraw/bigarrow.h b/src/cmd/devdraw/bigarrow.h
index a46f19a0..3b66c954 100644
--- a/src/cmd/devdraw/bigarrow.h
+++ b/src/cmd/devdraw/bigarrow.h
@@ -1,11 +1,13 @@
-Cursor bigarrow = {
-	{0, 0},
-	{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC, 
-	 0xFF, 0xF0, 0xFF, 0xF0, 0xFF, 0xF8, 0xFF, 0xFC, 
-	 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC, 
-	 0xF3, 0xF8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40},
-	{0x00, 0x00, 0x7F, 0xFE, 0x7F, 0xFC, 0x7F, 0xF0, 
-	 0x7F, 0xE0, 0x7F, 0xE0, 0x7F, 0xF0, 0x7F, 0xF8, 
-	 0x7F, 0xFC, 0x7F, 0xFE, 0x7F, 0xFC, 0x73, 0xF8, 
-	 0x61, 0xF0, 0x60, 0xE0, 0x40, 0x40, 0x00, 0x00},
+Cursor	bigarrow = {
+	{ -1, -1 },
+	{ 0xFF, 0xFF, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0C,
+	  0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04,
+	  0x80, 0x02, 0x80, 0x01, 0x80, 0x02, 0x8C, 0x04,
+	  0x92, 0x08, 0x91, 0x10, 0xA0, 0xA0, 0xC0, 0x40,
+	},
+	{ 0x00, 0x00, 0x7F, 0xFE, 0x7F, 0xFC, 0x7F, 0xF0,
+	  0x7F, 0xE0, 0x7F, 0xE0, 0x7F, 0xF0, 0x7F, 0xF8,
+	  0x7F, 0xFC, 0x7F, 0xFE, 0x7F, 0xFC, 0x73, 0xF8,
+	  0x61, 0xF0, 0x60, 0xE0, 0x40, 0x40, 0x00, 0x00,
+	},
 };
diff --git a/src/cmd/devdraw/cocoa-screen-metal.m b/src/cmd/devdraw/cocoa-screen-metal.m
new file mode 100644
index 00000000..c82ce0bc
--- /dev/null
+++ b/src/cmd/devdraw/cocoa-screen-metal.m
@@ -0,0 +1,1260 @@
+#define Cursor OSXCursor
+#define Point OSXPoint
+#define Rect OSXRect
+
+#import <Cocoa/Cocoa.h>
+#import <Metal/Metal.h>
+#import <QuartzCore/CAMetalLayer.h>
+
+#undef Cursor
+#undef Point
+#undef Rect
+
+#include <u.h>
+#include <libc.h>
+#include  "cocoa-thread.h"
+#include <draw.h>
+#include <memdraw.h>
+#include <keyboard.h>
+#include <cursor.h>
+#include "cocoa-screen.h"
+#include "osx-keycodes.h"
+#include "devdraw.h"
+#include "bigarrow.h"
+#include "glendapng.h"
+
+AUTOFRAMEWORK(Cocoa)
+AUTOFRAMEWORK(Metal)
+AUTOFRAMEWORK(QuartzCore)
+
+#define LOG	if(0)NSLog
+
+static void setprocname(const char*);
+static uint keycvt(uint);
+static uint msec(void);
+static Memimage* initimg(void);
+
+void
+usage(void)
+{
+	fprint(2, "usage: devdraw (don't run directly)\n");
+	threadexitsall("usage");
+}
+
+@interface AppDelegate : NSObject<NSApplicationDelegate,NSWindowDelegate>
++ (void)callservep9p:(id)arg;
++ (void)makewin:(NSValue *)v;
++ (void)callkicklabel:(NSString *)v;
++ (void)callsetNeedsDisplayInRect:(NSValue *)v;
++ (void)callsetcursor:(NSValue *)v;
+@end
+@interface DevDrawView : NSView<NSTextInputClient>
+- (void)clearInput;
+- (void)getmouse:(NSEvent *)e;
+- (void)sendmouse:(NSUInteger)b;
+- (void)resetLastInputRect;
+- (void)enlargeLastInputRect:(NSRect)r;
+@end
+@interface DrawLayer : CAMetalLayer
+@end
+
+static AppDelegate *myApp = NULL;
+static DevDrawView *myContent = NULL;
+static NSWindow *win = NULL;
+static NSCursor *currentCursor = NULL;
+
+static DrawLayer *layer;
+static MTLRenderPassDescriptor *renderPass;
+static id<MTLDevice> device;
+static id<MTLRenderPipelineState> pipelineState;
+static id<MTLCommandQueue> commandQueue;
+static id<MTLTexture> texture;
+
+static Memimage *img = NULL;
+
+static QLock snarfl;
+
+static NSString *const metal =
+@"#include<metal_stdlib>\n"
+"using namespace metal;\n"
+"typedef struct {\n"
+"	float4 rCoord [[position]];\n"
+"	float2 tCoord;\n"
+"} VertexOut;\n"
+"vertex VertexOut\n"
+"renderVertex(unsigned int vid [[ vertex_id ]])\n"
+"{\n"
+"	const VertexOut fixedV[] = {\n"
+"		{{ -1.0f, -1.0f, 0.0f, 1.0f }, { 0.0f, 1.0f }},\n"
+"		{{  1.0f, -1.0f, 0.0f, 1.0f }, { 1.0f, 1.0f }},\n"
+"		{{ -1.0f,  1.0f, 0.0f, 1.0f }, { 0.0f, 0.0f }},\n"
+"		{{  1.0f,  1.0f, 0.0f, 1.0f }, { 1.0f, 0.0f }},\n"
+"	};\n"
+"	return fixedV[vid];\n"
+"}\n"
+"fragment half4\n"
+"renderFragment(VertexOut in [[ stage_in ]],\n"
+"		texture2d<half> texture [[ texture(0) ]]) {\n"
+"	constexpr sampler s;\n"
+"	return texture.sample(s, in.tCoord);\n"
+"}";
+
+
+void
+threadmain(int argc, char **argv)
+{
+	/*
+	 * Move the protocol off stdin/stdout so that
+	 * any inadvertent prints don't screw things up.
+	 */
+	dup(0,3);
+	dup(1,4);
+	close(0);
+	close(1);
+	open("/dev/null", OREAD);
+	open("/dev/null", OWRITE);
+
+	ARGBEGIN{
+	case 'D':		/* for good ps -a listings */
+		break;
+	case 'f':		/* fall through for backward compatibility */
+	case 'g':
+	case 'b':
+		break;
+	default:
+		usage();
+	}ARGEND
+
+	setprocname(argv0);
+
+	@autoreleasepool{
+		[NSApplication sharedApplication];
+		[NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
+		myApp = [AppDelegate new];
+		[NSApp setDelegate:myApp];
+		[NSApp run];
+	}
+}
+
+@implementation AppDelegate
+
++ (void)callservep9p:(id)arg
+{
+	servep9p();
+	[NSApp terminate:self];
+}
+
++ (void)makewin:(NSValue *)v
+{
+	NSRect r, sr;
+	Rectangle wr;
+	int set;
+	char *s;
+	id<MTLLibrary> library;
+	MTLRenderPipelineDescriptor *pipelineDesc;
+	NSError *error;
+
+	const NSWindowStyleMask Winstyle = NSWindowStyleMaskTitled
+		| NSWindowStyleMaskClosable
+		| NSWindowStyleMaskMiniaturizable
+		| NSWindowStyleMaskResizable;
+
+	sr = [[NSScreen mainScreen] frame];
+	r = [[NSScreen mainScreen] visibleFrame];
+
+	s = [v pointerValue];
+	LOG(@"makewin(%s)", s);
+	if(s && *s){
+		if(parsewinsize(s, &wr, &set) < 0)
+			sysfatal("%r");
+	}else{
+		wr = Rect(0, 0, sr.size.width*2/3, sr.size.height*2/3);
+		set = 0;
+	}
+
+	r.origin.x = wr.min.x;
+	r.origin.y = sr.size.height-wr.max.y;	/* winsize is top-left-based */
+	r.size.width = fmin(Dx(wr), r.size.width);
+	r.size.height = fmin(Dy(wr), r.size.height);
+	r = [NSWindow contentRectForFrameRect:r styleMask:Winstyle];
+
+	win = [[NSWindow alloc]
+		initWithContentRect:r
+		styleMask:Winstyle
+		backing:NSBackingStoreBuffered defer:NO];
+	[win setTitle:@"devdraw"];
+
+	if(!set)
+		[win center];
+	[win setCollectionBehavior:NSWindowCollectionBehaviorFullScreenPrimary];
+	[win setContentMinSize:NSMakeSize(64,64)];
+
+	[win setRestorable:NO];
+	[win setAcceptsMouseMovedEvents:YES];
+	[win setDelegate:myApp];
+
+	myContent = [DevDrawView new];
+	[win setContentView:myContent];
+	[myContent setWantsLayer:YES];
+	[myContent setLayerContentsRedrawPolicy:NSViewLayerContentsRedrawOnSetNeedsDisplay];
+
+	device = MTLCreateSystemDefaultDevice();
+	commandQueue = [device newCommandQueue];
+
+	layer = (DrawLayer *)[myContent layer];
+	layer.device = device;
+	layer.pixelFormat = MTLPixelFormatBGRA8Unorm;
+	layer.framebufferOnly = YES;
+	layer.opaque = YES;
+
+	renderPass = [MTLRenderPassDescriptor renderPassDescriptor];
+	renderPass.colorAttachments[0].loadAction = MTLLoadActionDontCare;
+	renderPass.colorAttachments[0].storeAction = MTLStoreActionDontCare;
+
+	library = [device newLibraryWithSource:metal options:nil error:&error];
+	if(!library)
+		sysfatal((char *)[[error localizedDescription] UTF8String]);
+
+	pipelineDesc = [MTLRenderPipelineDescriptor new];
+	pipelineDesc.alphaToOneEnabled = YES;
+	pipelineDesc.inputPrimitiveTopology = MTLPrimitiveTopologyClassTriangle;
+	pipelineDesc.rasterSampleCount = 1;
+	pipelineDesc.colorAttachments[0].pixelFormat = MTLPixelFormatBGRA8Unorm;
+	[pipelineDesc setVertexFunction: [library newFunctionWithName: @"renderVertex"]];
+	[pipelineDesc setFragmentFunction: [library newFunctionWithName: @"renderFragment"]];
+
+	pipelineState = [device newRenderPipelineStateWithDescriptor:pipelineDesc error:&error];
+	if(!pipelineState)
+		sysfatal((char *)[[error localizedDescription] UTF8String]);
+
+	[NSEvent setMouseCoalescingEnabled:NO];
+
+	topwin();
+}
+
++ (void)callkicklabel:(NSString *)s
+{
+	LOG(@"callkicklabel(%@)", s);
+	[win setTitle:s];
+	[[NSApp dockTile] setBadgeLabel:s];
+}
+
+
++ (void)callsetNeedsDisplayInRect:(NSValue *)v
+{
+	NSRect r;
+
+	r = [v rectValue];
+	LOG(@"callsetNeedsDisplayInRect(%g, %g, %g, %g)", r.origin.x, r.origin.y, r.size.width, r.size.height);
+	r = [win convertRectFromBacking:r];
+	LOG(@"setNeedsDisplayInRect(%g, %g, %g, %g)", r.origin.x, r.origin.y, r.size.width, r.size.height);
+	[layer setNeedsDisplayInRect:r];
+	[myContent enlargeLastInputRect:r];
+}
+
++ (void)callsetcursor:(NSValue *)v
+{
+	Cursor *c;
+	NSBitmapImageRep *r, *r2;
+	NSImage *i;
+	NSPoint p;
+	uint b, x, y, a;
+	uchar *plane[5], *plane2[5];
+	uchar pu, pb, pl, pr, pc;  // upper, bottom, left, right, center
+	uchar pul, pur, pbl, pbr;
+	uchar ful, fur, fbl, fbr;
+
+	c = [v pointerValue];
+	if(!c)
+		c = &bigarrow;
+
+	r = [[NSBitmapImageRep alloc]
+		initWithBitmapDataPlanes:nil
+		pixelsWide:16
+		pixelsHigh:16
+		bitsPerSample:1
+		samplesPerPixel:2
+		hasAlpha:YES
+		isPlanar:YES
+		colorSpaceName:NSDeviceWhiteColorSpace
+		bytesPerRow:2
+		bitsPerPixel:0];
+	[r getBitmapDataPlanes:plane];
+	for(b=0; b<2*16; b++){
+		plane[0][b] = ~c->set[b] & c->clr[b];
+		plane[1][b] = c->set[b] | c->clr[b];
+	}
+
+	r2 = [[NSBitmapImageRep alloc]
+		initWithBitmapDataPlanes:nil
+		pixelsWide:32
+		pixelsHigh:32
+		bitsPerSample:1
+		samplesPerPixel:2
+		hasAlpha:YES
+		isPlanar:YES
+		colorSpaceName:NSDeviceWhiteColorSpace
+		bytesPerRow:4
+		bitsPerPixel:0];
+	[r2 getBitmapDataPlanes:plane2];
+	// https://en.wikipedia.org/wiki/Pixel-art_scaling_algorithms#EPX/Scale2×/AdvMAME2×
+	for(a=0; a<2; a++){
+		for(y=0; y<16; y++){
+			for(x=0; x<2; x++){
+				pc = plane[a][x+2*y];
+				pu = y==0 ? pc : plane[a][x+2*(y-1)];
+				pb = y==15 ? pc : plane[a][x+2*(y+1)];
+				pl = (pc>>1) | (x==0 ? pc&0x80 : (plane[a][x-1+2*y]&1)<<7);
+				pr = (pc<<1) | (x==1 ? pc&1 : (plane[a][x+1+2*y]&0x80)>>7);
+				ful = ~(pl^pu) & (pl^pb) & (pu^pr);
+				pul = (ful & pu) | (~ful & pc);
+				fur = ~(pu^pr) & (pu^pl) & (pr^pb);
+				pur = (fur & pr) | (~fur & pc);
+				fbl = ~(pb^pl) & (pb^pr) & (pl^pu);
+				pbl = (fbl & pl) | (~fbl & pc);
+				fbr = ~(pr^pb) & (pr^pu) & (pb^pl);
+				pbr = (fbr & pb) | (~fbr & pc);
+				plane2[a][2*x+4*2*y] = (pul&0x80) | ((pul&0x40)>>1)  | ((pul&0x20)>>2) | ((pul&0x10)>>3)
+					| ((pur&0x80)>>1) | ((pur&0x40)>>2)  | ((pur&0x20)>>3) | ((pur&0x10)>>4);
+				plane2[a][2*x+1+4*2*y] = ((pul&0x8)<<4) | ((pul&0x4)<<3)  | ((pul&0x2)<<2) | ((pul&0x1)<<1)
+					| ((pur&0x8)<<3) | ((pur&0x4)<<2)  | ((pur&0x2)<<1) | (pur&0x1);
+				plane2[a][2*x+4*(2*y+1)] =  (pbl&0x80) | ((pbl&0x40)>>1)  | ((pbl&0x20)>>2) | ((pbl&0x10)>>3)
+					| ((pbr&0x80)>>1) | ((pbr&0x40)>>2)  | ((pbr&0x20)>>3) | ((pbr&0x10)>>4);
+				plane2[a][2*x+1+4*(2*y+1)] = ((pbl&0x8)<<4) | ((pbl&0x4)<<3)  | ((pbl&0x2)<<2) | ((pbl&0x1)<<1)
+					| ((pbr&0x8)<<3) | ((pbr&0x4)<<2)  | ((pbr&0x2)<<1) | (pbr&0x1);
+			}
+		}
+	}
+
+	// For checking out the cursor bitmap image
+/*
+	static BOOL saveimg = YES;
+	if(saveimg){
+		NSData *data = [r representationUsingType: NSBitmapImageFileTypeBMP properties: @{}];
+		[data writeToFile: @"/tmp/r.bmp" atomically: NO];
+		data = [r2 representationUsingType: NSBitmapImageFileTypeBMP properties: @{}];
+		[data writeToFile: @"/tmp/r2.bmp" atomically: NO];
+		saveimg = NO;
+	}
+*/
+
+	i = [[NSImage alloc] initWithSize:NSMakeSize(16, 16)];
+	[i addRepresentation:r2];
+	[i addRepresentation:r];
+
+	p = NSMakePoint(-c->offset.x, -c->offset.y);
+	currentCursor = [[NSCursor alloc] initWithImage:i hotSpot:p];
+
+	[win invalidateCursorRectsForView:myContent];
+}
+
+- (void)applicationDidFinishLaunching:(id)arg
+{
+	NSMenu *m, *sm;
+	NSData *d;
+	NSImage *i;
+
+	LOG(@"applicationDidFinishLaunching");
+
+	sm = [NSMenu new];
+	[sm addItemWithTitle:@"Toggle Full Screen" action:@selector(toggleFullScreen:) keyEquivalent:@"f"];
+	[sm addItemWithTitle:@"Hide" action:@selector(hide:) keyEquivalent:@"h"];
+	[sm addItemWithTitle:@"Quit" action:@selector(terminate:) keyEquivalent:@"q"];
+	m = [NSMenu new];
+	[m addItemWithTitle:@"DEVDRAW" action:NULL keyEquivalent:@""];
+	[m setSubmenu:sm forItem:[m itemWithTitle:@"DEVDRAW"]];
+	[NSApp setMainMenu:m];
+
+	d = [[NSData alloc] initWithBytes:glenda_png length:(sizeof glenda_png)];
+	i = [[NSImage alloc] initWithData:d];
+	[NSApp setApplicationIconImage:i];
+	[[NSApp dockTile] display];
+
+	[NSThread
+		detachNewThreadSelector:@selector(callservep9p:)
+		toTarget:[self class] withObject:nil];
+}
+
+- (NSApplicationPresentationOptions)window:(id)arg
+		willUseFullScreenPresentationOptions:(NSApplicationPresentationOptions)proposedOptions {
+	NSApplicationPresentationOptions o;
+	o = proposedOptions;
+	o &= ~(NSApplicationPresentationAutoHideDock | NSApplicationPresentationAutoHideMenuBar);
+	o |= NSApplicationPresentationHideDock | NSApplicationPresentationHideMenuBar;
+	return o;
+}
+
+- (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)theApplication {
+	return YES;
+}
+
+@end
+
+@implementation DevDrawView
+{
+	NSMutableString *_tmpText;
+	NSRange _markedRange;
+	NSRange _selectedRange;
+	NSRect _lastInputRect;	// The view is flipped, this is not.
+	BOOL _tapping;
+	NSUInteger _tapFingers;
+	NSUInteger _tapTime;
+}
+
+- (id)init
+{
+	LOG(@"View init");
+	self = [super init];
+	[self setAllowedTouchTypes:NSTouchTypeMaskDirect|NSTouchTypeMaskIndirect];
+	_tmpText = [[NSMutableString alloc] initWithCapacity:2];
+	_markedRange = NSMakeRange(NSNotFound, 0);
+	_selectedRange = NSMakeRange(0, 0);
+	return self;
+}
+
+- (CALayer *)makeBackingLayer
+{
+	LOG(@"makeBackingLayer");
+	return [DrawLayer layer];
+}
+
+- (BOOL)wantsUpdateLayer
+{
+	return YES;
+}
+
+- (BOOL)isOpaque
+{
+	return YES;
+}
+
+- (BOOL)isFlipped
+{
+	return YES;
+}
+
+- (BOOL)acceptsFirstResponder
+{
+	return YES;
+}
+
+- (void)mouseMoved:(NSEvent*)e{ [self getmouse:e];}
+- (void)mouseDown:(NSEvent*)e{ [self getmouse:e];}
+- (void)mouseDragged:(NSEvent*)e{ [self getmouse:e];}
+- (void)mouseUp:(NSEvent*)e{ [self getmouse:e];}
+- (void)otherMouseDown:(NSEvent*)e{ [self getmouse:e];}
+- (void)otherMouseDragged:(NSEvent*)e{ [self getmouse:e];}
+- (void)otherMouseUp:(NSEvent*)e{ [self getmouse:e];}
+- (void)rightMouseDown:(NSEvent*)e{ [self getmouse:e];}
+- (void)rightMouseDragged:(NSEvent*)e{ [self getmouse:e];}
+- (void)rightMouseUp:(NSEvent*)e{ [self getmouse:e];}
+
+- (void)scrollWheel:(NSEvent*)e
+{
+	NSInteger s;
+
+	s = [e scrollingDeltaY];
+	if(s > 0)
+		[self sendmouse:8];
+	else if (s < 0)
+		[self sendmouse:16];
+}
+
+- (void)keyDown:(NSEvent*)e
+{
+	LOG(@"keyDown to interpret");
+
+	[self interpretKeyEvents:[NSArray arrayWithObject:e]];
+
+	[self resetLastInputRect];
+}
+
+- (void)flagsChanged:(NSEvent*)e
+{
+	static NSEventModifierFlags omod;
+	NSEventModifierFlags m;
+	uint b;
+
+	LOG(@"flagsChanged");
+	m = [e modifierFlags];
+
+	b = [NSEvent pressedMouseButtons];
+	b = (b&~6) | (b&4)>>1 | (b&2)<<1;
+	if(b){
+		if(m & ~omod & NSEventModifierFlagControl)
+			b |= 1;
+		if(m & ~omod & NSEventModifierFlagOption)
+			b |= 2;
+		if(m & ~omod & NSEventModifierFlagCommand)
+			b |= 4;
+		[self sendmouse:b];
+	}else if(m & ~omod & NSEventModifierFlagOption)
+		keystroke(Kalt);
+
+	omod = m;
+}
+
+- (void)magnifyWithEvent:(NSEvent*)e
+{
+	if(fabs([e magnification]) > 0.02)
+		[[self window] toggleFullScreen:nil];
+}
+
+- (void)touchesBeganWithEvent:(NSEvent*)e
+{
+	_tapping = YES;
+	_tapFingers = [e touchesMatchingPhase:NSTouchPhaseTouching inView:nil].count;
+	_tapTime = msec();
+}
+- (void)touchesMovedWithEvent:(NSEvent*)e
+{
+	_tapping = NO;
+}
+- (void)touchesEndedWithEvent:(NSEvent*)e
+{
+	if(_tapping
+		&& [e touchesMatchingPhase:NSTouchPhaseTouching inView:nil].count == 0
+		&& msec() - _tapTime < 250){
+		switch(_tapFingers){
+		case 3:
+			[self sendmouse:2];
+			[self sendmouse:0];
+			break;
+		case 4:
+			[self sendmouse:2];
+			[self sendmouse:1];
+			[self sendmouse:0];
+			break;
+		}
+		_tapping = NO;
+	}
+}
+- (void)touchesCancelledWithEvent:(NSEvent*)e
+{
+	_tapping = NO;
+}
+
+- (void)getmouse:(NSEvent *)e
+{
+	NSUInteger b;
+	NSEventModifierFlags m;
+
+	b = [NSEvent pressedMouseButtons];
+	b = b&~6 | (b&4)>>1 | (b&2)<<1;
+	b = mouseswap(b);
+
+	if(b == 1){
+		m = [e modifierFlags];
+		if(m & NSEventModifierFlagOption){
+			abortcompose();
+			b = 2;
+		}else
+		if(m & NSEventModifierFlagCommand)
+			b = 4;
+	}
+	[self sendmouse:b];
+}
+
+- (void)sendmouse:(NSUInteger)b
+{
+	NSPoint p;
+
+	p = [self.window convertPointToBacking:
+		[self.window mouseLocationOutsideOfEventStream]];
+	p.y = Dy(mouserect) - p.y;
+	// LOG(@"(%g, %g) <- sendmouse(%d)", p.x, p.y, (uint)b);
+	mousetrack(p.x, p.y, b, msec());
+	if(b && _lastInputRect.size.width && _lastInputRect.size.height)
+		[self resetLastInputRect];
+}
+
+- (void)resetCursorRects {
+	[super resetCursorRects];
+	[self addCursorRect:self.bounds cursor:currentCursor];
+}
+
+- (void)viewDidEndLiveResize
+{
+	[super viewDidEndLiveResize];
+	resizeimg();
+}
+
+- (void)viewDidChangeBackingProperties
+{
+	[super viewDidChangeBackingProperties];
+	resizeimg();
+}
+
+// conforms to protocol NSTextInputClient
+- (BOOL)hasMarkedText
+{
+	LOG(@"hasMarkedText");
+	return _markedRange.location != NSNotFound;
+}
+- (NSRange)markedRange
+{
+	LOG(@"markedRange");
+	return _markedRange;
+}
+- (NSRange)selectedRange
+{
+	LOG(@"selectedRange");
+	return _selectedRange;
+}
+- (void)setMarkedText:(id)string
+	selectedRange:(NSRange)sRange
+	replacementRange:(NSRange)rRange
+{
+	NSString *str;
+
+	LOG(@"setMarkedText: %@ (%ld, %ld) (%ld, %ld)", string,
+		sRange.location, sRange.length,
+		rRange.location, rRange.length);
+
+	[self clearInput];
+
+	if([string isKindOfClass:[NSAttributedString class]])
+		str = [string string];
+	else
+		str = string;
+
+	if(rRange.location == NSNotFound){
+		if(_markedRange.location != NSNotFound){
+			rRange = _markedRange;
+		}else{
+			rRange = _selectedRange;
+		}
+	}
+
+	if(str.length == 0){
+		[_tmpText deleteCharactersInRange:rRange];
+		[self unmarkText];
+	}else{
+		_markedRange = NSMakeRange(rRange.location, str.length);
+		[_tmpText replaceCharactersInRange:rRange withString:str];
+	}
+	_selectedRange.location = rRange.location + sRange.location;
+	_selectedRange.length = sRange.length;
+
+	if(_tmpText.length){
+		uint i;
+		LOG(@"text length %ld", _tmpText.length);
+		for(i = 0; i <= _tmpText.length; ++i){
+			if(i == _markedRange.location)
+				keystroke('[');
+			if(_selectedRange.length){
+				if(i == _selectedRange.location)
+					keystroke('{');
+				if(i == NSMaxRange(_selectedRange))
+					keystroke('}');
+				}
+			if(i == NSMaxRange(_markedRange))
+				keystroke(']');
+			if(i < _tmpText.length)
+				keystroke([_tmpText characterAtIndex:i]);
+		}
+		int l;
+		l = 1 + _tmpText.length - NSMaxRange(_selectedRange)
+			+ (_selectedRange.length > 0);
+		LOG(@"move left %d", l);
+		for(i = 0; i < l; ++i)
+			keystroke(Kleft);
+	}
+
+	LOG(@"text: \"%@\"  (%ld,%ld)  (%ld,%ld)", _tmpText,
+		_markedRange.location, _markedRange.length,
+		_selectedRange.location, _selectedRange.length);
+}
+- (void)unmarkText
+{
+	//NSUInteger i;
+	NSUInteger len;
+
+	LOG(@"unmarkText");
+	len = [_tmpText length];
+	//for(i = 0; i < len; ++i)
+	//	keystroke([_tmpText characterAtIndex:i]);
+	[_tmpText deleteCharactersInRange:NSMakeRange(0, len)];
+	_markedRange = NSMakeRange(NSNotFound, 0);
+	_selectedRange = NSMakeRange(0, 0);
+}
+- (NSArray<NSAttributedStringKey> *)validAttributesForMarkedText
+{
+	LOG(@"validAttributesForMarkedText");
+	return @[];
+}
+- (NSAttributedString *)attributedSubstringForProposedRange:(NSRange)r
+	actualRange:(NSRangePointer)actualRange
+{
+	NSRange sr;
+	NSAttributedString *s;
+
+	LOG(@"attributedSubstringForProposedRange: (%ld, %ld) (%ld, %ld)",
+		r.location, r.length, actualRange->location, actualRange->length);
+	sr = NSMakeRange(0, [_tmpText length]);
+	sr = NSIntersectionRange(sr, r);
+	if(actualRange)
+		*actualRange = sr;
+	LOG(@"use range: %ld, %ld", sr.location, sr.length);
+	if(sr.length)
+		s = [[NSAttributedString alloc]
+			initWithString:[_tmpText substringWithRange:sr]];
+	LOG(@"	return %@", s);
+	return s;
+}
+- (void)insertText:(id)s
+	replacementRange:(NSRange)r
+{
+	NSUInteger i;
+	NSUInteger len;
+
+	LOG(@"insertText: %@ replacementRange: %ld, %ld", s, r.location, r.length);
+
+	[self clearInput];
+
+	len = [s length];
+	for(i = 0; i < len; ++i)
+		keystroke([s characterAtIndex:i]);
+	[_tmpText deleteCharactersInRange:NSMakeRange(0, _tmpText.length)];
+	_markedRange = NSMakeRange(NSNotFound, 0);
+	_selectedRange = NSMakeRange(0, 0);
+}
+- (NSUInteger)characterIndexForPoint:(NSPoint)point
+{
+	LOG(@"characterIndexForPoint: %g, %g", point.x, point.y);
+	return 0;
+}
+- (NSRect)firstRectForCharacterRange:(NSRange)r
+	actualRange:(NSRangePointer)actualRange
+{
+	LOG(@"firstRectForCharacterRange: (%ld, %ld) (%ld, %ld)",
+		r.location, r.length, actualRange->location, actualRange->length);
+	if(actualRange)
+		*actualRange = r;
+	return [[self window] convertRectToScreen:_lastInputRect];
+}
+- (void)doCommandBySelector:(SEL)s
+{
+	NSEvent *e;
+	NSEventModifierFlags m;
+	uint c, k;
+
+	LOG(@"doCommandBySelector (%@)", NSStringFromSelector(s));
+
+	e = [NSApp currentEvent];
+	c = [[e characters] characterAtIndex:0];
+	k = keycvt(c);
+	LOG(@"keyDown: character0: 0x%x -> 0x%x", c, k);
+	m = [e modifierFlags];
+
+	if(m & NSEventModifierFlagCommand){
+		if((m & NSEventModifierFlagShift) && 'a' <= k && k <= 'z')
+			k += 'A' - 'a';
+		if(' '<=k && k<='~')
+			k += Kcmd;
+	}
+	if(k>0)
+		keystroke(k);
+}
+
+// Helper for managing input rect approximately
+- (void)resetLastInputRect
+{
+	LOG(@"resetLastInputRect");
+	_lastInputRect.origin.x = 0.0;
+	_lastInputRect.origin.y = 0.0;
+	_lastInputRect.size.width = 0.0;
+	_lastInputRect.size.height = 0.0;
+}
+
+- (void)enlargeLastInputRect:(NSRect)r
+{
+	r.origin.y = [self bounds].size.height - r.origin.y - r.size.height;
+	_lastInputRect = NSUnionRect(_lastInputRect, r);
+	LOG(@"update last input rect (%g, %g, %g, %g)",
+		_lastInputRect.origin.x, _lastInputRect.origin.y,
+		_lastInputRect.size.width, _lastInputRect.size.height);
+}
+
+- (void)clearInput
+{
+	if(_tmpText.length){
+		uint i;
+		int l;
+		l = 1 + _tmpText.length - NSMaxRange(_selectedRange)
+			+ (_selectedRange.length > 0);
+		LOG(@"move right %d", l);
+		for(i = 0; i < l; ++i)
+			keystroke(Kright);
+		l = _tmpText.length+2+2*(_selectedRange.length > 0);
+		LOG(@"backspace %d", l);
+		for(uint i = 0; i < l; ++i)
+			keystroke(Kbs);
+	}
+}
+
+@end
+
+@implementation DrawLayer
+
+- (void)display
+{
+	id<MTLCommandBuffer> cbuf;
+	id<MTLRenderCommandEncoder> cmd;
+
+	LOG(@"display");
+
+	cbuf = [commandQueue commandBuffer];
+
+	LOG(@"display query drawable");
+
+@autoreleasepool{
+	id<CAMetalDrawable> drawable;
+
+	drawable = [layer nextDrawable];
+	if(!drawable){
+		LOG(@"display couldn't get drawable");
+		[self setNeedsDisplay];
+		return;
+	}
+
+	LOG(@"display got drawable");
+
+	renderPass.colorAttachments[0].texture = drawable.texture;
+
+	cmd = [cbuf renderCommandEncoderWithDescriptor:renderPass];
+	[cmd setRenderPipelineState:pipelineState];
+	[cmd setFragmentTexture:texture atIndex:0];
+	[cmd drawPrimitives:MTLPrimitiveTypeTriangleStrip vertexStart:0 vertexCount:4];
+	[cmd endEncoding];
+
+	[cbuf presentDrawable:drawable];
+	drawable = nil;
+}
+	[cbuf addCompletedHandler:^(id<MTLCommandBuffer> cmdBuff){
+		if(cmdBuff.error){
+			NSLog(@"command buffer finished with error: %@",
+				cmdBuff.error.localizedDescription);
+		}else
+			LOG(@"command buffer finishes present drawable");
+	}];
+	[cbuf commit];
+
+	LOG(@"display commit");
+}
+
+@end
+
+static uint
+msec(void)
+{
+	return nsec()/1000000;
+}
+
+static uint
+keycvt(uint code)
+{
+	switch(code){
+	case '\r': return '\n';
+	case '\b': return 127;
+	case 127: return '\b';
+	case NSUpArrowFunctionKey: return Kup;
+	case NSDownArrowFunctionKey: return Kdown;
+	case NSLeftArrowFunctionKey: return Kleft;
+	case NSRightArrowFunctionKey: return Kright;
+	case NSInsertFunctionKey: return Kins;
+	case NSDeleteFunctionKey: return Kdel;
+	case NSHomeFunctionKey: return Khome;
+	case NSEndFunctionKey: return Kend;
+	case NSPageUpFunctionKey: return Kpgup;
+	case NSPageDownFunctionKey: return Kpgdown;
+	case NSF1FunctionKey: return KF|1;
+	case NSF2FunctionKey: return KF|2;
+	case NSF3FunctionKey: return KF|3;
+	case NSF4FunctionKey: return KF|4;
+	case NSF5FunctionKey: return KF|5;
+	case NSF6FunctionKey: return KF|6;
+	case NSF7FunctionKey: return KF|7;
+	case NSF8FunctionKey: return KF|8;
+	case NSF9FunctionKey: return KF|9;
+	case NSF10FunctionKey: return KF|10;
+	case NSF11FunctionKey: return KF|11;
+	case NSF12FunctionKey: return KF|12;
+	case NSBeginFunctionKey:
+	case NSPrintScreenFunctionKey:
+	case NSScrollLockFunctionKey:
+	case NSF13FunctionKey:
+	case NSF14FunctionKey:
+	case NSF15FunctionKey:
+	case NSF16FunctionKey:
+	case NSF17FunctionKey:
+	case NSF18FunctionKey:
+	case NSF19FunctionKey:
+	case NSF20FunctionKey:
+	case NSF21FunctionKey:
+	case NSF22FunctionKey:
+	case NSF23FunctionKey:
+	case NSF24FunctionKey:
+	case NSF25FunctionKey:
+	case NSF26FunctionKey:
+	case NSF27FunctionKey:
+	case NSF28FunctionKey:
+	case NSF29FunctionKey:
+	case NSF30FunctionKey:
+	case NSF31FunctionKey:
+	case NSF32FunctionKey:
+	case NSF33FunctionKey:
+	case NSF34FunctionKey:
+	case NSF35FunctionKey:
+	case NSPauseFunctionKey:
+	case NSSysReqFunctionKey:
+	case NSBreakFunctionKey:
+	case NSResetFunctionKey:
+	case NSStopFunctionKey:
+	case NSMenuFunctionKey:
+	case NSUserFunctionKey:
+	case NSSystemFunctionKey:
+	case NSPrintFunctionKey:
+	case NSClearLineFunctionKey:
+	case NSClearDisplayFunctionKey:
+	case NSInsertLineFunctionKey:
+	case NSDeleteLineFunctionKey:
+	case NSInsertCharFunctionKey:
+	case NSDeleteCharFunctionKey:
+	case NSPrevFunctionKey:
+	case NSNextFunctionKey:
+	case NSSelectFunctionKey:
+	case NSExecuteFunctionKey:
+	case NSUndoFunctionKey:
+	case NSRedoFunctionKey:
+	case NSFindFunctionKey:
+	case NSHelpFunctionKey:
+	case NSModeSwitchFunctionKey: return 0;
+	default: return code;
+	}
+}
+
+Memimage*
+attachscreen(char *label, char *winsize)
+{
+	LOG(@"attachscreen(%s, %s)", label, winsize);
+	[AppDelegate
+		performSelectorOnMainThread:@selector(makewin:)
+		withObject:[NSValue valueWithPointer:winsize]
+		waitUntilDone:YES];
+	kicklabel(label);
+	setcursor(nil);
+	mouseresized = 0;
+	return initimg();
+}
+
+static Memimage*
+initimg(void)
+{
+@autoreleasepool{
+	CGFloat scale;
+	NSSize size;
+	MTLTextureDescriptor *textureDesc;
+
+	size = [myContent convertSizeToBacking:[myContent bounds].size];
+	mouserect = Rect(0, 0, size.width, size.height);
+
+	LOG(@"initimg %.0f %.0f", size.width, size.height);
+
+	img = allocmemimage(mouserect, XRGB32);
+	if(img == nil)
+		panic("allocmemimage: %r");
+	if(img->data == nil)
+		panic("img->data == nil");
+
+	textureDesc = [MTLTextureDescriptor
+		texture2DDescriptorWithPixelFormat:MTLPixelFormatBGRA8Unorm
+		width:size.width
+		height:size.height
+		mipmapped:NO];
+	textureDesc.allowGPUOptimizedContents = YES;
+	textureDesc.usage = MTLTextureUsageShaderRead;
+	textureDesc.cpuCacheMode = MTLCPUCacheModeWriteCombined;
+	texture = [device newTextureWithDescriptor:textureDesc];
+
+	scale = [win backingScaleFactor];
+	[layer setDrawableSize:size];
+	[layer setContentsScale:scale];
+
+	// NOTE: This is not really the display DPI.
+	// On retina, scale is 2; otherwise it is 1.
+	// This formula gives us 220 for retina, 110 otherwise.
+	// That's not quite right but it's close to correct.
+	// https://en.wikipedia.org/wiki/Retina_display#Models
+	displaydpi = scale * 110;
+}
+	LOG(@"initimg return");
+
+	return img;
+}
+
+void
+_flushmemscreen(Rectangle r)
+{
+	LOG(@"_flushmemscreen(%d,%d,%d,%d)", r.min.x, r.min.y, Dx(r), Dy(r));
+
+	@autoreleasepool{
+		[texture
+			replaceRegion:MTLRegionMake2D(r.min.x, r.min.y, Dx(r), Dy(r))
+			mipmapLevel:0
+			withBytes:byteaddr(img, Pt(r.min.x, r.min.y))
+			bytesPerRow:img->width*sizeof(u32int)];
+		[AppDelegate
+			performSelectorOnMainThread:@selector(callsetNeedsDisplayInRect:)
+			withObject:[NSValue valueWithRect:NSMakeRect(r.min.x, r.min.y, Dx(r), Dy(r))]
+			waitUntilDone:NO];
+	}
+}
+
+void
+setmouse(Point p)
+{
+	@autoreleasepool{
+		NSPoint q;
+
+		LOG(@"setmouse(%d,%d)", p.x, p.y);
+		q = [win convertPointFromBacking:NSMakePoint(p.x, p.y)];
+		LOG(@"(%g, %g) <- fromBacking", q.x, q.y);
+		q = [myContent convertPoint:q toView:nil];
+		LOG(@"(%g, %g) <- toWindow", q.x, q.y);
+		q = [win convertPointToScreen:q];
+		LOG(@"(%g, %g) <- toScreen", q.x, q.y);
+		// Quartz has the origin of the "global display
+		// coordinate space" at the top left of the primary
+		// screen with y increasing downward, while Cocoa has
+		// the origin at the bottom left of the primary screen
+		// with y increasing upward.  We flip the coordinate
+		// with a negative sign and shift upward by the height
+		// of the primary screen.
+		q.y = NSScreen.screens[0].frame.size.height - q.y;
+		LOG(@"(%g, %g) <- setmouse", q.x, q.y);
+		CGWarpMouseCursorPosition(NSPointToCGPoint(q));
+		CGAssociateMouseAndMouseCursorPosition(true);
+	}
+}
+
+char*
+getsnarf(void)
+{
+	NSPasteboard *pb;
+	NSString *s;
+
+	@autoreleasepool{
+		pb = [NSPasteboard generalPasteboard];
+
+		qlock(&snarfl);
+		s = [pb stringForType:NSPasteboardTypeString];
+		qunlock(&snarfl);
+
+		if(s)
+			return strdup((char *)[s UTF8String]);
+		else
+			return nil;
+	}
+}
+
+void
+putsnarf(char *s)
+{
+	NSArray *t;
+	NSPasteboard *pb;
+	NSString *str;
+
+	if(strlen(s) >= SnarfSize)
+		return;
+
+	@autoreleasepool{
+		t = [NSArray arrayWithObject:NSPasteboardTypeString];
+		pb = [NSPasteboard generalPasteboard];
+		str = [[NSString alloc] initWithUTF8String:s];
+
+		qlock(&snarfl);
+		[pb declareTypes:t owner:nil];
+		[pb setString:str forType:NSPasteboardTypeString];
+		qunlock(&snarfl);
+	}
+}
+
+void
+kicklabel(char *label)
+{
+	NSString *s;
+
+	LOG(@"kicklabel(%s)", label);
+	if(label == nil)
+		return;
+
+	@autoreleasepool{
+		s = [[NSString alloc] initWithUTF8String:label];
+		[AppDelegate
+			performSelectorOnMainThread:@selector(callkicklabel:)
+			withObject:s
+			waitUntilDone:NO];
+	}
+}
+
+void
+setcursor(Cursor *c)
+{
+	[AppDelegate
+		performSelectorOnMainThread:@selector(callsetcursor:)
+		withObject:[NSValue valueWithPointer:c]
+		waitUntilDone:YES];
+}
+
+void
+topwin(void)
+{
+	[win
+		performSelectorOnMainThread:
+		@selector(makeKeyAndOrderFront:)
+		withObject:nil
+		waitUntilDone:YES];
+
+	[NSApp activateIgnoringOtherApps:YES];
+}
+
+void
+resizeimg(void)
+{
+	zlock();
+	_drawreplacescreenimage(initimg());
+
+	mouseresized = 1;
+	zunlock();
+	[myContent sendmouse:0];
+}
+
+void
+resizewindow(Rectangle r)
+{
+	LOG(@"resizewindow %d %d %d %d", r.min.x, r.min.y, Dx(r), Dy(r));
+	dispatch_async(dispatch_get_main_queue(), ^(void){
+		NSSize s;
+
+		s = [myContent convertSizeFromBacking:NSMakeSize(Dx(r), Dy(r))];
+		[win setContentSize:s];
+		resizeimg();
+	});
+}
+
+static void
+setprocname(const char *s)
+{
+  CFStringRef process_name;
+
+  process_name = CFStringCreateWithBytes(nil, (uchar*)s, strlen(s), kCFStringEncodingUTF8, false);
+
+  // Adapted from Chrome's mac_util.mm.
+  // http://src.chromium.org/viewvc/chrome/trunk/src/base/mac/mac_util.mm
+  //
+  // Copyright (c) 2012 The Chromium Authors. All rights reserved.
+  //
+  // Redistribution and use in source and binary forms, with or without
+  // modification, are permitted provided that the following conditions are
+  // met:
+  //
+  //    * Redistributions of source code must retain the above copyright
+  // notice, this list of conditions and the following disclaimer.
+  //    * Redistributions in binary form must reproduce the above
+  // copyright notice, this list of conditions and the following disclaimer
+  // in the documentation and/or other materials provided with the
+  // distribution.
+  //    * Neither the name of Google Inc. nor the names of its
+  // contributors may be used to endorse or promote products derived from
+  // this software without specific prior written permission.
+  //
+  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+  // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+  // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+  // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+  // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+  // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+  // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+  // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+  // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+  // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+  // Warning: here be dragons! This is SPI reverse-engineered from WebKit's
+  // plugin host, and could break at any time (although realistically it's only
+  // likely to break in a new major release).
+  // When 10.7 is available, check that this still works, and update this
+  // comment for 10.8.
+
+  // Private CFType used in these LaunchServices calls.
+  typedef CFTypeRef PrivateLSASN;
+  typedef PrivateLSASN (*LSGetCurrentApplicationASNType)();
+  typedef OSStatus (*LSSetApplicationInformationItemType)(int, PrivateLSASN,
+                                                          CFStringRef,
+                                                          CFStringRef,
+                                                          CFDictionaryRef*);
+
+  static LSGetCurrentApplicationASNType ls_get_current_application_asn_func =
+      NULL;
+  static LSSetApplicationInformationItemType
+      ls_set_application_information_item_func = NULL;
+  static CFStringRef ls_display_name_key = NULL;
+
+  static bool did_symbol_lookup = false;
+  if (!did_symbol_lookup) {
+    did_symbol_lookup = true;
+    CFBundleRef launch_services_bundle =
+        CFBundleGetBundleWithIdentifier(CFSTR("com.apple.LaunchServices"));
+    if (!launch_services_bundle) {
+      fprint(2, "Failed to look up LaunchServices bundle\n");
+      return;
+    }
+
+    ls_get_current_application_asn_func =
+        (LSGetCurrentApplicationASNType)(
+            CFBundleGetFunctionPointerForName(
+                launch_services_bundle, CFSTR("_LSGetCurrentApplicationASN")));
+    if (!ls_get_current_application_asn_func)
+      fprint(2, "Could not find _LSGetCurrentApplicationASN\n");
+
+    ls_set_application_information_item_func =
+        (LSSetApplicationInformationItemType)(
+            CFBundleGetFunctionPointerForName(
+                launch_services_bundle,
+                CFSTR("_LSSetApplicationInformationItem")));
+    if (!ls_set_application_information_item_func)
+      fprint(2, "Could not find _LSSetApplicationInformationItem\n");
+
+    CFStringRef* key_pointer = (CFStringRef*)(
+        CFBundleGetDataPointerForName(launch_services_bundle,
+                                      CFSTR("_kLSDisplayNameKey")));
+    ls_display_name_key = key_pointer ? *key_pointer : NULL;
+    if (!ls_display_name_key)
+      fprint(2, "Could not find _kLSDisplayNameKey\n");
+
+    // Internally, this call relies on the Mach ports that are started up by the
+    // Carbon Process Manager.  In debug builds this usually happens due to how
+    // the logging layers are started up; but in release, it isn't started in as
+    // much of a defined order.  So if the symbols had to be loaded, go ahead
+    // and force a call to make sure the manager has been initialized and hence
+    // the ports are opened.
+    ProcessSerialNumber psn;
+    GetCurrentProcess(&psn);
+  }
+  if (!ls_get_current_application_asn_func ||
+      !ls_set_application_information_item_func ||
+      !ls_display_name_key) {
+    return;
+  }
+
+  PrivateLSASN asn = ls_get_current_application_asn_func();
+  // Constant used by WebKit; what exactly it means is unknown.
+  const int magic_session_constant = -2;
+  OSErr err =
+      ls_set_application_information_item_func(magic_session_constant, asn,
+                                               ls_display_name_key,
+                                               process_name,
+                                               NULL /* optional out param */);
+  if(err != noErr)
+    fprint(2, "Call to set process name failed\n");
+}
diff --git a/src/cmd/devdraw/cocoa-screen.h b/src/cmd/devdraw/cocoa-screen.h
index 3c4c94c5..7b41c34b 100644
--- a/src/cmd/devdraw/cocoa-screen.h
+++ b/src/cmd/devdraw/cocoa-screen.h
@@ -16,5 +16,9 @@ void	servep9p(void);
 void	zlock(void);
 void	zunlock(void);
 
+void resizeimg(void);
+
 Rectangle mouserect;
-int	mouseresized;
+
+int mouseresized;
+void resizewindow(Rectangle);
diff --git a/src/cmd/devdraw/cocoa-srv.c b/src/cmd/devdraw/cocoa-srv.c
index 197fd512..6f9449ad 100644
--- a/src/cmd/devdraw/cocoa-srv.c
+++ b/src/cmd/devdraw/cocoa-srv.c
@@ -21,7 +21,7 @@ typedef struct Tagbuf Tagbuf;
 
 struct Kbdbuf
 {
-	Rune r[32];
+	Rune r[256];
 	int ri;
 	int wi;
 	int stall;
@@ -29,7 +29,7 @@ struct Kbdbuf
 
 struct Mousebuf
 {
-	Mouse m[32];
+	Mouse m[256];
 	Mouse last;
 	int ri;
 	int wi;
@@ -38,7 +38,7 @@ struct Mousebuf
 
 struct Tagbuf
 {
-	int t[32];
+	int t[256];
 	int ri;
 	int wi;
 };
@@ -97,7 +97,7 @@ servep9p(void)
 		/* pick off messages one by one */
 		if(convM2W(mbuf, nn+4, &m) <= 0)
 			sysfatal("cannot convert message");
-		if(trace) fprint(2, "<- %W\n", &m);
+		if(trace) fprint(2, "%ud [%d] <- %W\n", nsec()/1000000, threadid(), &m);
 		runmsg(&m);
 	}
 }
@@ -191,6 +191,7 @@ runmsg(Wsysmsg *m)
 		break;
 
 	case Trddraw:
+		zlock();
 		n = m->count;
 		if(n > sizeof buf)
 			n = sizeof buf;
@@ -202,13 +203,16 @@ runmsg(Wsysmsg *m)
 			m->data = buf;
 			replymsg(m);
 		}
+		zunlock();
 		break;
 
 	case Twrdraw:
+		zlock();
 		if(_drawmsgwrite(m->data, m->count) < 0)
 			replyerror(m);
 		else
 			replymsg(m);
+		zunlock();
 		break;
 	
 	case Ttop:
@@ -217,7 +221,9 @@ runmsg(Wsysmsg *m)
 		break;
 	
 	case Tresize:
-	//	_xresizewindow(m->rect);
+#if OSX_VERSION >= 101400
+		resizewindow(m->rect);
+#endif
 		replymsg(m);
 		break;
 	}
@@ -238,7 +244,7 @@ replymsg(Wsysmsg *m)
 	if(m->type%2 == 0)
 		m->type++;
 		
-	if(trace) fprint(2, "-> %W\n", m);
+	if(trace) fprint(2, "%ud [%d] -> %W\n", nsec()/1000000, threadid(), m);
 	/* copy to output buffer */
 	n = sizeW2M(m);
 
@@ -293,11 +299,11 @@ matchmouse(void)
 			mousetags.ri = 0;
 		m.mouse = mouse.m[mouse.ri];
 		m.resized = mouseresized;
+		mouseresized = 0;
 		/*
 		if(m.resized)
 			fprint(2, "sending resize\n");
 		*/
-		mouseresized = 0;
 		mouse.ri++;
 		if(mouse.ri == nelem(mouse.m))
 			mouse.ri = 0;
@@ -367,8 +373,6 @@ abortcompose(void)
 		keystroke(Kalt);
 }
 
-void resizeimg(void);
-
 void
 keystroke(int c)
 {
diff --git a/src/cmd/devdraw/cocoa-thread.c b/src/cmd/devdraw/cocoa-thread.c
index c9b280f7..92b92d2c 100644
--- a/src/cmd/devdraw/cocoa-thread.c
+++ b/src/cmd/devdraw/cocoa-thread.c
@@ -25,4 +25,11 @@ qunlock(QLock *q)
 {
 	pthread_mutex_unlock(&q->m);
 }
+
+int
+threadid(void)
+{
+	return pthread_mach_thread_np(pthread_self());
+}
+
 #endif
diff --git a/src/cmd/devdraw/cocoa-thread.h b/src/cmd/devdraw/cocoa-thread.h
index c2f3e982..d5793f0a 100644
--- a/src/cmd/devdraw/cocoa-thread.h
+++ b/src/cmd/devdraw/cocoa-thread.h
@@ -30,4 +30,5 @@
 
 	void	qlock(QLock*);
 	void	qunlock(QLock*);
+	int threadid(void);
 #endif
diff --git a/src/cmd/devdraw/mkfile b/src/cmd/devdraw/mkfile
index cad244ac..2e40087e 100644
--- a/src/cmd/devdraw/mkfile
+++ b/src/cmd/devdraw/mkfile
@@ -35,6 +35,9 @@ latin1.h: $PLAN9/lib/keyboard $O.mklatinkbd
 $O.macargv: $MACARGV
 	$LD -o $target $prereq
 
+cocoa-screen-metal-objc.$O: cocoa-screen-metal.m
+	$CC $CFLAGS $OBJCFLAGS -o $target cocoa-screen-metal.m
+
 %-objc.$O: %.m
 	$CC $CFLAGS -o $target $stem.m
 
diff --git a/src/cmd/devdraw/mkwsysrules.sh b/src/cmd/devdraw/mkwsysrules.sh
index 9c422261..98d6799d 100644
--- a/src/cmd/devdraw/mkwsysrules.sh
+++ b/src/cmd/devdraw/mkwsysrules.sh
@@ -60,7 +60,12 @@ elif [ $WSYSTYPE = osx ]; then
 	echo 'WSYSOFILES=$WSYSOFILES osx-screen-carbon-objc.o osx-draw.o osx-srv.o'
 	echo 'MACARGV=macargv.o'
 elif [ $WSYSTYPE = osx-cocoa ]; then
-	echo 'WSYSOFILES=$WSYSOFILES osx-draw.o cocoa-screen-objc.o cocoa-srv.o cocoa-thread.o'
+	if sw_vers|awk '/ProductVersion/{split($2,a,".");exit(a[2]<14)}' >/dev/null; then	# 0 is true in sh.
+		echo 'OBJCFLAGS=$OBJCFLAGS -fobjc-arc'
+		echo 'WSYSOFILES=$WSYSOFILES osx-draw.o cocoa-screen-metal-objc.o cocoa-srv.o cocoa-thread.o'
+	else
+		echo 'WSYSOFILES=$WSYSOFILES osx-draw.o cocoa-screen-objc.o cocoa-srv.o cocoa-thread.o'
+	fi
 	echo 'MACARGV=macargv-objc.o'
 elif [ $WSYSTYPE = nowsys ]; then
 	echo 'WSYSOFILES=nowsys.o'