app,internal/window: extract native window code to separate package

Signed-off-by: Elias Naur <mail@eliasnaur.com>

app/internal/window/GioActivity.java

@@ -0,0 +1,58 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package org.gioui;
+
+import android.app.Activity;
+import android.content.res.Configuration;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.View;
+import android.view.Window;
+import android.view.WindowManager;
+
+public class GioActivity extends Activity {
+	private GioView view;
+
+	@Override public void onCreate(Bundle state) {
+		super.onCreate(state);
+
+		Window w = getWindow();
+
+		this.view = new GioView(this);
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+			this.view.setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION | View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
+		}
+		this.view.setLayoutParams(new WindowManager.LayoutParams(WindowManager.LayoutParams.MATCH_PARENT, WindowManager.LayoutParams.MATCH_PARENT));
+		setContentView(view);
+	}
+
+	@Override public void onDestroy() {
+		view.destroy();
+		super.onDestroy();
+	}
+
+	@Override public void onStart() {
+		super.onStart();
+		view.start();
+	}
+
+	@Override public void onStop() {
+		view.stop();
+		super.onStop();
+	}
+
+	@Override public void onConfigurationChanged(Configuration c) {
+		super.onConfigurationChanged(c);
+		view.configurationChanged();
+	}
+
+	@Override public void onLowMemory() {
+		super.onLowMemory();
+		view.lowMemory();
+	}
+
+	@Override public void onBackPressed() {
+		if (!view.backPressed())
+			super.onBackPressed();
+	}
+}

app/internal/window/GioView.java

@@ -0,0 +1,238 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package org.gioui;
+
+import android.content.Context;
+import android.graphics.Rect;
+import android.os.Build;
+import android.os.Handler;
+import android.util.AttributeSet;
+import android.text.Editable;
+import android.view.Choreographer;
+import android.view.KeyCharacterMap;
+import android.view.KeyEvent;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.WindowInsets;
+import android.view.Surface;
+import android.view.SurfaceView;
+import android.view.SurfaceHolder;
+import android.view.inputmethod.BaseInputConnection;
+import android.view.inputmethod.InputConnection;
+import android.view.inputmethod.InputMethodManager;
+import android.view.inputmethod.EditorInfo;
+
+import java.io.UnsupportedEncodingException;
+
+public class GioView extends SurfaceView implements Choreographer.FrameCallback {
+	private final static Object initLock = new Object();
+	private static boolean jniLoaded;
+
+	private final SurfaceHolder.Callback callbacks;
+	private final InputMethodManager imm;
+	private final Handler handler;
+	private long nhandle;
+
+	private static synchronized void initialize(Context appCtx) {
+		synchronized (initLock) {
+			if (jniLoaded) {
+				return;
+			}
+			String dataDir = appCtx.getFilesDir().getAbsolutePath();
+			byte[] dataDirUTF8;
+			try {
+				dataDirUTF8 = dataDir.getBytes("UTF-8");
+			} catch (UnsupportedEncodingException e) {
+				throw new RuntimeException(e);
+			}
+			System.loadLibrary("gio");
+			runGoMain(dataDirUTF8);
+			jniLoaded = true;
+		}
+	}
+
+	public GioView(Context context) {
+		this(context, null);
+	}
+
+	public GioView(Context context, AttributeSet attrs) {
+		super(context, attrs);
+		// Late initialization of the Go runtime to wait for a valid context.
+		initialize(context.getApplicationContext());
+
+		nhandle = onCreateView(this);
+		handler = new Handler();
+		imm = (InputMethodManager)context.getSystemService(Context.INPUT_METHOD_SERVICE);
+		setFocusable(true);
+		setFocusableInTouchMode(true);
+		setOnFocusChangeListener(new View.OnFocusChangeListener() {
+			@Override public void onFocusChange(View v, boolean focus) {
+				GioView.this.onFocusChange(nhandle, focus);
+			}
+		});
+		callbacks = new SurfaceHolder.Callback() {
+			@Override public void surfaceCreated(SurfaceHolder holder) {
+				// Ignore; surfaceChanged is guaranteed to be called immediately after this.
+			}
+			@Override public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
+				onSurfaceChanged(nhandle, getHolder().getSurface());
+			}
+			@Override public void surfaceDestroyed(SurfaceHolder holder) {
+				onSurfaceDestroyed(nhandle);
+			}
+		};
+		getHolder().addCallback(callbacks);
+	}
+
+	@Override public boolean onKeyDown(int keyCode, KeyEvent event) {
+		onKeyEvent(nhandle, keyCode, event.getUnicodeChar(), event.getEventTime());
+		return false;
+	}
+
+	@Override public boolean onTouchEvent(MotionEvent event) {
+		// Ask for unbuffered events. Flutter and Chrome does it
+		// so I assume its good for us as well.
+		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+			requestUnbufferedDispatch(event);
+		}
+
+		for (int j = 0; j < event.getHistorySize(); j++) {
+			long time = event.getHistoricalEventTime(j);
+			for (int i = 0; i < event.getPointerCount(); i++) {
+				onTouchEvent(
+						nhandle,
+						event.ACTION_MOVE,
+						event.getPointerId(i),
+						event.getToolType(i),
+						event.getHistoricalX(i, j),
+						event.getHistoricalY(i, j),
+						time);
+			}
+		}
+		int act = event.getActionMasked();
+		int idx = event.getActionIndex();
+		for (int i = 0; i < event.getPointerCount(); i++) {
+			int pact = event.ACTION_MOVE;
+			if (i == idx) {
+				pact = act;
+			}
+			onTouchEvent(
+					nhandle,
+					act,
+					event.getPointerId(i),
+					event.getToolType(i),
+					event.getX(i),
+					event.getY(i),
+					event.getEventTime());
+		}
+		return true;
+	}
+
+	@Override public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
+		return new InputConnection(this);
+	}
+
+	void showTextInput() {
+		post(new Runnable() {
+			@Override public void run() {
+				GioView.this.requestFocus();
+				imm.showSoftInput(GioView.this, 0);
+			}
+		});
+	}
+
+	void hideTextInput() {
+		post(new Runnable() {
+			@Override public void run() {
+				imm.hideSoftInputFromWindow(getWindowToken(), 0);
+			}
+		});
+	}
+
+	void postFrameCallbackOnMainThread() {
+		handler.post(new Runnable() {
+			@Override public void run() {
+				postFrameCallback();
+			}
+		});
+	}
+
+	@Override protected boolean fitSystemWindows(Rect insets) {
+		onWindowInsets(nhandle, insets.top, insets.right, insets.bottom, insets.left);
+		return true;
+	}
+
+	void postFrameCallback() {
+		Choreographer.getInstance().removeFrameCallback(this);
+		Choreographer.getInstance().postFrameCallback(this);
+	}
+
+	@Override public void doFrame(long nanos) {
+		onFrameCallback(nhandle, nanos);
+	}
+
+	int getDensity() {
+		return getResources().getDisplayMetrics().densityDpi;
+	}
+
+	float getFontScale() {
+		return getResources().getConfiguration().fontScale;
+	}
+
+	void start() {
+		onStartView(nhandle);
+	}
+
+	void stop() {
+		onStopView(nhandle);
+	}
+
+	void destroy() {
+		getHolder().removeCallback(callbacks);
+		onDestroyView(nhandle);
+		nhandle = 0;
+	}
+
+	void configurationChanged() {
+		onConfigurationChanged(nhandle);
+	}
+
+	void lowMemory() {
+		onLowMemory();
+	}
+
+	boolean backPressed() {
+		return onBack(nhandle);
+	}
+
+	static private native long onCreateView(GioView view);
+	static private native void onDestroyView(long handle);
+	static private native void onStartView(long handle);
+	static private native void onStopView(long handle);
+	static private native void onSurfaceDestroyed(long handle);
+	static private native void onSurfaceChanged(long handle, Surface surface);
+	static private native void onConfigurationChanged(long handle);
+	static private native void onWindowInsets(long handle, int top, int right, int bottom, int left);
+	static private native void onLowMemory();
+	static private native void onTouchEvent(long handle, int action, int pointerID, int tool, float x, float y, long time);
+	static private native void onKeyEvent(long handle, int code, int character, long time);
+	static private native void onFrameCallback(long handle, long nanos);
+	static private native boolean onBack(long handle);
+	static private native void onFocusChange(long handle, boolean focus);
+	static private native void runGoMain(byte[] dataDir);
+
+	private static class InputConnection extends BaseInputConnection {
+		private final Editable editable;
+
+		InputConnection(View view) {
+			// Passing false enables "dummy mode", where the BaseInputConnection
+			// attempts to convert IME operations to key events.
+			super(view, false);
+			editable = Editable.Factory.getInstance().newEditable("");
+		}
+
+		@Override public Editable getEditable() {
+			return editable;
+		}
+	}
+}

app/internal/window/egl.go

@@ -0,0 +1,274 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build linux windows
+
+package window
+
+import (
+	"errors"
+	"fmt"
+	"runtime"
+	"strings"
+
+	"gioui.org/app/internal/gl"
+)
+
+type context struct {
+	c             *gl.Functions
+	driver        eglDriver
+	eglCtx        *eglContext
+	eglWin        _EGLNativeWindowType
+	eglSurf       _EGLSurface
+	width, height int
+	// For sRGB emulation.
+	srgbFBO *gl.SRGBFBO
+}
+
+type eglDriver interface {
+	eglDisplay() _EGLNativeDisplayType
+	eglWindow(visID int) (_EGLNativeWindowType, int, int, error)
+	eglDestroy()
+}
+
+type eglContext struct {
+	disp     _EGLDisplay
+	config   _EGLConfig
+	ctx      _EGLContext
+	visualID int
+	srgb     bool
+}
+
+var (
+	nilEGLSurface          _EGLSurface
+	nilEGLContext          _EGLContext
+	nilEGLConfig           _EGLConfig
+	nilEGLNativeWindowType _EGLNativeWindowType
+)
+
+const (
+	_EGL_ALPHA_SIZE             = 0x3021
+	_EGL_BLUE_SIZE              = 0x3022
+	_EGL_CONFIG_CAVEAT          = 0x3027
+	_EGL_CONTEXT_CLIENT_VERSION = 0x3098
+	_EGL_DEPTH_SIZE             = 0x3025
+	_EGL_GL_COLORSPACE_KHR      = 0x309d
+	_EGL_GL_COLORSPACE_SRGB_KHR = 0x3089
+	_EGL_GREEN_SIZE             = 0x3023
+	_EGL_EXTENSIONS             = 0x3055
+	_EGL_NATIVE_VISUAL_ID       = 0x302e
+	_EGL_NONE                   = 0x3038
+	_EGL_OPENGL_ES2_BIT         = 0x4
+	_EGL_RED_SIZE               = 0x3024
+	_EGL_RENDERABLE_TYPE        = 0x3040
+	_EGL_SURFACE_TYPE           = 0x3033
+	_EGL_WINDOW_BIT             = 0x4
+)
+
+func (c *context) Release() {
+	if c.srgbFBO != nil {
+		c.srgbFBO.Release()
+		c.srgbFBO = nil
+	}
+	if c.eglSurf != nilEGLSurface {
+		eglMakeCurrent(c.eglCtx.disp, nilEGLSurface, nilEGLSurface, nilEGLContext)
+		eglDestroySurface(c.eglCtx.disp, c.eglSurf)
+		c.eglSurf = nilEGLSurface
+	}
+	c.eglWin = nilEGLNativeWindowType
+	if c.eglCtx != nil {
+		eglDestroyContext(c.eglCtx.disp, c.eglCtx.ctx)
+		eglTerminate(c.eglCtx.disp)
+		eglReleaseThread()
+		c.eglCtx = nil
+	}
+	if c.driver != nil {
+		c.driver.eglDestroy()
+		c.driver = nil
+	}
+}
+
+func (c *context) Present() error {
+	if c.eglWin == nilEGLNativeWindowType {
+		panic("context is not active")
+	}
+	if c.srgbFBO != nil {
+		c.srgbFBO.Blit()
+	}
+	if !eglSwapBuffers(c.eglCtx.disp, c.eglSurf) {
+		return fmt.Errorf("eglSwapBuffers failed (%x)", eglGetError())
+	}
+	if c.srgbFBO != nil {
+		c.srgbFBO.AfterPresent()
+	}
+	return nil
+}
+
+func newContext(d eglDriver) (*context, error) {
+	eglCtx, err := createContext(d.eglDisplay())
+	if err != nil {
+		return nil, err
+	}
+	c := &context{
+		driver: d,
+		eglCtx: eglCtx,
+		c:      new(gl.Functions),
+	}
+	return c, nil
+}
+
+func (c *context) Functions() *gl.Functions {
+	return c.c
+}
+
+func (c *context) Lock() {}
+
+func (c *context) Unlock() {}
+
+func (c *context) MakeCurrent() error {
+	win, width, height, err := c.driver.eglWindow(int(c.eglCtx.visualID))
+	if err != nil {
+		return err
+	}
+	if c.eglWin == win && width == c.width && height == c.height {
+		return nil
+	}
+	if win == nilEGLNativeWindowType {
+		if c.srgbFBO != nil {
+			c.srgbFBO.Release()
+			c.srgbFBO = nil
+		}
+	}
+	if c.eglSurf != nilEGLSurface {
+		// Make sure any in-flight GL commands are complete.
+		c.c.Finish()
+		eglMakeCurrent(c.eglCtx.disp, nilEGLSurface, nilEGLSurface, nilEGLContext)
+		eglDestroySurface(c.eglCtx.disp, c.eglSurf)
+		c.eglSurf = nilEGLSurface
+	}
+	c.width, c.height = width, height
+	c.eglWin = win
+	if c.eglWin == nilEGLNativeWindowType {
+		return nil
+	}
+	eglSurf, err := createSurfaceAndMakeCurrent(c.eglCtx, win)
+	c.eglSurf = eglSurf
+	if err != nil {
+		c.eglWin = nilEGLNativeWindowType
+		return err
+	}
+	if c.eglCtx.srgb {
+		return nil
+	}
+	if c.srgbFBO == nil {
+		var err error
+		c.srgbFBO, err = gl.NewSRGBFBO(c.c)
+		if err != nil {
+			c.Release()
+			return err
+		}
+	}
+	if err := c.srgbFBO.Refresh(c.width, c.height); err != nil {
+		c.Release()
+		return err
+	}
+	return nil
+}
+
+func hasExtension(exts []string, ext string) bool {
+	for _, e := range exts {
+		if ext == e {
+			return true
+		}
+	}
+	return false
+}
+
+func createContext(disp _EGLNativeDisplayType) (*eglContext, error) {
+	eglDisp := eglGetDisplay(disp)
+	if eglDisp == 0 {
+		return nil, fmt.Errorf("eglGetDisplay(_EGL_DEFAULT_DISPLAY) failed: 0x%x", eglGetError())
+	}
+	major, minor, ret := eglInitialize(eglDisp)
+	if !ret {
+		return nil, fmt.Errorf("eglInitialize failed: 0x%x", eglGetError())
+	}
+	// sRGB framebuffer support on EGL 1.5 or if EGL_KHR_gl_colorspace is supported.
+	exts := strings.Split(eglQueryString(eglDisp, _EGL_EXTENSIONS), " ")
+	srgb := major > 1 || minor >= 5 || hasExtension(exts, "EGL_KHR_gl_colorspace")
+	attribs := []_EGLint{
+		_EGL_RENDERABLE_TYPE, _EGL_OPENGL_ES2_BIT,
+		_EGL_SURFACE_TYPE, _EGL_WINDOW_BIT,
+		_EGL_BLUE_SIZE, 8,
+		_EGL_GREEN_SIZE, 8,
+		_EGL_RED_SIZE, 8,
+		_EGL_CONFIG_CAVEAT, _EGL_NONE,
+	}
+	if srgb {
+		if runtime.GOOS == "linux" {
+			// Some Mesa drivers crash if an sRGB framebuffer is requested without alpha.
+			// https://bugs.freedesktop.org/show_bug.cgi?id=107782.
+			attribs = append(attribs, _EGL_ALPHA_SIZE, 1)
+		}
+		// Only request a depth buffer if we're going to render directly to the framebuffer.
+		attribs = append(attribs, _EGL_DEPTH_SIZE, 16)
+	}
+	attribs = append(attribs, _EGL_NONE)
+	eglCfg, ret := eglChooseConfig(eglDisp, attribs)
+	if !ret {
+		return nil, fmt.Errorf("eglChooseConfig failed: 0x%x", eglGetError())
+	}
+	if eglCfg == nilEGLConfig {
+		return nil, errors.New("eglChooseConfig returned 0 configs")
+	}
+	var eglCtx _EGLContext
+	ctxAttribs := []_EGLint{
+		_EGL_CONTEXT_CLIENT_VERSION, 3,
+		_EGL_NONE,
+	}
+	eglCtx = eglCreateContext(eglDisp, eglCfg, nilEGLContext, ctxAttribs)
+	if eglCtx == nilEGLContext {
+		return nil, fmt.Errorf("eglCreateContext failed: 0x%x", eglGetError())
+	}
+	visID, ret := eglGetConfigAttrib(eglDisp, eglCfg, _EGL_NATIVE_VISUAL_ID)
+	if !ret {
+		return nil, errors.New("newContext: eglGetConfigAttrib for _EGL_NATIVE_VISUAL_ID failed")
+	}
+	return &eglContext{
+		disp:     eglDisp,
+		config:   _EGLConfig(eglCfg),
+		ctx:      _EGLContext(eglCtx),
+		visualID: int(visID),
+		srgb:     srgb,
+	}, nil
+}
+
+func createSurfaceAndMakeCurrent(eglCtx *eglContext, win _EGLNativeWindowType) (_EGLSurface, error) {
+	var surfAttribs []_EGLint
+	if eglCtx.srgb {
+		surfAttribs = append(surfAttribs, _EGL_GL_COLORSPACE_KHR, _EGL_GL_COLORSPACE_SRGB_KHR)
+	}
+	surfAttribs = append(surfAttribs, _EGL_NONE)
+	eglSurf := eglCreateWindowSurface(eglCtx.disp, eglCtx.config, win, surfAttribs)
+	if eglSurf == nilEGLSurface && eglCtx.srgb {
+		// Try again without sRGB
+		eglCtx.srgb = false
+		surfAttribs = []_EGLint{_EGL_NONE}
+		eglSurf = eglCreateWindowSurface(eglCtx.disp, eglCtx.config, win, surfAttribs)
+	}
+	if eglSurf == nilEGLSurface {
+		return nilEGLSurface, fmt.Errorf("newContext: eglCreateWindowSurface failed 0x%x (sRGB=%v)", eglGetError(), eglCtx.srgb)
+	}
+	if !eglMakeCurrent(eglCtx.disp, eglSurf, eglSurf, eglCtx.ctx) {
+		eglDestroySurface(eglCtx.disp, eglSurf)
+		return nilEGLSurface, fmt.Errorf("eglMakeCurrent error 0x%x", eglGetError())
+	}
+	// eglSwapInterval 1 leads to erratic frame rates and unnecessary blocking.
+	// We rely on platform specific frame rate limiting instead, except on Windows
+	// where eglSwapInterval is all there is.
+	if runtime.GOOS != "windows" {
+		eglSwapInterval(eglCtx.disp, 0)
+	} else {
+		eglSwapInterval(eglCtx.disp, 1)
+	}
+	return eglSurf, nil
+}

app/internal/window/egl_android.go

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package window
+
+/*
+#include <EGL/egl.h>
+*/
+import "C"
+
+func (w *window) eglDestroy() {
+}
+
+func (w *window) eglDisplay() _EGLNativeDisplayType {
+	return nil
+}
+
+func (w *window) eglWindow(visID int) (_EGLNativeWindowType, int, int, error) {
+	win, width, height := w.nativeWindow(visID)
+	return _EGLNativeWindowType(win), width, height, nil
+}

app/internal/window/egl_linux.go

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package window
+
+/*
+#cgo LDFLAGS: -lEGL
+#cgo CFLAGS: -DMESA_EGL_NO_X11_HEADERS
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <GLES3/gl3.h>
+*/
+import "C"
+
+import "gioui.org/app/internal/gl"
+
+type (
+	_EGLint               = C.EGLint
+	_EGLDisplay           = C.EGLDisplay
+	_EGLConfig            = C.EGLConfig
+	_EGLContext           = C.EGLContext
+	_EGLSurface           = C.EGLSurface
+	_EGLNativeDisplayType = C.EGLNativeDisplayType
+	_EGLNativeWindowType  = C.EGLNativeWindowType
+)
+
+func eglChooseConfig(disp _EGLDisplay, attribs []_EGLint) (_EGLConfig, bool) {
+	var cfg C.EGLConfig
+	var ncfg C.EGLint
+	if C.eglChooseConfig(disp, &attribs[0], &cfg, 1, &ncfg) != C.EGL_TRUE {
+		return nil, false
+	}
+	return _EGLConfig(cfg), true
+}
+
+func eglCreateContext(disp _EGLDisplay, cfg _EGLConfig, shareCtx _EGLContext, attribs []_EGLint) _EGLContext {
+	ctx := C.eglCreateContext(disp, cfg, shareCtx, &attribs[0])
+	return _EGLContext(ctx)
+}
+
+func eglDestroySurface(disp _EGLDisplay, surf _EGLSurface) bool {
+	return C.eglDestroySurface(disp, surf) == C.EGL_TRUE
+}
+
+func eglDestroyContext(disp _EGLDisplay, ctx _EGLContext) bool {
+	return C.eglDestroyContext(disp, ctx) == C.EGL_TRUE
+}
+
+func eglGetConfigAttrib(disp _EGLDisplay, cfg _EGLConfig, attr _EGLint) (_EGLint, bool) {
+	var val _EGLint
+	ret := C.eglGetConfigAttrib(disp, cfg, attr, &val)
+	return val, ret == C.EGL_TRUE
+}
+
+func eglGetError() _EGLint {
+	return C.eglGetError()
+}
+
+func eglInitialize(disp _EGLDisplay) (_EGLint, _EGLint, bool) {
+	var maj, min _EGLint
+	ret := C.eglInitialize(disp, &maj, &min)
+	return maj, min, ret == C.EGL_TRUE
+}
+
+func eglMakeCurrent(disp _EGLDisplay, draw, read _EGLSurface, ctx _EGLContext) bool {
+	return C.eglMakeCurrent(disp, draw, read, ctx) == C.EGL_TRUE
+}
+
+func eglReleaseThread() bool {
+	return C.eglReleaseThread() == C.EGL_TRUE
+}
+
+func eglSwapBuffers(disp _EGLDisplay, surf _EGLSurface) bool {
+	return C.eglSwapBuffers(disp, surf) == C.EGL_TRUE
+}
+
+func eglSwapInterval(disp _EGLDisplay, interval _EGLint) bool {
+	return C.eglSwapInterval(disp, interval) == C.EGL_TRUE
+}
+
+func eglTerminate(disp _EGLDisplay) bool {
+	return C.eglTerminate(disp) == C.EGL_TRUE
+}
+
+func eglQueryString(disp _EGLDisplay, name _EGLint) string {
+	return C.GoString(C.eglQueryString(disp, name))
+}
+
+func eglGetDisplay(disp _EGLNativeDisplayType) _EGLDisplay {
+	return C.eglGetDisplay(disp)
+}
+
+func eglCreateWindowSurface(disp _EGLDisplay, conf _EGLConfig, win _EGLNativeWindowType, attribs []_EGLint) _EGLSurface {
+	eglSurf := C.eglCreateWindowSurface(disp, conf, win, &attribs[0])
+	return eglSurf
+}
+
+func (w *window) NewContext() (gl.Context, error) {
+	return newContext(w)
+}

app/internal/window/egl_wayland.go

@@ -0,0 +1,64 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build linux,!android
+
+package window
+
+import (
+	"errors"
+	"sync"
+	"unsafe"
+)
+
+/*
+#cgo LDFLAGS: -lwayland-egl
+
+#include <EGL/egl.h>
+#include <wayland-client.h>
+#include <wayland-egl.h>
+*/
+import "C"
+
+var eglWindows struct {
+	mu      sync.Mutex
+	windows map[*C.struct_wl_surface]*C.struct_wl_egl_window
+}
+
+func (w *window) eglDestroy() {
+	surf, _, _ := w.surface()
+	if surf == nil {
+		return
+	}
+	eglWindows.mu.Lock()
+	defer eglWindows.mu.Unlock()
+	if eglWin, ok := eglWindows.windows[surf]; ok {
+		C.wl_egl_window_destroy(eglWin)
+		delete(eglWindows.windows, surf)
+	}
+}
+
+func (w *window) eglDisplay() _EGLNativeDisplayType {
+	return _EGLNativeDisplayType(w.display())
+}
+
+func (w *window) eglWindow(visID int) (_EGLNativeWindowType, int, int, error) {
+	surf, width, height := w.surface()
+	if surf == nil {
+		return nilEGLNativeWindowType, 0, 0, errors.New("wayland: no surface")
+	}
+	eglWindows.mu.Lock()
+	defer eglWindows.mu.Unlock()
+	eglWin, ok := eglWindows.windows[surf]
+	if !ok {
+		if eglWindows.windows == nil {
+			eglWindows.windows = make(map[*C.struct_wl_surface]*C.struct_wl_egl_window)
+		}
+		eglWin = C.wl_egl_window_create(surf, C.int(width), C.int(height))
+		if eglWin == nil {
+			return nilEGLNativeWindowType, 0, 0, errors.New("wayland: wl_egl_create_window failed")
+		}
+		eglWindows.windows[surf] = eglWin
+	}
+	C.wl_egl_window_resize(eglWin, C.int(width), C.int(height), 0, 0)
+	return _EGLNativeWindowType(uintptr(unsafe.Pointer(eglWin))), width, height, nil
+}

app/internal/window/egl_windows.go

