layout

package
v1.4.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 13, 2026 License: MIT, Unlicense Imports: 11 Imported by: 6

Documentation

Index

Examples

Constants

This section is empty.

Variables

This section is empty.

Functions

func FPt 

func FPt(p image.Point) f32.Point

Types

type Alignment 

type Alignment uint8
const (
	Start Alignment = iota
	End
	Middle
	Baseline
)

func (Alignment) String 

func (a Alignment) String() string

type Axis 

type Axis uint8
const (
	Horizontal Axis = iota
	Vertical
)

func (Axis) Convert 

func (a Axis) Convert(pt image.Point) image.Point

func (Axis) FConvert 

func (a Axis) FConvert(pt f32.Point) f32.Point

func (Axis) String 

func (a Axis) String() string

type Background 

type Background struct{}
Example 
package main

import (
	"fmt"
	"image"

	"github.com/nanorele/gio/layout"
	"github.com/nanorele/gio/op"
)

func main() {
	gtx := layout.Context{
		Ops: new(op.Ops),
		Constraints: layout.Constraints{
			Max: image.Point{X: 100, Y: 100},
		},
	}

	layout.Background{}.Layout(gtx,

		func(gtx layout.Context) layout.Dimensions {
			fmt.Printf("Expand: %v\n", gtx.Constraints)
			return layoutWidget(gtx, 10, 10)
		},

		func(gtx layout.Context) layout.Dimensions {
			return layoutWidget(gtx, 50, 50)
		},
	)

}

func layoutWidget(ctx layout.Context, width, height int) layout.Dimensions {
	return layout.Dimensions{
		Size: image.Point{
			X: width,
			Y: height,
		},
	}
}

func (Background) Layout 

func (Background) Layout(gtx Context, background, widget Widget) Dimensions

type Constraints 

type Constraints struct {
	Min, Max image.Point
}

func Exact 

func Exact(size image.Point) Constraints

func (Constraints) AddMin 

func (c Constraints) AddMin(delta image.Point) Constraints

func (Constraints) Constrain 

func (c Constraints) Constrain(size image.Point) image.Point

func (Constraints) SubMax 

func (c Constraints) SubMax(delta image.Point) Constraints

type Context 

type Context struct {
	Constraints Constraints

	Metric unit.Metric

	Now time.Time

	Locale system.Locale

	Values map[string]any

	input.Source
	*op.Ops
}

func (Context) Disabled 

func (c Context) Disabled() Context

func (Context) Dp 

func (c Context) Dp(v unit.Dp) int

func (Context) Sp 

func (c Context) Sp(v unit.Sp) int

type Dimensions 

type Dimensions struct {
	Size     image.Point
	Baseline int
}

type Direction 

type Direction uint8
Example 
package main

import (
	"fmt"
	"image"

	"github.com/nanorele/gio/layout"
	"github.com/nanorele/gio/op"
)

func main() {
	gtx := layout.Context{
		Ops: new(op.Ops),

		Constraints: layout.Exact(image.Point{X: 100, Y: 100}),
	}

	dims := layout.Center.Layout(gtx, func(gtx layout.Context) layout.Dimensions {

		dims := layoutWidget(gtx, 50, 50)
		fmt.Println(dims.Size)
		return dims
	})

	fmt.Println(dims.Size)

}

func layoutWidget(ctx layout.Context, width, height int) layout.Dimensions {
	return layout.Dimensions{
		Size: image.Point{
			X: width,
			Y: height,
		},
	}
}

const (
	NW Direction = iota
	N
	NE
	E
	SE
	S
	SW
	W
	Center
)

func (Direction) Layout 

func (d Direction) Layout(gtx Context, w Widget) Dimensions

func (Direction) Position 

func (d Direction) Position(widget, bounds image.Point) image.Point

func (Direction) String 

func (d Direction) String() string

type Flex 

type Flex struct {
	Axis Axis

	Spacing Spacing

	Alignment Alignment

	WeightSum float32

	Gap int
}
Example 
package main

import (
	"fmt"
	"image"

	"github.com/nanorele/gio/layout"
	"github.com/nanorele/gio/op"
)

func main() {
	gtx := layout.Context{
		Ops: new(op.Ops),

		Constraints: layout.Exact(image.Point{X: 100, Y: 100}),
	}

	layout.Flex{WeightSum: 2}.Layout(gtx,

		layout.Rigid(func(gtx layout.Context) layout.Dimensions {
			fmt.Printf("Rigid: %v\n", gtx.Constraints)
			return layoutWidget(gtx, 10, 10)
		}),

		layout.Flexed(1, func(gtx layout.Context) layout.Dimensions {
			fmt.Printf("50%%: %v\n", gtx.Constraints)
			return layoutWidget(gtx, 10, 10)
		}),
	)

}

func layoutWidget(ctx layout.Context, width, height int) layout.Dimensions {
	return layout.Dimensions{
		Size: image.Point{
			X: width,
			Y: height,
		},
	}
}

func (Flex) Layout 

func (f Flex) Layout(gtx Context, children ...FlexChild) Dimensions

type FlexChild 

type FlexChild struct {
	// contains filtered or unexported fields
}

