whee back in busineess

elements/testing/artist.go

@@ -4,11 +4,14 @@ import "fmt"
 import "time"
 import "image"
 import "image/color"
+import "git.tebibyte.media/sashakoshka/tomo/canvas"
 import "git.tebibyte.media/sashakoshka/tomo/artist"
 import "git.tebibyte.media/sashakoshka/tomo/shatter"
 import "git.tebibyte.media/sashakoshka/tomo/textdraw"
 import "git.tebibyte.media/sashakoshka/tomo/defaultfont"
 import "git.tebibyte.media/sashakoshka/tomo/elements/core"
+import "git.tebibyte.media/sashakoshka/tomo/artist/shapes"
+import "git.tebibyte.media/sashakoshka/tomo/artist/patterns"
 
 // Artist is an element that displays shapes and patterns drawn by the artist
 // package in order to test it.
@@ -21,103 +24,52 @@ type Artist struct {
 func NewArtist () (element *Artist) {
 	element = &Artist { }
 	element.Core, element.core = core.NewCore(element.draw)
-	element.core.SetMinimumSize(240, 360)
+	element.core.SetMinimumSize(240, 240)
 	return
 }
 
 func (element *Artist) draw () {
 	bounds := element.Bounds()
-	artist.FillRectangle(element.core, artist.NewUniform(hex(0)), bounds)
+	patterns.Uhex(0x000000FF).Draw(element.core, bounds)
 
 	drawStart := time.Now()
 
-	// 0, 0
-	artist.FillRectangle (
-		element.core,
-		artist.Beveled {
-			artist.NewUniform(hex(0xFF0000FF)),
-			artist.NewUniform(hex(0x0000FFFF)),
-		},
-		element.cellAt(0, 0))
-
-	// 1, 0
-	artist.StrokeRectangle (
-		element.core,
-		artist.NewUniform(hex(0x00FF00FF)), 3,
-		element.cellAt(1, 0))
-
-	// 2, 0
-	artist.FillRectangle (
-		element.core,
-		artist.NewMultiBordered (
-			artist.Stroke { Pattern: uhex(0xFF0000FF), Weight: 1 },
-			artist.Stroke { Pattern: uhex(0x888800FF), Weight: 2 },
-			artist.Stroke { Pattern: uhex(0x00FF00FF), Weight: 3 },
-			artist.Stroke { Pattern: uhex(0x008888FF), Weight: 4 },
-			artist.Stroke { Pattern: uhex(0x0000FFFF), Weight: 5 },
-			),
-		element.cellAt(2, 0))
-
-	// 3, 0
-	artist.FillRectangle (
-		element.core,
-		artist.Bordered {
-			Stroke: artist.Stroke { Pattern: uhex(0x0000FFFF), Weight: 5 },
-			Fill: uhex(0xFF0000FF),
-		},
-		element.cellAt(3, 0))
+	// 0, 0 - 3, 0
+	for x := 0; x < 4; x ++ {
+		element.colorLines(x + 1, element.cellAt(x, 0).Bounds())
+	}
 
 	// 4, 0
-	artist.FillRectangle (
-		element.core,
-		artist.Padded {
-			Stroke: uhex(0xFFFFFFFF),
-			Fill: uhex(0x666666FF),
-			Sides: []int { 4, 13, 2, 0 },
-		},
-		element.cellAt(4, 0))
+	c40 := element.cellAt(4, 0)
+	shapes.StrokeColorRectangle(c40, artist.Hex(0x888888FF), c40.Bounds(), 1)
+	shapes.ColorLine (
+		c40, artist.Hex(0xFF0000FF), 1,
+		c40.Bounds().Min, c40.Bounds().Max)
 
-	// 0, 1 - 3, 1
-	for x := 0; x < 4; x ++ {
-		artist.FillRectangle (
-			element.core,
-			artist.Striped {
-				First:  artist.Stroke { Pattern: uhex(0xFF8800FF), Weight: 7 },
-				Second: artist.Stroke { Pattern: uhex(0x0088FFFF), Weight: 2 },
-				Orientation: artist.Orientation(x),
-				
-			},
-			element.cellAt(x, 1))
-	}
+	// 0, 1
+	c01 := element.cellAt(0, 1)
+	shapes.StrokeColorRectangle(c01, artist.Hex(0x888888FF), c01.Bounds(), 1)
+	shapes.FillColorEllipse(element.core, artist.Hex(0x00FF00FF), c01.Bounds())
 
-	// 0, 2 - 3, 2
-	for x := 0; x < 4; x ++ {
-		element.lines(x + 1, element.cellAt(x, 2))
-	}
-
-	// 0, 3
-	artist.StrokeRectangle (
-		element.core, uhex(0x888888FF), 1,
-		element.cellAt(0, 3))
-	artist.FillEllipse(element.core, uhex(0x00FF00FF), element.cellAt(0, 3))
-
-	// 1, 3 - 3, 3
+	// 1, 1 - 3, 1
 	for x := 1; x < 4; x ++ {
-		artist.StrokeRectangle (
-			element.core,uhex(0x888888FF), 1,
-			element.cellAt(x, 3))
-		artist.StrokeEllipse (
+		c := element.cellAt(x, 1)
+		shapes.StrokeColorRectangle (
+			element.core, artist.Hex(0x888888FF),
+			c.Bounds(), 1)
+		shapes.StrokeColorEllipse (
 			element.core,
-			[]artist.Pattern {
-				uhex(0xFF0000FF),
-				uhex(0x00FF00FF),
-				uhex(0xFF00FFFF),
+			[]color.RGBA {
+				artist.Hex(0xFF0000FF),
+				artist.Hex(0x00FF00FF),
+				artist.Hex(0xFF00FFFF),
 			} [x - 1],
-			x, element.cellAt(x, 3))
+			c.Bounds(), x)
 	}
 
-	// 4, 3
-	shatterPos := element.cellAt(4, 3).Min
+	// 4, 1
+	c41 := element.cellAt(4, 1)
+	shatterPos := c41.Bounds().Min
 	rocks := []image.Rectangle {
 		image.Rect(3, 12, 13, 23).Add(shatterPos),
 		// image.Rect(30, 10, 40, 23).Add(shatterPos),
@@ -125,159 +77,36 @@ func (element *Artist) draw () {
 		image.Rect(30, -10, 40, 43).Add(shatterPos),
 		image.Rect(80, 30, 90, 45).Add(shatterPos),
 	}
-	tiles := shatter.Shatter(element.cellAt(4, 3), rocks...)
-	for _, tile := range tiles {
-		artist.FillRectangle (
-			element.core,
-			artist.Bordered {
-				Fill: uhex(0x888888FF),
-				Stroke: artist.Stroke {
-					Pattern: artist.Beveled {
-						uhex(0xCCCCCCFF),
-						uhex(0x444444FF),
-					},
-					Weight: 1,
-				},
-			},
-			tile)
+	tiles := shatter.Shatter(c41.Bounds(), rocks...)
+	for index, tile := range tiles {
+		artist.DrawBounds (
+			element.core, tile,
+			[]artist.Pattern {
+				patterns.Uhex(0xFF0000FF),
+				patterns.Uhex(0x00FF00FF),
+				patterns.Uhex(0xFF00FFFF),
+				patterns.Uhex(0xFFFF00FF),
+				patterns.Uhex(0x00FFFFFF),
+			} [index % 5], tile)
 	}
 
-	// 0, 4 - 3, 4
-	for x := 0; x < 4; x ++ {
-		artist.FillEllipse (
-			element.core, 
-			artist.Split {
-				First:  uhex(0xFF0000FF),
-				Second: uhex(0x0000FFFF),
-				Orientation: artist.Orientation(x),
-			},
-			element.cellAt(x, 4))
-	}
+	// 0, 2
+	c02 := element.cellAt(0, 2)
+	shapes.StrokeColorRectangle(c02, artist.Hex(0x888888FF), c02.Bounds(), 1)
+	shapes.FillEllipse(c02, c41)
+
+	// 1, 2
+	c12 := element.cellAt(1, 2)
+	shapes.StrokeColorRectangle(c12, artist.Hex(0x888888FF), c12.Bounds(), 1)
+	shapes.StrokeEllipse(c12, c41, 5)
 	
-	// 0, 5
-	artist.FillRectangle (
-		element.core,
-		artist.QuadBeveled {
-			uhex(0x880000FF),
-			uhex(0x00FF00FF),
-			uhex(0x0000FFFF),
-			uhex(0xFF00FFFF),
-		},
-		element.cellAt(0, 5))
-		
-	// 1, 5
-	artist.FillRectangle (
-		element.core,
-		artist.Checkered {
-			First: artist.QuadBeveled {
-				uhex(0x880000FF),
-				uhex(0x00FF00FF),
-				uhex(0x0000FFFF),
-				uhex(0xFF00FFFF),
-			},
-			Second: artist.Striped {
-				First:  artist.Stroke { Pattern: uhex(0xFF8800FF), Weight: 1 },
-				Second: artist.Stroke { Pattern: uhex(0x0088FFFF), Weight: 1 },
-				Orientation: artist.OrientationVertical,
-			},
-			CellWidth: 32,
-			CellHeight: 16,
-		},
-		element.cellAt(1, 5))
-	
-	// 2, 5
-	artist.FillRectangle (
-		element.core,
-		artist.Dotted {
-			Foreground: uhex(0x00FF00FF),
-			Background: artist.Checkered {
-				First:  uhex(0x444444FF),
-				Second: uhex(0x888888FF),
-				CellWidth: 16,
-				CellHeight: 16,
-			},
-			Size: 8,
-			Spacing: 16,
-		},
-		element.cellAt(2, 5))
-		
-	// 3, 5
-	artist.FillRectangle (
-		element.core,
-		artist.Tiled {
-			Pattern: artist.QuadBeveled {
-				uhex(0x880000FF),
-				uhex(0x00FF00FF),
-				uhex(0x0000FFFF),
-				uhex(0xFF00FFFF),
-			},
-			CellWidth: 17,
-			CellHeight: 23,
-		},
-		element.cellAt(3, 5))
-		
-	// 0, 6 - 3, 6
-	for x := 0; x < 4; x ++ {
-		artist.FillRectangle (
-			element.core, 
-			artist.Gradient {
-				First:  uhex(0xFF0000FF),
-				Second: uhex(0x0000FFFF),
-				Orientation: artist.Orientation(x),
-			},
-			element.cellAt(x, 6))
-	}
+	// 2, 2
+	c22 := element.cellAt(2, 2)
+	shapes.FillRectangle(c22, c41)
 
-	// 0, 7
-	artist.FillEllipse (
-		element.core,
-		artist.EllipticallyBordered {
-			Fill: artist.Gradient {
-				First:  uhex(0x00FF00FF),
-				Second: uhex(0x0000FFFF),
-				Orientation: artist.OrientationVertical,
-			},
-			Stroke: artist.Stroke { Pattern: uhex(0x00FF00), Weight: 5 },
-		},
-		element.cellAt(0, 7))
-
-	// 1, 7
-	artist.FillRectangle (
-		element.core,
-		artist.Noisy {
-			Low:  uhex(0x000000FF),
-			High: uhex(0xFFFFFFFF),
-			Seed: 0,
-		},
-		element.cellAt(1, 7),
-	)
-
-	// 2, 7
-	artist.FillRectangle (
-		element.core,
-		artist.Noisy {
-			Low:  uhex(0x000000FF),
-			High: artist.Gradient {
-				First:  uhex(0x000000FF),
-				Second: uhex(0xFFFFFFFF),
-				Orientation: artist.OrientationVertical,
-			},
-			Seed: 0,
-		},
-		element.cellAt(2, 7),
-	)
-
-	// 3, 7
-	artist.FillRectangle (
-		element.core,
-		artist.Noisy {
-			Low:  uhex(0x000000FF),
-			High: uhex(0xFFFFFFFF),
-			Seed: 0,
-			Harsh: true,
-		},
-		element.cellAt(3, 7),
-	)
+	// 3, 2
+	c32 := element.cellAt(3, 2)
+	shapes.StrokeRectangle(c32, c41, 5)
 	
 	// how long did that take to render?
 	drawTime := time.Since(drawStart)
@@ -288,68 +117,51 @@ func (element *Artist) draw () {
 		drawTime.Milliseconds(),
 		drawTime.Microseconds())))
 	textDrawer.Draw (
-		element.core, uhex(0xFFFFFFFF),
+		element.core, artist.Hex(0xFFFFFFFF),
 		image.Pt(bounds.Min.X + 8, bounds.Max.Y - 24))
 }
 
-func (element *Artist) lines (weight int, bounds image.Rectangle) {
+func (element *Artist) colorLines (weight int, bounds image.Rectangle) {
 	bounds = bounds.Inset(4)
-	c := uhex(0xFFFFFFFF)
-	artist.Line(element.core, c, weight, bounds.Min, bounds.Max)
-	artist.Line (
+	c := artist.Hex(0xFFFFFFFF)
+	shapes.ColorLine(element.core, c, weight, bounds.Min, bounds.Max)
+	shapes.ColorLine (
 		element.core, c, weight,
 		image.Pt(bounds.Max.X, bounds.Min.Y),
 		image.Pt(bounds.Min.X, bounds.Max.Y))
-	artist.Line (
+	shapes.ColorLine (
 		element.core, c, weight,
 		image.Pt(bounds.Max.X, bounds.Min.Y + 16),
 		image.Pt(bounds.Min.X, bounds.Max.Y - 16))
-	artist.Line (
+	shapes.ColorLine (
 		element.core, c, weight,
 		image.Pt(bounds.Min.X, bounds.Min.Y + 16),
 		image.Pt(bounds.Max.X, bounds.Max.Y - 16))
-	artist.Line (
+	shapes.ColorLine (
 		element.core, c, weight,
 		image.Pt(bounds.Min.X + 20, bounds.Min.Y),
 		image.Pt(bounds.Max.X - 20, bounds.Max.Y))
-	artist.Line (
+	shapes.ColorLine (
 		element.core, c, weight,
 		image.Pt(bounds.Max.X - 20, bounds.Min.Y),
 		image.Pt(bounds.Min.X + 20, bounds.Max.Y))
-	artist.Line (
+	shapes.ColorLine (
 		element.core, c, weight,
 		image.Pt(bounds.Min.X, bounds.Min.Y + bounds.Dy() / 2),
 		image.Pt(bounds.Max.X, bounds.Min.Y + bounds.Dy() / 2))
-	artist.Line (
+	shapes.ColorLine (
 		element.core, c, weight,
 		image.Pt(bounds.Min.X + bounds.Dx() / 2, bounds.Min.Y),
 		image.Pt(bounds.Min.X + bounds.Dx() / 2, bounds.Max.Y))
 }
 
-func (element *Artist) cellAt (x, y int) (image.Rectangle) {
+func (element *Artist) cellAt (x, y int) (canvas.Canvas) {
 	bounds := element.Bounds()
 	cellBounds := image.Rectangle { }
 	cellBounds.Min = bounds.Min
 	cellBounds.Max.X = bounds.Min.X + bounds.Dx() / 5
-	cellBounds.Max.Y = bounds.Min.Y + (bounds.Dy() - 48) / 8
-	return cellBounds.Add (image.Pt (
+	cellBounds.Max.Y = bounds.Min.Y + (bounds.Dy() - 48) / 4
+	return canvas.Cut (element.core, cellBounds.Add (image.Pt (
 		x * cellBounds.Dx(),
-		y * cellBounds.Dy()))
-}
-
-func hex (n uint32) (c color.RGBA) {
-	c.A = uint8(n)
-	c.B = uint8(n >>  8)
-	c.G = uint8(n >> 16)
-	c.R = uint8(n >> 24)
-	return
-}
-
-func uhex (n uint32) (artist.Pattern) {
-	return artist.NewUniform (color.RGBA {
-		A: uint8(n),
-		B: uint8(n >>  8),
-		G: uint8(n >> 16),
-		R: uint8(n >> 24),
-	})
+		y * cellBounds.Dy())))
 }

elements/testing/mouse.go

@@ -1,11 +1,11 @@
 package testing
 
 import "image"
-import "image/color"
 import "git.tebibyte.media/sashakoshka/tomo/input"
-import "git.tebibyte.media/sashakoshka/tomo/config"
 import "git.tebibyte.media/sashakoshka/tomo/theme"
+import "git.tebibyte.media/sashakoshka/tomo/config"
 import "git.tebibyte.media/sashakoshka/tomo/artist"
+import "git.tebibyte.media/sashakoshka/tomo/artist/shapes"
 import "git.tebibyte.media/sashakoshka/tomo/elements/core"
 
 // Mouse is an element capable of testing mouse input. When the mouse is clicked
@@ -14,7 +14,6 @@ type Mouse struct {
 	*core.Core
 	core core.CoreControl
 	drawing      bool
-	color        artist.Pattern
 	lastMousePos image.Point
 	
 	config config.Config
@@ -27,7 +26,6 @@ func NewMouse () (element *Mouse) {
 	element = &Mouse { c: theme.C("testing", "mouse") }
 	element.Core, element.core = core.NewCore(element.draw)
 	element.core.SetMinimumSize(32, 32)
-	element.color = artist.NewUniform(color.Black)
 	return
 }
 
@@ -55,17 +53,17 @@ func (element *Mouse) draw () {
 		theme.PatternAccent,
 		theme.PatternState { },
 		element.c)
-	artist.FillRectangle(element.core, pattern, bounds)
-	artist.StrokeRectangle (
+	pattern.Draw(element.core, bounds)
+	shapes.StrokeColorRectangle (
 		element.core,
-		artist.NewUniform(color.Black), 1,
-		bounds)
-	artist.Line (
-		element.core, artist.NewUniform(color.White), 1,
+		artist.Hex(0x000000FF),
+		bounds, 1)
+	shapes.ColorLine (
+		element.core, artist.Hex(0xFFFFFFFF), 1,
 		bounds.Min.Add(image.Pt(1, 1)),
 		bounds.Min.Add(image.Pt(bounds.Dx() - 2, bounds.Dy() - 2)))
-	artist.Line (
-		element.core, artist.NewUniform(color.White), 1,
+	shapes.ColorLine (
+		element.core, artist.Hex(0xFFFFFFFF), 1,
 		bounds.Min.Add(image.Pt(1, bounds.Dy() - 2)),
 		bounds.Min.Add(image.Pt(bounds.Dx() - 2, 1)))
 }
@@ -78,8 +76,8 @@ func (element *Mouse) HandleMouseDown (x, y int, button input.Button) {
 func (element *Mouse) HandleMouseUp (x, y int, button input.Button) {
 	element.drawing = false
 	mousePos := image.Pt(x, y)
-	element.core.DamageRegion (artist.Line (
-		element.core, element.color, 1,
+	element.core.DamageRegion (shapes.ColorLine (
+		element.core, artist.Hex(0x000000FF), 1,
 		element.lastMousePos, mousePos))
 	element.lastMousePos = mousePos
 }
@@ -87,8 +85,8 @@ func (element *Mouse) HandleMouseUp (x, y int, button input.Button) {
 func (element *Mouse) HandleMouseMove (x, y int) {
 	if !element.drawing { return }
 	mousePos := image.Pt(x, y)
-	element.core.DamageRegion (artist.Line (
-		element.core, element.color, 1,
+	element.core.DamageRegion (shapes.ColorLine (
+		element.core, artist.Hex(0x000000FF), 1,
 		element.lastMousePos, mousePos))
 	element.lastMousePos = mousePos
 }