---
sidebar_position: 4
---

# Menus

Il est possible d'ajouter un menu applicatif aux projets Wails. Ceci est réalisé en définissant une structure [Menu](#menu) et en la définissant dans la configuration de l'application [`Menu`](../reference/options.mdx#menu) , ou en appelant la méthode d'exécution [MenuSetApplicationMenu](../reference/runtime/menu.mdx#menusetapplicationmenu).

Un exemple de définition d'un 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,
        },
    )
    // ...
```

Il est également possible de mettre à jour dynamiquement le menu, en mettant à jour le menu struct et en appelant [MenuUpdateApplicationMenu](../reference/runtime/menu.mdx#menuupdateapplicationmenu).

L'exemple ci-dessus utilise des méthodes d'aide, cependant il est possible de construire le menu manuellement.

## Menu

Un Menu est une collection de MenuItems:

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

Pour le menu de l'application, chaque MenuItem représente un seul menu tel que "Edit".

Une méthode simple d'aide est fournie pour les menus de construction :

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

Cela rend la mise en page du code plus semblable à celle d'un menu sans avoir à ajouter les éléments de menu manuellement après leur création. Vous pouvez également créer les liens de menu et les ajouter au menu manuellement.

## MenuItem

Un MenuItem représente un élément dans un 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
}
```

| Champ       | Type                                 | Notes                                                                                   |
| ----------- | ------------------------------------ | --------------------------------------------------------------------------------------- |
| Label       | string                               | Le texte du menu                                                                        |
| Accelerator | [\*keys.Accelerator](#accelerator) | Raccourci pour ce lien de menu                                                          |
| Type        | [Type](#type)                        | Type de MenuItem                                                                        |
| Disabled    | bool                                 | Désactive l'élément de menu                                                             |
| Hidden      | bool                                 | Masque cet élément de menu                                                              |
| Checked     | bool                                 | Ajoute une coche à l'élément (case à cocher & Types de radio)                           |
| SubMenu     | [\*Menu](#menu)                    | Définit un sous-menu                                                                    |
| Click       | [Callback](#callback)                | Fonction à appeler quand un click est fait sur cet élément du menu.                     |
| Role        | string                               | Définit un rôle [](#role) pour cet élément de menu. Pour Mac seulement, pour le moment. |

### Accelerator

Les accélérateurs (parfois appelés raccourcis clavier) définissent une liaison entre une clé et un élément du menu. Wails définit un accélérateur comme une combinaison ou une clé + [modificateur](#modifier). Ils sont disponibles dans le paquet `"github.com/wailsapp/wails/v2/pkg/menu/keys"`.

Exemple:

```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")
```

Les clés sont n'importe quel caractère sur un clavier à l'exception de `+`, qui est défini comme `plus`. Certaines clés ne peuvent pas être représentées comme des caractères, il y a donc un ensemble de caractères nommés qui peuvent être utilisés :

|                  |       |       |           |
|:----------------:|:-----:|:-----:|:---------:|
| `retour arrière` | `f1`  | `f16` |   `f31`   |
|   `tabulation`   | `f2`  | `f17` |   `f32`   |
|     `retour`     | `f3`  | `f18` |   `f33`   |
|     `entrée`     | `f4`  | `f19` |   `f34`   |
|     `echap`      | `f5`  | `f20` |   `f35`   |
|     `gauche`     | `f6`  | `f21` | `numlock` |
|     `droite`     | `f7`  | `f22` |           |
|      `haut`      | `f8`  | `f23` |           |
|      `bas`       | `f9`  | `f24` |           |
|     `espace`     | `f10` | `f25` |           |
|     `suppr`      | `f11` | `f36` |           |
|     `début`      | `f12` | `f37` |           |
|      `fin`       | `f13` | `f38` |           |
|   `page haut`    | `f14` | `f39` |           |
|    `page bas`    | `f15` | `f30` |           |

Wails prend également en charge l'analyse des accélérateurs en utilisant la même syntaxe qu'Electron. Ceci est utile pour stocker les accélérateurs dans les fichiers de configuration .

Exemple:

```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")
```

#### Modifier

Les modificateurs suivants sont des touches qui peuvent être utilisées en combinaison avec la touche accélérateur:

```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"
)
```

Un certain nombre de méthodes d'aide sont disponibles pour créer des accélérateurs en utilisant des modificateurs:

```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
```

Les modificateurs peuvent être combinés en utilisant `keys.Combo(key string, modifier1 Modifier, modifier2 Modifier, rest ...Modifier)`:

```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)
```

### Type

Chaque lien de menu doit avoir un type et il y a 5 types disponibles:

```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"
)
```

Pour plus de commodité, des méthodes d'aide sont fournies pour créer rapidement un lien 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
```

Vous pouvez également créer des liens directement dans un menu en utilisant les méthodes "Add" :

```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
```

Une note sur les groupes radio : Un groupe radio est défini comme un certain nombre d'éléments du menu radio qui sont à côté l'un de l'autre dans le menu. Cela signifie que vous n'avez pas besoin de regrouper les éléments car il est automatique. Cependant, cela signifie également que vous ne pouvez pas avoir 2 groupes radio les uns à côté des autres - il doit y avoir un élément non-radio entre eux.

### Callback

Chaque lien de menu peut avoir une fonction qui est exécutée lorsque l'élément est cliqué :

```go title="Package: github.com/wailsapp/wails/v2/pkg/menu"
type Callback func(*CallbackData)

type CallbackData struct {
    MenuItem    *MenuItem
}
```

La fonction reçoit une structure `CallbackData` qui indique quel élément de menu a été cliqué. Ceci est utile lorsque utilise des groupes radio qui peuvent partager une fonction.

### Role

:::info Roles

Les rôles ne sont actuellement pris en charge que sur Mac.

:::

Un lien de menu peut avoir un rôle, qui est essentiellement un lien de menu prédéfini. Nous supportons actuellement les rôles suivants :

| Role         | Description                                                                         |
| ------------ | ----------------------------------------------------------------------------------- |
| AppMenuRole  | Le menu standard de l'application Mac. Peut être créé en utilisant `menu.AppMenu()` |
| EditMenuRole | Le menu d'édition standard pour Mac. Peut être créé en utilisant `menu.EditMenu()`  |
