Delete old code

internal/layout/fill.go

···
-package layout
-
-import "image"
-
-type FillColor string
-
-const (
-	FillColorWhite FillColor = "white"
-	FillColorBlack FillColor = "black"
-	FillColorGray  FillColor = "gray"
-)
-
-const defaultFillColor = FillColorWhite
-
-type FillNode struct {
-	color FillColor
-	rect  image.Rectangle
-	style NodeStyle
-}
-
-func parseFillNode(n *rawNode, rect image.Rectangle) *FillNode {
-	fn := &FillNode{
-		color: defaultFillColor,
-		rect:  rect,
-		style: n.Style,
-	}
-
-	if col, ok := n.Attrs["color"]; ok {
-		if c, ok := col.(string); ok {
-			switch c {
-			case "white":
-				fn.color = FillColorWhite
-			case "black":
-				fn.color = FillColorBlack
-			case "gray":
-				fn.color = FillColorGray
-			}
-		}
-	}
-
-	return fn
-}
-
-func (n *FillNode) Type() NodeType {
-	return NodeTypeFill
-}
-
-func (n *FillNode) Rect() image.Rectangle {
-	return n.rect
-}
-
-func (n *FillNode) Style() NodeStyle {
-	return n.style
-}
-
-func (n *FillNode) Color() FillColor {
-	return n.color
-}
-
-func (n *FillNode) SetRect(rect image.Rectangle) {
-	n.rect = rect
-}
-
-func (n *FillNode) GetNode() Node {
-	return n
-}

internal/layout/flex.go

···
-package layout
-
-import (
-	"image"
-
-	"github.com/go-viper/mapstructure/v2"
-)
-
-type FlexDirection string
-
-const (
-	FlexDirectionVertical   FlexDirection = "vertical"
-	FlexDirectionHorizontal FlexDirection = "horizontal"
-)
-
-const defaultFlexDirection = FlexDirectionHorizontal
-
-type FlexSeparator string
-
-const (
-	FlexSeparatorNone   FlexSeparator = "none"
-	FlexSeparatorSolid  FlexSeparator = "solid"
-	FlexSeparatorDashed FlexSeparator = "dashed"
-)
-
-const defaultFlexSeparator = FlexSeparatorNone
-
-const defaultPadding = 0
-
-type childNode interface {
-	Node
-	GetNode() Node
-	SetRect(image.Rectangle)
-}
-
-type FlexStyle struct {
-	Direction FlexDirection
-	Separator FlexSeparator
-}
-
-type FlexNode struct {
-	flexStyle FlexStyle
-	rect      image.Rectangle
-	children  []childNode
-	style     NodeStyle
-}
-
-func parseFlexNode(n *rawNode, rect image.Rectangle) *FlexNode {
-	fn := &FlexNode{
-		flexStyle: FlexStyle{
-			Direction: defaultFlexDirection,
-			Separator: defaultFlexSeparator,
-		},
-		rect:  rect,
-		style: n.Style,
-	}
-
-	// Parse separator
-	if sep, ok := n.Attrs["separator"]; ok {
-		if s, ok := sep.(string); ok {
-			switch s {
-			case "none":
-				fn.flexStyle.Separator = FlexSeparatorNone
-			case "solid":
-				fn.flexStyle.Separator = FlexSeparatorSolid
-			case "dashed":
-				fn.flexStyle.Separator = FlexSeparatorDashed
-			}
-		}
-	}
-
-	// Parse direction
-	if dir, ok := n.Attrs["direction"]; ok {
-		if d, ok := dir.(string); ok {
-			switch d {
-			case "vertical":
-				fn.flexStyle.Direction = FlexDirectionVertical
-			case "horizontal":
-				fn.flexStyle.Direction = FlexDirectionHorizontal
-			}
-		}
-	}
-
-	return fn
-}
-
-func (n *FlexNode) Type() NodeType {
-	return NodeTypeFlex
-}
-
-func (n *FlexNode) Rect() image.Rectangle {
-	return n.rect
-}
-
-func (n *FlexNode) Style() NodeStyle {
-	return n.style
-}
-
-func (n *FlexNode) SetRect(rect image.Rectangle) {
-	n.rect = rect
-}
-
-func (n *FlexNode) GetNode() Node {
-	return n
-}
-
-func (n *FlexNode) FlexStyle() FlexStyle {
-	return n.flexStyle
-}
-
-func (n *FlexNode) Children() []Node {
-	ret := []Node{}
-	for _, c := range n.children {
-		ret = append(ret, c.GetNode())
-	}
-	return ret
-}
-
-type flexCalculation struct {
-	static   int
-	weighted int
-}
-
-func calculateChildrenWeights(dir FlexDirection, n *rawNode) (*flexCalculation, error) {
-	if len(n.Children) < 1 {
-		return nil, ErrNoChildren
-	}
-
-	calc := &flexCalculation{0, 0}
-	for _, child := range n.Children {
-		style := NodeStyle{
-			Weight: 1,
-		}
-		if st, ok := child["style"]; ok {
-			if s, ok := st.(map[string]any); ok {
-				if err := mapstructure.Decode(s, calc); err != nil {
-					return nil, err
-				}
-			}
-		}
-
-		if dir == FlexDirectionHorizontal && style.Width > 0 {
-			calc.static += style.Width
-		} else if dir == FlexDirectionVertical && style.Height > 0 {
-			calc.static += style.Height
-		} else {
-			calc.weighted += style.Weight
-		}
-	}
-
-	return calc, nil
-}

