bellui

package module
v1.0.0 Latest Latest
Warning

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

 Go to latest Published: Aug 6, 2026 License: BSD-3-Clause Imports: 20 Imported by: 0

README

About

Bellui is an easy-to-use UI toolkit and app API written in Go, for building applications that run on desktop and mobile devices from a single codebase.

Bellui began as a fork of the Fyne toolkit and diverges substantially from it; it is not intended to merge back. Highlights: a Material Design 3 theme system and component set, a reworked package architecture (geo/event/core as the source of truth for fundamental types), goroutine-safe widget APIs, and a GL rendering engine with canvas FBO, shadows, stencil clipping, and 3D support. See CLAUDE.md, docs/notes/ (per-area design detail) and ROADMAP.md for details. Module path: github.com/belluikit/bellui

Access note: the belluikit/* dependency repos are currently private. Building outside the org needs GOPRIVATE=github.com/belluikit/* and git credentials for GitHub (SSH, or a token with an insteadOf rewrite).

Prerequisites

To develop apps using Bellui you will need Go version 1.17 or later, a C compiler and your system's development tools. If you're not sure if that's all installed or you don't know how then check out our Getting Started document.

Rendering backend: this fork renders with WebGPU by default (Metal / Vulkan / D3D12 / browser WebGPU). The legacy OpenGL/GLES/WebGL backend remains available with the gl build tag (go build -tags gl ...). See docs/webgpu.md for build requirements and the platform matrix.

Using the standard go tools you can install Bellui's core library using:

go get github.com/belluikit/bellui@latest

After importing a new module, run the following command before compiling the code for the first time. Avoid running it before writing code that uses the module to prevent accidental removal of dependencies:

go mod tidy

Widget demo

To run a showcase of the features of this fork, build the MD3 gallery from the sibling repository:

git clone git@github.com:trendvidia/gallery.git
cd gallery && go run .

And you should see something like this (after you click a few buttons):

Bellui Demo Dark Theme

Or if you are using the light theme:

Bellui Demo Light Theme

And even running on a mobile device:

Bellui Demo Mobile Light Theme

Getting Started

Bellui is designed to be really easy to code with. If you have followed the prerequisite steps above then all you need is a Go IDE (or a text editor).

Open a new file and you're ready to write your first app!

package main

import (
	"github.com/belluikit/bellui/app"
	"github.com/belluikit/bellui/container"
	"github.com/belluikit/bellui/widget"
)

func main() {
	a := app.New()
	w := a.NewWindow("Hello")

	hello := widget.NewLabel("Hello Bellui!")
	w.SetContent(container.NewVBox(
		hello,
		widget.NewButton("Hi!", func() {
			hello.SetText("Welcome :)")
		}),
	))

	w.ShowAndRun()
}

And you can run that simply as:

go run main.go

[!NOTE]
The first compilation of Bellui on Windows can take up to 10 minutes, depending on your hardware. Subsequent builds will be fast.

It should look like this:

Bellui Hello Dark Theme Bellui Hello Dark Theme

Run in mobile simulation

There is a helpful mobile simulation mode that gives a hint of how your app would work on a mobile device:

go run -tags mobile main.go

Another option is to use bellui command, see Packaging for mobile.

Installing

Using go install will copy the executable into your go bin dir. To install the application with icons etc into your operating system's standard application location you can use the bellui utility and the "install" subcommand.

go install github.com/belluikit/bellui/cmd/bellui@latest
bellui install

Packaging for mobile

To run on a mobile device it is necessary to package up the application. To do this we can use the bellui utility "package" subcommand. You will need to add appropriate parameters as prompted, but the basic command is shown below. Once packaged you can install using the platform development tools or the bellui "install" subcommand.

bellui package -os android -appID my.domain.appname
bellui install -os android

The built Android application can run either in a real device or an Android emulator. However, building for iOS is slightly different. If the "-os" argument is "ios", it is build only for a real iOS device. Specify "-os" to "iossimulator" allows the application be able to run in an iOS simulator:

bellui package -os ios -appID my.domain.appname
bellui package -os iossimulator -appID my.domain.appname

Preparing a release

Using the bellui utility "release" subcommand you can package up your app for release to app stores and market places. Make sure you have the standard build tools installed and have followed the platform documentation for setting up accounts and signing. Then you can execute something like the following, notice the -os ios parameter allows building an iOS app from macOS computer. Other combinations work as well :)

$ bellui release -os ios -certificate "Apple Distribution" -profile "My App Distribution" -appID "com.example.myapp"

The above command will create a '.ipa' file that can then be uploaded to the iOS App Store.

Documentation

More documentation is available at the Bellui developer website or on pkg.go.dev.

Examples

The Bellui gallery is a Material Design 3 showcase covering every widget, theme and rendering feature in the toolkit — use it to explore the API and to manually verify changes.

The bellui_demo directory in this repository is a smaller, self-contained example app.

Shipping the Bellui Toolkit

All Bellui apps will work without pre-installed libraries, this is one reason the apps are so portable. However, if looking to support Bellui in a bigger way on your operating system then you can install some utilities that help to make a more complete experience.

Additional apps

It is recommended that you install the following additional apps:

app go install description
bellui_settings github.com/belluikit/bellui/cmd/bellui_settings A GUI for managing your global Bellui settings like theme and scaling

These are optional applications but can help to create a more complete desktop experience.

Documentation

Overview

Package bellui describes the objects and components available to any Bellui app. These can all be created, manipulated and tested without rendering (for speed). Your main package should use the app package to create an application with a default driver that will render your UI.

A simple application may look like this: 

package main

import "github.com/belluikit/bellui/app"
import "github.com/belluikit/bellui/container"
import "github.com/belluikit/bellui/widget"

func main() {
	a := app.New()
	w := a.NewWindow("Hello")

	hello := widget.NewLabel("Hello Bellui!")
	w.SetContent(container.NewVBox(
		hello,
		widget.NewButton("Hi!", func() {
			hello.SetText("Welcome :)")
		}),
	))

	bellui.ShowAndRun(w)
}

Package Organization

The root bellui package defines application-level interfaces and types. Fundamental types are in sub-packages:

This Package

Interfaces: App, Window, Driver, Theme

Shortcuts: Shortcutable, KeyboardShortcut, ShortcutHandler

Text: TextStyle, TextAlign, TextWrap, TextTruncation

Threading: Do, DoAndWait — schedule work on the main goroutine. Most widget methods (SetText, Enable, etc.) handle this internally.

Index

Constants

View Source 
const (
	// TextDirectionAuto is an alias for [DirectionAuto].
	//
	// Since: 2.8
	TextDirectionAuto = DirectionAuto
	// TextDirectionLTR is an alias for [DirectionLTR].
	//
	// Since: 2.8
	TextDirectionLTR = DirectionLTR
	// TextDirectionRTL is an alias for [DirectionRTL].
	//
	// Since: 2.8
	TextDirectionRTL = DirectionRTL
)
View Source 
const (
	// DefaultLineHeightScale is the default line-height multiplier (no scaling).
	DefaultLineHeightScale float32 = 1.0

	// DefaultLetterSpacing is the default letter spacing (no extra space).
	DefaultLetterSpacing float32 = 0
)
View Source 
const AnimationRepeatForever = -1

AnimationRepeatForever is an AnimationCount value that indicates it should not stop looping.

Since: 2.0

Variables

View Source 
var (
	// AnimationEaseInOut is the default easing, it starts slowly, accelerates to the middle and slows to the end.
	//
	// Since: 2.0
	AnimationEaseInOut = animationEaseInOut
	// AnimationEaseIn starts slowly and accelerates to the end.
	//
	// Since: 2.0
	AnimationEaseIn = animationEaseIn
	// AnimationEaseOut starts at speed and slows to the end.
	//
	// Since: 2.0
	AnimationEaseOut = animationEaseOut
	// AnimationLinear is a linear mapping for animations that progress uniformly through their duration.
	//
	// Since: 2.0
	AnimationLinear = animationLinear

	// AnimationEaseEmphasized is the MD3 emphasized easing — a two-phase cubic bezier
	// that accelerates then decelerates with different curves.
	AnimationEaseEmphasized AnimationCurve = animationEaseEmphasized

	// AnimationEaseStandard is the MD3 standard easing curve.
	AnimationEaseStandard AnimationCurve = animationEaseStandard

	// AnimationEaseStandardAccelerate is the MD3 accelerating curve for exit animations.
	AnimationEaseStandardAccelerate AnimationCurve = animationEaseStandardAccelerate

	// AnimationEaseStandardDecelerate is the MD3 decelerating curve for entrance animations.
	AnimationEaseStandardDecelerate AnimationCurve = animationEaseStandardDecelerate
)
View Source 
var ErrShareNotSupported = errors.New("sharing is not supported on this platform")

ErrShareNotSupported is returned by ShareText and ShareFile (and the SharerApp methods) when the current platform has no share surface — for example a plain desktop window manager, or a build without share support.

Functions

func AnnounceToScreenReader 

func AnnounceToScreenReader(text string, assertive bool)

AnnounceToScreenReader asks the current driver to speak a transient status message through a running screen reader, if the driver supports it. See AccessibilityAnnouncer. Call it on the main goroutine.

func ClipboardHTML 

func ClipboardHTML() (string, bool)

ClipboardHTML returns the HTML markup on the current app's clipboard. It returns ("", false) when no app is running, the clipboard does not support HTML (HTMLClipboard) or no HTML flavor is present.

Since: 1.0

func ClipboardImage 

func ClipboardImage() (image.Image, bool)

ClipboardImage returns the image on the current app's clipboard. It returns (nil, false) when no app is running, the clipboard does not support images (ImageClipboard) or no image is present.

Since: 1.0

func Do 

func Do(fn func())

Do is used to execute a specified function in the main Bellui runtime context without waiting. This is required when a background process wishes to adjust graphical elements of a running app. Developers should use this only from within goroutines they have created and when the result does not have to be waited for.

Since: 2.6

func DoAndWait 

func DoAndWait(fn func())

DoAndWait is used to execute a specified function in the main Bellui runtime context. This is required when a background process wishes to adjust graphical elements of a running app. Developers should use this only from within goroutines they have created.

Since: 2.6

func DoubleTapDelay 

func DoubleTapDelay() time.Duration

DoubleTapDelay returns the maximum duration where a second tap after a first one will be considered a double-tap. Falls back to 300ms if the driver doesn't implement DoubleTapDriver.

func IsHorizontal 

func IsHorizontal(orient DeviceOrientation) bool

IsHorizontal is a helper utility that determines if a passed orientation is horizontal

func IsMainGoroutine 

func IsMainGoroutine() bool

IsMainGoroutine reports whether the caller is running on the main (GUI) goroutine.

The desktop and mobile drivers register the main goroutine during app initialization, so this is meaningful in the real run path. When no main goroutine has been registered (e.g. in some unit-test setups), it reports true.

Use this to branch between running work inline and marshalling it onto the main goroutine with Do or DoAndWait. RunOnMain composes the two for the common "run on main, inline if already there" case.

Since: 1.0

func IsVertical 

func IsVertical(orient DeviceOrientation) bool

IsVertical is a helper utility that determines if a passed orientation is vertical

func LogError 

func LogError(reason string, err error)

LogError reports an error to the command line with the specified err cause, if not nil. The function also reports basic information about the code location.

func MeasureText 

func MeasureText(text string, size float32, style TextStyle) geo.Size

MeasureText uses the current driver to calculate the size of text when rendered. The font used will be read from the current app's theme.

If no app is running, falls back to the registered text measurement function (registered automatically when the painter package is imported).

func MeasureTextFull 

func MeasureTextFull(text string, fontSize float32, style TextStyle, source Resource) (geo.Size, float32)

MeasureTextFull measures text and returns both the rendered size and the baseline offset (distance from the top to the text baseline). The source parameter specifies a custom font resource; pass nil to use the theme font.

Like MeasureText, this works with or without a running app.

func OpenURL 

func OpenURL(url *url.URL) error

OpenURL opens a URL in the default browser application.

func Pref 

func Pref[T PreferenceType](p Preferences, key string) (T, bool)

Pref retrieves a typed value from preferences. Returns (value, true) if found and type-compatible, or (zero, false) otherwise. Handles JSON deserialization coercion between int and float64.

func PrefList 

func PrefList[T bool | int | float64 | string](p Preferences, key string) ([]T, bool)

PrefList retrieves a typed list value from preferences. Handles JSON deserialization coercion ([]any -> typed slice, []float64 <-> []int).

func PrefListOr 

func PrefListOr[T bool | int | float64 | string](p Preferences, key string, fallback []T) []T

PrefListOr retrieves a typed list from preferences, returning fallback if not found.

func PrefOr 

func PrefOr[T PreferenceType](p Preferences, key string, fallback T) T

PrefOr retrieves a typed value from preferences, returning fallback if the key is missing or the value is not type-compatible.

func Ptr 

func Ptr[T any](v T) *T

Ptr returns a pointer to v. It is a convenience for setting pointer fields in struct literals, e.g. bellui.TextStyle{Weight: bellui.Ptr(bellui.WeightBold)}.

func RegisterFontFallback 

func RegisterFontFallback(res Resource)

RegisterFontFallback adds res to the global font fallback chain. When the active font (and the theme's own fallbacks) lack a glyph for a rune, the registered fallback faces are consulted in registration order before any system-font scan.

This is the portable way to add coverage for scripts the bundled fonts do not include — most commonly CJK. Unlike system-font scanning it works on every platform, including WebAssembly, where there are no scannable system fonts, so a compiled-in fallback is the only way to render such scripts in the browser.

Register fallbacks once at startup, before building the UI. Registering after text has been measured is supported but invalidates the font caches.

Since: 1.0

func RegisterLayoutDirectionRefresh 

func RegisterLayoutDirectionRefresh(fn func())

RegisterLayoutDirectionRefresh registers the callback that SetLayoutDirection invokes when the active direction changes, so the app can re-lay-out and repaint its running windows. It is called automatically by the app package; applications do not need to call it.

func RegisterTextMeasure 

func RegisterTextMeasure(fn textMeasureFunc)

RegisterTextMeasure registers a fallback text measurement function. This is called automatically by the painter package on import.

func RunOnMain 

func RunOnMain(fn func())

RunOnMain runs fn on the main (GUI) goroutine and waits for it to complete. If the caller is already on the main goroutine — or no running app/driver is available (e.g. in unit tests) — fn runs inline. Otherwise it is dispatched via DoAndWait.

This is the safe primitive for code that may already be on the main goroutine: unlike calling DoAndWait directly, it never logs a "called from main goroutine" diagnostic or re-runs fn on a fresh goroutine. Prefer it when a single entry point is reached both from UI event handlers (already on main) and from background goroutines.

Since: 1.0

func SendNotification 

func SendNotification(n *Notification)

SendNotification sends a system notification via the current app, if it supports notifications.

func SendNotificationWithOptions 

func SendNotificationWithOptions(n *NotificationOptions) bool

SendNotificationWithOptions sends a rich system notification (click activation, action buttons, custom icon) via the current app if it implements NotifierWithOptionsApp. If the app supports only plain notifications the call falls back to a basic title-and-content notification so it is never silently dropped; the callbacks and actions are lost in that case. It reports whether the rich form was delivered.

Since: 1.0

func SetClipboardFiles 

func SetClipboardFiles(files []URI) bool

SetClipboardFiles places the given files on the current app's clipboard. It reports whether the clipboard supports file lists (FileClipboard) — when false nothing was written.

Since: 1.0

func SetClipboardFlavors 

func SetClipboardFlavors(content ClipboardContent) bool

SetClipboardFlavors places every set flavor of content on the current app's clipboard as one transaction. It reports whether the clipboard supports multi-flavor writes (MultiFlavorClipboard) — when false nothing was written.

Since: 1.0

func SetClipboardHTML 

func SetClipboardHTML(html, plainFallback string) bool

SetClipboardHTML places html on the current app's clipboard with plainFallback as the plain-text flavor of the same transaction. It reports whether the clipboard supports HTML (HTMLClipboard) — when false nothing was written.

Since: 1.0

func SetClipboardImage 

func SetClipboardImage(img image.Image) bool

SetClipboardImage places img on the current app's clipboard. It reports whether the clipboard supports images (ImageClipboard) — when false nothing was written.

Since: 1.0

func SetCurrentApp 

func SetCurrentApp(current App)

SetCurrentApp is an internal function to set the app instance currently running.

func SetFontFallbackRegister 

func SetFontFallbackRegister(fn func(Resource))

SetFontFallbackRegister wires the painter's fallback registration in. It is called automatically by the painter package on import and is not intended for application use.

func SetLayoutDirection 

func SetLayoutDirection(d Direction)

SetLayoutDirection overrides the process-wide user-interface direction. It governs both layout mirroring (horizontal containers and leading/trailing alignment) and the default base writing direction of text — a TextStyle left at DirectionAuto follows this setting. Passing DirectionAuto (the default) restores locale-based detection.

When the direction actually changes and an app is running, every running window is re-laid-out and repainted, the way a theme change is applied; this follows the same threading rules as Settings.SetTheme, so call it on the main goroutine. If no app is running the new direction simply takes effect for UI built or refreshed afterwards.

Since: 2.8

func SetPref 

func SetPref[T PreferenceType](p Preferences, key string, value T)

SetPref saves a typed value to preferences.

func SetPrefList 

func SetPrefList[T bool | int | float64 | string](p Preferences, key string, value []T)

SetPrefList saves a typed list to preferences.

func ShareFile 

func ShareFile(uri URI) error

ShareFile offers a file to the operating system's share UI via the current app. The URI must use the "file" scheme. It returns ErrShareNotSupported if the platform has no share surface.

func ShareText 

func ShareText(text string) error

ShareText offers text to the operating system's share UI via the current app. It returns ErrShareNotSupported if the platform has no share surface.

func ShowAndRun 

func ShowAndRun(w Window)

ShowAndRun shows a window and starts the application event loop. This is a convenience function equivalent to calling w.Show() followed by app.Run().

Types

type AccessibilityAnnouncer 

type AccessibilityAnnouncer interface {
	AnnounceToScreenReader(text string, assertive bool)
}

AccessibilityAnnouncer is an optional interface that a Driver can implement to push a transient status message to a running screen reader (a "live region" announcement). Widgets whose text appears without the user navigating to it — toasts, snackbars, status updates — use it so the message is spoken before it auto-dismisses; applications can call it via AnnounceToScreenReader for their own transient status.

assertive requests that the message interrupt current speech; polite (false) queues it after. The call is a no-op when the toolkit was built without the `accessibility` tag or no screen-reader backend is active.

type Animation 

type Animation struct {
	AutoReverse bool
	Curve       AnimationCurve
	Duration    time.Duration
	RepeatCount int
	Tick        func(float32)
}

Animation represents an animated element within a Bellui canvas. These animations may control individual objects or entire scenes.

Since: 2.0

func NewAnimation 

func NewAnimation(d time.Duration, fn func(float32)) *Animation

NewAnimation creates a very basic animation where the callback function will be called for every rendered frame between time.Now and the specified duration. The callback values start at 0.0 and will be 1.0 when the animation completes.

Since: 2.0

func (*Animation) Start 

func (a *Animation) Start()

Start registers the animation with the application run-loop and starts its execution.

func (*Animation) Stop 

func (a *Animation) Stop()

Stop will end this animation and remove it from the run-loop.

type AnimationCurve 

type AnimationCurve func(float32) float32

AnimationCurve represents an animation algorithm for calculating the progress through a timeline. Custom animations can be provided by implementing the "func(float32) float32" definition. The input parameter will start at 0.0 when an animation starts and travel up to 1.0 at which point it will end. A linear animation would return the same output value as is passed in.

type App 

type App interface {
	// Create a new window for the application.
	// The first window to open is considered the "master" and when closed
	// the application will exit.
	//
	// How additional windows are presented depends on the platform:
	//   - Desktop: each window is a real, independent OS window; any number
	//     can be shown concurrently.
	//   - Web (wasm): the first window owns the single browser canvas;
	//     additional windows are shown as draggable in-canvas windows overlaid
	//     on it (there is one HTML canvas, so they cannot be separate OS
	//     windows).
	//   - Mobile: windows form a stack and only the topmost visible one is
	//     shown at a time. Opening a window covers the previous one; closing it
	//     reveals the previous again.
	NewWindow(title string) Window

	// Icon returns the application icon, this is used in various ways
	// depending on operating system.
	// This is also the default icon for new windows.
	Icon() Resource

	// SetIcon sets the icon resource used for this application instance.
	SetIcon(Resource)

	// Run the application - this starts the event loop and waits until [App.Quit]
	// is called or the last window closes.
	// This should be called near the end of a main() function as it will block.
	Run()

	// Calling Quit on the application will cause the application to exit
	// cleanly, closing all open windows.
	// This function does no thing on a mobile device as the application lifecycle is
	// managed by the operating system.
	Quit()

	// Driver returns the driver that is rendering this application.
	// Typically not needed for day to day work, mostly internal functionality.
	Driver() Driver

	// UniqueID returns the application unique identifier, if set.
	// This must be set for use of the [App.Preferences]. see [NewWithID].
	UniqueID() string

	// Settings return the globally set settings, determining theme and so on.
	Settings() Settings

	// Preferences returns the application preferences, used for storing configuration and state
	Preferences() Preferences

	// Storage returns a storage handler specific to this application.
	Storage() Storage

	// Lifecycle returns a type that allows apps to hook in to lifecycle events.
	//
	// Since: 2.1
	Lifecycle() Lifecycle

	// Metadata returns the application metadata that was set at compile time.
	// The items of metadata are available after "bellui package" or when running "go run"
	// Building with "go build" may cause this to be unavailable.
	//
	// Since: 2.2
	Metadata() AppMetadata

	// Clipboard returns the system clipboard.
	//
	// Since: 2.6
	Clipboard() Clipboard
}

An App is the definition of a graphical application. Apps can have multiple windows, by default they will exit when all windows have been closed. This can be modified using SetMaster or SetCloseIntercept. To start an application you need to call Run somewhere in your main function. Alternatively use the ShowAndRun function for your main window.

func CurrentApp 

func CurrentApp() App

CurrentApp returns the current application, for which there is only 1 per process.

type AppMetadata 

type AppMetadata struct {
	// ID is the unique ID of this application, used by many distribution platforms.
	ID string
	// Name is the human friendly name of this app.
	Name string
	// Version represents the version of this application, normally following semantic versioning.
	Version string
	// Build is the build number of this app, some times appended to the version number.
	Build int
	// Icon contains, if present, a resource of the icon that was bundled at build time.
	Icon Resource
	// Release if true this binary was build in release mode
	// Since: 2.3
	Release bool
	// Custom contain the custom metadata defined either in manifest.pxf or on the compile command line
	// Since: 2.3
	Custom map[string]string
	// Migrations allows an app to opt into features before they are standard
	// Since: 2.6
	Migrations map[string]bool
}

AppMetadata captures the build metadata for an application.

Since: 2.2

type BadgeApp 

type BadgeApp interface {
	// SetBadge sets the numeric badge on the app icon. A count of 0 (or less)
	// clears the badge. Call on the main goroutine.
	SetBadge(count int)
}

BadgeApp is an optional interface that an App can implement to display a count badge on its icon in the OS launcher: the dock icon on macOS, the taskbar button on Windows, and the launcher entry on Linux desktops that support the Unity LauncherEntry protocol (KDE and others).

It is best-effort — desktops without a badge affordance silently ignore it — and only implemented on desktop platforms; mobile and web apps do not satisfy this interface.

Since: 1.0

type BuildType 

type BuildType int

BuildType defines different modes that an application can be built using. 

const (
	// BuildStandard is the normal build mode - it is not debug, test or release mode.
	BuildStandard BuildType = iota
	// BuildDebug is used when a developer would like more information and visual output for app debugging.
	BuildDebug
	// BuildRelease is a final production build, it is like [BuildStandard] but will use distribution certificates.
	// A release build is typically going to connect to live services and is not usually used during development.
	BuildRelease
)

type Clipboard 

type Clipboard interface {
	// Content returns the clipboard content
	Content() string
	// SetContent sets the clipboard content
	SetContent(content string)
}

Clipboard represents the system clipboard interface

type ClipboardContent 

type ClipboardContent struct {
	// Text is the plain-text flavor, doubling as the fallback for
	// applications that cannot paste any of the richer flavors.
	// Clipboard.Content reports it after the write.
	Text string
	// HTML is the HTML markup flavor.
	HTML string
	// Image is the raster image flavor.
	Image image.Image
	// Files is the file-list flavor. Only file-scheme URIs can be placed on
	// the system clipboard; others are skipped with a logged error.
	Files []URI
}

ClipboardContent describes a multi-flavor clipboard payload: alternative representations of one logical content, written together in a single clipboard transaction by MultiFlavorClipboard.SetFlavors. Zero-valued fields are omitted from the transaction; a wholly zero value clears the clipboard.

Since: 1.0

type CloudApp 

type CloudApp interface {
	// CloudProvider returns the current app cloud provider,
	// if one has been registered by the developer or chosen by the user.
	CloudProvider() CloudProvider
	// SetCloudProvider allows developers to specify how this application should integrate with cloud services.
	SetCloudProvider(CloudProvider)
}

CloudApp is an optional interface that an App can implement to support cloud services.

type CloudProvider 

type CloudProvider interface {
	// ProviderDescription returns a more detailed description of this cloud provider.
	ProviderDescription() string
	// ProviderIcon returns an icon resource that is associated with the given cloud service.
	ProviderIcon() Resource
	// ProviderName returns the name of this cloud provider, usually the name of the service it uses.
	ProviderName() string

	// Cleanup is called when this provider is no longer used and should be disposed.
	// This is guaranteed to execute before a new provider is `Setup`
	Cleanup(App)
	// Setup is called when this provider is being used for the first time.
	// Returning an error will exit the cloud setup process, though it can be retried.
	Setup(App) error
}

CloudProvider specifies the identifying information of a cloud provider. This information is mostly used by the fyne.io/cloud.ShowSettings user flow.

Since: 2.3

type CloudProviderPreferences 

type CloudProviderPreferences interface {
	// CloudPreferences returns a preference provider that will sync values to the cloud this provider uses.
	CloudPreferences(App) Preferences
}

CloudProviderPreferences interface defines the functionality that a cloud provider will include if it is capable of synchronizing user preferences.

Since: 2.3

type CloudProviderStorage 

type CloudProviderStorage interface {
	// CloudStorage returns a storage provider that will sync documents to the cloud this provider uses.
	CloudStorage(App) Storage
}

CloudProviderStorage interface defines the functionality that a cloud provider will include if it is capable of synchronizing user documents.

Since: 2.3

type Container 

type Container struct {
	Hidden bool // Is this Container hidden

	Layout       core.Layout         // The Layout algorithm for arranging child [core.CanvasObject]s
	Objects      []core.CanvasObject // The set of [core.CanvasObject]s this container holds
	ClipToBounds bool                // When true, children are clipped to the container's bounds
	// contains filtered or unexported fields
}

Container is a core.CanvasObject that contains a collection of child objects. The layout of the children is set by the specified Layout.

func (*Container) Add 

func (c *Container) Add(add core.CanvasObject)

Add appends the specified object to the items this container manages. It is safe to call from any goroutine.

Since: 1.4

func (*Container) Hide 

func (c *Container) Hide()

Hide sets this container, and all its children, to be not visible.

func (*Container) MinSize 

func (c *Container) MinSize() geo.Size

MinSize calculates the minimum size of c. This is delegated to the Container.Layout, if specified, otherwise it will be calculated.

func (*Container) Move 

func (c *Container) Move(pos geo.Position)

Move the container (and all its children) to a new position, relative to its parent.

func (*Container) Position 

func (c *Container) Position() geo.Position

Position gets the current position of c relative to its parent.

func (*Container) Refresh 

func (c *Container) Refresh()

Refresh causes this object to be redrawn in its current state

func (*Container) Remove 

func (c *Container) Remove(rem core.CanvasObject)

Remove updates the contents of this container to no longer include the specified object. This method is not intended to be used inside a loop, to remove all the elements. It is much more efficient to call [Container.RemoveAll) instead.

func (*Container) RemoveAll 

func (c *Container) RemoveAll()

RemoveAll updates the contents of this container to no longer include any objects.

Since: 2.2

func (*Container) Resize 

func (c *Container) Resize(size geo.Size)

Resize sets a new size for c.

func (*Container) Show 

func (c *Container) Show()

Show sets this container, and all its children, to be visible.

func (*Container) Size 

func (c *Container) Size() geo.Size

Size returns the current size c.

func (*Container) Visible 

func (c *Container) Visible() bool

Visible returns true if the container is currently visible, false otherwise.

type Device 

type Device interface {
	Orientation() DeviceOrientation
	IsMobile() bool
	IsBrowser() bool
	HasKeyboard() bool
	SystemScaleForWindow(Window) float32

	// Locale returns the information about this device's language and region.
	//
	// Since: 2.5
	Locale() Locale
}

Device provides information about the devices the code is running on

func CurrentDevice 

func CurrentDevice() Device

CurrentDevice returns the device information for the current hardware (via the driver)

type DeviceOrientation 

type DeviceOrientation int

DeviceOrientation represents the different ways that a mobile device can be held 

const (
	// OrientationVertical is the default vertical orientation
	OrientationVertical DeviceOrientation = iota
	// OrientationVerticalUpsideDown is the portrait orientation held upside down
	OrientationVerticalUpsideDown
	// OrientationHorizontalLeft is used to indicate a landscape orientation with the top to the left
	OrientationHorizontalLeft
	// OrientationHorizontalRight is used to indicate a landscape orientation with the top to the right
	OrientationHorizontalRight
)

type Direction 

type Direction int

Direction represents a left-to-right or right-to-left reading/flow direction. It is the single concept behind both the user-interface layout direction (see SetLayoutDirection, which mirrors horizontal containers and resolves leading/trailing alignment) and the base writing direction of text (see TextStyle.Direction via the TextDirection alias).

Since: 2.8 

const (
	// DirectionAuto derives the direction from the ambient user-interface
	// direction: the [SetLayoutDirection] override when set, otherwise the
	// active locale (right-to-left for Arabic, Hebrew and similar locales). It
	// is the default (zero) value.
	//
	// Since: 2.8
	DirectionAuto Direction = iota
	// DirectionLTR forces a left-to-right direction regardless of locale.
	//
	// Since: 2.8
	DirectionLTR
	// DirectionRTL forces a right-to-left direction regardless of locale.
	//
	// Since: 2.8
	DirectionRTL
)

func CurrentLayoutDirection 

func CurrentLayoutDirection() Direction

CurrentLayoutDirection returns the process-wide user-interface direction setting as configured by SetLayoutDirection. The default is DirectionAuto, which defers to the active locale; use lang.IsRTLDirection for the resolved right-to-left boolean.

Since: 2.8

type DoubleTapDriver 

type DoubleTapDriver interface {
	DoubleTapDelay() time.Duration
}

DoubleTapDriver is an optional interface that a Driver can implement to report the maximum duration for double-tap recognition.

type DragHoverEvent 

type DragHoverEvent struct {
	// AbsolutePosition is the pointer position relative to the window canvas.
	AbsolutePosition geo.Position
	// Position is the pointer position relative to the receiving object.
	Position geo.Position
}

DragHoverEvent carries the pointer position while a drag from outside the application is in progress over a DropHoverable.

It intentionally carries only the position, not the dragged items: the desktop drag protocols do not make the payload available before the drop, so the items arrive only with the final DropEvent.

Since: 1.0

type Driver 

type Driver interface {
	// CreateWindow creates a new UI Window for a certain implementation.
	// Developers should use [App.NewWindow].
	CreateWindow(string) Window
	// AllWindows returns a slice containing all app windows.
	AllWindows() []Window

	// RenderedTextSize returns the size required to render the given string of specified
	// font size and style. It also returns the height to text baseline, measured from the top.
	// If the source is specified it will be used, otherwise the current theme will be asked for the font.
	RenderedTextSize(text string, fontSize float32, style TextStyle, source Resource) (size geo.Size, baseline float32)

	// CanvasForObject returns the canvas that is associated with a given [core.CanvasObject].
	CanvasForObject(core.CanvasObject) core.Canvas
	// AbsolutePositionForObject returns the position of a given [core.CanvasObject] relative to the top/left of a canvas.
	AbsolutePositionForObject(core.CanvasObject) geo.Position

	// Device returns the device that the application is currently running on.
	Device() Device
	// Run starts the main event loop of the driver.
	Run()
	// Quit closes the driver and open windows, then exit the application.
	// On some operating systems this does nothing, for example iOS and Android.
	Quit()

	// StartAnimation registers a new animation with this driver and requests it be started.
	// Developers should use the [Animation.Start] function.
	StartAnimation(*Animation)
	// StopAnimation stops an animation and unregisters from this driver.
	// Developers should use the [Animation.Stop] function.
	StopAnimation(*Animation)

	// DoFromGoroutine provides a way to queue a function `fn` that is running on a goroutine back to
	// the central thread for Bellui updates, waiting for it to return if `wait` is true.
	// The driver provides the implementation normally accessed through [bellui.Do].
	// This is required when background tasks want to execute code safely in the graphical context.
	//
	// Since: 2.6
	DoFromGoroutine(fn func(), wait bool)
}

Driver defines an abstract concept of a Bellui render driver. Any implementation must provide at least these methods.

type DropEvent 

type DropEvent struct {
	// AbsolutePosition is the drop position relative to the window canvas.
	AbsolutePosition geo.Position
	// Position is the drop position relative to the receiving object.
	Position geo.Position
	// URIs are the dropped items. On desktop these are file URIs (the platform
	// backend delivers dropped file paths).
	URIs []URI
}

DropEvent carries the items dropped onto a Droppable target along with the drop position.

Since: 1.0

type DropHoverable 

type DropHoverable interface {
	Droppable

	// DragEnter is called when an external drag first reaches this object.
	DragEnter(*DragHoverEvent)
	// DragOver is called as an external drag moves within this object.
	DragOver(*DragHoverEvent)
	// DragLeave is called when an external drag moves off this object, leaves
	// the window, or ends.
	DragLeave()
}

DropHoverable is an optional companion to Droppable that a [CanvasObject] can implement to receive hover feedback while an external drag is in progress over it, before the drop — for example to highlight a drop zone.

The driver routes hover to the deepest DropHoverable under the pointer: DropHoverable.DragEnter when the drag first reaches the object, DropHoverable.DragOver as it moves within, and DropHoverable.DragLeave when it moves off the object, leaves the window, or the drag ends without a drop on this object. A drop is still delivered through Droppable.Dropped (after which DragLeave also fires so the object can clear its highlight).

Drag-motion is delivered only on desktop backends whose native drag protocol exposes it (X11 XDND, macOS and Windows OLE); where it is unavailable the object still receives Droppable.Dropped, just without the hover phases.

Since: 1.0

type Droppable 

type Droppable interface {
	// Dropped is called when one or more items are dropped onto this object.
	Dropped(*DropEvent)
}

Droppable is an optional interface that a [CanvasObject] can implement to receive items dropped onto it from outside the application — for example files dragged from the desktop file manager.

The driver routes a drop to the deepest Droppable under the pointer; a drop not claimed by any Droppable falls back to the window-wide DroppableWindow.SetOnDropped callback, which therefore keeps working unchanged.

A Droppable may additionally implement DropHoverable to receive drag-enter/over/leave hover feedback while a drag is in progress over it.

Since: 1.0

type DroppableWindow 

type DroppableWindow interface {
	// SetOnDropped allows setting a window-wide callback to receive dropped items.
	SetOnDropped(func(geo.Position, []URI))
}

DroppableWindow is an optional interface that a Window can implement to receive dropped items.

type FileClipboard 

type FileClipboard interface {
	// Files returns the list of files on the clipboard, or nil when the
	// clipboard holds no files.
	Files() []URI
	// SetFiles replaces the clipboard content with the given files.
	// Only file-scheme URIs can be placed on the system clipboard.
	SetFiles(files []URI)
}

FileClipboard is an optional interface a Clipboard can implement to carry lists of files, interoperating with copy/paste in the platform file manager. Assert it on the value returned by App.Clipboard; on platforms without file clipboard support the assertion fails.

Since: 1.0

type HTMLClipboard 

type HTMLClipboard interface {
	// HTML returns the HTML markup on the clipboard, or ("", false) when the
	// clipboard holds no HTML flavor.
	HTML() (string, bool)
	// SetHTML replaces the clipboard content with html, writing plainFallback
	// as the plain-text flavor of the same transaction so applications that
	// cannot paste rich text receive the fallback. Content() reports
	// plainFallback afterwards.
	SetHTML(html, plainFallback string)
}

HTMLClipboard is an optional interface a Clipboard can implement to carry an HTML flavor alongside plain text. Assert it on the value returned by App.Clipboard; on platforms without rich clipboard support the assertion fails.

Since: 1.0

type ImageClipboard 

type ImageClipboard interface {
	// Image returns the image on the clipboard, or (nil, false) when the
	// clipboard holds no image or reading it failed.
	Image() (image.Image, bool)
	// SetImage replaces the clipboard content with img.
	SetImage(img image.Image)
}

ImageClipboard is an optional interface a Clipboard can implement to carry raster images. Assert it on the value returned by App.Clipboard; on platforms without image clipboard support the assertion fails.

Since: 1.0

type KeyboardShortcut 

type KeyboardShortcut interface {
	core.Shortcut
	Key() event.KeyName
	Mod() event.KeyModifier
}

KeyboardShortcut describes a shortcut meant to be triggered by a keyboard action.

type LaunchAtLoginApp 

type LaunchAtLoginApp interface {
	// SetLaunchAtLogin enables or disables starting this app at user login,
	// returning an error if the change could not be applied (for example an
	// unbundled macOS binary, or insufficient permissions).
	SetLaunchAtLogin(enabled bool) error

	// LaunchAtLogin reports whether the app is currently registered to launch at
	// login. It returns false when the state cannot be determined.
	LaunchAtLogin() bool
}

LaunchAtLoginApp is an optional interface that an App can implement to control whether it starts automatically when the user logs in.

This is a desktop capability (macOS, Windows, Linux); mobile and web apps do not satisfy this interface. It applies to installed applications — an unpackaged binary run from a build directory (e.g. "go run") registers a path that changes between builds, so enabling it there is of limited use, and on macOS the underlying service requires a bundled app (SetLaunchAtLogin returns an error when that is not the case).

Since: 1.0

type LazyResource 

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

LazyResource is a resource that loads its content on first access. After the first call to Content(), the loaded bytes are cached and subsequent calls return the cached data with no additional I/O.

If the loader function returns an error, Content() returns nil and the error is logged. The next call to Content() will retry the load.

Use [Release] to free cached bytes under memory pressure; the next Content() call will re-load them.

LazyResource is safe for concurrent use.

Since: 2.7

func NewLazyResource 

func NewLazyResource(name string, loader func() ([]byte, error)) *LazyResource

NewLazyResource creates a resource that loads its content on first access using the provided loader function. The loader will be called at most once unless LazyResource.Release is called.

Since: 2.7

func NewLazyResourceFromPath 

func NewLazyResourceFromPath(path string) *LazyResource

NewLazyResourceFromPath creates a resource that loads its content from a filesystem path on first access. It also supports streaming via StreamingResource.Open, which opens the file directly without caching the bytes.

Since: 2.7

func NewStreamingLazyResource 

func NewStreamingLazyResource(name string, loader func() ([]byte, error), opener func() (io.ReadCloser, error)) *LazyResource

NewStreamingLazyResource creates a resource that loads its content on first access using the provided loader function, and supports streaming via StreamingResource.Open using the provided opener function.

Since: 2.7

func (*LazyResource) Content 

func (r *LazyResource) Content() []byte

Content returns the bytes of the resource, loading them on first call. The loaded bytes are cached for subsequent calls. If loading fails, the error is logged and nil is returned; the next call will retry.

func (*LazyResource) Loaded 

func (r *LazyResource) Loaded() bool

Loaded reports whether the resource content is currently cached in memory.

func (*LazyResource) Name 

func (r *LazyResource) Name() string

Name returns the identifying name of this resource.

func (*LazyResource) Open 

func (r *LazyResource) Open() (io.ReadCloser, error)

Open returns a reader for the resource content. If the resource was created with a path or URI that supports streaming, this returns a fresh reader directly from the source without caching all bytes in memory. Otherwise it falls back to wrapping Content() in a reader.

func (*LazyResource) Release 

func (r *LazyResource) Release()

Release frees the cached resource content. The next call to Content() will re-load the data from the source.

type LegacyTheme 

type LegacyTheme interface {
	BackgroundColor() color.Color
	ButtonColor() color.Color
	DisabledButtonColor() color.Color
	TextColor() color.Color
	DisabledTextColor() color.Color
	PlaceHolderColor() color.Color
	PrimaryColor() color.Color
	HoverColor() color.Color
	FocusColor() color.Color
	ScrollBarColor() color.Color
	ShadowColor() color.Color

	TextSize() int
	TextFont() Resource
	TextBoldFont() Resource
	TextItalicFont() Resource
	TextBoldItalicFont() Resource
	TextMonospaceFont() Resource

	Padding() int
	IconInlineSize() int
	ScrollBarSize() int
	ScrollBarSmallSize() int
}

LegacyTheme defines the requirements of any Bellui theme. This was previously called Theme and is kept for simpler transition of applications built before v2.0.0.

Since: 2.0

type Lifecycle 

type Lifecycle interface {
	// SetOnEnteredForeground hooks into the app becoming foreground and gaining focus.
	SetOnEnteredForeground(func())
	// SetOnExitedForeground hooks into the app losing input focus and going into the background.
	SetOnExitedForeground(func())
	// SetOnStarted hooks into an event that says the app is now running.
	SetOnStarted(func())
	// SetOnStopped hooks into an event that says the app is no longer running.
	SetOnStopped(func())
}

Lifecycle represents the various phases that an app can transition through.

Since: 2.1

type ListableURI 

type ListableURI interface {
	URI

	// List returns a list of child URIs of this URI.
	List() ([]URI, error)
}

ListableURI represents a URI that can have child items, most commonly a directory on disk in the native filesystem.

Since: 1.4

type Locale 

type Locale string

Locale represents a user's locale (language, region and script)

Since: 2.5

func (Locale) LanguageString 

func (l Locale) LanguageString() string

LanguageString returns a version of the local without the script portion. For example "en" or "fr-FR".

func (Locale) String 

func (l Locale) String() string

String returns the complete locale as a standard string. 

type MainMenu struct {
	Items []*Menu
}

MainMenu defines the data required to show a menu bar (desktop) or other appropriate top level menu.

func NewMainMenu 

func NewMainMenu(items ...*Menu) *MainMenu

NewMainMenu creates a top level menu structure used by bellui.Window for displaying a menubar (or appropriate equivalent). 

func (m *MainMenu) Refresh()

Refresh will instruct any rendered menus using this struct to update their display.

Since: 2.2

type MasterWindow 

type MasterWindow interface {
	SetMaster()
}

MasterWindow is an optional interface that a Window can implement to indicate that closing it should exit the app. 

type Menu struct {
	Label string
	Items []*MenuItem
}

Menu stores the information required for a standard menu. A menu can pop down from a MainMenu or could be a pop out menu.

func NewMenu 

func NewMenu(label string, items ...*MenuItem) *Menu

NewMenu creates a new menu given the specified label (to show in a MainMenu) and list of items to display. 

func (m *Menu) Refresh()

Refresh will instruct this menu to update its display.

Since: 2.2 

type MenuItem struct {
	ChildMenu *Menu
	// Since: 2.1
	IsQuit      bool
	IsSeparator bool
	Label       string
	Action      func() `json:"-"`
	// Since: 2.1
	Disabled bool
	// Since: 2.1
	Checked bool
	// Since: 2.2
	Icon Resource
	// Since: 2.2
	Shortcut core.Shortcut
}

MenuItem is a single item within any menu, it contains a display Label and Action function that is called when tapped.

func NewMenuItem 

func NewMenuItem(label string, action func()) *MenuItem

NewMenuItem creates a new menu item from the passed label and action parameters.

func NewMenuItemSeparator 

func NewMenuItemSeparator() *MenuItem

NewMenuItemSeparator creates a menu item that is to be used as a separator.

func NewMenuItemWithIcon 

func NewMenuItemWithIcon(label string, icon Resource, action func()) *MenuItem

NewMenuItemWithIcon creates a new menu item from the passed label, icon, and action parameters.

Since: 2.7

type MultiFlavorClipboard 

type MultiFlavorClipboard interface {
	// SetFlavors replaces the clipboard content with every set flavor of
	// content, written as one transaction. A flavor the platform cannot
	// carry (e.g. files on the web target, which never implements
	// [FileClipboard]) is skipped with a logged error.
	SetFlavors(content ClipboardContent)
}

MultiFlavorClipboard is an optional interface a Clipboard can implement to write several flavors in one clipboard transaction — e.g. a rendered chart as an image together with an HTML data table and a plain-text fallback. The single-flavor setters (ImageClipboard.SetImage etc.) each replace the whole clipboard, so this is the only way to offer combined flavors. Assert it on the value returned by App.Clipboard; on platforms without multi-flavor support the assertion fails.

Since: 1.0

type Notification 

type Notification struct {
	Title, Content string
}

Notification represents a user notification that can be sent to the operating system.

func NewNotification 

func NewNotification(title, content string) *Notification

NewNotification creates a notification that can be passed to [App.SendNotification].

type NotificationAction 

type NotificationAction struct {
	// Label is the user-visible button text.
	Label string
	// Callback is invoked on the main goroutine when the button is activated.
	Callback func()
}

NotificationAction is one inline action button attached to a NotificationOptions. Tapping the button in the OS notification runs Callback on the main goroutine.

Since: 1.0

type NotificationOptions 

type NotificationOptions struct {
	// Title and Content are the notification headline and body, as in [Notification].
	Title, Content string
	// Icon optionally overrides the application icon for this one notification.
	// Nil uses the app icon.
	Icon Resource
	// OnTapped is invoked on the main goroutine when the notification body is
	// clicked (the default activation). Nil disables click handling.
	OnTapped func()
	// Actions are inline action buttons, in display order. Platforms cap the
	// number they display; excess actions are dropped from the tail.
	Actions []NotificationAction
}

NotificationOptions is a richer notification than Notification: it adds click activation, inline action buttons and a per-notification icon. Send it with SendNotificationWithOptions (or the NotifierWithOptionsApp optional interface on the running app).

The callbacks (OnTapped and each action's Callback) are session-scoped: they are delivered on the main goroutine while the app that sent the notification is still running. Activating a notification whose app has since terminated is out of scope here — that requires per-platform launch activation (the "open with" territory of OpenHandlerApp).

Capabilities that the current platform cannot honour degrade gracefully: an implementation that cannot show action buttons still shows the title, content and icon rather than dropping the notification. See SendNotificationWithOptions.

Since: 1.0

type NotifierApp 

type NotifierApp interface {
	// SendNotification sends a system notification that will be displayed in the
	// operating system's notification area.
	SendNotification(*Notification)
}

NotifierApp is an optional interface that an App can implement to support system notifications.

type NotifierWithOptionsApp 

type NotifierWithOptionsApp interface {
	// SendNotificationWithOptions sends a rich system notification.
	SendNotificationWithOptions(*NotificationOptions)
}

NotifierWithOptionsApp is an optional interface that an App can implement to support rich system notifications with click activation, inline action buttons and a per-notification icon (see NotificationOptions).

It is asserted from the running app like the other optional interfaces (CloudApp, BadgeApp, …). Where a capability is not available the implementation degrades to a plain notification rather than dropping it, and callbacks that the platform cannot deliver simply never fire — so a caller can always send the rich form and rely on at least the title and content showing.

Callback delivery is on the main goroutine and session-scoped; see NotificationOptions.

Since: 1.0

type OpenHandlerApp 

type OpenHandlerApp interface {
	// SetOnFileOpened registers a callback fired with the URI of a file the app
	// was asked to open.
	SetOnFileOpened(func(URI))

	// SetOnURLOpened registers a callback fired with a URL the app was asked to
	// open (a custom scheme registered to the app, or a deep link).
	SetOnURLOpened(func(*url.URL))
}

OpenHandlerApp is an optional interface that an App can implement to be notified that it was launched — or, while already running, asked — to open a file or a URL. This is the receive half of OS "open with" / file-association and custom URL-scheme handling.

A payload can arrive two ways: as the reason the app was launched (buffered and delivered once the app is running), or while the app is already running. The launch case works out of the box on every desktop platform and the web. The already-running case is automatic on macOS (Launch Services re-activates the instance); on Windows and Linux it is delivered through single-instance argument forwarding, so an app that also opts into SingleInstanceApp (which it does anyway to avoid opening a second copy) receives already-running "open with" events with no extra wiring.

Both callbacks are invoked on the main goroutine, matching the model of other driver callbacks. Register them before App.Run. A nil callback clears the handler. On platforms without a delivery mechanism the setters are accepted but never fire (for example [SetOnFileOpened] on the web).

Since: 1.0

type PreferenceType 

type PreferenceType interface {
	bool | int | float64 | string | []bool | []int | []float64 | []string
}

PreferenceType constrains the types that can be stored in Preferences.

type Preferences 

type Preferences interface {
	// Value looks up the value for the given key. Returns (value, true) if found,
	// or (nil, false) if the key does not exist.
	Value(key string) (any, bool)

	// SetValue saves a value for the given key. The value must be one of the
	// supported [PreferenceType] types.
	SetValue(key string, value any)

	// RemoveValue removes a value for the given key (not currently supported on iOS).
	RemoveValue(key string)

	// AddChangeListener allows code to be notified when some preferences change.
	// This will fire on any update.
	AddChangeListener(func())
}

Preferences describes the ways that an app can save and load user preferences.

type PrimaryColorSettings 

type PrimaryColorSettings interface {
	Settings

	// SetPrimaryColor sets the preference for a named primary color and
	// re-applies the current theme. The change affects the running app only;
	// it is not written to the system-wide Bellui settings.
	SetPrimaryColor(name string)
}

PrimaryColorSettings describes the optional capability of Settings implementations that can change the user's named primary color at runtime. The settings of a running app (and of the test app) implement it.

Since: 1.0

type Resource 

type Resource interface {
	Name() string
	Content() []byte
}

Resource represents a single binary resource, such as an image or font. A resource has an identifying name and byte array content. The serialised path of a resource can be obtained which may result in a blocking filesystem write operation.

func LoadResourceFromPath 

func LoadResourceFromPath(path string) (Resource, error)

LoadResourceFromPath creates a new StaticResource in memory using the contents of the specified file.

func LoadResourceFromURLString 

func LoadResourceFromURLString(urlStr string) (Resource, error)

LoadResourceFromURLString creates a new StaticResource in memory using the body of the specified URL.

type ScreenBlankingDriver 

type ScreenBlankingDriver interface {
	SetDisableScreenBlanking(bool)
}

ScreenBlankingDriver is an optional interface that a Driver can implement to allow an app to ask the device not to sleep/lock/blank displays.

type ScrollDirection 

type ScrollDirection int

ScrollDirection represents the directions in which a scrollable container or widget can scroll its child content.

Since: 2.6 

const (
	// ScrollBoth supports horizontal and vertical scrolling.
	ScrollBoth ScrollDirection = iota
	// ScrollHorizontalOnly specifies the scrolling should only happen left to right.
	ScrollHorizontalOnly
	// ScrollVerticalOnly specifies the scrolling should only happen top to bottom.
	ScrollVerticalOnly
	// ScrollNone turns off scrolling for this container.
	ScrollNone
)

Constants for valid values of ScrollDirection used in containers and widgets.

type SelectableMode 

type SelectableMode int

SelectableMode represents the window-level selectable mode which can override per-widget Selectable properties for display widgets.

Since: 2.8 

const (
	// SelectablePerWidget uses each widget's own Selectable property to determine
	// whether its content can be selected and copied.
	SelectablePerWidget SelectableMode = iota
	// SelectableAll forces all display widgets in the window to be selectable,
	// regardless of their own Selectable property.
	SelectableAll
	// SelectableNone forces all display widgets in the window to be non-selectable,
	// regardless of their own Selectable property.
	SelectableNone
)

type Settings 

type Settings interface {
	Theme() Theme
	SetTheme(Theme)
	// ThemeVariant defines which preferred version of a theme should be used (i.e. light or dark)
	//
	// Since: 2.0
	ThemeVariant() ThemeVariant
	// SetThemeVariant sets the preferred theme variant (light or dark) and re-applies the current theme.
	SetThemeVariant(ThemeVariant)
	Scale() float32
	// PrimaryColor indicates a user preference for a named primary color
	//
	// Since: 1.4
	PrimaryColor() string

	// AddListener registers a callback that is invoked whenever the settings change.
	//
	// Since: 2.6
	AddListener(func(Settings))

	BuildType() BuildType

	ShowAnimations() bool
}

Settings describes the application configuration available.

type SharerApp 

type SharerApp interface {
	// ShareText offers the given text to the platform share UI.
	ShareText(text string) error

	// ShareFile offers the file identified by uri to the platform share UI.
	// The URI must use the "file" scheme.
	ShareFile(uri URI) error
}

SharerApp is an optional interface that an App can implement to hand content to the operating system's share UI (the OS-owned chooser that offers Messages, Mail, AirDrop, other installed apps, …). It is the "send" half of platform intent/share integration.

It is supported on macOS (NSSharingServicePicker), and on mobile (ACTION_SEND / UIActivityViewController). Platforms without a share surface return ErrShareNotSupported rather than silently doing nothing.

Since: 1.0

type ShortcutCopy 

type ShortcutCopy struct {
	Clipboard Clipboard
}

ShortcutCopy describes a shortcut copy action.

func (*ShortcutCopy) Key 

func (se *ShortcutCopy) Key() event.KeyName

Key returns the event.KeyName for this shortcut.

func (*ShortcutCopy) Mod 

func (se *ShortcutCopy) Mod() event.KeyModifier

Mod returns the event.KeyModifier for this shortcut.

func (*ShortcutCopy) ShortcutName 

func (se *ShortcutCopy) ShortcutName() string

ShortcutName returns the shortcut name

type ShortcutCut 

type ShortcutCut struct {
	Clipboard Clipboard
}

ShortcutCut describes a shortcut cut action.

func (*ShortcutCut) Key 

func (se *ShortcutCut) Key() event.KeyName

Key returns the event.KeyName for this shortcut.

func (*ShortcutCut) Mod 

func (se *ShortcutCut) Mod() event.KeyModifier

Mod returns the event.KeyModifier for this shortcut.

func (*ShortcutCut) ShortcutName 

func (se *ShortcutCut) ShortcutName() string

ShortcutName returns the shortcut name

type ShortcutHandler 

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

ShortcutHandler is a default implementation of the shortcut handler for core.CanvasObject.

func (*ShortcutHandler) AddShortcut 

func (sh *ShortcutHandler) AddShortcut(shortcut core.Shortcut, handler func(shortcut core.Shortcut))

AddShortcut register a handler to be executed when the shortcut action is triggered

func (*ShortcutHandler) RemoveShortcut 

func (sh *ShortcutHandler) RemoveShortcut(shortcut core.Shortcut)

RemoveShortcut removes a registered shortcut

func (*ShortcutHandler) TypedShortcut 

func (sh *ShortcutHandler) TypedShortcut(shortcut core.Shortcut)

TypedShortcut handle the registered shortcut

type ShortcutPaste 

type ShortcutPaste struct {
	Clipboard Clipboard
}

ShortcutPaste describes a shortcut paste action.

func (*ShortcutPaste) Key 

func (se *ShortcutPaste) Key() event.KeyName

Key returns the event.KeyName for this shortcut.

func (*ShortcutPaste) Mod 

func (se *ShortcutPaste) Mod() event.KeyModifier

Mod returns the event.KeyModifier for this shortcut.

func (*ShortcutPaste) ShortcutName 

func (se *ShortcutPaste) ShortcutName() string

ShortcutName returns the shortcut name

type ShortcutRedo 

type ShortcutRedo struct{}

ShortcutRedo describes a shortcut redo action.

Since: 2.5

func (*ShortcutRedo) Key 

func (se *ShortcutRedo) Key() event.KeyName

Key returns the event.KeyName for this shortcut.

func (*ShortcutRedo) Mod 

func (se *ShortcutRedo) Mod() event.KeyModifier

Mod returns the event.KeyModifier for this shortcut.

func (*ShortcutRedo) ShortcutName 

func (se *ShortcutRedo) ShortcutName() string

ShortcutName returns the shortcut name

type ShortcutSelectAll 

type ShortcutSelectAll struct{}

ShortcutSelectAll describes a shortcut selectAll action.

func (*ShortcutSelectAll) Key 

func (se *ShortcutSelectAll) Key() event.KeyName

Key returns the event.KeyName for this shortcut.

func (*ShortcutSelectAll) Mod 

func (se *ShortcutSelectAll) Mod() event.KeyModifier

Mod returns the event.KeyModifier for this shortcut.

func (*ShortcutSelectAll) ShortcutName 

func (se *ShortcutSelectAll) ShortcutName() string

ShortcutName returns the shortcut name

type ShortcutUndo 

type ShortcutUndo struct{}

ShortcutUndo describes a shortcut undo action.

Since: 2.5

func (*ShortcutUndo) Key 

func (se *ShortcutUndo) Key() event.KeyName

Key returns the event.KeyName for this shortcut.

func (*ShortcutUndo) Mod 

func (se *ShortcutUndo) Mod() event.KeyModifier

Mod returns the event.KeyModifier for this shortcut.

func (*ShortcutUndo) ShortcutName 

func (se *ShortcutUndo) ShortcutName() string

ShortcutName returns the shortcut name

type Shortcutable 

type Shortcutable interface {
	TypedShortcut(core.Shortcut)
}

Shortcutable describes any core.CanvasObject that can respond to shortcut commands.

type SingleInstanceApp 

type SingleInstanceApp interface {
	// SetSingleInstance enables single-instance mode, keyed on the app's UniqueID.
	//
	// It reports whether this process became the primary instance. When primary is
	// false the arguments of this launch (os.Args[1:]) have already been forwarded to
	// the running primary, and the caller should exit without calling [App.Run] - no
	// driver or window has been created at this point, so there is no window flash.
	//
	// The onOpen callback is invoked on the main goroutine, with the arguments
	// forwarded from each subsequent launch that was redirected to this primary. It
	// may be nil to enable single-instance mode without receiving forwarded arguments.
	//
	// SetSingleInstance must be called before [App.Run]. It is idempotent: repeated
	// calls report the same role without rebinding. It returns an error if the app has
	// no unique ID (see [NewWithID]). On platforms that are inherently single-instance
	// (mobile, web) it is a no-op that reports primary true.
	//
	// Since: 1.0
	SetSingleInstance(onOpen func(args []string)) (primary bool, err error)
}

SingleInstanceApp is an optional interface that an App can implement to support single-instance mode with argument forwarding.

When enabled, at most one process per application unique ID holds the "primary" role. A subsequent launch of the same app detects the running primary, forwards its command-line arguments to it, and reports that it is not the primary so the caller can exit without opening a second copy. This is the building block behind OS file-association and URL-scheme handling on Windows and Linux, where "open with" relaunches the binary with the target in the arguments.

Since: 1.0

type StaticResource 

type StaticResource struct {
	StaticName    string
	StaticContent []byte
}

StaticResource is a bundled resource compiled into the application. These resources are normally generated by the bellui_bundle command included in the Bellui toolkit.

func NewStaticResource 

func NewStaticResource(name string, content []byte) *StaticResource

NewStaticResource returns a new static resource object with the specified name and content. Creating a new static resource in memory results in sharable binary data that may be serialised to the system cache location.

func (*StaticResource) Content 

func (r *StaticResource) Content() []byte

Content returns the bytes of the bundled resource, no compression is applied but any compression on the resource is retained.

func (*StaticResource) GoString 

func (r *StaticResource) GoString() string

GoString converts a Resource object to Go code. This is useful if serialising to a Go file for compilation into a binary.

func (*StaticResource) Name 

func (r *StaticResource) Name() string

Name returns the unique name of this resource, usually matching the file it was generated from.

type Storage 

type Storage interface {
	RootURI() URI

	Create(name string) (URIWriteCloser, error)
	Open(name string) (URIReadCloser, error)
	Save(name string) (URIWriteCloser, error)
	Remove(name string) error

	List() []string
}

Storage is used to manage file storage inside an application sandbox. The files managed by this interface are unique to the current application.

type StreamingResource 

type StreamingResource interface {
	Resource
	Open() (io.ReadCloser, error)
}

StreamingResource is a resource that can provide its content as a stream. This is useful for large resources where loading everything into memory at once is wasteful.

StreamingResource extends Resource: the Content() method still works (reading all bytes into memory), but Open() provides an io.ReadCloser for streaming consumption without buffering the entire content.

Since: 2.7

type StringValidator 

type StringValidator func(string) error

StringValidator is a function signature for validating string inputs.

Since: 1.4

type TextAlign 

type TextAlign int

TextAlign represents the horizontal alignment of text within a widget or canvas object. 

const (
	// TextAlignLeading specifies a left alignment for left-to-right languages.
	TextAlignLeading TextAlign = iota
	// TextAlignCenter places the text centrally within the available space.
	TextAlignCenter
	// TextAlignTrailing will align the text right for a left-to-right language.
	TextAlignTrailing
)

type TextDirection 

type TextDirection = Direction

TextDirection represents the base writing direction of a block of text. It controls the paragraph base direction fed to the Unicode Bidirectional Algorithm (UAX #9), which determines how mixed left-to-right and right-to-left text — and neutral characters such as spaces and punctuation — are visually ordered. It does not affect within-run shaping (Arabic joining, Hebrew glyph forms), which is always derived from the text content itself.

It is an alias for Direction: text base direction and UI layout direction are the same concept, so TextStyle.Direction left at the default TextDirectionAuto follows the same ambient direction that mirrors layouts.

Since: 2.8

type TextStyle 

type TextStyle struct {
	Bold      bool // Should text be bold
	Italic    bool // Should text be italic
	Monospace bool // Use the system monospace font instead of regular
	// Since: 2.2
	Symbol bool // Use the system symbol font.
	// Since: 2.1
	TabWidth int // Width of tabs in spaces
	// Since: 2.5
	Underline bool // Should text be underlined.

	// Strikethrough draws a line through the middle of the text. Like
	// [TextStyle.Underline] it renders as a decoration over general text
	// (Label, RichText, canvas.Text) as well as in
	// [github.com/belluikit/bellui/widget.TextGrid].
	//
	// Since: 1.0
	Strikethrough bool // Should text be struck through.

	// Weight specifies the font weight (100–900). When nil, the Bold flag is
	// used: Bold=true maps to WeightBold (700), otherwise WeightNormal (400).
	// Valid values are 100–900. Use [Ptr] for struct literals:
	//
	//	bellui.TextStyle{Weight: bellui.Ptr(bellui.WeightBold)}
	Weight *TextWeight

	// LineHeightScale multiplies the default line height derived from font metrics.
	// When nil, the default (1.0×) is used. Values > 1.0 add extra vertical space.
	LineHeightScale *float32

	// LetterSpacing adds extra horizontal space (in points) between glyphs.
	// When nil, no extra spacing is applied. Can point to negative values to
	// tighten text.
	LetterSpacing *float32

	// Direction sets the base writing direction for bidirectional text layout.
	// The zero value [TextDirectionAuto] derives the direction from the active
	// locale. Within-run shaping (Arabic joining, Hebrew forms, mixed-script
	// runs) is always detected from the text content regardless of this field;
	// Direction only controls the base ordering of runs and neutral characters.
	//
	// Since: 2.8
	Direction TextDirection

	// Language overrides the language tag used when shaping this text. It
	// selects script-specific OpenType features and localized glyph forms — for
	// example "sr-Cyrl" renders Serbian Cyrillic forms and "ru" Russian
	// Cyrillic forms — independently of the application locale. The value is a
	// BCP 47 language tag. The zero value (empty string) follows the active
	// locale, which is the default.
	//
	// Like Direction, this only affects shaping of the text content (contextual
	// alternates, localized glyph forms); it does not change which font face is
	// selected or the bidi ordering.
	//
	// Since: 2.8
	Language string
}

TextStyle represents the styles that can be applied to a text canvas object or text based widget.

func (TextStyle) ResolvedLetterSpacing 

func (t TextStyle) ResolvedLetterSpacing() float32

ResolvedLetterSpacing returns the effective letter spacing in points. If LetterSpacing is nil, returns DefaultLetterSpacing (0).

func (TextStyle) ResolvedLineHeightScale 

func (t TextStyle) ResolvedLineHeightScale() float32

ResolvedLineHeightScale returns the effective line-height multiplier. If LineHeightScale is nil, returns DefaultLineHeightScale (1.0).

func (TextStyle) ResolvedWeight 

func (t TextStyle) ResolvedWeight() TextWeight

ResolvedWeight returns the effective font weight. If Weight is nil, it falls back to WeightBold when Bold is true, otherwise WeightNormal.

type TextTruncation 

type TextTruncation int

TextTruncation controls how a `Label` or `Entry` will truncate its text. The default value is `TextTruncateOff` which will not truncate.

Since: 2.4 

const (
	// TextTruncateOff means no truncation will be applied, it is the default.
	// This means that the minimum size of a text block will be the space required to display it fully.
	TextTruncateOff TextTruncation = iota
	// TextTruncateClip will truncate text when it reaches the end of the available space.
	TextTruncateClip
	// TextTruncateEllipsis is like regular truncation except that an ellipses (…) will be inserted
	// wherever text has been shortened to fit.
	//
	// Since: 2.4
	TextTruncateEllipsis
)

type TextWeight 

type TextWeight float32

TextWeight represents the weight (boldness) of a font. Values range from 100 (thinnest) to 900 (thickest). 

const (
	WeightThin       TextWeight = 100 // Thin weight (100).
	WeightExtraLight TextWeight = 200 // Extra light weight (200).
	WeightLight      TextWeight = 300 // Light weight (300).
	WeightNormal     TextWeight = 400 // Normal weight (400).
	WeightMedium     TextWeight = 500 // Medium weight (500).
	WeightSemiBold   TextWeight = 600 // Semi-bold weight (600).
	WeightBold       TextWeight = 700 // Bold weight (700).
	WeightExtraBold  TextWeight = 800 // Extra-bold weight (800).
	WeightBlack      TextWeight = 900 // Black weight (900).
)

type TextWrap 

type TextWrap int

TextWrap represents how text longer than the widget's width will be wrapped. 

const (
	// TextWrapOff extends the widget's width to fit the text, no wrapping is applied.
	TextWrapOff TextWrap = iota

	// TextWrapBreak trims the line of characters to the widget's width adding the excess as new line.
	// An Entry with text wrapping will scroll vertically if there is not enough space for all the text.
	TextWrapBreak
	// TextWrapWord trims the line of words to the widget's width adding the excess as new line.
	// An Entry with text wrapping will scroll vertically if there is not enough space for all the text.
	TextWrapWord
)

type Theme 

type Theme interface {
	Color(ThemeColorName, ThemeVariant) color.Color
	Font(TextStyle) Resource
	Icon(ThemeIconName) Resource
	Size(ThemeSizeName) float32
}

Theme defines the method to look up colors, sizes and fonts that make up a Bellui theme.

Since: 2.0

type ThemeColorName 

type ThemeColorName string

ThemeColorName is used to look up a colour based on its name.

Since: 2.0

type ThemeIconName 

type ThemeIconName string

ThemeIconName is used to look up an icon based on its name.

Since: 2.0

type ThemeSizeName 

type ThemeSizeName string

ThemeSizeName is used to look up a size based on its name.

Since: 2.0

type ThemeVariant 

type ThemeVariant uint

ThemeVariant indicates a variation of a theme, such as light or dark.

Since: 2.0

type ThemedResource 

type ThemedResource interface {
	Resource
	ThemeColorName() ThemeColorName
}

ThemedResource is a version of a resource that can be updated to match a certain theme color. The ThemeColorName will be used to look up the color for the current theme and colorize the resource.

Since: 2.5

type URI 

type URI interface {
	fmt.Stringer

	// Extension should return the file extension of the resource
	// (including the dot) referenced by the URI. For example, the
	// Extension() of 'file://foo/bar.baz' is '.baz'. May return an
	// empty string if the referenced resource has none.
	Extension() string

	// Name should return the base name of the item referenced by the URI.
	// For example, the name of 'file://foo/bar.baz' is 'bar.baz'.
	Name() string

	// MimeType should return the content type of the resource referenced
	// by the URI. The returned string should be in the format described
	// by Section 5 of RFC2045 ("Content-Type Header Field").
	MimeType() string

	// Scheme should return the URI scheme of the URI as defined by IETF
	// RFC3986. For example, the Scheme() of 'file://foo/bar.baz` is
	// 'file'.
	//
	// Scheme should always return the scheme in all lower-case characters.
	Scheme() string

	// Authority should return the URI authority, as defined by IETF
	// RFC3986.
	//
	// NOTE: the RFC3986 can be obtained by combining the [net/url.URL.User]
	// and [net/url.URL.Host]. Consult IETF RFC3986, section
	// 3.2, pp. 17.
	//
	// Since: 2.0
	Authority() string

	// Path should return the URI path, as defined by IETF RFC3986.
	//
	// Since: 2.0
	Path() string

	// Query should return the URI query, as defined by IETF RFC3986.
	//
	// Since: 2.0
	Query() string

	// Fragment should return the URI fragment, as defined by IETF
	// RFC3986.
	//
	// Since: 2.0
	Fragment() string
}

URI represents the identifier of a resource on a target system. This resource may be a file or another data source such as an app or file sharing system. The URI represents an absolute location of a resource, it is up to any parse or constructor implementations to ensure that relative resources are made absolute.

In general, it is expected that URI implementations follow IETF RFC3986. Implementations are highly recommended to utilize net/url to implement URI parsing methods, especially net/url/url.Scheme, net/url/url.Authority, net/url/url.Path, net/url/url.Query, and net/url/url.Fragment.

func ClipboardFiles 

func ClipboardFiles() []URI

ClipboardFiles returns the list of files on the current app's clipboard. It returns nil when no app is running, the clipboard does not support file lists (FileClipboard) or no files are present.

Since: 1.0

type URIReadCloser 

type URIReadCloser interface {
	io.ReadCloser

	URI() URI
}

URIReadCloser represents a cross platform data stream from a file or provider of data. It may refer to an item on a filesystem or data in another application that we have access to.

type URIWithIcon 

type URIWithIcon interface {
	URI

	Icon() Resource
}

URIWithIcon describes a URI that should be rendered with a certain icon in file browsers.

Since: 2.5

type URIWriteCloser 

type URIWriteCloser interface {
	io.WriteCloser

	URI() URI
}

URIWriteCloser represents a cross platform data writer for a file resource. This will normally refer to a local file resource.

type Validatable 

type Validatable interface {
	Validate() error

	// SetOnValidationChanged is used to set the callback that will be triggered when the validation state changes.
	// The function might be overwritten by a parent that cares about child validation (e.g. widget.Form).
	SetOnValidationChanged(func(error))
}

Validatable is an interface for specifying if a widget is validatable.

Since: 1.4

type Window 

type Window interface {
	// Title returns the current window title.
	// This is typically displayed in the window decorations.
	Title() string
	// SetTitle updates the current title of the window.
	SetTitle(string)

	// FullScreen returns whether or not this window is currently full screen.
	FullScreen() bool
	// SetFullScreen changes the requested fullScreen property
	// true for a fullScreen window and false to unset this.
	SetFullScreen(bool)

	// Resize this window to the requested content size.
	// The result may not be exactly as desired due to various desktop or
	// platform constraints.
	Resize(geo.Size)

	// RequestFocus attempts to raise and focus this window.
	// This should only be called when you are sure the user would want this window
	// to steal focus from any current focused window.
	RequestFocus()

	// FixedSize returns whether or not this window should disable resizing.
	FixedSize() bool
	// SetFixedSize sets a hint that states whether the window should be a fixed
	// size or allow resizing.
	SetFixedSize(bool)

	// CenterOnScreen places a window at the center of the monitor
	// the Window object is currently positioned on.
	CenterOnScreen()

	// Padded, normally true, states whether the window should have inner
	// padding so that components do not touch the window edge.
	Padded() bool
	// SetPadded allows applications to specify that a window should have
	// no inner padding. Useful for fullscreen or graphic based applications.
	SetPadded(bool)

	// SelectableMode returns the window-level selectable mode.
	// The default value is [SelectablePerWidget].
	//
	// Since: 2.8
	SelectableMode() SelectableMode
	// SetSelectableMode sets the window-level selectable mode which overrides
	// per-widget Selectable properties for display widgets (e.g. Label).
	// [SelectableAll] forces all display widgets to be selectable,
	// [SelectableNone] forces them to be non-selectable, and
	// [SelectablePerWidget] (the default) defers to each widget's own setting.
	//
	// Since: 2.8
	SetSelectableMode(SelectableMode)

	// Icon returns the window icon, this is used in various ways
	// depending on operating system.
	// Most commonly this is displayed on the window border or task switcher.
	Icon() Resource

	// SetIcon sets the icon resource used for this window.
	// If none is set should return the application icon.
	SetIcon(Resource)

	// MainMenu gets the content of the window's top level menu.
	MainMenu() *MainMenu

	// SetMainMenu adds a top level menu to this window.
	// The way this is rendered will depend on the loaded driver.
	SetMainMenu(*MainMenu)

	// SetOnClosed sets a function that runs when the window is closed.
	SetOnClosed(func())

	// SetCloseIntercept sets a function that runs instead of closing if defined.
	// [Window.Close] should be called explicitly in the interceptor to close the window.
	//
	// Since: 1.4
	SetCloseIntercept(func())

	// Show the window on screen.
	Show()
	// Hide the window from the user.
	// This will not destroy the window or cause the app to exit.
	Hide()
	// Close the window.
	// If it is the "master" window the app will Quit.
	// If it is the only open window and no menu is set via [desktop.App]
	// SetSystemTrayMenu the app will also Quit.
	Close()

	// Content returns the content of this window.
	Content() core.CanvasObject
	// SetContent sets the content of this window.
	SetContent(core.CanvasObject)
	// Canvas returns the canvas context to render in the window.
	// This can be useful to set a key handler for the window, for example.
	Canvas() core.Canvas
}

Window describes a user interface window. Depending on the platform an app may have many windows or just the one.

Multi-window support is platform-dependent (see App.NewWindow): desktop gives each window a real, independent OS window shown concurrently; web overlays additional windows as draggable in-canvas windows on the single browser canvas; mobile stacks windows and shows only the topmost visible one at a time.

Source Files

View all Source files

Directories

Path Synopsis
Package analytics is an opt-in, consent-first product-analytics package that lives beside the toolkit (the theme/cjk placement pattern): it is never imported by Bellui core, and costs nothing unless an app imports it.
 Package analytics is an opt-in, consent-first product-analytics package that lives beside the toolkit (the theme/cjk placement pattern): it is never imported by Bellui core, and costs nothing unless an app imports it.
ga4
Package ga4 is a dumb analytics.Sink over the Google Analytics 4 Measurement Protocol.
 Package ga4 is a dumb analytics.Sink over the Google Analytics 4 Measurement Protocol.
posthog
Package posthog is a dumb analytics.Sink over the PostHog batch capture API.
 Package posthog is a dumb analytics.Sink over the PostHog batch capture API.
Package app provides app implementations for working with Bellui graphical interfaces.
 Package app provides app implementations for working with Bellui graphical interfaces.
Package auth provides OIDC and OAuth 2.0 authentication for desktop apps.
 Package auth provides OIDC and OAuth 2.0 authentication for desktop apps.
Package canvas contains all of the primitive CanvasObjects that make up a Bellui GUI.
 Package canvas contains all of the primitive CanvasObjects that make up a Bellui GUI.
cmd
bellui_settings command
bellui_settings/data
bellui_settings/settings
framebench command
Command framebench is a frame-time benchmark harness for the dirty-region partial-repaint optimization (issue #9).
 Command framebench is a frame-time benchmark harness for the dirty-region partial-repaint optimization (issue #9).
prvalidate command
Command prvalidate is the on-device validation harness for the dirty-region partial-repaint optimization (#340 — mobile validation gate).
 Command prvalidate is the on-device validation harness for the dirty-region partial-repaint optimization (#340 — mobile validation gate).
Package container provides containers that are used to lay out and organise applications.
 Package container provides containers that are used to lay out and organise applications.
Package core defines the fundamental interfaces of the Bellui toolkit.
 Package core defines the fundamental interfaces of the Bellui toolkit.
data
binding
Package binding provides support for binding data to widgets.
 Package binding provides support for binding data to widgets.
model
Package model provides an observable, typed data layer that sits between an application's data and the List/Table widgets — a composable sort/filter/ selection layer in the spirit of Qt's model/view classes.
 Package model provides an observable, typed data layer that sits between an application's data and the List/Table widgets — a composable sort/filter/ selection layer in the spirit of Qt's model/view classes.
validation
Package validation provides validation for data inside widgets.
 Package validation provides validation for data inside widgets.
dev
Package dev provides developer tools for Bellui applications.
 Package dev provides developer tools for Bellui applications.
inspector
Package inspector provides an opt-in, read-only runtime widget-tree inspector for debugging Bellui layouts — the human-facing counterpart to the accessibility introspection layer.
 Package inspector provides an opt-in, read-only runtime widget-tree inspector for debugging Bellui layouts — the human-facing counterpart to the accessibility introspection layer.
Package dialog defines standard dialog windows for application GUIs.
 Package dialog defines standard dialog windows for application GUIs.
desktop
Package desktop provides desktop specific driver functionality.
 Package desktop provides desktop specific driver functionality.
embedded
mobile
Package mobile provides mobile specific driver functionality.
 Package mobile provides mobile specific driver functionality.
software
Package event defines input event types and behavioral interfaces for canvas objects that respond to user interaction.
 Package event defines input event types and behavioral interfaces for canvas objects that respond to user interaction.
Package flow provides reactive state management for Bellui applications.
 Package flow provides reactive state management for Bellui applications.
Package geo defines the fundamental geometry types used throughout Bellui: Size, Position, and Delta.
 Package geo defines the fundamental geometry types used throughout Bellui: Size, Position, and Delta.
hack
a11ybatchprobe command
Command a11ybatchprobe is the on-device verification harness for the Android a11y/IME polish batch: IME batch-edit coalescing (#1015), partial extracted-text updates (#1009) and the visual-layout sidecar (#995).
 Command a11ybatchprobe is the on-device verification harness for the Android a11y/IME polish batch: IME batch-edit coalescing (#1015), partial extracted-text updates (#1009) and the visual-layout sidecar (#995).
a11ygestureprobe command
Command a11ygestureprobe verifies #762: TalkBack accessibility gestures — scroll, long-press and slider adjust — must route to the corresponding Bellui behaviours even though Bellui consumes raw touch through the native input queue (which bypasses the framework's touch-exploration filter, so the #761 tap-gate suppresses raw gestures under TalkBack).
 Command a11ygestureprobe verifies #762: TalkBack accessibility gestures — scroll, long-press and slider adjust — must route to the corresponding Bellui behaviours even though Bellui consumes raw touch through the native input queue (which bypasses the framework's touch-exploration filter, so the #761 tap-gate suppresses raw gestures under TalkBack).
a11yprobe command
a11yprobe is the live-verification harness for the accessibility platform backends (epic #490, checked in per #561).
 a11yprobe is the live-verification harness for the accessibility platform backends (epic #490, checked in per #561).
a11yprogprobe command
Command a11yprogprobe verifies #763: the Android IME state-mirror (the hidden shadow EditText that TalkBack reads) must track a *programmatic* Entry text change while the Entry holds focus — SetText / binding write / undo / autocomplete — not just keystrokes.
 Command a11yprogprobe verifies #763: the Android IME state-mirror (the hidden shadow EditText that TalkBack reads) must track a *programmatic* Entry text change while the Entry holds focus — SetText / binding write / undo / autocomplete — not just keystrokes.
a11yrealizeprobe command
Command a11yrealizeprobe is a live-verify harness for the off-viewport virtualized-cell realize seam (fyne#637).
 Command a11yrealizeprobe is a live-verify harness for the off-viewport virtualized-cell realize seam (fyne#637).
a796probe command
Command a796probe verifies #796 (RangeSlider + TimePicker-dial screen-reader adjust) and the mobile a11y proxy-View reconcile.
 Command a796probe verifies #796 (RangeSlider + TimePicker-dial screen-reader adjust) and the mobile a11y proxy-View reconcile.
adrenorepro command
Command adrenorepro reproduces #310 (Android Adreno/Vulkan WebGPU black canvas after first interaction).
 Command adrenorepro reproduces #310 (Android Adreno/Vulkan WebGPU black canvas after first interaction).
analyticsprobe command
Command analyticsprobe live-verifies the analytics battery model (#699, follow-up to #526/#527) on a real device.
 Command analyticsprobe live-verifies the analytics battery model (#699, follow-up to #526/#527) on a real device.
androidwebviewprobe command
Command androidwebviewprobe is the on-device pass for the Android android.webkit.WebView backend (#63, #76) and the #143 IME polish work: hosting in the panel window, the runOnUiThread threading discipline under churn (the #973 deadlock shape), geometry + native clip inside a container.Scroll, the #59 focus bridge, the bridge and navigation API, teardown — and instrumented cold-tap / keystroke-latency measurement.
 Command androidwebviewprobe is the on-device pass for the Android android.webkit.WebView backend (#63, #76) and the #143 IME polish work: hosting in the panel window, the runOnUiThread threading discipline under churn (the #973 deadlock shape), geometry + native clip inside a container.Scroll, the #59 focus bridge, the bridge and navigation API, teardown — and instrumented cold-tap / keystroke-latency measurement.
atspiprobe command
Command atspiprobe is a research spike for fyne#489: a *pure-Go* AT-SPI2 accessibility provider, speaking the org.a11y.atspi.* D-Bus protocol directly through github.com/godbus/dbus/v5 (already a fork dependency) with no cgo and no Rust/AccessKit.
 Command atspiprobe is a research spike for fyne#489: a *pure-Go* AT-SPI2 accessibility provider, speaking the org.a11y.atspi.* D-Bus protocol directly through github.com/godbus/dbus/v5 (already a fork dependency) with no cgo and no Rust/AccessKit.
badgeprobe command
border1039probe command
Live-verify probe for #1039 (EnsureMinSize dropped-update fix).
 Live-verify probe for #1039 (EnsureMinSize dropped-update fix).
cefhostprobe command
Command cefhostprobe is the #105 acceptance run: the Linux webview backend — CEF offscreen, composited into bellui's canvas — driven end to end through the real webview.Host widget rather than through raw CEF as hack/cefprobe did.
 Command cefhostprobe is the #105 acceptance run: the Linux webview backend — CEF offscreen, composited into bellui's canvas — driven end to end through the real webview.Host widget rather than through raw CEF as hack/cefprobe did.
clipboardprobe command
Command clipboardprobe live-verifies the clipboard flavor interfaces (#513) against the real system clipboard.
 Command clipboardprobe live-verifies the clipboard flavor interfaces (#513) against the real system clipboard.
clipimageprobe command
Command clipimageprobe live-verifies mobile image clipboard (#580, bellui.ImageClipboard on Android/iOS): a generated pattern is copied to the system clipboard with SetClipboardImage, then read back with ClipboardImage and displayed — a full round-trip through the OS ClipboardManager / UIPasteboard (not an in-memory shortcut).
 Command clipimageprobe live-verifies mobile image clipboard (#580, bellui.ImageClipboard on Android/iOS): a generated pattern is copied to the system clipboard with SetClipboardImage, then read back with ClipboardImage and displayed — a full round-trip through the OS ClipboardManager / UIPasteboard (not an in-memory shortcut).
deviceinfoprobe command
Command deviceinfoprobe live-verifies device configuration plumbing on a real device or emulator: the canvas scale derived from the reported density (#272), the raw locale strings the system hands go-locale (#271), and the locale the lang package actually settled on (#282 — on Android the init-time lookup runs before the JVM attaches, so without the app-creation re-resolve the active locale stays the bare English fallback "en").
 Command deviceinfoprobe live-verifies device configuration plumbing on a real device or emulator: the canvas scale derived from the reported density (#272), the raw locale strings the system hands go-locale (#271), and the locale the lang package actually settled on (#282 — on Android the init-time lookup runs before the JVM attaches, so without the app-creation re-resolve the active locale stays the bare English fallback "en").
dndprobe command
Command dndprobe live-verifies per-widget drop targets (#515 Part A).
 Command dndprobe live-verifies per-widget drop targets (#515 Part A).
dragghostprobe command
Command dragghostprobe live-verifies the in-canvas drag affordances (#819 PR-1): a grab/grabbing cursor for the duration of a drag and a ghost image following the pointer.
 Command dragghostprobe live-verifies the in-canvas drag affordances (#819 PR-1): a grab/grabbing cursor for the duration of a drag and a ghost image following the pointer.
dragoutprobe command
Command dragoutprobe is a live-verify harness for #515 Part B (drag-out to other applications).
 Command dragoutprobe is a live-verify harness for #515 Part B (drag-out to other applications).
dropprobe command
Command dropprobe is a live-verify harness for #708 (drag-motion hover feedback for drop targets).
 Command dropprobe is a live-verify harness for #708 (drag-motion hover feedback for drop targets).
echoprobe966 command
Command echoprobe966 is the on-device verification harness for #966 (shadow-EditText echo bugs): hardware-key double insertion, and the password mask leaking into the next field on focus switch.
 Command echoprobe966 is the on-device verification harness for #966 (shadow-EditText echo bugs): hardware-key double insertion, and the password mask leaking into the next field on focus switch.
entryimeprobe command
Command entryimeprobe is the diagnostic harness for the Android TalkBack text-editing bugs (#572: stuck caret + phantom "space deleted").
 Command entryimeprobe is the diagnostic harness for the Android TalkBack text-editing bugs (#572: stuck caret + phantom "space deleted").
filedialogprobe command
Command filedialogprobe live-verifies the platform-native file dialogs (#514), default-on since #226.
 Command filedialogprobe live-verifies the platform-native file dialogs (#514), default-on since #226.
globalhotkeyprobe command
Command globalhotkeyprobe is a live-verify harness for the system-wide global hotkey API (#518, desktop.GlobalShortcutApp).
 Command globalhotkeyprobe is a live-verify harness for the system-wide global hotkey API (#518, desktop.GlobalShortcutApp).
hotkeyprobe command
Command hotkeyprobe live-verifies global (system-wide) hotkey registration (#518).
 Command hotkeyprobe live-verifies global (system-wide) hotkey registration (#518).
iosverifyprobe command
Command iosverifyprobe is a combined on-device verification harness for the iOS-device-dependent fixes landed together:
 Command iosverifyprobe is a combined on-device verification harness for the iOS-device-dependent fixes landed together:
ioswebviewprobe command
Command ioswebviewprobe is the #75 on-device pass for the iOS WKWebView backend (#64): hosting beside the GLKView, geometry + native clip inside a container.Scroll, the #59 focus bridge in both directions, the bridge and navigation API, and teardown.
 Command ioswebviewprobe is the #75 on-device pass for the iOS WKWebView backend (#64): hosting beside the GLKView, geometry + native clip inside a container.Scroll, the #59 focus bridge in both directions, the bridge and navigation API, and teardown.
modalprobe command
Command modalprobe live-verifies native window-modality for window-hosted dialogs (#498/#681).
 Command modalprobe live-verifies native window-modality for window-hosted dialogs (#498/#681).
modelprobe command
Command modelprobe is the live-verify demo for the data/model sort/filter/ selection layer (#539): a 100k-row list with a live search box, a locale-aware sort toggle, and multi-selection that survives re-sort and re-filter.
 Command modelprobe is the live-verify demo for the data/model sort/filter/ selection layer (#539): a 100k-row list with a live search box, a locale-aware sort toggle, and multi-selection that survives re-sort and re-filter.
multiselectprobe command
multiwindowprobe command
Command multiwindowprobe verifies mobile multi-window stack UX (#645, a #499 follow-up): opening a second NewWindow().Show() over a visible one pushes a child window that covers the parent and carries a titlebar with a close (X) button; closing it pops back to the parent.
 Command multiwindowprobe verifies mobile multi-window stack UX (#645, a #499 follow-up): opening a second NewWindow().Show() over a visible one pushes a child window that covers the parent and carries a titlebar with a close (X) button; closing it pops back to the parent.
notifyprobe command
Command notifyprobe is a live-verify harness for rich system notifications (#516, bellui.NotifierWithOptionsApp / SendNotificationWithOptions): click activation, an inline action button and a per-notification icon.
 Command notifyprobe is a live-verify harness for rich system notifications (#516, bellui.NotifierWithOptionsApp / SendNotificationWithOptions): click activation, an inline action button and a per-notification icon.
openwith command
Command openwith is the live-verify probe for the desktop "open with" events (#510 Phase 1: bellui.OpenHandlerApp — SetOnFileOpened / SetOnURLOpened).
 Command openwith is the live-verify probe for the desktop "open with" events (#510 Phase 1: bellui.OpenHandlerApp — SetOnFileOpened / SetOnURLOpened).
openwithprobe command
Command openwithprobe verifies iOS "open with" / deep-link delivery (#622): bellui.OpenHandlerApp's SetOnURLOpened / SetOnFileOpened firing from the native application:openURL: delegate, end to end including the packaging metadata (CFBundleURLTypes emitted from manifest.pxf URLSchemes = ["belluiopen"], tools#4).
 Command openwithprobe verifies iOS "open with" / deep-link delivery (#622): bellui.OpenHandlerApp's SetOnURLOpened / SetOnFileOpened firing from the native application:openURL: delegate, end to end including the packaging metadata (CFBundleURLTypes emitted from manifest.pxf URLSchemes = ["belluiopen"], tools#4).
progressprobe command
rasterstream command
Command rasterstream is the live-verify probe for canvas.Raster streaming (#34) — the path a video player drives with SetPixels.
 Command rasterstream is the live-verify probe for canvas.Raster streaming (#34) — the path a video player drives with SetPixels.
recreateprobe command
Command recreateprobe live-verifies in-process Android activity recreation (#283): a configuration change the manifest does not declare makes the framework destroy and recreate the activity inside the surviving process, and the toolkit must come back painting instead of hanging the Java main thread in the redraw handshake (ANR).
 Command recreateprobe live-verifies in-process Android activity recreation (#283): a configuration change the manifest does not declare makes the framework destroy and recreate the activity inside the surviving process, and the toolkit must come back painting instead of hanging the Java main thread in the redraw handshake (ANR).
renderprobe command
Command renderprobe is an on-device verification harness for the GPU render pipeline (roadmap §6 / #34): it puts a rotating 3D cube (canvas.Scene3D), an elevated Card (canvas.BoxShadow), and a RepaintBoundary-wrapped animated widget on screen at once, so a device screenshot confirms shadows, 3D rasterization+compositing, and boundary-cached subtrees all render correctly under the WebGPU painter.
 Command renderprobe is an on-device verification harness for the GPU render pipeline (roadmap §6 / #34): it puts a rotating 3D cube (canvas.Scene3D), an elevated Card (canvas.BoxShadow), and a RepaintBoundary-wrapped animated widget on screen at once, so a device screenshot confirms shadows, 3D rasterization+compositing, and boundary-cached subtrees all render correctly under the WebGPU painter.
repro1086 command
Command repro1086 drives the #1086 aligned-oversized-container scene on a real window (WebGPU/Metal by default) so the anchor point can be eyeballed against the software golden (hack/repro1086 TestSoftwareGolden).
 Command repro1086 drives the #1086 aligned-oversized-container scene on a real window (WebGPU/Metal by default) so the anchor point can be eyeballed against the software golden (hack/repro1086 TestSoftwareGolden).
repro960 command
Command repro960 drives the #960 scene (Transform-scaled canvas.Text vs untransformed and Transform-scaled Rectangles) on a real window.
 Command repro960 drives the #960 scene (Transform-scaled canvas.Text vs untransformed and Transform-scaled Rectangles) on a real window.
richentryprobe command
Command richentryprobe is the live-verify harness for widget.RichEntry (#667), the editable rich-text surface (epic #648).
 Command richentryprobe is the live-verify harness for widget.RichEntry (#667), the editable rich-text surface (epic #648).
richimeprobe command
Command richimeprobe verifies widget.RichEntry IME composition on real targets (#674), side by side with a plain widget.Entry as the control.
 Command richimeprobe verifies widget.RichEntry IME composition on real targets (#674), side by side with a plain widget.Entry as the control.
ring1107probe command
Command ring1107probe verifies the iOS VoiceOver per-line ring alignment fix (#1107) on a real iPad.
 Command ring1107probe verifies the iOS VoiceOver per-line ring alignment fix (#1107) on a real iPad.
shareprobe command
Command shareprobe verifies the mobile intent/share integration:
 Command shareprobe verifies the mobile intent/share integration:
singleinstance command
Command singleinstance is the live-verify probe for single-instance mode with argument forwarding (#509 / bellui.SingleInstanceApp).
 Command singleinstance is the live-verify probe for single-instance mode with argument forwarding (#509 / bellui.SingleInstanceApp).
systrayprobe command
Command systrayprobe live-verifies the system tray tooltip and custom tap-callback extensions (#511).
 Command systrayprobe live-verifies the system tray tooltip and custom tap-callback extensions (#511).
taskbarprobe command
Command taskbarprobe is a live-verify harness for desktop.ProgressWindow (#517 taskbar progress).
 Command taskbarprobe is a live-verify harness for desktop.ProgressWindow (#517 taskbar progress).
tooltipprobe command
touchprobe command
Command touchprobe live-verifies desktop touchscreen gesture dispatch (#266): the glfw fork's touch callback (belluikit/glfw#1, v1.10.0) feeds the shared TouchHandler, so a Windows (WM_POINTER) or Wayland (wl_touch) touchscreen reaches the mobile gesture vocabulary — tap, drag, double-tap, and hold-fire long-press (#758).
 Command touchprobe live-verifies desktop touchscreen gesture dispatch (#266): the glfw fork's touch callback (belluikit/glfw#1, v1.10.0) feeds the shared TouchHandler, so a Windows (WM_POINTER) or Wayland (wl_touch) touchscreen reaches the mobile gesture vocabulary — tap, drag, double-tap, and hold-fire long-press (#758).
touchselprobe command
Command touchselprobe is the on-device harness for the mobile touch text-selection stack (#945): #758 hold-fire long-press + selection handles, #942 drag magnifier/loupe, #943 caret drag-handle, #944 selectable Label/RichText parity, #888 RichEntry handles + styled-run loupe.
 Command touchselprobe is the on-device harness for the mobile touch text-selection stack (#945): #758 hold-fire long-press + selection handles, #942 drag magnifier/loupe, #943 caret drag-handle, #944 selectable Label/RichText parity, #888 RichEntry handles + styled-run loupe.
webgpuwaylandprobe command
Command webgpuwaylandprobe verifies that the default (WebGPU) painter creates and renders to a native Wayland surface (#608, a #542 follow-up).
 Command webgpuwaylandprobe verifies that the default (WebGPU) painter creates and renders to a native Wayland surface (#608, a #542 follow-up).
webviewprobe command
Command webviewprobe is the live-verify probe for the native-view-embedding spike (#45) and the bridge and navigation API designed on top of it (#66): widget.NativeViewHost hosting the platform's real web engine — a WKWebView on macOS, a WebView2 on Windows (#65).
 Command webviewprobe is the live-verify probe for the native-view-embedding spike (#45) and the bridge and navigation API designed on top of it (#66): widget.NativeViewHost hosting the platform's real web engine — a WKWebView on macOS, a WebView2 on Windows (#65).
winhoverprobe command
Command winhoverprobe live-verifies Windows drag-motion hover feedback (bellui #926 / glfw OLE IDropTarget).
 Command winhoverprobe live-verifies Windows drag-motion hover feedback (bellui #926 / glfw OLE IDropTarget).
winposprobe command
Command winposprobe reports where the OS/GLFW places bellui windows that never ask for a position (#955).
 Command winposprobe reports where the OS/GLFW places bellui windows that never ask for a position (#955).
winwatchprobe command
Command winwatchprobe is the live-verify harness for belluikit/bellui#68 — intermittent Go runtime fatals (runtime.semawakeup / runtime.semasleep / netpoll failed, all errno=6 = ERROR_INVALID_HANDLE) in internal/repository on windows/arm64.
 Command winwatchprobe is the live-verify harness for belluikit/bellui#68 — intermittent Go runtime fatals (runtime.semawakeup / runtime.semasleep / netpoll failed, all errno=6 = ERROR_INVALID_HANDLE) in internal/repository on windows/arm64.
xdgforeignprobe command
Command xdgforeignprobe verifies the xdg-foreign portal-dialog parenting on Wayland (fyne#626 + belluikit/glfw#7).
 Command xdgforeignprobe verifies the xdg-foreign portal-dialog parenting on Wayland (fyne#626 + belluikit/glfw#7).
accessibility
Package accessibility builds the platform-neutral semantic tree that screen-reader backends expose to assistive technologies (#484).
 Package accessibility builds the platform-neutral semantic tree that screen-reader backends expose to assistive technologies (#484).
animation
app
async
Package async provides unbounded channel and queue structures that are designed for caching unlimited number of a concrete type.
 Package async provides unbounded channel and queue structures that are designed for caching unlimited number of a concrete type.
build
Package build contains information about they type of build currently running.
 Package build contains information about they type of build currently running.
cache
clipboard
Package clipboard provides pure-Go codecs for platform clipboard payloads: the Windows CF_HTML ("HTML Format") header block and device-independent bitmaps (CF_DIB).
 Package clipboard provides pure-Go codecs for platform clipboard payloads: the Windows CF_HTML ("HTML Format") header block and device-independent bitmaps (CF_DIB).
color
driver
driver/common
driver/embedded
driver/glfw
Package glfw provides a full Bellui desktop driver that uses the system OpenGL libraries.
 Package glfw provides a full Bellui desktop driver that uses the system OpenGL libraries.
driver/mobile
driver/mobile/app
Package app lets you write portable all-Go apps for Android and iOS.
 Package app lets you write portable all-Go apps for Android and iOS.
driver/mobile/event/composition
Package composition defines the IME composition (preedit) event used by the mobile driver to carry input-method composition state from the native platform layer to the focused widget.
 Package composition defines the IME composition (preedit) event used by the mobile driver to carry input-method composition state from the native platform layer to the focused widget.
driver/mobile/event/config
Package config defines the event that reports an in-place configuration change to the mobile driver.
 Package config defines the event that reports an in-place configuration change to the mobile driver.
driver/mobile/event/key
Package key defines an event for physical keyboard keys.
 Package key defines an event for physical keyboard keys.
driver/mobile/event/lifecycle
Package lifecycle defines an event for an app's lifecycle.
 Package lifecycle defines an event for an app's lifecycle.
driver/mobile/event/paint
Package paint defines an event for the app being ready to paint.
 Package paint defines an event for the app being ready to paint.
driver/mobile/event/size
Package size defines an event for the dimensions, physical resolution and orientation of the app's window.
 Package size defines an event for the dimensions, physical resolution and orientation of the app's window.
driver/mobile/event/textedit
Package textedit defines the committed text-edit event used by the mobile driver to carry a native IME/keyboard edit — a range replacement — from the platform layer to the focused editor through the text-input mirror seam (#771).
 Package textedit defines the committed text-edit event used by the mobile driver to carry a native IME/keyboard edit — a range replacement — from the platform layer to the focused editor through the text-input mirror seam (#771).
driver/mobile/event/touch
Package touch defines an event for touch input.
 Package touch defines an event for touch input.
driver/mobile/event/undoredo
Package undoredo defines the native undo/redo invocation event used by the mobile driver to carry a platform-initiated undo or redo — the iPad soft keyboard's undo/redo bar keys, the three-finger swipe gestures or shake-to-undo, all of which drive the first responder's NSUndoManager — from the platform layer to the focused editor (#1134).
 Package undoredo defines the native undo/redo invocation event used by the mobile driver to carry a platform-initiated undo or redo — the iPad soft keyboard's undo/redo bar keys, the three-finger swipe gestures or shake-to-undo, all of which drive the first responder's NSUndoManager — from the platform layer to the focused editor (#1134).
driver/mobile/gl
Package gl implements Go bindings for OpenGL ES 2.0 and ES 3.0.
 Package gl implements Go bindings for OpenGL ES 2.0 and ES 3.0.
driver/mobile/mobileinit
Package mobileinit contains common initialization logic for mobile platforms that is relevant to both all-Go apps and gobind-based apps.
 Package mobileinit contains common initialization logic for mobile platforms that is relevant to both all-Go apps and gobind-based apps.
gpu
Package gpu defines the backend-neutral painter interfaces used by the drivers.
 Package gpu defines the backend-neutral painter interfaces used by the drivers.
gsportal
Package gsportal is a pure-Go client for the freedesktop org.freedesktop.portal.GlobalShortcuts D-Bus portal — the only way to register system-wide hotkeys under Wayland, where there is no client key-grab API by design.
 Package gsportal is a pure-Go client for the freedesktop org.freedesktop.portal.GlobalShortcuts D-Bus portal — the only way to register system-wide hotkeys under Wayland, where there is no client key-grab API by design.
ico
metadata
metadata/belluiapppb
oksvg
painter
painter/software
painter/webgpu
Package webgpu will host the WebGPU implementation of the backend-neutral gpu.Painter interface (WebGPU migration, issue #198, Phase 2 / #201).
 Package webgpu will host the WebGPU implementation of the backend-neutral gpu.Painter interface (WebGPU migration, issue #198, Phase 2 / #201).
preferences/prefspb
rasterx
Package rasterx implements a rasterizer in go.
 Package rasterx implements a rasterizer in go.
render
repository
repository/mime
scale
settings/settingspb
svg
test
textbuf
Package textbuf provides the editable text storage backing the lazy single-segment editing path of widget.Entry / widget.RichText (#381).
 Package textbuf provides the editable text storage backing the lazy single-segment editing path of widget.Entry / widget.RichText (#381).
textinput
Package textinput defines the neutral text-input mirror seam shared by every platform's native text-editing / IME integration (#768, epic #490).
 Package textinput defines the neutral text-input mirror seam shared by every platform's native text-editing / IME integration (#768, epic #490).
theme
thread
Package thread provides low-level goroutine identification primitives with zero dependencies on the bellui package, allowing both the root bellui package and internal packages to import it without circular dependencies.
 Package thread provides low-level goroutine identification primitives with zero dependencies on the bellui package, allowing both the root bellui package and internal packages to import it without circular dependencies.
uidir
Package uidir holds an ambient, per-goroutine user-interface direction override.
 Package uidir holds an ambient, per-goroutine user-interface direction override.
widget
Package lang introduces a translation and localisation API for Bellui applications
 Package lang introduces a translation and localisation API for Bellui applications
Package layout defines the various layouts available to Bellui apps.
 Package layout defines the various layouts available to Bellui apps.
Package storage provides storage access and management functionality.
 Package storage provides storage access and management functionality.
repository
Package repository provides primitives for working with storage repositories.
 Package repository provides primitives for working with storage repositories.
Package test provides utility drivers for running UI tests without rendering to a screen.
 Package test provides utility drivers for running UI tests without rendering to a screen.
Package theme defines how a Bellui app should look when rendered.
 Package theme defines how a Bellui app should look when rendered.
cjk
Package cjk bundles a Noto Sans CJK fallback font and registers it as a global font fallback, so Chinese/Japanese/Korean text renders without each app having to supply its own font — on every platform, including WebAssembly, where system fonts cannot be scanned.
 Package cjk bundles a Noto Sans CJK fallback font and registers it as a global font fallback, so Chinese/Japanese/Korean text renders without each app having to supply its own font — on every platform, including WebAssembly, where system fonts cannot be scanned.
tools
playground
Package playground provides tooling for running bellui applications inside the Go playground.
 Package playground provides tooling for running bellui applications inside the Go playground.
Package webview embeds a web engine in a bellui layout.
 Package webview embeds a web engine in a bellui layout.
Package widget defines the UI widgets within the Bellui toolkit.
 Package widget defines the UI widgets within the Bellui toolkit.
x
charts module
editor module
tables module

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.