wails/mkdocs-website/docs/en/API/application.md

Application

The application API assists in creating an application using the Wails framework.

New

API: New(appOptions Options) *App

New(appOptions Options) creates a new application using the given application options . It applies default values for unspecified options, merges them with the provided ones, initializes and returns an instance of the application.

In case of an error during initialization, the application is stopped with the error message provided.

It should be noted that if a global application instance already exists, that instance will be returned instead of creating a new one.

package main

import "github.com/wailsapp/wails/v3/pkg/application"

func main() {
    app := application.New(application.Options{
        Name:        "WebviewWindow Demo",
		// Other options
    })

	// Rest of application
}

Get

Get() returns the global application instance. It's useful when you need to access the application from different parts of your code.

    // Get the application instance
    app := application.Get()

Capabilities

API: Capabilities() capabilities.Capabilities

Capabilities() retrieves a map of capabilities that the application currently has. Capabilities can be about different features the operating system provides, like webview features.

    // Get the application capabilities
    capabilities := app.Capabilities()
	if capabilities.HasNativeDrag {
		// Do something
    }

GetPID

API: GetPID() int

GetPID() returns the Process ID of the application.

    pid := app.GetPID()

Run

API: Run() error

Run() starts the execution of the application and its components.

    app := application.New(application.Options{
	    //options
	})
    // Run the application
    err := application.Run()
    if err != nil {
        // Handle error
    }

Quit

API: Quit()

Quit() quits the application by destroying windows and potentially other components.

    // Quit the application
    app.Quit()

IsDarkMode

API: IsDarkMode() bool

IsDarkMode() checks if the application is running in dark mode. It returns a boolean indicating whether dark mode is enabled.

    // Check if dark mode is enabled
    if app.IsDarkMode() {
        // Do something
    }

Hide

API: Hide()

Hide() hides the application window.

    // Hide the application window
    app.Hide()

Show

API: Show()

Show() shows the application window.

    // Show the application window
    app.Show()

NewWebviewWindow

API: NewWebviewWindow() *WebviewWindow

NewWebviewWindow() creates a new Webview window with default options, and returns it.

    // Create a new webview window
    window := app.NewWebviewWindow()

NewWebviewWindowWithOptions

API: NewWebviewWindowWithOptions(windowOptions WebviewWindowOptions) *WebviewWindow

NewWebviewWindowWithOptions() creates a new webview window with custom options. The newly created window is added to a map of windows managed by the application.

    // Create a new webview window with custom options
    window := app.NewWebviewWindowWithOptions(WebviewWindowOptions{
		Name: "Main",
        Title: "My Window",
        Width: 800,
        Height: 600,
    })

OnWindowCreation

API: OnWindowCreation(callback func(window *WebviewWindow))

OnWindowCreation() registers a callback function to be called when a window is created.

    // Register a callback to be called when a window is created
    app.OnWindowCreation(func(window *WebviewWindow) {
        // Do something
    })

GetWindowByName

API: GetWindowByName(name string) *WebviewWindow

GetWindowByName() fetches and returns a window with a specific name.

    // Get a window by name
    window := app.GetWindowByName("Main")

CurrentWindow

API: CurrentWindow() *WebviewWindow

CurrentWindow() fetches and returns a pointer to the currently active window in the application. If there is no window, it returns nil.

    // Get the current window
    window := app.CurrentWindow()

RegisterContextMenu

API: RegisterContextMenu(name string, menu *Menu)

RegisterContextMenu() registers a context menu with a given name. This menu can be used later in the application.

    // Create a new menu
    ctxmenu := app.NewMenu()

    // Register the menu as a context menu
    app.RegisterContextMenu("MyContextMenu", ctxmenu)

SetMenu

API: SetMenu(menu *Menu)

SetMenu() sets the menu for the application. On Mac, this will be the global menu. For Windows and Linux, this will be the default menu for any new window created.

    // Create a new menu
    menu := app.NewMenu()

    // Set the menu for the application
    app.SetMenu(menu)

ShowAboutDialog

API: ShowAboutDialog()

ShowAboutDialog() shows an "About" dialog box. It can show the application's name, description and icon.

    // Show the about dialog
    app.ShowAboutDialog()

Info

API: InfoDialog()

InfoDialog() creates and returns a new instance of MessageDialog with an InfoDialogType. This dialog is typically used to display informational messages to the user.

Question

API: QuestionDialog()

QuestionDialog() creates and returns a new instance of MessageDialog with a QuestionDialogType. This dialog is often used to ask a question to the user and expect a response.

Warning

API: WarningDialog()

WarningDialog() creates and returns a new instance of MessageDialog with a WarningDialogType. As the name suggests, this dialog is primarily used to display warning messages to the user.

Error

API: ErrorDialog()

ErrorDialog() creates and returns a new instance of MessageDialog with an ErrorDialogType. This dialog is designed to be used when you need to display an error message to the user.

OpenFile

API: OpenFileDialog()

OpenFileDialog() creates and returns a new OpenFileDialogStruct. This dialog prompts the user to select one or more files from their file system.

SaveFile

API: SaveFileDialog()

SaveFileDialog() creates and returns a new SaveFileDialogStruct. This dialog prompts the user to choose a location on their file system where a file should be saved.

OpenDirectory

API: OpenDirectoryDialog()

OpenDirectoryDialog() creates and returns a new instance of MessageDialog with an OpenDirectoryDialogType. This dialog enables the user to choose a directory from their file system.

On

API: On(eventType events.ApplicationEventType, callback func(event *Event)) func()

On() registers an event listener for specific application events. The callback function provided will be triggered when the corresponding event occurs. The function returns a function that can be called to remove the listener.

RegisterHook

API: RegisterHook(eventType events.ApplicationEventType, callback func(event *Event)) func()

RegisterHook() registers a callback to be run as a hook during specific events. These hooks are run before listeners attached with On(). The function returns a function that can be called to remove the hook.

GetPrimaryScreen

API: GetPrimaryScreen() (*Screen, error)

GetPrimaryScreen() returns the primary screen of the system.

GetScreens

API: GetScreens() ([]*Screen, error)

GetScreens() returns information about all screens attached to the system.

This is a brief summary of the exported methods in the provided App struct. Do note that for more detailed functionality or considerations, refer to the actual Go code or further internal documentation.

Options

--8<--
../v3/pkg/application/options_application.go
--8<--

Windows Options

--8<--
../v3/pkg/application/options_application_win.go
--8<--

Mac Options

--8<--
../v3/pkg/application/options_application_mac.go
--8<--