internal/layout/layout.go

···
-package layout
-
-import (
-	"errors"
-	"image"
-
-	"github.com/dop251/goja"
-	"github.com/go-viper/mapstructure/v2"
-)
-
-type NodeType string
-
-const (
-	NodeTypeFlex NodeType = "flex"
-	NodeTypeText NodeType = "text"
-	NodeTypeFill NodeType = "fill"
-)
-
-var (
-	ErrUnknownNodeType   = errors.New("unknown node type")
-	ErrModuleWithoutFunc = errors.New("module node without function")
-	ErrNoChildren        = errors.New("no children")
-)
-
-type Node interface {
-	Type() NodeType
-	Rect() image.Rectangle
-	Style() NodeStyle
-}
-
-type NodeStyle struct {
-	Weight       int
-	Margin       int
-	Padding      int
-	Height       int
-	Width        int
-	CornerRadius int
-}
-
-type weightedNode struct {
-	Node   map[string]any
-	Weight float32
-}
-
-type rawNode struct {
-	NodeName string
-	Style    NodeStyle
-	Attrs    map[string]any
-	Children []map[string]any
-}
-
-type rawModule struct {
-	Module  goja.Callable
-	Weight  int64
-	Padding int64
-	Attrs   map[string]any
-}
-
-func CalculateLayout(root map[string]any, rect image.Rectangle, rt *goja.Runtime) (Node, error) {
-	node, err := calculateLayout(root, rect, rt)
-	if err != nil {
-		return nil, err
-	}
-
-	return node.GetNode(), nil
-}
-
-func calculateLayout(root map[string]any, rect image.Rectangle, rt *goja.Runtime) (childNode, error) {
-	t, ok := root["type"]
-	if !ok {
-		return nil, ErrUnknownNodeType
-	}
-
-	switch t {
-	case "node":
-		// Parse raw node data
-		n := &rawNode{}
-		if err := mapstructure.Decode(&root, n); err != nil {
-			return nil, err
-		}
-
-		return calculateNode(n, rect, rt)
-
-	case "module":
-		// Make sure module has a function to call
-		mod, ok := root["module"]
-		if !ok {
-			return nil, ErrModuleWithoutFunc
-		}
-
-		fn, ok := goja.AssertFunction(rt.ToValue(mod))
-		if !ok {
-			return nil, ErrModuleWithoutFunc
-		}
-
-		weight := int64(1)
-		if w, ok := root["weight"]; ok {
-			weight = w.(int64)
-		}
-
-		padding := int64(defaultPadding)
-		if p, ok := root["padding"]; ok {
-			padding = p.(int64)
-		}
-
-		attrs := map[string]any{}
-		if a, ok := root["attrs"]; ok {
-			if err := rt.ExportTo(rt.ToValue(a), &attrs); err != nil {
-				return nil, err
-			}
-		}
-
-		return calculateModule(&rawModule{
-			Module:  fn,
-			Weight:  weight,
-			Padding: padding,
-			Attrs:   attrs,
-		}, rect, rt)
-	default:
-		return nil, ErrUnknownNodeType
-	}
-}
-
-func calculateNode(n *rawNode, rect image.Rectangle, rt *goja.Runtime) (childNode, error) {
-	switch NodeType(n.NodeName) {
-	case NodeTypeFlex:
-		return calculateFlex(n, rect, rt)
-	case NodeTypeFill:
-		return parseFillNode(n, rect), nil
-	case NodeTypeText:
-		return parseTextNode(n, rect), nil
-	default:
-		return nil, ErrUnknownNodeType
-	}
-}
-
-func calculateFlex(n *rawNode, rect image.Rectangle, rt *goja.Runtime) (childNode, error) {
-	node := parseFlexNode(n, rect)
-
-	// Calculate padded rect
-	pRect := image.Rect(
-		rect.Min.X+node.style.Padding,
-		rect.Min.Y+node.style.Padding,
-		rect.Max.X-node.style.Padding,
-		rect.Max.Y-node.style.Padding,
-	)
-	width := pRect.Max.X - pRect.Min.X
-	height := pRect.Max.Y - pRect.Min.Y
-
-	if calc, err := calculateChildrenWeights(node.flexStyle.Direction, n); err == nil {
-		weighted := []weightedNode{}
-
-		for _, child := range n.Children {
-			style := NodeStyle{
-				Weight: 1,
-			}
-			if st, ok := child["style"]; ok {
-				if s, ok := st.(map[string]any); ok {
-					if err := mapstructure.Decode(s, calc); err != nil {
-						return nil, err
-					}
-				}
-			}
-		}
-	}
-
-	if sum, err := sumChildrenWeight(n); err == nil {
-		weighted := []weightedNode{}
-
-		for _, child := range n.Children {
-			weight := int64(1)
-			if w, ok := child["weight"]; ok {
-				weight = w.(int64)
-			}
-
-			w := float32(weight) / float32(sum)
-			weighted = append(weighted, weightedNode{child, w})
-		}
-
-		if node.Direction == FlexDirectionVertical {
-			pos := pRect.Min.Y
-			for _, child := range weighted {
-				r := image.Rect(
-					pRect.Min.X,
-					pos,
-					pRect.Max.X,
-					pos+int(float32(height)*child.Weight),
-				)
-				pos = r.Max.Y
-
-				c, err := calculateLayout(child.Node, r, rt)
-				if err != nil {
-					return nil, err
-				}
-
-				node.Children = append(node.Children, c)
-			}
-		} else if node.Direction == FlexDirectionHorizontal {
-			pos := pRect.Min.X
-			for _, child := range weighted {
-				r := image.Rect(
-					pos,
-					pRect.Min.Y,
-					pos+int(float32(width)*child.Weight),
-					pRect.Max.Y,
-				)
-				pos = r.Max.X
-
-				c, err := calculateLayout(child.Node, r, rt)
-				if err != nil {
-					return nil, err
-				}
-
-				node.Children = append(node.Children, c)
-			}
-		}
-	}
-
-	return node, nil
-}
-
-func sumChildrenWeight(n *rawNode) (int64, error) {
-	if len(n.Children) < 1 {
-		return 0, ErrNoChildren
-	}
-
-	sum := int64(0)
-	for _, child := range n.Children {
-		weight := int64(1)
-		if w, ok := child["weight"]; ok {
-			weight = w.(int64)
-		}
-
-		sum += weight
-	}
-
-	return sum, nil
-}
-
-func calculateModule(m *rawModule, rect image.Rectangle, rt *goja.Runtime) (childNode, error) {
-	props := map[string]any{
-		"width":  rect.Max.X - rect.Min.X,
-		"height": rect.Max.Y - rect.Min.Y,
-	}
-
-	for k, v := range m.Attrs {
-		// Make sure size can't be overwritten
-		if k != "height" && k != "width" {
-			props[k] = v
-		}
-	}
-
-	ret, err := m.Module(goja.Undefined(), rt.ToValue(props))
-	if err != nil {
-		return nil, err
-	}
-
-	root := map[string]any{}
-	if err := rt.ExportTo(ret, &root); err != nil {
-		return nil, err
-	}
-
-	// Set weight
-	root["weight"] = m.Weight
-	root["padding"] = m.Padding
-
-	return calculateLayout(root, rect, rt)
-}