@@ -0,0 +1,160 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package window
+
+import (
+	"os"
+	"unsafe"
+
+	syscall "golang.org/x/sys/windows"
+
+	"gioui.org/app/internal/gl"
+)
+
+type (
+	_EGLint               int32
+	_EGLDisplay           uintptr
+	_EGLConfig            uintptr
+	_EGLContext           uintptr
+	_EGLSurface           uintptr
+	_EGLNativeDisplayType uintptr
+	_EGLNativeWindowType  uintptr
+)
+
+var (
+	libEGL                  = syscall.NewLazyDLL("libEGL.dll")
+	_eglChooseConfig        = libEGL.NewProc("eglChooseConfig")
+	_eglCreateContext       = libEGL.NewProc("eglCreateContext")
+	_eglCreateWindowSurface = libEGL.NewProc("eglCreateWindowSurface")
+	_eglDestroyContext      = libEGL.NewProc("eglDestroyContext")
+	_eglDestroySurface      = libEGL.NewProc("eglDestroySurface")
+	_eglGetConfigAttrib     = libEGL.NewProc("eglGetConfigAttrib")
+	_eglGetDisplay          = libEGL.NewProc("eglGetDisplay")
+	_eglGetError            = libEGL.NewProc("eglGetError")
+	_eglInitialize          = libEGL.NewProc("eglInitialize")
+	_eglMakeCurrent         = libEGL.NewProc("eglMakeCurrent")
+	_eglReleaseThread       = libEGL.NewProc("eglReleaseThread")
+	_eglSwapInterval        = libEGL.NewProc("eglSwapInterval")
+	_eglSwapBuffers         = libEGL.NewProc("eglSwapBuffers")
+	_eglTerminate           = libEGL.NewProc("eglTerminate")
+	_eglQueryString         = libEGL.NewProc("eglQueryString")
+)
+
+func init() {
+	mustLoadDLL(libEGL, "libEGL.dll")
+	mustLoadDLL(gl.LibGLESv2, "libGLESv2.dll")
+	// d3dcompiler_47.dll is needed internally for shader compilation to function.
+	mustLoadDLL(syscall.NewLazyDLL("d3dcompiler_47.dll"), "d3dcompiler_47.dll")
+}
+
+func mustLoadDLL(dll *syscall.LazyDLL, name string) {
+	loadErr := dll.Load()
+	if loadErr == nil {
+		return
+	}
+	pmsg := syscall.StringToUTF16Ptr("Failed to load " + name)
+	ptitle := syscall.StringToUTF16Ptr("Error")
+	syscall.MessageBox(0 /* HWND */, pmsg, ptitle, syscall.MB_ICONERROR|syscall.MB_SYSTEMMODAL)
+	os.Exit(1)
+}
+
+func eglChooseConfig(disp _EGLDisplay, attribs []_EGLint) (_EGLConfig, bool) {
+	var cfg _EGLConfig
+	var ncfg _EGLint
+	a := &attribs[0]
+	r, _, _ := _eglChooseConfig.Call(uintptr(disp), uintptr(unsafe.Pointer(a)), uintptr(unsafe.Pointer(&cfg)), 1, uintptr(unsafe.Pointer(&ncfg)))
+	issue34474KeepAlive(a)
+	return cfg, r != 0
+}
+
+func eglCreateContext(disp _EGLDisplay, cfg _EGLConfig, shareCtx _EGLContext, attribs []_EGLint) _EGLContext {
+	a := &attribs[0]
+	c, _, _ := _eglCreateContext.Call(uintptr(disp), uintptr(cfg), uintptr(shareCtx), uintptr(unsafe.Pointer(a)))
+	issue34474KeepAlive(a)
+	return _EGLContext(c)
+}
+
+func eglCreateWindowSurface(disp _EGLDisplay, cfg _EGLConfig, win _EGLNativeWindowType, attribs []_EGLint) _EGLSurface {
+	a := &attribs[0]
+	s, _, _ := _eglCreateWindowSurface.Call(uintptr(disp), uintptr(cfg), uintptr(win), uintptr(unsafe.Pointer(a)))
+	issue34474KeepAlive(a)
+	return _EGLSurface(s)
+}
+
+func eglDestroySurface(disp _EGLDisplay, surf _EGLSurface) bool {
+	r, _, _ := _eglDestroySurface.Call(uintptr(disp), uintptr(surf))
+	return r != 0
+}
+
+func eglDestroyContext(disp _EGLDisplay, ctx _EGLContext) bool {
+	r, _, _ := _eglDestroyContext.Call(uintptr(disp), uintptr(ctx))
+	return r != 0
+}
+
+func eglGetConfigAttrib(disp _EGLDisplay, cfg _EGLConfig, attr _EGLint) (_EGLint, bool) {
+	var val uintptr
+	r, _, _ := _eglGetConfigAttrib.Call(uintptr(disp), uintptr(cfg), uintptr(attr), uintptr(unsafe.Pointer(&val)))
+	return _EGLint(val), r != 0
+}
+
+func eglGetDisplay(disp _EGLNativeDisplayType) _EGLDisplay {
+	d, _, _ := _eglGetDisplay.Call(uintptr(disp))
+	return _EGLDisplay(d)
+}
+
+func eglGetError() _EGLint {
+	e, _, _ := _eglGetError.Call()
+	return _EGLint(e)
+}
+
+func eglInitialize(disp _EGLDisplay) (_EGLint, _EGLint, bool) {
+	var maj, min uintptr
+	r, _, _ := _eglInitialize.Call(uintptr(disp), uintptr(unsafe.Pointer(&maj)), uintptr(unsafe.Pointer(&min)))
+	return _EGLint(maj), _EGLint(min), r != 0
+}
+
+func eglMakeCurrent(disp _EGLDisplay, draw, read _EGLSurface, ctx _EGLContext) bool {
+	r, _, _ := _eglMakeCurrent.Call(uintptr(disp), uintptr(draw), uintptr(read), uintptr(ctx))
+	return r != 0
+}
+
+func eglReleaseThread() bool {
+	r, _, _ := _eglReleaseThread.Call()
+	return r != 0
+}
+
+func eglSwapInterval(disp _EGLDisplay, interval _EGLint) bool {
+	r, _, _ := _eglSwapInterval.Call(uintptr(disp), uintptr(interval))
+	return r != 0
+}
+
+func eglSwapBuffers(disp _EGLDisplay, surf _EGLSurface) bool {
+	r, _, _ := _eglSwapBuffers.Call(uintptr(disp), uintptr(surf))
+	return r != 0
+}
+
+func eglTerminate(disp _EGLDisplay) bool {
+	r, _, _ := _eglTerminate.Call(uintptr(disp))
+	return r != 0
+}
+
+func eglQueryString(disp _EGLDisplay, name _EGLint) string {
+	r, _, _ := _eglQueryString.Call(uintptr(disp), uintptr(name))
+	return gl.GoString(gl.SliceOf(r))
+}
+
+func (w *window) eglDestroy() {
+}
+
+func (w *window) eglDisplay() _EGLNativeDisplayType {
+	return _EGLNativeDisplayType(w.HDC())
+}
+
+func (w *window) eglWindow(visID int) (_EGLNativeWindowType, int, int, error) {
+	hwnd, width, height := w.HWND()
+	return _EGLNativeWindowType(hwnd), width, height, nil
+}
+
+func (w *window) NewContext() (gl.Context, error) {
+	return newContext(w)
+}

app/internal/window/framework_ios.h

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+@import UIKit;
+
+@interface GioAppDelegate : UIResponder <UIApplicationDelegate>
+@property (strong, nonatomic) UIWindow *window;
+@end
+

app/internal/window/gl_ios.go

@@ -0,0 +1,128 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build darwin,ios
+
+package window
+
+/*
+#cgo CFLAGS: -fmodules -fobjc-arc -x objective-c
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <OpenGLES/ES2/gl.h>
+#include <OpenGLES/ES2/glext.h>
+#include "gl_ios.h"
+*/
+import "C"
+
+import (
+	"errors"
+	"fmt"
+
+	"gioui.org/app/internal/gl"
+)
+
+type context struct {
+	owner                    *window
+	c                        *gl.Functions
+	ctx                      C.CFTypeRef
+	layer                    C.CFTypeRef
+	init                     bool
+	frameBuffer              gl.Framebuffer
+	colorBuffer, depthBuffer gl.Renderbuffer
+}
+
+func init() {
+	layerFactory = func() uintptr {
+		return uintptr(C.gio_createGLLayer())
+	}
+}
+
+func newContext(w *window) (*context, error) {
+	ctx := C.gio_createContext()
+	if ctx == 0 {
+		return nil, fmt.Errorf("failed to create EAGLContext")
+	}
+	c := &context{
+		ctx:   ctx,
+		owner: w,
+		layer: C.CFTypeRef(w.contextLayer()),
+		c:     new(gl.Functions),
+	}
+	return c, nil
+}
+
+func (c *context) Functions() *gl.Functions {
+	return c.c
+}
+
+func (c *context) Release() {
+	if c.ctx == 0 {
+		return
+	}
+	C.gio_renderbufferStorage(c.ctx, 0, C.GLenum(gl.RENDERBUFFER))
+	c.c.DeleteFramebuffer(c.frameBuffer)
+	c.c.DeleteRenderbuffer(c.colorBuffer)
+	c.c.DeleteRenderbuffer(c.depthBuffer)
+	C.gio_makeCurrent(0)
+	C.CFRelease(c.ctx)
+	c.ctx = 0
+}
+
+func (c *context) Present() error {
+	if c.layer == 0 {
+		panic("context is not active")
+	}
+	// Discard depth buffer as recommended in
+	// https://developer.apple.com/library/archive/documentation/3DDrawing/Conceptual/OpenGLES_ProgrammingGuide/WorkingwithEAGLContexts/WorkingwithEAGLContexts.html
+	c.c.BindFramebuffer(gl.FRAMEBUFFER, c.frameBuffer)
+	c.c.InvalidateFramebuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT)
+	c.c.BindRenderbuffer(gl.RENDERBUFFER, c.colorBuffer)
+	if C.gio_presentRenderbuffer(c.ctx, C.GLenum(gl.RENDERBUFFER)) == 0 {
+		return errors.New("presentRenderBuffer failed")
+	}
+	return nil
+}
+
+func (c *context) Lock() {}
+
+func (c *context) Unlock() {}
+
+func (c *context) MakeCurrent() error {
+	if C.gio_makeCurrent(c.ctx) == 0 {
+		C.CFRelease(c.ctx)
+		c.ctx = 0
+		return errors.New("[EAGLContext setCurrentContext] failed")
+	}
+	if !c.init {
+		c.init = true
+		c.frameBuffer = c.c.CreateFramebuffer()
+		c.colorBuffer = c.c.CreateRenderbuffer()
+		c.depthBuffer = c.c.CreateRenderbuffer()
+	}
+	if !c.owner.isVisible() {
+		// Make sure any in-flight GL commands are complete.
+		c.c.Finish()
+		return nil
+	}
+	currentRB := gl.Renderbuffer{uint(c.c.GetInteger(gl.RENDERBUFFER_BINDING))}
+	c.c.BindRenderbuffer(gl.RENDERBUFFER, c.colorBuffer)
+	if C.gio_renderbufferStorage(c.ctx, c.layer, C.GLenum(gl.RENDERBUFFER)) == 0 {
+		return errors.New("renderbufferStorage failed")
+	}
+	w := c.c.GetRenderbufferParameteri(gl.RENDERBUFFER, gl.RENDERBUFFER_WIDTH)
+	h := c.c.GetRenderbufferParameteri(gl.RENDERBUFFER, gl.RENDERBUFFER_HEIGHT)
+	c.c.BindRenderbuffer(gl.RENDERBUFFER, c.depthBuffer)
+	c.c.RenderbufferStorage(gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, w, h)
+	c.c.BindRenderbuffer(gl.RENDERBUFFER, currentRB)
+	c.c.BindFramebuffer(gl.FRAMEBUFFER, c.frameBuffer)
+	c.c.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.RENDERBUFFER, c.colorBuffer)
+	c.c.FramebufferRenderbuffer(gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, c.depthBuffer)
+	if st := c.c.CheckFramebufferStatus(gl.FRAMEBUFFER); st != gl.FRAMEBUFFER_COMPLETE {
+		return fmt.Errorf("framebuffer incomplete, status: %#x\n", st)
+	}
+	return nil
+}
+
+func (w *window) NewContext() (gl.Context, error) {
+	return newContext(w)
+}

app/internal/window/gl_ios.h

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+__attribute__ ((visibility ("hidden"))) int gio_renderbufferStorage(CFTypeRef ctx, CFTypeRef layer, GLenum buffer);
+__attribute__ ((visibility ("hidden"))) int gio_presentRenderbuffer(CFTypeRef ctx, GLenum buffer);
+__attribute__ ((visibility ("hidden"))) int gio_makeCurrent(CFTypeRef ctx);
+__attribute__ ((visibility ("hidden"))) CFTypeRef gio_createContext(void);
+__attribute__ ((visibility ("hidden"))) CFTypeRef gio_createGLLayer(void);

app/internal/window/gl_ios.m

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build darwin,ios
+
+@import UIKit;
+@import OpenGLES;
+
+#include "gl_ios.h"
+
+int gio_renderbufferStorage(CFTypeRef ctxRef, CFTypeRef layerRef, GLenum buffer) {
+	EAGLContext *ctx = (__bridge EAGLContext *)ctxRef;
+	CAEAGLLayer *layer = (__bridge CAEAGLLayer *)layerRef;
+	return (int)[ctx renderbufferStorage:buffer fromDrawable:layer];
+}
+
+int gio_presentRenderbuffer(CFTypeRef ctxRef, GLenum buffer) {
+	EAGLContext *ctx = (__bridge EAGLContext *)ctxRef;
+	return (int)[ctx presentRenderbuffer:buffer];
+}
+
+int gio_makeCurrent(CFTypeRef ctxRef) {
+	EAGLContext *ctx = (__bridge EAGLContext *)ctxRef;
+	return (int)[EAGLContext setCurrentContext:ctx];
+}
+
+CFTypeRef gio_createContext(void) {
+	EAGLContext *ctx = [[EAGLContext alloc] initWithAPI:kEAGLRenderingAPIOpenGLES3];
+	if (ctx == nil) {
+		return nil;
+	}
+	return CFBridgingRetain(ctx);
+}
+
+CFTypeRef gio_createGLLayer(void) {
+	CAEAGLLayer *layer = [[CAEAGLLayer layer] init];
+	if (layer == nil) {
+		return nil;
+	}
+	layer.drawableProperties = @{kEAGLDrawablePropertyColorFormat: kEAGLColorFormatSRGBA8};
+	layer.opaque = YES;
+	layer.anchorPoint = CGPointMake(0, 0);
+	return CFBridgingRetain(layer);
+}

app/internal/window/gl_js.go

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package window
+
+import (
+	"errors"
+	"syscall/js"
+
+	"gioui.org/app/internal/gl"
+)
+
+type context struct {
+	ctx     js.Value
+	cnv     js.Value
+	f       *gl.Functions
+	srgbFBO *gl.SRGBFBO
+}
+
+func newContext(w *window) (*context, error) {
+	args := map[string]interface{}{
+		// Enable low latency rendering.
+		// See https://developers.google.com/web/updates/2019/05/desynchronized.
+		"desynchronized":        true,
+		"preserveDrawingBuffer": true,
+	}
+	version := 2
+	ctx := w.cnv.Call("getContext", "webgl2", args)
+	if ctx == js.Null() {
+		version = 1
+		ctx = w.cnv.Call("getContext", "webgl", args)
+	}
+	if ctx == js.Null() {
+		return nil, errors.New("app: webgl is not supported")
+	}
+	f := &gl.Functions{Ctx: ctx}
+	if err := f.Init(version); err != nil {
+		return nil, err
+	}
+	c := &context{
+		ctx: ctx,
+		cnv: w.cnv,
+		f:   f,
+	}
+	return c, nil
+}
+
+func (c *context) Functions() *gl.Functions {
+	return c.f
+}
+
+func (c *context) Release() {
+	if c.srgbFBO != nil {
+		c.srgbFBO.Release()
+		c.srgbFBO = nil
+	}
+}
+
+func (c *context) Present() error {
+	if c.srgbFBO != nil {
+		c.srgbFBO.Blit()
+	}
+	if c.srgbFBO != nil {
+		c.srgbFBO.AfterPresent()
+	}
+	if c.ctx.Call("isContextLost").Bool() {
+		return errors.New("context lost")
+	}
+	return nil
+}
+
+func (c *context) Lock() {}
+
+func (c *context) Unlock() {}
+
+func (c *context) MakeCurrent() error {
+	if c.srgbFBO == nil {
+		var err error
+		c.srgbFBO, err = gl.NewSRGBFBO(c.f)
+		if err != nil {
+			c.Release()
+			c.srgbFBO = nil
+			return err
+		}
+	}
+	w, h := c.cnv.Get("width").Int(), c.cnv.Get("height").Int()
+	if err := c.srgbFBO.Refresh(w, h); err != nil {
+		c.Release()
+		return err
+	}
+	return nil
+}
+
+func (w *window) NewContext() (gl.Context, error) {
+	return newContext(w)
+}

app/internal/window/gl_macos.go

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build darwin,!ios
+
+package window
+
+import (
+	"gioui.org/app/internal/gl"
+)
+
+/*
+#cgo CFLAGS: -DGL_SILENCE_DEPRECATION -fmodules -fobjc-arc -x objective-c
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <CoreGraphics/CoreGraphics.h>
+#include <AppKit/AppKit.h>
+#include <OpenGL/gl3.h>
+#include "gl_macos.h"
+*/
+import "C"
+
+type context struct {
+	c    *gl.Functions
+	ctx  C.CFTypeRef
+	view C.CFTypeRef
+}
+
+func init() {
+	viewFactory = func() C.CFTypeRef {
+		return C.gio_createGLView()
+	}
+}
+
+func newContext(w *window) (*context, error) {
+	view := w.contextView()
+	ctx := C.gio_contextForView(view)
+	c := &context{
+		ctx:  ctx,
+		c:    new(gl.Functions),
+		view: view,
+	}
+	return c, nil
+}
+
+func (c *context) Functions() *gl.Functions {
+	return c.c
+}
+
+func (c *context) Release() {
+	c.Lock()
+	defer c.Unlock()
+	C.gio_clearCurrentContext()
+}
+
+func (c *context) Present() error {
+	// Assume the caller already locked the context.
+	C.glFlush()
+	return nil
+}
+
+func (c *context) Lock() {
+	C.gio_lockContext(c.ctx)
+}
+
+func (c *context) Unlock() {
+	C.gio_unlockContext(c.ctx)
+}
+
+func (c *context) MakeCurrent() error {
+	c.Lock()
+	defer c.Unlock()
+	C.gio_makeCurrentContext(c.ctx)
+	return nil
+}
+
+func (w *window) NewContext() (gl.Context, error) {
+	return newContext(w)
+}

app/internal/window/gl_macos.h

@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+__attribute__ ((visibility ("hidden"))) CFTypeRef gio_createGLView(void);
+__attribute__ ((visibility ("hidden"))) CFTypeRef gio_contextForView(CFTypeRef viewRef);
+__attribute__ ((visibility ("hidden"))) void gio_makeCurrentContext(CFTypeRef ctx);
+__attribute__ ((visibility ("hidden"))) void gio_flushContextBuffer(CFTypeRef ctx);
+__attribute__ ((visibility ("hidden"))) void gio_clearCurrentContext(void);
+__attribute__ ((visibility ("hidden"))) void gio_lockContext(CFTypeRef ctxRef);
+__attribute__ ((visibility ("hidden"))) void gio_unlockContext(CFTypeRef ctxRef);

app/internal/window/gl_macos.m

@@ -0,0 +1,166 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build darwin,!ios
+
+@import AppKit;
+
+#include <CoreFoundation/CoreFoundation.h>
+#include <OpenGL/OpenGL.h>
+#include <OpenGL/gl3.h>
+#include "os_macos.h"
+#include "gl_macos.h"
+#include "_cgo_export.h"
+
+static void handleMouse(NSView *view, NSEvent *event, int typ, CGFloat dx, CGFloat dy) {
+	NSPoint p = [view convertPoint:[event locationInWindow] fromView:nil];
+	if (!event.hasPreciseScrollingDeltas) {
+		// dx and dy are in rows and columns.
+		dx *= 10;
+		dy *= 10;
+	}
+	gio_onMouse((__bridge CFTypeRef)view, typ, p.x, p.y, dx, dy, [event timestamp]);
+}
+
+static CVReturn displayLinkCallback(CVDisplayLinkRef displayLink, const CVTimeStamp *inNow, const CVTimeStamp *inOutputTime, CVOptionFlags flagsIn, CVOptionFlags *flagsOut, void *displayLinkContext) {
+	CFTypeRef view = (CFTypeRef *)displayLinkContext;
+	gio_onFrameCallback(view);
+	return kCVReturnSuccess;
+}
+
+@interface GioView : NSOpenGLView 
+@end
+
+@implementation GioView {
+CVDisplayLinkRef displayLink;
+}
+- (instancetype)initWithFrame:(NSRect)frameRect
+				  pixelFormat:(NSOpenGLPixelFormat *)format {
+	self = [super initWithFrame:frameRect pixelFormat:format];
+	if (self) {
+		CVDisplayLinkCreateWithActiveCGDisplays(&displayLink);
+		CVDisplayLinkSetOutputCallback(displayLink, displayLinkCallback, (__bridge void*)self);
+	}
+	return self;
+}
+- (void)dealloc {
+	CVDisplayLinkRelease(displayLink);
+}
+- (void)setAnimating:(BOOL)anim {
+	if (anim) {
+		CVDisplayLinkStart(displayLink);
+	} else {
+		CVDisplayLinkStop(displayLink);
+	}
+}
+- (void)updateDisplay:(CGDirectDisplayID)dispID {
+	CVDisplayLinkSetCurrentCGDisplay(displayLink, dispID);
+}
+- (void)prepareOpenGL {
+	[super prepareOpenGL];
+	// Bind a default VBA to emulate OpenGL ES 2.
+	GLuint defVBA;
+	glGenVertexArrays(1, &defVBA);
+	glBindVertexArray(defVBA);
+	glEnable(GL_FRAMEBUFFER_SRGB);
+}
+- (BOOL)isFlipped {
+	return YES;
+}
+- (void)update {
+	[super update];
+	[self setNeedsDisplay:YES];
+}
+- (void)drawRect:(NSRect)r {
+	gio_onDraw((__bridge CFTypeRef)self);
+}
+- (void)mouseDown:(NSEvent *)event {
+	handleMouse(self, event, GIO_MOUSE_DOWN, 0, 0);
+}
+- (void)mouseUp:(NSEvent *)event {
+	handleMouse(self, event, GIO_MOUSE_UP, 0, 0);
+}
+- (void)mouseMoved:(NSEvent *)event {
+	handleMouse(self, event, GIO_MOUSE_MOVE, 0, 0);
+}
+- (void)mouseDragged:(NSEvent *)event {
+	handleMouse(self, event, GIO_MOUSE_MOVE, 0, 0);
+}
+- (void)scrollWheel:(NSEvent *)event {
+	CGFloat dx = -event.scrollingDeltaX;
+	CGFloat dy = -event.scrollingDeltaY;
+	handleMouse(self, event, GIO_MOUSE_MOVE, dx, dy);
+}
+- (void)keyDown:(NSEvent *)event {
+	NSString *keys = [event charactersIgnoringModifiers];
+	gio_onKeys((__bridge CFTypeRef)self, (char *)[keys UTF8String], [event timestamp], [event modifierFlags]);
+	[self interpretKeyEvents:[NSArray arrayWithObject:event]];
+}
+- (void)insertText:(id)string {
+	const char *utf8 = [string UTF8String];
+	gio_onText((__bridge CFTypeRef)self, (char *)utf8);
+}
+- (void)doCommandBySelector:(SEL)sel {
+	// Don't pass commands up the responder chain.
+	// They will end up in a beep.
+}
+@end
+
+CFTypeRef gio_createGLView(void) {
+	@autoreleasepool {
+		NSOpenGLPixelFormatAttribute attr[] = {
+			NSOpenGLPFAOpenGLProfile, NSOpenGLProfileVersion3_2Core,
+			NSOpenGLPFAColorSize,     24,
+			NSOpenGLPFADepthSize,     16,
+			NSOpenGLPFAAccelerated,
+			// Opt-in to automatic GPU switching. CGL-only property.
+			kCGLPFASupportsAutomaticGraphicsSwitching,
+			NSOpenGLPFAAllowOfflineRenderers,
+			0
+		};
+		id pixFormat = [[NSOpenGLPixelFormat alloc] initWithAttributes:attr];
+
+		NSRect frame = NSMakeRect(0, 0, 0, 0);
+		GioView* view = [[GioView alloc] initWithFrame:frame pixelFormat:pixFormat];
+
+		[view setWantsBestResolutionOpenGLSurface:YES];
+		[view setWantsLayer:YES]; // The default in Mojave.
+
+		return CFBridgingRetain(view);
+	}
+}
+
+void gio_updateDisplayLink(CFTypeRef viewRef, CGDirectDisplayID dispID) {
+	GioView *view = (__bridge GioView *)viewRef;
+	[view updateDisplay:dispID];
+}
+
+void gio_setAnimating(CFTypeRef viewRef, BOOL anim) {
+	GioView *view = (__bridge GioView *)viewRef;
+	dispatch_async(dispatch_get_main_queue(), ^{
+		[view setAnimating:anim];
+	});
+}
+
+CFTypeRef gio_contextForView(CFTypeRef viewRef) {
+	NSOpenGLView *view = (__bridge NSOpenGLView *)viewRef;
+	return (__bridge CFTypeRef)view.openGLContext;
+}
+
+void gio_clearCurrentContext(void) {
+	[NSOpenGLContext clearCurrentContext];
+}
+
+void gio_makeCurrentContext(CFTypeRef ctxRef) {
+	NSOpenGLContext *ctx = (__bridge NSOpenGLContext *)ctxRef;
+	return [ctx makeCurrentContext];
+}
+
+void gio_lockContext(CFTypeRef ctxRef) {
+	NSOpenGLContext *ctx = (__bridge NSOpenGLContext *)ctxRef;
+	CGLLockContext([ctx CGLContextObj]);
+}
+
+void gio_unlockContext(CFTypeRef ctxRef) {
+	NSOpenGLContext *ctx = (__bridge NSOpenGLContext *)ctxRef;
+	CGLUnlockContext([ctx CGLContextObj]);
+}

app/internal/window/os_android.c

