---
sidebar_position: 4
---

# Menus

É possível adicionar um menu de aplicação aos projetos do Wails. Isso é conseguido definindo uma struct [Menu](#menu) e configurando-a no configuração do aplicativo [`Menu`](../reference/options.mdx#menu) ou chamando o método [MenuSetApplicationMenu](../reference/runtime/menu.mdx#menusetapplicationmenu).

Um exemplo de como criar um menu:

```go

    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](../reference/runtime/menu.mdx#menuupdateapplicationmenu).

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

## Menu

Um Menu é uma coleção de MenuItems:

```go title="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:

```go title="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.

```go title="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](#accelerator) | Vinculação de teclas para este item de menu                                |
| Tipo        | [Tipo](#type)                        | 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](#menu)                    | Define o submenu                                                           |
| Click       | [Callback](#callback)                | Função Callback quando clicado no menu                                     |
| Role        | string                               | Define um papel [](#role) 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](#modifier). Eles estão disponíveis no pacote `"github.com/wailsapp/wails/v2/pkg/menu/keys"`.

Exemplo:

```go title="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:

```go title="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:

```go title="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:

```go title="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)`:

```go title="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:

```go title="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:

```go title="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":

```go title="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:

```go title="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

:::info 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()`  |