mirror of
https://github.com/wailsapp/wails.git
synced 2025-05-02 06:32:10 +08:00
231 lines
10 KiB
Plaintext
231 lines
10 KiB
Plaintext
---
|
|
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()` |
|