Passer au contenu principal
Version: Prochaine version 🚧

Menus

Il est possible d'ajouter un menu applicatif aux projets Wails. Ceci est réalisé en définissant une structure Menu et en la définissant dans la configuration de l'application Menu , ou en appelant la méthode d'exécution MenuSetApplicationMenu.

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

Il est également possible de mettre à jour dynamiquement le menu, en mettant à jour le menu struct et en appelant MenuUpdateApplicationMenu.

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

Un Menu est une collection de MenuItems:

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 :

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.

Un MenuItem représente un élément dans un 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
}
ChampTypeNotes
LabelstringLe texte du menu
Accelerator*keys.AcceleratorRaccourci pour ce lien de menu
TypeTypeType de MenuItem
DisabledboolDésactive l'élément de menu
HiddenboolMasque cet élément de menu
CheckedboolAjoute une coche à l'élément (case à cocher & Types de radio)
SubMenu*MenuDéfinit un sous-menu
ClickCallbackFonction à appeler quand un click est fait sur cet élément du menu.
RolestringDéfinit un rôle 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. Ils sont disponibles dans le paquet "github.com/wailsapp/wails/v2/pkg/menu/keys".

Exemple:

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èref1f16f31
tabulationf2f17f32
retourf3f18f33
entréef4f19f34
echapf5f20f35
gauchef6f21numlock
droitef7f22
hautf8f23
basf9f24
espacef10f25
supprf11f36
débutf12f37
finf13f38
page hautf14f39
page basf15f30

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:

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:

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:

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

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:

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 :

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" :

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é :

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

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 :

RoleDescription
AppMenuRoleLe menu standard de l'application Mac. Peut être créé en utilisant menu.AppMenu()
EditMenuRoleLe menu d'édition standard pour Mac. Peut être créé en utilisant menu.EditMenu()