Fyne

https://docs.fyne.io
Admin
Fyne is a cross-platform UI toolkit written in Go, designed to build graphical applications for...
Tokens:154,557
Snippets:2,028
Trust Score:8.5
Update:2 months ago
Show doc for...
Tokens:
Raw
### Initialize and Run a Fyne Application

Source: https://docs.fyne.io/started/apprun

Demonstrates the standard setup for a Fyne application, including window creation and starting the event loop.

```go
package main

import (
	"fmt"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Hello")
	myWindow.SetContent(widget.NewLabel("Hello"))

	myWindow.Show()
	myApp.Run()
	tidyUp()
}

func tidyUp() {
	fmt.Println("Exited")
}
```

--------------------------------

### Install and run the demo

Source: https://docs.fyne.io/started/quick

Install the demo binary to your system and execute it from the command line.

```bash
go install fyne.io/demo@latest
```

```bash
demo
```

--------------------------------

### Install and Run Fyne Web Server

Source: https://docs.fyne.io/started/webapp

Install the Fyne CLI tools and start a local web server for testing the application on port 8080.

```bash
go install fyne.io/tools/cmd/fyne@latest
fyne serve
```

--------------------------------

### Install Application System-Wide

Source: https://docs.fyne.io/started/packaging

Installs the current application directly onto the local system.

```bash
fyne install -icon myapp.png
```

--------------------------------

### Clone and prepare examples

Source: https://docs.fyne.io/started/cross-compiling

Steps to clone the Fyne examples repository for testing cross-compilation.

```bash
git clone https://github.com/fyne-io/examples.git
cd examples
```

--------------------------------

### Install Fyne Demo Application

Source: https://docs.fyne.io/started/demo

Install the Fyne CLI tool and use it to package and install the demo as a local graphical application.

```bash
go install fyne.io/tools/cmd/fyne@latest
```

```bash
fyne install fyne.io/demo
```

--------------------------------

### func (*ProgressBarInfinite) Start()

Source: https://docs.fyne.io/api/v2/widget/progressbarinfinite

Starts the infinite progress bar animation.

```APIDOC
## func (*ProgressBarInfinite) Start()

### Description
Starts the infinite progress bar animation.
```

--------------------------------

### Install fyne-cross

Source: https://docs.fyne.io/started/cross-compiling

Commands to install the fyne-cross tool based on the installed Go version.

```bash
go install github.com/fyne-io/fyne-cross@latest
```

```bash
go get github.com/fyne-io/fyne-cross
```

--------------------------------

### Create a simple Fyne application

Source: https://docs.fyne.io/api/v2/fyne/package

A basic example demonstrating how to initialize an application, create a window, and add interactive widgets.

```go
package main

import "fyne.io/fyne/v2/app"
import "fyne.io/fyne/v2/container"
import "fyne.io/fyne/v2/widget"

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

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

	w.ShowAndRun()
}
```

--------------------------------

### Complete system tray application

Source: https://docs.fyne.io/explore/systray

A full example demonstrating the integration of system tray menus and window lifecycle management.

```go
package main

import (
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/driver/desktop"
	"fyne.io/fyne/v2/widget"
)

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

	if desk, ok := a.(desktop.App); ok {
		m := fyne.NewMenu("MyApp",
			fyne.NewMenuItem("Show", func() {
				w.Show()
			}))
		desk.SetSystemTrayMenu(m)
	}

	w.SetContent(widget.NewLabel("Fyne System Tray"))
	w.SetCloseIntercept(func() {
		w.Hide()
	})
	w.ShowAndRun()
}
```

--------------------------------

### Install Fyne Toolkit

Source: https://docs.fyne.io/

Use the Go toolchain to fetch the latest version of the Fyne library.

```bash
go get fyne.io/fyne/v2@latest
```

```bash
go get fyne.io/fyne/v2
```

--------------------------------

### Complete numericalEntry implementation

Source: https://docs.fyne.io/extend/numerical-entry

Full example combining all overrides into a functional application.

```go
package main

import (
	"strconv"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/driver/mobile"
	"fyne.io/fyne/v2/widget"
)

type numericalEntry struct {
	widget.Entry
}

func newNumericalEntry() *numericalEntry {
	entry := &numericalEntry{}
	entry.ExtendBaseWidget(entry)
	return entry
}

func (e *numericalEntry) TypedRune(r rune) {
	if (r >= '0' && r <= '9') || r == '.' || r == ',' {
		e.Entry.TypedRune(r)
	}
}

func (e *numericalEntry) TypedShortcut(shortcut fyne.Shortcut) {
	paste, ok := shortcut.(*fyne.ShortcutPaste)
	if !ok {
		e.Entry.TypedShortcut(shortcut)
		return
	}

	content := paste.Clipboard.Content()
	if _, err := strconv.ParseFloat(content, 64); err == nil {
		e.Entry.TypedShortcut(shortcut)
	}
}

func (e *numericalEntry) Keyboard() mobile.KeyboardType {
	return mobile.NumberKeyboard
}

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

	entry := newNumericalEntry()

	w.SetContent(entry)
	w.ShowAndRun()
}
```

--------------------------------

### Install development tools on Termux

Source: https://docs.fyne.io/started/quick

Installs Go and Git on an Android device using the Termux package manager.

```bash
pkg install golang git
```

--------------------------------

### Install Fyne dependencies

Source: https://docs.fyne.io/started/quick

Download the Fyne module and install the Fyne command-line helper tool.

```bash
go get fyne.io/fyne/v2@latest
go install fyne.io/tools/cmd/fyne@latest
```

--------------------------------

### Install and Package for macOS

Source: https://docs.fyne.io/started/packaging

Installs the Fyne packaging tool and creates a macOS application bundle from a PNG icon.

```bash
go install fyne.io/tools/cmd/fyne@latest
fyne package -os darwin -icon myapp.png
```

