Pular para o conteúdo principal
Versão: v2.8.1

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()
FileMenu := AppMenu.AddSubmenu("File")
FileMenu.AddText("&Open", keys.CmdOrCtrl("o"), openFile)
FileMenu.AddSeparator()
FileMenu.AddText("Quit", keys.CmdOrCtrl("q"), func(_ *menu.CallbackData) {
runtime.Quit(app.ctx)
})

if runtime.GOOS == "darwin" {
AppMenu.Append(menu.EditMenu()) // on macos platform, we should append EditMenu to enable Cmd+C,Cmd+V,Cmd+Z... shortcut
}

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.

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
}
CampoTipoNotas
LabelstringO texto do menu
Accelerator*keys.AcceleratorVinculação de teclas para este item de menu
TipoTipoTipo de MenuItem
DisabledboolDesativa o item de menu
HiddenboolOculta este item de menu
CheckedboolAdiciona uma seleção para o item ( & Tipos de Rádio)
SubMenu*MenuDefine o submenu
ClickCallbackFunção Callback quando clicado no menu
RolestringDefine 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:

backspacef1f16f31
tabf2f17f32
returnf3f18f33
enterf4f19f34
escapef5f20f35
leftf6f21numlock
rightf7f22
upf8f23
downf9f24
spacef10f25
deletef11f36
homef12f37
endf13f38
page upf14f39
page downf15f30

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:

RoleDescrição
AppMenuRoleMenu padrão do aplicativo para Mac. Pode ser criado usando menu.AppMenu()
EditMenuRoleO menu de edição padrão para Mac. Pode ser criado usando menu.EditMenu()