@@ -0,0 +1,168 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+#include <jni.h>
+#include <dlfcn.h>
+#include <android/log.h>
+#include "os_android.h"
+#include "_cgo_export.h"
+
+JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
+	JNIEnv *env;
+	if ((*vm)->GetEnv(vm, (void**)&env, JNI_VERSION_1_6) != JNI_OK) {
+		return -1;
+	}
+
+	setJVM(vm);
+
+	jclass viewClass = (*env)->FindClass(env, "org/gioui/GioView");
+	if (viewClass == NULL) {
+		return -1;
+	}
+
+	static const JNINativeMethod methods[] = {
+		{
+			.name = "runGoMain",
+			.signature = "([B)V",
+			.fnPtr = runGoMain
+		},
+		{
+			.name = "onCreateView",
+			.signature = "(Lorg/gioui/GioView;)J",
+			.fnPtr = onCreateView
+		},
+		{
+			.name = "onDestroyView",
+			.signature = "(J)V",
+			.fnPtr = onDestroyView
+		},
+		{
+			.name = "onStartView",
+			.signature = "(J)V",
+			.fnPtr = onStartView
+		},
+		{
+			.name = "onStopView",
+			.signature = "(J)V",
+			.fnPtr = onStopView
+		},
+		{
+			.name = "onSurfaceDestroyed",
+			.signature = "(J)V",
+			.fnPtr = onSurfaceDestroyed
+		},
+		{
+			.name = "onSurfaceChanged",
+			.signature = "(JLandroid/view/Surface;)V",
+			.fnPtr = onSurfaceChanged
+		},
+		{
+			.name = "onConfigurationChanged",
+			.signature = "(J)V",
+			.fnPtr = onConfigurationChanged
+		},
+		{
+			.name = "onWindowInsets",
+			.signature = "(JIIII)V",
+			.fnPtr = onWindowInsets
+		},
+		{
+			.name = "onLowMemory",
+			.signature = "()V",
+			.fnPtr = onLowMemory
+		},
+		{
+			.name = "onTouchEvent",
+			.signature = "(JIIIFFJ)V",
+			.fnPtr = onTouchEvent
+		},
+		{
+			.name = "onKeyEvent",
+			.signature = "(JIIJ)V",
+			.fnPtr = onKeyEvent
+		},
+		{
+			.name = "onFrameCallback",
+			.signature = "(JJ)V",
+			.fnPtr = onFrameCallback
+		},
+		{
+			.name = "onBack",
+			.signature = "(J)Z",
+			.fnPtr = onBack
+		},
+		{
+			.name = "onFocusChange",
+			.signature = "(JZ)V",
+			.fnPtr = onFocusChange
+		}
+	};
+	if ((*env)->RegisterNatives(env, viewClass, methods, sizeof(methods)/sizeof(methods[0])) != 0) {
+		return -1;
+	}
+
+	return JNI_VERSION_1_6;
+}
+
+jint gio_jni_GetEnv(JavaVM *vm, JNIEnv **env, jint version) {
+	return (*vm)->GetEnv(vm, (void **)env, version);
+}
+
+jint gio_jni_AttachCurrentThread(JavaVM *vm, JNIEnv **p_env, void *thr_args) {
+	return (*vm)->AttachCurrentThread(vm, p_env, thr_args);
+}
+
+jint gio_jni_DetachCurrentThread(JavaVM *vm) {
+	return (*vm)->DetachCurrentThread(vm);
+}
+
+jobject gio_jni_NewGlobalRef(JNIEnv *env, jobject obj) {
+	return (*env)->NewGlobalRef(env, obj);
+}
+
+void gio_jni_DeleteGlobalRef(JNIEnv *env, jobject obj) {
+	(*env)->DeleteGlobalRef(env, obj);
+}
+
+jclass gio_jni_GetObjectClass(JNIEnv *env, jobject obj) {
+	return (*env)->GetObjectClass(env, obj);
+}
+
+jmethodID gio_jni_GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig) {
+	return (*env)->GetMethodID(env, clazz, name, sig);
+}
+
+jmethodID gio_jni_GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig) {
+	return (*env)->GetStaticMethodID(env, clazz, name, sig);
+}
+
+jint gio_jni_CallStaticIntMethodII(JNIEnv *env, jclass clazz, jmethodID methodID, jint a1, jint a2) {
+	return (*env)->CallStaticIntMethod(env, clazz, methodID, a1, a2);
+}
+
+jfloat gio_jni_CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID) {
+	return (*env)->CallFloatMethod(env, obj, methodID);
+}
+
+jint gio_jni_CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID) {
+	return (*env)->CallIntMethod(env, obj, methodID);
+}
+
+void gio_jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID) {
+	(*env)->CallVoidMethod(env, obj, methodID);
+}
+
+void gio_jni_CallVoidMethod_J(JNIEnv *env, jobject obj, jmethodID methodID, jlong a1) {
+	(*env)->CallVoidMethod(env, obj, methodID, a1);
+}
+
+jbyte *gio_jni_GetByteArrayElements(JNIEnv *env, jbyteArray arr) {
+	return (*env)->GetByteArrayElements(env, arr, NULL);
+}
+
+void gio_jni_ReleaseByteArrayElements(JNIEnv *env, jbyteArray arr, jbyte *bytes) {
+	(*env)->ReleaseByteArrayElements(env, arr, bytes, JNI_ABORT);
+}
+
+jsize gio_jni_GetArrayLength(JNIEnv *env, jbyteArray arr) {
+	return (*env)->GetArrayLength(env, arr);
+}

app/internal/window/os_android.go

@@ -0,0 +1,433 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package window
+
+/*
+#cgo LDFLAGS: -landroid
+
+#include <android/native_window_jni.h>
+#include <android/configuration.h>
+#include <android/keycodes.h>
+#include <android/input.h>
+#include <stdlib.h>
+#include "os_android.h"
+*/
+import "C"
+
+import (
+	"errors"
+	"fmt"
+	"image"
+	"runtime"
+	"runtime/debug"
+	"sync"
+	"time"
+	"unsafe"
+
+	"gioui.org/f32"
+	"gioui.org/io/key"
+	"gioui.org/io/pointer"
+	"gioui.org/io/system"
+	"gioui.org/unit"
+)
+
+type window struct {
+	callbacks Callbacks
+
+	view C.jobject
+
+	dpi       int
+	fontScale float32
+	insets    system.Insets
+
+	stage   system.Stage
+	started bool
+
+	mu        sync.Mutex
+	win       *C.ANativeWindow
+	animating bool
+
+	mgetDensity                    C.jmethodID
+	mgetFontScale                  C.jmethodID
+	mshowTextInput                 C.jmethodID
+	mhideTextInput                 C.jmethodID
+	mpostFrameCallback             C.jmethodID
+	mpostFrameCallbackOnMainThread C.jmethodID
+}
+
+var dataDirChan = make(chan string, 1)
+
+var theJVM *C.JavaVM
+
+var views = make(map[C.jlong]*window)
+
+var mainWindow = newWindowRendezvous()
+
+func jniGetMethodID(env *C.JNIEnv, class C.jclass, method, sig string) C.jmethodID {
+	m := C.CString(method)
+	defer C.free(unsafe.Pointer(m))
+	s := C.CString(sig)
+	defer C.free(unsafe.Pointer(s))
+	return C.gio_jni_GetMethodID(env, class, m, s)
+}
+
+func jniGetStaticMethodID(env *C.JNIEnv, class C.jclass, method, sig string) C.jmethodID {
+	m := C.CString(method)
+	defer C.free(unsafe.Pointer(m))
+	s := C.CString(sig)
+	defer C.free(unsafe.Pointer(s))
+	return C.gio_jni_GetStaticMethodID(env, class, m, s)
+}
+
+//export runGoMain
+func runGoMain(env *C.JNIEnv, class C.jclass, jdataDir C.jbyteArray) {
+	dirBytes := C.gio_jni_GetByteArrayElements(env, jdataDir)
+	if dirBytes == nil {
+		panic("runGoMain: GetByteArrayElements failed")
+	}
+	n := C.gio_jni_GetArrayLength(env, jdataDir)
+	dataDir := C.GoStringN((*C.char)(unsafe.Pointer(dirBytes)), n)
+	dataDirChan <- dataDir
+	C.gio_jni_ReleaseByteArrayElements(env, jdataDir, dirBytes)
+	runMain()
+}
+
+func GetDataDir() string {
+	return <-dataDirChan
+}
+
+//export setJVM
+func setJVM(vm *C.JavaVM) {
+	theJVM = vm
+}
+
+//export onCreateView
+func onCreateView(env *C.JNIEnv, class C.jclass, view C.jobject) C.jlong {
+	view = C.gio_jni_NewGlobalRef(env, view)
+	w := &window{
+		view:                           view,
+		mgetDensity:                    jniGetMethodID(env, class, "getDensity", "()I"),
+		mgetFontScale:                  jniGetMethodID(env, class, "getFontScale", "()F"),
+		mshowTextInput:                 jniGetMethodID(env, class, "showTextInput", "()V"),
+		mhideTextInput:                 jniGetMethodID(env, class, "hideTextInput", "()V"),
+		mpostFrameCallback:             jniGetMethodID(env, class, "postFrameCallback", "()V"),
+		mpostFrameCallbackOnMainThread: jniGetMethodID(env, class, "postFrameCallbackOnMainThread", "()V"),
+	}
+	wopts := <-mainWindow.out
+	w.callbacks = wopts.window
+	w.callbacks.SetDriver(w)
+	handle := C.jlong(view)
+	views[handle] = w
+	w.loadConfig(env, class)
+	w.setStage(system.StagePaused)
+	return handle
+}
+
+//export onDestroyView
+func onDestroyView(env *C.JNIEnv, class C.jclass, handle C.jlong) {
+	w := views[handle]
+	w.callbacks.SetDriver(nil)
+	delete(views, handle)
+	C.gio_jni_DeleteGlobalRef(env, w.view)
+	w.view = 0
+}
+
+//export onStopView
+func onStopView(env *C.JNIEnv, class C.jclass, handle C.jlong) {
+	w := views[handle]
+	w.started = false
+	w.setStage(system.StagePaused)
+}
+
+//export onStartView
+func onStartView(env *C.JNIEnv, class C.jclass, handle C.jlong) {
+	w := views[handle]
+	w.started = true
+	if w.aNativeWindow() != nil {
+		w.setVisible()
+	}
+}
+
+//export onSurfaceDestroyed
+func onSurfaceDestroyed(env *C.JNIEnv, class C.jclass, handle C.jlong) {
+	w := views[handle]
+	w.mu.Lock()
+	w.win = nil
+	w.mu.Unlock()
+	w.setStage(system.StagePaused)
+}
+
+//export onSurfaceChanged
+func onSurfaceChanged(env *C.JNIEnv, class C.jclass, handle C.jlong, surf C.jobject) {
+	w := views[handle]
+	w.mu.Lock()
+	w.win = C.ANativeWindow_fromSurface(env, surf)
+	w.mu.Unlock()
+	if w.started {
+		w.setVisible()
+	}
+}
+
+//export onLowMemory
+func onLowMemory() {
+	runtime.GC()
+	debug.FreeOSMemory()
+}
+
+//export onConfigurationChanged
+func onConfigurationChanged(env *C.JNIEnv, class C.jclass, view C.jlong) {
+	w := views[view]
+	w.loadConfig(env, class)
+	if w.stage >= system.StageRunning {
+		w.draw(true)
+	}
+}
+
+//export onFrameCallback
+func onFrameCallback(env *C.JNIEnv, class C.jclass, view C.jlong, nanos C.jlong) {
+	w, exist := views[view]
+	if !exist {
+		return
+	}
+	if w.stage < system.StageRunning {
+		return
+	}
+	w.mu.Lock()
+	anim := w.animating
+	w.mu.Unlock()
+	if anim {
+		runInJVM(func(env *C.JNIEnv) {
+			C.gio_jni_CallVoidMethod(env, w.view, w.mpostFrameCallback)
+		})
+		w.draw(false)
+	}
+}
+
+//export onBack
+func onBack(env *C.JNIEnv, class C.jclass, view C.jlong) C.jboolean {
+	w := views[view]
+	ev := &system.CommandEvent{Type: system.CommandBack}
+	w.callbacks.Event(ev)
+	if ev.Cancel {
+		return C.JNI_TRUE
+	}
+	return C.JNI_FALSE
+}
+
+//export onFocusChange
+func onFocusChange(env *C.JNIEnv, class C.jclass, view C.jlong, focus C.jboolean) {
+	w := views[view]
+	w.callbacks.Event(key.FocusEvent{Focus: focus == C.JNI_TRUE})
+}
+
+//export onWindowInsets
+func onWindowInsets(env *C.JNIEnv, class C.jclass, view C.jlong, top, right, bottom, left C.jint) {
+	w := views[view]
+	w.insets = system.Insets{
+		Top:    unit.Px(float32(top)),
+		Right:  unit.Px(float32(right)),
+		Bottom: unit.Px(float32(bottom)),
+		Left:   unit.Px(float32(left)),
+	}
+	if w.stage >= system.StageRunning {
+		w.draw(true)
+	}
+}
+
+func (w *window) setVisible() {
+	win := w.aNativeWindow()
+	width, height := C.ANativeWindow_getWidth(win), C.ANativeWindow_getHeight(win)
+	if width == 0 || height == 0 {
+		return
+	}
+	w.setStage(system.StageRunning)
+	w.draw(true)
+}
+
+func (w *window) setStage(stage system.Stage) {
+	if stage == w.stage {
+		return
+	}
+	w.stage = stage
+	w.callbacks.Event(system.StageEvent{stage})
+}
+
+func (w *window) nativeWindow(visID int) (*C.ANativeWindow, int, int) {
+	win := w.aNativeWindow()
+	var width, height int
+	if win != nil {
+		if C.ANativeWindow_setBuffersGeometry(win, 0, 0, C.int32_t(visID)) != 0 {
+			panic(errors.New("ANativeWindow_setBuffersGeometry failed"))
+		}
+		w, h := C.ANativeWindow_getWidth(win), C.ANativeWindow_getHeight(win)
+		width, height = int(w), int(h)
+	}
+	return win, width, height
+}
+
+func (w *window) aNativeWindow() *C.ANativeWindow {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	return w.win
+}
+
+func (w *window) loadConfig(env *C.JNIEnv, class C.jclass) {
+	dpi := int(C.gio_jni_CallIntMethod(env, w.view, w.mgetDensity))
+	w.fontScale = float32(C.gio_jni_CallFloatMethod(env, w.view, w.mgetFontScale))
+	switch dpi {
+	case C.ACONFIGURATION_DENSITY_NONE,
+		C.ACONFIGURATION_DENSITY_DEFAULT,
+		C.ACONFIGURATION_DENSITY_ANY:
+		// Assume standard density.
+		w.dpi = C.ACONFIGURATION_DENSITY_MEDIUM
+	default:
+		w.dpi = int(dpi)
+	}
+}
+
+func (w *window) SetAnimating(anim bool) {
+	w.mu.Lock()
+	w.animating = anim
+	w.mu.Unlock()
+	if anim {
+		runInJVM(func(env *C.JNIEnv) {
+			C.gio_jni_CallVoidMethod(env, w.view, w.mpostFrameCallbackOnMainThread)
+		})
+	}
+}
+
+func (w *window) draw(sync bool) {
+	win := w.aNativeWindow()
+	width, height := C.ANativeWindow_getWidth(win), C.ANativeWindow_getHeight(win)
+	if width == 0 || height == 0 {
+		return
+	}
+	ppdp := float32(w.dpi) * inchPrDp
+	w.callbacks.Event(FrameEvent{
+		FrameEvent: system.FrameEvent{
+			Size: image.Point{
+				X: int(width),
+				Y: int(height),
+			},
+			Insets: w.insets,
+			Config: &config{
+				pxPerDp: ppdp,
+				pxPerSp: w.fontScale * ppdp,
+				now:     time.Now(),
+			},
+		},
+		Sync: sync,
+	})
+}
+
+type keyMapper func(devId, keyCode C.int32_t) rune
+
+func runInJVM(f func(env *C.JNIEnv)) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+	var env *C.JNIEnv
+	var detach bool
+	if res := C.gio_jni_GetEnv(theJVM, &env, C.JNI_VERSION_1_6); res != C.JNI_OK {
+		if res != C.JNI_EDETACHED {
+			panic(fmt.Errorf("JNI GetEnv failed with error %d", res))
+		}
+		if C.gio_jni_AttachCurrentThread(theJVM, &env, nil) != C.JNI_OK {
+			panic(errors.New("runInJVM: AttachCurrentThread failed"))
+		}
+		detach = true
+	}
+
+	if detach {
+		defer func() {
+			C.gio_jni_DetachCurrentThread(theJVM)
+		}()
+	}
+	f(env)
+}
+
+func convertKeyCode(code C.jint) (rune, bool) {
+	var n rune
+	switch code {
+	case C.AKEYCODE_DPAD_UP:
+		n = key.NameUpArrow
+	case C.AKEYCODE_DPAD_DOWN:
+		n = key.NameDownArrow
+	case C.AKEYCODE_DPAD_LEFT:
+		n = key.NameLeftArrow
+	case C.AKEYCODE_DPAD_RIGHT:
+		n = key.NameRightArrow
+	case C.AKEYCODE_FORWARD_DEL:
+		n = key.NameDeleteForward
+	case C.AKEYCODE_DEL:
+		n = key.NameDeleteBackward
+	default:
+		return 0, false
+	}
+	return n, true
+}
+
+//export onKeyEvent
+func onKeyEvent(env *C.JNIEnv, class C.jclass, handle C.jlong, keyCode, r C.jint, t C.jlong) {
+	w := views[handle]
+	if n, ok := convertKeyCode(keyCode); ok {
+		w.callbacks.Event(key.Event{Name: n})
+	}
+	if r != 0 {
+		w.callbacks.Event(key.EditEvent{Text: string(rune(r))})
+	}
+}
+
+//export onTouchEvent
+func onTouchEvent(env *C.JNIEnv, class C.jclass, handle C.jlong, action, pointerID, tool C.jint, x, y C.jfloat, t C.jlong) {
+	w := views[handle]
+	var typ pointer.Type
+	switch action {
+	case C.AMOTION_EVENT_ACTION_DOWN, C.AMOTION_EVENT_ACTION_POINTER_DOWN:
+		typ = pointer.Press
+	case C.AMOTION_EVENT_ACTION_UP, C.AMOTION_EVENT_ACTION_POINTER_UP:
+		typ = pointer.Release
+	case C.AMOTION_EVENT_ACTION_CANCEL:
+		typ = pointer.Cancel
+	case C.AMOTION_EVENT_ACTION_MOVE:
+		typ = pointer.Move
+	default:
+		return
+	}
+	var src pointer.Source
+	switch tool {
+	case C.AMOTION_EVENT_TOOL_TYPE_FINGER:
+		src = pointer.Touch
+	case C.AMOTION_EVENT_TOOL_TYPE_MOUSE:
+		src = pointer.Mouse
+	default:
+		return
+	}
+	w.callbacks.Event(pointer.Event{
+		Type:      typ,
+		Source:    src,
+		PointerID: pointer.ID(pointerID),
+		Time:      time.Duration(t) * time.Millisecond,
+		Position:  f32.Point{X: float32(x), Y: float32(y)},
+	})
+}
+
+func (w *window) ShowTextInput(show bool) {
+	if w.view == 0 {
+		return
+	}
+	runInJVM(func(env *C.JNIEnv) {
+		if show {
+			C.gio_jni_CallVoidMethod(env, w.view, w.mshowTextInput)
+		} else {
+			C.gio_jni_CallVoidMethod(env, w.view, w.mhideTextInput)
+		}
+	})
+}
+
+func Main() {
+}
+
+func NewWindow(window Callbacks, opts *Options) error {
+	mainWindow.in <- windowAndOptions{window, opts}
+	return <-mainWindow.errs
+}

app/internal/window/os_android.h

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+__attribute__ ((visibility ("hidden"))) jint gio_jni_GetEnv(JavaVM *vm, JNIEnv **env, jint version);
+__attribute__ ((visibility ("hidden"))) jint gio_jni_AttachCurrentThread(JavaVM *vm, JNIEnv **p_env, void *thr_args);
+__attribute__ ((visibility ("hidden"))) jint gio_jni_DetachCurrentThread(JavaVM *vm);
+
+__attribute__ ((visibility ("hidden"))) jobject gio_jni_NewGlobalRef(JNIEnv *env, jobject obj);
+__attribute__ ((visibility ("hidden"))) void gio_jni_DeleteGlobalRef(JNIEnv *env, jobject obj);
+__attribute__ ((visibility ("hidden"))) jclass gio_jni_GetObjectClass(JNIEnv *env, jobject obj);
+__attribute__ ((visibility ("hidden"))) jmethodID gio_jni_GetStaticMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
+__attribute__ ((visibility ("hidden"))) jmethodID gio_jni_GetMethodID(JNIEnv *env, jclass clazz, const char *name, const char *sig);
+__attribute__ ((visibility ("hidden"))) jint gio_jni_CallStaticIntMethodII(JNIEnv *env, jclass clazz, jmethodID methodID, jint a1, jint a2);
+__attribute__ ((visibility ("hidden"))) jfloat gio_jni_CallFloatMethod(JNIEnv *env, jobject obj, jmethodID methodID);
+__attribute__ ((visibility ("hidden"))) jint gio_jni_CallIntMethod(JNIEnv *env, jobject obj, jmethodID methodID);
+__attribute__ ((visibility ("hidden"))) void gio_jni_CallVoidMethod(JNIEnv *env, jobject obj, jmethodID methodID);
+__attribute__ ((visibility ("hidden"))) void gio_jni_CallVoidMethod_J(JNIEnv *env, jobject obj, jmethodID methodID, jlong a1);
+__attribute__ ((visibility ("hidden"))) jbyte *gio_jni_GetByteArrayElements(JNIEnv *env, jbyteArray arr);
+__attribute__ ((visibility ("hidden"))) void gio_jni_ReleaseByteArrayElements(JNIEnv *env, jbyteArray arr, jbyte *bytes);
+__attribute__ ((visibility ("hidden"))) jsize gio_jni_GetArrayLength(JNIEnv *env, jbyteArray arr);

app/internal/window/os_ios.go

@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build darwin,ios
+
+package window
+
+/*
+#cgo CFLAGS: -fmodules -fobjc-arc -x objective-c
+
+#include <CoreGraphics/CoreGraphics.h>
+#include <UIKit/UIKit.h>
+#include <stdint.h>
+#include "os_ios.h"
+
+*/
+import "C"
+
+import (
+	"image"
+	"runtime"
+	"runtime/debug"
+	"sync/atomic"
+	"time"
+
+	"gioui.org/f32"
+	"gioui.org/io/key"
+	"gioui.org/io/pointer"
+	"gioui.org/io/system"
+	"gioui.org/unit"
+)
+
+type window struct {
+	view C.CFTypeRef
+	w    Callbacks
+
+	layer   C.CFTypeRef
+	visible atomic.Value
+
+	pointerMap []C.CFTypeRef
+}
+
+var mainWindow = newWindowRendezvous()
+
+var layerFactory func() uintptr
+
+var views = make(map[C.CFTypeRef]*window)
+
+func init() {
+	// Darwin requires UI operations happen on the main thread only.
+	runtime.LockOSThread()
+}
+
+//export onCreate
+func onCreate(view C.CFTypeRef) {
+	w := &window{
+		view: view,
+	}
+	wopts := <-mainWindow.out
+	w.w = wopts.window
+	w.w.SetDriver(w)
+	w.visible.Store(false)
+	w.layer = C.CFTypeRef(layerFactory())
+	C.gio_addLayerToView(view, w.layer)
+	views[view] = w
+	w.w.Event(system.StageEvent{Stage: system.StagePaused})
+}
+
+//export onDraw
+func onDraw(view C.CFTypeRef, dpi, sdpi, width, height C.CGFloat, sync C.int, top, right, bottom, left C.CGFloat) {
+	if width == 0 || height == 0 {
+		return
+	}
+	w := views[view]
+	wasVisible := w.isVisible()
+	w.visible.Store(true)
+	C.gio_updateView(view, w.layer)
+	if !wasVisible {
+		w.w.Event(system.StageEvent{Stage: system.StageRunning})
+	}
+	isSync := false
+	if sync != 0 {
+		isSync = true
+	}
+	w.w.Event(FrameEvent{
+		FrameEvent: system.FrameEvent{
+			Size: image.Point{
+				X: int(width + .5),
+				Y: int(height + .5),
+			},
+			Insets: system.Insets{
+				Top:    unit.Px(float32(top)),
+				Right:  unit.Px(float32(right)),
+				Bottom: unit.Px(float32(bottom)),
+				Left:   unit.Px(float32(left)),
+			},
+			Config: &config{
+				pxPerDp: float32(dpi) * inchPrDp,
+				pxPerSp: float32(sdpi) * inchPrDp,
+				now:     time.Now(),
+			},
+		},
+		Sync: isSync,
+	})
+}
+
+//export onStop
+func onStop(view C.CFTypeRef) {
+	w := views[view]
+	w.visible.Store(false)
+	w.w.Event(system.StageEvent{Stage: system.StagePaused})
+}
+
+//export onDestroy
+func onDestroy(view C.CFTypeRef) {
+	w := views[view]
+	delete(views, view)
+	w.w.Event(system.DestroyEvent{})
+	C.gio_removeLayer(w.layer)
+	C.CFRelease(w.layer)
+	w.layer = 0
+	w.view = 0
+}
+
+//export onFocus
+func onFocus(view C.CFTypeRef, focus int) {
+	w := views[view]
+	w.w.Event(key.FocusEvent{Focus: focus != 0})
+}
+
+//export onLowMemory
+func onLowMemory() {
+	runtime.GC()
+	debug.FreeOSMemory()
+}
+
+//export onUpArrow
+func onUpArrow(view C.CFTypeRef) {
+	views[view].onKeyCommand(key.NameUpArrow)
+}
+
+//export onDownArrow
+func onDownArrow(view C.CFTypeRef) {
+	views[view].onKeyCommand(key.NameDownArrow)
+}
+
+//export onLeftArrow
+func onLeftArrow(view C.CFTypeRef) {
+	views[view].onKeyCommand(key.NameLeftArrow)
+}
+
+//export onRightArrow
+func onRightArrow(view C.CFTypeRef) {
+	views[view].onKeyCommand(key.NameRightArrow)
+}
+
+//export onDeleteBackward
+func onDeleteBackward(view C.CFTypeRef) {
+	views[view].onKeyCommand(key.NameDeleteBackward)
+}
+
+//export onText
+func onText(view C.CFTypeRef, str *C.char) {
+	w := views[view]
+	w.w.Event(key.EditEvent{
+		Text: C.GoString(str),
+	})
+}
+
+//export onTouch
+func onTouch(last C.int, view, touchRef C.CFTypeRef, phase C.NSInteger, x, y C.CGFloat, ti C.double) {
+	var typ pointer.Type
+	switch phase {
+	case C.UITouchPhaseBegan:
+		typ = pointer.Press
+	case C.UITouchPhaseMoved:
+		typ = pointer.Move
+	case C.UITouchPhaseEnded:
+		typ = pointer.Release
+	case C.UITouchPhaseCancelled:
+		typ = pointer.Cancel
+	default:
+		return
+	}
+	w := views[view]
+	t := time.Duration(float64(ti) * float64(time.Second))
+	p := f32.Point{X: float32(x), Y: float32(y)}
+	w.w.Event(pointer.Event{
+		Type:      typ,
+		Source:    pointer.Touch,
+		PointerID: w.lookupTouch(last != 0, touchRef),
+		Position:  p,
+		Time:      t,
+	})
+}
+
+func (w *window) SetAnimating(anim bool) {
+	if w.view == 0 {
+		return
+	}
+	var animi C.int
+	if anim {
+		animi = 1
+	}
+	C.gio_setAnimating(w.view, animi)
+}
+
+func (w *window) onKeyCommand(name rune) {
+	w.w.Event(key.Event{
+		Name: name,
+	})
+}
+
+// lookupTouch maps an UITouch pointer value to an index. If
+// last is set, the map is cleared.
+func (w *window) lookupTouch(last bool, touch C.CFTypeRef) pointer.ID {
+	id := -1
+	for i, ref := range w.pointerMap {
+		if ref == touch {
+			id = i
+			break
+		}
+	}
+	if id == -1 {
+		id = len(w.pointerMap)
+		w.pointerMap = append(w.pointerMap, touch)
+	}
+	if last {
+		w.pointerMap = w.pointerMap[:0]
+	}
+	return pointer.ID(id)
+}
+
+func (w *window) contextLayer() uintptr {
+	return uintptr(w.layer)
+}
+
+func (w *window) isVisible() bool {
+	return w.visible.Load().(bool)
+}
+
+func (w *window) ShowTextInput(show bool) {
+	if w.view == 0 {
+		return
+	}
+	if show {
+		C.gio_showTextInput(w.view)
+	} else {
+		C.gio_hideTextInput(w.view)
+	}
+}
+
+func NewWindow(win Callbacks, opts *Options) error {
+	mainWindow.in <- windowAndOptions{win, opts}
+	return <-mainWindow.errs
+}
+
+func Main() {
+}