func Flexed 

func Flexed(weight float32, widget Widget) FlexChild

func Rigid 

func Rigid(widget Widget) FlexChild

type Inset 

type Inset struct {
	Top, Bottom, Left, Right unit.Dp
}
Example 
package main

import (
	"fmt"
	"image"

	"github.com/nanorele/gio/layout"
	"github.com/nanorele/gio/op"
)

func main() {
	gtx := layout.Context{
		Ops: new(op.Ops),

		Constraints: layout.Constraints{
			Max: image.Point{X: 100, Y: 100},
		},
	}

	inset := layout.UniformInset(10)
	dims := inset.Layout(gtx, func(gtx layout.Context) layout.Dimensions {

		dims := layoutWidget(gtx, 50, 50)
		fmt.Println(dims.Size)
		return dims
	})

	fmt.Println(dims.Size)

}

func layoutWidget(ctx layout.Context, width, height int) layout.Dimensions {
	return layout.Dimensions{
		Size: image.Point{
			X: width,
			Y: height,
		},
	}
}

func UniformInset 

func UniformInset(v unit.Dp) Inset

func (Inset) Layout 

func (in Inset) Layout(gtx Context, w Widget) Dimensions

type List 

type List struct {
	Axis Axis

	ScrollToEnd bool

	Alignment Alignment

	ScrollAnyAxis bool

	Gap int

	Position Position
	// contains filtered or unexported fields
}
Example 
package main

import (
	"fmt"
	"image"

	"github.com/nanorele/gio/layout"
	"github.com/nanorele/gio/op"
)

func main() {
	gtx := layout.Context{
		Ops: new(op.Ops),

		Constraints: layout.Exact(image.Point{X: 100, Y: 100}),
	}

	const listLen = 1e6

	var list layout.List
	list.Layout(gtx, listLen, func(gtx layout.Context, i int) layout.Dimensions {
		return layoutWidget(gtx, 20, 20)
	})

	fmt.Println(list.Position.Count)

}

func layoutWidget(ctx layout.Context, width, height int) layout.Dimensions {
	return layout.Dimensions{
		Size: image.Point{
			X: width,
			Y: height,
		},
	}
}

func (*List) Dragging 

func (l *List) Dragging() bool

func (*List) Layout 

func (l *List) Layout(gtx Context, len int, w ListElement) Dimensions

func (*List) ScrollBy 

func (l *List) ScrollBy(num float32)

func (*List) ScrollTo 

func (l *List) ScrollTo(n int)

func (*List) VisibleRange added in v1.4.0 

func (l *List) VisibleRange(gtx Context, len, itemSize int) (first, count int)

VisibleRange applies the current frame's scroll events to the list position and returns the index range [first, first+count) that a subsequent Layout call in the same frame is expected to produce. itemSize is the main-axis size of one element in pixels excluding Gap; pass 0 to derive it from the previous frame's average. With uniform element sizes the range is exact up to one element of slack on each side; with varying sizes it is an estimate. When no size information exists yet (first frame with itemSize 0), it returns the full range.

It lets callers warm up exactly the widgets about to be laid out (event handler prepass, column width measurement) instead of walking the whole model with heuristics based on the previous frame.

type ListElement 

type ListElement func(gtx Context, index int) Dimensions

type Position 

type Position struct {
	BeforeEnd bool

	First int

	Offset int

	OffsetLast int

	Count int

	Length int
}

type Spacer 

type Spacer struct {
	Width, Height unit.Dp
}

func (Spacer) Layout 

func (s Spacer) Layout(gtx Context) Dimensions

type Spacing 

type Spacing uint8
const (
	SpaceEnd Spacing = iota

	SpaceStart

	SpaceSides

	SpaceAround

	SpaceBetween

	SpaceEvenly
)

func (Spacing) String 

func (s Spacing) String() string

type Stack 

type Stack struct {
	Alignment Direction
}
Example 
package main

import (
	"fmt"
	"image"

	"github.com/nanorele/gio/layout"
	"github.com/nanorele/gio/op"
)

func main() {
	gtx := layout.Context{
		Ops: new(op.Ops),
		Constraints: layout.Constraints{
			Max: image.Point{X: 100, Y: 100},
		},
	}

	layout.Stack{}.Layout(gtx,

		layout.Expanded(func(gtx layout.Context) layout.Dimensions {
			fmt.Printf("Expand: %v\n", gtx.Constraints)
			return layoutWidget(gtx, 10, 10)
		}),

		layout.Stacked(func(gtx layout.Context) layout.Dimensions {
			return layoutWidget(gtx, 50, 50)
		}),
	)

}

func layoutWidget(ctx layout.Context, width, height int) layout.Dimensions {
	return layout.Dimensions{
		Size: image.Point{
			X: width,
			Y: height,
		},
	}
}

func (Stack) Layout 

func (s Stack) Layout(gtx Context, children ...StackChild) Dimensions

type StackChild 

type StackChild struct {
	// contains filtered or unexported fields
}

func Expanded 

func Expanded(w Widget) StackChild

func Stacked 

func Stacked(w Widget) StackChild

type Widget 

type Widget func(gtx Context) Dimensions

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.