--------------------------------

### Define UI components for testing

Source: https://docs.fyne.io/started/testing

Initial UI setup returning a label and entry field for interaction.

```go
func makeUI() (*widget.Label, *widget.Entry) {
	return widget.NewLabel("Hello world!"),
		widget.NewEntry()
}

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

	w.SetContent(container.NewVBox(makeUI()))
	w.ShowAndRun()
}
```

--------------------------------

### Install on iOS Simulator

Source: https://docs.fyne.io/started/mobile

Use xcrun to install the packaged application onto a booted iOS simulator.

```bash
xcrun simctl install booted myapp.app
```

--------------------------------

### Install dependencies on Linux and BSD

Source: https://docs.fyne.io/started/quick

Package manager commands to install Go, GCC, and graphics library headers for various distributions.

```bash
sudo apt-get install golang gcc libgl1-mesa-dev xorg-dev libwayland-dev libxkbcommon-dev
```

```bash
sudo dnf install golang golang-misc gcc libXcursor-devel libXrandr-devel mesa-libGL-devel libXi-devel libXinerama-devel libXxf86vm-devel libxkbcommon-devel wayland-devel
```

```bash
sudo pacman -S go xorg-server-devel libxcursor libxrandr libxinerama libxi wayland libxkbcommon
```

```bash
sudo eopkg it -c system.devel golang mesalib-devel libxrandr-devel libxcursor-devel libxi-devel libxinerama-devel wayland-devel libxkbcommon-devel
```

```bash
sudo zypper install go gcc libXcursor-devel libXrandr-devel Mesa-libGL-devel libXi-devel libXinerama-devel libXxf86vm-devel wayland-devel libxkbcommon-devel
```

```bash
sudo xbps-install -S go base-devel xorg-server-devel libXrandr-devel libXcursor-devel libXinerama-devel libXxf86vm-devel libxkbcommon-devel wayland-devel
```

```bash
sudo apk add go gcc libxcursor-dev libxrandr-dev libxinerama-dev libxi-dev linux-headers mesa-dev libxkbcommon-dev wayland-dev
```

```bash
nix-shell -p libGL pkg-config xorg.libX11.dev xorg.libXcursor xorg.libXi xorg.libXinerama xorg.libXrandr xorg.libXxf86vm libxkbcommon wayland
```

```bash
sudo pkg install go gcc xorg pkgconf wayland libxkbcommon
```

```bash
sudo pkg_add go wayland libxkbcommon
```

```bash
sudo pkgin install go pkgconf wayland libxkbcommon
```

--------------------------------

### Initialize test file structure

Source: https://docs.fyne.io/started/testing

Standard Go test file setup for Fyne applications.

```go
package main

import (
   "testing"
)

func TestGreeting(t *testing.T) {
}
```

--------------------------------

### func (*Activity) Start

Source: https://docs.fyne.io/api/v2/widget/activity

Starts the animation for the activity indicator.

```APIDOC
### func (*Activity) Start

#### Description
Starts the activity indicator animation.

#### Signature
`func (a *Activity) Start()`
```

--------------------------------

### Starting an animation

Source: https://docs.fyne.io/api/v2/fyne/animation

Registers the animation with the application run-loop to begin execution.

```go
func (a *Animation) Start()
```

--------------------------------

### Install MSYS2 toolchain on Windows

Source: https://docs.fyne.io/started/quick

Commands to install Git, Go, and the MinGW toolchain via the MSYS2 package manager.

```bash
pacman -Syu
pacman -S git mingw-w64-x86_64-toolchain mingw-w64-x86_64-go
```

--------------------------------

### Complete Timeout Application Example

Source: https://docs.fyne.io/explore/preferences

Full implementation of an application that uses preferences to persist a user-selected timeout duration.

```go
package main

import (
    "time"

    "fyne.io/fyne/v2/app"
    "fyne.io/fyne/v2/widget"
)

func main() {
    a := app.NewWithID("com.example.tutorial.preferences")
    w := a.NewWindow("Timeout")

    var timeout time.Duration

    timeoutSelector := widget.NewSelect([]string{"10 seconds", "30 seconds", "1 minute"}, func(selected string) {
        switch selected {
        case "10 seconds":
            timeout = 10 * time.Second
        case "30 seconds":
            timeout = 30 * time.Second
        case "1 minute":
            timeout = time.Minute
        }

        a.Preferences().SetString("AppTimeout", selected)
    })

    timeoutSelector.SetSelected(a.Preferences().StringWithFallback("AppTimeout", "10 seconds"))

    go func() {
        time.Sleep(timeout)
        a.Quit()
    }()

    w.SetContent(timeoutSelector)
    w.ShowAndRun()
}
```

--------------------------------

### Prepend

Source: https://docs.fyne.io/api/v2/widget/toolbar

Adds a new item to the start of the toolbar.

```APIDOC
## func (*Toolbar) Prepend(item ToolbarItem)

### Description
Prepends a new ToolbarItem to the start of this Toolbar.

### Parameters
- **item** (ToolbarItem) - Required - The item to add to the toolbar.
```

--------------------------------

### Install Xcode command line tools

Source: https://docs.fyne.io/started/quick

Initializes the Xcode command line tools required for macOS development.

```bash
xcode-select --install
```

--------------------------------

### Get Laid Out Objects

Source: https://docs.fyne.io/api/v2/test/pkg

Returns all fyne.CanvasObject starting at the given object which is laid out previously.

```go
func LaidOutObjects(o fyne.CanvasObject) (objects []fyne.CanvasObject)
```

--------------------------------

### Creating a new application instance

Source: https://docs.fyne.io/api/v2/app/pkg

Initializes a new application using the default driver. Use the 'ci' build tag to run in-memory.

```go
func New() fyne.App
```

--------------------------------

### Create a basic Fyne application

Source: https://docs.fyne.io/guiintro