internal/layout/text.go

···
-package layout
-
-import "image"
-
-const defaultFontSize = 32
-
-type TextNode struct {
-	content string
-	size    int
-	rect    image.Rectangle
-	style   NodeStyle
-}
-
-func parseTextNode(n *rawNode, rect image.Rectangle) *TextNode {
-	tn := &TextNode{
-		size:  defaultFontSize,
-		rect:  rect,
-		style: n.Style,
-	}
-
-	if con, ok := n.Attrs["content"]; ok {
-		if c, ok := con.(string); ok {
-			tn.content = c
-		}
-	}
-
-	if sz, ok := n.Attrs["size"]; ok {
-		if s, ok := sz.(int64); ok {
-			tn.size = int(s)
-		}
-	}
-
-	return tn
-}
-
-func (n *TextNode) Type() NodeType {
-	return NodeTypeText
-}
-
-func (n *TextNode) Rect() image.Rectangle {
-	return n.rect
-}
-
-func (n *TextNode) Style() NodeStyle {
-	return n.style
-}
-
-func (n *TextNode) Content() string {
-	return n.content
-}
-
-func (n *TextNode) Size() int {
-	return n.size
-}
-
-func (n *TextNode) SetRect(rect image.Rectangle) {
-	n.rect = rect
-}
-
-func (n *TextNode) GetNode() Node {
-	return n
-}

