Merge pull request #1670 from cogentcore/transpose

transpose: fix crash in transpose, and update to non-deprecated typesetting api to fix web text rendering

Author: rcoreilly

content/examples/basic/basic.go

@@ -19,6 +19,7 @@ import (
 var econtent embed.FS
 
 func main() {
+	// rasterx.UseGlyphCache = false
 	content.Settings.SiteTitle = "Cogent Content Example"
 	content.OfflineURL = "https://example.com"
 	b := core.NewBody("Cogent Content Example")

go.mod

@@ -66,6 +66,7 @@ require (
 	github.com/pkg/errors v0.9.1 // indirect
 	github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect
 	github.com/rivo/uniseg v0.4.7 // indirect
+	github.com/rogpeppe/go-internal v1.13.1 // indirect
 	golang.org/x/exp/shiny v0.0.0-20240416160154-fe59bbe5cc7f // indirect
 	golang.org/x/mobile v0.0.0-20231127183840-76ac6878050a // indirect
 	golang.org/x/mod v0.34.0 // indirect

go.sum

@@ -135,8 +135,9 @@ github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRI
 github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
 github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
 github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
-github.com/rogpeppe/go-internal v1.9.0 h1:73kH8U+JUqXU8lRuOHeVHaa/SZPifC7BkcraZVejAe8=
 github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
+github.com/rogpeppe/go-internal v1.13.1 h1:KvO1DLK/DRN07sQ1LQKScxyZJuNnedQ5/wKSR38lUII=
+github.com/rogpeppe/go-internal v1.13.1/go.mod h1:uMEvuHeurkdAXX61udpOXGD/AzZDWNMNyH2VO9fmH0o=
 github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
 github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
 github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo=

paint/renderers/rasterx/glyphcache.go

@@ -36,7 +36,8 @@ const (
 	// glyphMaskOffsets is the number of different subpixel offsets to render, in each axis.
 	// The memory usage goes as the square of this number, and 4 produces very good results,
 	// while 2 is acceptable, and is significantly better than 1. 8 is overkill.
-	glyphMaskOffsets = 4
+	glyphMaskOffsetsX = 4
+	glyphMaskOffsetsY = 4
 )
 
 func init() {
@@ -83,7 +84,7 @@ func (gc *glyphCache) Glyph(face *font.Face, g *shaping.Glyph, outline font.Glyp
 	gc.Lock()
 	defer gc.Unlock()
 
-	fsize := image.Point{X: int(g.Width.Ceil()), Y: -int(g.Height.Ceil())}
+	fsize := image.Point{X: int(g.Width.Round()), Y: -int(g.Height.Round())}
 	size := fsize.Add(image.Point{2 * glyphMaskBorder, 2 * glyphMaskBorder})
 	if size.X <= 0 || size.X > glyphMaxSize || size.Y <= 0 || size.Y > glyphMaxSize {
 		return nil, image.Point{}
@@ -95,8 +96,9 @@ func (gc *glyphCache) Glyph(face *font.Face, g *shaping.Glyph, outline font.Glyp
 	pi := pf.ToPoint().Sub(image.Point{glyphMaskBorder, glyphMaskBorder})
 	pi.X += g.XBearing.Round()
 	pi.Y -= g.YBearing.Round()
+
 	off := pos.Sub(pf)
-	oi := off.MulScalar(glyphMaskOffsets).Floor().ToPoint()
+	oi := off.Mul(math32.Vec2(glyphMaskOffsetsX, glyphMaskOffsetsY)).Round().ToPoint()
 	// fmt.Println("pos:", pos, "oi:", oi, "pi:", pi)
 
 	key := glyphKey{gid: g.GlyphID, sx: uint8(fsize.X), sy: uint8(fsize.Y), ox: uint8(oi.X), oy: uint8(oi.Y)}
@@ -123,9 +125,9 @@ func (gc *glyphCache) renderGlyph(face *font.Face, gid font.GID, g *shaping.Glyp
 	// clear target:
 	draw.Draw(gc.image, gc.image.Bounds(), colors.Uniform(color.Transparent), image.Point{0, 0}, draw.Src)
 
-	od := float32(1) / glyphMaskOffsets
-	x := -float32(g.XBearing.Round()) + float32(xo)*od + glyphMaskBorder
-	y := float32(g.YBearing.Round()) + float32(yo)*od + glyphMaskBorder
+	od := math32.Vec2(1, 1).Div(math32.Vec2(glyphMaskOffsetsX, glyphMaskOffsetsY))
+	x := -float32(g.XBearing.Round()) + float32(xo)*od.X + glyphMaskBorder
+	y := float32(g.YBearing.Round()) + float32(yo)*od.Y + glyphMaskBorder
 	rs := gc.filler
 	rs.Clear()
 	for _, s := range outline.Segments {

paint/renderers/rasterx/text.go

@@ -165,8 +165,11 @@ func (rs *Renderer) TextRun(ctx *render.Context, run *shapedgt.Run, ln *shaped.L
 		} else {
 			fmt.Printf("unrecognized glyph data for glyphID: %v, face: %v\n", g.GlyphID, run.Face.Describe().Family)
 		}
-		off.X += math32.FromFixed(g.XAdvance)
-		off.Y -= math32.FromFixed(g.YAdvance)
+		if run.Direction.IsVertical() {
+			off.Y -= math32.FromFixed(g.Advance)
+		} else {
+			off.X += math32.FromFixed(g.Advance)
+		}
 	}
 
 	if run.Decoration.HasFlag(rich.LineThrough) {
@@ -188,7 +191,8 @@ func (rs *Renderer) GlyphOutline(ctx *render.Context, run *shapedgt.Run, g *shap
 	}
 
 	wd := math32.FromFixed(g.Width)
-	xadv := math32.Abs(math32.FromFixed(g.XAdvance))
+	// todo: should be conditional on run.Direction
+	xadv := math32.Abs(math32.FromFixed(g.Advance))
 	if wd > xadv {
 		if run.Font.Style(&ctx.Style.Text).Family == rich.Monospace {
 			scale *= 0.95 * xadv / wd

text/lines/move.go

@@ -5,6 +5,8 @@
 package lines
 
 import (
+	"fmt"
+
 	"cogentcore.org/core/text/textpos"
 )
 
@@ -154,6 +156,10 @@ func (ls *Lines) transposeChar(vw *view, pos textpos.Pos) bool {
 		return false
 	}
 	ppos := ls.posFromView(vw, pvp)
+	if pos.Line >= len(ls.lines) || pos.Char >= len(ls.lines[pos.Line]) {
+		fmt.Println("transpose err:", pos, "lines:", len(ls.lines))
+		return false
+	}
 	chr := ls.lines[pos.Line][pos.Char]
 	pchr := ls.lines[ppos.Line][ppos.Char]
 	repl := string([]rune{chr, pchr})

text/shaped/shaped_test.go

@@ -403,3 +403,15 @@ func TestFontList(t *testing.T) {
 		fmt.Println(fi.Family, "Weight:", fi.Weight, "Slant:", fi.Slant)
 	}
 }
+
+func TestGlyphAlign(t *testing.T) {
+	RunTest(t, "align", 300, 300, func(pc *paint.Painter, sh Shaper, tsty *text.Style) {
+		src := "to gopher so"
+		sty := rich.NewStyle()
+		sty.Size = 0.845
+		tx := rich.NewText(sty, []rune(src))
+		lns := sh.WrapLines(tx, sty, tsty, math32.Vec2(250, 250))
+		pos := math32.Vec2(10.3, 10.96875)
+		pc.DrawText(lns, pos)
+	})
+}

text/shaped/shapers/shapedgt/run.go

@@ -131,10 +131,10 @@ func (run *Run) GlyphsAt(i int) []int {
 	var gis []int
 	for gi := range run.Glyphs {
 		g := &run.Glyphs[gi]
-		if g.ClusterIndex > i {
+		if g.TextIndex() > i {
 			break
 		}
-		if g.ClusterIndex == i {
+		if g.TextIndex() == i {
 			gis = append(gis, gi)
 		}
 	}
@@ -146,7 +146,7 @@ func (run *Run) GlyphsAt(i int) []int {
 func (run *Run) FirstGlyphAt(i int) int {
 	for gi := range run.Glyphs {
 		g := &run.Glyphs[gi]
-		if g.ClusterIndex >= i {
+		if g.TextIndex() >= i {
 			return gi
 		}
 	}
@@ -159,7 +159,7 @@ func (run *Run) LastGlyphAt(i int) int {
 	ng := len(run.Glyphs)
 	for gi := ng - 1; gi >= 0; gi-- {
 		g := &run.Glyphs[gi]
-		if g.ClusterIndex <= i {
+		if g.TextIndex() <= i {
 			return gi
 		}
 	}
@@ -171,7 +171,7 @@ func (run *Run) LastGlyphAt(i int) int {
 func (run *Run) SetGlyphXAdvance(adv fixed.Int26_6) {
 	for gi := range run.Glyphs {
 		g := &run.Glyphs[gi]
-		g.XAdvance = adv
+		g.Advance = adv
 	}
 	run.Output.Advance = adv * fixed.Int26_6(len(run.Glyphs))
 }
@@ -186,8 +186,8 @@ func (run *Run) RuneAtPoint(src rich.Text, pt, off math32.Vector2) int {
 	rr := run.Runes()
 	for gi := range run.Glyphs {
 		g := &run.Glyphs[gi]
-		cri := g.ClusterIndex
-		gadv := math32.FromFixed(g.XAdvance)
+		cri := g.TextIndex()
+		gadv := math32.FromFixed(g.Advance)
 		mx := adv + gadv
 		// fmt.Println(gi, cri, adv, mx, pt.X)
 		if pt.X >= adv && pt.X < mx {
@@ -222,14 +222,14 @@ func (run *Run) GlyphRegionBounds(st, ed int) math32.Box2 {
 	off := float32(0)
 	for gi := 0; gi < st; gi++ {
 		g := &run.Glyphs[gi]
-		off += math32.FromFixed(g.XAdvance)
+		off += math32.FromFixed(g.Advance)
 	}
 	mb.Min.X = off + stb.Min.X - 2
 	for gi := st; gi <= ed; gi++ {
 		g := &run.Glyphs[gi]
 		gb := run.GlyphBoundsBox(g)
 		mb.Max.X = off + gb.Max.X + 2
-		off += math32.FromFixed(g.XAdvance)
+		off += math32.FromFixed(g.Advance)
 	}
 	return mb
 }

text/shaped/shapers/shapedjs/shaper.go

@@ -152,18 +152,18 @@ func (sh *Shaper) adjustOutput(out *shaping.Output, fnt *text.Font, tx rich.Text
 	ng := len(out.Glyphs)
 	for gi := 0; gi < ng; gi++ {
 		g := &out.Glyphs[gi]
-		gri := g.ClusterIndex - rng.Start
+		gri := g.TextIndex() - rng.Start
 		// nrtx := len(rtx)
-		ed := gri + g.GlyphCount
+		ed := gri + g.GlyphsCount()
 		gtx := rtx[gri:ed]
 		gm := theGlyphCache.Glyph(ctx, fnt, tsty, gtx, g.GlyphID)
-		if g.GlyphCount > 1 {
-			gi += g.GlyphCount - 1
+		if g.GlyphsCount() > 1 {
+			gi += g.GlyphsCount() - 1
 		}
 		msz := gm.ActualBoundingBoxAscent + gm.ActualBoundingBoxDescent
 		mwd := -gm.ActualBoundingBoxLeft + gm.ActualBoundingBoxRight
 		// todo: conditional on vertical / horiz
-		g.XAdvance = math32.ToFixed(gm.Width)
+		g.Advance = math32.ToFixed(gm.Width)
 		g.Width = math32.ToFixed(mwd)
 		g.Height = -math32.ToFixed(msz)
 		g.XBearing = -math32.ToFixed(gm.ActualBoundingBoxLeft)