Versão: Próxima Versão 🚧

Menus

É possível adicionar um menu de aplicação aos projetos do Wails. Isso é conseguido definindo uma struct Menu e configurando-a no configuração do aplicativo Menu ou chamando o método MenuSetApplicationMenu.

Um exemplo de como criar um menu:

    app := NewApp()

    AppMenu := menu.NewMenu()
    if runtime.GOOS == "darwin" {
        AppMenu.Append(menu.AppMenu()) // On macOS platform, this must be done right after `NewMenu()`
    }
    FileMenu := AppMenu.AddSubmenu("File")
    FileMenu.AddText("&Open", keys.CmdOrCtrl("o"), func(_ *menu.CallbackData) {
        // do something
    })
    FileMenu.AddSeparator()
    FileMenu.AddText("Quit", keys.CmdOrCtrl("q"), func(_ *menu.CallbackData) {
        // `rt` is an alias of "github.com/wailsapp/wails/v2/pkg/runtime" to prevent collision with standard package
        rt.Quit(app.ctx)
    })

    if runtime.GOOS == "darwin" {
    AppMenu.Append(menu.EditMenu())  // On macOS platform, EditMenu should be appended to enable Cmd+C, Cmd+V, Cmd+Z... shortcuts
    }

    err := wails.Run(&options.App{
        Title:             "Menus Demo",
        Width:             800,
        Height:            600,
        Menu:              AppMenu, // reference the menu above
        Bind: []interface{}{
            app,
        },
    )
    // ...

Também é possível atualizar dinamicamente o menu, atualizando o menu struct e chamando MenuUpdateApplicationMenu.

O exemplo acima usa métodos de ajuda, no entanto, é possível construir as construções do menu manualmente.

Um Menu é uma coleção de MenuItems:

Package: github.com/wailsapp/wails/v2/pkg/menu
type Menu struct {
    Items []*MenuItem
}

Para o menu de Aplicação, cada MenuItem representa um único menu como "Editar".

Um método simples de ajuda é fornecido para menus de construção:

Package: github.com/wailsapp/wails/v2/pkg/menu
func NewMenuFromItems(first *MenuItem, rest ...*MenuItem) *Menu

Isto torna o layout do código mais parecido com o de um menu sem a necessidade de adicionar os itens de menu manualmente depois de criá-los. Como alternativa, você pode apenas criar os itens de menu e adicioná-los ao menu manualmente.

MenuItem

Um MenuItem representa um item dentro de um Menu.

Package: github.com/wailsapp/wails/v2/pkg/menu
// MenuItem represents a menu item contained in a menu
type MenuItem struct {
    Label string
    Role Role
    Accelerator *keys.Accelerator
    Type Type
    Disabled bool
    Hidden bool
    Checked bool
    SubMenu *Menu
    Click Callback
}

Campo	Tipo	Notas
Label	string	O texto do menu
Accelerator	*keys.Accelerator	Vinculação de teclas para este item de menu
Tipo	Tipo	Tipo de MenuItem
Disabled	bool	Desativa o item de menu
Hidden	bool	Oculta este item de menu
Checked	bool	Adiciona uma seleção para o item ( & Tipos de Rádio)
SubMenu	*Menu	Define o submenu
Click	Callback	Função Callback quando clicado no menu
Role	string	Define um papel para este item de menu. Mac apenas por enquanto.

Accelerator

Os aceleradores (às vezes chamados atalhos de teclado) definem uma ligação entre um toque de tecla e um item de menu. Lamentos define um Acelerador como uma combinação ou tecla + Modificador. Eles estão disponíveis no pacote "github.com/wailsapp/wails/v2/pkg/menu/keys".

Exemplo:

Package: github.com/wailsapp/wails/v2/pkg/menu/keys
    // Defines cmd+o on Mac and ctrl-o on Window/Linux
    myShortcut := keys.CmdOrCtrl("o")

Teclas são qualquer caractere único em um teclado com exceção de +, que é definido como plus. Algumas chaves não podem ser representadas como caracteres, portanto há um conjunto de caracteres nomeados que podem ser usados:


`backspace`	`f1`	`f16`	`f31`
`tab`	`f2`	`f17`	`f32`
`return`	`f3`	`f18`	`f33`
`enter`	`f4`	`f19`	`f34`
`escape`	`f5`	`f20`	`f35`
`left`	`f6`	`f21`	`numlock`
`right`	`f7`	`f22`
`up`	`f8`	`f23`
`down`	`f9`	`f24`
`space`	`f10`	`f25`
`delete`	`f11`	`f36`
`home`	`f12`	`f37`
`end`	`f13`	`f38`
`page up`	`f14`	`f39`
`page down`	`f15`	`f30`

Wails também suportam a análise de aceleradores usando a mesma sintaxe que o Electron. Isso é útil para armazenar aceleradores em arquivos de configuração.

Exemplo:

Package: github.com/wailsapp/wails/v2/pkg/menu/keys
    // Defines cmd+o on Mac and ctrl-o on Window/Linux
    myShortcut, err := keys.Parse("Ctrl+Option+A")

Modificador

Os seguintes modificadores são chaves que podem ser usadas em combinação com a tecla de aceleração:

Package: github.com/wailsapp/wails/v2/pkg/menu/keys
const (
    // CmdOrCtrlKey represents Command on Mac and Control on other platforms
    CmdOrCtrlKey Modifier = "cmdorctrl"
    // OptionOrAltKey represents Option on Mac and Alt on other platforms
    OptionOrAltKey Modifier = "optionoralt"
    // ShiftKey represents the shift key on all systems
    ShiftKey Modifier = "shift"
    // ControlKey represents the control key on all systems
    ControlKey Modifier = "ctrl"
)

Vários métodos de ajuda estão disponíveis para criar aceleradores usando modificadores:

Package: github.com/wailsapp/wails/v2/pkg/menu/keys
func CmdOrCtrl(key string) *Accelerator
func OptionOrAlt(key string) *Accelerator
func Shift(key string) *Accelerator
func Control(key string) *Accelerator

Modificadores podem ser combinados usando keys.Combo(string de chaves, modificador 1 modificador, modificador modificador, rest ...Modificador):

Package: github.com/wailsapp/wails/v2/pkg/menu/keys
    // Defines "Ctrl+Option+A" on Mac and "Ctrl+Alt+A" on Window/Linux
    myShortcut := keys.Combo("a", ControlKey, OptionOrAltKey)

Tipo

Cada item de menu deve ter um tipo e existem 5 tipos disponíveis:

Package: github.com/wailsapp/wails/v2/pkg/menu
const (
    TextType Type = "Text"
    SeparatorType Type = "Separator"
    SubmenuType Type = "Submenu"
    CheckboxType Type = "Checkbox"
    RadioType Type = "Radio"
)

Para conveniência, métodos auxiliares são fornecidos para criar rapidamente um item de menu:

Package: github.com/wailsapp/wails/v2/pkg/menu
func Text(label string, accelerator *keys.Accelerator, click Callback) *MenuItem
func Separator() *MenuItem
func Radio(label string, selected bool, accelerator *keys.Accelerator, click Callback) *MenuItem
func Checkbox(label string, checked bool, accelerator *keys.Accelerator, click Callback) *MenuItem
func SubMenu(label string, menu *Menu) *Menu

Você também pode criar itens de menu diretamente em um menu, usando os ajudantes "Adicionar":

Package: github.com/wailsapp/wails/v2/pkg/menu
func (m *Menu) AddText(label string, accelerator *keys.Accelerator, click Callback) *MenuItem
func (m *Menu) AddSeparator() *MenuItem
func (m *Menu) AddRadio(label string, selected bool, accelerator *keys.Accelerator, click Callback) *MenuItem
func (m *Menu) AddCheckbox(label string, checked bool, accelerator *keys.Accelerator, click Callback) *MenuItem
func (m *Menu) AddSubMenu(label string, menu *Menu) *MenuI

Uma nota nos grupos de rádio: Um grupo de rádio é definido como um número de itens do menu de rádio que estão próximos um ao outro no menu. Isso significa que não é necessário agrupar os itens porque é automático. No entanto, isso também significa que você não pode ter 2 grupos lado a lado - deve haver um item que não seja de rádio entre eles.

Callback

Cada item de menu pode ter um callback que é executado quando o item é clicado:

Package: github.com/wailsapp/wails/v2/pkg/menu
type Callback func(*CallbackData)

type CallbackData struct {
    MenuItem    *MenuItem
}

A função recebe uma instrução CallbackData que indica qual item de menu acionou a callback. Isso é útil quando usar grupos de rádio que podem compartilhar um callback.

Role

Regras

As regras que são atualmente suportados apenas no Mac.

Um item de menu pode ter uma função, que é essencialmente um item de menu pré-definido. Atualmente, apoiamos as seguintes funções:

Role	Descrição
AppMenuRole	Menu padrão do aplicativo para Mac. Pode ser criado usando `menu.AppMenu()`
EditMenuRole	O menu de edição padrão para Mac. Pode ser criado usando `menu.EditMenu()`

Menu​

MenuItem​

Accelerator​

Modificador​

Tipo​

Callback​

Role​

Menu