internal/module/pregnancy/pregnancy.go

···
-package pregnancy
-
-import (
-	"time"
-
-	"github.com/arnarg/scrn/internal/module"
-	"github.com/golang/freetype/truetype"
-	"github.com/llgcode/draw2d"
-	"github.com/llgcode/draw2d/draw2dimg"
-)
-
-type pregnancyModule struct {
-	tr   *tracker
-	font *truetype.Font
-}
-
-func NewPregnancyModule(due time.Time) module.Module {
-	return &pregnancyModule{
-		tr: newTracker(due),
-		font: draw2d.GetFont(draw2d.FontData{
-			Name:   "inconsolata",
-			Family: draw2d.FontFamilySans,
-			Style:  draw2d.FontStyleNormal,
-		}),
-	}
-}
-
-func (m *pregnancyModule) Draw(ctx *draw2dimg.GraphicContext) error {
-
-	// ctx.SetFont(m.font)
-	// ctx.SetFontSize(14)
-
-	// ctx.StrokeStringAt("Week", 20, 20)
-
-	// minX := float64(img.Bounds().Min.X)
-	// minY := float64(img.Bounds().Min.Y)
-
-	// ctx.SetFillColor(color.Black)
-	// ctx.SetStrokeColor(color.Black)
-	// ctx.SetLineWidth(5)
-
-	// ctx.MoveTo(10, 10)
-	// ctx.LineTo(100, 10)
-
-	// ctx.FillStroke()
-
-	return nil
-}

internal/module/pregnancy/util.go

···
-package pregnancy
-
-import (
-	"math"
-	"time"
-)
-
-const (
-	week = time.Hour * 24 * 7
-)
-
-type progress struct {
-	w int
-	d int
-}
-
-type tracker struct {
-	due   time.Time
-	start time.Time
-}
-
-func newTracker(due time.Time) *tracker {
-	s := due.Add(week * -40)
-
-	return &tracker{
-		due:   due,
-		start: s,
-	}
-}
-
-func (t *tracker) progressAt(d time.Time) progress {
-	days := t.daysAt(d)
-
-	return progress{
-		w: days / 7,
-		d: days % 7,
-	}
-}
-
-func (t *tracker) progress() progress {
-	return t.progressAt(time.Now())
-}
-
-func (t *tracker) daysAt(d time.Time) int {
-	// Calculate number of days since start date
-	return int(d.Sub(t.start).Hours() / 24)
-}
-
-func (t *tracker) days() int {
-	return t.daysAt(time.Now())
-}
-
-func (t *tracker) percentageAt(d time.Time) float64 {
-	total := t.due.Sub(t.start).Hours()
-	current := d.Sub(t.start).Hours()
-
-	return math.Round((current/total)*100) / 100
-}
-
-func (t *tracker) percentage() float64 {
-	return t.percentageAt(time.Now())
-}

internal/module/pregnancy/util_test.go

