app: introduce Config.Focused that tracks the window focus state

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

.builds/apple.yml

@@ -29,7 +29,7 @@ environment:
 tasks:
  - install_go: |
      mkdir -p /home/build/sdk
-     curl -s https://dl.google.com/go/go1.22.2.linux-amd64.tar.gz | tar -C /home/build/sdk -xzf -
+     curl -s https://dl.google.com/go/go1.19.11.linux-amd64.tar.gz | tar -C /home/build/sdk -xzf -
  - prepare_toolchain: |
      mkdir -p $APPLE_TOOLCHAIN_ROOT
      cd $APPLE_TOOLCHAIN_ROOT

.builds/freebsd.yml

@@ -16,7 +16,7 @@ environment:
 tasks:
  - install_go: |
      mkdir -p /home/build/sdk
-     curl https://dl.google.com/go/go1.22.2.freebsd-amd64.tar.gz | tar -C /home/build/sdk -xzf -
+     curl https://dl.google.com/go/go1.19.11.freebsd-amd64.tar.gz | tar -C /home/build/sdk -xzf -
  - test_gio: |
      cd gio
      go test ./...

.builds/linux.yml

@@ -40,7 +40,7 @@ secrets:
 tasks:
  - install_go: |
      mkdir -p /home/build/sdk
-     curl -s https://dl.google.com/go/go1.22.2.linux-amd64.tar.gz | tar -C /home/build/sdk -xzf -
+     curl -s https://dl.google.com/go/go1.19.11.linux-amd64.tar.gz | tar -C /home/build/sdk -xzf -
  - check_gofmt: |
      cd gio
      test -z "$(gofmt -s -l .)"
@@ -80,8 +80,6 @@ tasks:
      unzip -q ndk.zip
      rm ndk.zip
      mv android-ndk-* ndk-bundle
-     # sdkmanager needs lots of file descriptors
-     ulimit -n 10000
      yes|sdkmanager --licenses
      sdkmanager "platforms;android-31" "build-tools;32.0.0"
  - test_android: |

.builds/openbsd.yml

@@ -10,7 +10,7 @@ environment:
 tasks:
  - install_go: |
      mkdir -p /home/build/sdk
-     curl https://dl.google.com/go/go1.22.2.src.tar.gz | tar -C /home/build/sdk -xzf -
+     curl https://dl.google.com/go/go1.19.11.src.tar.gz | tar -C /home/build/sdk -xzf -
      cd /home/build/sdk/go/src
      ./make.bash
  - test_gio: |

app/app.go