Initializes a new application instance, creates a window, and sets a label as the window content.

```go
package main

import (
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Hello")

	myWindow.SetContent(widget.NewLabel("Hello Fyne!"))

	myWindow.ShowAndRun()
}
```

--------------------------------

### Complete clock application using goroutines

Source: https://docs.fyne.io/started/goroutines

A full example demonstrating a background ticker updating a canvas text element via fyne.Do.

```go
package main

import (
	"image/color"
	"time"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/canvas"
)

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

	output := canvas.NewText(time.Now().Format(time.TimeOnly), color.NRGBA{G: 0xff, A: 0xff})
	output.TextStyle.Monospace = true
	output.TextSize = 32
	w.SetContent(output)

	go func() {
		ticker := time.NewTicker(time.Second)
		for range ticker.C {
			fyne.Do(func() {
				output.Text = time.Now().Format(time.TimeOnly)
				output.Refresh()
			})
		}
	}()
	w.ShowAndRun()
}
```

--------------------------------

### Create Multiple Windows

Source: https://docs.fyne.io/started/windows

Demonstrates initializing an application with two distinct windows shown simultaneously.

```go
package main

import (
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

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

	w.SetContent(widget.NewLabel("Hello World!"))
	w.Show()

	w2 := a.NewWindow("Larger")
	w2.SetContent(widget.NewLabel("More content"))
	w2.Resize(fyne.NewSize(100, 100))
	w2.Show()

	a.Run()
}
```

--------------------------------

### Full example of updating content on button tap

Source: https://docs.fyne.io/started/updating

A complete application demonstrating how to update a label's text when a button is clicked.

```go
package main

import (
	"time"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"
)

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

	message := widget.NewLabel("Welcome")
	button := widget.NewButton("Update", func() {
		formatted := time.Now().Format("Time: 03:04:05")
		message.SetText(formatted)
	})

	w.SetContent(container.NewVBox(message, button))
	w.ShowAndRun()
}
```

--------------------------------

### Create a basic Entry widget

Source: https://docs.fyne.io/widget/entry

Demonstrates initializing an entry widget with a placeholder and accessing its text content via a button callback.

```go
package main

import (
	"log"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Entry Widget")

	input := widget.NewEntry()
	input.SetPlaceHolder("Enter text...")

	content := container.NewVBox(input, widget.NewButton("Save", func() {
		log.Println("Content was:", input.Text)
	}))

	myWindow.SetContent(content)
	myWindow.ShowAndRun()
}
```

--------------------------------

### Create a Toolbar with Actions and Spacers

Source: https://docs.fyne.io/widget/toolbar

Demonstrates initializing a toolbar with various action items, a separator, and a spacer to align elements.

```go
package main

import (
	"log"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/theme"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Toolbar Widget")

	toolbar := widget.NewToolbar(
		widget.NewToolbarAction(theme.DocumentCreateIcon(), func() {
			log.Println("New document")
		}),
		widget.NewToolbarSeparator(),
		widget.NewToolbarAction(theme.ContentCutIcon(), func() {}),
		widget.NewToolbarAction(theme.ContentCopyIcon(), func() {}),
		widget.NewToolbarAction(theme.ContentPasteIcon(), func() {}),
		widget.NewToolbarSpacer(),
		widget.NewToolbarAction(theme.HelpIcon(), func() {
			log.Println("Display help")
		}),
	)

	content := container.NewBorder(toolbar, nil, nil, nil, widget.NewLabel("Content"))
	myWindow.SetContent(content)
	myWindow.ShowAndRun()
}
```

--------------------------------

### Create and control an Activity widget

Source: https://docs.fyne.io/widget/activity

Initializes an activity indicator, starts the animation, and stops it after a simulated background task completes.

```go
package main

import (
	"time"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Activity Widget")

	activity := widget.NewActivity()
	activity.Start()

	go func() {
		time.Sleep(time.Second * 5) // pretend to do some work
		activity.Stop()
		activity.Hide()
	}()

	myWindow.SetContent(container.NewCenter(activity))
	myWindow.ShowAndRun()
}
```

--------------------------------

### Basic Preferences Usage

Source: https://docs.fyne.io/explore/preferences

Demonstrates initializing an app with a unique ID and performing basic read/write operations on preferences.

```go
a := app.NewWithID("com.example.tutorial.preferences")
[...]
a.Preferences().SetBool("Boolean", true)
a.Preferences().SetFloatList("Constants", []float64{3.142, 2.718})
number := a.Preferences().IntWithFallback("ApplicationLuckyNumber", 21)
expression := a.Preferences().String("RegularExpression")
[...]
```

--------------------------------

### Install Fyne CLI Tool

Source: https://docs.fyne.io/faq/troubleshoot

Command to install the latest version of the Fyne command-line tool.

```bash
go install fyne.io/tools/cmd/fyne@latest
```

--------------------------------

### Create a Form with Input Fields

Source: https://docs.fyne.io/widget/form

Demonstrates initializing a form with a standard entry and a multiline entry, including an OnSubmit handler to process input.

```go
package main

import (
	"log"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Form Widget")

	entry := widget.NewEntry()
	textArea := widget.NewMultiLineEntry()

	form := &widget.Form{
		Items: []*widget.FormItem{ // we can specify items in the constructor
			{Text: "Entry", Widget: entry}},
		OnSubmit: func() { // optional, handle form submission
			log.Println("Form submitted:", entry.Text)
			log.Println("multiline:", textArea.Text)
			myWindow.Close()
		},
	}

	// we can also append items
	form.Append("Text", textArea)

	myWindow.SetContent(form)
	myWindow.ShowAndRun()
}
```

--------------------------------

### Install Android APK

Source: https://docs.fyne.io/started/mobile

Install the generated APK file onto an Android device or simulator using the Android Debug Bridge.

```bash
adb install myapp.apk
```