app/internal/window/os_ios.h

@@ -0,0 +1,8 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+__attribute__ ((visibility ("hidden"))) void gio_showTextInput(CFTypeRef viewRef);
+__attribute__ ((visibility ("hidden"))) void gio_hideTextInput(CFTypeRef viewRef);
+__attribute__ ((visibility ("hidden"))) void gio_addLayerToView(CFTypeRef viewRef, CFTypeRef layerRef);
+__attribute__ ((visibility ("hidden"))) void gio_updateView(CFTypeRef viewRef, CFTypeRef layerRef);
+__attribute__ ((visibility ("hidden"))) void gio_removeLayer(CFTypeRef layerRef);
+__attribute__ ((visibility ("hidden"))) void gio_setAnimating(CFTypeRef viewRef, int anim);

app/internal/window/os_ios.m

@@ -0,0 +1,320 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build darwin,ios
+
+@import UIKit;
+
+#include <stdint.h>
+#include "_cgo_export.h"
+#include "os_ios.h"
+#include "framework_ios.h"
+
+@interface GioView: UIView <UIKeyInput>
+- (void)setAnimating:(BOOL)anim;
+@end
+
+@interface GioViewController : UIViewController
+@property(weak) UIScreen *screen;
+@end
+
+static void redraw(CFTypeRef viewRef, BOOL sync) {
+	UIView *v = (__bridge UIView *)viewRef;
+	CGFloat scale = v.layer.contentsScale;
+	// Use 163 as the standard ppi on iOS.
+	CGFloat dpi = 163*scale;
+	CGFloat sdpi = dpi;
+	UIEdgeInsets insets = v.layoutMargins;
+	if (@available(iOS 11.0, tvOS 11.0, *)) {
+		UIFontMetrics *metrics = [UIFontMetrics defaultMetrics];
+		sdpi = [metrics scaledValueForValue:sdpi];
+		insets = v.safeAreaInsets;
+	}
+	onDraw(viewRef, dpi, sdpi, v.bounds.size.width*scale, v.bounds.size.height*scale, sync,
+			insets.top*scale, insets.right*scale, insets.bottom*scale, insets.left*scale);
+}
+
+@implementation GioAppDelegate
+- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
+	gio_runMain();
+
+	self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
+	GioViewController *controller = [[GioViewController alloc] initWithNibName:nil bundle:nil];
+	controller.screen = self.window.screen;
+    self.window.rootViewController = controller;
+    [self.window makeKeyAndVisible];
+	return YES;
+}
+
+- (void)applicationWillResignActive:(UIApplication *)application {
+}
+
+- (void)applicationDidEnterBackground:(UIApplication *)application {
+	GioViewController *vc = (GioViewController *)self.window.rootViewController;
+	UIView *drawView = vc.view.subviews[0];
+	if (drawView != nil) {
+		onStop((__bridge CFTypeRef)drawView);
+	}
+}
+
+- (void)applicationWillEnterForeground:(UIApplication *)application {
+	GioViewController *c = (GioViewController*)self.window.rootViewController;
+	UIView *drawView = c.view.subviews[0];
+	if (drawView != nil) {
+		CFTypeRef viewRef = (__bridge CFTypeRef)drawView;
+		redraw(viewRef, YES);
+	}
+}
+@end
+
+@implementation GioViewController
+CGFloat _keyboardHeight;
+
+- (void)loadView {
+	CGRect zeroFrame = CGRectMake(0, 0, 0, 0);
+	self.view = [[UIView alloc] initWithFrame:zeroFrame];
+	self.view.layoutMargins = UIEdgeInsetsMake(0, 0, 0, 0);
+	UIView *drawView = [[GioView alloc] initWithFrame:zeroFrame];
+	[self.view addSubview: drawView];
+#ifndef TARGET_OS_TV
+	drawView.multipleTouchEnabled = YES;
+#endif
+	drawView.contentScaleFactor = self.screen.nativeScale;
+	drawView.preservesSuperviewLayoutMargins = YES;
+	drawView.layoutMargins = UIEdgeInsetsMake(0, 0, 0, 0);
+	onCreate((__bridge CFTypeRef)drawView);
+	[[NSNotificationCenter defaultCenter] addObserver:self
+											 selector:@selector(keyboardWillChange:)
+												 name:UIKeyboardWillShowNotification
+											   object:nil];
+	[[NSNotificationCenter defaultCenter] addObserver:self
+											 selector:@selector(keyboardWillChange:)
+												 name:UIKeyboardWillChangeFrameNotification
+											   object:nil];
+	[[NSNotificationCenter defaultCenter] addObserver:self
+											 selector:@selector(keyboardWillHide:)
+												 name:UIKeyboardWillHideNotification
+											   object:nil];
+}
+
+- (void)viewDidDisappear:(BOOL)animated {
+	[super viewDidDisappear:animated];
+	CFTypeRef viewRef = (__bridge CFTypeRef)self.view.subviews[0];
+	onDestroy(viewRef);
+}
+
+- (void)viewDidLayoutSubviews {
+	[super viewDidLayoutSubviews];
+	UIView *view = self.view.subviews[0];
+	CGRect frame = self.view.bounds;
+	// Adjust view bounds to make room for the keyboard.
+	frame.size.height -= _keyboardHeight;
+	view.frame = frame;
+	redraw((__bridge CFTypeRef)view, YES);
+}
+
+- (void)didReceiveMemoryWarning {
+	onLowMemory();
+	[super didReceiveMemoryWarning];
+}
+
+- (void)keyboardWillChange:(NSNotification *)note {
+	NSDictionary *userInfo = note.userInfo;
+	CGRect f = [userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
+	_keyboardHeight = f.size.height;
+	[self.view setNeedsLayout];
+}
+
+- (void)keyboardWillHide:(NSNotification *)note {
+	_keyboardHeight = 0.0;
+	[self.view setNeedsLayout];
+}
+@end
+
+static void handleTouches(int last, UIView *view, NSSet<UITouch *> *touches, UIEvent *event) {
+	CGFloat scale = view.contentScaleFactor;
+	NSUInteger i = 0;
+	NSUInteger n = [touches count];
+	CFTypeRef viewRef = (__bridge CFTypeRef)view;
+	for (UITouch *touch in touches) {
+		CFTypeRef touchRef = (__bridge CFTypeRef)touch;
+		i++;
+		NSArray<UITouch *> *coalescedTouches = [event coalescedTouchesForTouch:touch];
+		NSUInteger j = 0;
+		NSUInteger m = [coalescedTouches count];
+		for (UITouch *coalescedTouch in [event coalescedTouchesForTouch:touch]) {
+			CGPoint loc = [coalescedTouch locationInView:view];
+			j++;
+			int lastTouch = last && i == n && j == m;
+			onTouch(lastTouch, viewRef, touchRef, touch.phase, loc.x*scale, loc.y*scale, [coalescedTouch timestamp]);
+		}
+	}
+}
+
+@implementation GioView
+CADisplayLink *displayLink;
+NSArray<UIKeyCommand *> *_keyCommands;
+
+- (void)onFrameCallback:(CADisplayLink *)link {
+	redraw((__bridge CFTypeRef)self, NO);
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+	self = [super initWithFrame:frame];
+	if (self) {
+		__weak id weakSelf = self;
+		displayLink = [CADisplayLink displayLinkWithTarget:weakSelf selector:@selector(onFrameCallback:)];
+	}
+	return self;
+}
+
+- (void)willMoveToWindow:(UIWindow *)newWindow {
+	if (self.window != nil) {
+		[[NSNotificationCenter defaultCenter] removeObserver:self
+														name:UIWindowDidBecomeKeyNotification
+													  object:self.window];
+		[[NSNotificationCenter defaultCenter] removeObserver:self
+														name:UIWindowDidResignKeyNotification
+													  object:self.window];
+	}
+	[[NSNotificationCenter defaultCenter] addObserver:self
+											 selector:@selector(onWindowDidBecomeKey:)
+												 name:UIWindowDidBecomeKeyNotification
+											   object:newWindow];
+	[[NSNotificationCenter defaultCenter] addObserver:self
+											 selector:@selector(onWindowDidResignKey:)
+												 name:UIWindowDidResignKeyNotification
+											   object:newWindow];
+}
+
+- (void)onWindowDidBecomeKey:(NSNotification *)note {
+	if (self.isFirstResponder) {
+		onFocus((__bridge CFTypeRef)self, YES);
+	}
+}
+
+- (void)onWindowDidResignKey:(NSNotification *)note {
+	if (self.isFirstResponder) {
+		onFocus((__bridge CFTypeRef)self, NO);
+	}
+}
+
+- (void)dealloc {
+	[displayLink invalidate];
+}
+
+- (void)setAnimating:(BOOL)anim {
+	NSRunLoop *runLoop = [NSRunLoop currentRunLoop];
+	if (anim) {
+		[displayLink addToRunLoop:runLoop forMode:[runLoop currentMode]];
+	} else {
+		[displayLink removeFromRunLoop:runLoop forMode:[runLoop currentMode]];
+	}
+}
+
+- (void)touchesBegan:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+	handleTouches(0, self, touches, event);
+}
+
+- (void)touchesMoved:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+	handleTouches(0, self, touches, event);
+}
+
+- (void)touchesEnded:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+	handleTouches(1, self, touches, event);
+}
+
+- (void)touchesCancelled:(NSSet<UITouch *> *)touches withEvent:(UIEvent *)event {
+	handleTouches(1, self, touches, event);
+}
+
+- (void)insertText:(NSString *)text {
+	onText((__bridge CFTypeRef)self, (char *)text.UTF8String);
+}
+
+- (BOOL)canBecomeFirstResponder {
+	return YES;
+}
+
+- (BOOL)hasText {
+	return YES;
+}
+
+- (void)deleteBackward {
+	onDeleteBackward((__bridge CFTypeRef)self);
+}
+
+- (void)onUpArrow {
+	onUpArrow((__bridge CFTypeRef)self);
+}
+
+- (void)onDownArrow {
+	onDownArrow((__bridge CFTypeRef)self);
+}
+
+- (void)onLeftArrow {
+	onLeftArrow((__bridge CFTypeRef)self);
+}
+
+- (void)onRightArrow {
+	onRightArrow((__bridge CFTypeRef)self);
+}
+
+- (NSArray<UIKeyCommand *> *)keyCommands {
+	if (_keyCommands == nil) {
+		_keyCommands = @[
+			[UIKeyCommand keyCommandWithInput:UIKeyInputUpArrow
+								modifierFlags:0
+									   action:@selector(onUpArrow)],
+			[UIKeyCommand keyCommandWithInput:UIKeyInputDownArrow
+								modifierFlags:0
+									   action:@selector(onDownArrow)],
+			[UIKeyCommand keyCommandWithInput:UIKeyInputLeftArrow
+								modifierFlags:0
+									   action:@selector(onLeftArrow)],
+			[UIKeyCommand keyCommandWithInput:UIKeyInputRightArrow
+								modifierFlags:0
+									   action:@selector(onRightArrow)]
+		];
+	}
+	return _keyCommands;
+}
+@end
+
+void gio_setAnimating(CFTypeRef viewRef, int anim) {
+	GioView *view = (__bridge GioView *)viewRef;
+	dispatch_async(dispatch_get_main_queue(), ^{
+		[view setAnimating:(anim ? YES : NO)];
+	});
+}
+
+void gio_showTextInput(CFTypeRef viewRef) {
+	UIView *view = (__bridge UIView *)viewRef;
+	dispatch_async(dispatch_get_main_queue(), ^{
+		[view becomeFirstResponder];
+	});
+}
+
+void gio_hideTextInput(CFTypeRef viewRef) {
+	UIView *view = (__bridge UIView *)viewRef;
+	dispatch_async(dispatch_get_main_queue(), ^{
+		[view resignFirstResponder];
+	});
+}
+
+void gio_addLayerToView(CFTypeRef viewRef, CFTypeRef layerRef) {
+	UIView *view = (__bridge UIView *)viewRef;
+	CALayer *layer = (__bridge CALayer *)layerRef;
+	[view.layer addSublayer:layer];
+}
+
+void gio_updateView(CFTypeRef viewRef, CFTypeRef layerRef) {
+	UIView *view = (__bridge UIView *)viewRef;
+	CAEAGLLayer *layer = (__bridge CAEAGLLayer *)layerRef;
+	layer.contentsScale = view.contentScaleFactor;
+	layer.bounds = view.bounds;
+}
+
+void gio_removeLayer(CFTypeRef layerRef) {
+	CALayer *layer = (__bridge CALayer *)layerRef;
+	[layer removeFromSuperlayer];
+}

app/internal/window/os_js.go

@@ -0,0 +1,424 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package window
+
+import (
+	"image"
+	"sync"
+	"syscall/js"
+	"time"
+
+	"gioui.org/f32"
+	"gioui.org/io/key"
+	"gioui.org/io/pointer"
+	"gioui.org/io/system"
+)
+
+type window struct {
+	window                js.Value
+	cnv                   js.Value
+	tarea                 js.Value
+	w                     Callbacks
+	redraw                js.Func
+	requestAnimationFrame js.Value
+	cleanfuncs            []func()
+	touches               []js.Value
+	composing             bool
+
+	mu        sync.Mutex
+	scale     float32
+	animating bool
+}
+
+var mainDone = make(chan struct{})
+
+func NewWindow(win Callbacks, opts *Options) error {
+	doc := js.Global().Get("document")
+	cont := getContainer(doc)
+	cnv := createCanvas(doc)
+	cont.Call("appendChild", cnv)
+	tarea := createTextArea(doc)
+	cont.Call("appendChild", tarea)
+	w := &window{
+		cnv:    cnv,
+		tarea:  tarea,
+		window: js.Global().Get("window"),
+	}
+	w.requestAnimationFrame = w.window.Get("requestAnimationFrame")
+	w.redraw = w.funcOf(func(this js.Value, args []js.Value) interface{} {
+		w.animCallback()
+		return nil
+	})
+	w.addEventListeners()
+	w.w = win
+	go func() {
+		w.w.SetDriver(w)
+		w.focus()
+		w.w.Event(system.StageEvent{Stage: system.StageRunning})
+		w.draw(true)
+		select {}
+		w.cleanup()
+		close(mainDone)
+	}()
+	return nil
+}
+
+func getContainer(doc js.Value) js.Value {
+	cont := doc.Call("getElementById", "giowindow")
+	if cont != js.Null() {
+		return cont
+	}
+	cont = doc.Call("createElement", "DIV")
+	doc.Get("body").Call("appendChild", cont)
+	return cont
+}
+
+func createTextArea(doc js.Value) js.Value {
+	tarea := doc.Call("createElement", "input")
+	style := tarea.Get("style")
+	style.Set("width", "1px")
+	style.Set("height", "1px")
+	style.Set("opacity", "0")
+	style.Set("border", "0")
+	style.Set("padding", "0")
+	tarea.Set("autocomplete", "off")
+	tarea.Set("autocorrect", "off")
+	tarea.Set("autocapitalize", "off")
+	tarea.Set("spellcheck", false)
+	return tarea
+}
+
+func createCanvas(doc js.Value) js.Value {
+	cnv := doc.Call("createElement", "canvas")
+	style := cnv.Get("style")
+	style.Set("position", "fixed")
+	style.Set("width", "100%")
+	style.Set("height", "100%")
+	return cnv
+}
+
+func (w *window) cleanup() {
+	// Cleanup in the opposite order of
+	// construction.
+	for i := len(w.cleanfuncs) - 1; i >= 0; i-- {
+		w.cleanfuncs[i]()
+	}
+	w.cleanfuncs = nil
+}
+
+func (w *window) addEventListeners() {
+	w.addEventListener(w.window, "resize", func(this js.Value, args []js.Value) interface{} {
+		w.draw(true)
+		return nil
+	})
+	w.addEventListener(w.cnv, "mousemove", func(this js.Value, args []js.Value) interface{} {
+		w.pointerEvent(pointer.Move, 0, 0, args[0])
+		return nil
+	})
+	w.addEventListener(w.cnv, "mousedown", func(this js.Value, args []js.Value) interface{} {
+		w.pointerEvent(pointer.Press, 0, 0, args[0])
+		return nil
+	})
+	w.addEventListener(w.cnv, "mouseup", func(this js.Value, args []js.Value) interface{} {
+		w.pointerEvent(pointer.Release, 0, 0, args[0])
+		return nil
+	})
+	w.addEventListener(w.cnv, "wheel", func(this js.Value, args []js.Value) interface{} {
+		e := args[0]
+		dx, dy := e.Get("deltaX").Float(), e.Get("deltaY").Float()
+		mode := e.Get("deltaMode").Int()
+		switch mode {
+		case 0x01: // DOM_DELTA_LINE
+			dx *= 10
+			dy *= 10
+		case 0x02: // DOM_DELTA_PAGE
+			dx *= 120
+			dy *= 120
+		}
+		w.pointerEvent(pointer.Move, float32(dx), float32(dy), e)
+		return nil
+	})
+	w.addEventListener(w.cnv, "touchstart", func(this js.Value, args []js.Value) interface{} {
+		w.touchEvent(pointer.Press, args[0])
+		return nil
+	})
+	w.addEventListener(w.cnv, "touchend", func(this js.Value, args []js.Value) interface{} {
+		w.touchEvent(pointer.Release, args[0])
+		return nil
+	})
+	w.addEventListener(w.cnv, "touchmove", func(this js.Value, args []js.Value) interface{} {
+		w.touchEvent(pointer.Move, args[0])
+		return nil
+	})
+	w.addEventListener(w.cnv, "touchcancel", func(this js.Value, args []js.Value) interface{} {
+		// Cancel all touches even if only one touch was cancelled.
+		for i := range w.touches {
+			w.touches[i] = js.Null()
+		}
+		w.touches = w.touches[:0]
+		w.w.Event(pointer.Event{
+			Type:   pointer.Cancel,
+			Source: pointer.Touch,
+		})
+		return nil
+	})
+	w.addEventListener(w.tarea, "focus", func(this js.Value, args []js.Value) interface{} {
+		w.w.Event(key.FocusEvent{Focus: true})
+		return nil
+	})
+	w.addEventListener(w.tarea, "blur", func(this js.Value, args []js.Value) interface{} {
+		w.w.Event(key.FocusEvent{Focus: false})
+		return nil
+	})
+	w.addEventListener(w.tarea, "keydown", func(this js.Value, args []js.Value) interface{} {
+		w.keyEvent(args[0])
+		return nil
+	})
+	w.addEventListener(w.tarea, "compositionstart", func(this js.Value, args []js.Value) interface{} {
+		w.composing = true
+		return nil
+	})
+	w.addEventListener(w.tarea, "compositionend", func(this js.Value, args []js.Value) interface{} {
+		w.composing = false
+		w.flushInput()
+		return nil
+	})
+	w.addEventListener(w.tarea, "input", func(this js.Value, args []js.Value) interface{} {
+		if w.composing {
+			return nil
+		}
+		w.flushInput()
+		return nil
+	})
+}
+
+func (w *window) flushInput() {
+	val := w.tarea.Get("value").String()
+	w.tarea.Set("value", "")
+	w.w.Event(key.EditEvent{Text: string(val)})
+}
+
+func (w *window) blur() {
+	w.tarea.Call("blur")
+}
+
+func (w *window) focus() {
+	w.tarea.Call("focus")
+}
+
+func (w *window) keyEvent(e js.Value) {
+	k := e.Get("key").String()
+	if n, ok := translateKey(k); ok {
+		cmd := key.Event{Name: n}
+		if e.Call("getModifierState", "Control").Bool() {
+			cmd.Modifiers |= key.ModCommand
+		}
+		if e.Call("getModifierState", "Shift").Bool() {
+			cmd.Modifiers |= key.ModShift
+		}
+		w.w.Event(cmd)
+	}
+}
+
+func (w *window) touchEvent(typ pointer.Type, e js.Value) {
+	e.Call("preventDefault")
+	t := time.Duration(e.Get("timeStamp").Int()) * time.Millisecond
+	changedTouches := e.Get("changedTouches")
+	n := changedTouches.Length()
+	rect := w.cnv.Call("getBoundingClientRect")
+	w.mu.Lock()
+	scale := w.scale
+	w.mu.Unlock()
+	for i := 0; i < n; i++ {
+		touch := changedTouches.Index(i)
+		pid := w.touchIDFor(touch)
+		x, y := touch.Get("clientX").Float(), touch.Get("clientY").Float()
+		x -= rect.Get("left").Float()
+		y -= rect.Get("top").Float()
+		pos := f32.Point{
+			X: float32(x) * scale,
+			Y: float32(y) * scale,
+		}
+		w.w.Event(pointer.Event{
+			Type:      typ,
+			Source:    pointer.Touch,
+			Position:  pos,
+			PointerID: pid,
+			Time:      t,
+		})
+	}
+}
+
+func (w *window) touchIDFor(touch js.Value) pointer.ID {
+	id := touch.Get("identifier")
+	for i, id2 := range w.touches {
+		if id2 == id {
+			return pointer.ID(i)
+		}
+	}
+	pid := pointer.ID(len(w.touches))
+	w.touches = append(w.touches, id)
+	return pid
+}
+
+func (w *window) pointerEvent(typ pointer.Type, dx, dy float32, e js.Value) {
+	e.Call("preventDefault")
+	x, y := e.Get("clientX").Float(), e.Get("clientY").Float()
+	rect := w.cnv.Call("getBoundingClientRect")
+	x -= rect.Get("left").Float()
+	y -= rect.Get("top").Float()
+	w.mu.Lock()
+	scale := w.scale
+	w.mu.Unlock()
+	pos := f32.Point{
+		X: float32(x) * scale,
+		Y: float32(y) * scale,
+	}
+	scroll := f32.Point{
+		X: dx * scale,
+		Y: dy * scale,
+	}
+	t := time.Duration(e.Get("timeStamp").Int()) * time.Millisecond
+	w.w.Event(pointer.Event{
+		Type:     typ,
+		Source:   pointer.Mouse,
+		Position: pos,
+		Scroll:   scroll,
+		Time:     t,
+	})
+}
+
+func (w *window) addEventListener(this js.Value, event string, f func(this js.Value, args []js.Value) interface{}) {
+	jsf := w.funcOf(f)
+	this.Call("addEventListener", event, jsf)
+	w.cleanfuncs = append(w.cleanfuncs, func() {
+		this.Call("removeEventListener", event, jsf)
+	})
+}
+
+// funcOf is like js.FuncOf but adds the js.Func to a list of
+// functions to be released up.
+func (w *window) funcOf(f func(this js.Value, args []js.Value) interface{}) js.Func {
+	jsf := js.FuncOf(f)
+	w.cleanfuncs = append(w.cleanfuncs, jsf.Release)
+	return jsf
+}
+
+func (w *window) animCallback() {
+	w.mu.Lock()
+	anim := w.animating
+	if anim {
+		w.requestAnimationFrame.Invoke(w.redraw)
+	}
+	w.mu.Unlock()
+	if anim {
+		w.draw(false)
+	}
+}
+
+func (w *window) SetAnimating(anim bool) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	if anim && !w.animating {
+		w.requestAnimationFrame.Invoke(w.redraw)
+	}
+	w.animating = anim
+}
+
+func (w *window) ShowTextInput(show bool) {
+	// Run in a goroutine to avoid a deadlock if the
+	// focus change result in an event.
+	go func() {
+		if show {
+			w.focus()
+		} else {
+			w.blur()
+		}
+	}()
+}
+
+func (w *window) draw(sync bool) {
+	width, height, scale, cfg := w.config()
+	if cfg == (config{}) {
+		return
+	}
+	w.mu.Lock()
+	w.scale = float32(scale)
+	w.mu.Unlock()
+	cfg.now = time.Now()
+	w.w.Event(FrameEvent{
+		FrameEvent: system.FrameEvent{
+			Size: image.Point{
+				X: width,
+				Y: height,
+			},
+			Config: &cfg,
+		},
+		Sync: sync,
+	})
+}
+
+func (w *window) config() (int, int, float32, config) {
+	rect := w.cnv.Call("getBoundingClientRect")
+	width, height := rect.Get("width").Float(), rect.Get("height").Float()
+	scale := w.window.Get("devicePixelRatio").Float()
+	width *= scale
+	height *= scale
+	iw, ih := int(width+.5), int(height+.5)
+	// Adjust internal size of canvas if necessary.
+	if cw, ch := w.cnv.Get("width").Int(), w.cnv.Get("height").Int(); iw != cw || ih != ch {
+		w.cnv.Set("width", iw)
+		w.cnv.Set("height", ih)
+	}
+	const ppdp = 96 * inchPrDp * monitorScale
+	return iw, ih, float32(scale), config{
+		pxPerDp: ppdp * float32(scale),
+		pxPerSp: ppdp * float32(scale),
+	}
+}
+
+func Main() {
+	<-mainDone
+}
+
+func translateKey(k string) (rune, bool) {
+	if len(k) == 1 {
+		c := k[0]
+		if '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' {
+			return rune(c), true
+		}
+		if 'a' <= c && c <= 'z' {
+			return rune(c - 0x20), true
+		}
+	}
+	var n rune
+	switch k {
+	case "ArrowUp":
+		n = key.NameUpArrow
+	case "ArrowDown":
+		n = key.NameDownArrow
+	case "ArrowLeft":
+		n = key.NameLeftArrow
+	case "ArrowRight":
+		n = key.NameRightArrow
+	case "Escape":
+		n = key.NameEscape
+	case "Enter":
+		n = key.NameReturn
+	case "Backspace":
+		n = key.NameDeleteBackward
+	case "Delete":
+		n = key.NameDeleteForward
+	case "Home":
+		n = key.NameHome
+	case "End":
+		n = key.NameEnd
+	case "PageUp":
+		n = key.NamePageUp
+	case "PageDown":
+		n = key.NamePageDown
+	default:
+		return 0, false
+	}
+	return n, true
+}

