mirror of
https://github.com/wailsapp/wails.git
synced 2025-05-04 21:00:31 +08:00
360 lines
7.9 KiB
Markdown
360 lines
7.9 KiB
Markdown
# 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.
|
|
|
|
```go title="main.go" hl_lines="6-9"
|
|
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.
|
|
|
|
```go
|
|
// 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.
|
|
|
|
```go
|
|
// Get the application capabilities
|
|
capabilities := app.Capabilities()
|
|
if capabilities.HasNativeDrag {
|
|
// Do something
|
|
}
|
|
```
|
|
|
|
### GetPID
|
|
|
|
API: `GetPID() int`
|
|
|
|
`GetPID()` returns the Process ID of the application.
|
|
|
|
```go
|
|
pid := app.GetPID()
|
|
```
|
|
|
|
### Run
|
|
|
|
API: `Run() error`
|
|
|
|
`Run()` starts the execution of the application and its components.
|
|
|
|
```go
|
|
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.
|
|
|
|
```go
|
|
// 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.
|
|
|
|
```go
|
|
// Check if dark mode is enabled
|
|
if app.IsDarkMode() {
|
|
// Do something
|
|
}
|
|
```
|
|
|
|
### Hide
|
|
|
|
API: `Hide()`
|
|
|
|
`Hide()` hides the application window.
|
|
|
|
```go
|
|
// Hide the application window
|
|
app.Hide()
|
|
```
|
|
|
|
### Show
|
|
|
|
API: `Show()`
|
|
|
|
`Show()` shows the application window.
|
|
|
|
```go
|
|
// Show the application window
|
|
app.Show()
|
|
```
|
|
|
|
### NewWebviewWindow
|
|
|
|
API: `NewWebviewWindow() *WebviewWindow`
|
|
|
|
`NewWebviewWindow()` creates a new Webview window with default options, and
|
|
returns it.
|
|
|
|
```go
|
|
// 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.
|
|
|
|
```go
|
|
// 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.
|
|
|
|
```go
|
|
// 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.
|
|
|
|
```go
|
|
// 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.
|
|
|
|
```go
|
|
// 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.
|
|
|
|
```go
|
|
|
|
// 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.
|
|
|
|
```go
|
|
// 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.
|
|
|
|
```go
|
|
// 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
|
|
|
|
```go title="application_options.go"
|
|
--8<--
|
|
../v3/pkg/application/options_application.go
|
|
--8<--
|
|
```
|
|
|
|
### Windows Options
|
|
|
|
```go title="application_options_windows.go"
|
|
--8<--
|
|
../v3/pkg/application/options_application_win.go
|
|
--8<--
|
|
```
|
|
|
|
### Mac Options
|
|
|
|
```go title="options_application_mac.go"
|
|
--8<--
|
|
../v3/pkg/application/options_application_mac.go
|
|
--8<--
|
|
```
|