--------------------------------

### Create Test App

Source: https://docs.fyne.io/api/v2/test/pkg

Returns a new dummy app used for testing, loading a test driver with a virtual window.

```go
func NewApp() fyne.App
```

--------------------------------

### Set window content to a widget

Source: https://docs.fyne.io/explore/canvas

Shows how to initialize an application and set a widget.Entry as the primary window content.

```go
package main

import (
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Widget")

	myWindow.SetContent(widget.NewEntry())
	myWindow.ShowAndRun()
}
```

--------------------------------

### Get ToolbarObject

Source: https://docs.fyne.io/api/v2/widget/toolbarspacer

Retrieves the underlying canvas object for the spacer.

```go
func (t *ToolbarSpacer) ToolbarObject() fyne.CanvasObject
```

--------------------------------

### Create and configure a SelectEntry widget

Source: https://docs.fyne.io/widget/selectentry

Initializes a SelectEntry with a list of options and sets up an OnChanged callback to handle user input.

```go
package main

import (
	"log"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("SelectEntry Widget")

	combo := widget.NewSelectEntry([]string{"Red", "Green", "Blue"})
	combo.PlaceHolder = "Choose or type a colour"
	combo.OnChanged = func(value string) {
		log.Println("Colour is", value)
	}

	myWindow.SetContent(combo)
	myWindow.Resize(fyne.NewSize(250, 100))
	myWindow.ShowAndRun()
}
```

--------------------------------

### Get widget size

Source: https://docs.fyne.io/api/v2/widget/basewidget

Retrieves the current size of the widget.

```go
func (w *BaseWidget) Size() fyne.Size
```

--------------------------------

### Initialize a Go module

Source: https://docs.fyne.io/started/quick

Create a new directory and initialize a Go module for your Fyne application.

```bash
mkdir myapp
cd myapp
go mod init MODULE_NAME
```

--------------------------------

### Initialize a Table Widget

Source: https://docs.fyne.io/collection/table

Demonstrates creating a basic Table widget with defined row/column counts and cell update logic.

```go
package main

import (
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

var data = [][]string{[]string{"top left", "top right"},
	[]string{"bottom left", "bottom right"}}

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Table Widget")

	list := widget.NewTable(
		func() (int, int) {
			return len(data), len(data[0])
		},
		func() fyne.CanvasObject {
			return widget.NewLabel("wide content")
		},
		func(i widget.TableCellID, o fyne.CanvasObject) {
			o.(*widget.Label).SetText(data[i.Row][i.Col])
		})

	myWindow.SetContent(list)
	myWindow.ShowAndRun()
}
```

--------------------------------

### Get resource name

Source: https://docs.fyne.io/api/v2/fyne/staticresource

Returns the unique identifier for the resource.

```go
func (r *StaticResource) Name() string
```

--------------------------------

### Automate bundling with go:generate

Source: https://docs.fyne.io/extend/bundle

Use go:generate headers to manage multiple bundled assets and append them to a single file.

```go
//go:generate fyne bundle -o bundled.go image1.png
//go:generate fyne bundle -o bundled.go -append image2.png
```

--------------------------------

### Get Position Components

Source: https://docs.fyne.io/api/v2/fyne/position

Returns the X and Y elements of the position.

```go
func (p Position) Components() (float32, float32)
```

--------------------------------

### Controlling animation

Source: https://docs.fyne.io/api/v2/widget/activity

Methods to start and stop the activity indicator animation.

```go
func (a *Activity) Start()
```

```go
func (a *Activity) Stop()
```

--------------------------------

### Implement a Stack Layout

Source: https://docs.fyne.io/container/max

Demonstrates creating a container with a stack layout to overlay text on an image.

```go
package main

import (
	"image/color"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/canvas"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/layout"
	"fyne.io/fyne/v2/theme"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Stack Layout")

	img := canvas.NewImageFromResource(theme.FyneLogo())
	text := canvas.NewText("Overlay", color.Black)
	content := container.New(layout.NewStackLayout(), img, text)

	myWindow.SetContent(content)
	myWindow.ShowAndRun()
}
```

--------------------------------

### Get widget position

Source: https://docs.fyne.io/api/v2/widget/basewidget

Retrieves the current position relative to the parent.

```go
func (w *BaseWidget) Position() fyne.Position
```

--------------------------------

### Get minimum size

Source: https://docs.fyne.io/api/v2/widget/basewidget

Returns the minimum size constraint for the widget.

```go
func (w *BaseWidget) MinSize() fyne.Size
```

--------------------------------

### Implementing FormLayout in Fyne

Source: https://docs.fyne.io/container/form

Demonstrates initializing a FormLayout and adding it to a window container.

```go
package main

import (
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/layout"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Form Layout")

	label1 := widget.NewLabel("Label 1")
	value1 := widget.NewLabel("Value")
	label2 := widget.NewLabel("Label 2")
	value2 := widget.NewLabel("Something")
	grid := container.New(layout.NewFormLayout(), label1, value1, label2, value2)
	myWindow.SetContent(grid)
	myWindow.ShowAndRun()
}
```

--------------------------------

### Get the system locale

Source: https://docs.fyne.io/api/v2/lang/pkg

Retrieves the current system locale setting.

```go
func SystemLocale() fyne.Locale
```

--------------------------------

### Create a Navigation container in Go

Source: https://docs.fyne.io/container/navigation

Initializes a navigation stack with a root view and demonstrates pushing a new detail view onto the stack.

```go
package main

import (
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Navigation Container")

	var nav *container.Navigation
	root := container.NewVBox(
		widget.NewLabel("The first screen"),
		widget.NewButton("Show detail", func() {
			detail := widget.NewLabel("The detail of the item")
			nav.PushWithTitle(detail, "Detail")
		}),
	)

	nav = container.NewNavigationWithTitle(root, "Home")

	myWindow.SetContent(nav)
	myWindow.Resize(fyne.NewSize(300, 200))
	myWindow.ShowAndRun()
}
```