app/internal/window/os_macos.go

@@ -0,0 +1,336 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build darwin,!ios
+
+package window
+
+import (
+	"errors"
+	"image"
+	"runtime"
+	"sync"
+	"time"
+	"unsafe"
+
+	"gioui.org/f32"
+	"gioui.org/io/key"
+	"gioui.org/io/pointer"
+	"gioui.org/io/system"
+)
+
+/*
+#cgo CFLAGS: -DGL_SILENCE_DEPRECATION -Werror -Wno-deprecated-declarations -fmodules -fobjc-arc -x objective-c
+
+#include <AppKit/AppKit.h>
+#include "os_macos.h"
+*/
+import "C"
+
+func init() {
+	// Darwin requires that UI operations happen on the main thread only.
+	runtime.LockOSThread()
+}
+
+type window struct {
+	view  C.CFTypeRef
+	w     Callbacks
+	stage system.Stage
+	ppdp  float32
+	scale float32
+}
+
+type viewCmd struct {
+	view C.CFTypeRef
+	f    viewFunc
+}
+
+type viewFunc func(views viewMap, view C.CFTypeRef)
+
+type viewMap map[C.CFTypeRef]*window
+
+var (
+	viewOnce sync.Once
+	viewCmds = make(chan viewCmd)
+	viewAcks = make(chan struct{})
+)
+
+var mainWindow = newWindowRendezvous()
+
+var viewFactory func() C.CFTypeRef
+
+func viewDo(view C.CFTypeRef, f viewFunc) {
+	viewOnce.Do(func() {
+		go runViewCmdLoop()
+	})
+	viewCmds <- viewCmd{view, f}
+	<-viewAcks
+}
+
+func runViewCmdLoop() {
+	views := make(viewMap)
+	for {
+		select {
+		case cmd := <-viewCmds:
+			cmd.f(views, cmd.view)
+			viewAcks <- struct{}{}
+		}
+	}
+}
+
+func (w *window) contextView() C.CFTypeRef {
+	return w.view
+}
+
+func (w *window) ShowTextInput(show bool) {}
+
+func (w *window) SetAnimating(anim bool) {
+	var animb C.BOOL
+	if anim {
+		animb = 1
+	}
+	C.gio_setAnimating(w.view, animb)
+}
+
+func (w *window) setStage(stage system.Stage) {
+	if stage == w.stage {
+		return
+	}
+	w.stage = stage
+	w.w.Event(system.StageEvent{Stage: stage})
+}
+
+// Use a top level func for onFrameCallback to avoid
+// garbage from viewDo.
+func onFrameCmd(views viewMap, view C.CFTypeRef) {
+	// CVDisplayLink does not run on the main thread,
+	// so we have to ignore requests to windows being
+	// deleted.
+	if w, exists := views[view]; exists {
+		w.draw(false)
+	}
+}
+
+//export gio_onFrameCallback
+func gio_onFrameCallback(view C.CFTypeRef) {
+	viewDo(view, onFrameCmd)
+}
+
+//export gio_onKeys
+func gio_onKeys(view C.CFTypeRef, cstr *C.char, ti C.double, mods C.NSUInteger) {
+	str := C.GoString(cstr)
+	var kmods key.Modifiers
+	if mods&C.NSCommandKeyMask != 0 {
+		kmods |= key.ModCommand
+	}
+	if mods&C.NSShiftKeyMask != 0 {
+		kmods |= key.ModShift
+	}
+	viewDo(view, func(views viewMap, view C.CFTypeRef) {
+		w := views[view]
+		for _, k := range str {
+			if n, ok := convertKey(k); ok {
+				w.w.Event(key.Event{Name: n, Modifiers: kmods})
+			}
+		}
+	})
+}
+
+//export gio_onText
+func gio_onText(view C.CFTypeRef, cstr *C.char) {
+	str := C.GoString(cstr)
+	viewDo(view, func(views viewMap, view C.CFTypeRef) {
+		w := views[view]
+		w.w.Event(key.EditEvent{Text: str})
+	})
+}
+
+//export gio_onMouse
+func gio_onMouse(view C.CFTypeRef, cdir C.int, x, y, dx, dy C.CGFloat, ti C.double) {
+	var typ pointer.Type
+	switch cdir {
+	case C.GIO_MOUSE_MOVE:
+		typ = pointer.Move
+	case C.GIO_MOUSE_UP:
+		typ = pointer.Release
+	case C.GIO_MOUSE_DOWN:
+		typ = pointer.Press
+	default:
+		panic("invalid direction")
+	}
+	t := time.Duration(float64(ti)*float64(time.Second) + .5)
+	viewDo(view, func(views viewMap, view C.CFTypeRef) {
+		w := views[view]
+		x, y := float32(x)*w.scale, float32(y)*w.scale
+		dx, dy := float32(dx)*w.scale, float32(dy)*w.scale
+		w.w.Event(pointer.Event{
+			Type:     typ,
+			Source:   pointer.Mouse,
+			Time:     t,
+			Position: f32.Point{X: x, Y: y},
+			Scroll:   f32.Point{X: dx, Y: dy},
+		})
+	})
+}
+
+//export gio_onDraw
+func gio_onDraw(view C.CFTypeRef) {
+	viewDo(view, func(views viewMap, view C.CFTypeRef) {
+		if w, exists := views[view]; exists {
+			w.draw(true)
+		}
+	})
+}
+
+//export gio_onFocus
+func gio_onFocus(view C.CFTypeRef, focus C.BOOL) {
+	viewDo(view, func(views viewMap, view C.CFTypeRef) {
+		w := views[view]
+		w.w.Event(key.FocusEvent{Focus: focus == C.YES})
+	})
+}
+
+func (w *window) draw(sync bool) {
+	w.scale = float32(C.gio_getViewBackingScale(w.view))
+	wf, hf := float32(C.gio_viewWidth(w.view)), float32(C.gio_viewHeight(w.view))
+	if wf == 0 || hf == 0 {
+		return
+	}
+	width := int(wf*w.scale + .5)
+	height := int(hf*w.scale + .5)
+	cfg := configFor(w.ppdp, w.scale)
+	cfg.now = time.Now()
+	w.setStage(system.StageRunning)
+	w.w.Event(FrameEvent{
+		FrameEvent: system.FrameEvent{
+			Size: image.Point{
+				X: width,
+				Y: height,
+			},
+			Config: &cfg,
+		},
+		Sync: sync,
+	})
+}
+
+func getPixelsPerDp(scale float32) float32 {
+	ppdp := float32(C.gio_getPixelsPerDP())
+	ppdp = ppdp * scale * monitorScale
+	if ppdp < minDensity {
+		ppdp = minDensity
+	}
+	return ppdp / scale
+}
+
+func configFor(ppdp, scale float32) config {
+	ppdp = ppdp * scale
+	return config{
+		pxPerDp: ppdp,
+		pxPerSp: ppdp,
+	}
+}
+
+//export gio_onTerminate
+func gio_onTerminate(view C.CFTypeRef) {
+	viewDo(view, func(views viewMap, view C.CFTypeRef) {
+		w := views[view]
+		delete(views, view)
+		w.w.Event(system.DestroyEvent{})
+	})
+}
+
+//export gio_onHide
+func gio_onHide(view C.CFTypeRef) {
+	viewDo(view, func(views viewMap, view C.CFTypeRef) {
+		w := views[view]
+		w.setStage(system.StagePaused)
+	})
+}
+
+//export gio_onShow
+func gio_onShow(view C.CFTypeRef) {
+	viewDo(view, func(views viewMap, view C.CFTypeRef) {
+		w := views[view]
+		w.setStage(system.StageRunning)
+	})
+}
+
+//export gio_onCreate
+func gio_onCreate(view C.CFTypeRef) {
+	viewDo(view, func(views viewMap, view C.CFTypeRef) {
+		scale := float32(C.gio_getBackingScale())
+		w := &window{
+			view:  view,
+			ppdp:  getPixelsPerDp(scale),
+			scale: scale,
+		}
+		wopts := <-mainWindow.out
+		w.w = wopts.window
+		w.w.SetDriver(w)
+		views[view] = w
+	})
+}
+
+func NewWindow(win Callbacks, opts *Options) error {
+	mainWindow.in <- windowAndOptions{win, opts}
+	return <-mainWindow.errs
+}
+
+func Main() {
+	wopts := <-mainWindow.out
+	view := viewFactory()
+	if view == 0 {
+		// TODO: return this error from CreateWindow.
+		panic(errors.New("CreateWindow: failed to create view"))
+	}
+	scale := float32(C.gio_getBackingScale())
+	ppdp := getPixelsPerDp(scale)
+	cfg := configFor(ppdp, scale)
+	opts := wopts.opts
+	w := cfg.Px(opts.Width)
+	h := cfg.Px(opts.Height)
+	// Window sizes is on screen coordinates, not device pixels.
+	w = int(float32(w) / scale)
+	h = int(float32(h) / scale)
+	title := C.CString(opts.Title)
+	defer C.free(unsafe.Pointer(title))
+	C.gio_main(view, title, C.CGFloat(w), C.CGFloat(h))
+}
+
+func convertKey(k rune) (rune, bool) {
+	if '0' <= k && k <= '9' || 'A' <= k && k <= 'Z' {
+		return k, true
+	}
+	if 'a' <= k && k <= 'z' {
+		return k - 0x20, true
+	}
+	var n rune
+	switch k {
+	case 0x1b:
+		n = key.NameEscape
+	case C.NSLeftArrowFunctionKey:
+		n = key.NameLeftArrow
+	case C.NSRightArrowFunctionKey:
+		n = key.NameRightArrow
+	case C.NSUpArrowFunctionKey:
+		n = key.NameUpArrow
+	case C.NSDownArrowFunctionKey:
+		n = key.NameDownArrow
+	case 0xd:
+		n = key.NameReturn
+	case C.NSHomeFunctionKey:
+		n = key.NameHome
+	case C.NSEndFunctionKey:
+		n = key.NameEnd
+	case 0x7f:
+		n = key.NameDeleteBackward
+	case C.NSDeleteFunctionKey:
+		n = key.NameDeleteForward
+	case C.NSPageUpFunctionKey:
+		n = key.NamePageUp
+	case C.NSPageDownFunctionKey:
+		n = key.NamePageDown
+	default:
+		return 0, false
+	}
+	return n, true
+}

app/internal/window/os_macos.h

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+#ifndef _OS_MACOS_H
+#define _OS_MACOS_H
+
+#define GIO_MOUSE_MOVE 1
+#define GIO_MOUSE_UP 2
+#define GIO_MOUSE_DOWN 3
+
+__attribute__ ((visibility ("hidden"))) void gio_main(CFTypeRef viewRef, const char *title, CGFloat width, CGFloat height);
+__attribute__ ((visibility ("hidden"))) CGFloat gio_viewWidth(CFTypeRef viewRef);
+__attribute__ ((visibility ("hidden"))) CGFloat gio_viewHeight(CFTypeRef viewRef);
+__attribute__ ((visibility ("hidden"))) void gio_setAnimating(CFTypeRef viewRef, BOOL anim);
+__attribute__ ((visibility ("hidden"))) void gio_updateDisplayLink(CFTypeRef viewRef, CGDirectDisplayID dispID);
+__attribute__ ((visibility ("hidden"))) CGFloat gio_getPixelsPerDP(void);
+__attribute__ ((visibility ("hidden"))) CGFloat gio_getBackingScale(void);
+__attribute__ ((visibility ("hidden"))) CGFloat gio_getViewBackingScale(CFTypeRef viewRef);
+
+#endif

app/internal/window/os_macos.m

@@ -0,0 +1,130 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build darwin,!ios
+
+@import AppKit;
+
+#include "os_macos.h"
+#include "_cgo_export.h"
+
+@interface GioDelegate : NSObject<NSApplicationDelegate, NSWindowDelegate>
+@property (strong,nonatomic) NSWindow *window;
+@end
+
+@implementation GioDelegate
+- (void)applicationDidFinishLaunching:(NSNotification *)aNotification {
+	[[NSRunningApplication currentApplication] activateWithOptions:(NSApplicationActivateAllWindows | NSApplicationActivateIgnoringOtherApps)];
+	[self.window makeKeyAndOrderFront:self];
+	gio_onShow((__bridge CFTypeRef)self.window.contentView);
+}
+- (void)applicationDidHide:(NSNotification *)aNotification {
+	gio_onHide((__bridge CFTypeRef)self.window.contentView);
+}
+- (void)applicationWillUnhide:(NSNotification *)notification {
+	gio_onShow((__bridge CFTypeRef)self.window.contentView);
+}
+- (void)windowWillMiniaturize:(NSNotification *)notification {
+	gio_onHide((__bridge CFTypeRef)self.window.contentView);
+}
+- (void)windowDidDeminiaturize:(NSNotification *)notification {
+	gio_onShow((__bridge CFTypeRef)self.window.contentView);
+}
+- (void)windowDidChangeScreen:(NSNotification *)notification {
+	CGDirectDisplayID dispID = [[[self.window screen] deviceDescription][@"NSScreenNumber"] unsignedIntValue];
+	CFTypeRef view = (__bridge CFTypeRef)self.window.contentView;
+	gio_updateDisplayLink(view, dispID);
+}
+- (void)windowDidBecomeKey:(NSNotification *)notification {
+	gio_onFocus((__bridge CFTypeRef)self.window.contentView, YES);
+}
+- (void)windowDidResignKey:(NSNotification *)notification {
+	gio_onFocus((__bridge CFTypeRef)self.window.contentView, NO);
+}
+- (void)windowWillClose:(NSNotification *)notification {
+	gio_onTerminate((__bridge CFTypeRef)self.window.contentView);
+	self.window.delegate = nil;
+	[NSApp terminate:nil];
+}
+@end
+
+CGFloat gio_viewHeight(CFTypeRef viewRef) {
+	NSView *view = (__bridge NSView *)viewRef;
+	return [view bounds].size.height;
+}
+
+CGFloat gio_viewWidth(CFTypeRef viewRef) {
+	NSView *view = (__bridge NSView *)viewRef;
+	return [view bounds].size.width;
+}
+
+// Points pr. dp.
+static CGFloat getPointsPerDP(NSScreen *screen) {
+	NSDictionary *description = [screen deviceDescription];
+	NSSize displayPixelSize = [[description objectForKey:NSDeviceSize] sizeValue];
+	CGSize displayPhysicalSize = CGDisplayScreenSize([[description objectForKey:@"NSScreenNumber"] unsignedIntValue]);
+	return (25.4/160)*displayPixelSize.width / displayPhysicalSize.width;
+}
+
+// Pixels pr dp.
+CGFloat gio_getPixelsPerDP(void) {
+	NSScreen *screen = [NSScreen mainScreen];
+	return getPointsPerDP(screen);
+}
+
+CGFloat gio_getBackingScale() {
+	NSScreen *screen = [NSScreen mainScreen];
+	return [screen backingScaleFactor];
+}
+
+CGFloat gio_getViewBackingScale(CFTypeRef viewRef) {
+	NSView *view = (__bridge NSView *)viewRef;
+	return [view.window backingScaleFactor];
+}
+
+void gio_main(CFTypeRef viewRef, const char *title, CGFloat width, CGFloat height) {
+	@autoreleasepool {
+		NSView *view = (NSView *)CFBridgingRelease(viewRef);
+		[NSApplication sharedApplication];
+		[NSApp setActivationPolicy:NSApplicationActivationPolicyRegular];
+
+		NSMenuItem *mainMenu = [NSMenuItem new];
+
+		NSMenu *menu = [NSMenu new];
+		NSMenuItem *hideMenuItem = [[NSMenuItem alloc] initWithTitle:@"Hide"
+															  action:@selector(hide:)
+													   keyEquivalent:@"h"];
+		[menu addItem:hideMenuItem];
+		NSMenuItem *quitMenuItem = [[NSMenuItem alloc] initWithTitle:@"Quit"
+															  action:@selector(terminate:)
+													   keyEquivalent:@"q"];
+		[menu addItem:quitMenuItem];
+		[mainMenu setSubmenu:menu];
+		NSMenu *menuBar = [NSMenu new];
+		[menuBar addItem:mainMenu];
+		[NSApp setMainMenu:menuBar];
+
+		NSRect rect = NSMakeRect(0, 0, width, height);
+		NSUInteger styleMask = NSTitledWindowMask |
+			NSResizableWindowMask |
+			NSMiniaturizableWindowMask |
+			NSClosableWindowMask;
+		NSWindow* window = [[NSWindow alloc] initWithContentRect:rect
+													   styleMask:styleMask
+														 backing:NSBackingStoreBuffered
+														   defer:NO];
+		window.title = [NSString stringWithUTF8String: title];
+		[window cascadeTopLeftFromPoint:NSMakePoint(20,20)];
+		[window setAcceptsMouseMovedEvents:YES];
+
+		gio_onCreate((__bridge CFTypeRef)view);
+		GioDelegate *del = [[GioDelegate alloc] init];
+		del.window = window;
+		[window setDelegate:del];
+		[NSApp setDelegate:del];
+		[window setContentView:view];
+		[window makeFirstResponder:view];
+
+
+		[NSApp run];
+	}
+}

app/internal/window/os_wayland.c

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build linux,!android
+
+#include <wayland-client.h>
+#include "wayland_xdg_shell.h"
+#include "wayland_text_input.h"
+#include "os_wayland.h"
+#include "_cgo_export.h"
+
+static const struct wl_registry_listener registry_listener = {
+	// Cast away const parameter.
+	.global = (void (*)(void *, struct wl_registry *, uint32_t,  const char *, uint32_t))gio_onRegistryGlobal,
+	.global_remove = gio_onRegistryGlobalRemove
+};
+
+void gio_wl_registry_add_listener(struct wl_registry *reg) {
+	wl_registry_add_listener(reg, &registry_listener, NULL);
+}
+
+static struct wl_surface_listener surface_listener = {.enter = gio_onSurfaceEnter, .leave = gio_onSurfaceLeave};
+
+void gio_wl_surface_add_listener(struct wl_surface *surface) {
+	wl_surface_add_listener(surface, &surface_listener, NULL);
+}
+
+static const struct xdg_surface_listener xdg_surface_listener = {
+	.configure = gio_onXdgSurfaceConfigure,
+};
+
+void gio_xdg_surface_add_listener(struct xdg_surface *surface) {
+	xdg_surface_add_listener(surface, &xdg_surface_listener, NULL);
+}
+
+static const struct xdg_toplevel_listener xdg_toplevel_listener = {
+	.configure = gio_onToplevelConfigure,
+	.close = gio_onToplevelClose,
+};
+
+void gio_xdg_toplevel_add_listener(struct xdg_toplevel *toplevel) {
+	xdg_toplevel_add_listener(toplevel, &xdg_toplevel_listener, NULL);
+}
+
+static void xdg_wm_base_handle_ping(void *data, struct xdg_wm_base *wm, uint32_t serial) {
+	xdg_wm_base_pong(wm, serial);
+}
+static const struct xdg_wm_base_listener xdg_wm_base_listener = {
+	.ping = xdg_wm_base_handle_ping,
+};
+
+void gio_xdg_wm_base_add_listener(struct xdg_wm_base *wm) {
+	xdg_wm_base_add_listener(wm, &xdg_wm_base_listener, NULL);
+}
+
+static const struct wl_callback_listener wl_callback_listener = {
+	.done = gio_onFrameDone,
+};
+
+void gio_wl_callback_add_listener(struct wl_callback *callback, void *data) {
+	wl_callback_add_listener(callback, &wl_callback_listener, data);
+}
+
+static const struct wl_output_listener wl_output_listener = {
+	// Cast away const parameter.
+	.geometry = (void (*)(void *, struct wl_output *, int32_t,  int32_t,  int32_t,  int32_t,  int32_t,  const char *, const char *, int32_t))gio_onOutputGeometry,
+	.mode = gio_onOutputMode,
+	.done = gio_onOutputDone,
+	.scale = gio_onOutputScale,
+};
+
+void gio_wl_output_add_listener(struct wl_output *output) {
+	wl_output_add_listener(output, &wl_output_listener, NULL);
+}
+
+static const struct wl_seat_listener wl_seat_listener = {
+	.capabilities = gio_onSeatCapabilities,
+	// Cast away const parameter.
+	.name = (void (*)(void *, struct wl_seat *, const char *))gio_onSeatName,
+};
+
+void gio_wl_seat_add_listener(struct wl_seat *seat) {
+	wl_seat_add_listener(seat, &wl_seat_listener, NULL);
+}
+
+static const struct wl_pointer_listener wl_pointer_listener = {
+	.enter = gio_onPointerEnter,
+	.leave = gio_onPointerLeave,
+	.motion = gio_onPointerMotion,
+	.button = gio_onPointerButton,
+	.axis = gio_onPointerAxis,
+	.frame = gio_onPointerFrame,
+	.axis_source = gio_onPointerAxisSource,
+	.axis_stop = gio_onPointerAxisStop,
+	.axis_discrete = gio_onPointerAxisDiscrete,
+};
+
+void gio_wl_pointer_add_listener(struct wl_pointer *pointer) {
+	wl_pointer_add_listener(pointer, &wl_pointer_listener, NULL);
+}
+
+static const struct wl_touch_listener wl_touch_listener = {
+	.down = gio_onTouchDown,
+	.up = gio_onTouchUp,
+	.motion = gio_onTouchMotion,
+	.frame = gio_onTouchFrame,
+	.cancel = gio_onTouchCancel,
+};
+
+void gio_wl_touch_add_listener(struct wl_touch *touch) {
+	wl_touch_add_listener(touch, &wl_touch_listener, NULL);
+}
+
+static const struct wl_keyboard_listener wl_keyboard_listener = {
+	.keymap = gio_onKeyboardKeymap,
+	.enter = gio_onKeyboardEnter,
+	.leave = gio_onKeyboardLeave,
+	.key = gio_onKeyboardKey,
+	.modifiers = gio_onKeyboardModifiers,
+	.repeat_info = gio_onKeyboardRepeatInfo
+};
+
+void gio_wl_keyboard_add_listener(struct wl_keyboard *keyboard) {
+	wl_keyboard_add_listener(keyboard, &wl_keyboard_listener, NULL);
+}
+
+static const struct zwp_text_input_v3_listener zwp_text_input_v3_listener = {
+	.enter = gio_onTextInputEnter,
+	.leave = gio_onTextInputLeave,
+	// Cast away const parameter.
+	.preedit_string = (void (*)(void *, struct zwp_text_input_v3 *, const char *, int32_t,  int32_t))gio_onTextInputPreeditString,
+	.commit_string = (void (*)(void *, struct zwp_text_input_v3 *, const char *))gio_onTextInputCommitString,
+	.delete_surrounding_text = gio_onTextInputDeleteSurroundingText,
+	.done = gio_onTextInputDone
+};
+
+void gio_zwp_text_input_v3_add_listener(struct zwp_text_input_v3 *im) {
+	zwp_text_input_v3_add_listener(im, &zwp_text_input_v3_listener, NULL);
+}

app/internal/window/os_wayland.h

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+__attribute__ ((visibility ("hidden"))) void gio_wl_registry_add_listener(struct wl_registry *reg);
+__attribute__ ((visibility ("hidden"))) void gio_wl_surface_add_listener(struct wl_surface *surface);
+__attribute__ ((visibility ("hidden"))) void gio_xdg_surface_add_listener(struct xdg_surface *surface);
+__attribute__ ((visibility ("hidden"))) void gio_xdg_toplevel_add_listener(struct xdg_toplevel *toplevel);
+__attribute__ ((visibility ("hidden"))) void gio_xdg_wm_base_add_listener(struct xdg_wm_base *wm);
+__attribute__ ((visibility ("hidden"))) void gio_wl_callback_add_listener(struct wl_callback *callback, void *data);
+__attribute__ ((visibility ("hidden"))) void gio_wl_output_add_listener(struct wl_output *output);
+__attribute__ ((visibility ("hidden"))) void gio_wl_seat_add_listener(struct wl_seat *seat);
+__attribute__ ((visibility ("hidden"))) void gio_wl_pointer_add_listener(struct wl_pointer *pointer);
+__attribute__ ((visibility ("hidden"))) void gio_wl_touch_add_listener(struct wl_touch *touch);
+__attribute__ ((visibility ("hidden"))) void gio_wl_keyboard_add_listener(struct wl_keyboard *keyboard);
+__attribute__ ((visibility ("hidden"))) void gio_zwp_text_input_v3_add_listener(struct zwp_text_input_v3 *im);

app/internal/window/os_windows.go

