cleaning up the component system just a bit more...

Reviewed-on: #6

common/elements/v1/block.go

@@ -1,61 +0,0 @@
-package elements
-
-import (
-	"context"
-	"image/color"
-
-	"git.vezzani.net/ben/games/common/ux/v1"
-	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/vector"
-	"golang.org/x/image/font"
-)
-
-type Block struct {
-	Label string
-	Style struct {
-		Width           float32
-		Height          float32
-		XAlign          XAlign
-		YAlign          YAlign
-		Offset          int
-		Font            *font.Face
-		BackgroundColor *color.Color
-	}
-}
-
-func (b *Block) backgroundColor() color.Color {
-	var c *color.Color
-	if b.Style.BackgroundColor != nil {
-		c = b.Style.BackgroundColor
-	} else {
-		c = &ux.BackgroundColor
-	}
-
-	return *c
-}
-
-func (b *Block) size(ctx context.Context) (x, y float32) {
-	x = b.Style.Width
-	y = b.Style.Height
-
-	if x == 0 || y == 0 {
-		px, py := GetContainerSize(ctx)
-		if x == 0 {
-			x = px
-		}
-		if y == 0 {
-			y = py
-		}
-	}
-
-	return
-}
-
-func (b *Block) Draw(ctx context.Context, image *ebiten.Image) error {
-	xz, yz := GetZero(ctx)
-	w, h := b.size(ctx)
-
-	vector.StrokeRect(image, xz, yz, w, h, 1, b.backgroundColor(), true)
-
-	return nil
-}

common/elements/v1/blocks/block.go

@@ -0,0 +1,56 @@
+package blocks
+
+import (
+	"image/color"
+
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/vector"
+)
+
+func New(ops ...OptFunc) elements.Element {
+	b := Block{}
+	for i := range ops {
+		ops[i](&b)
+	}
+	return &b
+}
+
+type Block struct {
+	elements.Core
+
+	backgroundColor *color.Color
+	mouse.NopHandler
+	width, height int
+	name          string
+}
+
+func (b *Block) Bounds() elements.Bounds {
+	return elements.Bounds{
+		Min:    b.Anchor(),
+		Width:  b.width,
+		Height: b.height,
+	}
+}
+
+func (b *Block) Size() (w, h int) {
+	return b.width, b.height
+}
+
+func (b *Block) Draw(image *ebiten.Image) {
+	bnd := b.Bounds()
+	if b.backgroundColor != nil {
+		vector.DrawFilledRect(
+			image,
+			float32(b.Anchor().X),
+			float32(b.Anchor().Y),
+			float32(bnd.Width),
+			float32(bnd.Height),
+			*b.backgroundColor,
+			true,
+		)
+	}
+	return
+}

common/elements/v1/blocks/options.go

@@ -0,0 +1,33 @@
+package blocks
+
+import (
+	"image/color"
+
+	"git.vezzani.net/ben/games/common/elements/v1"
+)
+
+type OptFunc func(*Block)
+
+func Core(f elements.OptFunc) OptFunc {
+	return func(b *Block) {
+		f(&b.Core)
+	}
+}
+
+func Size(w, h int) OptFunc {
+	return func(b *Block) {
+		b.width, b.height = w, h
+	}
+}
+
+func BackgroundColor(c color.Color) OptFunc {
+	return func(b *Block) {
+		b.backgroundColor = &c
+	}
+}
+
+func Name(n string) OptFunc {
+	return func(b *Block) {
+		b.name = n
+	}
+}

common/elements/v1/button.go