--------------------------------

### Getting Minimum Size

Source: https://docs.fyne.io/api/v2/dialog/colorpickerdialog

Returns the minimum size the dialog should not shrink below.

```go
func (d ColorPickerDialog) MinSize() fyne.Size
```

--------------------------------

### Implement a basic Tree widget in Go

Source: https://docs.fyne.io/collection/tree

Demonstrates the initialization of a Tree widget using the required callback functions to define hierarchy, branch status, and node templates.

```go
package main

import (
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Table Widget")

	tree := widget.NewTree(
		func(id widget.TreeNodeID) []widget.TreeNodeID {
			switch id {
			case "":
				return []widget.TreeNodeID{"a", "b", "c"}
			case "a":
				return []widget.TreeNodeID{"a1", "a2"}
			}
			return []string{}
		},
		func(id widget.TreeNodeID) bool {
			return id == "" || id == "a"
		},
		func(branch bool) fyne.CanvasObject {
			if branch {
				return widget.NewLabel("Branch template")
			}
			return widget.NewLabel("Leaf template")
		},
		func(id widget.TreeNodeID, branch bool, o fyne.CanvasObject) {
			text := id
			if branch {
				text += " (branch)"
			}
			o.(*widget.Label).SetText(text)
		})

	myWindow.SetContent(tree)
	myWindow.ShowAndRun()
}
```

--------------------------------

### Widget Configuration and Lifecycle

Source: https://docs.fyne.io/api/v2/container/apptabs

Methods for managing widget visibility, size, and rendering.

```go
func (t *AppTabs) CreateRenderer() fyne.WidgetRenderer
func (t *AppTabs) ExtendBaseWidget(wid fyne.Widget)
func (t *AppTabs) Hide()
func (t *AppTabs) MinSize() fyne.Size
func (t *AppTabs) SetTabLocation(l TabLocation)
func (t *AppTabs) Show()
```

--------------------------------

### Retrieving ToolbarObject

Source: https://docs.fyne.io/api/v2/widget/toolbaraction

Gets the underlying canvas object representing the button for rendering.

```go
func (t *ToolbarAction) ToolbarObject() fyne.CanvasObject
```

--------------------------------

### Getting the ToolbarObject

Source: https://docs.fyne.io/api/v2/widget/toolbarseparator

Retrieves the canvas object representing the visual separator line.

```go
func (t *ToolbarSeparator) ToolbarObject() fyne.CanvasObject
```

--------------------------------

### Open a New Window from a Button

Source: https://docs.fyne.io/started/windows

Shows how to trigger the creation and display of a new window from a button click event.

```go
w2.SetContent(widget.NewButton("Open new", func() {
	w3 := a.NewWindow("Third")
	w3.SetContent(widget.NewLabel("Third"))
	w3.Show()
}))
```

--------------------------------

### Getting the minimum size

Source: https://docs.fyne.io/api/v2/widget/icon

Returns the minimum dimensions the icon widget should maintain.

```go
func (i *Icon) MinSize() fyne.Size
```

--------------------------------

### Apply the custom theme

Source: https://docs.fyne.io/extend/custom-theme

Set the custom theme on the application settings.

```go
app.Settings().SetTheme(&myTheme{})
```

--------------------------------

### Get Canvas for Testing

Source: https://docs.fyne.io/api/v2/test/pkg

Returns a reusable in-memory canvas for testing purposes.

```go
func Canvas() fyne.Canvas
```

--------------------------------

### Get original resource

Source: https://docs.fyne.io/api/v2/theme/primarythemedresource

Returns the original fyne.Resource that was wrapped by this themed resource.

```go
func (res *PrimaryThemedResource) Original() fyne.Resource
```

--------------------------------

### Create size animation

Source: https://docs.fyne.io/api/v2/canvas/pkg

Sets up an animation to transition an object's size.

```go
func NewSizeAnimation(start, stop fyne.Size, d time.Duration, fn func(fyne.Size)) *fyne.Animation
```

--------------------------------

### Create and display icons in Go

Source: https://docs.fyne.io/widget/icon

Initializes a Fyne application and displays home and info icons using the theme package.

```go
package main

import (
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/theme"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Icon Widget")

	home := widget.NewIcon(theme.HomeIcon())
	info := widget.NewIcon(theme.InfoIcon())

	myWindow.SetContent(container.NewVBox(home, info))
	myWindow.ShowAndRun()
}
```

--------------------------------

### Retrieving Tab State

Source: https://docs.fyne.io/api/v2/container/apptabs

Methods to get the currently selected tab or its index.

```go
func (t *AppTabs) CurrentTab() *TabItem
func (t *AppTabs) CurrentTabIndex() int
func (t *AppTabs) Selected() *TabItem
func (t *AppTabs) SelectedIndex() int
```

--------------------------------

### Implement Timeout Goroutine

Source: https://docs.fyne.io/explore/preferences

Starts a background process to terminate the application after the specified duration.

```go
go func() {
    time.Sleep(timeout)
    a.Quit()
}()
```

--------------------------------

### Loading translations in main

Source: https://docs.fyne.io/explore/translations

Register the embedded filesystem with Fyne between app.New and Run().

```go
lang.AddTranslationsFS(translations, "translation")
```

--------------------------------

### Getting the minimum size of the Separator

Source: https://docs.fyne.io/api/v2/widget/separator

Returns the minimal size required to display the separator.

```go
func (s *Separator) MinSize() fyne.Size
```

--------------------------------

### Get Theme Variants

Source: https://docs.fyne.io/api/v2/test/pkg

Returns the known theme variants mapped by a descriptive key.

```go
func KnownThemeVariants() map[string]fyne.ThemeVariant
```

--------------------------------

### Creating a Table