@@ -0,0 +1,735 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+package window
+
+import (
+	"errors"
+	"fmt"
+	"image"
+	"runtime"
+	"sync"
+	"time"
+	"unicode"
+	"unsafe"
+
+	syscall "golang.org/x/sys/windows"
+
+	"gioui.org/f32"
+	"gioui.org/io/key"
+	"gioui.org/io/pointer"
+	"gioui.org/io/system"
+)
+
+var winMap = make(map[syscall.Handle]*window)
+
+type rect struct {
+	left, top, right, bottom int32
+}
+
+type wndClassEx struct {
+	cbSize        uint32
+	style         uint32
+	lpfnWndProc   uintptr
+	cnClsExtra    int32
+	cbWndExtra    int32
+	hInstance     syscall.Handle
+	hIcon         syscall.Handle
+	hCursor       syscall.Handle
+	hbrBackground syscall.Handle
+	lpszMenuName  *uint16
+	lpszClassName *uint16
+	hIconSm       syscall.Handle
+}
+
+type msg struct {
+	hwnd     syscall.Handle
+	message  uint32
+	wParam   uintptr
+	lParam   uintptr
+	time     uint32
+	pt       point
+	lPrivate uint32
+}
+
+type point struct {
+	x, y int32
+}
+
+type window struct {
+	hwnd   syscall.Handle
+	hdc    syscall.Handle
+	w      Callbacks
+	width  int
+	height int
+	stage  system.Stage
+	dead   bool
+
+	mu        sync.Mutex
+	animating bool
+}
+
+const (
+	_CS_HREDRAW = 0x0002
+	_CS_VREDRAW = 0x0001
+	_CS_OWNDC   = 0x0020
+
+	_CW_USEDEFAULT = -2147483648
+
+	_IDC_ARROW = 32512
+
+	_INFINITE = 0xFFFFFFFF
+
+	_LOGPIXELSX = 88
+
+	_SIZE_MAXIMIZED = 2
+	_SIZE_MINIMIZED = 1
+	_SIZE_RESTORED  = 0
+
+	_SW_SHOWDEFAULT = 10
+
+	_USER_TIMER_MINIMUM = 0x0000000A
+
+	_VK_CONTROL = 0x11
+	_VK_SHIFT   = 0x10
+
+	_VK_BACK   = 0x08
+	_VK_DELETE = 0x2e
+	_VK_DOWN   = 0x28
+	_VK_END    = 0x23
+	_VK_ESCAPE = 0x1b
+	_VK_HOME   = 0x24
+	_VK_LEFT   = 0x25
+	_VK_NEXT   = 0x22
+	_VK_PRIOR  = 0x21
+	_VK_RIGHT  = 0x27
+	_VK_RETURN = 0x0d
+	_VK_UP     = 0x26
+
+	_UNICODE_NOCHAR = 65535
+
+	_WM_CANCELMODE  = 0x001F
+	_WM_CHAR        = 0x0102
+	_WM_CREATE      = 0x0001
+	_WM_DESTROY     = 0x0002
+	_WM_KEYDOWN     = 0x0100
+	_WM_KEYUP       = 0x0101
+	_WM_LBUTTONDOWN = 0x0201
+	_WM_LBUTTONUP   = 0x0202
+	_WM_MOUSEMOVE   = 0x0200
+	_WM_MOUSEWHEEL  = 0x020A
+	_WM_PAINT       = 0x000F
+	_WM_QUIT        = 0x0012
+	_WM_SETFOCUS    = 0x0007
+	_WM_KILLFOCUS   = 0x0008
+	_WM_SHOWWINDOW  = 0x0018
+	_WM_SIZE        = 0x0005
+	_WM_SYSKEYDOWN  = 0x0104
+	_WM_TIMER       = 0x0113
+	_WM_UNICHAR     = 0x0109
+	_WM_USER        = 0x0400
+
+	_WS_CLIPCHILDREN     = 0x00010000
+	_WS_CLIPSIBLINGS     = 0x04000000
+	_WS_VISIBLE          = 0x10000000
+	_WS_OVERLAPPED       = 0x00000000
+	_WS_OVERLAPPEDWINDOW = _WS_OVERLAPPED | _WS_CAPTION | _WS_SYSMENU | _WS_THICKFRAME |
+		_WS_MINIMIZEBOX | _WS_MAXIMIZEBOX
+	_WS_CAPTION     = 0x00C00000
+	_WS_SYSMENU     = 0x00080000
+	_WS_THICKFRAME  = 0x00040000
+	_WS_MINIMIZEBOX = 0x00020000
+	_WS_MAXIMIZEBOX = 0x00010000
+
+	_WS_EX_APPWINDOW  = 0x00040000
+	_WS_EX_WINDOWEDGE = 0x00000100
+
+	_QS_ALLINPUT = 0x04FF
+
+	_MWMO_WAITALL        = 0x0001
+	_MWMO_INPUTAVAILABLE = 0x0004
+
+	_WAIT_OBJECT_0 = 0
+
+	_PM_REMOVE   = 0x0001
+	_PM_NOREMOVE = 0x0000
+)
+
+const _WM_REDRAW = _WM_USER + 0
+
+var onceMu sync.Mutex
+var mainDone = make(chan struct{})
+
+func Main() {
+	<-mainDone
+}
+
+func NewWindow(window Callbacks, opts *Options) error {
+	onceMu.Lock()
+	defer onceMu.Unlock()
+	if len(winMap) > 0 {
+		return errors.New("multiple windows are not supported")
+	}
+	cerr := make(chan error)
+	go func() {
+		// Call win32 API from a single OS thread.
+		runtime.LockOSThread()
+		w, err := createNativeWindow(opts)
+		if err != nil {
+			cerr <- err
+			return
+		}
+		defer w.destroy()
+		cerr <- nil
+		winMap[w.hwnd] = w
+		defer delete(winMap, w.hwnd)
+		w.w = window
+		w.w.SetDriver(w)
+		defer w.w.Event(system.DestroyEvent{})
+		showWindow(w.hwnd, _SW_SHOWDEFAULT)
+		setForegroundWindow(w.hwnd)
+		setFocus(w.hwnd)
+		if err := w.loop(); err != nil {
+			panic(err)
+		}
+		close(mainDone)
+	}()
+	return <-cerr
+}
+
+func createNativeWindow(opts *Options) (*window, error) {
+	setProcessDPIAware()
+	screenDC, err := getDC(0)
+	if err != nil {
+		return nil, err
+	}
+	cfg := configForDC(screenDC)
+	releaseDC(screenDC)
+	hInst, err := getModuleHandle()
+	if err != nil {
+		return nil, err
+	}
+	curs, err := loadCursor(_IDC_ARROW)
+	if err != nil {
+		return nil, err
+	}
+	wcls := wndClassEx{
+		cbSize:        uint32(unsafe.Sizeof(wndClassEx{})),
+		style:         _CS_HREDRAW | _CS_VREDRAW | _CS_OWNDC,
+		lpfnWndProc:   syscall.NewCallback(windowProc),
+		hInstance:     hInst,
+		hCursor:       curs,
+		lpszClassName: syscall.StringToUTF16Ptr("GioWindow"),
+	}
+	cls, err := registerClassEx(&wcls)
+	if err != nil {
+		return nil, err
+	}
+	wr := rect{
+		right:  int32(cfg.Px(opts.Width)),
+		bottom: int32(cfg.Px(opts.Height)),
+	}
+	dwStyle := uint32(_WS_OVERLAPPEDWINDOW)
+	dwExStyle := uint32(_WS_EX_APPWINDOW | _WS_EX_WINDOWEDGE)
+	adjustWindowRectEx(&wr, dwStyle, 0, dwExStyle)
+	hwnd, err := createWindowEx(dwExStyle,
+		cls,
+		opts.Title,
+		dwStyle|_WS_CLIPSIBLINGS|_WS_CLIPCHILDREN,
+		_CW_USEDEFAULT, _CW_USEDEFAULT,
+		wr.right-wr.left,
+		wr.bottom-wr.top,
+		0,
+		0,
+		hInst,
+		0)
+	if err != nil {
+		return nil, err
+	}
+	w := &window{
+		hwnd: hwnd,
+	}
+	w.hdc, err = getDC(hwnd)
+	if err != nil {
+		return nil, err
+	}
+	return w, nil
+}
+
+func windowProc(hwnd syscall.Handle, msg uint32, wParam, lParam uintptr) uintptr {
+	w := winMap[hwnd]
+	switch msg {
+	case _WM_UNICHAR:
+		if wParam == _UNICODE_NOCHAR {
+			// Tell the system that we accept WM_UNICHAR messages.
+			return 1
+		}
+		fallthrough
+	case _WM_CHAR:
+		if r := rune(wParam); unicode.IsPrint(r) {
+			w.w.Event(key.EditEvent{Text: string(r)})
+		}
+		// The message is processed.
+		return 1
+	case _WM_KEYDOWN, _WM_SYSKEYDOWN:
+		if n, ok := convertKeyCode(wParam); ok {
+			cmd := key.Event{Name: n}
+			if getKeyState(_VK_CONTROL)&0x1000 != 0 {
+				cmd.Modifiers |= key.ModCommand
+			}
+			if getKeyState(_VK_SHIFT)&0x1000 != 0 {
+				cmd.Modifiers |= key.ModShift
+			}
+			w.w.Event(cmd)
+		}
+	case _WM_LBUTTONDOWN:
+		setCapture(w.hwnd)
+		x, y := coordsFromlParam(lParam)
+		p := f32.Point{X: float32(x), Y: float32(y)}
+		w.w.Event(pointer.Event{
+			Type:     pointer.Press,
+			Source:   pointer.Mouse,
+			Position: p,
+			Time:     getMessageTime(),
+		})
+	case _WM_CANCELMODE:
+		w.w.Event(pointer.Event{
+			Type: pointer.Cancel,
+		})
+	case _WM_SETFOCUS:
+		w.w.Event(key.FocusEvent{Focus: true})
+	case _WM_KILLFOCUS:
+		w.w.Event(key.FocusEvent{Focus: false})
+	case _WM_LBUTTONUP:
+		releaseCapture()
+		x, y := coordsFromlParam(lParam)
+		p := f32.Point{X: float32(x), Y: float32(y)}
+		w.w.Event(pointer.Event{
+			Type:     pointer.Release,
+			Source:   pointer.Mouse,
+			Position: p,
+			Time:     getMessageTime(),
+		})
+	case _WM_MOUSEMOVE:
+		x, y := coordsFromlParam(lParam)
+		p := f32.Point{X: float32(x), Y: float32(y)}
+		w.w.Event(pointer.Event{
+			Type:     pointer.Move,
+			Source:   pointer.Mouse,
+			Position: p,
+			Time:     getMessageTime(),
+		})
+	case _WM_MOUSEWHEEL:
+		w.scrollEvent(wParam, lParam)
+	case _WM_DESTROY:
+		w.dead = true
+	case _WM_PAINT:
+		w.draw(true)
+	case _WM_SIZE:
+		switch wParam {
+		case _SIZE_MINIMIZED:
+			w.setStage(system.StagePaused)
+		case _SIZE_MAXIMIZED, _SIZE_RESTORED:
+			w.setStage(system.StageRunning)
+			w.draw(true)
+		}
+	}
+	return defWindowProc(hwnd, msg, wParam, lParam)
+}
+
+func coordsFromlParam(lParam uintptr) (int, int) {
+	x := int(int16(lParam & 0xffff))
+	y := int(int16((lParam >> 16) & 0xffff))
+	return x, y
+}
+
+func (w *window) scrollEvent(wParam, lParam uintptr) {
+	x, y := coordsFromlParam(lParam)
+	// The WM_MOUSEWHEEL coordinates are in screen coordinates, in contrast
+	// to other mouse events.
+	np := point{x: int32(x), y: int32(y)}
+	screenToClient(w.hwnd, &np)
+	p := f32.Point{X: float32(np.x), Y: float32(np.y)}
+	dist := float32(int16(wParam >> 16))
+	w.w.Event(pointer.Event{
+		Type:     pointer.Move,
+		Source:   pointer.Mouse,
+		Position: p,
+		Scroll:   f32.Point{Y: -dist},
+		Time:     getMessageTime(),
+	})
+}
+
+// Adapted from https://blogs.msdn.microsoft.com/oldnewthing/20060126-00/?p=32513/
+func (w *window) loop() error {
+	msg := new(msg)
+	for !w.dead {
+		w.mu.Lock()
+		anim := w.animating
+		w.mu.Unlock()
+		if anim && !peekMessage(msg, w.hwnd, 0, 0, _PM_NOREMOVE) {
+			w.draw(false)
+			continue
+		}
+		getMessage(msg, w.hwnd, 0, 0)
+		if msg.message == _WM_QUIT {
+			postQuitMessage(msg.wParam)
+			break
+		}
+		translateMessage(msg)
+		dispatchMessage(msg)
+	}
+	return nil
+}
+
+func (w *window) SetAnimating(anim bool) {
+	w.mu.Lock()
+	w.animating = anim
+	w.mu.Unlock()
+	if anim {
+		w.postRedraw()
+	}
+}
+
+func (w *window) postRedraw() {
+	if err := postMessage(w.hwnd, _WM_REDRAW, 0, 0); err != nil {
+		panic(err)
+	}
+}
+
+func (w *window) setStage(s system.Stage) {
+	w.stage = s
+	w.w.Event(system.StageEvent{Stage: s})
+}
+
+func (w *window) draw(sync bool) {
+	var r rect
+	getClientRect(w.hwnd, &r)
+	w.width = int(r.right - r.left)
+	w.height = int(r.bottom - r.top)
+	cfg := configForDC(w.hdc)
+	cfg.now = time.Now()
+	w.w.Event(FrameEvent{
+		FrameEvent: system.FrameEvent{
+			Size: image.Point{
+				X: w.width,
+				Y: w.height,
+			},
+			Config: &cfg,
+		},
+		Sync: sync,
+	})
+}
+
+func (w *window) destroy() {
+	if w.hdc != 0 {
+		releaseDC(w.hdc)
+		w.hdc = 0
+	}
+	if w.hwnd != 0 {
+		destroyWindow(w.hwnd)
+		w.hwnd = 0
+	}
+}
+
+func (w *window) ShowTextInput(show bool) {}
+
+func (w *window) HDC() syscall.Handle {
+	return w.hdc
+}
+
+func (w *window) HWND() (syscall.Handle, int, int) {
+	return w.hwnd, w.width, w.height
+}
+
+func convertKeyCode(code uintptr) (rune, bool) {
+	if '0' <= code && code <= '9' || 'A' <= code && code <= 'Z' {
+		return rune(code), true
+	}
+	var r rune
+	switch code {
+	case _VK_ESCAPE:
+		r = key.NameEscape
+	case _VK_LEFT:
+		r = key.NameLeftArrow
+	case _VK_RIGHT:
+		r = key.NameRightArrow
+	case _VK_RETURN:
+		r = key.NameReturn
+	case _VK_UP:
+		r = key.NameUpArrow
+	case _VK_DOWN:
+		r = key.NameDownArrow
+	case _VK_HOME:
+		r = key.NameHome
+	case _VK_END:
+		r = key.NameEnd
+	case _VK_BACK:
+		r = key.NameDeleteBackward
+	case _VK_DELETE:
+		r = key.NameDeleteForward
+	case _VK_PRIOR:
+		r = key.NamePageUp
+	case _VK_NEXT:
+		r = key.NamePageDown
+	default:
+		return 0, false
+	}
+	return r, true
+}
+
+func configForDC(hdc syscall.Handle) config {
+	dpi := getDeviceCaps(hdc, _LOGPIXELSX)
+	ppdp := float32(dpi) * inchPrDp * monitorScale
+	// Force a minimum density to keep text legible and to handle bogus output geometry.
+	if ppdp < minDensity {
+		ppdp = minDensity
+	}
+	return config{
+		pxPerDp: ppdp,
+		pxPerSp: ppdp,
+	}
+}
+
+var (
+	kernel32          = syscall.NewLazySystemDLL("kernel32.dll")
+	_GetModuleHandleW = kernel32.NewProc("GetModuleHandleW")
+
+	user32                       = syscall.NewLazySystemDLL("user32.dll")
+	_AdjustWindowRectEx          = user32.NewProc("AdjustWindowRectEx")
+	_CallMsgFilter               = user32.NewProc("CallMsgFilterW")
+	_CreateWindowEx              = user32.NewProc("CreateWindowExW")
+	_DefWindowProc               = user32.NewProc("DefWindowProcW")
+	_DestroyWindow               = user32.NewProc("DestroyWindow")
+	_DispatchMessage             = user32.NewProc("DispatchMessageW")
+	_GetClientRect               = user32.NewProc("GetClientRect")
+	_GetDC                       = user32.NewProc("GetDC")
+	_GetKeyState                 = user32.NewProc("GetKeyState")
+	_GetMessage                  = user32.NewProc("GetMessageW")
+	_GetMessageTime              = user32.NewProc("GetMessageTime")
+	_KillTimer                   = user32.NewProc("KillTimer")
+	_LoadCursor                  = user32.NewProc("LoadCursorW")
+	_MsgWaitForMultipleObjectsEx = user32.NewProc("MsgWaitForMultipleObjectsEx")
+	_PeekMessage                 = user32.NewProc("PeekMessageW")
+	_PostMessage                 = user32.NewProc("PostMessageW")
+	_PostQuitMessage             = user32.NewProc("PostQuitMessage")
+	_ReleaseCapture              = user32.NewProc("ReleaseCapture")
+	_RegisterClassExW            = user32.NewProc("RegisterClassExW")
+	_ReleaseDC                   = user32.NewProc("ReleaseDC")
+	_ScreenToClient              = user32.NewProc("ScreenToClient")
+	_ShowWindow                  = user32.NewProc("ShowWindow")
+	_SetCapture                  = user32.NewProc("SetCapture")
+	_SetForegroundWindow         = user32.NewProc("SetForegroundWindow")
+	_SetFocus                    = user32.NewProc("SetFocus")
+	_SetProcessDPIAware          = user32.NewProc("SetProcessDPIAware")
+	_SetTimer                    = user32.NewProc("SetTimer")
+	_TranslateMessage            = user32.NewProc("TranslateMessage")
+	_UnregisterClass             = user32.NewProc("UnregisterClassW")
+	_UpdateWindow                = user32.NewProc("UpdateWindow")
+
+	gdi32          = syscall.NewLazySystemDLL("gdi32")
+	_GetDeviceCaps = gdi32.NewProc("GetDeviceCaps")
+)
+
+func getModuleHandle() (syscall.Handle, error) {
+	h, _, err := _GetModuleHandleW.Call(uintptr(0))
+	if h == 0 {
+		return 0, fmt.Errorf("GetModuleHandleW failed: %v", err)
+	}
+	return syscall.Handle(h), nil
+}
+
+func adjustWindowRectEx(r *rect, dwStyle uint32, bMenu int, dwExStyle uint32) {
+	_AdjustWindowRectEx.Call(uintptr(unsafe.Pointer(r)), uintptr(dwStyle), uintptr(bMenu), uintptr(dwExStyle))
+	issue34474KeepAlive(r)
+}
+
+func callMsgFilter(m *msg, nCode uintptr) bool {
+	r, _, _ := _CallMsgFilter.Call(uintptr(unsafe.Pointer(m)), nCode)
+	issue34474KeepAlive(m)
+	return r != 0
+}
+
+func createWindowEx(dwExStyle uint32, lpClassName uint16, lpWindowName string, dwStyle uint32, x, y, w, h int32, hWndParent, hMenu, hInstance syscall.Handle, lpParam uintptr) (syscall.Handle, error) {
+	wname := syscall.StringToUTF16Ptr(lpWindowName)
+	hwnd, _, err := _CreateWindowEx.Call(
+		uintptr(dwExStyle),
+		uintptr(lpClassName),
+		uintptr(unsafe.Pointer(wname)),
+		uintptr(dwStyle),
+		uintptr(x), uintptr(y),
+		uintptr(w), uintptr(h),
+		uintptr(hWndParent),
+		uintptr(hMenu),
+		uintptr(hInstance),
+		uintptr(lpParam))
+	issue34474KeepAlive(wname)
+	if hwnd == 0 {
+		return 0, fmt.Errorf("CreateWindowEx failed: %v", err)
+	}
+	return syscall.Handle(hwnd), nil
+}
+
+func defWindowProc(hwnd syscall.Handle, msg uint32, wparam, lparam uintptr) uintptr {
+	r, _, _ := _DefWindowProc.Call(uintptr(hwnd), uintptr(msg), wparam, lparam)
+	return r
+}
+
+func destroyWindow(hwnd syscall.Handle) {
+	_DestroyWindow.Call(uintptr(hwnd))
+}
+
+func dispatchMessage(m *msg) {
+	_DispatchMessage.Call(uintptr(unsafe.Pointer(m)))
+	issue34474KeepAlive(m)
+}
+
+func getClientRect(hwnd syscall.Handle, r *rect) {
+	_GetClientRect.Call(uintptr(hwnd), uintptr(unsafe.Pointer(r)))
+	issue34474KeepAlive(r)
+}
+
+func getDC(hwnd syscall.Handle) (syscall.Handle, error) {
+	hdc, _, err := _GetDC.Call(uintptr(hwnd))
+	if hdc == 0 {
+		return 0, fmt.Errorf("GetDC failed: %v", err)
+	}
+	return syscall.Handle(hdc), nil
+}
+
+func getDeviceCaps(hdc syscall.Handle, index int32) int {
+	c, _, _ := _GetDeviceCaps.Call(uintptr(hdc), uintptr(index))
+	return int(c)
+}
+
+func getKeyState(nVirtKey int32) int16 {
+	c, _, _ := _GetKeyState.Call(uintptr(nVirtKey))
+	return int16(c)
+}
+
+func getMessage(m *msg, hwnd syscall.Handle, wMsgFilterMin, wMsgFilterMax uint32) int32 {
+	r, _, _ := _GetMessage.Call(uintptr(unsafe.Pointer(m)),
+		uintptr(hwnd),
+		uintptr(wMsgFilterMin),
+		uintptr(wMsgFilterMax))
+	issue34474KeepAlive(m)
+	return int32(r)
+}
+
+func getMessageTime() time.Duration {
+	r, _, _ := _GetMessageTime.Call()
+	return time.Duration(r) * time.Millisecond
+}
+
+func killTimer(hwnd syscall.Handle, nIDEvent uintptr) error {
+	r, _, err := _SetTimer.Call(uintptr(hwnd), uintptr(nIDEvent), 0, 0)
+	if r == 0 {
+		return fmt.Errorf("KillTimer failed: %v", err)
+	}
+	return nil
+}
+
+func loadCursor(curID uint16) (syscall.Handle, error) {
+	h, _, err := _LoadCursor.Call(0, uintptr(curID))
+	if h == 0 {
+		return 0, fmt.Errorf("LoadCursorW failed: %v", err)
+	}
+	return syscall.Handle(h), nil
+}
+
+func msgWaitForMultipleObjectsEx(nCount uint32, pHandles uintptr, millis, mask, flags uint32) (uint32, error) {
+	r, _, err := _MsgWaitForMultipleObjectsEx.Call(uintptr(nCount), pHandles, uintptr(millis), uintptr(mask), uintptr(flags))
+	res := uint32(r)
+	if res == 0xFFFFFFFF {
+		return 0, fmt.Errorf("MsgWaitForMultipleObjectsEx failed: %v", err)
+	}
+	return res, nil
+}
+
+func peekMessage(m *msg, hwnd syscall.Handle, wMsgFilterMin, wMsgFilterMax, wRemoveMsg uint32) bool {
+	r, _, _ := _PeekMessage.Call(uintptr(unsafe.Pointer(m)), uintptr(hwnd), uintptr(wMsgFilterMin), uintptr(wMsgFilterMax), uintptr(wRemoveMsg))
+	issue34474KeepAlive(m)
+	return r != 0
+}
+
+func postQuitMessage(exitCode uintptr) {
+	_PostQuitMessage.Call(exitCode)
+}
+
+func postMessage(hwnd syscall.Handle, msg uint32, wParam, lParam uintptr) error {
+	r, _, err := _PostMessage.Call(uintptr(hwnd), uintptr(msg), wParam, lParam)
+	if r == 0 {
+		return fmt.Errorf("PostMessage failed: %v", err)
+	}
+	return nil
+}
+
+func releaseCapture() bool {
+	r, _, _ := _ReleaseCapture.Call()
+	return r != 0
+}
+
+func registerClassEx(cls *wndClassEx) (uint16, error) {
+	a, _, err := _RegisterClassExW.Call(uintptr(unsafe.Pointer(cls)))
+	issue34474KeepAlive(cls)
+	if a == 0 {
+		return 0, fmt.Errorf("RegisterClassExW failed: %v", err)
+	}
+	return uint16(a), nil
+}
+
+func releaseDC(hdc syscall.Handle) {
+	_ReleaseDC.Call(uintptr(hdc))
+}
+
+func setForegroundWindow(hwnd syscall.Handle) {
+	_SetForegroundWindow.Call(uintptr(hwnd))
+}
+
+func setFocus(hwnd syscall.Handle) {
+	_SetFocus.Call(uintptr(hwnd))
+}
+
+func setProcessDPIAware() {
+	_SetProcessDPIAware.Call()
+}
+
+func setCapture(hwnd syscall.Handle) syscall.Handle {
+	r, _, _ := _SetCapture.Call(uintptr(hwnd))
+	return syscall.Handle(r)
+}
+
+func setTimer(hwnd syscall.Handle, nIDEvent uintptr, uElapse uint32, timerProc uintptr) error {
+	r, _, err := _SetTimer.Call(uintptr(hwnd), uintptr(nIDEvent), uintptr(uElapse), timerProc)
+	if r == 0 {
+		return fmt.Errorf("SetTimer failed: %v", err)
+	}
+	return nil
+}
+
+func screenToClient(hwnd syscall.Handle, p *point) {
+	_ScreenToClient.Call(uintptr(hwnd), uintptr(unsafe.Pointer(p)))
+	issue34474KeepAlive(p)
+}
+
+func showWindow(hwnd syscall.Handle, nCmdShow int32) {
+	_ShowWindow.Call(uintptr(hwnd), uintptr(nCmdShow))
+}
+
+func translateMessage(m *msg) {
+	_TranslateMessage.Call(uintptr(unsafe.Pointer(m)))
+	issue34474KeepAlive(m)
+}
+
+func unregisterClass(cls uint16, hInst syscall.Handle) {
+	_UnregisterClass.Call(uintptr(cls), uintptr(hInst))
+}
+
+func updateWindow(hwnd syscall.Handle) {
+	_UpdateWindow.Call(uintptr(hwnd))
+}
+
+// issue34474KeepAlive calls runtime.KeepAlive as a
+// workaround for golang.org/issue/34474.
+func issue34474KeepAlive(v interface{}) {
+	runtime.KeepAlive(v)
+}

