all: rename c to gtx for *layout.Context parameters

Short like `ctx` but not as easily confused with context.Context
values.

Suggested by Larry Clapp.

Signed-off-by: Elias Naur <mail@eliasnaur.com>

ui/layout/flex.go

@@ -68,12 +68,12 @@ const (
 )
 
 // Init must be called before Rigid or Flexible.
-func (f *Flex) Init(c *Context) *Flex {
+func (f *Flex) Init(gtx *Context) *Flex {
 	if f.mode > modeBegun {
 		panic("must End the current child before calling Init again")
 	}
 	f.mode = modeBegun
-	f.ctx = c
+	f.ctx = gtx
 	f.size = 0
 	f.rigidSize = 0
 	f.maxCross = 0

ui/layout/layout.go

@@ -133,12 +133,12 @@ type Inset struct {
 type Align Direction
 
 // Layout a widget.
-func (in Inset) Layout(c *Context, w Widget) {
-	top := c.Px(in.Top)
-	right := c.Px(in.Right)
-	bottom := c.Px(in.Bottom)
-	left := c.Px(in.Left)
-	mcs := c.Constraints
+func (in Inset) Layout(gtx *Context, w Widget) {
+	top := gtx.Px(in.Top)
+	right := gtx.Px(in.Right)
+	bottom := gtx.Px(in.Bottom)
+	left := gtx.Px(in.Left)
+	mcs := gtx.Constraints
 	mcs.Width.Min -= left + right
 	mcs.Width.Max -= left + right
 	if mcs.Width.Min < 0 {
@@ -156,12 +156,12 @@ func (in Inset) Layout(c *Context, w Widget) {
 		mcs.Height.Max = mcs.Height.Min
 	}
 	var stack ui.StackOp
-	stack.Push(c.Ops)
-	ui.TransformOp{}.Offset(toPointF(image.Point{X: left, Y: top})).Add(c.Ops)
-	dims := c.Layout(mcs, w)
+	stack.Push(gtx.Ops)
+	ui.TransformOp{}.Offset(toPointF(image.Point{X: left, Y: top})).Add(gtx.Ops)
+	dims := gtx.Layout(mcs, w)
 	stack.Pop()
-	c.Dimensions = Dimensions{
-		Size:     c.Constraints.Constrain(dims.Size.Add(image.Point{X: right + left, Y: top + bottom})),
+	gtx.Dimensions = Dimensions{
+		Size:     gtx.Constraints.Constrain(dims.Size.Add(image.Point{X: right + left, Y: top + bottom})),
 		Baseline: dims.Baseline + top,
 	}
 }
@@ -173,14 +173,14 @@ func UniformInset(v ui.Value) Inset {
 }
 
 // Layout a widget.
-func (a Align) Layout(c *Context, w Widget) {
+func (a Align) Layout(gtx *Context, w Widget) {
 	var macro ui.MacroOp
-	macro.Record(c.Ops)
-	cs := c.Constraints
+	macro.Record(gtx.Ops)
+	cs := gtx.Constraints
 	mcs := cs
 	mcs.Width.Min = 0
 	mcs.Height.Min = 0
-	dims := c.Layout(mcs, w)
+	dims := gtx.Layout(mcs, w)
 	macro.Stop()
 	sz := dims.Size
 	if sz.X < cs.Width.Min {
@@ -203,11 +203,11 @@ func (a Align) Layout(c *Context, w Widget) {
 		p.Y = sz.Y - dims.Size.Y
 	}
 	var stack ui.StackOp
-	stack.Push(c.Ops)
-	ui.TransformOp{}.Offset(toPointF(p)).Add(c.Ops)
-	macro.Add(c.Ops)
+	stack.Push(gtx.Ops)
+	ui.TransformOp{}.Offset(toPointF(p)).Add(gtx.Ops)
+	macro.Add(gtx.Ops)
 	stack.Pop()
-	c.Dimensions = Dimensions{
+	gtx.Dimensions = Dimensions{
 		Size:     sz,
 		Baseline: dims.Baseline,
 	}

ui/layout/list.go

@@ -67,11 +67,11 @@ const (
 const inf = 1e6
 
 // Init prepares the list for iterating through its children with Next.
-func (l *List) init(c *Context, len int) {
+func (l *List) init(gtx *Context, len int) {
 	if l.more() {
 		panic("unfinished child")
 	}
-	l.ctx = c
+	l.ctx = gtx
 	l.maxSize = 0
 	l.children = l.children[:0]
 	l.len = len
@@ -84,20 +84,20 @@ func (l *List) init(c *Context, len int) {
 		l.offset = 0
 		l.first = len
 	}
-	l.macro.Record(c.Ops)
+	l.macro.Record(gtx.Ops)
 	l.next()
 }
 
 // Layout the List and return its dimensions.
-func (l *List) Layout(c *Context, len int, w ListElement) {
-	for l.init(c, len); l.more(); l.next() {
+func (l *List) Layout(gtx *Context, len int, w ListElement) {
+	for l.init(gtx, len); l.more(); l.next() {
 		cs := axisConstraints(l.Axis, Constraint{Max: inf}, axisCrossConstraint(l.Axis, l.ctx.Constraints))
 		i := l.index()
-		l.end(c.Layout(cs, func() {
+		l.end(gtx.Layout(cs, func() {
 			w(i)
 		}))
 	}
-	c.Dimensions = l.layout()
+	gtx.Dimensions = l.layout()
 }
 
 func (l *List) scrollToEnd() bool {

ui/layout/stack.go

@@ -29,8 +29,8 @@ type StackChild struct {
 }
 
 // Init a stack before calling Rigid or Expand.
-func (s *Stack) Init(c *Context) *Stack {
-	s.ctx = c
+func (s *Stack) Init(gtx *Context) *Stack {
+	s.ctx = gtx
 	s.constrained = true
 	s.maxSZ = image.Point{}
 	s.baseline = 0

ui/text/editor.go

@@ -81,9 +81,9 @@ const (
 )
 
 // Next returns the next available editor event, or false if none are available.
-func (e *Editor) Next(c *layout.Context) (EditorEvent, bool) {
+func (e *Editor) Next(gtx *layout.Context) (EditorEvent, bool) {
 	// Crude configuration change detection.
-	if scale := c.Px(ui.Sp(100)); scale != e.oldScale {
+	if scale := gtx.Px(ui.Sp(100)); scale != e.oldScale {
 		e.invalidate()
 		e.oldScale = scale
 	}
@@ -97,7 +97,7 @@ func (e *Editor) Next(c *layout.Context) (EditorEvent, bool) {
 		axis = gesture.Vertical
 		smin, smax = sbounds.Min.Y, sbounds.Max.Y
 	}
-	sdist := e.scroller.Scroll(c.Config, c.Queue, axis)
+	sdist := e.scroller.Scroll(gtx.Config, gtx.Queue, axis)
 	var soff int
 	if e.SingleLine {
 		e.scrollOff.X += sdist
@@ -106,26 +106,26 @@ func (e *Editor) Next(c *layout.Context) (EditorEvent, bool) {
 		e.scrollOff.Y += sdist
 		soff = e.scrollOff.Y
 	}
-	for evt, ok := e.clicker.Next(c.Queue); ok; evt, ok = e.clicker.Next(c.Queue) {
+	for evt, ok := e.clicker.Next(gtx.Queue); ok; evt, ok = e.clicker.Next(gtx.Queue) {
 		switch {
 		case evt.Type == gesture.TypePress && evt.Source == pointer.Mouse,
 			evt.Type == gesture.TypeClick && evt.Source == pointer.Touch:
-			e.blinkStart = c.Now()
+			e.blinkStart = gtx.Now()
 			e.moveCoord(image.Point{
 				X: int(math.Round(float64(evt.Position.X))),
 				Y: int(math.Round(float64(evt.Position.Y))),
 			})
 			e.requestFocus = true
 			if e.scroller.State() != gesture.StateFlinging {
-				e.scrollToCaret(c)
+				e.scrollToCaret(gtx)
 			}
 		}
 	}
 	if (sdist > 0 && soff >= smax) || (sdist < 0 && soff <= smin) {
 		e.scroller.Stop()
 	}
-	for ke, ok := c.Queue.Next(e); ok; ke, ok = c.Queue.Next(e) {
-		e.blinkStart = c.Now()
+	for ke, ok := gtx.Queue.Next(e); ok; ke, ok = gtx.Queue.Next(e) {
+		e.blinkStart = gtx.Now()
 		switch ke := ke.(type) {
 		case key.FocusEvent:
 			e.focused = ke.Focus
@@ -139,11 +139,11 @@ func (e *Editor) Next(c *layout.Context) (EditorEvent, bool) {
 				}
 			}
 			if e.command(ke) {
-				e.scrollToCaret(c.Config)
+				e.scrollToCaret(gtx.Config)
 				e.scroller.Stop()
 			}
 		case key.EditEvent:
-			e.scrollToCaret(c)
+			e.scrollToCaret(gtx)
 			e.scroller.Stop()
 			e.append(ke.Text)
 		}
@@ -164,11 +164,11 @@ func (e *Editor) Focus() {
 	e.requestFocus = true
 }
 
-func (e *Editor) Layout(c *layout.Context) {
-	cs := c.Constraints
-	for _, ok := e.Next(c); ok; _, ok = e.Next(c) {
+func (e *Editor) Layout(gtx *layout.Context) {
+	cs := gtx.Constraints
+	for _, ok := e.Next(gtx); ok; _, ok = e.Next(gtx) {
 	}
-	twoDp := c.Px(ui.Dp(2))
+	twoDp := gtx.Px(ui.Dp(2))
 	e.padLeft, e.padRight = twoDp, twoDp
 	maxWidth := cs.Width.Max
 	if e.SingleLine {
@@ -196,7 +196,7 @@ func (e *Editor) Layout(c *layout.Context) {
 		Min: image.Point{X: 0, Y: 0},
 		Max: image.Point{X: e.viewSize.X, Y: e.viewSize.Y},
 	}
-	key.InputOp{Key: e, Focus: e.requestFocus}.Add(c.Ops)
+	key.InputOp{Key: e, Focus: e.requestFocus}.Add(gtx.Ops)
 	e.requestFocus = false
 	e.it = lineIterator{
 		Lines:     lines,
@@ -206,14 +206,14 @@ func (e *Editor) Layout(c *layout.Context) {
 		Offset:    off,
 	}
 	var stack ui.StackOp
-	stack.Push(c.Ops)
+	stack.Push(gtx.Ops)
 	// Apply material. Set a default color in case the material is empty.
 	if e.rr.len() > 0 {
-		paint.ColorOp{Color: color.RGBA{A: 0xff}}.Add(c.Ops)
-		e.Material.Add(c.Ops)
+		paint.ColorOp{Color: color.RGBA{A: 0xff}}.Add(gtx.Ops)
+		e.Material.Add(gtx.Ops)
 	} else {
-		paint.ColorOp{Color: color.RGBA{A: 0xaa}}.Add(c.Ops)
-		e.HintMaterial.Add(c.Ops)
+		paint.ColorOp{Color: color.RGBA{A: 0xaa}}.Add(gtx.Ops)
+		e.HintMaterial.Add(gtx.Ops)
 	}
 	for {
 		str, lineOff, ok := e.it.Next()
@@ -221,21 +221,21 @@ func (e *Editor) Layout(c *layout.Context) {
 			break
 		}
 		var stack ui.StackOp
-		stack.Push(c.Ops)
-		ui.TransformOp{}.Offset(lineOff).Add(c.Ops)
-		e.Face.Path(str).Add(c.Ops)
-		paint.PaintOp{Rect: toRectF(clip).Sub(lineOff)}.Add(c.Ops)
+		stack.Push(gtx.Ops)
+		ui.TransformOp{}.Offset(lineOff).Add(gtx.Ops)
+		e.Face.Path(str).Add(gtx.Ops)
+		paint.PaintOp{Rect: toRectF(clip).Sub(lineOff)}.Add(gtx.Ops)
 		stack.Pop()
 	}
 	if e.focused {
-		now := c.Now()
+		now := gtx.Now()
 		dt := now.Sub(e.blinkStart)
 		blinking := dt < maxBlinkDuration
 		const timePerBlink = time.Second / blinksPerSecond
 		nextBlink := now.Add(timePerBlink/2 - dt%(timePerBlink/2))
 		on := !blinking || dt%timePerBlink < timePerBlink/2
 		if on {
-			carWidth := e.caretWidth(c)
+			carWidth := e.caretWidth(gtx)
 			carX -= carWidth / 2
 			carAsc, carDesc := -lines[carLine].Bounds.Min.Y, lines[carLine].Bounds.Max.Y
 			carRect := image.Rectangle{
@@ -248,29 +248,29 @@ func (e *Editor) Layout(c *layout.Context) {
 			})
 			carRect = clip.Intersect(carRect)
 			if !carRect.Empty() {
-				paint.ColorOp{Color: color.RGBA{A: 0xff}}.Add(c.Ops)
-				e.Material.Add(c.Ops)
-				paint.PaintOp{Rect: toRectF(carRect)}.Add(c.Ops)
+				paint.ColorOp{Color: color.RGBA{A: 0xff}}.Add(gtx.Ops)
+				e.Material.Add(gtx.Ops)
+				paint.PaintOp{Rect: toRectF(carRect)}.Add(gtx.Ops)
 			}
 		}
 		if blinking {
 			redraw := ui.InvalidateOp{At: nextBlink}
-			redraw.Add(c.Ops)
+			redraw.Add(gtx.Ops)
 		}
 	}
 	stack.Pop()
 
 	baseline := e.padTop + e.dims.Baseline
-	pointerPadding := c.Px(ui.Dp(4))
+	pointerPadding := gtx.Px(ui.Dp(4))
 	r := image.Rectangle{Max: e.viewSize}
 	r.Min.X -= pointerPadding
 	r.Min.Y -= pointerPadding
 	r.Max.X += pointerPadding
 	r.Max.X += pointerPadding
-	pointer.RectAreaOp{Rect: r}.Add(c.Ops)
-	e.scroller.Add(c.Ops)
-	e.clicker.Add(c.Ops)
-	c.Dimensions = layout.Dimensions{Size: e.viewSize, Baseline: baseline}
+	pointer.RectAreaOp{Rect: r}.Add(gtx.Ops)
+	e.scroller.Add(gtx.Ops)
+	e.clicker.Add(gtx.Ops)
+	gtx.Dimensions = layout.Dimensions{Size: e.viewSize, Baseline: baseline}
 }
 
 // Text returns the contents of the editor.

ui/text/label.go

@@ -92,8 +92,8 @@ func (l *lineIterator) Next() (String, f32.Point, bool) {
 	return String{}, f32.Point{}, false
 }
 
-func (l Label) Layout(c *layout.Context) {
-	cs := c.Constraints
+func (l Label) Layout(gtx *layout.Context) {
+	cs := gtx.Constraints
 	textLayout := l.Face.Layout(l.Text, LayoutOptions{MaxWidth: cs.Width.Max})
 	lines := textLayout.Lines
 	if max := l.MaxLines; max > 0 && len(lines) > max {
@@ -119,16 +119,16 @@ func (l Label) Layout(c *layout.Context) {
 		}
 		lclip := toRectF(clip).Sub(off)
 		var stack ui.StackOp
-		stack.Push(c.Ops)
-		ui.TransformOp{}.Offset(off).Add(c.Ops)
-		l.Face.Path(str).Add(c.Ops)
+		stack.Push(gtx.Ops)
+		ui.TransformOp{}.Offset(off).Add(gtx.Ops)
+		l.Face.Path(str).Add(gtx.Ops)
 		// Set a default color in case the material is empty.
-		paint.ColorOp{Color: color.RGBA{A: 0xff}}.Add(c.Ops)
-		l.Material.Add(c.Ops)
-		paint.PaintOp{Rect: lclip}.Add(c.Ops)
+		paint.ColorOp{Color: color.RGBA{A: 0xff}}.Add(gtx.Ops)
+		l.Material.Add(gtx.Ops)
+		paint.PaintOp{Rect: lclip}.Add(gtx.Ops)
 		stack.Pop()
 	}
-	c.Dimensions = dims
+	gtx.Dimensions = dims
 }
 
 func toRectF(r image.Rectangle) f32.Rectangle {

ui/widget/image.go

@@ -25,17 +25,17 @@ type Image struct {
 	Scale float32
 }
 
-func (im Image) Layout(c *layout.Context) {
+func (im Image) Layout(gtx *layout.Context) {
 	size := im.Src.Bounds()
 	wf, hf := float32(size.Dx()), float32(size.Dy())
 	var w, h int
 	if im.Scale == 0 {
 		const dpPrPx = 160 / 72
-		w, h = c.Px(ui.Dp(wf*dpPrPx)), c.Px(ui.Dp(hf*dpPrPx))
+		w, h = gtx.Px(ui.Dp(wf*dpPrPx)), gtx.Px(ui.Dp(hf*dpPrPx))
 	} else {
 		w, h = int(wf*im.Scale+.5), int(hf*im.Scale+.5)
 	}
-	cs := c.Constraints
+	cs := gtx.Constraints
 	d := image.Point{X: cs.Width.Constrain(w), Y: cs.Height.Constrain(h)}
 	aspect := float32(w) / float32(h)
 	dw, dh := float32(d.X), float32(d.Y)
@@ -48,7 +48,7 @@ func (im Image) Layout(c *layout.Context) {
 	dr := f32.Rectangle{
 		Max: f32.Point{X: float32(d.X), Y: float32(d.Y)},
 	}
-	paint.ImageOp{Src: im.Src, Rect: im.Rect}.Add(c.Ops)
-	paint.PaintOp{Rect: dr}.Add(c.Ops)
-	c.Dimensions = layout.Dimensions{Size: d, Baseline: d.Y}
+	paint.ImageOp{Src: im.Src, Rect: im.Rect}.Add(gtx.Ops)
+	paint.PaintOp{Rect: dr}.Add(gtx.Ops)
+	gtx.Dimensions = layout.Dimensions{Size: d, Baseline: d.Y}
 }