Source: https://docs.fyne.io/api/v2/widget/table

Constructors for initializing a standard Table or a Table with sticky headers.

```go
func NewTable(length func() (rows int, cols int), create func() fyne.CanvasObject, update func(TableCellID, fyne.CanvasObject)) *Table
```

```go
func NewTableWithHeaders(length func() (rows int, cols int), create func() fyne.CanvasObject, update func(TableCellID, fyne.CanvasObject)) *Table
```

--------------------------------

### Create a basic List widget

Source: https://docs.fyne.io/collection/list

Initializes a List widget with a data source, a template creation callback, and an update callback to bind data to UI elements.

```go
package main

import (
	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

var data = []string{"a", "string", "list"}

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("List Widget")

	list := widget.NewList(
		func() int {
			return len(data)
		},
		func() fyne.CanvasObject {
			return widget.NewLabel("template")
		},
		func(i widget.ListItemID, o fyne.CanvasObject) {
			o.(*widget.Label).SetText(data[i])
		})

	myWindow.SetContent(list)
	myWindow.ShowAndRun()
}
```

--------------------------------

### Getting the resource name

Source: https://docs.fyne.io/api/v2/theme/errorthemedresource

Returns the name of the underlying resource, primarily for caching purposes.

```go
func (res *ErrorThemedResource) Name() string
```

--------------------------------

### Initialize a new Menu

Source: https://docs.fyne.io/api/v2/widget/menu

Creates a new Menu instance from a fyne.Menu.

```go
func NewMenu(menu *fyne.Menu) *Menu
```

--------------------------------

### Run Fyne Demo via Go

Source: https://docs.fyne.io/started/demo

Execute the demo application directly from the command line using the Go toolchain.

```bash
go run fyne.io/demo@latest
```

```bash
go run fyne.io/demo
```

--------------------------------

### func NewRadialGradient

Source: https://docs.fyne.io/api/v2/canvas/radialgradient

Creates a new radial gradient instance with the specified start and end colors.

```APIDOC
### func NewRadialGradient(start, end color.Color) *RadialGradient

Creates a new radial gradient.
```

--------------------------------

### Using wildcards with fyne-cross

Source: https://docs.fyne.io/started/cross-compiling

Example of using the arch flag with wildcards to target multiple architectures.

```bash
fyne-cross windows -arch=*
```

```bash
fyne-cross windows -arch=amd64,386
```

--------------------------------

### Create a Horizontal Gradient

Source: https://docs.fyne.io/canvas/gradient

Demonstrates initializing a horizontal gradient from white to transparent and setting it as the window content.

```go
package main

import (
	"image/color"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/canvas"
)

func main() {
	myApp := app.New()
	w := myApp.NewWindow("Gradient")

	gradient := canvas.NewHorizontalGradient(color.White, color.Transparent)
	//gradient := canvas.NewRadialGradient(color.White, color.Transparent)
	w.SetContent(gradient)

	w.Resize(fyne.NewSize(100, 100))
	w.ShowAndRun()
}
```

--------------------------------

### Create Test Window

Source: https://docs.fyne.io/api/v2/test/pkg

Creates and registers a new window for test purposes.

```go
func NewWindow(content fyne.CanvasObject) fyne.Window
```

--------------------------------

### Define a widget renderer structure

Source: https://docs.fyne.io/extend/custom-widget

Example of a renderer structure caching canvas objects for drawing.

```go
type buttonRenderer struct {
	icon   *canvas.Image
	label  *canvas.Text
	shadow *fyne.CanvasObject

	objects []fyne.CanvasObject
	button  *Button
}
```

--------------------------------

### Define a custom widget structure

Source: https://docs.fyne.io/extend/custom-widget

Example of a widget structure extending BaseWidget to store state.

```go
type Button struct {
	BaseWidget
	Text  string
	Style ButtonStyle
	Icon  fyne.Resource

	OnTapped func()
}
```

--------------------------------

### Implement default Font and Size methods

Source: https://docs.fyne.io/extend/custom-theme

Required methods for the theme interface that can delegate to the default theme.

```go
func (m *myTheme) Font(style fyne.TextStyle) fyne.Resource {
	return theme.DefaultTheme().Font(style)
}

func (m *myTheme) Size(name fyne.ThemeSizeName) float32 {
	return theme.DefaultTheme().Size(name)
}
```

--------------------------------

### Create a basic Hyperlink widget

Source: https://docs.fyne.io/widget/hyperlink

Initializes a new hyperlink pointing to a URL, handling potential parsing errors using the standard library.

```go
package main

import (
	"net/url"

	"fyne.io/fyne/v2"
	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/widget"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Hyperlink Widget")

	link, err := url.Parse("https://fyne.io/")
	if err != nil {
		fyne.LogError("Could not parse URL", err)
	}

	myWindow.SetContent(widget.NewHyperlink("Fyne website", link))
	myWindow.ShowAndRun()
}
```

--------------------------------

### Get a listable URI

Source: https://docs.fyne.io/api/v2/storage/pkg

Converts a standard URI into a listable URI using the application driver.

```go
func ListerForURI(uri fyne.URI) (fyne.ListableURI, error)
```

--------------------------------

### Create Test Theme

Source: https://docs.fyne.io/api/v2/test/pkg

Returns a new test theme using quiet ugly colors.

```go
func NewTheme() fyne.Theme
```

--------------------------------

### Get widget theme

Source: https://docs.fyne.io/api/v2/widget/basewidget

Returns the cached theme instance. Available since version 2.5.

```go
func (w *BaseWidget) Theme() fyne.Theme
```

--------------------------------

### Create Test Driver

Source: https://docs.fyne.io/api/v2/test/pkg

Functions to set up and register a new dummy driver for test purposes.

```go
func NewDriver() fyne.Driver
```

```go
func NewDriverWithPainter(painter fynedriver.Painter) fyne.Driver
```

