README
¶
outlay
This package provides extra layouts for gio.
State
This package has no stable API, and should always be locked to a particular commit with go modules.
Layouts
Grid
This layout allows placement of many items in a grid with to several different strategies for wrapping across lines. For examples, run:
Radial
The radial layout allows you to lay out a set of widgets along an arc. The width and oritentation of the arc are configurable to allow for everything from a hand of cards to a full circle of widgets.
Known issues:
- The radial layout does not currently return correct dimensions for itself, which breaks most attempts to use it as part of a larger layout.
Documentation
¶
Overview ¶
Package outlay provides extra layouts for gio.
Index ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type Animation ¶
Animation holds state for an Animation between two states that is not invertible.
func (*Animation) Progress ¶
Progress returns the current progress through the animation as a value in the range [0,1]
func (*Animation) SetDuration ¶
type AxisPosition ¶
type AxisPosition struct {
// First and last are the indicies of the first and last visible
// cell on the axis.
First, Last int
// Offset is the pixel offset from the beginning of the first cell to
// the first visible pixel.
Offset int
// OffsetAbs is the estimated absolute position of the first visible
// pixel within the entire axis, mesaured in pixels.
OffsetAbs int
// Length is the estimated total size of the axis, measured in pixels.
Length int
}
AxisPosition describes the position of a viewport on a given axis.
type Cell ¶
type Cell func(gtx layout.Context, row, col int) layout.Dimensions
Cell is the layout function for a grid cell, with row,col parameters.
type Dimensioner ¶
Dimensioner is a function that provides the dimensions (in pixels) of an element on a given axis. The constraint parameter provides the size of the visible portion of the axis for applications that want it.
type Fan ¶
type Fan struct {
Animation
// The width, in radians, of the full arc that items should occupy.
// If zero, math.Pi/2 will be used (1/4 of a full circle).
WidthRadians float32
// The offset, in radians, above the X axis to apply before rendering the
// arc. This can be used with a value of Pi/4 to center an arc of width
// Pi/2. If zero, math.Pi/4 will be used (1/8 of a full circle). To get the
// equivalent of specifying zero, specify a value of 2*math.Pi.
OffsetRadians float32
// The radius of the hollow circle at the center of the fan. Leave nil to
// use the default heuristic of half the width of the widest item.
HollowRadius *unit.Dp
// contains filtered or unexported fields
}
type Flex ¶ added in v0.3.0
type Flex struct {
// Axis is the main axis, either Horizontal or Vertical.
Axis layout.Axis
// Spacing controls the distribution of space left after
// layout.
Spacing layout.Spacing
// Alignment is the alignment in the cross axis.
Alignment layout.Alignment
// WeightSum is the sum of weights used for the weighted
// size of Flexed children. If WeightSum is zero, the sum
// of all Flexed weights is used.
WeightSum float32
}
Flex lays out child elements along an axis, according to alignment, weights, and the configured system locale. It differs from gioui.org/layout.Flex by flipping the visual order of its children in RTL locales.
func (Flex) Layout ¶ added in v0.3.0
Layout a list of children. The position of the children are determined by the specified order, but Rigid children are laid out before Flexed children. If the locale of the gtx specifies a horizontal, RTL language, the children will be allocated space in the order that they are provided, but will be displayed in the inverse order to match RTL conventions.
type FlexChild ¶ added in v0.3.0
type FlexChild struct {
// contains filtered or unexported fields
}
FlexChild is the descriptor for a Flex child.
type Flow ¶
type Flow struct {
Num int
Axis layout.Axis
Alignment layout.Alignment
// contains filtered or unexported fields
}
Flow lays out at most Num elements along the main axis. The number of cross axis elements depend on the total number of elements.
func (*Flow) Layout ¶
func (g *Flow) Layout(gtx layout.Context, num int, el FlowElement) layout.Dimensions
type FlowElement ¶
type FlowElement func(gtx layout.Context, i int) layout.Dimensions
FlowElement lays out the ith element of a Grid.
type FlowWrap ¶
FlowWrap lays out as many elements as possible along the main axis before wrapping to the cross axis.
func (FlowWrap) Layout ¶
func (g FlowWrap) Layout(gtx layout.Context, num int, el FlowElement) layout.Dimensions
type Grid ¶
type Grid struct {
Vertical AxisPosition
Horizontal AxisPosition
Vscroll gesture.Scroll
Hscroll gesture.Scroll
// LockedRows is a quantity of rows (starting from row 0) to lock to
// the top of the grid's viewport. These rows will not be included in
// the indicies provided in the Vertical AxisPosition field.
LockedRows int
}
Grid provides a scrollable two dimensional viewport that efficiently lays out only content visible or nearly visible within the current viewport.
func (*Grid) Layout ¶
func (g *Grid) Layout(gtx layout.Context, rows, cols int, dimensioner Dimensioner, cellFunc Cell) layout.Dimensions
Layout the Grid.
type Inset ¶ added in v0.3.0
type Inset struct {
Top, Bottom unit.Dp
// Start and End refer to the visual start and end of the widget
// and surrounding area. In LTR locales, Start is left and End is
// right. In RTL locales the inverse in true.
Start, End unit.Dp
}
Inset adds space around a widget by decreasing its maximum constraints. The minimum constraints will be adjusted to ensure they do not exceed the maximum. Inset respects the system locale provided at layout time, and will swap start/end insets for RTL text. This differs from gioui.org/layout.Inset, which never swaps the sides contextually.
func UniformInset ¶ added in v0.3.0
UniformInset returns an Inset with a single inset applied to all edges.
type RigidRows ¶ added in v0.8.0
type RigidRows struct {
Axis layout.Axis
Alignment layout.Alignment
Spacing layout.Spacing
CrossSpacing layout.Spacing
CrossAlign layout.Alignment
}
RigidRows lays out a sequence of rigid widgets along Axis until it runs out of out space. It then makes a new row/column on the cross axis and fills that with widgets until it runs out there, repeating this process until all widgets are placed.
Source Files