app/internal/window/runmain.go

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build android darwin,ios
+
+package window
+
+// Android only supports non-Java programs as c-shared libraries.
+// Unfortunately, Go does not run a program's main function in
+// library mode. To make Gio programs simpler and uniform, we'll
+// link to the main function here and call it from Java.
+
+import (
+	"sync"
+	_ "unsafe" // for go:linkname
+)
+
+//go:linkname mainMain main.main
+func mainMain()
+
+var runMainOnce sync.Once
+
+func runMain() {
+	runMainOnce.Do(func() {
+		// Indirect call, since the linker does not know the address of main when
+		// laying down this package.
+		fn := mainMain
+		go fn()
+	})
+}

app/internal/window/runmain_ios.go

@@ -0,0 +1,12 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// +build darwin,ios
+
+package window
+
+import "C"
+
+//export gio_runMain
+func gio_runMain() {
+	runMain()
+}

app/internal/window/wayland_text_input.c

@@ -0,0 +1,98 @@
+// +build linux,!android
+
+/* Generated by wayland-scanner 1.16.0 */
+
+/*
+ * Copyright © 2012, 2013 Intel Corporation
+ * Copyright © 2015, 2016 Jan Arne Petersen
+ * Copyright © 2017, 2018 Red Hat, Inc.
+ * Copyright © 2018       Purism SPC
+ *
+ * Permission to use, copy, modify, distribute, and sell this
+ * software and its documentation for any purpose is hereby granted
+ * without fee, provided that the above copyright notice appear in
+ * all copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of
+ * the copyright holders not be used in advertising or publicity
+ * pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied
+ * warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface wl_seat_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface zwp_text_input_v3_interface;
+
+static const struct wl_interface *types[] = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&wl_surface_interface,
+	&wl_surface_interface,
+	&zwp_text_input_v3_interface,
+	&wl_seat_interface,
+};
+
+static const struct wl_message zwp_text_input_v3_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "enable", "", types + 0 },
+	{ "disable", "", types + 0 },
+	{ "set_surrounding_text", "sii", types + 0 },
+	{ "set_text_change_cause", "u", types + 0 },
+	{ "set_content_type", "uu", types + 0 },
+	{ "set_cursor_rectangle", "iiii", types + 0 },
+	{ "commit", "", types + 0 },
+};
+
+static const struct wl_message zwp_text_input_v3_events[] = {
+	{ "enter", "o", types + 4 },
+	{ "leave", "o", types + 5 },
+	{ "preedit_string", "?sii", types + 0 },
+	{ "commit_string", "?s", types + 0 },
+	{ "delete_surrounding_text", "uu", types + 0 },
+	{ "done", "u", types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface zwp_text_input_v3_interface = {
+	"zwp_text_input_v3", 1,
+	8, zwp_text_input_v3_requests,
+	6, zwp_text_input_v3_events,
+};
+
+static const struct wl_message zwp_text_input_manager_v3_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "get_text_input", "no", types + 6 },
+};
+
+WL_PRIVATE const struct wl_interface zwp_text_input_manager_v3_interface = {
+	"zwp_text_input_manager_v3", 1,
+	2, zwp_text_input_manager_v3_requests,
+	0, NULL,
+};
+

app/internal/window/wayland_text_input.h

@@ -0,0 +1,819 @@
+/* Generated by wayland-scanner 1.16.0 */
+
+#ifndef TEXT_INPUT_UNSTABLE_V3_CLIENT_PROTOCOL_H
+#define TEXT_INPUT_UNSTABLE_V3_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_text_input_unstable_v3 The text_input_unstable_v3 protocol
+ * Protocol for composing text
+ *
+ * @section page_desc_text_input_unstable_v3 Description
+ *
+ * This protocol allows compositors to act as input methods and to send text
+ * to applications. A text input object is used to manage state of what are
+ * typically text entry fields in the application.
+ *
+ * This document adheres to the RFC 2119 when using words like "must",
+ * "should", "may", etc.
+ *
+ * Warning! The protocol described in this file is experimental and
+ * backward incompatible changes may be made. Backward compatible changes
+ * may be added together with the corresponding interface version bump.
+ * Backward incompatible changes are done by bumping the version number in
+ * the protocol and interface names and resetting the interface version.
+ * Once the protocol is to be declared stable, the 'z' prefix and the
+ * version number in the protocol and interface names are removed and the
+ * interface version number is reset.
+ *
+ * @section page_ifaces_text_input_unstable_v3 Interfaces
+ * - @subpage page_iface_zwp_text_input_v3 - text input
+ * - @subpage page_iface_zwp_text_input_manager_v3 - text input manager
+ * @section page_copyright_text_input_unstable_v3 Copyright
+ * <pre>
+ *
+ * Copyright © 2012, 2013 Intel Corporation
+ * Copyright © 2015, 2016 Jan Arne Petersen
+ * Copyright © 2017, 2018 Red Hat, Inc.
+ * Copyright © 2018       Purism SPC
+ *
+ * Permission to use, copy, modify, distribute, and sell this
+ * software and its documentation for any purpose is hereby granted
+ * without fee, provided that the above copyright notice appear in
+ * all copies and that both that copyright notice and this permission
+ * notice appear in supporting documentation, and that the name of
+ * the copyright holders not be used in advertising or publicity
+ * pertaining to distribution of the software without specific,
+ * written prior permission.  The copyright holders make no
+ * representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied
+ * warranty.
+ *
+ * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+ * SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ * FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+ * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ * </pre>
+ */
+struct wl_seat;
+struct wl_surface;
+struct zwp_text_input_manager_v3;
+struct zwp_text_input_v3;
+
+/**
+ * @page page_iface_zwp_text_input_v3 zwp_text_input_v3
+ * @section page_iface_zwp_text_input_v3_desc Description
+ *
+ * The zwp_text_input_v3 interface represents text input and input methods
+ * associated with a seat. It provides enter/leave events to follow the
+ * text input focus for a seat.
+ *
+ * Requests are used to enable/disable the text-input object and set
+ * state information like surrounding and selected text or the content type.
+ * The information about the entered text is sent to the text-input object
+ * via the preedit_string and commit_string events.
+ *
+ * Text is valid UTF-8 encoded, indices and lengths are in bytes. Indices
+ * must not point to middle bytes inside a code point: they must either
+ * point to the first byte of a code point or to the end of the buffer.
+ * Lengths must be measured between two valid indices.
+ *
+ * Focus moving throughout surfaces will result in the emission of
+ * zwp_text_input_v3.enter and zwp_text_input_v3.leave events. The focused
+ * surface must commit zwp_text_input_v3.enable and
+ * zwp_text_input_v3.disable requests as the keyboard focus moves across
+ * editable and non-editable elements of the UI. Those two requests are not
+ * expected to be paired with each other, the compositor must be able to
+ * handle consecutive series of the same request.
+ *
+ * State is sent by the state requests (set_surrounding_text,
+ * set_content_type and set_cursor_rectangle) and a commit request. After an
+ * enter event or disable request all state information is invalidated and
+ * needs to be resent by the client.
+ * @section page_iface_zwp_text_input_v3_api API
+ * See @ref iface_zwp_text_input_v3.
+ */
+/**
+ * @defgroup iface_zwp_text_input_v3 The zwp_text_input_v3 interface
+ *
+ * The zwp_text_input_v3 interface represents text input and input methods
+ * associated with a seat. It provides enter/leave events to follow the
+ * text input focus for a seat.
+ *
+ * Requests are used to enable/disable the text-input object and set
+ * state information like surrounding and selected text or the content type.
+ * The information about the entered text is sent to the text-input object
+ * via the preedit_string and commit_string events.
+ *
+ * Text is valid UTF-8 encoded, indices and lengths are in bytes. Indices
+ * must not point to middle bytes inside a code point: they must either
+ * point to the first byte of a code point or to the end of the buffer.
+ * Lengths must be measured between two valid indices.
+ *
+ * Focus moving throughout surfaces will result in the emission of
+ * zwp_text_input_v3.enter and zwp_text_input_v3.leave events. The focused
+ * surface must commit zwp_text_input_v3.enable and
+ * zwp_text_input_v3.disable requests as the keyboard focus moves across
+ * editable and non-editable elements of the UI. Those two requests are not
+ * expected to be paired with each other, the compositor must be able to
+ * handle consecutive series of the same request.
+ *
+ * State is sent by the state requests (set_surrounding_text,
+ * set_content_type and set_cursor_rectangle) and a commit request. After an
+ * enter event or disable request all state information is invalidated and
+ * needs to be resent by the client.
+ */
+extern const struct wl_interface zwp_text_input_v3_interface;
+/**
+ * @page page_iface_zwp_text_input_manager_v3 zwp_text_input_manager_v3
+ * @section page_iface_zwp_text_input_manager_v3_desc Description
+ *
+ * A factory for text-input objects. This object is a global singleton.
+ * @section page_iface_zwp_text_input_manager_v3_api API
+ * See @ref iface_zwp_text_input_manager_v3.
+ */
+/**
+ * @defgroup iface_zwp_text_input_manager_v3 The zwp_text_input_manager_v3 interface
+ *
+ * A factory for text-input objects. This object is a global singleton.
+ */
+extern const struct wl_interface zwp_text_input_manager_v3_interface;
+
+#ifndef ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_ENUM
+#define ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_ENUM
+/**
+ * @ingroup iface_zwp_text_input_v3
+ * text change reason
+ *
+ * Reason for the change of surrounding text or cursor posision.
+ */
+enum zwp_text_input_v3_change_cause {
+	/**
+	 * input method caused the change
+	 */
+	ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_INPUT_METHOD = 0,
+	/**
+	 * something else than the input method caused the change
+	 */
+	ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_OTHER = 1,
+};
+#endif /* ZWP_TEXT_INPUT_V3_CHANGE_CAUSE_ENUM */
+
+#ifndef ZWP_TEXT_INPUT_V3_CONTENT_HINT_ENUM
+#define ZWP_TEXT_INPUT_V3_CONTENT_HINT_ENUM
+/**
+ * @ingroup iface_zwp_text_input_v3
+ * content hint
+ *
+ * Content hint is a bitmask to allow to modify the behavior of the text
+ * input.
+ */
+enum zwp_text_input_v3_content_hint {
+	/**
+	 * no special behavior
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_NONE = 0x0,
+	/**
+	 * suggest word completions
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_COMPLETION = 0x1,
+	/**
+	 * suggest word corrections
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_SPELLCHECK = 0x2,
+	/**
+	 * switch to uppercase letters at the start of a sentence
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_AUTO_CAPITALIZATION = 0x4,
+	/**
+	 * prefer lowercase letters
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_LOWERCASE = 0x8,
+	/**
+	 * prefer uppercase letters
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_UPPERCASE = 0x10,
+	/**
+	 * prefer casing for titles and headings (can be language dependent)
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_TITLECASE = 0x20,
+	/**
+	 * characters should be hidden
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_HIDDEN_TEXT = 0x40,
+	/**
+	 * typed text should not be stored
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_SENSITIVE_DATA = 0x80,
+	/**
+	 * just Latin characters should be entered
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_LATIN = 0x100,
+	/**
+	 * the text input is multiline
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_HINT_MULTILINE = 0x200,
+};
+#endif /* ZWP_TEXT_INPUT_V3_CONTENT_HINT_ENUM */
+
+#ifndef ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ENUM
+#define ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ENUM
+/**
+ * @ingroup iface_zwp_text_input_v3
+ * content purpose
+ *
+ * The content purpose allows to specify the primary purpose of a text
+ * input.
+ *
+ * This allows an input method to show special purpose input panels with
+ * extra characters or to disallow some characters.
+ */
+enum zwp_text_input_v3_content_purpose {
+	/**
+	 * default input, allowing all characters
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NORMAL = 0,
+	/**
+	 * allow only alphabetic characters
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ALPHA = 1,
+	/**
+	 * allow only digits
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DIGITS = 2,
+	/**
+	 * input a number (including decimal separator and sign)
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NUMBER = 3,
+	/**
+	 * input a phone number
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PHONE = 4,
+	/**
+	 * input an URL
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_URL = 5,
+	/**
+	 * input an email address
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_EMAIL = 6,
+	/**
+	 * input a name of a person
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_NAME = 7,
+	/**
+	 * input a password (combine with sensitive_data hint)
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PASSWORD = 8,
+	/**
+	 * input is a numeric password (combine with sensitive_data hint)
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_PIN = 9,
+	/**
+	 * input a date
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DATE = 10,
+	/**
+	 * input a time
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TIME = 11,
+	/**
+	 * input a date and time
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_DATETIME = 12,
+	/**
+	 * input for a terminal
+	 */
+	ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_TERMINAL = 13,
+};
+#endif /* ZWP_TEXT_INPUT_V3_CONTENT_PURPOSE_ENUM */
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ * @struct zwp_text_input_v3_listener
+ */
+struct zwp_text_input_v3_listener {
+	/**
+	 * enter event
+	 *
+	 * Notification that this seat's text-input focus is on a certain
+	 * surface.
+	 *
+	 * When the seat has the keyboard capability the text-input focus
+	 * follows the keyboard focus. This event sets the current surface
+	 * for the text-input object.
+	 */
+	void (*enter)(void *data,
+		      struct zwp_text_input_v3 *zwp_text_input_v3,
+		      struct wl_surface *surface);
+	/**
+	 * leave event
+	 *
+	 * Notification that this seat's text-input focus is no longer on
+	 * a certain surface. The client should reset any preedit string
+	 * previously set.
+	 *
+	 * The leave notification clears the current surface. It is sent
+	 * before the enter notification for the new focus.
+	 *
+	 * When the seat has the keyboard capability the text-input focus
+	 * follows the keyboard focus.
+	 */
+	void (*leave)(void *data,
+		      struct zwp_text_input_v3 *zwp_text_input_v3,
+		      struct wl_surface *surface);
+	/**
+	 * pre-edit
+	 *
+	 * Notify when a new composing text (pre-edit) should be set at
+	 * the current cursor position. Any previously set composing text
+	 * must be removed. Any previously existing selected text must be
+	 * removed.
+	 *
+	 * The argument text contains the pre-edit string buffer.
+	 *
+	 * The parameters cursor_begin and cursor_end are counted in bytes
+	 * relative to the beginning of the submitted text buffer. Cursor
+	 * should be hidden when both are equal to -1.
+	 *
+	 * They could be represented by the client as a line if both values
+	 * are the same, or as a text highlight otherwise.
+	 *
+	 * Values set with this event are double-buffered. They must be
+	 * applied and reset to initial on the next zwp_text_input_v3.done
+	 * event.
+	 *
+	 * The initial value of text is an empty string, and cursor_begin,
+	 * cursor_end and cursor_hidden are all 0.
+	 */
+	void (*preedit_string)(void *data,
+			       struct zwp_text_input_v3 *zwp_text_input_v3,
+			       const char *text,
+			       int32_t cursor_begin,
+			       int32_t cursor_end);
+	/**
+	 * text commit
+	 *
+	 * Notify when text should be inserted into the editor widget.
+	 * The text to commit could be either just a single character after
+	 * a key press or the result of some composing (pre-edit).
+	 *
+	 * Values set with this event are double-buffered. They must be
+	 * applied and reset to initial on the next zwp_text_input_v3.done
+	 * event.
+	 *
+	 * The initial value of text is an empty string.
+	 */
+	void (*commit_string)(void *data,
+			      struct zwp_text_input_v3 *zwp_text_input_v3,
+			      const char *text);
+	/**
+	 * delete surrounding text
+	 *
+	 * Notify when the text around the current cursor position should
+	 * be deleted.
+	 *
+	 * Before_length and after_length are the number of bytes before
+	 * and after the current cursor index (excluding the selection) to
+	 * delete.
+	 *
+	 * If a preedit text is present, in effect before_length is counted
+	 * from the beginning of it, and after_length from its end (see
+	 * done event sequence).
+	 *
+	 * Values set with this event are double-buffered. They must be
+	 * applied and reset to initial on the next zwp_text_input_v3.done
+	 * event.
+	 *
+	 * The initial values of both before_length and after_length are 0.
+	 * @param before_length length of text before current cursor position
+	 * @param after_length length of text after current cursor position
+	 */
+	void (*delete_surrounding_text)(void *data,
+					struct zwp_text_input_v3 *zwp_text_input_v3,
+					uint32_t before_length,
+					uint32_t after_length);
+	/**
+	 * apply changes
+	 *
+	 * Instruct the application to apply changes to state requested
+	 * by the preedit_string, commit_string and delete_surrounding_text
+	 * events. The state relating to these events is double-buffered,
+	 * and each one modifies the pending state. This event replaces the
+	 * current state with the pending state.
+	 *
+	 * The application must proceed by evaluating the changes in the
+	 * following order:
+	 *
+	 * 1. Replace existing preedit string with the cursor. 2. Delete
+	 * requested surrounding text. 3. Insert commit string with the
+	 * cursor at its end. 4. Calculate surrounding text to send. 5.
+	 * Insert new preedit text in cursor position. 6. Place cursor
+	 * inside preedit text.
+	 *
+	 * The serial number reflects the last state of the
+	 * zwp_text_input_v3 object known to the compositor. The value of
+	 * the serial argument must be equal to the number of commit
+	 * requests already issued on that object. When the client receives
+	 * a done event with a serial different than the number of past
+	 * commit requests, it must proceed as normal, except it should not
+	 * change the current state of the zwp_text_input_v3 object.
+	 */
+	void (*done)(void *data,
+		     struct zwp_text_input_v3 *zwp_text_input_v3,
+		     uint32_t serial);
+};
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+static inline int
+zwp_text_input_v3_add_listener(struct zwp_text_input_v3 *zwp_text_input_v3,
+			       const struct zwp_text_input_v3_listener *listener, void *data)
+{
+	return wl_proxy_add_listener((struct wl_proxy *) zwp_text_input_v3,
+				     (void (**)(void)) listener, data);
+}
+
+#define ZWP_TEXT_INPUT_V3_DESTROY 0
+#define ZWP_TEXT_INPUT_V3_ENABLE 1
+#define ZWP_TEXT_INPUT_V3_DISABLE 2
+#define ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT 3
+#define ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE 4
+#define ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE 5
+#define ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE 6
+#define ZWP_TEXT_INPUT_V3_COMMIT 7
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_ENTER_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_LEAVE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_PREEDIT_STRING_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_COMMIT_STRING_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_DELETE_SURROUNDING_TEXT_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_DONE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_ENABLE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_DISABLE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_v3
+ */
+#define ZWP_TEXT_INPUT_V3_COMMIT_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_text_input_v3 */
+static inline void
+zwp_text_input_v3_set_user_data(struct zwp_text_input_v3 *zwp_text_input_v3, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) zwp_text_input_v3, user_data);
+}
+
+/** @ingroup iface_zwp_text_input_v3 */
+static inline void *
+zwp_text_input_v3_get_user_data(struct zwp_text_input_v3 *zwp_text_input_v3)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) zwp_text_input_v3);
+}
+
+static inline uint32_t
+zwp_text_input_v3_get_version(struct zwp_text_input_v3 *zwp_text_input_v3)
+{
+	return wl_proxy_get_version((struct wl_proxy *) zwp_text_input_v3);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ *
+ * Destroy the wp_text_input object. Also disables all surfaces enabled
+ * through this wp_text_input object.
+ */
+static inline void
+zwp_text_input_v3_destroy(struct zwp_text_input_v3 *zwp_text_input_v3)
+{
+	wl_proxy_marshal((struct wl_proxy *) zwp_text_input_v3,
+			 ZWP_TEXT_INPUT_V3_DESTROY);
+
+	wl_proxy_destroy((struct wl_proxy *) zwp_text_input_v3);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ *
+ * Requests text input on the surface previously obtained from the enter
+ * event.
+ *
+ * This request must be issued every time the active text input changes
+ * to a new one, including within the current surface. Use
+ * zwp_text_input_v3.disable when there is no longer any input focus on
+ * the current surface.
+ *
+ * This request resets all state associated with previous enable, disable,
+ * set_surrounding_text, set_text_change_cause, set_content_type, and
+ * set_cursor_rectangle requests, as well as the state associated with
+ * preedit_string, commit_string, and delete_surrounding_text events.
+ *
+ * The set_surrounding_text, set_content_type and set_cursor_rectangle
+ * requests must follow if the text input supports the necessary
+ * functionality.
+ *
+ * State set with this request is double-buffered. It will get applied on
+ * the next zwp_text_input_v3.commit request, and stay valid until the
+ * next committed enable or disable request.
+ *
+ * The changes must be applied by the compositor after issuing a
+ * zwp_text_input_v3.commit request.
+ */
+static inline void
+zwp_text_input_v3_enable(struct zwp_text_input_v3 *zwp_text_input_v3)
+{
+	wl_proxy_marshal((struct wl_proxy *) zwp_text_input_v3,
+			 ZWP_TEXT_INPUT_V3_ENABLE);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ *
+ * Explicitly disable text input on the current surface (typically when
+ * there is no focus on any text entry inside the surface).
+ *
+ * State set with this request is double-buffered. It will get applied on
+ * the next zwp_text_input_v3.commit request.
+ */
+static inline void
+zwp_text_input_v3_disable(struct zwp_text_input_v3 *zwp_text_input_v3)
+{
+	wl_proxy_marshal((struct wl_proxy *) zwp_text_input_v3,
+			 ZWP_TEXT_INPUT_V3_DISABLE);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ *
+ * Sets the surrounding plain text around the input, excluding the preedit
+ * text.
+ *
+ * The client should notify the compositor of any changes in any of the
+ * values carried with this request, including changes caused by handling
+ * incoming text-input events as well as changes caused by other
+ * mechanisms like keyboard typing.
+ *
+ * If the client is unaware of the text around the cursor, it should not
+ * issue this request, to signify lack of support to the compositor.
+ *
+ * Text is UTF-8 encoded, and should include the cursor position, the
+ * complete selection and additional characters before and after them.
+ * There is a maximum length of wayland messages, so text can not be
+ * longer than 4000 bytes.
+ *
+ * Cursor is the byte offset of the cursor within text buffer.
+ *
+ * Anchor is the byte offset of the selection anchor within text buffer.
+ * If there is no selected text, anchor is the same as cursor.
+ *
+ * If any preedit text is present, it is replaced with a cursor for the
+ * purpose of this event.
+ *
+ * Values set with this request are double-buffered. They will get applied
+ * on the next zwp_text_input_v3.commit request, and stay valid until the
+ * next committed enable or disable request.
+ *
+ * The initial state for affected fields is empty, meaning that the text
+ * input does not support sending surrounding text. If the empty values
+ * get applied, subsequent attempts to change them may have no effect.
+ */
+static inline void
+zwp_text_input_v3_set_surrounding_text(struct zwp_text_input_v3 *zwp_text_input_v3, const char *text, int32_t cursor, int32_t anchor)
+{
+	wl_proxy_marshal((struct wl_proxy *) zwp_text_input_v3,
+			 ZWP_TEXT_INPUT_V3_SET_SURROUNDING_TEXT, text, cursor, anchor);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ *
+ * Tells the compositor why the text surrounding the cursor changed.
+ *
+ * Whenever the client detects an external change in text, cursor, or
+ * anchor posision, it must issue this request to the compositor. This
+ * request is intended to give the input method a chance to update the
+ * preedit text in an appropriate way, e.g. by removing it when the user
+ * starts typing with a keyboard.
+ *
+ * cause describes the source of the change.
+ *
+ * The value set with this request is double-buffered. It must be applied
+ * and reset to initial at the next zwp_text_input_v3.commit request.
+ *
+ * The initial value of cause is input_method.
+ */
+static inline void
+zwp_text_input_v3_set_text_change_cause(struct zwp_text_input_v3 *zwp_text_input_v3, uint32_t cause)
+{
+	wl_proxy_marshal((struct wl_proxy *) zwp_text_input_v3,
+			 ZWP_TEXT_INPUT_V3_SET_TEXT_CHANGE_CAUSE, cause);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ *
+ * Sets the content purpose and content hint. While the purpose is the
+ * basic purpose of an input field, the hint flags allow to modify some of
+ * the behavior.
+ *
+ * Values set with this request are double-buffered. They will get applied
+ * on the next zwp_text_input_v3.commit request.
+ * Subsequent attempts to update them may have no effect. The values
+ * remain valid until the next committed enable or disable request.
+ *
+ * The initial value for hint is none, and the initial value for purpose
+ * is normal.
+ */
+static inline void
+zwp_text_input_v3_set_content_type(struct zwp_text_input_v3 *zwp_text_input_v3, uint32_t hint, uint32_t purpose)
+{
+	wl_proxy_marshal((struct wl_proxy *) zwp_text_input_v3,
+			 ZWP_TEXT_INPUT_V3_SET_CONTENT_TYPE, hint, purpose);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ *
+ * Marks an area around the cursor as a x, y, width, height rectangle in
+ * surface local coordinates.
+ *
+ * Allows the compositor to put a window with word suggestions near the
+ * cursor, without obstructing the text being input.
+ *
+ * If the client is unaware of the position of edited text, it should not
+ * issue this request, to signify lack of support to the compositor.
+ *
+ * Values set with this request are double-buffered. They will get applied
+ * on the next zwp_text_input_v3.commit request, and stay valid until the
+ * next committed enable or disable request.
+ *
+ * The initial values describing a cursor rectangle are empty. That means
+ * the text input does not support describing the cursor area. If the
+ * empty values get applied, subsequent attempts to change them may have
+ * no effect.
+ */
+static inline void
+zwp_text_input_v3_set_cursor_rectangle(struct zwp_text_input_v3 *zwp_text_input_v3, int32_t x, int32_t y, int32_t width, int32_t height)
+{
+	wl_proxy_marshal((struct wl_proxy *) zwp_text_input_v3,
+			 ZWP_TEXT_INPUT_V3_SET_CURSOR_RECTANGLE, x, y, width, height);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_v3
+ *
+ * Atomically applies state changes recently sent to the compositor.
+ *
+ * The commit request establishes and updates the state of the client, and
+ * must be issued after any changes to apply them.
+ *
+ * Text input state (enabled status, content purpose, content hint,
+ * surrounding text and change cause, cursor rectangle) is conceptually
+ * double-buffered within the context of a text input, i.e. between a
+ * committed enable request and the following committed enable or disable
+ * request.
+ *
+ * Protocol requests modify the pending state, as opposed to the current
+ * state in use by the input method. A commit request atomically applies
+ * all pending state, replacing the current state. After commit, the new
+ * pending state is as documented for each related request.
+ *
+ * Requests are applied in the order of arrival.
+ *
+ * Neither current nor pending state are modified unless noted otherwise.
+ *
+ * The compositor must count the number of commit requests coming from
+ * each zwp_text_input_v3 object and use the count as the serial in done
+ * events.
+ */
+static inline void
+zwp_text_input_v3_commit(struct zwp_text_input_v3 *zwp_text_input_v3)
+{
+	wl_proxy_marshal((struct wl_proxy *) zwp_text_input_v3,
+			 ZWP_TEXT_INPUT_V3_COMMIT);
+}
+
+#define ZWP_TEXT_INPUT_MANAGER_V3_DESTROY 0
+#define ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT 1
+
+
+/**
+ * @ingroup iface_zwp_text_input_manager_v3
+ */
+#define ZWP_TEXT_INPUT_MANAGER_V3_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zwp_text_input_manager_v3
+ */
+#define ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT_SINCE_VERSION 1
+
+/** @ingroup iface_zwp_text_input_manager_v3 */
+static inline void
+zwp_text_input_manager_v3_set_user_data(struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) zwp_text_input_manager_v3, user_data);
+}
+
+/** @ingroup iface_zwp_text_input_manager_v3 */
+static inline void *
+zwp_text_input_manager_v3_get_user_data(struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) zwp_text_input_manager_v3);
+}
+
+static inline uint32_t
+zwp_text_input_manager_v3_get_version(struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3)
+{
+	return wl_proxy_get_version((struct wl_proxy *) zwp_text_input_manager_v3);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_manager_v3
+ *
+ * Destroy the wp_text_input_manager object.
+ */
+static inline void
+zwp_text_input_manager_v3_destroy(struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3)
+{
+	wl_proxy_marshal((struct wl_proxy *) zwp_text_input_manager_v3,
+			 ZWP_TEXT_INPUT_MANAGER_V3_DESTROY);
+
+	wl_proxy_destroy((struct wl_proxy *) zwp_text_input_manager_v3);
+}
+
+/**
+ * @ingroup iface_zwp_text_input_manager_v3
+ *
+ * Creates a new text-input object for a given seat.
+ */
+static inline struct zwp_text_input_v3 *
+zwp_text_input_manager_v3_get_text_input(struct zwp_text_input_manager_v3 *zwp_text_input_manager_v3, struct wl_seat *seat)
+{
+	struct wl_proxy *id;
+
+	id = wl_proxy_marshal_constructor((struct wl_proxy *) zwp_text_input_manager_v3,
+			 ZWP_TEXT_INPUT_MANAGER_V3_GET_TEXT_INPUT, &zwp_text_input_v3_interface, NULL, seat);
+
+	return (struct zwp_text_input_v3 *) id;
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

app/internal/window/wayland_xdg_decoration.c

@@ -0,0 +1,77 @@
+// +build linux,!android
+
+/* Generated by wayland-scanner 1.16.0 */
+
+/*
+ * Copyright © 2018 Simon Ser
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface xdg_toplevel_interface;
+extern const struct wl_interface zxdg_toplevel_decoration_v1_interface;
+
+static const struct wl_interface *types[] = {
+	NULL,
+	&zxdg_toplevel_decoration_v1_interface,
+	&xdg_toplevel_interface,
+};
+
+static const struct wl_message zxdg_decoration_manager_v1_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "get_toplevel_decoration", "no", types + 1 },
+};
+
+WL_PRIVATE const struct wl_interface zxdg_decoration_manager_v1_interface = {
+	"zxdg_decoration_manager_v1", 1,
+	2, zxdg_decoration_manager_v1_requests,
+	0, NULL,
+};
+
+static const struct wl_message zxdg_toplevel_decoration_v1_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "set_mode", "u", types + 0 },
+	{ "unset_mode", "", types + 0 },
+};
+
+static const struct wl_message zxdg_toplevel_decoration_v1_events[] = {
+	{ "configure", "u", types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface zxdg_toplevel_decoration_v1_interface = {
+	"zxdg_toplevel_decoration_v1", 1,
+	3, zxdg_toplevel_decoration_v1_requests,
+	1, zxdg_toplevel_decoration_v1_events,
+};
+

app/internal/window/wayland_xdg_decoration.h

@@ -0,0 +1,376 @@
+/* Generated by wayland-scanner 1.16.0 */
+
+#ifndef XDG_DECORATION_UNSTABLE_V1_CLIENT_PROTOCOL_H
+#define XDG_DECORATION_UNSTABLE_V1_CLIENT_PROTOCOL_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include "wayland-client.h"
+
+#ifdef  __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @page page_xdg_decoration_unstable_v1 The xdg_decoration_unstable_v1 protocol
+ * @section page_ifaces_xdg_decoration_unstable_v1 Interfaces
+ * - @subpage page_iface_zxdg_decoration_manager_v1 - window decoration manager
+ * - @subpage page_iface_zxdg_toplevel_decoration_v1 - decoration object for a toplevel surface
+ * @section page_copyright_xdg_decoration_unstable_v1 Copyright
+ * <pre>
+ *
+ * Copyright © 2018 Simon Ser
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ * </pre>
+ */
+struct xdg_toplevel;
+struct zxdg_decoration_manager_v1;
+struct zxdg_toplevel_decoration_v1;
+
+/**
+ * @page page_iface_zxdg_decoration_manager_v1 zxdg_decoration_manager_v1
+ * @section page_iface_zxdg_decoration_manager_v1_desc Description
+ *
+ * This interface allows a compositor to announce support for server-side
+ * decorations.
+ *
+ * A window decoration is a set of window controls as deemed appropriate by
+ * the party managing them, such as user interface components used to move,
+ * resize and change a window's state.
+ *
+ * A client can use this protocol to request being decorated by a supporting
+ * compositor.
+ *
+ * If compositor and client do not negotiate the use of a server-side
+ * decoration using this protocol, clients continue to self-decorate as they
+ * see fit.
+ *
+ * Warning! The protocol described in this file is experimental and
+ * backward incompatible changes may be made. Backward compatible changes
+ * may be added together with the corresponding interface version bump.
+ * Backward incompatible changes are done by bumping the version number in
+ * the protocol and interface names and resetting the interface version.
+ * Once the protocol is to be declared stable, the 'z' prefix and the
+ * version number in the protocol and interface names are removed and the
+ * interface version number is reset.
+ * @section page_iface_zxdg_decoration_manager_v1_api API
+ * See @ref iface_zxdg_decoration_manager_v1.
+ */
+/**
+ * @defgroup iface_zxdg_decoration_manager_v1 The zxdg_decoration_manager_v1 interface
+ *
+ * This interface allows a compositor to announce support for server-side
+ * decorations.
+ *
+ * A window decoration is a set of window controls as deemed appropriate by
+ * the party managing them, such as user interface components used to move,
+ * resize and change a window's state.
+ *
+ * A client can use this protocol to request being decorated by a supporting
+ * compositor.
+ *
+ * If compositor and client do not negotiate the use of a server-side
+ * decoration using this protocol, clients continue to self-decorate as they
+ * see fit.
+ *
+ * Warning! The protocol described in this file is experimental and
+ * backward incompatible changes may be made. Backward compatible changes
+ * may be added together with the corresponding interface version bump.
+ * Backward incompatible changes are done by bumping the version number in
+ * the protocol and interface names and resetting the interface version.
+ * Once the protocol is to be declared stable, the 'z' prefix and the
+ * version number in the protocol and interface names are removed and the
+ * interface version number is reset.
+ */
+extern const struct wl_interface zxdg_decoration_manager_v1_interface;
+/**
+ * @page page_iface_zxdg_toplevel_decoration_v1 zxdg_toplevel_decoration_v1
+ * @section page_iface_zxdg_toplevel_decoration_v1_desc Description
+ *
+ * The decoration object allows the compositor to toggle server-side window
+ * decorations for a toplevel surface. The client can request to switch to
+ * another mode.
+ *
+ * The xdg_toplevel_decoration object must be destroyed before its
+ * xdg_toplevel.
+ * @section page_iface_zxdg_toplevel_decoration_v1_api API
+ * See @ref iface_zxdg_toplevel_decoration_v1.
+ */
+/**
+ * @defgroup iface_zxdg_toplevel_decoration_v1 The zxdg_toplevel_decoration_v1 interface
+ *
+ * The decoration object allows the compositor to toggle server-side window
+ * decorations for a toplevel surface. The client can request to switch to
+ * another mode.
+ *
+ * The xdg_toplevel_decoration object must be destroyed before its
+ * xdg_toplevel.
+ */
+extern const struct wl_interface zxdg_toplevel_decoration_v1_interface;
+
+#define ZXDG_DECORATION_MANAGER_V1_DESTROY 0
+#define ZXDG_DECORATION_MANAGER_V1_GET_TOPLEVEL_DECORATION 1
+
+
+/**
+ * @ingroup iface_zxdg_decoration_manager_v1
+ */
+#define ZXDG_DECORATION_MANAGER_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_decoration_manager_v1
+ */
+#define ZXDG_DECORATION_MANAGER_V1_GET_TOPLEVEL_DECORATION_SINCE_VERSION 1
+
+/** @ingroup iface_zxdg_decoration_manager_v1 */
+static inline void
+zxdg_decoration_manager_v1_set_user_data(struct zxdg_decoration_manager_v1 *zxdg_decoration_manager_v1, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) zxdg_decoration_manager_v1, user_data);
+}
+
+/** @ingroup iface_zxdg_decoration_manager_v1 */
+static inline void *
+zxdg_decoration_manager_v1_get_user_data(struct zxdg_decoration_manager_v1 *zxdg_decoration_manager_v1)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) zxdg_decoration_manager_v1);
+}
+
+static inline uint32_t
+zxdg_decoration_manager_v1_get_version(struct zxdg_decoration_manager_v1 *zxdg_decoration_manager_v1)
+{
+	return wl_proxy_get_version((struct wl_proxy *) zxdg_decoration_manager_v1);
+}
+
+/**
+ * @ingroup iface_zxdg_decoration_manager_v1
+ *
+ * Destroy the decoration manager. This doesn't destroy objects created
+ * with the manager.
+ */
+static inline void
+zxdg_decoration_manager_v1_destroy(struct zxdg_decoration_manager_v1 *zxdg_decoration_manager_v1)
+{
+	wl_proxy_marshal((struct wl_proxy *) zxdg_decoration_manager_v1,
+			 ZXDG_DECORATION_MANAGER_V1_DESTROY);
+
+	wl_proxy_destroy((struct wl_proxy *) zxdg_decoration_manager_v1);
+}
+
+/**
+ * @ingroup iface_zxdg_decoration_manager_v1
+ *
+ * Create a new decoration object associated with the given toplevel.
+ *
+ * Creating an xdg_toplevel_decoration from an xdg_toplevel which has a
+ * buffer attached or committed is a client error, and any attempts by a
+ * client to attach or manipulate a buffer prior to the first
+ * xdg_toplevel_decoration.configure event must also be treated as
+ * errors.
+ */
+static inline struct zxdg_toplevel_decoration_v1 *
+zxdg_decoration_manager_v1_get_toplevel_decoration(struct zxdg_decoration_manager_v1 *zxdg_decoration_manager_v1, struct xdg_toplevel *toplevel)
+{
+	struct wl_proxy *id;
+
+	id = wl_proxy_marshal_constructor((struct wl_proxy *) zxdg_decoration_manager_v1,
+			 ZXDG_DECORATION_MANAGER_V1_GET_TOPLEVEL_DECORATION, &zxdg_toplevel_decoration_v1_interface, NULL, toplevel);
+
+	return (struct zxdg_toplevel_decoration_v1 *) id;
+}
+
+#ifndef ZXDG_TOPLEVEL_DECORATION_V1_ERROR_ENUM
+#define ZXDG_TOPLEVEL_DECORATION_V1_ERROR_ENUM
+enum zxdg_toplevel_decoration_v1_error {
+	/**
+	 * xdg_toplevel has a buffer attached before configure
+	 */
+	ZXDG_TOPLEVEL_DECORATION_V1_ERROR_UNCONFIGURED_BUFFER = 0,
+	/**
+	 * xdg_toplevel already has a decoration object
+	 */
+	ZXDG_TOPLEVEL_DECORATION_V1_ERROR_ALREADY_CONSTRUCTED = 1,
+	/**
+	 * xdg_toplevel destroyed before the decoration object
+	 */
+	ZXDG_TOPLEVEL_DECORATION_V1_ERROR_ORPHANED = 2,
+};
+#endif /* ZXDG_TOPLEVEL_DECORATION_V1_ERROR_ENUM */
+
+#ifndef ZXDG_TOPLEVEL_DECORATION_V1_MODE_ENUM
+#define ZXDG_TOPLEVEL_DECORATION_V1_MODE_ENUM
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ * window decoration modes
+ *
+ * These values describe window decoration modes.
+ */
+enum zxdg_toplevel_decoration_v1_mode {
+	/**
+	 * no server-side window decoration
+	 */
+	ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE = 1,
+	/**
+	 * server-side window decoration
+	 */
+	ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE = 2,
+};
+#endif /* ZXDG_TOPLEVEL_DECORATION_V1_MODE_ENUM */
+
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ * @struct zxdg_toplevel_decoration_v1_listener
+ */
+struct zxdg_toplevel_decoration_v1_listener {
+	/**
+	 * suggest a surface change
+	 *
+	 * The configure event asks the client to change its decoration
+	 * mode. The configured state should not be applied immediately.
+	 * Clients must send an ack_configure in response to this event.
+	 * See xdg_surface.configure and xdg_surface.ack_configure for
+	 * details.
+	 *
+	 * A configure event can be sent at any time. The specified mode
+	 * must be obeyed by the client.
+	 * @param mode the decoration mode
+	 */
+	void (*configure)(void *data,
+			  struct zxdg_toplevel_decoration_v1 *zxdg_toplevel_decoration_v1,
+			  uint32_t mode);
+};
+
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ */
+static inline int
+zxdg_toplevel_decoration_v1_add_listener(struct zxdg_toplevel_decoration_v1 *zxdg_toplevel_decoration_v1,
+					 const struct zxdg_toplevel_decoration_v1_listener *listener, void *data)
+{
+	return wl_proxy_add_listener((struct wl_proxy *) zxdg_toplevel_decoration_v1,
+				     (void (**)(void)) listener, data);
+}
+
+#define ZXDG_TOPLEVEL_DECORATION_V1_DESTROY 0
+#define ZXDG_TOPLEVEL_DECORATION_V1_SET_MODE 1
+#define ZXDG_TOPLEVEL_DECORATION_V1_UNSET_MODE 2
+
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ */
+#define ZXDG_TOPLEVEL_DECORATION_V1_CONFIGURE_SINCE_VERSION 1
+
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ */
+#define ZXDG_TOPLEVEL_DECORATION_V1_DESTROY_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ */
+#define ZXDG_TOPLEVEL_DECORATION_V1_SET_MODE_SINCE_VERSION 1
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ */
+#define ZXDG_TOPLEVEL_DECORATION_V1_UNSET_MODE_SINCE_VERSION 1
+
+/** @ingroup iface_zxdg_toplevel_decoration_v1 */
+static inline void
+zxdg_toplevel_decoration_v1_set_user_data(struct zxdg_toplevel_decoration_v1 *zxdg_toplevel_decoration_v1, void *user_data)
+{
+	wl_proxy_set_user_data((struct wl_proxy *) zxdg_toplevel_decoration_v1, user_data);
+}
+
+/** @ingroup iface_zxdg_toplevel_decoration_v1 */
+static inline void *
+zxdg_toplevel_decoration_v1_get_user_data(struct zxdg_toplevel_decoration_v1 *zxdg_toplevel_decoration_v1)
+{
+	return wl_proxy_get_user_data((struct wl_proxy *) zxdg_toplevel_decoration_v1);
+}
+
+static inline uint32_t
+zxdg_toplevel_decoration_v1_get_version(struct zxdg_toplevel_decoration_v1 *zxdg_toplevel_decoration_v1)
+{
+	return wl_proxy_get_version((struct wl_proxy *) zxdg_toplevel_decoration_v1);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ *
+ * Switch back to a mode without any server-side decorations at the next
+ * commit.
+ */
+static inline void
+zxdg_toplevel_decoration_v1_destroy(struct zxdg_toplevel_decoration_v1 *zxdg_toplevel_decoration_v1)
+{
+	wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_decoration_v1,
+			 ZXDG_TOPLEVEL_DECORATION_V1_DESTROY);
+
+	wl_proxy_destroy((struct wl_proxy *) zxdg_toplevel_decoration_v1);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ *
+ * Set the toplevel surface decoration mode. This informs the compositor
+ * that the client prefers the provided decoration mode.
+ *
+ * After requesting a decoration mode, the compositor will respond by
+ * emitting a xdg_surface.configure event. The client should then update
+ * its content, drawing it without decorations if the received mode is
+ * server-side decorations. The client must also acknowledge the configure
+ * when committing the new content (see xdg_surface.ack_configure).
+ *
+ * The compositor can decide not to use the client's mode and enforce a
+ * different mode instead.
+ *
+ * Clients whose decoration mode depend on the xdg_toplevel state may send
+ * a set_mode request in response to a xdg_surface.configure event and wait
+ * for the next xdg_surface.configure event to prevent unwanted state.
+ * Such clients are responsible for preventing configure loops and must
+ * make sure not to send multiple successive set_mode requests with the
+ * same decoration mode.
+ */
+static inline void
+zxdg_toplevel_decoration_v1_set_mode(struct zxdg_toplevel_decoration_v1 *zxdg_toplevel_decoration_v1, uint32_t mode)
+{
+	wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_decoration_v1,
+			 ZXDG_TOPLEVEL_DECORATION_V1_SET_MODE, mode);
+}
+
+/**
+ * @ingroup iface_zxdg_toplevel_decoration_v1
+ *
+ * Unset the toplevel surface decoration mode. This informs the compositor
+ * that the client doesn't prefer a particular decoration mode.
+ *
+ * This request has the same semantics as set_mode.
+ */
+static inline void
+zxdg_toplevel_decoration_v1_unset_mode(struct zxdg_toplevel_decoration_v1 *zxdg_toplevel_decoration_v1)
+{
+	wl_proxy_marshal((struct wl_proxy *) zxdg_toplevel_decoration_v1,
+			 ZXDG_TOPLEVEL_DECORATION_V1_UNSET_MODE);
+}
+
+#ifdef  __cplusplus
+}
+#endif
+
+#endif