--------------------------------

### Get Theme Icons

Source: https://docs.fyne.io/api/v2/theme/pkg

Functions to retrieve standard theme resources for various UI actions and states.

```go
func UploadIcon() fyne.Resource
```

```go
func ViewFullScreenIcon() fyne.Resource
```

```go
func ViewRefreshIcon() fyne.Resource
```

```go
func ViewRestoreIcon() fyne.Resource
```

```go
func VisibilityIcon() fyne.Resource
```

```go
func VisibilityOffIcon() fyne.Resource
```

```go
func VolumeDownIcon() fyne.Resource
```

```go
func VolumeMuteIcon() fyne.Resource
```

```go
func VolumeUpIcon() fyne.Resource
```

```go
func WarningIcon() fyne.Resource
```

```go
func WindowCloseIcon() fyne.Resource
```

```go
func WindowMaximizeIcon() fyne.Resource
```

```go
func WindowMinimizeIcon() fyne.Resource
```

```go
func ZoomFitIcon() fyne.Resource
```

```go
func ZoomInIcon() fyne.Resource
```

```go
func ZoomOutIcon() fyne.Resource
```

--------------------------------

### Implement greeter logic

Source: https://docs.fyne.io/started/testing

Update the UI function to include the logic that responds to input changes.

```go
func makeUI() (*widget.Label, *widget.Entry) {
	out := widget.NewLabel("Hello world!")
	in := widget.NewEntry()

	in.OnChanged = func(content string) {
		out.SetText("Hello " + content + "!")
	}
	return out, in
}
```

--------------------------------

### Get TextSubHeadingSize

Source: https://docs.fyne.io/api/v2/theme/pkg

Retrieves the standard text size for sub-header elements. Available since version 2.1.

```go
func TextSubHeadingSize() float32
```

--------------------------------

### Create a listable resource

Source: https://docs.fyne.io/api/v2/storage/pkg

Creates a new listable resource, such as a directory, at the specified URI.

```go
func CreateListable(u fyne.URI) error
```

--------------------------------

### Get Parent URI

Source: https://docs.fyne.io/api/v2/storage/pkg

Returns the parent URI of the provided resource. The returned URI is guaranteed to be listable.

```go
func Parent(u fyne.URI) (fyne.URI, error)
```

--------------------------------

### Create position animation

Source: https://docs.fyne.io/api/v2/canvas/pkg

Sets up an animation to transition an object's position.

```go
func NewPositionAnimation(start, stop fyne.Position, d time.Duration, fn func(fyne.Position)) *fyne.Animation
```

--------------------------------

### Get a child URI

Source: https://docs.fyne.io/api/v2/storage/pkg

Returns a new URI referencing a resource nested hierarchically below the provided URI.

```go
func Child(u fyne.URI, component string) (fyne.URI, error)
```

--------------------------------

### Creating containers with various layouts

Source: https://docs.fyne.io/api/v2/container/pkg

Functions for initializing containers with specific layout behaviors.

```go
func New(layout fyne.Layout, objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewAdaptiveGrid(rowcols int, objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewBorder(top, bottom, left, right fyne.CanvasObject, objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewCenter(objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewGridWithColumns(cols int, objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewGridWithRows(rows int, objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewGridWrap(size fyne.Size, objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewHBox(objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewMax(objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewPadded(objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewStack(objects ...fyne.CanvasObject) *fyne.Container
```

```go
func NewVBox(objects ...fyne.CanvasObject) *fyne.Container
```

--------------------------------

### Managing Size and Position

Source: https://docs.fyne.io/api/v2/canvas/radialgradient

Methods for getting and setting the size, minimum size, and position of the radial gradient.

```go
func (o *RadialGradient) MinSize() fyne.Size
func (g *RadialGradient) Move(pos fyne.Position)
func (o *RadialGradient) Position() fyne.Position
func (g *RadialGradient) Resize(size fyne.Size)
func (o *RadialGradient) SetMinSize(size fyne.Size)
func (o *RadialGradient) Size() fyne.Size
```

--------------------------------

### Create a Border Layout in Fyne

Source: https://docs.fyne.io/container/border

Demonstrates initializing a window with a border layout containing top, left, and center elements.

```go
package main

import (
	"image/color"

	"fyne.io/fyne/v2/app"
	"fyne.io/fyne/v2/canvas"
	"fyne.io/fyne/v2/container"
	"fyne.io/fyne/v2/layout"
)

func main() {
	myApp := app.New()
	myWindow := myApp.NewWindow("Border Layout")

	top := canvas.NewText("top bar", color.White)
	left := canvas.NewText("left", color.White)
	middle := canvas.NewText("content", color.White)
	content := container.NewBorder(top, nil, left, nil, middle)
	myWindow.SetContent(content)
	myWindow.ShowAndRun()
}
```

--------------------------------

### TextGrid Constructors

Source: https://docs.fyne.io/api/v2/widget/textgrid

Methods to initialize a new TextGrid instance.

```go
func NewTextGrid() *TextGrid
```

```go
func NewTextGridFromString(content string) *TextGrid
```

--------------------------------

### Show a folder open dialog

Source: https://docs.fyne.io/api/v2/dialog/pkg

Allows the user to choose a folder to open.

```go
func ShowFolderOpen(callback func(fyne.ListableURI, error), parent fyne.Window)
```

--------------------------------

### Creating a New RadialGradient

Source: https://docs.fyne.io/api/v2/canvas/radialgradient

Constructor function to initialize a new radial gradient with specified start and end colors.

```go
func NewRadialGradient(start, end color.Color) *RadialGradient
```

--------------------------------

### RadialGradient Struct Definition

Source: https://docs.fyne.io/api/v2/canvas/radialgradient

The structure defining the start and end colors, and the center offset coordinates for the radial gradient.