···
-package pregnancy
-
-import (
-	"testing"
-	"time"
-)
-
-func TestTrackerProgressAt(t *testing.T) {
-	due, err := time.Parse(time.DateOnly, "2025-05-12")
-	if err != nil {
-		t.Fatalf("parsing time somehow failed: %s", err)
-	}
-
-	tracker := newTracker(due)
-
-	now, err := time.Parse(time.DateOnly, "2025-01-01")
-	if err != nil {
-		t.Fatalf("parsing time somehow failed: %s", err)
-	}
-
-	progress := tracker.progressAt(now)
-
-	if progress.w != 21 {
-		t.Errorf("week progress is not 21, got %d", progress.w)
-	}
-
-	if progress.d != 2 {
-		t.Errorf("day progress is not 2, got %d", progress.d)
-	}
-}
-
-func TestTrackerDaysAt(t *testing.T) {
-	due, err := time.Parse(time.DateOnly, "2025-05-12")
-	if err != nil {
-		t.Fatalf("parsing time somehow failed: %s", err)
-	}
-
-	tracker := newTracker(due)
-
-	now, err := time.Parse(time.DateOnly, "2025-01-01")
-	if err != nil {
-		t.Fatalf("parsing time somehow failed: %s", err)
-	}
-
-	days := tracker.daysAt(now)
-
-	if days != 149 {
-		t.Errorf("number of days since start is not 149, got %d", days)
-	}
-}
-
-func TestTrackerPercentageAt(t *testing.T) {
-	due, err := time.Parse(time.DateOnly, "2025-05-12")
-	if err != nil {
-		t.Fatalf("parsing time somehow failed: %s", err)
-	}
-
-	tracker := newTracker(due)
-
-	now, err := time.Parse(time.DateOnly, "2025-01-01")
-	if err != nil {
-		t.Fatalf("parsing time somehow failed: %s", err)
-	}
-
-	percentage := tracker.percentageAt(now)
-
-	if percentage != 0.53 {
-		t.Errorf("calculated percentage is not 0.53, got %f", percentage)
-	}
-}

internal/module/weather/weather.go

···
-package weather
-
-import (
-	"github.com/arnarg/scrn/internal/module"
-	"github.com/llgcode/draw2d/draw2dimg"
-)
-
-type weatherModule struct {
-}
-
-func NewWeatherModule() module.Module {
-	return &weatherModule{}
-}
-
-func (m *weatherModule) Draw(ctx *draw2dimg.GraphicContext) error {
-	return nil
-}

internal/util/painter.go

···
-package util
-
-import (
-	"image"
-	"image/color"
-
-	"github.com/golang/freetype/raster"
-	"github.com/llgcode/draw2d/draw2dimg"
-)
-
-type palettedPainter struct {
-	image *image.Paletted
-	color color.Color
-}
-
-func NewPalettedPainter(img *image.Paletted) draw2dimg.Painter {
-	return &palettedPainter{
-		image: img,
-		color: color.White,
-	}
-}
-
-func (p *palettedPainter) Paint(ss []raster.Span, done bool) {
-	b := p.image.Bounds()
-	rect := image.Rect(0, 0, b.Max.X-b.Min.X, b.Max.Y-b.Min.Y)
-	for _, s := range ss {
-		if s.Y < rect.Min.Y {
-			continue
-		}
-		if s.Y >= rect.Max.Y {
-			return
-		}
-		if s.X0 < rect.Min.X {
-			s.X0 = b.Min.X
-		}
-		if s.X1 > rect.Max.X {
-			s.X1 = b.Max.X
-		}
-		if s.X0 >= s.X1 {
-			continue
-		}
-
-		if s.Alpha >= 0x8000 {
-			for i := s.X0; i < s.X1; i++ {
-				p.image.Set(b.Min.X+i, b.Min.Y+s.Y, p.color)
-			}
-		}
-	}
-}
-
-func (p *palettedPainter) SetColor(color color.Color) {
-	p.color = p.image.ColorModel().Convert(color)
-}

internal/util/rounded.go