app/internal/window/wayland_xdg_shell.c

@@ -0,0 +1,176 @@
+// +build linux,!android
+
+/* Generated by wayland-scanner 1.16.0 */
+
+/*
+ * Copyright © 2008-2013 Kristian Høgsberg
+ * Copyright © 2013      Rafael Antognolli
+ * Copyright © 2013      Jasper St. Pierre
+ * Copyright © 2010-2013 Intel Corporation
+ * Copyright © 2015-2017 Samsung Electronics Co., Ltd
+ * Copyright © 2015-2017 Red Hat Inc.
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice (including the next
+ * paragraph) shall be included in all copies or substantial portions of the
+ * Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+ * DEALINGS IN THE SOFTWARE.
+ */
+
+#include <stdlib.h>
+#include <stdint.h>
+#include "wayland-util.h"
+
+#ifndef __has_attribute
+# define __has_attribute(x) 0  /* Compatibility with non-clang compilers. */
+#endif
+
+#if (__has_attribute(visibility) || defined(__GNUC__) && __GNUC__ >= 4)
+#define WL_PRIVATE __attribute__ ((visibility("hidden")))
+#else
+#define WL_PRIVATE
+#endif
+
+extern const struct wl_interface wl_output_interface;
+extern const struct wl_interface wl_seat_interface;
+extern const struct wl_interface wl_surface_interface;
+extern const struct wl_interface xdg_popup_interface;
+extern const struct wl_interface xdg_positioner_interface;
+extern const struct wl_interface xdg_surface_interface;
+extern const struct wl_interface xdg_toplevel_interface;
+
+static const struct wl_interface *types[] = {
+	NULL,
+	NULL,
+	NULL,
+	NULL,
+	&xdg_positioner_interface,
+	&xdg_surface_interface,
+	&wl_surface_interface,
+	&xdg_toplevel_interface,
+	&xdg_popup_interface,
+	&xdg_surface_interface,
+	&xdg_positioner_interface,
+	&xdg_toplevel_interface,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	&wl_seat_interface,
+	NULL,
+	NULL,
+	&wl_output_interface,
+	&wl_seat_interface,
+	NULL,
+};
+
+static const struct wl_message xdg_wm_base_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "create_positioner", "n", types + 4 },
+	{ "get_xdg_surface", "no", types + 5 },
+	{ "pong", "u", types + 0 },
+};
+
+static const struct wl_message xdg_wm_base_events[] = {
+	{ "ping", "u", types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_wm_base_interface = {
+	"xdg_wm_base", 2,
+	4, xdg_wm_base_requests,
+	1, xdg_wm_base_events,
+};
+
+static const struct wl_message xdg_positioner_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "set_size", "ii", types + 0 },
+	{ "set_anchor_rect", "iiii", types + 0 },
+	{ "set_anchor", "u", types + 0 },
+	{ "set_gravity", "u", types + 0 },
+	{ "set_constraint_adjustment", "u", types + 0 },
+	{ "set_offset", "ii", types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_positioner_interface = {
+	"xdg_positioner", 2,
+	7, xdg_positioner_requests,
+	0, NULL,
+};
+
+static const struct wl_message xdg_surface_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "get_toplevel", "n", types + 7 },
+	{ "get_popup", "n?oo", types + 8 },
+	{ "set_window_geometry", "iiii", types + 0 },
+	{ "ack_configure", "u", types + 0 },
+};
+
+static const struct wl_message xdg_surface_events[] = {
+	{ "configure", "u", types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_surface_interface = {
+	"xdg_surface", 2,
+	5, xdg_surface_requests,
+	1, xdg_surface_events,
+};
+
+static const struct wl_message xdg_toplevel_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "set_parent", "?o", types + 11 },
+	{ "set_title", "s", types + 0 },
+	{ "set_app_id", "s", types + 0 },
+	{ "show_window_menu", "ouii", types + 12 },
+	{ "move", "ou", types + 16 },
+	{ "resize", "ouu", types + 18 },
+	{ "set_max_size", "ii", types + 0 },
+	{ "set_min_size", "ii", types + 0 },
+	{ "set_maximized", "", types + 0 },
+	{ "unset_maximized", "", types + 0 },
+	{ "set_fullscreen", "?o", types + 21 },
+	{ "unset_fullscreen", "", types + 0 },
+	{ "set_minimized", "", types + 0 },
+};
+
+static const struct wl_message xdg_toplevel_events[] = {
+	{ "configure", "iia", types + 0 },
+	{ "close", "", types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_toplevel_interface = {
+	"xdg_toplevel", 2,
+	14, xdg_toplevel_requests,
+	2, xdg_toplevel_events,
+};
+
+static const struct wl_message xdg_popup_requests[] = {
+	{ "destroy", "", types + 0 },
+	{ "grab", "ou", types + 22 },
+};
+
+static const struct wl_message xdg_popup_events[] = {
+	{ "configure", "iiii", types + 0 },
+	{ "popup_done", "", types + 0 },
+};
+
+WL_PRIVATE const struct wl_interface xdg_popup_interface = {
+	"xdg_popup", 2,
+	2, xdg_popup_requests,
+	2, xdg_popup_events,
+};
+

app/internal/window/window.go

@@ -0,0 +1,121 @@
+// SPDX-License-Identifier: Unlicense OR MIT
+
+// Package window implements platform specific windows
+// and GPU contexts.
+package window
+
+import (
+	"errors"
+	"math"
+	"time"
+
+	"gioui.org/app/internal/gl"
+	"gioui.org/io/event"
+	"gioui.org/io/system"
+	"gioui.org/unit"
+)
+
+type Options struct {
+	Width, Height unit.Value
+	Title         string
+}
+
+type FrameEvent struct {
+	system.FrameEvent
+
+	Sync bool
+}
+
+type Callbacks interface {
+	SetDriver(d Driver)
+	Event(e event.Event)
+}
+
+// Driver is the interface for the platform implementation
+// of a window.
+type Driver interface {
+	// SetAnimating sets the animation flag. When the window is animating,
+	// FrameEvents are delivered as fast as the display can handle them.
+	SetAnimating(anim bool)
+	// ShowTextInput updates the virtual keyboard state.
+	ShowTextInput(show bool)
+	NewContext() (gl.Context, error)
+}
+
+type windowRendezvous struct {
+	in   chan windowAndOptions
+	out  chan windowAndOptions
+	errs chan error
+}
+
+type windowAndOptions struct {
+	window Callbacks
+	opts   *Options
+}
+
+// config implements the system.Config interface.
+type config struct {
+	// Device pixels per dp.
+	pxPerDp float32
+	// Device pixels per sp.
+	pxPerSp float32
+	now     time.Time
+}
+
+func (c *config) Now() time.Time {
+	return c.now
+}
+
+func (c *config) Px(v unit.Value) int {
+	var r float32
+	switch v.U {
+	case unit.UnitPx:
+		r = v.V
+	case unit.UnitDp:
+		r = c.pxPerDp * v.V
+	case unit.UnitSp:
+		r = c.pxPerSp * v.V
+	default:
+		panic("unknown unit")
+	}
+	return int(math.Round(float64(r)))
+}
+
+func newWindowRendezvous() *windowRendezvous {
+	wr := &windowRendezvous{
+		in:   make(chan windowAndOptions),
+		out:  make(chan windowAndOptions),
+		errs: make(chan error),
+	}
+	go func() {
+		var main windowAndOptions
+		var out chan windowAndOptions
+		for {
+			select {
+			case w := <-wr.in:
+				var err error
+				if main.window != nil {
+					err = errors.New("multiple windows are not supported")
+				}
+				wr.errs <- err
+				main = w
+				out = wr.out
+			case out <- main:
+			}
+		}
+	}()
+	return wr
+}
+
+const (
+	inchPrDp = 1.0 / 160
+	mmPrDp   = 25.4 / 160
+	// monitorScale is the extra scale applied to
+	// monitor outputs to compensate for the extra
+	// viewing distance compared to phone and tables.
+	monitorScale = 1.20
+	// minDensity is the minimum pixels per dp to
+	// ensure font and ui legibility on low-dpi
+	// screens.
+	minDensity = 1.25
+)