@@ -1,76 +0,0 @@
-package elements
-
-import (
-	"context"
-	"image/color"
-
-	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/vector"
-	"golang.org/x/image/font"
-)
-import "git.vezzani.net/ben/games/common/ux/v1"
-
-type XAlign int
-type YAlign int
-
-const (
-	AlignCente XAlign = iota
-	AlignLeft
-	AlignRight
-)
-
-const (
-	AlignCenter YAlign = iota
-	AlignTop
-	AlignBottom
-)
-
-type Button struct {
-	mouseHandler
-	Block
-	Label        string
-	OnClick      func() error
-	OnRightClick func() error
-	Style        struct {
-		MouseDownColor *color.Color
-	}
-}
-
-func (b *Button) HandleClick(_ MouseState) error {
-	if b.OnClick == nil {
-		return nil
-	}
-	return b.OnClick()
-}
-
-func (b *Button) getFont() font.Face {
-	if b.Block.Style.Font == nil {
-		return ux.FontFace
-	}
-
-	return *b.Block.Style.Font
-}
-
-func (b *Button) backgroundColor() color.Color {
-	var c *color.Color
-	if b.Block.Style.BackgroundColor != nil {
-		c = b.Block.Style.BackgroundColor
-	} else {
-		c = &ux.BackgroundColor
-	}
-
-	if (b.mouseState.RightDown || b.mouseState.LeftDown) && b.Style.MouseDownColor != nil {
-		c = b.Style.MouseDownColor
-	}
-
-	return *c
-}
-
-func (b *Button) Draw(ctx context.Context, image *ebiten.Image) error {
-	xz, yz := GetZero(ctx)
-	w, h := b.size(ctx)
-
-	vector.StrokeRect(image, xz, yz, w, h, 1, b.backgroundColor(), true)
-
-	return nil
-}

common/elements/v1/buttons/button.go

@@ -0,0 +1,82 @@
+package buttons
+
+import (
+	"image/color"
+
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/blocks"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+	"git.vezzani.net/ben/games/common/ux/v1"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/text"
+	"golang.org/x/image/font"
+)
+
+func New(ops ...OptFunc) elements.Element {
+	b := Button{
+		Block: blocks.Block{},
+		font:  ux.FontFace,
+		color: ux.FontColor,
+	}
+	for op := range ops {
+		ops[op](&b)
+	}
+
+	return &b
+}
+
+type Button struct {
+	blocks.Block
+
+	label string
+	font  font.Face
+	color color.Color
+
+	onClick     func(ms mouse.State)
+	onMouseDown func(ms mouse.State)
+	onMouseUp   func(ms mouse.State)
+}
+
+func (b *Button) Draw(screen *ebiten.Image) {
+	b.Block.Draw(screen)
+	b.drawLabel(screen)
+}
+
+func (b *Button) drawLabel(screen *ebiten.Image) {
+	if b.label != "" {
+		strBounds, _ := font.BoundString(b.font, b.label)
+
+		textWidth := strBounds.Max.X - strBounds.Min.X
+		textHeight := strBounds.Max.Y - strBounds.Min.Y
+
+		bnd := b.Bounds()
+		tx := bnd.Min.X + (bnd.Width / 2) - (textWidth / 2).Round()
+		ty := bnd.Min.Y + (bnd.Height / 2) - (textHeight / 2).Round()
+
+		text.Draw(screen, b.label, b.font, tx, ty, b.color)
+
+	}
+}
+
+func (b *Button) HandleMouseEvent(ms mouse.State) bool {
+	bnd := b.Bounds()
+
+	if !bnd.Contains(ms.Point()) {
+		return false
+	}
+
+	switch {
+	case b.onClick != nil && (ms.RightClicked || ms.LeftClicked):
+		b.onClick(ms)
+		return true
+	case b.onMouseUp != nil && (ms.RightChanged && !ms.RightDown || ms.LeftChanged && !ms.LeftDown):
+		b.onMouseUp(ms)
+		return true
+	case b.onMouseDown != nil && (ms.RightChanged && ms.RightDown || ms.LeftChanged && ms.LeftDown):
+		b.onMouseDown(ms)
+		return true
+	}
+
+	return false
+}

common/elements/v1/buttons/options.go

