ContainerBox can now be aligned as well

canvas/shatter.go

@@ -0,0 +1,96 @@
+package canvas
+
+import "image"
+
+// Shatter takes in a bounding rectangle, and several rectangles to be
+// subtracted from it. It returns a slice of rectangles that tile together to
+// make up the difference between them. This is intended to be used for figuring
+// out which areas of a container box's background are covered by other boxes so
+// it doesn't waste CPU cycles drawing to those areas.
+func Shatter (
+	glass image.Rectangle,
+	rocks ...image.Rectangle,
+) (
+	tiles []image.Rectangle,
+) {
+	// in this function, the metaphor of throwing several rocks at a sheet
+	// of glass is used to illustrate the concept.
+
+	tiles = []image.Rectangle { glass }
+	for _, rock := range rocks {
+		
+		// check each tile to see if the rock has collided with it
+		tileLen := len(tiles)
+		for tileIndex := 0; tileIndex < tileLen; tileIndex ++ {
+			tile := tiles[tileIndex]
+			if !rock.Overlaps(tile) { continue }
+			newTiles, n := shatterOnce(tile, rock)
+			if n > 0 {
+				// the tile was shattered into one or more sub
+				// tiles
+				tiles[tileIndex] = newTiles[0]
+				tiles = append(tiles, newTiles[1:n]...)
+			} else {
+				// the tile was entirely obscured by the rock
+				// and must be wholly removed
+				tiles = remove(tiles, tileIndex)
+				tileIndex --
+				tileLen --
+			}
+		}
+	}
+	return
+}
+
+func shatterOnce (glass, rock image.Rectangle) (tiles [4]image.Rectangle, n int) {
+	rock = rock.Intersect(glass)
+
+	// |'''''''''''|
+	// |           |
+	// |###|'''|   |
+	// |###|___|   |
+	// |           |
+	// |___________|
+	if rock.Min.X > glass.Min.X { tiles[n] = image.Rect (
+		glass.Min.X, rock.Min.Y,
+		rock.Min.X,  rock.Max.Y,
+	); n ++ }
+	
+	// |'''''''''''|
+	// |           |
+	// |   |'''|###|
+	// |   |___|###|
+	// |           |
+	// |___________|
+	if rock.Max.X < glass.Max.X { tiles[n] = image.Rect (
+		rock.Max.X,  rock.Min.Y,
+		glass.Max.X, rock.Max.Y,
+	); n ++ }
+	
+	// |###########|
+	// |###########|
+	// |   |'''|   |
+	// |   |___|   |
+	// |           |
+	// |___________|
+	if rock.Min.Y > glass.Min.Y { tiles[n] = image.Rect (
+		glass.Min.X, glass.Min.Y,
+		glass.Max.X, rock.Min.Y,
+	); n ++ }
+	
+	// |'''''''''''|
+	// |           |
+	// |   |'''|   |
+	// |   |___|   |
+	// |###########|
+	// |###########|
+	if rock.Max.Y < glass.Max.Y { tiles[n] = image.Rect (
+		glass.Min.X, rock.Max.Y,
+		glass.Max.X, glass.Max.Y,
+	); n ++ }
+	return
+}
+
+func remove[ELEMENT any] (slice []ELEMENT, s int) []ELEMENT {
+    return append(slice[:s], slice[s + 1:]...)
+}

event/event.go

@@ -61,5 +61,7 @@ type FuncBroadcaster struct {
 
 // Broadcast calls all connected listener funcs.
 func (broadcaster *FuncBroadcaster) Broadcast () {
-	
+	for _, listener := range broadcaster.Listeners() {
+		listener()
+	}
 }

object.go

@@ -8,8 +8,6 @@ import "git.tebibyte.media/tomo/tomo/event"
 import "git.tebibyte.media/tomo/tomo/input"
 import "git.tebibyte.media/tomo/tomo/canvas"
 
-type Gap image.Point
-
 // Side represents one side of a rectangle.
 type Side int; const (
 	SideTop Side = iota
@@ -111,10 +109,11 @@ type Box interface {
 	Window         () Window
 	Bounds         () image.Rectangle
 	InnerBounds    () image.Rectangle
+	MinimumSize    () image.Point
 	SetBounds      (image.Rectangle)
 	SetColor       (color.Color)
 	SetBorder      (...Border)
-	SetMinimumSize (int, int)
+	SetMinimumSize (image.Point)
 	SetPadding     (Inset)
 
 	SetDNDData   (data.Data)
@@ -156,22 +155,24 @@ type ContentBox interface {
 	ContentBounds         () image.Rectangle
 	ScrollTo              (image.Point)
 	OnContentBoundsChange (func ()) event.Cookie
+	SetAlign              (x, y Align)
 }
 
 // TextBox is a box that contains text content.
 type TextBox interface {
 	ContentBox
+
+	SetText      (string)
 	SetTextColor (color.Color)
 	SetFace      (font.Face)
-	SetHAlign    (Align)
-	SetVAlign    (Align)
+	SetWrap      (bool)
 }
 
 // ContentBox is a box that can contain child objects. It arranges them
 // according to a layout rule.
 type ContainerBox interface {
 	ContentBox
-	SetGap    (Gap)
+	SetGap    (image.Point)
 	Add       (Object)
 	Delete    (Object)
 	Insert    (child Object, before Object)
@@ -181,9 +182,20 @@ type ContainerBox interface {
 	SetLayout (Layout)
 }
 
+// LayoutHints are passed to a layout to tell it how to arrange child boxes.
+type LayoutHints struct {
+	Bounds image.Rectangle
+	OverflowX bool
+	OverflowY bool
+	AlignX    Align
+	AlignY    Align
+	Gap image.Point
+}
+
 // Layout can be given to a ContainerBox to arrange child objects.
 type Layout interface {
-	Arrange (image.Rectangle, Gap, []Box)
+	MinimumSize (LayoutHints, []Box) image.Point
+	Arrange     (LayoutHints, []Box)
 }
 
 // Window is an operating system window. It can contain one object.