Fix TextBox scroll behavior

README.md

@@ -1,3 +1,14 @@
 # x
 
-WIP X backend for Tomo.
+[![Go Reference](https://pkg.go.dev/badge/git.tebibyte.media/tomo/x.svg)](https://pkg.go.dev/git.tebibyte.media/tomo/x)
+
+An X11 backend for Tomo.
+
+## Installation
+
+```
+cd x/x
+go build -buildmode=plugin .
+mkdir -p ~/.local/lib/tomo/plugins
+mv x.so ~/.local/lib/tomo/plugins
+```

box.go

@@ -259,6 +259,11 @@ func (this *box) handleMouseUp (button input.Button) {
 		listener(button)
 	}
 }
+func (this *box) handleScroll (x, y float64) {
+	for _, listener := range this.on.scroll.Listeners() {
+		listener(x, y)
+	}
+}
 func (this *box) handleKeyDown (key input.Key, numberPad bool) {
 	for _, listener := range this.on.keyDown.Listeners() {
 		listener(key, numberPad)
@@ -374,6 +379,10 @@ func (this *box) setParent (parent parent) {
 	this.parent = parent
 }
 
+func (this *box) getParent () parent {
+	return this.parent
+}
+
 func (this *box) flushActionQueue () {
 	if this.parent == nil || this.parent.window() == nil { return }
 
@@ -412,7 +421,7 @@ func (this *box) canBeFocused () bool {
 	return this.focusable
 }
 
-func (this *box) boxUnder (point image.Point) anyBox {
+func (this *box) boxUnder (point image.Point, category eventCategory) anyBox {
 	if point.In(this.bounds) {
 		return this.outer
 	} else {

canvas/canvas.go

@@ -97,7 +97,7 @@ func (this *pen) Path (points ...image.Point) {
 		if this.fill.A > 0 {
 			this.fillPolygon(this.fill, points...)
 		}
-	} else if this.closed {
+	} else if this.closed && len(points) > 2 {
 		if this.stroke.A > 0 {
 			this.strokePolygon(this.stroke, points...)
 		}

canvas/line.go

@@ -3,6 +3,7 @@ package xcanvas
 import "image"
 import "github.com/jezek/xgbutil/xgraphics"
 
+// TODO: clip the line to the bounds
 func (this *pen) line  (
 	c      xgraphics.BGRA,
 	min    image.Point,
@@ -17,11 +18,11 @@ func (this *pen) line  (
 		min: min,
 		max: max,
 	}
-	
+
 	if abs(max.Y - min.Y) < abs(max.X - min.X) {
 		if max.X < min.X { context.swap() }
 		context.lineLow()
-		
+
 	} else {
 		if max.Y < min.Y { context.swap() }
 		context.lineHigh()

canvas/texture.go

@@ -1,6 +1,8 @@
 package xcanvas
 
 import "image"
+import "image/color"
+import "github.com/jezek/xgbutil/xgraphics"
 import "git.tebibyte.media/tomo/tomo/canvas"
 
 // Texture is a read-only image texture that can be quickly written to a canvas.
@@ -40,11 +42,43 @@ func NewTextureFrom (source image.Image) *Texture {
 	return texture
 }
 
+func (this *Texture) BGRAAt (x, y int) xgraphics.BGRA {
+	if !(image.Point{ x, y }.In(this.rect)) {
+		return xgraphics.BGRA { }
+	}
+	index := this.PixOffset(x, y)
+	return xgraphics.BGRA {
+		B: this.pix[index    ],
+		G: this.pix[index + 1],
+		R: this.pix[index + 2],
+		A: this.pix[index + 3],
+	}
+}
+
+func (this *Texture) At (x, y int) color.Color {
+	return this.BGRAAt(x, y)
+}
+
+// Bounds returns the bounding rectangle of this texture.
+func (this *Texture) Bounds () image.Rectangle {
+	return this.rect
+}
+
+func (this *Texture) ColorModel () color.Model {
+	return xgraphics.BGRAModel
+}
+
 // Opaque reports whether or not the texture is fully opaque.
 func (this *Texture) Opaque () bool {
 	return !this.transparent
 }
 
+func (this *Texture) PixOffset (x, y int) int {
+	x = wrap(x, this.rect.Min.X, this.rect.Max.X)
+	y = wrap(y, this.rect.Min.Y, this.rect.Max.Y)
+	return x * 4 + y * this.stride
+}
+
 // Close frees the texture from memory.
 func (this *Texture) Close () error {
 	// i lied we dont actually need to close this, but we will once this
@@ -59,14 +93,11 @@ func (this *Texture) Clip (bounds image.Rectangle) canvas.Texture {
 	return &clipped
 }
 
-func (this *Texture) PixOffset (x, y int) int {
-	x = wrap(x, this.rect.Min.X, this.rect.Max.X)
-	y = wrap(y, this.rect.Min.Y, this.rect.Max.Y)
-	return x * 4 + y * this.stride
-}
-
 // AssertTexture checks if a given canvas.Texture is a texture from this package.
 func AssertTexture (unknown canvas.Texture) *Texture {
+	if unknown == nil {
+		return nil
+	}
 	if tx, ok := unknown.(*Texture); ok {
 		return tx
 	} else {

canvasbox.go

@@ -5,11 +5,13 @@ import "git.tebibyte.media/tomo/tomo/canvas"
 
 type canvasBox struct {
 	*box
+	userDrawer canvas.Drawer
 }
 
 func (backend *Backend) NewCanvasBox () tomo.CanvasBox {
 	this    := &canvasBox { }
 	this.box = backend.newBox(this)
+	this.drawer = this
 	return this
 }
 
@@ -18,10 +20,16 @@ func (this *canvasBox) Box () tomo.Box {
 }
 
 func (this *canvasBox) SetDrawer (drawer canvas.Drawer) {
-	this.drawer = drawer
+	this.userDrawer = drawer
 	this.invalidateDraw()
 }
 
 func (this *canvasBox) Invalidate () {
 	this.invalidateDraw()
 }
+
+func (this *canvasBox) Draw (can canvas.Canvas) {
+	this.box.Draw(can)
+	this.userDrawer.Draw (
+		can.Clip(this.padding.Apply(this.innerClippingBounds)))
+}

containerbox.go

@@ -1,6 +1,7 @@
 package x
 
 import "image"
+import "image/color"
 import "git.tebibyte.media/tomo/tomo"
 import "git.tebibyte.media/tomo/tomo/event"
 import "git.tebibyte.media/tomo/tomo/canvas"
@@ -12,11 +13,11 @@ type containerBox struct {
 	hAlign, vAlign       tomo.Align
 	contentBounds image.Rectangle
 	scroll        image.Point
-	
+	capture [4]bool
+
 	gap             image.Point
 	children        []tomo.Box
 	layout          tomo.Layout
-	propagateEvents bool
 
 	on struct {
 		contentBoundsChange event.FuncBroadcaster
@@ -24,11 +25,21 @@ type containerBox struct {
 }
 
 func (backend *Backend) NewContainerBox() tomo.ContainerBox {
-	this    := &containerBox { propagateEvents: true }
+	this    := &containerBox { }
 	this.box = backend.newBox(this)
 	return this
 }
 
+func (this *containerBox) SetColor (c color.Color) {
+	this.box.SetColor(c)
+	this.invalidateTransparentChildren()
+}
+
+func (this *containerBox) SetTexture (texture canvas.Texture) {
+	this.box.SetTexture(texture)
+	this.invalidateTransparentChildren()
+}
+
 func (this *containerBox) SetOverflow (horizontal, vertical bool) {
 	if this.hOverflow == horizontal && this.vOverflow == vertical { return }
 	this.hOverflow = horizontal
@@ -48,7 +59,7 @@ func (this *containerBox) ContentBounds () image.Rectangle {
 }
 
 func (this *containerBox) ScrollTo (point image.Point) {
-	// TODO: constrain scroll
+	if this.scroll == point { return }
 	this.scroll = point
 	this.invalidateLayout()
 }
@@ -57,8 +68,20 @@ func (this *containerBox) OnContentBoundsChange (callback func()) event.Cookie {
 	return this.on.contentBoundsChange.Connect(callback)
 }
 
-func (this *containerBox) SetPropagateEvents (propagate bool) {
-	this.propagateEvents = propagate
+func (this *containerBox) CaptureDND (capture bool) {
+	this.capture[eventCategoryDND] = capture
+}
+
+func (this *containerBox) CaptureMouse (capture bool) {
+	this.capture[eventCategoryMouse] = capture
+}
+
+func (this *containerBox) CaptureScroll (capture bool) {
+	this.capture[eventCategoryScroll] = capture
+}
+
+func (this *containerBox) CaptureKeyboard (capture bool) {
+	this.capture[eventCategoryKeyboard] = capture
 }
 
 func (this *containerBox) SetGap (gap image.Point) {
@@ -71,7 +94,7 @@ func (this *containerBox) SetGap (gap image.Point) {
 func (this *containerBox) Add (child tomo.Object) {
 	box := assertAnyBox(child.GetBox())
 	if indexOf(this.children, tomo.Box(box)) > -1 { return }
-	
+
 	box.setParent(this)
 	box.flushActionQueue()
 	this.children = append(this.children, box)
@@ -83,7 +106,7 @@ func (this *containerBox) Delete (child tomo.Object) {
 	box := assertAnyBox(child.GetBox())
 	index := indexOf(this.children, tomo.Box(box))
 	if index < 0 { return }
-	
+
 	box.setParent(nil)
 	this.children = remove(this.children, index)
 	this.invalidateLayout()
@@ -96,10 +119,14 @@ func (this *containerBox) Insert (child, before tomo.Object) {
 
 	beforeBox := assertAnyBox(before.GetBox())
 	index     := indexOf(this.children, tomo.Box(beforeBox))
-	if index < 0 { return }
 	
+	if index < 0 {
+		this.children = append(this.children, tomo.Box(box))
+	} else {
+		this.children = insert(this.children, index, tomo.Box(box))
+	}
 	box.setParent(this)
-	this.children = insert(this.children, index, tomo.Box(box))
+
 	this.invalidateLayout()
 	this.invalidateMinimum()
 }
@@ -155,13 +182,24 @@ func (this *containerBox) drawBackgroundPart (can canvas.Canvas) {
 	pen := can.Pen()
 	pen.Fill(this.color)
 	pen.Texture(this.texture)
-	
+
 	if this.transparent() && this.parent != nil {
 		this.parent.drawBackgroundPart(can)
 	}
 	pen.Rectangle(this.innerClippingBounds)
 }
 
+func (this *containerBox) invalidateTransparentChildren () {
+	window := this.window()
+	if window == nil { return }
+	for _, box := range this.children {
+		box := assertAnyBox(box)
+		if box.transparent() {
+			window.invalidateDraw(box)
+		}
+	}
+}
+
 func (this *containerBox) flushActionQueue () {
 	for _, box := range this.children {
 		box.(anyBox).flushActionQueue()
@@ -187,10 +225,14 @@ func (this *containerBox) notifyMinimumSizeChange (child anyBox) {
 	}
 }
 
+func (this *containerBox) boundedLayoutHints () tomo.LayoutHints {
+	hints := this.layoutHints()
+	hints.Bounds = this.ContentBounds().Add(this.InnerBounds().Min)
+	return hints
+}
+
 func (this *containerBox) layoutHints () tomo.LayoutHints {
-	innerBounds := this.InnerBounds().Sub(this.scroll)
 	return tomo.LayoutHints {
-		Bounds:    innerBounds,
 		OverflowX: this.hOverflow,
 		OverflowY: this.vOverflow,
 		AlignX:    this.hAlign,
@@ -202,10 +244,12 @@ func (this *containerBox) layoutHints () tomo.LayoutHints {
 func (this *containerBox) contentMinimum () image.Point {
 	minimum := this.box.contentMinimum()
 	if this.layout != nil {
-		minimum = minimum.Add (
-			this.layout.MinimumSize (
-				this.layoutHints(),
-				this.children))
+		layoutMinimum := this.layout.MinimumSize (
+			this.boundedLayoutHints(),
+			this.children)
+		if this.hOverflow { layoutMinimum.X = 0 }
+		if this.vOverflow { layoutMinimum.Y = 0 }
+		minimum = minimum.Add(layoutMinimum)
 	}
 	return minimum
 }
@@ -213,14 +257,59 @@ func (this *containerBox) contentMinimum () image.Point {
 func (this *containerBox) doLayout () {
 	this.box.doLayout()
 	previousContentBounds := this.contentBounds
+
+	// by default, use innerBounds for contentBounds. if a direction
+	// overflows, use the layout's minimum size for it.
+	var minimum image.Point
 	if this.layout != nil {
-		this.layout.Arrange(this.layoutHints(), this.children)
+		minimum = this.layout.MinimumSize (
+			this.layoutHints(),
+			this.children)
 	}
+	innerBounds := this.InnerBounds()
+	this.contentBounds = innerBounds
+	if this.hOverflow { this.contentBounds.Max.X = this.contentBounds.Min.X + minimum.X }
+	if this.vOverflow { this.contentBounds.Max.Y = this.contentBounds.Min.Y + minimum.Y }
+
+	// offset the content bounds by the scroll so children can be positioned
+	// accordingly.
+	this.constrainScroll()
+	this.contentBounds = this.contentBounds.Add(this.scroll).Sub(innerBounds.Min)
+	
+	// arrange children
+	if this.layout != nil {
+		this.layout.Arrange(this.boundedLayoutHints(), this.children)
+	}
+	
 	if previousContentBounds != this.contentBounds {
 		this.on.contentBoundsChange.Broadcast()
 	}
 }
 
+func (this *containerBox) constrainScroll () {
+	innerBounds := this.InnerBounds()
+	width  := this.contentBounds.Dx()
+	height := this.contentBounds.Dy()
+
+	// X
+	if width <= innerBounds.Dx() {
+		this.scroll.X = 0
+	} else if this.scroll.X > 0 {
+		this.scroll.X = 0
+	} else if this.scroll.X < innerBounds.Dx() - width  {
+		this.scroll.X =  innerBounds.Dx() - width
+	}
+
+	// Y
+	if height <= innerBounds.Dy() {
+		this.scroll.Y = 0
+	} else if this.scroll.Y > 0 {
+		this.scroll.Y = 0
+	} else if this.scroll.Y < innerBounds.Dy() - height {
+		this.scroll.Y = innerBounds.Dy() - height
+	}
+}
+
 func (this *containerBox) recursiveRedo () {
 	this.doLayout()
 	this.doDraw()
@@ -229,15 +318,15 @@ func (this *containerBox) recursiveRedo () {
 	}
 }
 
-func (this *containerBox) boxUnder (point image.Point) anyBox {
-	if this.propagateEvents {
+func (this *containerBox) boxUnder (point image.Point, category eventCategory) anyBox {
+	if !this.capture[category] {
 		for _, box := range this.children {
-			candidate := box.(anyBox).boxUnder(point)
+			candidate := box.(anyBox).boxUnder(point, category)
 			if candidate != nil { return candidate }
 		}
 	}
 
-	return this.box.boxUnder(point)
+	return this.box.boxUnder(point, category)
 }
 
 func (this *containerBox) propagate (callback func (anyBox) bool) bool {
@@ -251,11 +340,15 @@ func (this *containerBox) propagate (callback func (anyBox) bool) bool {
 
 func (this *containerBox) propagateAlt (callback func (anyBox) bool) bool {
 	if !callback(this) { return false}
-	
+
 	for _, box := range this.children {
 		box := box.(anyBox)
 		if !box.propagateAlt(callback) { return false }
 	}
-	
+
 	return true
 }
+
+func (this *containerBox) captures (category eventCategory) bool {
+	return this.capture[category]
+}

event.go

@@ -8,6 +8,31 @@ import "git.tebibyte.media/tomo/xgbkb"
 import "github.com/jezek/xgbutil/xevent"
 import "git.tebibyte.media/tomo/tomo/input"
 
+type scrollSum struct {
+	x, y int
+}
+
+// TODO: this needs to be configurable, we need a config api
+const scrollDistance = 16
+
+func (sum *scrollSum) add (button xproto.Button, window *window, state uint16) {
+	if xgbkb.StateToModifiers(state).Shift {
+		switch button {
+		case 4: sum.x -= scrollDistance
+		case 5: sum.x += scrollDistance
+		case 6: sum.y -= scrollDistance
+		case 7: sum.y += scrollDistance
+		}
+	} else {
+		switch button {
+		case 4: sum.y -= scrollDistance
+		case 5: sum.y += scrollDistance
+		case 6: sum.x -= scrollDistance
+		case 7: sum.x += scrollDistance
+		}
+	}
+}
+
 var buttonCodeTable = map[xproto.Keysym] input.Key {
 	0xFFFFFF: input.KeyNone,
 
@@ -208,7 +233,7 @@ func (window *window) handleKeyPress (
 	} else if key == input.KeyEscape && window.shy {
 		window.Close()
 	} else if window.focused != nil {
-		window.focused.handleKeyDown(key, numberPad)
+		window.keyboardTarget().handleKeyDown(key, numberPad)
 	}
 }
 
@@ -241,7 +266,7 @@ func (window *window) handleKeyRelease (
 	window.updateModifiers(keyEvent.State)
 
 	if window.focused != nil {
-		window.focused.handleKeyUp(key, numberPad)
+		window.keyboardTarget().handleKeyUp(key, numberPad)
 	}
 }
 
@@ -261,20 +286,15 @@ func (window *window) handleButtonPress (
 	if !insideWindow && window.shy && !scrolling {
 		window.Close()
 	} else if scrolling {
-		// TODO
-		// underneath := window.scrollTargetChildAt(point)
-		// if underneath != nil {
-			// if child, ok := underneath.element.(ability.ScrollTarget); ok {
-				// sum := scrollSum { }
-				// sum.add(buttonEvent.Detail, window, buttonEvent.State)
-				// window.compressScrollSum(buttonEvent, &sum)
-				// child.HandleScroll (
-					// point, float64(sum.x), float64(sum.y),
-					// modifiers)
-			// }
-		// }
+		underneath := window.boxUnder(point, eventCategoryScroll)
+		if underneath != nil {
+			sum := scrollSum { }
+			sum.add(buttonEvent.Detail, window, buttonEvent.State)
+			window.compressScrollSum(buttonEvent, &sum)
+			underneath.handleScroll(float64(sum.x), float64(sum.y))
+		}
 	} else {
-		underneath := window.boxUnder(point)
+		underneath := window.boxUnder(point, eventCategoryMouse)
 		window.drags[buttonEvent.Detail] = underneath
 		if underneath != nil {
 			underneath.handleMouseDown(input.Button(buttonEvent.Detail))
@@ -318,12 +338,14 @@ func (window *window) handleMotionNotify (
 		handled = true
 	}
 
-	underneath := window.boxUnder(image.Pt(x, y))
-	window.hover(underneath)
-	
-	if !handled {
-		underneath.handleMouseMove()
+	underneath := window.boxUnder(image.Pt(x, y), eventCategoryMouse)
+	if underneath != nil {
+		window.hover(underneath)
+		if !handled {
+			underneath.handleMouseMove()
+		}
 	}
+	
 }
 
 func (window *window) compressExpose (
@@ -391,6 +413,33 @@ func (window *window) compressConfigureNotify (
 	return
 }
 
+func (window *window) compressScrollSum (
+	firstEvent xproto.ButtonPressEvent,
+	sum *scrollSum,
+) {
+	window.backend.x.Sync()
+	xevent.Read(window.backend.x, false)
+	
+	for index, untypedEvent := range xevent.Peek(window.backend.x) {
+		if untypedEvent.Err != nil { continue }
+		
+		typedEvent, ok := untypedEvent.Event.(xproto.ButtonPressEvent)
+		if !ok { continue }
+
+		if firstEvent.Event == typedEvent.Event &&
+			typedEvent.Detail >= 4 &&
+			typedEvent.Detail <= 7 {
+
+			sum.add(typedEvent.Detail, window, typedEvent.State)
+			defer func (index int) {
+				xevent.DequeueAt(window.backend.x, index)
+			} (index)
+		}
+	}
+
+	return
+}
+
 func (window *window) compressMotionNotify (
 	firstEvent xproto.MotionNotifyEvent,
 ) (

go.mod

@@ -3,8 +3,8 @@ module git.tebibyte.media/tomo/x
 go 1.20
 
 require (
-	git.tebibyte.media/tomo/tomo v0.26.1
-	git.tebibyte.media/tomo/typeset v0.5.2
+	git.tebibyte.media/tomo/tomo v0.31.0
+	git.tebibyte.media/tomo/typeset v0.7.1
 	git.tebibyte.media/tomo/xgbkb v1.0.1
 	github.com/jezek/xgb v1.1.0
 	github.com/jezek/xgbutil v0.0.0-20230603163917-04188eb39cf0

go.sum

@@ -1,8 +1,8 @@
 git.tebibyte.media/sashakoshka/xgbkb v1.0.0/go.mod h1:pNcE6TRO93vHd6q42SdwLSTTj25L0Yzggz7yLe0JV6Q=
-git.tebibyte.media/tomo/tomo v0.26.1 h1:V5ciRuixMYb79aAawgquFEfJ1icyEmMKBKFPWwi94NE=
-git.tebibyte.media/tomo/tomo v0.26.1/go.mod h1:C9EzepS9wjkTJjnZaPBh22YvVPyA4hbBAJVU20Rdmps=
-git.tebibyte.media/tomo/typeset v0.5.2 h1:qHxN62/VDnrAouOuzxLmLleQNwAebshrfVYvtoOnAG4=
-git.tebibyte.media/tomo/typeset v0.5.2/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
+git.tebibyte.media/tomo/tomo v0.31.0 h1:LHPpj3AWycochnC8F441aaRNS6Tq6w6WnBrp/LGjyhM=
+git.tebibyte.media/tomo/tomo v0.31.0/go.mod h1:C9EzepS9wjkTJjnZaPBh22YvVPyA4hbBAJVU20Rdmps=
+git.tebibyte.media/tomo/typeset v0.7.1 h1:aZrsHwCG5ZB4f5CruRFsxLv5ezJUCFUFsQJJso2sXQ8=
+git.tebibyte.media/tomo/typeset v0.7.1/go.mod h1:PwDpSdBF3l/EzoIsa2ME7QffVVajnTHZN6l3MHEGe1g=
 git.tebibyte.media/tomo/xgbkb v1.0.1 h1:b3HDUopjdQp1MZrb5Vpil4bOtk3NnNXtfQW27Blw2kE=
 git.tebibyte.media/tomo/xgbkb v1.0.1/go.mod h1:P5Du0yo5hUsojchW08t+Mds0XPIJXwMi733ZfklzjRw=
 github.com/BurntSushi/freetype-go v0.0.0-20160129220410-b763ddbfe298 h1:1qlsVAQJXZHsaM8b6OLVo6muQUQd4CwkH/D3fnnbHXA=

system.go

@@ -37,21 +37,24 @@ type parent interface {
 	canvas                  () canvas.Canvas
 	notifyMinimumSizeChange (anyBox)
 	drawBackgroundPart      (canvas.Canvas)
+	captures                (eventCategory) bool
 }
 
 type anyBox interface {
 	tomo.Box
 	canvas.Drawer
-	
+
 	doDraw           ()
 	doLayout         ()
 	doMinimumSize    ()
 	contentMinimum   () image.Point
 	setParent        (parent)
+	getParent        () parent
 	flushActionQueue ()
 	recursiveRedo    ()
 	canBeFocused     () bool
-	boxUnder         (image.Point) anyBox
+	boxUnder         (image.Point, eventCategory) anyBox
+	transparent      () bool
 
 	propagate    (func (anyBox) bool) bool
 	propagateAlt (func (anyBox) bool) bool
@@ -66,7 +69,7 @@ type anyBox interface {
 	handleMouseMove  ()
 	handleMouseDown  (input.Button)
 	handleMouseUp    (input.Button)
-	// handleScroll     (float64, float64)
+	handleScroll     (float64, float64)
 	handleKeyDown    (input.Key, bool)
 	handleKeyUp      (input.Key, bool)
 }
@@ -122,10 +125,10 @@ func (window *window) invalidateLayout (box anyBox) {
 
 func (window *window) focus (box anyBox) {
 	if window.focused == box { return }
-	
+
 	previous := window.focused
 	window.focused = box
-	
+
 	if previous != nil {
 		previous.handleFocusLeave()
 	}
@@ -136,10 +139,10 @@ func (window *window) focus (box anyBox) {
 
 func (window *window) hover (box anyBox) {
 	if window.hovered == box { return }
-	
+
 	previous := window.hovered
 	window.hovered = box
-	
+
 	if previous != nil {
 		previous.handleMouseLeave()
 	}
@@ -152,9 +155,36 @@ func (window *window) anyFocused () bool {
 	return window.focused != nil
 }
 
-func (this *window) boxUnder (point image.Point) anyBox {
+type eventCategory int; const (
+	eventCategoryDND eventCategory = iota
+	eventCategoryMouse
+	eventCategoryScroll
+	eventCategoryKeyboard
+)
+
+func (this *window) boxUnder (point image.Point, category eventCategory) anyBox {
 	if this.root == nil { return nil }
-	return this.root.boxUnder(point)
+	return this.root.boxUnder(point, category)
+}
+
+func (this *window) captures (eventCategory) bool {
+	return false
+}
+
+func (this *window) keyboardTarget () anyBox {
+	focused := this.window().focused
+	if focused == nil { return nil }
+	parent := focused.getParent()
+	for {
+		parentBox, ok := parent.(anyBox)
+		if !ok { break }
+		if parent.captures(eventCategoryKeyboard) {
+			return parentBox
+		}
+		parent = parentBox.getParent()
+	}
+
+	return focused
 }
 
 func (this *window) focusNext () {
@@ -213,7 +243,7 @@ func (window *window) afterEvent () {
 		childBounds = childBounds.Sub(childBounds.Min)
 		window.root.SetBounds(childBounds)
 
-		// full relayout/redraw		
+		// full relayout/redraw
 		if window.root != nil {
 			window.root.recursiveRedo()
 		}

textbox.go

@@ -23,6 +23,7 @@ type textBox struct {
 	face      font.Face
 	wrap      bool
 	hAlign    tomo.Align
+	vAlign    tomo.Align
 
 	selectable  bool
 	selecting   bool
@@ -59,7 +60,7 @@ func (this *textBox) ContentBounds () image.Rectangle {
 }
 
 func (this *textBox) ScrollTo (point image.Point) {
-	// TODO: constrain scroll
+	if this.scroll == point { return }
 	this.scroll = point
 	this.invalidateLayout()
 }
@@ -115,6 +116,7 @@ func (this *textBox) Select (dot text.Dot) {
 	if this.dot == dot  { return }
 	this.SetFocused(true)
 	this.dot = dot
+	this.scrollToDot()
 	this.on.dotChange.Broadcast()
 	this.invalidateDraw()
 }
@@ -128,16 +130,10 @@ func (this *textBox) OnDotChange (callback func ()) event.Cookie {
 }
 
 func (this *textBox) SetAlign (x, y tomo.Align) {
-	if this.hAlign == x { return }
+	if this.hAlign == x && this.vAlign == y { return }
 	this.hAlign = x
-
-	switch x {
-	case tomo.AlignStart:  this.drawer.SetAlign(typeset.AlignLeft)
-	case tomo.AlignMiddle: this.drawer.SetAlign(typeset.AlignCenter)
-	case tomo.AlignEnd:    this.drawer.SetAlign(typeset.AlignRight)
-	case tomo.AlignEven:   this.drawer.SetAlign(typeset.AlignJustify)
-	}
-
+	this.vAlign = y
+	this.drawer.SetAlign(typeset.Align(x), typeset.Align(y))
 	this.invalidateDraw()
 }
 
@@ -226,7 +222,7 @@ func (this *textBox) drawDot (can canvas.Canvas) {
 
 func (this *textBox) textOffset () image.Point {
 	return this.InnerBounds().Min.
-		Sub(this.scroll).
+		Add(this.scroll).
 		Sub(this.drawer.LayoutBoundsSpace().Min)
 }
 
@@ -275,16 +271,13 @@ func (this *textBox) normalizedLayoutBoundsSpace () image.Rectangle {
 }
 
 func (this *textBox) contentMinimum () image.Point {
-	minimum := image.Pt (
-		this.drawer.Em().Round(),
-		this.drawer.LineHeight().Round())
+	minimum := this.drawer.MinimumSize()
 
-	textSize := this.drawer.MinimumSize()
-	if !this.hOverflow && !this.wrap {
-		minimum.X = textSize.X
+	if this.hOverflow || this.wrap {
+		minimum.X = this.drawer.Em().Round()
 	}
-	if !this.vOverflow {
-		 minimum.Y = textSize.Y
+	if this.vOverflow {
+		minimum.Y = this.drawer.LineHeight().Round()
 	}
 
 	return minimum.Add(this.box.contentMinimum())
@@ -295,12 +288,63 @@ func (this *textBox) doLayout () {
 	previousContentBounds := this.contentBounds
 
 	innerBounds := this.InnerBounds()
-	this.drawer.SetMaxWidth(innerBounds.Dx())
-	this.drawer.SetMaxHeight(innerBounds.Dy())
+	this.drawer.SetWidth(innerBounds.Dx())
+	this.drawer.SetHeight(innerBounds.Dy())
 
-	this.contentBounds = this.normalizedLayoutBoundsSpace().Sub(this.scroll)
+	this.contentBounds = this.normalizedLayoutBoundsSpace()
+	this.constrainScroll()
+	this.contentBounds = this.contentBounds.Add(this.scroll)
+	// println(this.InnerBounds().String(), this.contentBounds.String())
 
 	if previousContentBounds != this.contentBounds {
 		this.on.contentBoundsChange.Broadcast()
 	}
 }
+
+func (this *textBox) constrainScroll () {
+	innerBounds := this.InnerBounds()
+	width  := this.contentBounds.Dx()
+	height := this.contentBounds.Dy()
+
+	// X
+	if width <= innerBounds.Dx() {
+		this.scroll.X = 0
+	} else if this.scroll.X > 0 {
+		this.scroll.X = 0
+	} else if this.scroll.X < innerBounds.Dx() - width  {
+		this.scroll.X =  innerBounds.Dx() - width
+	}
+
+	// Y
+	if height <= innerBounds.Dy() {
+		this.scroll.Y = 0
+	} else if this.scroll.Y > 0 {
+		this.scroll.Y = 0
+	} else if this.scroll.Y < innerBounds.Dy() - height {
+		this.scroll.Y = innerBounds.Dy() - height
+	}
+}
+
+func (this *textBox) scrollToDot () {
+	dot := roundPt(this.drawer.PositionAt(this.dot.End)).Add(this.textOffset())
+	innerBounds := this.InnerBounds()
+	scroll      := this.scroll
+	em          := this.drawer.Em().Round()
+	lineHeight  := this.drawer.LineHeight().Round()
+
+	// X
+	if dot.X < innerBounds.Min.X + em {
+		scroll.X += innerBounds.Min.X - dot.X + em
+	} else if dot.X > innerBounds.Max.X - em {
+		scroll.X -= dot.X - innerBounds.Max.X + em
+	}
+
+	// Y
+	if dot.Y < innerBounds.Min.Y + lineHeight {
+		scroll.Y += innerBounds.Min.Y - dot.Y + lineHeight
+	} else if dot.Y > innerBounds.Max.Y - lineHeight {
+		scroll.Y -= dot.Y - innerBounds.Max.Y + lineHeight
+	}
+	
+	this.ScrollTo(scroll)
+}

texture.go

@@ -4,6 +4,6 @@ import "image"
 import "git.tebibyte.media/tomo/x/canvas"
 import "git.tebibyte.media/tomo/tomo/canvas"
 
-func (backend Backend) NewTexture (source image.Image) canvas.Texture {
+func (backend Backend) NewTexture (source image.Image) canvas.TextureCloser {
 	return xcanvas.NewTextureFrom(source)
 }

window.go

@@ -73,6 +73,20 @@ func (backend *Backend) NewWindow (
 	return output, err
 }
 
+func (backend *Backend) NewPlainWindow (
+	bounds image.Rectangle,
+) (
+	output tomo.MainWindow,
+	err error,
+) {
+	backend.assert()
+	window, err := backend.newWindow(bounds, false)
+	window.setType("dock")
+	
+	output = mainWindow { window: window }
+	return output, err
+}
+
 func (backend *Backend) newWindow (
 	bounds   image.Rectangle,
 	override bool,

x/plugin.go

@@ -1,17 +0,0 @@
-// Plugin x provides the X11 backend as a plugin.
-package main
-
-import "git.tebibyte.media/tomo/x"
-import "git.tebibyte.media/tomo/tomo"
-
-func init () {
-	tomo.Register(0, tomo.Factory(x.NewBackend))	
-}
-
-func Name () string {
-	return "X"
-}
-
-func Description () string {
-	return "Provides an X11 backend."
-}