updates for Cogent Canvas

base/keylist/keylist_test.go

@@ -32,6 +32,15 @@ func TestKeyList(t *testing.T) {
 	assert.Equal(t, 0, kl.Values[1])
 	assert.Equal(t, 2, kl.IndexByKey("key2"))
 
+	kl.DeleteByKey("new0")
+	assert.Equal(t, 0, kl.Values[0])
+	assert.Equal(t, 2, kl.Values[1])
+	assert.Equal(t, 1, kl.IndexByKey("key2"))
+
+	kl.Add("new0", 3)
+	assert.Equal(t, 3, kl.Values[2])
+	assert.Equal(t, 2, kl.IndexByKey("new0"))
+
 	//	nm := Make([]KeyValue[string, int]{{"one", 1}, {"two", 2}, {"three", 3}})
 	// assert.Equal(t, 3, nm.Values[2])
 	// assert.Equal(t, 2, nm.Values[1])

base/tiered/tiered.go

@@ -25,10 +25,10 @@ type Tiered[T any] struct {
 
 // Do calls the given function for each tier,
 // going through first, then normal, then final.
-func (t *Tiered[T]) Do(f func(T)) {
-	f(t.First)
-	f(t.Normal)
-	f(t.Final)
+func (t *Tiered[T]) Do(f func(*T)) {
+	f(&t.First)
+	f(&t.Normal)
+	f(&t.Final)
 }
 
 // DoWith calls the given function with each tier of this tiered

colors/gradient/gradient.go

@@ -82,14 +82,14 @@ type Base struct { //types:add -setters
 // Stop represents a single stop in a gradient
 type Stop struct {
 
-	// the color of the stop. these should be fully opaque,
+	// Color of the stop. These should be fully opaque,
 	// with opacity specified separately, for best results, as is done in SVG etc.
-	Color color.Color
+	Color color.RGBA
 
-	// the position of the stop between 0 and 1
+	// Pos is the position of the stop in normalized units between 0 and 1.
 	Pos float32
 
-	// Opacity is the 0-1 level of opacity for this stop
+	// Opacity is the 0-1 level of opacity for this stop.
 	Opacity float32
 }
 

colors/gradient/gradient_test.go

@@ -144,15 +144,26 @@ func TestRenderRadial(t *testing.T) {
 	imagex.Assert(t, img, "radial-user-space")
 }
 
-// func matToRasterx(mat *math32.Matrix2) rasterx.Matrix2D {
-// 	// A = XX
-// 	// B = YX
-// 	// C = XY
-// 	// D = YY
-// 	// E = X0
-// 	// F = Y0
-// 	return rasterx.Matrix2D{float64(mat.XX), float64(mat.YX), float64(mat.XY), float64(mat.YY), float64(mat.X0), float64(mat.Y0)}
-// }
+func TestRenderRadialRotate(t *testing.T) {
+	r := image.Rectangle{Max: image.Point{128, 128}}
+	b := math32.B2FromRect(r)
+	img := image.NewRGBA(r)
+	g := CopyOf(radialTransformTest)
+	// g.AsBase().Blend = colors.HCT
+	g.Update(1, b, math32.Identity2())
+	draw.Draw(img, img.Bounds(), g, image.Point{}, draw.Src)
+	imagex.Assert(t, img, "radial-rot")
+
+	xf := math32.Rotate2D(math32.DegToRad(-45))
+	ug := CopyOf(g).(*Radial)
+	ug.SetUnits(UserSpaceOnUse)
+	ug.Center.SetMul(ug.Box.Size())
+	ug.Focal.SetMul(ug.Box.Size())
+	ug.Radius.SetMul(ug.Box.Size())
+	ug.Update(1, b, xf)
+	draw.Draw(img, img.Bounds(), ug, image.Point{}, draw.Src)
+	imagex.Assert(t, img, "radial-rot-user-space")
+}
 
 func compareTol(t *testing.T, a, c float32) {
 	if math32.Abs(a-c) > 1.0e-5 {

colors/gradient/parse.go

@@ -59,7 +59,6 @@ func FromString(str string, ctx ...colors.Context) (image.Image, error) {
 		// TODO(kai): do we need to clone?
 		return img, nil
 	}
-
 	str = strings.TrimSpace(str)
 	if strings.HasPrefix(str, "url(") {
 		img := cc.ImageByURL(str)
@@ -69,6 +68,9 @@ func FromString(str string, ctx ...colors.Context) (image.Image, error) {
 		return img, nil
 	}
 	str = strings.ToLower(str)
+	if str == "none" || str == "" {
+		return nil, nil
+	}
 	grad := "-gradient"
 
 	gidx := strings.Index(str, grad)
@@ -126,10 +128,14 @@ func FromAny(val any, ctx ...colors.Context) (image.Image, error) {
 	switch v := val.(type) {
 	case color.Color:
 		return colors.Uniform(v), nil
+	case *color.Color:
+		return colors.Uniform(*v), nil
 	case image.Image:
 		return v, nil
 	case string:
 		return FromString(v, ctx...)
+	case *string:
+		return FromString(*v, ctx...)
 	}
 	return nil, fmt.Errorf("gradient.FromAny: got unsupported type %T", val)
 }
@@ -498,9 +504,6 @@ func readFraction(v string) (float32, error) {
 	}
 	f := float32(f64)
 	f /= d
-	if f < 0 {
-		f = 0
-	}
 	return f, nil
 }
 

colors/gradient/radial.go

@@ -31,6 +31,8 @@ type Radial struct { //types:add -setters
 	rCenter math32.Vector2
 	rFocal  math32.Vector2
 	rRadius math32.Vector2
+
+	rotTrans math32.Matrix2
 }
 
 var _ Gradient = &Radial{}
@@ -62,6 +64,7 @@ func (r *Radial) Update(opacity float32, box math32.Box2, objTransform math32.Ma
 	r.Box = box
 	r.Opacity = opacity
 	r.updateBase()
+	r.rotTrans = math32.Identity2()
 
 	c, f, rs := r.Center, r.Focal, r.Radius
 	sz := r.Box.Size()
@@ -70,12 +73,12 @@ func (r *Radial) Update(opacity float32, box math32.Box2, objTransform math32.Ma
 		f = r.Box.Min.Add(sz.Mul(f))
 		rs.SetMul(sz)
 	} else {
-		c = r.Transform.MulVector2AsPoint(c)
-		f = r.Transform.MulVector2AsPoint(f)
-		rs = r.Transform.MulVector2AsVector(rs)
-		c = objTransform.MulVector2AsPoint(c)
-		f = objTransform.MulVector2AsPoint(f)
-		rs = objTransform.MulVector2AsVector(rs)
+		ct := objTransform.Mul(r.Transform)
+		c = ct.MulVector2AsPoint(c)
+		f = ct.MulVector2AsPoint(f)
+		_, _, phi, sx, sy, _ := ct.Decompose()
+		r.rotTrans = math32.Rotate2D(phi)
+		rs.SetMul(math32.Vec2(sx, sy))
 	}
 	if c != f {
 		f.SetDiv(rs)
@@ -111,7 +114,7 @@ func (r *Radial) At(x, y int) color.Color {
 		if r.Units == ObjectBoundingBox {
 			pt = r.boxTransform.MulVector2AsPoint(pt)
 		}
-		d := pt.Sub(r.rCenter)
+		d := r.rotTrans.MulVector2AsVector(pt.Sub(r.rCenter))
 		pos := math32.Sqrt(d.X*d.X/(r.rRadius.X*r.rRadius.X) + (d.Y*d.Y)/(r.rRadius.Y*r.rRadius.Y))
 		return r.getColor(pos)
 	}
@@ -123,6 +126,7 @@ func (r *Radial) At(x, y int) color.Color {
 	if r.Units == ObjectBoundingBox {
 		pt = r.boxTransform.MulVector2AsPoint(pt)
 	}
+	pt = r.rotTrans.MulVector2AsVector(pt)
 	e := pt.Div(r.rRadius)
 
 	t1, intersects := rayCircleIntersectionF(e, r.rFocal, r.rCenter, 1)

colors/image.go

@@ -12,6 +12,9 @@ import (
 // Uniform returns a new [image.Uniform] filled completely with the given color.
 // See [ToUniform] for the converse.
 func Uniform(c color.Color) image.Image {
+	if c == nil {
+		return nil
+	}
 	return image.NewUniform(c)
 }
 
@@ -24,6 +27,20 @@ func ToUniform(img image.Image) color.RGBA {
 	return AsRGBA(img.At(0, 0))
 }
 
+// CloneUniform returns a copy of a Uniform image color, if image is one.
+// Otherwise just returns the image back. This is useful when modifying
+// an image color, to ensure that it doesn't modify all users of this image.
+func CloneUniform(img image.Image) image.Image {
+	if img == nil {
+		return nil
+	}
+	u, ok := img.(*image.Uniform)
+	if !ok {
+		return img
+	}
+	return image.NewUniform(AsRGBA(u.C))
+}
+
 // Pattern returns a new unbounded [image.Image] represented by the given pattern function.
 func Pattern(f func(x, y int) color.Color) image.Image {
 	return &pattern{f}

core/button.go

@@ -130,6 +130,7 @@ func (bt *Button) Init() {
 			}
 		}
 		s.Font.Size.Dp(14) // Button font size is used for text font size
+		s.IconSize.Set(units.Em(18.0 / 14))
 		s.Gap.Zero()
 		s.CenterAll()
 
@@ -209,9 +210,6 @@ func (bt *Button) Init() {
 		}
 		if bt.Icon.IsSet() {
 			tree.AddAt(p, "icon", func(w *Icon) {
-				w.Styler(func(s *styles.Style) {
-					s.Font.Size.Dp(18)
-				})
 				w.Updater(func() {
 					w.SetIcon(bt.Icon)
 				})
@@ -251,10 +249,7 @@ func (bt *Button) Init() {
 			})
 			tree.AddAt(p, "indicator", func(w *Icon) {
 				w.Styler(func(s *styles.Style) {
-					s.Min.X.Dp(18)
-					s.Min.Y.Dp(18)
-					s.Margin.Zero()
-					s.Padding.Zero()
+					s.IconSize.Set(units.Dp(18)) // independent from Em
 				})
 				w.Updater(func() {
 					w.SetIcon(bt.Indicator)