Support padding & margin, routing. (#70)

* Support padding & margin. Integrate router.

* Add old sign in background

* Adjust sign in style

Author: magicoder10

assets.sketch

@@ -53,16 +53,16 @@ func (e *EbitenWindow) Update() error {
 	return nil
 }
 
-func (e EbitenWindow) Draw(screen *ebiten.Image) {
+func (e *EbitenWindow) Draw(screen *ebiten.Image) {
 	e.sp.Draw()
 	e.ebiten.Render(screen)
 }
 
-func (e EbitenWindow) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
+func (e *EbitenWindow) Layout(outsideWidth, outsideHeight int) (screenWidth, screenHeight int) {
 	return e.windowConfig.Width, e.windowConfig.Height
 }
 
-func (e EbitenWindow) pollEvents() []input.Input {
+func (e *EbitenWindow) pollEvents() []input.Input {
 	inputs := make([]input.Input, 0)
 	if ebiten.IsKeyPressed(ebiten.KeyLeft) {
 		inputs = append(inputs, input.Input{
@@ -141,13 +141,13 @@ func (e EbitenWindow) pollEvents() []input.Input {
 	return inputs
 }
 
-func NewEbitenWindow(windowConfig WindowConfig, sp Sprite, framesPerSeconds int, ebiten *Ebiten) EbitenWindow {
+func NewEbitenWindow(windowConfig WindowConfig, sp Sprite, framesPerSeconds int, eb *Ebiten) *EbitenWindow {
 	nanoPerUpdate := time.Second.Nanoseconds() / int64(framesPerSeconds)
-	return EbitenWindow{
+	return &EbitenWindow{
 		sp:            sp,
 		nanoPerUpdate: nanoPerUpdate,
 		updateTime:    time.Duration(nanoPerUpdate),
 		windowConfig:  windowConfig,
-		ebiten:        ebiten,
+		ebiten:        eb,
 	}
 }

graphics/window.go

@@ -66,7 +66,7 @@ func main() {
 	}, app, 24, &eb)
 	g.Init()
 
-	if err := ebiten.RunGame(&g); err != nil {
+	if err := ebiten.RunGame(g); err != nil {
 		log.Fatal(err)
 	}
 }

main.go

@@ -0,0 +1,135 @@
+package view
+
+import (
+	"fmt"
+	"strings"
+
+	"candy/observability"
+	"candy/view"
+)
+
+type Route struct {
+	Path          string
+	CreateFactory view.CreateFactory
+}
+
+type trieNode struct {
+	endOfPath bool
+	route     *Route
+	children  map[rune]*trieNode
+}
+
+type Router struct {
+	logger   *observability.Logger
+	root     *trieNode
+	currView view.View
+}
+
+func (r *Router) AddRoute(route Route) error {
+	if !isPathValid(route.Path) {
+		return fmt.Errorf("path is invalid: %s", route.Path)
+	}
+
+	path := preparePath(route.Path)
+	root := r.root
+	for index, currRune := range path {
+		if child, ok := root.children[currRune]; ok {
+			root = child
+		} else {
+			child := newTrieNode()
+			root.children[currRune] = child
+			root = child
+		}
+
+		if index < len(path)-1 {
+			continue
+		} else if root.endOfPath {
+			return fmt.Errorf("path already exists: %s", route.Path)
+		} else {
+			root.endOfPath = true
+			root.route = &route
+		}
+	}
+	return nil
+}
+
+func (r *Router) AddRoutes(routes []Route) error {
+	for _, rt := range routes {
+		err := r.AddRoute(rt)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (r Router) CurrentView() view.View {
+	return r.currView
+}
+
+func (r *Router) Navigate(path string, props interface{}) error {
+	rt, err := r.matchRoute(path)
+	if err != nil {
+		return err
+	}
+	if r.currView != nil {
+		r.currView.Destroy()
+	}
+
+	r.currView = rt.CreateFactory(props)
+	r.currView.Init()
+	r.logger.Infof("Navigate to %s\n", path)
+	return nil
+}
+
+func (r Router) matchRoute(path string) (*Route, error) {
+	if !isPathValid(path) {
+		return nil, fmt.Errorf("path is invalid: %s", path)
+	}
+
+	path = preparePath(path)
+	root := r.root
+	for index, currRune := range path {
+		child, ok := root.children[currRune]
+		if !ok {
+			break
+		}
+		root = child
+		if index == len(path)-1 && root.endOfPath {
+			return root.route, nil
+		}
+	}
+	return nil, fmt.Errorf("path not found: %s", path)
+}
+
+func preparePath(path string) string {
+	for len(path) > 1 && path[len(path)-1] == '/' {
+		path = path[:len(path)-1]
+	}
+	return path
+}
+
+var blockedRunes = map[rune]struct{}{}
+
+func isPathValid(path string) bool {
+	if !strings.HasPrefix(path, "/") {
+		return false
+	}
+	for _, currRune := range path {
+		if _, ok := blockedRunes[currRune]; ok {
+			return false
+		}
+	}
+	return true
+}
+
+func NewRouter(logger *observability.Logger) *Router {
+	return &Router{
+		logger: logger,
+		root:   newTrieNode(),
+	}
+}
+
+func newTrieNode() *trieNode {
+	return &trieNode{children: make(map[rune]*trieNode)}
+}

public/test/signin.png

@@ -0,0 +1,61 @@
+package view
+
+import (
+	"testing"
+
+	"candy/observability"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestRouter_AddRoute(t *testing.T) {
+	testCases := []struct {
+		name      string
+		newRoutes []Route
+		hasErr    bool
+	}{
+		{
+			name:      "path is empty",
+			newRoutes: []Route{{Path: ""}},
+			hasErr:    true,
+		},
+		{
+			name:      "path must start with /",
+			newRoutes: []Route{{Path: "path"}},
+			hasErr:    true,
+		},
+		{
+			name:      "path is valid",
+			newRoutes: []Route{{Path: "/first/second"}},
+			hasErr:    false,
+		},
+		{
+			name:      "path already exists",
+			newRoutes: []Route{{Path: "/first/second"}, {Path: "/first/second/"}},
+			hasErr:    true,
+		},
+	}
+
+	for _, testCase := range testCases {
+		t.Run(testCase.name, func(t *testing.T) {
+			logger := observability.NewLogger(observability.Info)
+			router := NewRouter(&logger)
+
+			var err error
+
+			for _, newRoute := range testCase.newRoutes {
+				err = router.AddRoute(newRoute)
+				if err != nil {
+					break
+				}
+			}
+
+			if testCase.hasErr {
+				assert.NotNil(t, err)
+				return
+			} else {
+				assert.Nil(t, err)
+			}
+		})
+	}
+}

router/router.go

@@ -0,0 +1,54 @@
+package ui
+
+type AlignHorizontal int
+
+func (a AlignHorizontal) Ptr() *AlignHorizontal {
+	return &a
+}
+
+const (
+	AlignLeft AlignHorizontal = iota
+	AlignHorizontalCenter
+	AlignRight
+)
+
+type AlignVertical int
+
+const (
+	AlignTop AlignVertical = iota
+	AlignVerticalCenter
+	AlignBottom
+)
+
+type Alignment struct {
+	Horizontal *AlignHorizontal
+	Vertical   *AlignVertical
+}
+
+func (a Alignment) getHorizontal() AlignHorizontal {
+	if a.Horizontal == nil {
+		return AlignLeft
+	}
+	return *a.Horizontal
+}
+
+func (a Alignment) getVertical() AlignVertical {
+	if a.Vertical == nil {
+		return AlignTop
+	}
+	return *a.Vertical
+}
+
+func (a Alignment) AlignHorizontal(parent Component, child Component) int {
+	padding := parent.getStyle().GetPadding()
+	margin := child.getStyle().GetMargin()
+	switch a.getHorizontal() {
+	case AlignLeft:
+		return margin.GetLeft() + padding.GetLeft()
+	case AlignRight:
+		return parent.getSize().width - padding.GetRight() - margin.GetRight() - child.getSize().width
+	case AlignHorizontalCenter:
+		return (parent.getSize().width - child.getSize().width) / 2
+	}
+	return margin.GetLeft() + padding.GetLeft()
+}

router/router_test.go

@@ -18,8 +18,15 @@ type Background struct {
 	hasChanged bool
 }
 
-func (b Background) Paint(painter *Painter, destLayer draw.Image) {
-	if b.ImagePath != nil {
+func (b Background) Paint(painter *Painter, size Size, destLayer draw.Image) {
+	if b.image != nil {
+		rect := image.Rectangle{
+			Max: image.Point{
+				X: size.width,
+				Y: size.height,
+			},
+		}
+		painter.drawImage(b.image, rect, destLayer, image.Point{})
 		return
 	}
 	if b.Color != nil {

ui/alignment.go

@@ -1,8 +1,6 @@
 package ui
 
 import (
-	"image"
-	"image/draw"
 	"sort"
 
 	"candy/ui/ptr"
@@ -22,52 +20,17 @@ func (b Box) GetName() string {
 	return "Box"
 }
 
-func (b Box) Paint(painter *Painter, destLayer draw.Image, offset Offset) {
-	if !b.hasChanged {
-		return
-	}
-
-	contentLayer := image.NewRGBA(image.Rectangle{
-		Max: image.Point{
-			X: b.size.width,
-			Y: b.size.height,
-		},
-	})
-	if b.style.Background != nil {
-		b.style.Background.Paint(painter, contentLayer)
-	}
-
-	sortedChildren := Children{
-		children:       b.children,
-		childrenOffset: b.childrenOffset,
-	}
-	sort.Sort(&sortedChildren)
-
-	for index, child := range sortedChildren.children {
-		childOffset := sortedChildren.childrenOffset[index]
-		child.Paint(painter, contentLayer, childOffset)
-	}
-
-	painter.drawImage(contentLayer, image.Rectangle{
-		Min: image.Point{},
-		Max: contentLayer.Bounds().Max,
-	}, destLayer, image.Point{
-		X: offset.x,
-		Y: offset.y,
-	})
-}
-
 func (b Box) ComputeLeafSize(_ Constraints) Size {
-	padding := b.style.GetPadding()
+	padding := b.Style.GetPadding()
 
 	width := 0
-	if b.style.Width != nil {
-		width = *b.style.Width
+	if b.Style.Width != nil {
+		width = *b.Style.Width
 	}
 	width += padding.GetLeft() + padding.GetRight()
 	height := 0
-	if b.style.Height != nil {
-		height = *b.style.Height
+	if b.Style.Height != nil {
+		height = *b.Style.Height
 	}
 	height += padding.GetTop() + padding.GetBottom()
 	return Size{width: width, height: height}
@@ -90,10 +53,10 @@ func NewBox(pros *BoxProps, children []Component, style *Style) *Box {
 	}
 	return &Box{
 		SharedComponent: SharedComponent{
-			name:           "Box",
-			layout:         newLayout(*style.LayoutType),
-			style:          style,
-			children:       children,
+			Name:           "Box",
+			Layout:         NewLayout(*style.LayoutType),
+			Style:          style,
+			Children:       children,
 			childrenOffset: []Offset{},
 			events:         Events{onClick: pros.OnClick},
 		}}