@@ -0,0 +1,53 @@
+package buttons
+
+import (
+	"image/color"
+
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/blocks"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+)
+
+type OptFunc func(button *Button)
+
+func Core(f elements.OptFunc) OptFunc {
+	return func(b *Button) {
+		f(&b.Core)
+	}
+}
+
+func OnClick(f func(ms mouse.State)) OptFunc {
+	return func(button *Button) {
+		button.onClick = f
+	}
+}
+
+func OnMouseDown(f func(ms mouse.State)) OptFunc {
+	return func(button *Button) {
+		button.onMouseDown = f
+	}
+}
+
+func OnMouseUp(f func(ms mouse.State)) OptFunc {
+	return func(button *Button) {
+		button.onMouseUp = f
+	}
+}
+
+func BlockOpt(o blocks.OptFunc) OptFunc {
+	return func(s *Button) {
+		o(&s.Block)
+	}
+}
+
+func Label(s string) OptFunc {
+	return func(button *Button) {
+		button.label = s
+	}
+}
+
+func LabelColor(color color.Color) OptFunc {
+	return func(button *Button) {
+		button.color = color
+	}
+}

common/elements/v1/config.go

@@ -0,0 +1,15 @@
+package elements
+
+type OptFunc func(*Core)
+
+func Children(children ...Element) OptFunc {
+	return func(c *Core) {
+		c.children = children
+	}
+}
+
+func Name(name string) OptFunc {
+	return func(s *Core) {
+		s.name = name
+	}
+}

common/elements/v1/element.go

@@ -1,92 +1,63 @@
 package elements
 
 import (
-	"context"
-
 	"github.com/hajimehoshi/ebiten/v2"
 )
 
-type MouseState struct {
-	X, Y                      int32
-	LeftDown, RightDown       bool
-	LeftChanged, RightChanged bool
-}
-
-const (
-	ContainerSizeKey = "container_size"
-	ZeroKey          = "zero"
-)
-
-type Clickable interface {
-	Element
-	HandleClick(ctx context.Context, s MouseState) error
-}
-
-type Mouseable interface {
-	Element
-	HandleMouseEnter(ctx context.Context, s MouseState) error
-	HandleMouseLeave(ctx context.Context, s MouseState) error
-	HandleMouseMove(ctx context.Context, s MouseState) error
-	HandleMouseDown(ctx context.Context, s MouseState) error
-	HandleMouseUp(ctx context.Context, s MouseState) error
-}
-
 type Element interface {
-	Draw(ctx context.Context, image *ebiten.Image) error
+	Draw(*ebiten.Image)
+	SetAnchor(Point)
+	Anchor() Point
+	Size() (w, h int)
+	Children() []Element
 }
 
-func SetZero(ctx context.Context, x, y float32) context.Context {
-	return context.WithValue(ctx, ZeroKey, [2]float32{x, y})
+type Point struct {
+	X, Y int
 }
 
-func SetContainerSize(ctx context.Context, w, h float32) context.Context {
-	return context.WithValue(ctx, ContainerSizeKey, [2]float32{w, h})
-}
-
-func GetZero(ctx context.Context) (x, y float32) {
-	if v, ok := ctx.Value(ZeroKey).([2]float32); ok {
-		return v[0], v[1]
+func (p Point) Delta(p2 Point) Point {
+	return Point{
+		X: p2.X - p.X,
+		Y: p2.Y - p.Y,
 	}
-	return 0, 0
 }
 
-func GetContainerSize(ctx context.Context) (w, h float32) {
-	if s, ok := ctx.Value(ContainerSizeKey).([2]float32); ok {
-		return s[0], s[1]
+func (p Point) Add(p2 Point) Point {
+	return Point{
+		X: p.X + p2.X,
+		Y: p.Y + p2.Y,
 	}
-	return 0, 0
 }
 
-type mouseHandler struct {
-	mouseState     MouseState
-	prevMouseState MouseState
+type Bounds struct {
+	Min           Point
+	Width, Height int
 }
 
-func (b *mouseHandler) HandleMouseEnter(s MouseState) error {
-	b.mouseState = s
-	return nil
+func (b *Bounds) Contains(p Point) bool {
+	return p.X >= b.Min.X && p.X <= b.Min.X+b.Width && p.Y >= b.Min.Y && p.Y <= b.Min.Y+b.Height
 }
 
-func (b *mouseHandler) HandleMouseLeave(s MouseState) error {
-	b.prevMouseState = b.mouseState
-	b.mouseState = MouseState{}
-	return nil
+type Core struct {
+	anchor   Point
+	children []Element
+
+	name string // For debugging
 }
 
-func (b *mouseHandler) HandleMouseMove(s MouseState) error {
-	b.prevMouseState = b.mouseState
-	b.mouseState = s
-	return nil
+func (c *Core) Anchor() Point {
+	return c.anchor
 }
 
-func (b *mouseHandler) HandleMouseDown(s MouseState) error {
-	b.prevMouseState = b.mouseState
-	b.mouseState = s
-	return nil
+func (c *Core) SetAnchor(a Point) {
+	d := c.Anchor().Delta(a)
+	for _, ch := range c.Children() {
+		ch.SetAnchor(ch.Anchor().Add(d))
+	}
+	c.anchor = a
 }
 
-func (b *mouseHandler) HandleMouseUp(s MouseState) error {
-	b.prevMouseState = b.mouseState
-	b.mouseState = s
-	return nil
+func (c *Core) Children() []Element {
+	return c.children
 }

common/elements/v1/menu.go

@@ -1 +0,0 @@
-package elements

common/elements/v1/mouse/mouse.go

@@ -0,0 +1,93 @@
+package mouse
+
+import (
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"github.com/hajimehoshi/ebiten/v2"
+	"github.com/hajimehoshi/ebiten/v2/inpututil"
+)
+
+type NopHandler struct{}
+
+func (n NopHandler) HandleMouseEvent(s State) bool {
+	return false
+}
+
+type EventHandler interface {
+	HandleMouseEvent(s State) bool
+}
+
+type State struct {
+	X, Y                      int
+	LeftDown, RightDown       bool
+	LeftChanged, RightChanged bool
+	LeftClicked, RightClicked bool
+	Clicked                   bool
+}
+
+func (s *State) Point() elements.Point {
+	return elements.Point{
+		X: s.X,
+		Y: s.Y,
+	}
+}
+
+func Handler(e elements.Element) func() bool {
+	newState := StateBuilder()
+	ms := newState()
+	return func() bool {
+		ms = newState()
+		return propagateMouse(e, ms)
+	}
+}
+
+func propagateMouse(e elements.Element, ms State) bool {
+	for _, c := range e.Children() {
+		if propagateMouse(c, ms) {
+			return true
+		}
+	}
+
+	if e, ok := e.(EventHandler); ok {
+		return e.HandleMouseEvent(ms)
+	}
+
+	return false
+}
+
+func StateBuilder() func() State {
+	prevState := State{}
+	state := State{}
+	return func() State {
+		state = prevState
+		state.X, state.Y = ebiten.CursorPosition()
+
+		if inpututil.IsMouseButtonJustPressed(ebiten.MouseButtonLeft) {
+			state.LeftDown = true
+		}
+		if inpututil.IsMouseButtonJustPressed(ebiten.MouseButtonRight) {
+			state.RightDown = true
+		}
+		if inpututil.IsMouseButtonJustReleased(ebiten.MouseButtonLeft) {
+			state.LeftDown = false
+			if !state.RightDown {
+				state.Clicked = true
+			}
+		}
+		if inpututil.IsMouseButtonJustReleased(ebiten.MouseButtonRight) {
+			state.RightDown = false
+			if !state.LeftDown {
+				state.Clicked = true
+			}
+		}
+
+		state.Clicked = state.Clicked && !prevState.Clicked
+
+		state.LeftChanged = state.LeftDown != prevState.LeftDown
+		state.RightChanged = state.RightDown != prevState.RightDown
+		state.LeftClicked = state.LeftChanged && state.LeftDown
+		state.RightClicked = state.RightChanged && state.RightDown
+
+		prevState = state
+		return state
+	}
+}

common/elements/v1/stacks/options.go

@@ -0,0 +1,17 @@
+package stacks
+
+import "git.vezzani.net/ben/games/common/elements/v1"
+
+type OptFunc func(*Stack)
+
+func Core(f elements.OptFunc) OptFunc {
+	return func(s *Stack) {
+		f(&s.Core)
+	}
+}
+
+func Horizontal() OptFunc {
+	return func(s *Stack) {
+		s.horizontal = true
+	}
+}

common/elements/v1/stacks/stack.go

@@ -0,0 +1,61 @@
+package stacks
+
+import (
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+func New(ops ...OptFunc) elements.Element {
+	s := Stack{}
+	for op := range ops {
+		ops[op](&s)
+	}
+
+	var cw, ch int
+	anchor := s.Anchor()
+	for _, c := range s.Children() {
+		c.SetAnchor(anchor)
+		cw, ch = c.Size()
+		if s.horizontal {
+			anchor.X += cw
+		} else {
+			anchor.Y += ch
+		}
+	}
+
+	return &s
+}
+
+type Stack struct {
+	elements.Core
+	mouse.NopHandler
+	horizontal bool
+}
+
+func (s *Stack) Size() (w, h int) {
+	var cw, ch int
+	for _, c := range s.Children() {
+		cw, ch = c.Size()
+		if s.horizontal {
+			w += cw
+			if h < ch {
+				h = ch
+			}
+		} else {
+			h += ch
+			if w < cw {
+				w = cw
+			}
+		}
+	}
+
+	return
+}
+
+func (s *Stack) Draw(image *ebiten.Image) {
+	for _, c := range s.Children() {
+		c.Draw(image)
+	}
+}

common/elements/v1/table.go

@@ -1,100 +0,0 @@
-package elements
-
-import (
-	"context"
-	"fmt"
-
-	"github.com/hajimehoshi/ebiten/v2"
-)
-
-type Table struct {
-	mouseHandler
-	Block
-
-	ColumnCount int
-	RowCount    int
-
-	Cells []Element
-
-	Style struct {
-	}
-
-	mouseOverCell int
-}
-
-func (t *Table) HandleClick(ctx context.Context, s MouseState) error {
-	address := t.getAddressUnderMouse()
-	if address < 0 || address >= len(t.Cells) {
-		return fmt.Errorf("cell address under mouse is out of bounds")
-	}
-
-	if clickable, ok := t.Cells[address].(Clickable); ok {
-		return clickable.HandleClick(s)
-	}
-
-	return nil
-}
-
-func (t *Table) HandleMouseEnter(ctx context.Context, s MouseState) error {
-	_ = t.mouseHandler.HandleMouseEnter(s)
-	address := t.getAddressUnderMouse()
-	if address < 0 || address >= len(t.Cells) {
-		return fmt.Errorf("cell address under mouse is out of bounds")
-	}
-
-	if mouseable, ok := t.Cells[address].(Mouseable); ok {
-		s.X -=
-		return mouseable.HandleMouseEnter(s)
-	}
-
-	return nil
-}
-
-func (t *Table) HandleMouseLeave(ctx context.Context, s MouseState) error {
-	_ = t.mouseHandler.HandleMouseLeave(s)
-	return nil
-}
-
-func (t *Table) HandleMouseMove(ctx context.Context, s MouseState) error {
-	_ = t.mouseHandler.HandleMouseMove(s)
-	return nil
-}
-
-func (t *Table) HandleMouseDown(ctx context.Context, s MouseState) error {
-	_ = t.mouseHandler.HandleMouseDown(s)
-	return nil
-}
-
-func (t *Table) HandleMouseUp(ctx context.Context, s MouseState) error {
-	_ = t.mouseHandler.HandleMouseUp(s)
-	return nil
-}
-
-func (t *Table) CellSize(ctx context.Context) (w, h float32) {
-	w, h = GetContainerSize(ctx)
-	return w / float32(t.ColumnCount), h / float32(t.RowCount)
-}
-
-func (t *Table) CellZero(ctx context.Context, addr int) (x, y float32) {
-	x, y = GetZero(ctx)
-	w, h := t.CellSize(ctx)
-
-	col, row := addr%t.ColumnCount, addr/t.ColumnCount
-	return x + float32(col)*w, y + float32(row) + h
-}
-
-func (t *Table) Draw(ctx context.Context, screen *ebiten.Image) error {
-
-}
-
-func (t *Table) contextForCell(ctx context.Context, addr int) context.Context {
-	zx, zy := t.CellZero(ctx, addr)
-	w, h := t.CellSize(ctx)
-	ctx = SetZero(ctx, zx, zy)
-	ctx = SetContainerSize(ctx, w, h)
-	return ctx
-}
-
-func (t *Table) getAddressUnderMouse() int {
-	return int(t.mouseState.Y)*t.RowCount + int(t.mouseState.X)
-}

common/sprites/v1/sprite.go

@@ -3,7 +3,7 @@ package sprites
 import (
 	"image"
 
-	"git.vezzani.net/ben/games/common/window/v1"
+	"git.vezzani.net/ben/games/common/ux/v1"
 	"github.com/hajimehoshi/ebiten/v2"
 )
 
@@ -16,9 +16,9 @@ func Update() {
 }
 
 type animation struct {
-	RowNumber  uint8
-	FrameCount uint8
-	Scale      float32
+	RowNumber uint8
+	TickCount uint8
+	Scale     float32
 }
 
 type subImager interface {
@@ -31,7 +31,12 @@ type Sprite struct {
 	imgData       subImager
 	animations    map[string]animation
 
-	baseAnim *animation
+	baseAnim    *animation
+	currentAnim *animation
+
+	animationStartedAt int
+	animationStopAt    int
+	animateOnce        bool
 }
 
 func (s *Sprite) baseAnimation() animation {
@@ -50,22 +55,17 @@ func (s *Sprite) baseAnimation() animation {
 	return animation{}
 }
 
-func (s *Sprite) getAnimation(id string) animation {
-	if id == "" {
-		return s.baseAnimation()
+func (s *Sprite) getAnimation() animation {
+	if s.currentAnim != nil {
+		return *s.currentAnim
 	}
-
-	if anim, ok := s.animations[id]; ok {
-		return anim
-	}
-
 	return s.baseAnimation()
 }
 
 func (s *Sprite) Image(ops imageOptions) image.Image {
-	anim := s.getAnimation(ops.animation)
+	anim := s.getAnimation()
 
-	xOffset := updateCount % int(anim.FrameCount) * s.width
+	xOffset := updateCount % int(anim.TickCount) * s.width
 	yOffset := int(anim.RowNumber) * s.height
 
 	r := image.Rect(xOffset, yOffset, s.width, s.height).Intersect(s.imgData.Bounds())
@@ -74,9 +74,12 @@ func (s *Sprite) Image(ops imageOptions) image.Image {
 }
 
 func (s *Sprite) Draw(screen *ebiten.Image, options ...ImageOption) {
+	if s.getAnimation().RowNumber == 0 {
+	}
+
 	ops := imageOptions{
-		scaleX: window.Scale,
-		scaleY: window.Scale,
+		scaleX: ux.Scale,
+		scaleY: ux.Scale,
 	}
 
 	for _, o := range options {
@@ -98,11 +101,28 @@ func (s *Sprite) Draw(screen *ebiten.Image, options ...ImageOption) {
 	)
 }
 
+func (s *Sprite) StartAnimation(id string, once bool) {
+	if a, ok := s.animations[id]; ok {
+		s.currentAnim = &a
+	}
+	if once {
+		s.animateOnce = true
+		s.animationStopAt = updateCount + int(s.currentAnim.TickCount)
+	}
+	s.animationStartedAt = updateCount
+}
+
+func (s *Sprite) StopAnimation() {
+	s.currentAnim = nil
+	s.animationStartedAt = 0
+	s.animationStopAt = 0
+	s.animateOnce = false
+}
+
 type imageOptions struct {
 	x, y           float64
 	scaleX, scaleY float64
 	rotateTheta    float64
-	animation      string
 }
 
 type ImageOption func(options *imageOptions)
@@ -114,12 +134,6 @@ func ToScale(x, y float64) ImageOption {
 	}
 }
 
-func Animation(name string) ImageOption {
-	return func(o *imageOptions) {
-		o.animation = name
-	}
-}
-
 func AtPosition(x, y float64) ImageOption {
 	return func(o *imageOptions) {
 		o.x, o.y = x, y

common/ux/v1/ux.go

@@ -9,6 +9,7 @@ import (
 
 var (
 	FontFace        font.Face   = basicfont.Face7x13
+	FontColor       color.Color = color.Black
 	BackgroundColor color.Color = color.White
 	Scale           float64     = 1.0
 )

tools/component_test/editor.go

@@ -0,0 +1,83 @@
+package main
+
+import (
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/blocks"
+	"git.vezzani.net/ben/games/common/elements/v1/buttons"
+	"git.vezzani.net/ben/games/common/elements/v1/mouse"
+	"git.vezzani.net/ben/games/common/elements/v1/stacks"
+	"git.vezzani.net/ben/games/common/sprites/v1"
+
+	"github.com/hajimehoshi/ebiten/v2"
+	"golang.org/x/image/colornames"
+)
+
+var root = stacks.New(
+	stacks.Horizontal(),
+	//stacks.Core(blocks.BackgroundColor(color.White)),
+	stacks.Core(elements.Name("parent")),
+	stacks.Core(elements.Children(
+		stacks.New(
+			stacks.Core(elements.Name("left")),
+			stacks.Core(elements.Children(
+				buttons.New(
+					buttons.BlockOpt(blocks.Size(100, 100)),
+					buttons.Label("hello"),
+					buttons.BlockOpt(blocks.BackgroundColor(colornames.Green)),
+					buttons.OnClick(func(ms mouse.State) {
+						println("green")
+					}),
+				),
+				blocks.New(
+					blocks.Size(100, 100),
+					blocks.BackgroundColor(colornames.Yellow),
+				),
+			)),
+		),
+		stacks.New(
+			stacks.Core(elements.Name("right")),
+			stacks.Core(elements.Children(
+				blocks.New(
+					blocks.Size(100, 100),
+					blocks.BackgroundColor(colornames.Blue),
+				),
+				blocks.New(
+					blocks.Size(100, 100),
+					blocks.BackgroundColor(colornames.Red),
+				),
+			)),
+		),
+	)),
+)
+
+func newEditor() *editor {
+	return &editor{}
+}
+
+type editor struct {
+	bounds      elements.Bounds
+	handleMouse func() bool
+}
+
+func (e *editor) Update() error {
+	sprites.Update()
+	e.handleMouse()
+	return nil
+}
+
+func (e *editor) Draw(screen *ebiten.Image) {
+	root.Draw(screen)
+}
+
+func (e *editor) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
+	if e.bounds.Width != outsideWidth || e.bounds.Height != outsideHeight {
+		e.bounds = elements.Bounds{
+			Min:    elements.Point{},
+			Width:  outsideWidth,
+			Height: outsideHeight,
+		}
+		e.handleMouse = mouse.Handler(root)
+	}
+
+	return outsideWidth, outsideHeight
+}

tools/component_test/main.go

@@ -0,0 +1,15 @@
+package main
+
+import (
+	"github.com/hajimehoshi/ebiten/v2"
+)
+
+func main() {
+	ebiten.SetWindowSize(480, 320)
+	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
+	ebiten.SetWindowTitle("Component/Layout Test")
+	e := newEditor()
+	if err := ebiten.RunGame(e); err != nil {
+		panic(err)
+	}
+}

tools/spritedit/editor.go

@@ -0,0 +1,48 @@
+package main
+
+import (
+	"image/color"
+
+	"git.vezzani.net/ben/games/common/elements/v1"
+	"git.vezzani.net/ben/games/common/elements/v1/blocks"
+	"git.vezzani.net/ben/games/common/elements/v1/stacks"
+	"git.vezzani.net/ben/games/common/sprites/v1"
+	"github.com/hajimehoshi/ebiten/v2"
+	"golang.org/x/image/colornames"
+)
+
+var menu = stacks.New(
+	stacks.BlockOpt(blocks.BackgroundColor(color.White)),
+	stacks.BlockOpt(blocks.Size(100, 200)),
+	stacks.Children(
+		blocks.New(blocks.BackgroundColor(colornames.Green)),
+		blocks.New(),
+	),
+)
+
+func newEditor() *editor {
+	return &editor{}
+}
+
+type editor struct {
+}
+
+func (e *editor) Update() error {
+	sprites.Update()
+
+	return nil
+}
+
+func (e *editor) Draw(screen *ebiten.Image) {
+	b := screen.Bounds()
+	menu(elements.Bounds{
+		ZX: float64(b.Min.X),
+		ZY: float64(b.Min.Y),
+		WX: float64(b.Max.X),
+		WY: float64(b.Max.Y),
+	}).Draw(screen)
+}
+
+func (e *editor) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
+	return outsideWidth, outsideHeight
+}

tools/spritedit/main.go

@@ -1,90 +1,15 @@
 package main
 
 import (
-	"bytes"
-
-	"github.com/ebitenui/ebitenui"
-	"github.com/ebitenui/ebitenui/image"
-	"github.com/ebitenui/ebitenui/widget"
 	"github.com/hajimehoshi/ebiten/v2"
-	"github.com/hajimehoshi/ebiten/v2/text/v2"
-	"golang.org/x/image/colornames"
-	"golang.org/x/image/font/gofont/goregular"
 )
 
-type Editor struct {
-	ui *ebitenui.UI
-}
-
-func NewEditor() *Editor {
-	root := widget.NewContainer(
-		widget.ContainerOpts.BackgroundImage(
-			image.NewNineSliceColor(colornames.Gainsboro),
-		))
-	root.AddChild(
-		widget.NewButton(
-			widget.ButtonOpts.TextLabel("Open Sprite Sheet..."),
-			widget.ButtonOpts.TextFace(DefaultFont()),
-			widget.ButtonOpts.TextColor(&widget.ButtonTextColor{
-				Idle:    colornames.Gainsboro,
-				Hover:   colornames.Gainsboro,
-				Pressed: colornames.Gainsboro,
-			}),
-			widget.ButtonOpts.Image(&widget.ButtonImage{
-				Idle:         DefaultNineSlice(colornames.Darkslategray),
-				Hover:        DefaultNineSlice(Mix(colornames.Darkslategray, colornames.Mediumseagreen, 0.4)),
-				Disabled:     DefaultNineSlice(Mix(colornames.Darkslategray, colornames.Gainsboro, 0.8)),
-				Pressed:      PressedNineSlice(Mix(colornames.Darkslategray, colornames.Black, 0.4)),
-				PressedHover: PressedNineSlice(Mix(colornames.Darkslategray, colornames.Black, 0.4)),
-			}),
-			widget.ButtonOpts.WidgetOpts(
-				widget.WidgetOpts.LayoutData(widget.AnchorLayoutData{
-					VerticalPosition:   widget.AnchorLayoutPositionCenter,
-					HorizontalPosition: widget.AnchorLayoutPositionCenter,
-				}),
-				widget.WidgetOpts.MinSize(180, 48),
-			),
-		),
-	)
-
-	return &Editor{
-		ui: &ebitenui.UI{Container: root},
-	}
-}
-
-func (e *Editor) Update() error {
-	e.ui.Update()
-	return nil
-}
-
-func (e *Editor) Draw(screen *ebiten.Image) {
-	e.ui.Draw(screen)
-}
-
-func (e *Editor) Layout(w, h int) (int, int) {
-	return w, h
-}
-
-func DefaultFont() *text.Face {
-	s, err := text.NewGoTextFaceSource(bytes.NewReader(goregular.TTF))
-	if err != nil {
-		panic(err)
-	}
-
-	var f text.Face
-
-	f = &text.GoTextFace{
-		Source: s,
-		Size:   20,
-	}
-
-	return &f
-}
-
 func main() {
 	ebiten.SetWindowSize(480, 320)
 	ebiten.SetWindowResizingMode(ebiten.WindowResizingModeEnabled)
-	if err := ebiten.RunGame(NewEditor()); err != nil {
+	ebiten.SetWindowTitle("Sprite Editor")
+	e := newEditor()
+	if err := ebiten.RunGame(e); err != nil {
 		panic(err)
 	}
 }