nefergui

type ButtonEvent ¶

type ButtonEvent = ui.ButtonEvent

ButtonEvent is an immutable snapshot queried with Activated. Alias methods are listed by go doc github.com/bnema/nefergui/internal/ui.ButtonEvent.

type ButtonOption ¶

type ButtonOption = ui.ButtonOption

Option families are sealed: ContainerOption, ButtonOption, EditOption, ValueOption and HeadingOption accept the common CSS options (Key, ID, Class, Inline) plus the control-specific options listed on each function.

type ChangeEvent ¶

type ChangeEvent = ui.ChangeEvent

ChangeEvent is an immutable snapshot queried with Changed. Alias methods are listed by go doc github.com/bnema/nefergui/internal/ui.ChangeEvent.

type Clipboard ¶ added in v0.5.0

type Clipboard = ui.Clipboard

Clipboard is an optional asynchronous clipboard; IME an optional input method.

type ContainerOption ¶

type ContainerOption = ui.ContainerOption

Option families are sealed: ContainerOption, ButtonOption, EditOption, ValueOption and HeadingOption accept the common CSS options (Key, ID, Class, Inline) plus the control-specific options listed on each function.

type Cursor ¶ added in v0.5.0

type Cursor = ui.Cursor

Cursor is the pointer shape the surface wants.

type EditEvent ¶

type EditEvent = ui.EditEvent

EditEvent is an immutable snapshot queried with Changed and Submitted. Alias methods are listed by go doc github.com/bnema/nefergui/internal/ui.EditEvent.

type EditOption ¶

type EditOption = ui.EditOption

Option families are sealed: ContainerOption, ButtonOption, EditOption, ValueOption and HeadingOption accept the common CSS options (Key, ID, Class, Inline) plus the control-specific options listed on each function.

func Password(v bool) EditOption

func Placeholder(v string) EditOption

type Format ¶ added in v0.5.0

type Format = ui.Format

Format is a DRM format and modifier the compositor accepts.

type Frame ¶

type Frame = ui.Frame

Frame is valid only during one call to the view function. Root builds the application element; Diagnostics reports identity problems in debug builds. Alias methods are listed by go doc github.com/bnema/nefergui/internal/ui.Frame.

type HeadingOption ¶

type HeadingOption = ui.HeadingOption

Option families are sealed: ContainerOption, ButtonOption, EditOption, ValueOption and HeadingOption accept the common CSS options (Key, ID, Class, Inline) plus the control-specific options listed on each function.

func Level(level int) HeadingOption

type IME ¶ added in v0.5.0

type IME = ui.IME

Clipboard is an optional asynchronous clipboard; IME an optional input method.

type Input ¶ added in v0.5.0

type Input = ui.Input

Input is one platform input event; Text is valid only during Renderer.Input.

type InputKind ¶ added in v0.2.0

type InputKind = ui.InputKind

InputKind classifies an Input; Modifiers is a bit set of held modifiers and latched Caps Lock and Num Lock state.

type Modifiers ¶ added in v0.2.0

type Modifiers = ui.Modifiers

InputKind classifies an Input; Modifiers is a bit set of held modifiers and latched Caps Lock and Num Lock state.

type Node ¶

type Node = ui.Node

Node is an ephemeral handle into the current frame. Do not retain it between frames. Container methods (Box, Row, Column, Stack, Scroll, Header, Nav, Main, Section, Aside, Footer, Element) return child nodes; control methods (Button, Checkbox, Radio, Slider, Input, Textarea, Text, Heading, Image, Icon, Separator, Spacer) declare controls. Interactive controls return event snapshots. Alias methods are listed by go doc github.com/bnema/nefergui/internal/ui.Node.

type Output ¶ added in v0.5.0

type Output = ui.Output

Output describes one frame to present, in physical pixels. All file descriptors stay owned by the Renderer: duplicate them before handing them to a transport that consumes descriptors. Slices are valid until the next Render.