@@ -61,10 +61,6 @@ type FrameEvent struct {
 type ViewEvent interface {
 	implementsViewEvent()
 	ImplementsEvent()
-	// Valid will return true when the ViewEvent does contains valid handles.
-	// If a window receives an invalid ViewEvent, it should deinitialize any
-	// state referring to handles from a previous ViewEvent.
-	Valid() bool
 }
 
 // Insets is the space taken up by

app/egl_android.go

@@ -17,8 +17,9 @@ import (
 )
 
 type androidContext struct {
-	win     *window
-	eglSurf egl.NativeWindowType
+	win           *window
+	eglSurf       egl.NativeWindowType
+	width, height int
 	*egl.Context
 }
 
@@ -44,8 +45,9 @@ func (c *androidContext) Refresh() error {
 	if err := c.win.setVisual(c.Context.VisualID()); err != nil {
 		return err
 	}
-	win, _, _ := c.win.nativeWindow()
+	win, width, height := c.win.nativeWindow()
 	c.eglSurf = egl.NativeWindowType(unsafe.Pointer(win))
+	c.width, c.height = width, height
 	return nil
 }
 
@@ -53,7 +55,7 @@ func (c *androidContext) Lock() error {
 	// The Android emulator creates a broken surface if it is not
 	// created on the same thread as the context is made current.
 	if c.eglSurf != nil {
-		if err := c.Context.CreateSurface(c.eglSurf); err != nil {
+		if err := c.Context.CreateSurface(c.eglSurf, c.width, c.height); err != nil {
 			return err
 		}
 		c.eglSurf = nil

app/egl_wayland.go

@@ -69,7 +69,7 @@ func (c *wlContext) Refresh() error {
 	}
 	c.eglWin = eglWin
 	eglSurf := egl.NativeWindowType(uintptr(unsafe.Pointer(eglWin)))
-	if err := c.Context.CreateSurface(eglSurf); err != nil {
+	if err := c.Context.CreateSurface(eglSurf, width, height); err != nil {
 		return err
 	}
 	if err := c.Context.MakeCurrent(); err != nil {

app/egl_windows.go

@@ -5,6 +5,8 @@
 package app
 
 import (
+	"golang.org/x/sys/windows"
+
 	"gioui.org/internal/egl"
 )
 
@@ -22,18 +24,6 @@ func init() {
 			if err != nil {
 				return nil, err
 			}
-			win, _, _ := w.HWND()
-			eglSurf := egl.NativeWindowType(win)
-			if err := ctx.CreateSurface(eglSurf); err != nil {
-				ctx.Release()
-				return nil, err
-			}
-			if err := ctx.MakeCurrent(); err != nil {
-				ctx.Release()
-				return nil, err
-			}
-			defer ctx.ReleaseCurrent()
-			ctx.EnableVSync(true)
 			return &glContext{win: w, Context: ctx}, nil
 		},
 	})
@@ -47,6 +37,21 @@ func (c *glContext) Release() {
 }
 
 func (c *glContext) Refresh() error {
+	c.Context.ReleaseSurface()
+	var (
+		win           windows.Handle
+		width, height int
+	)
+	win, width, height = c.win.HWND()
+	eglSurf := egl.NativeWindowType(win)
+	if err := c.Context.CreateSurface(eglSurf, width, height); err != nil {
+		return err
+	}
+	if err := c.Context.MakeCurrent(); err != nil {
+		return err
+	}
+	c.Context.EnableVSync(true)
+	c.Context.ReleaseCurrent()
 	return nil
 }
 

app/egl_x11.go

@@ -25,18 +25,6 @@ func init() {
 		if err != nil {
 			return nil, err
 		}
-		win, _, _ := w.window()
-		eglSurf := egl.NativeWindowType(uintptr(win))
-		if err := ctx.CreateSurface(eglSurf); err != nil {
-			ctx.Release()
-			return nil, err
-		}
-		if err := ctx.MakeCurrent(); err != nil {
-			ctx.Release()
-			return nil, err
-		}
-		defer ctx.ReleaseCurrent()
-		ctx.EnableVSync(true)
 		return &x11Context{win: w, Context: ctx}, nil
 	}
 }
@@ -49,6 +37,17 @@ func (c *x11Context) Release() {
 }
 
 func (c *x11Context) Refresh() error {
+	c.Context.ReleaseSurface()
+	win, width, height := c.win.window()
+	eglSurf := egl.NativeWindowType(uintptr(win))
+	if err := c.Context.CreateSurface(eglSurf, width, height); err != nil {
+		return err
+	}
+	if err := c.Context.MakeCurrent(); err != nil {
+		return err
+	}
+	defer c.Context.ReleaseCurrent()
+	c.Context.EnableVSync(true)
 	return nil
 }
 

app/gl_macos.m

@@ -7,7 +7,7 @@
 #include <OpenGL/OpenGL.h>
 #include "_cgo_export.h"
 
-CALayer *gio_layerFactory(BOOL presentWithTrans) {
+CALayer *gio_layerFactory(void) {
 	@autoreleasepool {
 		return [CALayer layer];
 	}

app/internal/windows/windows.go

@@ -266,7 +266,6 @@ const (
 	WM_MOUSEWHEEL           = 0x020A
 	WM_MOUSEHWHEEL          = 0x020E
 	WM_NCACTIVATE           = 0x0086
-	WM_NCLBUTTONDBLCLK      = 0x00A3
 	WM_NCHITTEST            = 0x0084
 	WM_NCCALCSIZE           = 0x0083
 	WM_PAINT                = 0x000F

app/metal_macos.go

@@ -12,12 +12,12 @@ package app
 #import <QuartzCore/CAMetalLayer.h>
 #include <CoreFoundation/CoreFoundation.h>
 
-CALayer *gio_layerFactory(BOOL presentWithTrans) {
+CALayer *gio_layerFactory(void) {
 	@autoreleasepool {
 		CAMetalLayer *l = [CAMetalLayer layer];
 		l.autoresizingMask = kCALayerHeightSizable|kCALayerWidthSizable;
 		l.needsDisplayOnBoundsChange = YES;
-		l.presentsWithTransaction = presentWithTrans;
+		l.presentsWithTransaction = YES;
 		return l;
 	}
 }

app/os.go

@@ -173,13 +173,19 @@ type context interface {
 	Unlock()
 }
 
-// driver is the interface for the platform implementation
-// of a window.
-type driver interface {
-	// Event blocks until an event is available and returns it.
+// basicDriver is the subset of [driver] that may be called even after
+// a window is destroyed.
+type basicDriver interface {
+	// Event blocks until an even is available and returns it.
 	Event() event.Event
 	// Invalidate requests a FrameEvent.
 	Invalidate()
+}
+
+// driver is the interface for the platform implementation
+// of a window.
+type driver interface {
+	basicDriver
 	// SetAnimating sets the animation flag. When the window is animating,
 	// FrameEvents are delivered as fast as the display can handle them.
 	SetAnimating(anim bool)

app/os_android.go

@@ -1495,6 +1495,3 @@ func Java_org_gioui_Gio_scheduleMainFuncs(env *C.JNIEnv, cls C.jclass) {
 
 func (AndroidViewEvent) implementsViewEvent() {}
 func (AndroidViewEvent) ImplementsEvent()     {}
-func (a AndroidViewEvent) Valid() bool {
-	return a != (AndroidViewEvent{})
-}

app/os_darwin.go

@@ -75,13 +75,9 @@ var displayLinks sync.Map
 
 var mainFuncs = make(chan func(), 1)
 
-func isMainThread() bool {
-	return bool(C.isMainThread())
-}
-
 // runOnMain runs the function on the main thread.
 func runOnMain(f func()) {
-	if isMainThread() {
+	if C.isMainThread() {
 		f()
 		return
 	}

app/os_ios.go

@@ -12,7 +12,6 @@ package app
 #include <UIKit/UIKit.h>
 #include <stdint.h>
 
-__attribute__ ((visibility ("hidden"))) int gio_applicationMain(int argc, char *argv[]);
 __attribute__ ((visibility ("hidden"))) void gio_viewSetHandle(CFTypeRef viewRef, uintptr_t handle);
 
 struct drawParams {
@@ -22,7 +21,6 @@ struct drawParams {
 };
 
 static void writeClipboard(unichar *chars, NSUInteger length) {
-#if !TARGET_OS_TV
 	@autoreleasepool {
 		NSString *s = [NSString string];
 		if (length > 0) {
@@ -31,18 +29,13 @@ static void writeClipboard(unichar *chars, NSUInteger length) {
 		UIPasteboard *p = UIPasteboard.generalPasteboard;
 		p.string = s;
 	}
-#endif
 }
 
 static CFTypeRef readClipboard(void) {
-#if !TARGET_OS_TV
 	@autoreleasepool {
 		UIPasteboard *p = UIPasteboard.generalPasteboard;
 		return (__bridge_retained CFTypeRef)p.string;
 	}
-#else
-	return nil;
-#endif
 }
 
 static void showTextInput(CFTypeRef viewRef) {
@@ -82,7 +75,6 @@ import "C"
 import (
 	"image"
 	"io"
-	"os"
 	"runtime"
 	"runtime/cgo"
 	"runtime/debug"
@@ -396,51 +388,13 @@ func newWindow(win *callbacks, options []Option) {
 	<-mainWindow.windows
 }
 
-var mainMode = mainModeUndefined
-
-const (
-	mainModeUndefined = iota
-	mainModeExe
-	mainModeLibrary
-)
-
 func osMain() {
-	if !isMainThread() {
-		panic("app.Main must be run on the main goroutine")
-	}
-	switch mainMode {
-	case mainModeUndefined:
-		mainMode = mainModeExe
-		var argv []*C.char
-		for _, arg := range os.Args {
-			a := C.CString(arg)
-			defer C.free(unsafe.Pointer(a))
-			argv = append(argv, a)
-		}
-		C.gio_applicationMain(C.int(len(argv)), unsafe.SliceData(argv))
-	case mainModeExe:
-		panic("app.Main may be called only once")
-	case mainModeLibrary:
-		// Do nothing, we're embedded as a library.
-	}
 }
 
 //export gio_runMain
 func gio_runMain() {
-	if !isMainThread() {
-		panic("app.Main must be run on the main goroutine")
-	}
-	switch mainMode {
-	case mainModeUndefined:
-		mainMode = mainModeLibrary
-		runMain()
-	case mainModeExe:
-		// Do nothing, main has already been called.
-	}
+	runMain()
 }
 
 func (UIKitViewEvent) implementsViewEvent() {}
 func (UIKitViewEvent) ImplementsEvent()     {}
-func (u UIKitViewEvent) Valid() bool {
-	return u != (UIKitViewEvent{})
-}

app/os_ios.m

@@ -26,13 +26,12 @@ CGFloat _keyboardHeight;
 	self.view.layoutMargins = UIEdgeInsetsMake(0, 0, 0, 0);
 	UIView *drawView = [[GioView alloc] initWithFrame:zeroFrame];
 	[self.view addSubview: drawView];
-#if !TARGET_OS_TV
+#ifndef TARGET_OS_TV
 	drawView.multipleTouchEnabled = YES;
 #endif
 	drawView.preservesSuperviewLayoutMargins = YES;
 	drawView.layoutMargins = UIEdgeInsetsMake(0, 0, 0, 0);
 	onCreate((__bridge CFTypeRef)drawView, (__bridge CFTypeRef)self);
-#if !TARGET_OS_TV
 	[[NSNotificationCenter defaultCenter] addObserver:self
 											 selector:@selector(keyboardWillChange:)
 												 name:UIKeyboardWillShowNotification
@@ -45,7 +44,6 @@ CGFloat _keyboardHeight;
 											 selector:@selector(keyboardWillHide:)
 												 name:UIKeyboardWillHideNotification
 											   object:nil];
-#endif
 	[[NSNotificationCenter defaultCenter] addObserver: self
 											 selector: @selector(applicationDidEnterBackground:)
 												 name: UIApplicationDidEnterBackgroundNotification
@@ -91,7 +89,6 @@ CGFloat _keyboardHeight;
 	[super didReceiveMemoryWarning];
 }
 
-#if !TARGET_OS_TV
 - (void)keyboardWillChange:(NSNotification *)note {
 	NSDictionary *userInfo = note.userInfo;
 	CGRect f = [userInfo[UIKeyboardFrameEndUserInfoKey] CGRectValue];
@@ -103,7 +100,6 @@ CGFloat _keyboardHeight;
 	_keyboardHeight = 0.0;
 	[self.view setNeedsLayout];
 }
-#endif
 @end
 
 static void handleTouches(int last, GioView *view, NSSet<UITouch *> *touches, UIEvent *event) {
@@ -280,23 +276,3 @@ void gio_viewSetHandle(CFTypeRef viewRef, uintptr_t handle) {
 	GioView *v = (__bridge GioView *)viewRef;
 	v.handle = handle;
 }
-
-@interface _gioAppDelegate : UIResponder <UIApplicationDelegate>
-@property (strong, nonatomic) UIWindow *window;
-@end
-
-@implementation _gioAppDelegate
-- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
-	self.window = [[UIWindow alloc] initWithFrame:[[UIScreen mainScreen] bounds]];
-	GioViewController *controller = [[GioViewController alloc] initWithNibName:nil bundle:nil];
-	self.window.rootViewController = controller;
-	[self.window makeKeyAndVisible];
-	return YES;
-}
-@end
-
-int gio_applicationMain(int argc, char *argv[]) {
-	@autoreleasepool {
-		return UIApplicationMain(argc, argv, nil, NSStringFromClass([_gioAppDelegate class]));
-	}
-}

app/os_js.go

@@ -822,6 +822,3 @@ func translateKey(k string) (key.Name, bool) {
 
 func (JSViewEvent) implementsViewEvent() {}
 func (JSViewEvent) ImplementsEvent()     {}
-func (j JSViewEvent) Valid() bool {
-	return !(j.Element.IsNull() || j.Element.IsUndefined())
-}

app/os_macos.go

@@ -40,7 +40,7 @@ import (
 #define MOUSE_SCROLL 4
 
 __attribute__ ((visibility ("hidden"))) void gio_main(void);
-__attribute__ ((visibility ("hidden"))) CFTypeRef gio_createView(int presentWithTrans);
+__attribute__ ((visibility ("hidden"))) CFTypeRef gio_createView(void);
 __attribute__ ((visibility ("hidden"))) CFTypeRef gio_createWindow(CFTypeRef viewRef, CGFloat width, CGFloat height, CGFloat minWidth, CGFloat minHeight, CGFloat maxWidth, CGFloat maxHeight);
 __attribute__ ((visibility ("hidden"))) void gio_viewSetHandle(CFTypeRef viewRef, uintptr_t handle);
 
@@ -195,14 +195,6 @@ static void setScreenFrame(CFTypeRef windowRef, CGFloat x, CGFloat y, CGFloat w,
 	}
 }
 
-static void resetLayerFrame(CFTypeRef viewRef) {
-	@autoreleasepool {
-		NSView* view = (__bridge NSView *)viewRef;
-		NSRect r = view.frame;
-		view.layer.frame = r;
-	}
-}
-
 static void hideWindow(CFTypeRef windowRef) {
 	@autoreleasepool {
 		NSWindow* window = (__bridge NSWindow *)windowRef;
@@ -464,9 +456,6 @@ func (w *window) Configure(options []Option) {
 		C.setWindowStandardButtonHidden(window, C.NSWindowCloseButton, barTrans)
 		C.setWindowStandardButtonHidden(window, C.NSWindowMiniaturizeButton, barTrans)
 		C.setWindowStandardButtonHidden(window, C.NSWindowZoomButton, barTrans)
-		// When toggling the titlebar, the layer doesn't update its frame
-		// until the next resize. Force it.
-		C.resetLayerFrame(w.view)
 	}
 	w.ProcessEvent(ConfigEvent{Config: w.config})
 }
@@ -925,9 +914,7 @@ func newWindow(win *callbacks, options []Option) {
 		w.loop = newEventLoop(w.w, w.wakeup)
 		win.SetDriver(w)
 		res <- struct{}{}
-		var cnf Config
-		cnf.apply(unit.Metric{}, options)
-		if err := w.init(cnf.CustomRenderer); err != nil {
+		if err := w.init(); err != nil {
 			w.ProcessEvent(DestroyEvent{Err: err})
 			return
 		}
@@ -948,12 +935,8 @@ func newWindow(win *callbacks, options []Option) {
 	<-res
 }
 
-func (w *window) init(customRenderer bool) error {
-	presentWithTrans := 1
-	if customRenderer {
-		presentWithTrans = 0
-	}
-	view := C.gio_createView(C.int(presentWithTrans))
+func (w *window) init() error {
+	view := C.gio_createView()
 	if view == 0 {
 		return errors.New("newOSWindow: failed to create view")
 	}
@@ -982,9 +965,6 @@ func (w *window) init(customRenderer bool) error {
 }
 
 func osMain() {
-	if !isMainThread() {
-		panic("app.Main must run on the main goroutine")
-	}
 	C.gio_main()
 }
 
@@ -1074,6 +1054,3 @@ func convertMods(mods C.NSUInteger) key.Modifiers {
 
 func (AppKitViewEvent) implementsViewEvent() {}
 func (AppKitViewEvent) ImplementsEvent()     {}
-func (a AppKitViewEvent) Valid() bool {
-	return a != (AppKitViewEvent{})
-}

app/os_macos.m

@@ -6,7 +6,7 @@
 
 #include "_cgo_export.h"
 
-__attribute__ ((visibility ("hidden"))) CALayer *gio_layerFactory(BOOL presentWithTrans);
+__attribute__ ((visibility ("hidden"))) CALayer *gio_layerFactory(void);
 
 @interface GioAppDelegate : NSObject<NSApplicationDelegate>
 @end
@@ -16,7 +16,6 @@ __attribute__ ((visibility ("hidden"))) CALayer *gio_layerFactory(BOOL presentWi
 
 @interface GioView : NSView <CALayerDelegate,NSTextInputClient>
 @property uintptr_t handle;
-@property BOOL presentWithTrans;
 @end
 
 @implementation GioWindowDelegate
@@ -48,17 +47,13 @@ __attribute__ ((visibility ("hidden"))) CALayer *gio_layerFactory(BOOL presentWi
 }
 - (void)windowDidBecomeKey:(NSNotification *)notification {
 	NSWindow *window = (NSWindow *)[notification object];
-	GioView *view = (GioView *)window.contentView;
-	if ([window firstResponder] == view) {
-		gio_onFocus(view.handle, 1);
-	}
+  GioView *view = (GioView *)window.contentView;
+	gio_onFocus(view.handle, 1);
 }
 - (void)windowDidResignKey:(NSNotification *)notification {
 	NSWindow *window = (NSWindow *)[notification object];
-	GioView *view = (GioView *)window.contentView;
-	if ([window firstResponder] == view) {
-		gio_onFocus(view.handle, 0);
-	}
+  GioView *view = (GioView *)window.contentView;
+	gio_onFocus(view.handle, 0);
 }
 @end
 
@@ -89,7 +84,7 @@ static void handleMouse(GioView *view, NSEvent *event, int typ, CGFloat dx, CGFl
 	gio_onDraw(self.handle);
 }
 - (CALayer *)makeBackingLayer {
-	CALayer *layer = gio_layerFactory(self.presentWithTrans);
+	CALayer *layer = gio_layerFactory();
 	layer.delegate = self;
 	return layer;
 }
@@ -210,14 +205,6 @@ static void handleMouse(GioView *view, NSEvent *event, int typ, CGFloat dx, CGFl
 - (void)dealloc {
 	gio_onDestroy(self.handle);
 }
-- (BOOL) becomeFirstResponder {
-	gio_onFocus(self.handle, 1);
-	return [super becomeFirstResponder];
- }
-- (BOOL) resignFirstResponder {
-	gio_onFocus(self.handle, 0);
-	return [super resignFirstResponder];
-}
 @end
 
 // Delegates are weakly referenced from their peers. Nothing
@@ -393,11 +380,10 @@ CFTypeRef gio_createWindow(CFTypeRef viewRef, CGFloat width, CGFloat height, CGF
 	}
 }
 
-CFTypeRef gio_createView(int presentWithTrans) {
+CFTypeRef gio_createView(void) {
 	@autoreleasepool {
 		NSRect frame = NSMakeRect(0, 0, 0, 0);
 		GioView* view = [[GioView alloc] initWithFrame:frame];
-		view.presentWithTrans = presentWithTrans ? YES : NO;
 		view.wantsLayer = YES;
 		view.layerContentsRedrawPolicy = NSViewLayerContentsRedrawDuringViewResize;
 

app/os_unix.go

@@ -9,6 +9,7 @@ import (
 	"errors"
 	"unsafe"
 
+	"gioui.org/io/event"
 	"gioui.org/io/pointer"
 )
 
@@ -21,9 +22,6 @@ type X11ViewEvent struct {
 
 func (X11ViewEvent) implementsViewEvent() {}
 func (X11ViewEvent) ImplementsEvent()     {}
-func (x X11ViewEvent) Valid() bool {
-	return x != (X11ViewEvent{})
-}
 
 type WaylandViewEvent struct {
 	// Display is the *wl_display returned by wl_display_connect.
@@ -34,9 +32,6 @@ type WaylandViewEvent struct {
 
 func (WaylandViewEvent) implementsViewEvent() {}
 func (WaylandViewEvent) ImplementsEvent()     {}
-func (w WaylandViewEvent) Valid() bool {
-	return w != (WaylandViewEvent{})
-}
 
 func osMain() {
 	select {}
@@ -62,12 +57,35 @@ func newWindow(window *callbacks, options []Option) {
 			errFirst = err
 		}
 	}
+	window.SetDriver(&dummyDriver{
+		win:     window,
+		wakeups: make(chan event.Event, 1),
+	})
 	if errFirst == nil {
 		errFirst = errors.New("app: no window driver available")
 	}
 	window.ProcessEvent(DestroyEvent{Err: errFirst})
 }
 
+type dummyDriver struct {
+	win     *callbacks
+	wakeups chan event.Event
+}
+
+func (d *dummyDriver) Event() event.Event {
+	if e, ok := d.win.nextEvent(); ok {
+		return e
+	}
+	return <-d.wakeups
+}
+
+func (d *dummyDriver) Invalidate() {
+	select {
+	case d.wakeups <- wakeupEvent{}:
+	default:
+	}
+}
+
 // xCursor contains mapping from pointer.Cursor to XCursor.
 var xCursor = [...]string{
 	pointer.CursorDefault:                  "left_ptr",

app/os_wayland.go

@@ -216,7 +216,9 @@ type window struct {
 
 	wakeups chan struct{}
 
-	closing bool
+	// invMu avoids the race between the destruction of disp and
+	// Invalidate waking it up.
+	invMu sync.Mutex
 }
 
 type poller struct {
@@ -554,7 +556,7 @@ func gio_onXdgSurfaceConfigure(data unsafe.Pointer, wmSurf *C.struct_xdg_surface
 //export gio_onToplevelClose
 func gio_onToplevelClose(data unsafe.Pointer, topLvl *C.struct_xdg_toplevel) {
 	w := callbackLoad(data).(*window)
-	w.closing = true
+	w.close(nil)
 }
 
 //export gio_onToplevelConfigure
@@ -1137,7 +1139,7 @@ func (w *window) Perform(actions system.Action) {
 	walkActions(actions, func(action system.Action) {
 		switch action {
 		case system.ActionClose:
-			w.closing = true
+			w.close(nil)
 		}
 	})
 }
@@ -1364,9 +1366,6 @@ func gio_onFrameDone(data unsafe.Pointer, callback *C.struct_wl_callback, t C.ui
 func (w *window) close(err error) {
 	w.ProcessEvent(WaylandViewEvent{})
 	w.ProcessEvent(DestroyEvent{Err: err})
-	w.destroy()
-	w.disp.destroy()
-	w.disp = nil
 }
 
 func (w *window) dispatch() {
@@ -1375,7 +1374,7 @@ func (w *window) dispatch() {
 		w.w.Invalidate()
 		return
 	}
-	if err := w.disp.dispatch(); err != nil || w.closing {
+	if err := w.disp.dispatch(); err != nil {
 		w.close(err)
 		return
 	}
@@ -1400,6 +1399,13 @@ func (w *window) Event() event.Event {
 			w.dispatch()
 			continue
 		}
+		if _, destroy := evt.(DestroyEvent); destroy {
+			w.destroy()
+			w.invMu.Lock()
+			w.disp.destroy()
+			w.disp = nil
+			w.invMu.Unlock()
+		}
 		return evt
 	}
 }
@@ -1410,7 +1416,11 @@ func (w *window) Invalidate() {
 	default:
 		return
 	}
-	w.disp.wakeup()
+	w.invMu.Lock()
+	defer w.invMu.Unlock()
+	if w.disp != nil {
+		w.disp.wakeup()
+	}
 }
 
 func (w *window) Run(f func()) {
@@ -1505,10 +1515,6 @@ func (d *wlDisplay) wakeup() {
 }
 
 func (w *window) destroy() {
-	if w.lastFrameCallback != nil {
-		C.wl_callback_destroy(w.lastFrameCallback)
-		w.lastFrameCallback = nil
-	}
 	if w.cursor.surf != nil {
 		C.wl_surface_destroy(w.cursor.surf)
 	}
@@ -1633,14 +1639,6 @@ func (w *window) flushScroll() {
 	if total == (f32.Point{}) {
 		return
 	}
-	if w.scroll.steps == (image.Point{}) {
-		w.fling.xExtrapolation.SampleDelta(w.scroll.time, -w.scroll.dist.X)
-		w.fling.yExtrapolation.SampleDelta(w.scroll.time, -w.scroll.dist.Y)
-	}
-	// Zero scroll distance prior to calling ProcessEvent, otherwise we may recursively
-	// re-process the scroll distance.
-	w.scroll.dist = f32.Point{}
-	w.scroll.steps = image.Point{}
 	w.ProcessEvent(pointer.Event{
 		Kind:      pointer.Scroll,
 		Source:    pointer.Mouse,
@@ -1650,6 +1648,12 @@ func (w *window) flushScroll() {
 		Time:      w.scroll.time,
 		Modifiers: w.disp.xkb.Modifiers(),
 	})
+	if w.scroll.steps == (image.Point{}) {
+		w.fling.xExtrapolation.SampleDelta(w.scroll.time, -w.scroll.dist.X)
+		w.fling.yExtrapolation.SampleDelta(w.scroll.time, -w.scroll.dist.Y)
+	}
+	w.scroll.dist = f32.Point{}
+	w.scroll.steps = image.Point{}
 }
 
 func (w *window) onPointerMotion(x, y C.wl_fixed_t, t C.uint32_t) {

app/os_windows.go

@@ -54,6 +54,9 @@ type window struct {
 	borderSize image.Point
 	config     Config
 	loop       *eventLoop
+
+	// invMu avoids the race between destroying the window and Invalidate.
+	invMu sync.Mutex
 }
 
 const _WM_WAKEUP = windows.WM_USER + iota
@@ -301,8 +304,10 @@ func windowProc(hwnd syscall.Handle, msg uint32, wParam, lParam uintptr) uintptr
 			windows.ReleaseDC(w.hdc)
 			w.hdc = 0
 		}
+		w.invMu.Lock()
 		// The system destroys the HWND for us.
 		w.hwnd = 0
+		w.invMu.Unlock()
 		windows.PostQuitMessage(0)
 	case windows.WM_NCCALCSIZE:
 		if w.config.Decorated {
@@ -326,12 +331,6 @@ func windowProc(hwnd syscall.Handle, msg uint32, wParam, lParam uintptr) uintptr
 		mi := windows.GetMonitorInfo(w.hwnd)
 		szp.Rgrc[0] = mi.WorkArea
 		return 0
-	case windows.WM_NCLBUTTONDBLCLK:
-		if !w.config.Decorated {
-			// Override Windows behaviour when we
-			// draw decorations.
-			return 0
-		}
 	case windows.WM_PAINT:
 		w.draw(true)
 	case windows.WM_SIZE:
@@ -621,6 +620,13 @@ func (w *window) Frame(frame *op.Ops) {
 }
 
 func (w *window) wakeup() {
+	w.invMu.Lock()
+	defer w.invMu.Unlock()
+	if w.hwnd == 0 {
+		w.loop.Wakeup()
+		w.loop.FlushEvents()
+		return
+	}
 	if err := windows.PostMessage(w.hwnd, _WM_WAKEUP, 0, 0); err != nil {
 		panic(err)
 	}
@@ -987,6 +993,3 @@ func configForDPI(dpi int) unit.Metric {
 
 func (Win32ViewEvent) implementsViewEvent() {}
 func (Win32ViewEvent) ImplementsEvent()     {}
-func (w Win32ViewEvent) Valid() bool {
-	return w != (Win32ViewEvent{})
-}

app/os_x11.go

@@ -113,6 +113,9 @@ type x11Window struct {
 	wakeups chan struct{}
 	handler x11EventHandler
 	buf     [100]byte
+
+	// invMy avoids the race between destroy and Invalidate.
+	invMu sync.Mutex
 }
 
 var (
@@ -386,7 +389,6 @@ func (w *x11Window) ProcessEvent(e event.Event) {
 func (w *x11Window) shutdown(err error) {
 	w.ProcessEvent(X11ViewEvent{})
 	w.ProcessEvent(DestroyEvent{Err: err})
-	w.destroy()
 }
 
 func (w *x11Window) Event() event.Event {
@@ -396,6 +398,9 @@ func (w *x11Window) Event() event.Event {
 			w.dispatch()
 			continue
 		}
+		if _, destroy := evt.(DestroyEvent); destroy {
+			w.destroy()
+		}
 		return evt
 	}
 }
@@ -413,6 +418,11 @@ func (w *x11Window) Invalidate() {
 	case w.wakeups <- struct{}{}:
 	default:
 	}
+	w.invMu.Lock()
+	defer w.invMu.Unlock()
+	if w.x == nil {
+		return
+	}
 	if _, err := syscall.Write(w.notify.write, x11OneByte); err != nil && err != syscall.EAGAIN {
 		panic(fmt.Errorf("failed to write to pipe: %v", err))
 	}
@@ -454,12 +464,7 @@ func (w *x11Window) dispatch() {
 	// Check for pending draw events before checking animation or blocking.
 	// This fixes an issue on Xephyr where on startup XPending() > 0 but
 	// poll will still block. This also prevents no-op calls to poll.
-	syn = w.handler.handleEvents()
-	if w.x == nil {
-		// handleEvents received a close request and destroyed the window.
-		return
-	}
-	if !syn {
+	if syn = w.handler.handleEvents(); !syn {
 		anim = w.animating
 		if !anim {
 			// Clear poll events.
@@ -471,9 +476,6 @@ func (w *x11Window) dispatch() {
 			switch {
 			case *xEvents&syscall.POLLIN != 0:
 				syn = w.handler.handleEvents()
-				if w.x == nil {
-					return
-				}
 			case *xEvents&(syscall.POLLERR|syscall.POLLHUP) != 0:
 			}
 		}
@@ -501,6 +503,8 @@ func (w *x11Window) dispatch() {
 }
 
 func (w *x11Window) destroy() {
+	w.invMu.Lock()
+	defer w.invMu.Unlock()
 	if w.notify.write != 0 {
 		syscall.Close(w.notify.write)
 		w.notify.write = 0

app/window.go

@@ -7,6 +7,7 @@ import (
 	"fmt"
 	"image"
 	"image/color"
+	"reflect"
 	"runtime"
 	"sync"
 	"time"
@@ -35,15 +36,14 @@ type Option func(unit.Metric, *Config)
 
 // Window represents an operating system window.
 //
-// The zero-value Window is useful; the GUI window is created and shown the first
-// time the [Event] method is called. On iOS or Android, the first Window represents
-// the window previously created by the platform.
+// The zero-value Window is useful, and calling any method on
+// it creates and shows a new GUI window. On iOS or Android,
+// the first Window represents the the window previously
+// created by the platform.
 //
-// More than one Window is not supported on iOS, Android, WebAssembly.
+// More than one Window is not supported on iOS, Android,
+// WebAssembly.
 type Window struct {
-	initialOpts    []Option
-	initialActions []system.Action
-
 	ctx context
 	gpu gpu.GPU
 	// timer tracks the delayed invalidate goroutine.
@@ -89,15 +89,13 @@ type Window struct {
 	}
 	imeState editorState
 	driver   driver
-
-	// invMu protects mayInvalidate.
-	invMu         sync.Mutex
-	mayInvalidate bool
-
+	// basic is the driver interface that is needed even after the window is gone.
+	basic basicDriver
+	once  sync.Once
 	// coalesced tracks the most recent events waiting to be delivered
 	// to the client.
 	coalesced eventSummary
-	// frame tracks the most recent frame event.
+	// frame tracks the most recently frame event.
 	lastFrame struct {
 		sync bool
 		size image.Point
@@ -107,12 +105,11 @@ type Window struct {
 }
 
 type eventSummary struct {
-	wakeup       bool
-	cfg          *ConfigEvent
-	view         *ViewEvent
-	frame        *frameEvent
-	framePending bool
-	destroy      *DestroyEvent
+	wakeup  bool
+	cfg     *ConfigEvent
+	view    *ViewEvent
+	frame   *frameEvent
+	destroy *DestroyEvent
 }
 
 type callbacks struct {
@@ -219,7 +216,6 @@ func (w *Window) frame(frame *op.Ops, viewport image.Point) error {
 }
 
 func (w *Window) processFrame(frame *op.Ops, ack chan<- struct{}) {
-	w.coalesced.framePending = false
 	wrapper := &w.decorations.Ops
 	off := op.Offset(w.lastFrame.off).Push(wrapper)
 	ops.AddCall(&wrapper.Internal, &frame.Internal, ops.PC{}, ops.PCFor(&frame.Internal))
@@ -277,12 +273,8 @@ func (w *Window) updateState() {
 //
 // Invalidate is safe for concurrent use.
 func (w *Window) Invalidate() {
-	w.invMu.Lock()
-	defer w.invMu.Unlock()
-	if w.mayInvalidate {
-		w.mayInvalidate = false
-		w.driver.Invalidate()
-	}
+	w.init()
+	w.basic.Invalidate()
 }
 
 // Option applies the options to the window. The options are hints; the platform is
@@ -291,10 +283,7 @@ func (w *Window) Option(opts ...Option) {
 	if len(opts) == 0 {
 		return
 	}
-	if w.driver == nil {
-		w.initialOpts = append(w.initialOpts, opts...)
-		return
-	}
+	w.init(opts...)
 	w.Run(func() {
 		cnf := Config{Decorated: w.decorations.enabled}
 		for _, opt := range opts {
@@ -313,14 +302,16 @@ func (w *Window) Option(opts ...Option) {
 }
 
 // Run f in the same thread as the native window event loop, and wait for f to
-// return or the window to close. If the window has not yet been created,
-// Run calls f directly.
+// return or the window to close. Run is guaranteed not to deadlock if it is
+// invoked during the handling of a [ViewEvent], [FrameEvent],
+// [StageEvent]; call Run in a separate goroutine to avoid deadlock in all
+// other cases.
 //
 // Note that most programs should not call Run; configuring a Window with
 // [CustomRenderer] is a notable exception.
 func (w *Window) Run(f func()) {
+	w.init()
 	if w.driver == nil {
-		f()
 		return
 	}
 	done := make(chan struct{})
@@ -386,11 +377,11 @@ func (w *Window) setNextFrame(at time.Time) {
 	}
 }
 
-func (c *callbacks) SetDriver(d driver) {
-	if d == nil {
-		panic("nil driver")
+func (c *callbacks) SetDriver(d basicDriver) {
+	c.w.basic = d
+	if d, ok := d.(driver); ok {
+		c.w.driver = d
 	}
-	c.w.driver = d
 }
 
 func (c *callbacks) ProcessFrame(frame *op.Ops, ack chan<- struct{}) {
@@ -557,20 +548,10 @@ func (c *callbacks) Invalidate() {
 }
 
 func (c *callbacks) nextEvent() (event.Event, bool) {
-	return c.w.nextEvent()
-}
-
-func (w *Window) nextEvent() (event.Event, bool) {
-	s := &w.coalesced
-	defer func() {
-		// Every event counts as a wakeup.
-		s.wakeup = false
-	}()
+	s := &c.w.coalesced
+	// Every event counts as a wakeup.
+	defer func() { s.wakeup = false }()
 	switch {
-	case s.framePending:
-		// If the user didn't call FrameEvent.Event, process
-		// an empty frame.
-		w.processFrame(new(op.Ops), nil)
 	case s.view != nil:
 		e := *s.view
 		s.view = nil
@@ -587,14 +568,10 @@ func (w *Window) nextEvent() (event.Event, bool) {
 	case s.frame != nil:
 		e := *s.frame
 		s.frame = nil
-		s.framePending = true
 		return e.FrameEvent, true
 	case s.wakeup:
 		return wakeupEvent{}, true
 	}
-	w.invMu.Lock()
-	defer w.invMu.Unlock()
-	w.mayInvalidate = w.driver != nil
 	return nil, false
 }
 
@@ -638,9 +615,6 @@ func (w *Window) processEvent(e event.Event) bool {
 		w.coalesced.frame = &e2
 	case DestroyEvent:
 		w.destroyGPU()
-		w.invMu.Lock()
-		w.mayInvalidate = false
-		w.invMu.Unlock()
 		w.driver = nil
 		if q := w.timer.quit; q != nil {
 			q <- struct{}{}
@@ -648,7 +622,7 @@ func (w *Window) processEvent(e event.Event) bool {
 		}
 		w.coalesced.destroy = &e2
 	case ViewEvent:
-		if !e2.Valid() && w.gpu != nil {
+		if reflect.ValueOf(e2).IsZero() && w.gpu != nil {
 			w.ctx.Lock()
 			w.gpu.Release()
 			w.gpu = nil
@@ -709,61 +683,48 @@ func (w *Window) processEvent(e event.Event) bool {
 }
 
 // Event blocks until an event is received from the window, such as
-// [FrameEvent], or until [Invalidate] is called. The window is created
-// and shown the first time Event is called.
+// [FrameEvent], or until [Invalidate] is called.
 func (w *Window) Event() event.Event {
-	if w.driver == nil {
-		w.init()
-	}
-	if w.driver == nil {
-		e, ok := w.nextEvent()
-		if !ok {
-			panic("window initializion failed without a DestroyEvent")
-		}
-		return e
-	}
-	return w.driver.Event()
+	w.init()
+	return w.basic.Event()
 }
 
-func (w *Window) init() {
-	debug.Parse()
-	// Measure decoration height.
-	deco := new(widget.Decorations)
-	theme := material.NewTheme()
-	theme.Shaper = text.NewShaper(text.NoSystemFonts(), text.WithCollection(gofont.Regular()))
-	decoStyle := material.Decorations(theme, deco, 0, "")
-	gtx := layout.Context{
-		Ops: new(op.Ops),
-		// Measure in Dp.
-		Metric: unit.Metric{},
-	}
-	// Allow plenty of space.
-	gtx.Constraints.Max.Y = 200
-	dims := decoStyle.Layout(gtx)
-	decoHeight := unit.Dp(dims.Size.Y)
-	defaultOptions := []Option{
-		Size(800, 600),
-		Title("Gio"),
-		Decorated(true),
-		decoHeightOpt(decoHeight),
-	}
-	options := append(defaultOptions, w.initialOpts...)
-	w.initialOpts = nil
-	var cnf Config
-	cnf.apply(unit.Metric{}, options)
+func (w *Window) init(initial ...Option) {
+	w.once.Do(func() {
+		debug.Parse()
+		// Measure decoration height.
+		deco := new(widget.Decorations)
+		theme := material.NewTheme()
+		theme.Shaper = text.NewShaper(text.NoSystemFonts(), text.WithCollection(gofont.Regular()))
+		decoStyle := material.Decorations(theme, deco, 0, "")
+		gtx := layout.Context{
+			Ops: new(op.Ops),
+			// Measure in Dp.
+			Metric: unit.Metric{},
+		}
+		// Allow plenty of space.
+		gtx.Constraints.Max.Y = 200
+		dims := decoStyle.Layout(gtx)
+		decoHeight := unit.Dp(dims.Size.Y)
+		defaultOptions := []Option{
+			Size(800, 600),
+			Title("Gio"),
+			Decorated(true),
+			decoHeightOpt(decoHeight),
+		}
+		options := append(defaultOptions, initial...)
+		var cnf Config
+		cnf.apply(unit.Metric{}, options)
 
-	w.nocontext = cnf.CustomRenderer
-	w.decorations.Theme = theme
-	w.decorations.Decorations = deco
-	w.decorations.enabled = cnf.Decorated
-	w.decorations.height = decoHeight
-	w.imeState.compose = key.Range{Start: -1, End: -1}
-	w.semantic.ids = make(map[input.SemanticID]input.SemanticNode)
-	newWindow(&callbacks{w}, options)
-	for _, acts := range w.initialActions {
-		w.Perform(acts)
-	}
-	w.initialActions = nil
+		w.nocontext = cnf.CustomRenderer
+		w.decorations.Theme = theme
+		w.decorations.Decorations = deco
+		w.decorations.enabled = cnf.Decorated
+		w.decorations.height = decoHeight
+		w.imeState.compose = key.Range{Start: -1, End: -1}
+		w.semantic.ids = make(map[input.SemanticID]input.SemanticNode)
+		newWindow(&callbacks{w}, options)
+	})
 }
 
 func (w *Window) updateCursor() {
@@ -811,12 +772,8 @@ func (w *Window) decorate(e FrameEvent, o *op.Ops) image.Point {
 	}
 	// Update the window based on the actions on the decorations.
 	opts, acts := splitActions(deco.Update(gtx))
-	if len(opts) > 0 {
-		w.driver.Configure(opts)
-	}
-	if acts != 0 {
-		w.driver.Perform(acts)
-	}
+	w.driver.Configure(opts)
+	w.driver.Perform(acts)
 	style.Layout(gtx)
 	// Offset to place the frame content below the decorations.
 	decoHeight := gtx.Dp(w.decorations.Config.decoHeight)
@@ -863,10 +820,6 @@ func (w *Window) Perform(actions system.Action) {
 	if acts == 0 {
 		return
 	}
-	if w.driver == nil {
-		w.initialActions = append(w.initialActions, acts)
-		return
-	}
 	w.Run(func() {
 		w.driver.Perform(actions)
 	})

gesture/gesture.go

@@ -271,13 +271,12 @@ func (s *Scroll) Stop() {
 }
 
 // Update state and report the scroll distance along axis.
-func (s *Scroll) Update(cfg unit.Metric, q input.Source, t time.Time, axis Axis, scrollx, scrolly pointer.ScrollRange) int {
+func (s *Scroll) Update(cfg unit.Metric, q input.Source, t time.Time, axis Axis, bounds image.Rectangle) int {
 	total := 0
 	f := pointer.Filter{
-		Target:  s,
-		Kinds:   pointer.Press | pointer.Drag | pointer.Release | pointer.Scroll | pointer.Cancel,
-		ScrollX: scrollx,
-		ScrollY: scrolly,
+		Target:       s,
+		Kinds:        pointer.Press | pointer.Drag | pointer.Release | pointer.Scroll | pointer.Cancel,
+		ScrollBounds: bounds,
 	}
 	for {
 		evt, ok := q.Event(f)

go.mod

@@ -1,16 +1,16 @@
 module gioui.org
 
-go 1.21
+go 1.19
 
 require (
 	eliasnaur.com/font v0.0.0-20230308162249-dd43949cb42d
 	gioui.org/cpu v0.0.0-20210817075930-8d6a761490d2
 	gioui.org/shader v1.0.8
-	github.com/go-text/typesetting v0.1.1
+	github.com/go-text/typesetting v0.0.0-20230803102845-24e03d8b5372
 	golang.org/x/exp v0.0.0-20221012211006-4de253d81b95
 	golang.org/x/exp/shiny v0.0.0-20220827204233-334a2380cb91
 	golang.org/x/image v0.5.0
-	golang.org/x/sys v0.5.0
+	golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64
 )
 
-require golang.org/x/text v0.9.0
+require golang.org/x/text v0.7.0

go.sum

@@ -5,10 +5,9 @@ gioui.org/cpu v0.0.0-20210817075930-8d6a761490d2 h1:AGDDxsJE1RpcXTAxPG2B4jrwVUJG
 gioui.org/cpu v0.0.0-20210817075930-8d6a761490d2/go.mod h1:A8M0Cn5o+vY5LTMlnRoK3O5kG+rH0kWfJjeKd9QpBmQ=
 gioui.org/shader v1.0.8 h1:6ks0o/A+b0ne7RzEqRZK5f4Gboz2CfG+mVliciy6+qA=
 gioui.org/shader v1.0.8/go.mod h1:mWdiME581d/kV7/iEhLmUgUK5iZ09XR5XpduXzbePVM=
-github.com/go-text/typesetting v0.1.1 h1:bGAesCuo85nXnEN5LmFMVGAGpGkCPtHrZLi//qD7EJo=
-github.com/go-text/typesetting v0.1.1/go.mod h1:d22AnmeKq/on0HNv73UFriMKc4Ez6EqZAofLhAzpSzI=
-github.com/go-text/typesetting-utils v0.0.0-20231211103740-d9332ae51f04 h1:zBx+p/W2aQYtNuyZNcTfinWvXBQwYtDfme051PR/lAY=
-github.com/go-text/typesetting-utils v0.0.0-20231211103740-d9332ae51f04/go.mod h1:DDxDdQEnB70R8owOx3LVpEFvpMK9eeH1o2r0yZhFI9o=
+github.com/go-text/typesetting v0.0.0-20230803102845-24e03d8b5372 h1:FQivqchis6bE2/9uF70M2gmmLpe82esEm2QadL0TEJo=
+github.com/go-text/typesetting v0.0.0-20230803102845-24e03d8b5372/go.mod h1:evDBbvNR/KaVFZ2ZlDSOWWXIUKq0wCOEtzLxRM8SG3k=
+github.com/go-text/typesetting-utils v0.0.0-20230616150549-2a7df14b6a22 h1:LBQTFxP2MfsyEDqSKmUBZaDuDHN1vpqDyOZjcqS7MYI=
 github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
@@ -29,16 +28,15 @@ golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7w
 golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
-golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
-golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64 h1:UiNENfZ8gDvpiWw7IpOMQ27spWmThO1RwwdQVbJahJM=
+golang.org/x/sys v0.0.0-20220825204002-c680a09ffe64/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
 golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
 golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
 golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0 h1:4BRB4x83lYWy72KwLD/qYDuTu7q9PjSagHvijDw7cLo=
 golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
-golang.org/x/text v0.9.0 h1:2sjJmO8cDvYveuX97RDLsxlyUxLl+GHoLxBiRdHllBE=
-golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
 golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=

gpu/gpu.go

@@ -261,7 +261,7 @@ type texture struct {
 type blitter struct {
 	ctx                    driver.Device
 	viewport               image.Point
-	pipelines              [2][3]*pipeline
+	pipelines              [3]*pipeline
 	colUniforms            *blitColUniforms
 	texUniforms            *blitTexUniforms
 	linearGradientUniforms *blitLinearGradientUniforms
@@ -560,24 +560,12 @@ func newBlitter(ctx driver.Device) *blitter {
 func (b *blitter) release() {
 	b.quadVerts.Release()
 	for _, p := range b.pipelines {
-		for _, p := range p {
-			p.Release()
-		}
+		p.Release()
 	}
 }
 
-func createColorPrograms(b driver.Device, vsSrc shader.Sources, fsSrc [3]shader.Sources, uniforms [3]interface{}) (pipelines [2][3]*pipeline, err error) {
-	defer func() {
-		if err != nil {
-			for _, p := range pipelines {
-				for _, p := range p {
-					if p != nil {
-						p.Release()
-					}
-				}
-			}
-		}
-	}()
+func createColorPrograms(b driver.Device, vsSrc shader.Sources, fsSrc [3]shader.Sources, uniforms [3]interface{}) ([3]*pipeline, error) {
+	var pipelines [3]*pipeline
 	blend := driver.BlendDesc{
 		Enable:    true,
 		SrcFactor: driver.BlendFactorOne,
@@ -595,76 +583,86 @@ func createColorPrograms(b driver.Device, vsSrc shader.Sources, fsSrc [3]shader.
 		return pipelines, err
 	}
 	defer vsh.Release()
-	for i, format := range []driver.TextureFormat{driver.TextureFormatOutput, driver.TextureFormatSRGBA} {
-		{
-			fsh, err := b.NewFragmentShader(fsSrc[materialTexture])
-			if err != nil {
-				return pipelines, err
-			}
-			defer fsh.Release()
-			pipe, err := b.NewPipeline(driver.PipelineDesc{
-				VertexShader:   vsh,
-				FragmentShader: fsh,
-				BlendDesc:      blend,
-				VertexLayout:   layout,
-				PixelFormat:    format,
-				Topology:       driver.TopologyTriangleStrip,
-			})
-			if err != nil {
-				return pipelines, err
-			}
-			var vertBuffer *uniformBuffer
-			if u := uniforms[materialTexture]; u != nil {
-				vertBuffer = newUniformBuffer(b, u)
-			}
-			pipelines[i][materialTexture] = &pipeline{pipe, vertBuffer}
+	{
+		fsh, err := b.NewFragmentShader(fsSrc[materialTexture])
+		if err != nil {
+			return pipelines, err
 		}
-		{
-			var vertBuffer *uniformBuffer
-			fsh, err := b.NewFragmentShader(fsSrc[materialColor])
-			if err != nil {
-				return pipelines, err
-			}
-			defer fsh.Release()
-			pipe, err := b.NewPipeline(driver.PipelineDesc{
-				VertexShader:   vsh,
-				FragmentShader: fsh,
-				BlendDesc:      blend,
-				VertexLayout:   layout,
-				PixelFormat:    format,
-				Topology:       driver.TopologyTriangleStrip,
-			})
-			if err != nil {
-				return pipelines, err
-			}
-			if u := uniforms[materialColor]; u != nil {
-				vertBuffer = newUniformBuffer(b, u)
-			}
-			pipelines[i][materialColor] = &pipeline{pipe, vertBuffer}
+		defer fsh.Release()
+		pipe, err := b.NewPipeline(driver.PipelineDesc{
+			VertexShader:   vsh,
+			FragmentShader: fsh,
+			BlendDesc:      blend,
+			VertexLayout:   layout,
+			PixelFormat:    driver.TextureFormatOutput,
+			Topology:       driver.TopologyTriangleStrip,
+		})
+		if err != nil {
+			return pipelines, err
 		}
-		{
-			var vertBuffer *uniformBuffer
-			fsh, err := b.NewFragmentShader(fsSrc[materialLinearGradient])
-			if err != nil {
-				return pipelines, err
-			}
-			defer fsh.Release()
-			pipe, err := b.NewPipeline(driver.PipelineDesc{
-				VertexShader:   vsh,
-				FragmentShader: fsh,
-				BlendDesc:      blend,
-				VertexLayout:   layout,
-				PixelFormat:    format,
-				Topology:       driver.TopologyTriangleStrip,
-			})
-			if err != nil {
-				return pipelines, err
-			}
-			if u := uniforms[materialLinearGradient]; u != nil {
-				vertBuffer = newUniformBuffer(b, u)
-			}
-			pipelines[i][materialLinearGradient] = &pipeline{pipe, vertBuffer}
+		var vertBuffer *uniformBuffer
+		if u := uniforms[materialTexture]; u != nil {
+			vertBuffer = newUniformBuffer(b, u)
 		}
+		pipelines[materialTexture] = &pipeline{pipe, vertBuffer}
+	}
+	{
+		var vertBuffer *uniformBuffer
+		fsh, err := b.NewFragmentShader(fsSrc[materialColor])
+		if err != nil {
+			pipelines[materialTexture].Release()
+			return pipelines, err
+		}
+		defer fsh.Release()
+		pipe, err := b.NewPipeline(driver.PipelineDesc{
+			VertexShader:   vsh,
+			FragmentShader: fsh,
+			BlendDesc:      blend,
+			VertexLayout:   layout,
+			PixelFormat:    driver.TextureFormatOutput,
+			Topology:       driver.TopologyTriangleStrip,
+		})
+		if err != nil {
+			pipelines[materialTexture].Release()
+			return pipelines, err
+		}
+		if u := uniforms[materialColor]; u != nil {
+			vertBuffer = newUniformBuffer(b, u)
+		}
+		pipelines[materialColor] = &pipeline{pipe, vertBuffer}
+	}
+	{
+		var vertBuffer *uniformBuffer
+		fsh, err := b.NewFragmentShader(fsSrc[materialLinearGradient])
+		if err != nil {
+			pipelines[materialTexture].Release()
+			pipelines[materialColor].Release()
+			return pipelines, err
+		}
+		defer fsh.Release()
+		pipe, err := b.NewPipeline(driver.PipelineDesc{
+			VertexShader:   vsh,
+			FragmentShader: fsh,
+			BlendDesc:      blend,
+			VertexLayout:   layout,
+			PixelFormat:    driver.TextureFormatOutput,
+			Topology:       driver.TopologyTriangleStrip,
+		})
+		if err != nil {
+			pipelines[materialTexture].Release()
+			pipelines[materialColor].Release()
+			return pipelines, err
+		}
+		if u := uniforms[materialLinearGradient]; u != nil {
+			vertBuffer = newUniformBuffer(b, u)
+		}
+		pipelines[materialLinearGradient] = &pipeline{pipe, vertBuffer}
+	}
+	if err != nil {
+		for _, p := range pipelines {
+			p.Release()
+		}
+		return pipelines, err
 	}
 	return pipelines, nil
 }
@@ -867,7 +865,7 @@ func (r *renderer) drawLayers(layers []opacityLayer, ops []imageOp) {
 			Min: l.place.Pos,
 			Max: l.place.Pos.Add(l.clip.Size()),
 		}
-		r.ctx.Viewport(v.Min.X, v.Min.Y, v.Dx(), v.Dy())
+		r.ctx.Viewport(v.Min.X, v.Min.Y, v.Max.X, v.Max.Y)
 		f := r.layerFBOs.fbos[fbo]
 		r.drawOps(true, l.clip.Min.Mul(-1), l.clip.Size(), ops[l.opStart:l.opEnd])
 		sr := f32.FRect(v)
@@ -932,7 +930,7 @@ func (d *drawOps) newPathOp() *pathOp {
 	return &d.pathOpCache[len(d.pathOpCache)-1]
 }
 
-func (d *drawOps) addClipPath(state *drawState, aux []byte, auxKey opKey, bounds f32.Rectangle, off f32.Point) {
+func (d *drawOps) addClipPath(state *drawState, aux []byte, auxKey opKey, bounds f32.Rectangle, off f32.Point, push bool) {
 	npath := d.newPathOp()
 	*npath = pathOp{
 		parent:    state.cpath,
@@ -1057,7 +1055,7 @@ loop:
 				quads.aux, bounds, _ = d.boundsForTransformedRect(bounds, trans)
 				quads.key = opKey{Key: encOp.Key}
 			}
-			d.addClipPath(&state, quads.aux, quads.key, bounds, off)
+			d.addClipPath(&state, quads.aux, quads.key, bounds, off, true)
 			quads = quadsOp{}
 		case ops.TypePopClip:
 			state.cpath = state.cpath.parent
@@ -1102,7 +1100,7 @@ loop:
 				// this transformed rectangle.
 				k := opKey{Key: encOp.Key}
 				k.SetTransform(t) // TODO: This call has no effect.
-				d.addClipPath(&state, clipData, k, bnd, off)
+				d.addClipPath(&state, clipData, k, bnd, off, false)
 			}
 
 			bounds := cl.Round()
@@ -1232,7 +1230,7 @@ func (r *renderer) prepareDrawOps(ops []imageOp) {
 	}
 }
 
-func (r *renderer) drawOps(isFBO bool, opOff, viewport image.Point, ops []imageOp) {
+func (r *renderer) drawOps(isFBO bool, opOff image.Point, viewport image.Point, ops []imageOp) {
 	var coverTex driver.Texture
 	for i := 0; i < len(ops); i++ {
 		img := ops[i]
@@ -1246,13 +1244,9 @@ func (r *renderer) drawOps(isFBO bool, opOff, viewport image.Point, ops []imageO
 
 		scale, off := clipSpaceTransform(drc, viewport)
 		var fbo FBO
-		fboIdx := 0
-		if isFBO {
-			fboIdx = 1
-		}
 		switch img.clipType {
 		case clipTypeNone:
-			p := r.blitter.pipelines[fboIdx][m.material]
+			p := r.blitter.pipelines[m.material]
 			r.ctx.BindPipeline(p.pipeline)
 			r.ctx.BindVertexBuffer(r.blitter.quadVerts, 0)
 			r.blitter.blit(m.material, isFBO, m.color, m.color1, m.color2, scale, off, m.opacity, m.uvTrans)
@@ -1271,7 +1265,7 @@ func (r *renderer) drawOps(isFBO bool, opOff, viewport image.Point, ops []imageO
 			Max: img.place.Pos.Add(drc.Size()),
 		}
 		coverScale, coverOff := texSpaceTransform(f32.FRect(uv), fbo.size)
-		p := r.pather.coverer.pipelines[fboIdx][m.material]
+		p := r.pather.coverer.pipelines[m.material]
 		r.ctx.BindPipeline(p.pipeline)
 		r.ctx.BindVertexBuffer(r.blitter.quadVerts, 0)
 		r.pather.cover(m.material, isFBO, m.color, m.color1, m.color2, scale, off, m.uvTrans, coverScale, coverOff)
@@ -1279,11 +1273,7 @@ func (r *renderer) drawOps(isFBO bool, opOff, viewport image.Point, ops []imageO
 }
 
 func (b *blitter) blit(mat materialType, fbo bool, col f32color.RGBA, col1, col2 f32color.RGBA, scale, off f32.Point, opacity float32, uvTrans f32.Affine2D) {
-	fboIdx := 0
-	if fbo {
-		fboIdx = 1
-	}
-	p := b.pipelines[fboIdx][mat]
+	p := b.pipelines[mat]
 	b.ctx.BindPipeline(p.pipeline)
 	var uniforms *blitUniforms
 	switch mat {

gpu/internal/rendertest/render_test.go

@@ -483,14 +483,14 @@ func TestGapsInPath(t *testing.T) {
 func TestOpacity(t *testing.T) {
 	run(t, func(ops *op.Ops) {
 		opc1 := paint.PushOpacity(ops, .3)
-		// Fill screen to exercise the glClear optimization.
+		// Fill screen to exercize the glClear optimization.
 		paint.FillShape(ops, color.NRGBA{R: 255, A: 255}, clip.Rect{Max: image.Pt(1024, 1024)}.Op())
 		opc2 := paint.PushOpacity(ops, .6)
 		paint.FillShape(ops, color.NRGBA{G: 255, A: 255}, clip.Rect{Min: image.Pt(20, 10), Max: image.Pt(64, 128)}.Op())
 		opc2.Pop()
 		opc1.Pop()
 		opc3 := paint.PushOpacity(ops, .6)
-		paint.FillShape(ops, color.NRGBA{B: 255, A: 255}, clip.Ellipse(image.Rectangle{Min: image.Pt(20+20, 10), Max: image.Pt(50+64, 128)}).Op(ops))
+		paint.FillShape(ops, color.NRGBA{G: 255, A: 255}, clip.Rect{Min: image.Pt(50+20, 10), Max: image.Pt(50+64, 128)}.Op())
 		opc3.Pop()
 	}, func(r result) {
 	})

gpu/path.go

@@ -30,7 +30,7 @@ type pather struct {
 
 type coverer struct {
 	ctx                    driver.Device
-	pipelines              [2][3]*pipeline
+	pipelines              [3]*pipeline
 	texUniforms            *coverTexUniforms
 	colUniforms            *coverColUniforms
 	linearGradientUniforms *coverLinearGradientUniforms
@@ -309,9 +309,7 @@ func (p *pather) release() {
 
 func (c *coverer) release() {
 	for _, p := range c.pipelines {
-		for _, p := range p {
-			p.Release()
-		}
+		p.Release()
 	}
 }
 
@@ -407,11 +405,7 @@ func (c *coverer) cover(mat materialType, isFBO bool, col f32color.RGBA, col1, c
 	}
 	uniforms.transform = [4]float32{scale.X, scale.Y, off.X, off.Y}
 	uniforms.uvCoverTransform = [4]float32{coverScale.X, coverScale.Y, coverOff.X, coverOff.Y}
-	fboIdx := 0
-	if isFBO {
-		fboIdx = 1
-	}
-	c.pipelines[fboIdx][mat].UploadUniforms(c.ctx)
+	c.pipelines[mat].UploadUniforms(c.ctx)
 	c.ctx.DrawArrays(0, 4)
 }
 

internal/egl/egl.go

@@ -15,9 +15,10 @@ import (
 )
 
 type Context struct {
-	disp    _EGLDisplay
-	eglCtx  *eglContext
-	eglSurf _EGLSurface
+	disp          _EGLDisplay
+	eglCtx        *eglContext
+	eglSurf       _EGLSurface
+	width, height int
 }
 
 type eglContext struct {
@@ -120,9 +121,11 @@ func (c *Context) VisualID() int {
 	return c.eglCtx.visualID
 }
 
-func (c *Context) CreateSurface(win NativeWindowType) error {
+func (c *Context) CreateSurface(win NativeWindowType, width, height int) error {
 	eglSurf, err := createSurface(c.disp, c.eglCtx, win)
 	c.eglSurf = eglSurf
+	c.width = width
+	c.height = height
 	return err
 }
 

internal/gl/gl_windows.go

@@ -361,9 +361,6 @@ func (c *Functions) GetProgrami(p Program, pname Enum) int {
 }
 func (c *Functions) GetProgramInfoLog(p Program) string {
 	n := c.GetProgrami(p, INFO_LOG_LENGTH)
-	if n == 0 {
-		return ""
-	}
 	buf := make([]byte, n)
 	syscall.Syscall6(_glGetProgramInfoLog.Addr(), 4, uintptr(p.V), uintptr(len(buf)), 0, uintptr(unsafe.Pointer(&buf[0])), 0, 0)
 	return string(buf)

internal/stroke/stroke.go

@@ -327,9 +327,6 @@ func strokePathNorm(p0, p1, p2 f32.Point, t, d float32) f32.Point {
 func rot90CW(p f32.Point) f32.Point { return f32.Pt(+p.Y, -p.X) }
 
 func normPt(p f32.Point, l float32) f32.Point {
-	if (p.X == 0 && p.Y == l) || (p.Y == 0 && p.X == l) {
-		return f32.Point{X: p.X, Y: p.Y}
-	}
 	d := math.Hypot(float64(p.X), float64(p.Y))
 	l64 := float64(l)
 	if math.Abs(d-l64) < 1e-10 {

io/input/key_test.go

@@ -251,10 +251,9 @@ func TestFocusScroll(t *testing.T) {
 	filters := []event.Filter{
 		key.FocusFilter{Target: h},
 		pointer.Filter{
-			Target:  h,
-			Kinds:   pointer.Scroll,
-			ScrollX: pointer.ScrollRange{Min: -100, Max: +100},
-			ScrollY: pointer.ScrollRange{Min: -100, Max: +100},
+			Target:       h,
+			Kinds:        pointer.Scroll,
+			ScrollBounds: image.Rect(-100, -100, 100, 100),
 		},
 	}
 	events(r, -1, filters...)

io/input/pointer.go

@@ -72,7 +72,7 @@ type pointerHandler struct {
 type pointerFilter struct {
 	kinds pointer.Kind
 	// min and max horizontal/vertical scroll
-	scrollX, scrollY pointer.ScrollRange
+	scrollRange image.Rectangle
 
 	sourceMimes []string
 	targetMimes []string
@@ -297,8 +297,7 @@ func (p *pointerFilter) Add(f event.Filter) {
 		p.targetMimes = append(p.targetMimes, f.Type)
 	case pointer.Filter:
 		p.kinds = p.kinds | f.Kinds
-		p.scrollX = p.scrollX.Union(f.ScrollX)
-		p.scrollY = p.scrollY.Union(f.ScrollY)
+		p.scrollRange = p.scrollRange.Union(f.ScrollBounds)
 	}
 }
 
@@ -326,8 +325,7 @@ func (p *pointerFilter) Matches(e event.Event) bool {
 
 func (p *pointerFilter) Merge(p2 pointerFilter) {
 	p.kinds = p.kinds | p2.kinds
-	p.scrollX = p.scrollX.Union(p2.scrollX)
-	p.scrollY = p.scrollY.Union(p2.scrollY)
+	p.scrollRange = p.scrollRange.Union(p2.scrollRange)
 	p.sourceMimes = append(p.sourceMimes, p2.sourceMimes...)
 	p.targetMimes = append(p.targetMimes, p2.targetMimes...)
 }
@@ -335,8 +333,8 @@ func (p *pointerFilter) Merge(p2 pointerFilter) {
 // clampScroll splits a scroll distance in the remaining scroll and the
 // scroll accepted by the filter.
 func (p *pointerFilter) clampScroll(scroll f32.Point) (left, scrolled f32.Point) {
-	left.X, scrolled.X = clampSplit(scroll.X, p.scrollX.Min, p.scrollX.Max)
-	left.Y, scrolled.Y = clampSplit(scroll.Y, p.scrollY.Min, p.scrollY.Max)
+	left.X, scrolled.X = clampSplit(scroll.X, p.scrollRange.Min.X, p.scrollRange.Max.X)
+	left.Y, scrolled.Y = clampSplit(scroll.Y, p.scrollRange.Min.Y, p.scrollRange.Max.Y)
 	return
 }
 

io/input/pointer_test.go

@@ -300,9 +300,9 @@ func TestPointerPriority(t *testing.T) {
 	r1 := clip.Rect(image.Rect(0, 0, 100, 100)).Push(&ops)
 	f1 := func(t event.Tag) event.Filter {
 		return pointer.Filter{
-			Target:  t,
-			Kinds:   pointer.Scroll,
-			ScrollX: pointer.ScrollRange{Max: 100},
+			Target:       t,
+			Kinds:        pointer.Scroll,
+			ScrollBounds: image.Rectangle{Max: image.Point{X: 100}},
 		}
 	}
 	events(&r, -1, f1(handler1))
@@ -311,9 +311,9 @@ func TestPointerPriority(t *testing.T) {
 	r2 := clip.Rect(image.Rect(0, 0, 100, 50)).Push(&ops)
 	f2 := func(t event.Tag) event.Filter {
 		return pointer.Filter{
-			Target:  t,
-			Kinds:   pointer.Scroll,
-			ScrollX: pointer.ScrollRange{Max: 20},
+			Target:       t,
+			Kinds:        pointer.Scroll,
+			ScrollBounds: image.Rectangle{Max: image.Point{X: 20}},
 		}
 	}
 	events(&r, -1, f2(handler2))
@@ -324,10 +324,9 @@ func TestPointerPriority(t *testing.T) {
 	r3 := clip.Rect(image.Rect(0, 100, 100, 200)).Push(&ops)
 	f3 := func(t event.Tag) event.Filter {
 		return pointer.Filter{
-			Target:  t,
-			Kinds:   pointer.Scroll,
-			ScrollX: pointer.ScrollRange{Min: -20},
-			ScrollY: pointer.ScrollRange{Min: -40},
+			Target:       t,
+			Kinds:        pointer.Scroll,
+			ScrollBounds: image.Rectangle{Min: image.Point{X: -20, Y: -40}},
 		}
 	}
 	events(&r, -1, f3(handler3))
@@ -1086,33 +1085,6 @@ func TestPassCursor(t *testing.T) {
 	}
 }
 
-func TestPartialEvent(t *testing.T) {
-	var ops op.Ops
-	var r Router
-
-	rect := clip.Rect(image.Rect(0, 0, 100, 100))
-	background := rect.Push(&ops)
-	event.Op(&ops, 1)
-	background.Pop()
-
-	overlayPass := pointer.PassOp{}.Push(&ops)
-	overlay := rect.Push(&ops)
-	event.Op(&ops, 2)
-	overlay.Pop()
-	overlayPass.Pop()
-	assertEventSequence(t, events(&r, -1, pointer.Filter{Target: 1, Kinds: pointer.Press}))
-	assertEventSequence(t, events(&r, -1, pointer.Filter{Target: 2, Kinds: pointer.Press}))
-	r.Frame(&ops)
-	r.Queue(pointer.Event{
-		Kind: pointer.Press,
-	})
-	assertEventSequence(t, events(&r, -1, pointer.Filter{Target: 1, Kinds: pointer.Press}, key.FocusFilter{Target: 1}),
-		key.FocusEvent{}, pointer.Event{Kind: pointer.Press, Source: pointer.Mouse, Priority: pointer.Shared})
-	r.Source().Execute(key.FocusCmd{Tag: 1})
-	assertEventSequence(t, events(&r, -1, pointer.Filter{Target: 2, Kinds: pointer.Press}),
-		pointer.Event{Kind: pointer.Press, Source: pointer.Mouse, Priority: pointer.Foremost})
-}
-
 // offer satisfies io.ReadCloser for use in data transfers.
 type offer struct {
 	data   string

io/input/router.go

@@ -35,9 +35,10 @@ type Router struct {
 		queue keyQueue
 		// The following fields have the same purpose as the fields in
 		// type handler, but for key.Events.
-		filter        keyFilter
-		nextFilter    keyFilter
-		scratchFilter keyFilter
+		filter          keyFilter
+		nextFilter      keyFilter
+		processedFilter keyFilter
+		scratchFilter   keyFilter
 	}
 	cqueue clipboardQueue
 	// states is the list of pending state changes resulting from
@@ -274,29 +275,28 @@ func (q *Router) Event(filters ...event.Filter) (event.Event, bool) {
 			}
 		}
 	}
-	for i := range q.changes {
-		if q.deferring && i > 0 {
-			break
-		}
-		change := &q.changes[i]
-		for j, evt := range change.events {
-			match := false
-			switch e := evt.event.(type) {
-			case key.Event:
-				match = q.key.scratchFilter.Matches(change.state.keyState.focus, e, false)
-			default:
-				for _, tf := range q.scratchFilters {
-					if evt.tag == tf.tag && tf.filter.Matches(evt.event) {
-						match = true
-						break
+	if !q.deferring {
+		for i := range q.changes {
+			change := &q.changes[i]
+			for j, evt := range change.events {
+				match := false
+				switch e := evt.event.(type) {
+				case key.Event:
+					match = q.key.scratchFilter.Matches(change.state.keyState.focus, e, false)
+				default:
+					for _, tf := range q.scratchFilters {
+						if evt.tag == tf.tag && tf.filter.Matches(evt.event) {
+							match = true
+							break
+						}
 					}
 				}
-			}
-			if match {
-				change.events = append(change.events[:j], change.events[j+1:]...)
-				// Fast forward state to last matched.
-				q.collapseState(i)
-				return evt.event, true
+				if match {
+					change.events = append(change.events[:j], change.events[j+1:]...)
+					// Fast forward state to last matched.
+					q.collapseState(i)
+					return evt.event, true
+				}
 			}
 		}
 	}
@@ -304,6 +304,7 @@ func (q *Router) Event(filters ...event.Filter) (event.Event, bool) {
 		h := q.stateFor(tf.tag)
 		h.processedFilter.Merge(tf.filter)
 	}
+	q.key.processedFilter = append(q.key.processedFilter, q.key.scratchFilter...)
 	return nil, false
 }
 
@@ -314,15 +315,15 @@ func (q *Router) collapseState(idx int) {
 	}
 	first := &q.changes[0]
 	first.state = q.changes[idx].state
-	for _, ch := range q.changes[1 : idx+1] {
-		first.events = append(first.events, ch.events...)
+	for i := 1; i <= idx; i++ {
+		first.events = append(first.events, q.changes[i].events...)
 	}
 	q.changes = append(q.changes[:1], q.changes[idx+1:]...)
 }
 
-// Frame completes the current frame and starts a new with the
-// handlers from the frame argument. Remaining events are discarded,
-// unless they were deferred by a command.
+// Frame replaces the declared handlers from the supplied
+// operation list. The text input state, wakeup time and whether
+// there are active profile handlers is also saved.
 func (q *Router) Frame(frame *op.Ops) {
 	var remaining []event.Event
 	if n := len(q.changes); n > 0 {

io/pointer/doc.go

@@ -37,11 +37,11 @@ For example:
 	var h1, h2 *Handler
 
 	area := clip.Rect(...).Push(ops)
-	event.Op(Ops, h1)
+	event.Op{Tag: h1}.Add(Ops)
 	area.Pop()
 
 	area := clip.Rect(...).Push(ops)
-	event.Op(Ops, h2)
+	event.Op{Tag: h2}.Add(ops)
 	area.Pop()
 
 implies a tree of two inner nodes, each with one pointer handler attached.

io/pointer/pointer.go

@@ -3,6 +3,7 @@
 package pointer
 
 import (
+	"image"
 	"strings"
 	"time"
 
@@ -60,19 +61,12 @@ type Filter struct {
 	Target event.Tag
 	// Kinds is a bitwise-or of event types to match.
 	Kinds Kind
-	// ScrollX and ScrollY constrain the range of scrolling events delivered
-	// to Target. Specifically, any Event e delivered to Tag will satisfy
+	// ScrollBounds describe the maximum scrollable distances in both
+	// axes. Specifically, any Event e delivered to Tag will satisfy
 	//
-	// ScrollX.Min <= e.Scroll.X <= ScrollX.Max (horizontal axis)
-	// ScrollY.Min <= e.Scroll.Y <= ScrollY.Max (vertical axis)
-	ScrollX ScrollRange
-	ScrollY ScrollRange
-}
-
-// ScrollRange describes the range of scrolling distances in an
-// axis.
-type ScrollRange struct {
-	Min, Max int
+	// ScrollBounds.Min.X <= e.Scroll.X <= ScrollBounds.Max.X (horizontal axis)
+	// ScrollBounds.Min.Y <= e.Scroll.Y <= ScrollBounds.Max.Y (vertical axis)
+	ScrollBounds image.Rectangle
 }
 
 // GrabCmd requests a pointer grab on the pointer identified by ID.
@@ -225,13 +219,6 @@ const (
 	ButtonTertiary
 )
 
-func (s ScrollRange) Union(s2 ScrollRange) ScrollRange {
-	return ScrollRange{
-		Min: min(s.Min, s2.Min),
-		Max: max(s.Max, s2.Max),
-	}
-}
-
 // Push the current pass mode to the pass stack and set the pass mode.
 func (p PassOp) Push(o *op.Ops) PassStack {
 	id, mid := ops.PushOp(&o.Internal, ops.PassStack)

layout/list.go

@@ -7,7 +7,6 @@ import (
 	"math"
 
 	"gioui.org/gesture"
-	"gioui.org/io/pointer"
 	"gioui.org/op"
 	"gioui.org/op/clip"
 )
@@ -159,12 +158,11 @@ func (l *List) update(gtx Context) {
 			max = 0
 		}
 	}
-	xrange := pointer.ScrollRange{Min: min, Max: max}
-	yrange := pointer.ScrollRange{}
-	if l.Axis == Vertical {
-		xrange, yrange = yrange, xrange
+	scrollRange := image.Rectangle{
+		Min: l.Axis.Convert(image.Pt(min, 0)),
+		Max: l.Axis.Convert(image.Pt(max, 0)),
 	}
-	d := l.scroll.Update(gtx.Metric, gtx.Source, gtx.Now, gesture.Axis(l.Axis), xrange, yrange)
+	d := l.scroll.Update(gtx.Metric, gtx.Source, gtx.Now, gesture.Axis(l.Axis), scrollRange)
 	l.scrollDelta = d
 	l.Position.Offset += d
 }

op/clip/clip.go

@@ -138,9 +138,6 @@ type Path struct {
 func (p *Path) Pos() f32.Point { return p.pen }
 
 // Begin the path, storing the path data and final Op into ops.
-//
-// Caller must also call End to finish the drawing.
-// Forgetting to call it will result in a "panic: cannot mix multi ops with single ones".
 func (p *Path) Begin(o *op.Ops) {
 	*p = Path{
 		ops:     &o.Internal,

text/gotext.go

@@ -4,7 +4,6 @@ package text
 
 import (
 	"bytes"
-	"fmt"
 	"image"
 	"io"
 	"log"
@@ -277,8 +276,7 @@ func newShaperImpl(systemFonts bool, collection []FontFace) *shaperImpl {
 // It returns whether the face is now available for use. FontFaces are prioritized
 // in the order in which they are loaded, with the first face being the default.
 func (s *shaperImpl) Load(f FontFace) {
-	desc := opentype.FontToDescription(f.Font)
-	s.fontMap.AddFace(f.Face.Face(), fontscan.Location{File: fmt.Sprint(desc)}, desc)
+	s.fontMap.AddFace(f.Face.Face(), opentype.FontToDescription(f.Font))
 	s.addFace(f.Face.Face(), f.Font)
 }
 

widget/editor.go

@@ -228,19 +228,19 @@ func (e *Editor) processPointer(gtx layout.Context) (EditorEvent, bool) {
 		axis = gesture.Vertical
 		smin, smax = sbounds.Min.Y, sbounds.Max.Y
 	}
-	var scrollX, scrollY pointer.ScrollRange
+	var scrollRange image.Rectangle
 	textDims := e.text.FullDimensions()
 	visibleDims := e.text.Dimensions()
 	if e.SingleLine {
 		scrollOffX := e.text.ScrollOff().X
-		scrollX.Min = min(-scrollOffX, 0)
-		scrollX.Max = max(0, textDims.Size.X-(scrollOffX+visibleDims.Size.X))
+		scrollRange.Min.X = min(-scrollOffX, 0)
+		scrollRange.Max.X = max(0, textDims.Size.X-(scrollOffX+visibleDims.Size.X))
 	} else {
 		scrollOffY := e.text.ScrollOff().Y
-		scrollY.Min = -scrollOffY
-		scrollY.Max = max(0, textDims.Size.Y-(scrollOffY+visibleDims.Size.Y))
+		scrollRange.Min.Y = -scrollOffY
+		scrollRange.Max.Y = max(0, textDims.Size.Y-(scrollOffY+visibleDims.Size.Y))
 	}
-	sdist := e.scroller.Update(gtx.Metric, gtx.Source, gtx.Now, axis, scrollX, scrollY)
+	sdist := e.scroller.Update(gtx.Metric, gtx.Source, gtx.Now, axis, scrollRange)
 	var soff int
 	if e.SingleLine {
 		e.text.ScrollRel(sdist, 0)
@@ -289,9 +289,6 @@ func (e *Editor) processPointerEvent(gtx layout.Context, ev event.Event) (Editor
 				Y: int(math.Round(float64(evt.Position.Y))),
 			})
 			gtx.Execute(key.FocusCmd{Tag: e})
-			if !e.ReadOnly {
-				gtx.Execute(key.SoftKeyboardCmd{Show: true})
-			}
 			if e.scroller.State() != gesture.StateFlinging {
 				e.scrollCaret = true
 			}
@@ -315,8 +312,8 @@ func (e *Editor) processPointerEvent(gtx layout.Context, ev event.Event) (Editor
 				e.text.MoveWord(1, selectionExtend)
 				e.dragging = false
 			case evt.NumClicks >= 3:
-				e.text.MoveLineStart(selectionClear)
-				e.text.MoveLineEnd(selectionExtend)
+				e.text.MoveStart(selectionClear)
+				e.text.MoveEnd(selectionExtend)
 				e.dragging = false
 			}
 		}
@@ -377,8 +374,8 @@ func (e *Editor) processKey(gtx layout.Context) (EditorEvent, bool) {
 		key.Filter{Focus: e, Name: key.NameDeleteBackward, Optional: key.ModShortcutAlt | key.ModShift},
 		key.Filter{Focus: e, Name: key.NameDeleteForward, Optional: key.ModShortcutAlt | key.ModShift},
 
-		key.Filter{Focus: e, Name: key.NameHome, Optional: key.ModShortcut | key.ModShift},
-		key.Filter{Focus: e, Name: key.NameEnd, Optional: key.ModShortcut | key.ModShift},
+		key.Filter{Focus: e, Name: key.NameHome, Optional: key.ModShift},
+		key.Filter{Focus: e, Name: key.NameEnd, Optional: key.ModShift},
 		key.Filter{Focus: e, Name: key.NamePageDown, Optional: key.ModShift},
 		key.Filter{Focus: e, Name: key.NamePageUp, Optional: key.ModShift},
 		condFilter(!atBeginning, key.Filter{Focus: e, Name: key.NameLeftArrow, Optional: key.ModShortcutAlt | key.ModShift}),
@@ -398,7 +395,7 @@ func (e *Editor) processKey(gtx layout.Context) (EditorEvent, bool) {
 		case key.FocusEvent:
 			// Reset IME state.
 			e.ime.imeState = imeState{}
-			if ke.Focus && !e.ReadOnly {
+			if ke.Focus {
 				gtx.Execute(key.SoftKeyboardCmd{Show: true})
 			}
 		case key.Event:
@@ -524,10 +521,6 @@ func (e *Editor) command(gtx layout.Context, k key.Event) (EditorEvent, bool) {
 					}
 				}
 			}
-		case key.NameHome:
-			e.text.MoveTextStart(selAct)
-		case key.NameEnd:
-			e.text.MoveTextEnd(selAct)
 		}
 		return nil, false
 	}
@@ -589,9 +582,9 @@ func (e *Editor) command(gtx layout.Context, k key.Event) (EditorEvent, bool) {
 	case key.NamePageDown:
 		e.text.MovePages(+1, selAct)
 	case key.NameHome:
-		e.text.MoveLineStart(selAct)
+		e.text.MoveStart(selAct)
 	case key.NameEnd:
-		e.text.MoveLineEnd(selAct)
+		e.text.MoveEnd(selAct)
 	}
 	return nil, false
 }

widget/editor_test.go

@@ -256,7 +256,7 @@ func TestEditor(t *testing.T) {
 	// Regression test for bad in-cluster rune offset math.
 	e.SetText("æbc")
 	e.Layout(gtx, cache, font, fontSize, op.CallOp{}, op.CallOp{})
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	assertCaret(t, e, 0, 3, len("æbc"))
 
 	textSample := "æbc\naøå••"
@@ -268,7 +268,7 @@ func TestEditor(t *testing.T) {
 	}
 	e.Layout(gtx, cache, font, fontSize, op.CallOp{}, op.CallOp{})
 	assertCaret(t, e, 0, 0, 0)
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	assertCaret(t, e, 0, 3, len("æbc"))
 	e.MoveCaret(+1, +1)
 	assertCaret(t, e, 1, 0, len("æbc\n"))
@@ -276,7 +276,7 @@ func TestEditor(t *testing.T) {
 	assertCaret(t, e, 0, 3, len("æbc"))
 	e.text.MoveLines(+1, selectionClear)
 	assertCaret(t, e, 1, 4, len("æbc\naøå•"))
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	assertCaret(t, e, 1, 5, len("æbc\naøå••"))
 	e.MoveCaret(+1, +1)
 	assertCaret(t, e, 1, 5, len("æbc\naøå••"))
@@ -300,7 +300,7 @@ func TestEditor(t *testing.T) {
 	// Test that moveLine applies x offsets from previous moves.
 	e.SetText("long line\nshort")
 	e.SetCaret(0, 0)
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	e.text.MoveLines(+1, selectionClear)
 	e.text.MoveLines(-1, selectionClear)
 	assertCaret(t, e, 0, utf8.RuneCountInString("long line"), len("long line"))
@@ -342,14 +342,14 @@ func TestEditorRTL(t *testing.T) {
 	e.MoveCaret(+1, +1)
 	assertCaret(t, e, 0, 3, len("الح"))
 	// Move to the "end" of the line. This moves to the left edge of the line.
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	assertCaret(t, e, 0, 4, len("الحب"))
 
 	sentence := "الحب سماء لا\nتمط غير الأحلام"
 	e.SetText(sentence)
 	e.Layout(gtx, cache, font, fontSize, op.CallOp{}, op.CallOp{})
 	assertCaret(t, e, 0, 0, 0)
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	assertCaret(t, e, 0, 12, len("الحب سماء لا"))
 	e.MoveCaret(+1, +1)
 	assertCaret(t, e, 1, 0, len("الحب سماء لا\n"))
@@ -361,7 +361,7 @@ func TestEditorRTL(t *testing.T) {
 	assertCaret(t, e, 0, 12, len("الحب سماء لا"))
 	e.text.MoveLines(+1, selectionClear)
 	assertCaret(t, e, 1, 14, len("الحب سماء لا\nتمط غير الأحلا"))
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	assertCaret(t, e, 1, 15, len("الحب سماء لا\nتمط غير الأحلام"))
 	e.MoveCaret(+1, +1)
 	assertCaret(t, e, 1, 15, len("الحب سماء لا\nتمط غير الأحلام"))
@@ -417,7 +417,7 @@ func TestEditorLigature(t *testing.T) {
 	assertCaret(t, e, 0, 0, 0)
 	e.SetText("fl") // just a ligature
 	e.Layout(gtx, cache, font, fontSize, op.CallOp{}, op.CallOp{})
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	assertCaret(t, e, 0, 2, len("fl"))
 	e.MoveCaret(-1, -1)
 	assertCaret(t, e, 0, 1, len("f"))
@@ -428,7 +428,7 @@ func TestEditorLigature(t *testing.T) {
 	e.SetText("flaffl•ffi\n•fflfi") // 3 ligatures on line 0, 2 on line 1
 	e.Layout(gtx, cache, font, fontSize, op.CallOp{}, op.CallOp{})
 	assertCaret(t, e, 0, 0, 0)
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	assertCaret(t, e, 0, 10, len("ffaffl•ffi"))
 	e.MoveCaret(+1, +1)
 	assertCaret(t, e, 1, 0, len("ffaffl•ffi\n"))
@@ -481,7 +481,7 @@ func TestEditorLigature(t *testing.T) {
 	e.Layout(gtx, cache, font, fontSize, op.CallOp{}, op.CallOp{})
 	// Ensure that all runes in the final cluster of a line are properly
 	// decoded when moving to the end of the line. This is a regression test.
-	e.text.MoveLineEnd(selectionClear)
+	e.text.MoveEnd(selectionClear)
 	// The first line was broken by line wrapping, not a newline character, and has a trailing
 	// whitespace. However, we should never be able to reach the "other side" of such a trailing
 	// whitespace glyph.
@@ -548,10 +548,8 @@ const (
 	moveRune
 	moveLine
 	movePage
-	moveTextStart
-	moveTextEnd
-	moveLineStart
-	moveLineEnd
+	moveStart
+	moveEnd
 	moveCoord
 	moveWord
 	deleteWord
@@ -601,14 +599,10 @@ func TestEditorCaretConsistency(t *testing.T) {
 				e.text.MoveLines(int(distance), selectionClear)
 			case movePage:
 				e.text.MovePages(int(distance), selectionClear)
-			case moveLineStart:
-				e.text.MoveLineStart(selectionClear)
-			case moveLineEnd:
-				e.text.MoveLineEnd(selectionClear)
-			case moveTextStart:
-				e.text.MoveTextStart(selectionClear)
-			case moveTextEnd:
-				e.text.MoveTextEnd(selectionClear)
+			case moveStart:
+				e.text.MoveStart(selectionClear)
+			case moveEnd:
+				e.text.MoveEnd(selectionClear)
 			case moveCoord:
 				e.text.MoveCoord(image.Pt(int(x), int(y)))
 			case moveWord:
@@ -885,7 +879,7 @@ func (editMutation) Generate(rand *rand.Rand, size int) reflect.Value {
 // to make it much narrower (which makes the lines in the editor reflow), and
 // then verifies that the updated (col, line) positions of the selected text
 // are where we expect.
-func TestEditorSelectReflow(t *testing.T) {
+func TestEditorSelect(t *testing.T) {
 	e := new(Editor)
 	e.SetText(`a 2 4 6 8 a
 b 2 4 6 8 b
@@ -988,60 +982,6 @@ g 2 4 6 8 g
 	}
 }
 
-func TestEditorSelectShortcuts(t *testing.T) {
-	tFont := font.Font{}
-	tFontSize := unit.Sp(10)
-	tShaper := text.NewShaper(text.NoSystemFonts(), text.WithCollection(gofont.Collection()))
-	var tEditor = &Editor{
-		SingleLine: false,
-		ReadOnly:   true,
-	}
-	lines := "abc abc abc\ndef def def\nghi ghi ghi"
-	tEditor.SetText(lines)
-	type testCase struct {
-		// Initial text selection.
-		startPos, endPos int
-		// Keyboard shortcut to execute.
-		keyEvent key.Event
-		// Expected text selection.
-		selection string
-	}
-
-	pos1, pos2 := 14, 21
-	for n, tst := range []testCase{
-		{pos1, pos2, key.Event{Name: "A", Modifiers: key.ModShortcut}, lines},
-		{pos2, pos1, key.Event{Name: "A", Modifiers: key.ModShortcut}, lines},
-		{pos1, pos2, key.Event{Name: key.NameHome, Modifiers: key.ModShift}, "def def d"},
-		{pos1, pos2, key.Event{Name: key.NameEnd, Modifiers: key.ModShift}, "ef"},
-		{pos2, pos1, key.Event{Name: key.NameHome, Modifiers: key.ModShift}, "de"},
-		{pos2, pos1, key.Event{Name: key.NameEnd, Modifiers: key.ModShift}, "f def def"},
-		{pos1, pos2, key.Event{Name: key.NameHome, Modifiers: key.ModShortcut | key.ModShift}, "abc abc abc\ndef def d"},
-		{pos1, pos2, key.Event{Name: key.NameEnd, Modifiers: key.ModShortcut | key.ModShift}, "ef\nghi ghi ghi"},
-		{pos2, pos1, key.Event{Name: key.NameHome, Modifiers: key.ModShortcut | key.ModShift}, "abc abc abc\nde"},
-		{pos2, pos1, key.Event{Name: key.NameEnd, Modifiers: key.ModShortcut | key.ModShift}, "f def def\nghi ghi ghi"},
-	} {
-		tRouter := new(input.Router)
-		gtx := layout.Context{
-			Ops:         new(op.Ops),
-			Locale:      english,
-			Constraints: layout.Exact(image.Pt(100, 100)),
-			Source:      tRouter.Source(),
-		}
-		gtx.Execute(key.FocusCmd{Tag: tEditor})
-		tEditor.Layout(gtx, tShaper, tFont, tFontSize, op.CallOp{}, op.CallOp{})
-
-		tEditor.SetCaret(tst.startPos, tst.endPos)
-		if cStart, cEnd := tEditor.Selection(); cStart != tst.startPos || cEnd != tst.endPos {
-			t.Errorf("TestEditorSelect %d: initial selection", n)
-		}
-		tRouter.Queue(tst.keyEvent)
-		tEditor.Update(gtx)
-		if got := tEditor.SelectedText(); got != tst.selection {
-			t.Errorf("TestEditorSelect %d: Expected %q, got %q", n, tst.selection, got)
-		}
-	}
-}
-
 // Verify that an existing selection is dismissed when you press arrow keys.
 func TestSelectMove(t *testing.T) {
 	e := new(Editor)

widget/index_test.go

@@ -284,9 +284,9 @@ func TestIndexPositionBidi(t *testing.T) {
 			name:   "bidi rtl",
 			glyphs: bidiRTLText,
 			expectedXs: []fixed.Int26_6{
-				2646, 3272, 3842, 4412, 4697, 5267, 5837, 6090, 6602, 7114, 2646, 2380, 1577, 985, 687, 266, // Positions on line 0.
+				2665, 3291, 3861, 4431, 4716, 5286, 5856, 6109, 6621, 7133, 2665, 2380, 1577, 985, 687, 266, // Positions on line 0.
 
-				7867, 7099, 6331, 5563, 4795, 4510, 4212, 3914, 3648, 2281, 2566, 3136, 3648, 2281, 2015, 1709, 1117, 266, // Positions on line 1.
+				7886, 7118, 6350, 5582, 4814, 4529, 4231, 3933, 3667, 2300, 2585, 3155, 3667, 2300, 2015, 1709, 1117, 266, // Positions on line 1.
 
 				8794, 8026, 7258, 6490, 5722, 5437, 4922, 4540, 4134, 3868, 0, 290, 860, 1430, 1715, 1989, 2559, 3071, 3583, // Positions on line 2.
 
@@ -402,7 +402,7 @@ func TestIndexPositionLines(t *testing.T) {
 					xOff:    fixed.Int26_6(0),
 					yOff:    22,
 					glyphs:  15,
-					width:   fixed.Int26_6(7114),
+					width:   fixed.Int26_6(7133),
 					ascent:  fixed.Int26_6(1407),
 					descent: fixed.Int26_6(756),
 				},
@@ -410,7 +410,7 @@ func TestIndexPositionLines(t *testing.T) {
 					xOff:    fixed.Int26_6(0),
 					yOff:    41,
 					glyphs:  15,
-					width:   fixed.Int26_6(7867),
+					width:   fixed.Int26_6(7886),
 					ascent:  fixed.Int26_6(1407),
 					descent: fixed.Int26_6(756),
 				},
@@ -477,18 +477,18 @@ func TestIndexPositionLines(t *testing.T) {
 			glyphs: bidiRTLTextOpp,
 			expectedLines: []lineInfo{
 				{
-					xOff:    fixed.Int26_6(3126),
+					xOff:    fixed.Int26_6(3107),
 					yOff:    22,
 					glyphs:  15,
-					width:   fixed.Int26_6(7114),
+					width:   fixed.Int26_6(7133),
 					ascent:  fixed.Int26_6(1407),
 					descent: fixed.Int26_6(756),
 				},
 				{
-					xOff:    fixed.Int26_6(2373),
+					xOff:    fixed.Int26_6(2354),
 					yOff:    41,
 					glyphs:  15,
-					width:   fixed.Int26_6(7867),
+					width:   fixed.Int26_6(7886),
 					ascent:  fixed.Int26_6(1407),
 					descent: fixed.Int26_6(756),
 				},

widget/material/progressbar.go

@@ -54,9 +54,6 @@ func (p ProgressBarStyle) Layout(gtx layout.Context) layout.Dimensions {
 			if !gtx.Enabled() {
 				fillColor = f32color.Disabled(fillColor)
 			}
-			if fillWidth < int(p.Radius*2) {
-				fillWidth = int(p.Radius * 2)
-			}
 			return shader(fillWidth, fillColor)
 		}),
 	)

widget/selectable.go

@@ -247,8 +247,8 @@ func (e *Selectable) processPointer(gtx layout.Context) {
 					e.text.MoveWord(1, selectionExtend)
 					e.dragging = false
 				case evt.NumClicks >= 3:
-					e.text.MoveLineStart(selectionClear)
-					e.text.MoveLineEnd(selectionExtend)
+					e.text.MoveStart(selectionClear)
+					e.text.MoveEnd(selectionExtend)
 					e.dragging = false
 				}
 			}
@@ -378,9 +378,9 @@ func (e *Selectable) command(gtx layout.Context, k key.Event) {
 	case key.NamePageDown:
 		e.text.MovePages(+1, selAct)
 	case key.NameHome:
-		e.text.MoveLineStart(selAct)
+		e.text.MoveStart(selAct)
 	case key.NameEnd:
-		e.text.MoveLineEnd(selAct)
+		e.text.MoveEnd(selAct)
 	}
 }
 

widget/text.go

@@ -639,28 +639,9 @@ func (e *textView) MoveCaret(startDelta, endDelta int) {
 	e.caret.end = e.moveByGraphemes(e.caret.end, endDelta)
 }
 
-// MoveTextStart moves the caret to the start of the text.
-func (e *textView) MoveTextStart(selAct selectionAction) {
-	caret := e.closestToRune(e.caret.end)
-	e.caret.start = 0
-	e.caret.end = caret.runes
-	e.caret.xoff = -caret.x
-	e.updateSelection(selAct)
-	e.clampCursorToGraphemes()
-}
-
-// MoveTextEnd moves the caret to the end of the text.
-func (e *textView) MoveTextEnd(selAct selectionAction) {
-	caret := e.closestToRune(math.MaxInt)
-	e.caret.start = caret.runes
-	e.caret.xoff = fixed.I(e.params.MaxWidth) - caret.x
-	e.updateSelection(selAct)
-	e.clampCursorToGraphemes()
-}
-
-// MoveLineStart moves the caret to the start of the current line, ensuring that the resulting
+// MoveStart moves the caret to the start of the current line, ensuring that the resulting
 // cursor position is on a grapheme cluster boundary.
-func (e *textView) MoveLineStart(selAct selectionAction) {
+func (e *textView) MoveStart(selAct selectionAction) {
 	caret := e.closestToRune(e.caret.start)
 	caret = e.closestToLineCol(caret.lineCol.line, 0)
 	e.caret.start = caret.runes
@@ -669,9 +650,9 @@ func (e *textView) MoveLineStart(selAct selectionAction) {
 	e.clampCursorToGraphemes()
 }
 
-// MoveLineEnd moves the caret to the end of the current line, ensuring that the resulting
+// MoveEnd moves the caret to the end of the current line, ensuring that the resulting
 // cursor position is on a grapheme cluster boundary.
-func (e *textView) MoveLineEnd(selAct selectionAction) {
+func (e *textView) MoveEnd(selAct selectionAction) {
 	caret := e.closestToRune(e.caret.start)
 	caret = e.closestToLineCol(caret.lineCol.line, math.MaxInt)
 	e.caret.start = caret.runes