···
-package util
-
-import (
-	"image"
-	"image/color"
-	"image/draw"
-	"math"
-
-	"github.com/golang/freetype/raster"
-	"github.com/llgcode/draw2d/draw2dimg"
-)
-
-type RoundedImage struct {
-	draw.Image
-	radius int
-}
-
-func NewRoundedImage(img draw.Image, radius int) *RoundedImage {
-	return &RoundedImage{
-		img,
-		radius,
-	}
-}
-
-func (r *RoundedImage) Set(x, y int, c color.Color) {
-	rad := r.radius
-	b := r.Image.Bounds()
-	p := image.Pt(x, y)
-
-	// Check top left corner
-	tl := image.Pt(b.Min.X+rad, b.Min.Y+rad)
-	if x <= tl.X && y <= tl.Y && isOutside(p, tl, rad) {
-		return
-	}
-	// Check top right corner
-	tr := image.Pt(b.Max.X-rad-1, b.Min.Y+rad)
-	if x >= tr.X && y <= tr.Y && isOutside(p, tr, rad) {
-		return
-	}
-	// Check bottom left corner
-	bl := image.Pt(b.Min.X+rad, b.Max.Y-rad-1)
-	if x <= bl.X && y >= bl.Y && isOutside(p, bl, rad) {
-		return
-	}
-	// Check bottom right corner
-	br := image.Pt(b.Max.X-rad-1, b.Max.Y-rad-1)
-	if x >= br.X && y >= br.Y && isOutside(p, br, rad) {
-		return
-	}
-
-	// If we got this far we're inside the rounded
-	// rectangle area and we just draw
-	r.Image.Set(x, y, c)
-}
-
-func (r *RoundedImage) Painter() draw2dimg.Painter {
-	return &roundedPainter{
-		image: r,
-		color: color.White,
-	}
-}
-
-func isOutside(p1, p2 image.Point, r int) bool {
-	dist := calculateDistance(p1.X, p1.Y, p2.X, p2.Y)
-
-	return dist > float64(r)
-}
-
-func calculateDistance(x1, y1, x2, y2 int) float64 {
-	return math.Sqrt(math.Pow(float64(x2)-float64(x1), 2) + math.Pow(float64(y2)-float64(y1), 2))
-
-}
-
-type roundedPainter struct {
-	image *RoundedImage
-	color color.Color
-}
-
-func (r *roundedPainter) Paint(ss []raster.Span, done bool) {
-	b := r.image.Bounds()
-	rect := image.Rect(0, 0, b.Max.X-b.Min.X, b.Max.Y-b.Min.Y)
-	for _, s := range ss {
-		if s.Y < rect.Min.Y {
-			continue
-		}
-		if s.Y >= rect.Max.Y {
-			return
-		}
-		if s.X0 < rect.Min.X {
-			s.X0 = b.Min.X
-		}
-		if s.X1 > rect.Max.X {
-			s.X1 = b.Max.X
-		}
-		if s.X0 >= s.X1 {
-			continue
-		}
-
-		if s.Alpha >= 0x8000 {
-			for i := s.X0; i < s.X1; i++ {
-				r.image.Set(b.Min.X+i, b.Min.Y+s.Y, r.color)
-			}
-		}
-	}
-}
-
-func (r *roundedPainter) SetColor(color color.Color) {
-	r.color = r.image.ColorModel().Convert(color)
-}

internal/util/uniform.go

···
-package util
-
-import (
-	"image"
-	"image/color"
-)
-
-type patternImage struct {
-	pix  [][]color.Color
-	size int
-}
-
-func (p *patternImage) At(x, y int) color.Color {
-	return p.pix[y%p.size][x%p.size]
-}
-
-func (p *patternImage) Bounds() image.Rectangle {
-	return image.Rectangle{
-		image.Point{-1e9, -1e9},
-		image.Point{1e9, 1e9},
-	}
-}
-
-func (p *patternImage) ColorModel() color.Model {
-	return color.GrayModel
-}
-
-func NewLightGrayImage() image.Image {
-	return &patternImage{
-		pix: [][]color.Color{
-			{color.White, color.White, color.White, color.Black, color.White, color.White},
-			{color.White, color.White, color.White, color.White, color.White, color.White},
-			{color.White, color.White, color.White, color.White, color.White, color.White},
-			{color.Black, color.White, color.White, color.White, color.White, color.White},
-			{color.White, color.White, color.White, color.White, color.White, color.White},
-			{color.White, color.White, color.White, color.White, color.White, color.White},
-		},
-		size: 6,
-	}
-}
-
-func NewGrayImage() image.Image {
-	return &patternImage{
-		pix: [][]color.Color{
-			{color.White, color.White, color.Black, color.White},
-			{color.White, color.White, color.White, color.White},
-			{color.Black, color.White, color.White, color.White},
-			{color.White, color.White, color.White, color.White},
-		},
-		size: 4,
-	}
-}
-
-func NewDarkGrayImage() image.Image {
-	return &patternImage{
-		pix: [][]color.Color{
-			{color.White, color.Black},
-			{color.Black, color.White},
-		},
-		size: 2,
-	}
-}