type Plane ¶ added in v0.5.0

type Plane = ui.Plane

Plane, Timeline and Retired are parts of Output. A Timeline FD is valid only when Output.NewTimelines is set. The client must stop watching and destroy each Retired buffer before the next Render.

type Rect ¶ added in v0.2.0

type Rect = ui.Rect

Rect is an integer logical-pixel rectangle in surface coordinates, used by Frame.SetInputRects and Output.InputRects.

type Renderer ¶ added in v0.5.0

type Renderer = ui.Renderer

Renderer renders views into DMA-BUF buffers for a Wayland client the application owns. It imports no Wayland library, starts no goroutine and is used from one owner goroutine. Typical loop: forward Wayland events with Input and Resize, call Render when a redraw is needed, import and present the Output buffer, and call Released when its ReleaseFD becomes readable.

Pending() reports a built frame waiting for the GPU rather than the compositor; arm a short timer (about 2 ms) and call Render again.

Render is generic over the model type, so it is a generic method:

ok, err := r.Render(&out, &model, view)

Measure sizes a view before a surface exists (owner goroutine, not for every frame); it changes no Renderer state:

width, height, err := r.Measure(&model, view, maxWidth)

package main

import (
	"fmt"
	"log"

	"github.com/bnema/nefergui"
)

func main() {
	type model struct{ count int }
	view := func(f *nefergui.Frame, m *model) {
		root := f.Root().Column()
		root.Text("Hello, Wayland!")
		if root.Button("Count", nefergui.Key("count")).Activated() {
			m.count++
		}
		root.Text(fmt.Sprintf("Clicked %d times", m.count))
	}

	// mainDevice and formats come from the compositor's linux-dmabuf feedback.
	var (
		mainDevice uint64
		formats    []nefergui.Format
	)
	r, err := nefergui.NewRenderer(nefergui.RendererConfig{MainDevice: mainDevice, Formats: formats})
	if err != nil {
		log.Fatal(err)
	}
	defer r.Close()

	// Forward the surface size, then wire events as they arrive.
	r.Resize(320, 200, 1)
	r.Input(&nefergui.Input{Kind: nefergui.InputPointerMotion, X: 10, Y: 10})

	m := &model{}
	var out nefergui.Output
	// One iteration of the client loop; real clients repeat it forever.
	drawn, err := r.Render(&out, m, view)
	if err != nil {
		log.Fatal(err)
	}
	if drawn {
		// Import out.Planes as a wl_buffer when out.NewBuffer is set, attach
		// it with the Acquire/Release points, commit, and call r.Released
		// when out.ReleaseFD becomes readable.
		_ = out.Buffer
	}
	// Then sleep until a Wayland event, <-r.Wake(), or a short timer when
	// r.Pending() reports a frame waiting for the GPU.
}

Output:

func NewRenderer(cfg RendererConfig) (*Renderer, error)

type RendererConfig ¶ added in v0.5.0

type RendererConfig = ui.RendererConfig

RendererConfig configures NewRenderer. MainDevice and Formats come from the compositor's linux-dmabuf feedback.

type Retired ¶ added in v0.5.0

type Retired = ui.Retired

Plane, Timeline and Retired are parts of Output. A Timeline FD is valid only when Output.NewTimelines is set. The client must stop watching and destroy each Retired buffer before the next Render.

type Timeline ¶ added in v0.5.0

type Timeline = ui.Timeline

Plane, Timeline and Retired are parts of Output. A Timeline FD is valid only when Output.NewTimelines is set. The client must stop watching and destroy each Retired buffer before the next Render.

type ValueOption ¶

type ValueOption = ui.ValueOption

Option families are sealed: ContainerOption, ButtonOption, EditOption, ValueOption and HeadingOption accept the common CSS options (Key, ID, Class, Inline) plus the control-specific options listed on each function.