```go
type RadialGradient struct {
	StartColor color.Color // The beginning color of the gradient
	EndColor   color.Color // The end color of the gradient
	// The offset of the center for generation of the gradient.
	// This is not a DP measure but relates to the width/height.
	// A value of 0.5 would move the center by the half width/height.
	CenterOffsetX, CenterOffsetY float64
}
```

--------------------------------

### Create File Dialogs

Source: https://docs.fyne.io/api/v2/dialog/filedialog

Functions to initialize different types of file dialogs.

```go
func NewFileOpen(callback func(reader fyne.URIReadCloser, err error), parent fyne.Window) *FileDialog
```

```go
func NewFileSave(callback func(writer fyne.URIWriteCloser, err error), parent fyne.Window) *FileDialog
```

```go
func NewFolderOpen(callback func(fyne.ListableURI, error), parent fyne.Window) *FileDialog
```

--------------------------------

### NewVerticalGradient

Source: https://docs.fyne.io/api/v2/canvas/lineargradient

Creates a new vertically traveling linear gradient where the start color is at the top and the end color is at the bottom.

```APIDOC
## func NewVerticalGradient(start, end color.Color) *LinearGradient

### Description
Creates a new vertically traveling linear gradient. The start color will be at the top of the gradient and the end color will be at the bottom.

### Parameters
- **start** (color.Color) - Required - The beginning color of the gradient
- **end** (color.Color) - Required - The end color of the gradient
```

--------------------------------

### NewHorizontalGradient

Source: https://docs.fyne.io/api/v2/canvas/lineargradient

Creates a new horizontally traveling linear gradient where the start color is at the left and the end color is at the right.

```APIDOC
## func NewHorizontalGradient(start, end color.Color) *LinearGradient

### Description
Creates a new horizontally traveling linear gradient. The start color will be at the left of the gradient and the end color will be at the right.

### Parameters
- **start** (color.Color) - Required - The beginning color of the gradient
- **end** (color.Color) - Required - The end color of the gradient
```

--------------------------------

### Apply a theme for testing

Source: https://docs.fyne.io/api/v2/test/pkg

Sets the theme and waits for it to be applied to the current application.

```go
func ApplyTheme(t *testing.T, theme fyne.Theme)
```

--------------------------------

### Translation file structure examples

Source: https://docs.fyne.io/explore/translations

Translation files should follow a specific naming convention, often organized in a directory.

```bash
$ tree # at translations
.
|-- de.json
|-- en.json
|-- zh.json
```

```bash
$ tree # at translations
.
|-- pt-PT.json
|-- pt-BR.json
|-- pt.json
|-- en.json
```

--------------------------------

### Creating a Toolbar

Source: https://docs.fyne.io/api/v2/widget/toolbar

Constructor for initializing a new Toolbar widget with optional items.

```go
func NewToolbar(items ...ToolbarItem) *Toolbar
```

--------------------------------

### Bundle an asset using the command line

Source: https://docs.fyne.io/extend/bundle

Execute the fyne bundle command to convert a file into a Go source file.

```bash
$ ls
image.png	main.go
$ fyne bundle -o bundled.go image.png
$ ls
bundled.go	image.png	main.go
$
```

--------------------------------

### Getting the theme color name

Source: https://docs.fyne.io/api/v2/theme/invertedthemedresource

Returns the specific theme color name used as the foreground color for the resource.

```go
func (res *InvertedThemedResource) ThemeColorName() fyne.ThemeColorName
```

--------------------------------

### Creating a New ThemeOverride

Source: https://docs.fyne.io/api/v2/container/themeoverride

Constructor function to initialize a new ThemeOverride with specific content and theme.

```go
func NewThemeOverride(obj fyne.CanvasObject, th fyne.Theme) *ThemeOverride
```

--------------------------------

### Handle reserved key errors

Source: https://docs.fyne.io/api/v2/lang/pkg

Example of an error message returned by the loader when reserved keys are mixed with unreserved keys.

```text
reserved keys [Description] mixed with unreserved keys [Name Type]
```

--------------------------------

### Creating a ProgressInfiniteDialog

Source: https://docs.fyne.io/api/v2/dialog/progressinfinitedialog

Initializes a new infinite progress dialog. Call Show() on the returned handle to display it.

```go
func NewProgressInfinite(title, message string, parent fyne.Window) *ProgressInfiniteDialog
```

--------------------------------

### Toolbar Widget Lifecycle Methods

Source: https://docs.fyne.io/api/v2/widget/toolbar

Standard widget methods for rendering and size calculation.

```go
func (t *Toolbar) CreateRenderer() fyne.WidgetRenderer
```

```go
func (t *Toolbar) MinSize() fyne.Size
```

--------------------------------

### Getting the theme color name

Source: https://docs.fyne.io/api/v2/theme/disabledresource

Returns the theme color name used for the foreground, available since version 2.6.

```go
func (res *DisabledResource) ThemeColorName() fyne.ThemeColorName
```

--------------------------------

### Container Constructors

Source: https://docs.fyne.io/api/v2/fyne/container

Functions to initialize a new Container instance.

```go
func NewContainer(objects ...CanvasObject) *Container
```

```go
func NewContainerWithLayout(layout Layout, objects ...CanvasObject) *Container
```

```go
func NewContainerWithoutLayout(objects ...CanvasObject) *Container
```

--------------------------------

### Get WarningColor

Source: https://docs.fyne.io/api/v2/theme/pkg

Retrieves the theme's warning foreground color. Deprecated since 2.3; use Color(theme.ColorNameWarning) instead.

```go
func WarningColor() color.Color
```

--------------------------------

### Create a new StaticResource

Source: https://docs.fyne.io/api/v2/fyne/staticresource

Initializes a new resource object in memory for sharable binary data.

```go
func NewStaticResource(name string, content []byte) *StaticResource
```
Tokens:
Raw