Test bun install

docs: sync translations (#2699 )
Co-authored-by: leaanthony <leaanthony@users.noreply.github.com>
2026-04-22 15:26:15 -07:00 · 2023-09-11 20:54:49 +10:00 · 2023-09-08 23:25:21 +10:00 · 2023-09-08 23:23:33 +10:00 · 2023-09-08 13:56:40 +10:00 · 2023-09-07 21:25:02 +10:00
112 changed files with 2451 additions and 297 deletions
@@ -4,6 +4,7 @@
 #include <stdio.h>
 #include <limits.h>
 #include <stdint.h>
+#include <locale.h>
 #include "window.h"

 // These are the x,y,time & button of the last mouse down event
@@ -145,20 +146,39 @@ void SetBackgroundColour(void *data)
 {
    // set webview's background color
    RGBAOptions *options = (RGBAOptions *)data;
+
    GdkRGBA colour = {options->r / 255.0, options->g / 255.0, options->b / 255.0, options->a / 255.0};
+    if (options->windowIsTranslucent != NULL && options->windowIsTranslucent == TRUE)
+    {
+        colour.alpha = 0.0;
+    }
    webkit_web_view_set_background_color(WEBKIT_WEB_VIEW(options->webview), &colour);

    // set window's background color
-    GtkWidget *window = GTK_WIDGET(options->window);
-    gchar *str = g_strdup_printf("window {background-color: rgba(%d, %d, %d, %d);}", options->r, options->g, options->b, options->a);
+    // Get the name of the current locale
+    char *old_locale, *saved_locale;
+    old_locale = setlocale(LC_ALL, NULL);
+
+    // Copy the name so it won’t be clobbered by setlocale.
+    saved_locale = strdup(old_locale);
+    if (saved_locale == NULL)
+        return;
+
+    //Now change the locale to english for so printf always converts floats with a dot decimal separator
+    setlocale(LC_ALL, "en_US.UTF-8");
+    gchar *str = g_strdup_printf("#webview-box {background-color: rgba(%d, %d, %d, %1.1f);}", options->r, options->g, options->b, options->a / 255.0);
+
+    //Restore the original locale.
+    setlocale(LC_ALL, saved_locale);
+    free(saved_locale);

    if (windowCssProvider == NULL)
    {
        windowCssProvider = gtk_css_provider_new();
        gtk_style_context_add_provider(
-            gtk_widget_get_style_context(window),
+            gtk_widget_get_style_context(GTK_WIDGET(options->webviewBox)),
            GTK_STYLE_PROVIDER(windowCssProvider),
-            GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
+            GTK_STYLE_PROVIDER_PRIORITY_USER);
        g_object_unref(windowCssProvider);
    }

@@ -43,6 +43,7 @@ type Window struct {
 	webview                                  unsafe.Pointer
 	applicationMenu                          *menu.Menu
 	menubar                                  *C.GtkWidget
+	webviewBox                               *C.GtkWidget
 	vbox                                     *C.GtkWidget
 	accels                                   *C.GtkAccelGroup
 	minWidth, minHeight, maxWidth, maxHeight int
@@ -72,6 +73,11 @@ func NewWindow(appoptions *options.App, debug bool, devtools bool) *Window {
 	C.g_object_ref_sink(C.gpointer(gtkWindow))
 	result.gtkWindow = unsafe.Pointer(gtkWindow)

+	webviewName := C.CString("webview-box")
+	defer C.free(unsafe.Pointer(webviewName))
+	result.webviewBox = C.gtk_box_new(C.GTK_ORIENTATION_VERTICAL, 0)
+	C.gtk_widget_set_name(result.webviewBox, webviewName)
+
 	result.vbox = C.gtk_box_new(C.GTK_ORIENTATION_VERTICAL, 0)
 	C.gtk_container_add(result.asGTKContainer(), result.vbox)

@@ -265,13 +271,18 @@ func (w *Window) IsNormal() bool {
 }

 func (w *Window) SetBackgroundColour(r uint8, g uint8, b uint8, a uint8) {
+	windowIsTranslucent := false
+	if w.appoptions.Linux != nil && w.appoptions.Linux.WindowIsTranslucent {
+		windowIsTranslucent = true
+	}
 	data := C.RGBAOptions{
-		r:       C.uchar(r),
-		g:       C.uchar(g),
-		b:       C.uchar(b),
-		a:       C.uchar(a),
-		webview: w.webview,
-		window:  w.gtkWindow,
+		r:                   C.uchar(r),
+		g:                   C.uchar(g),
+		b:                   C.uchar(b),
+		a:                   C.uchar(a),
+		webview:             w.webview,
+		webviewBox:          unsafe.Pointer(w.webviewBox),
+		windowIsTranslucent: gtkBool(windowIsTranslucent),
 	}
 	invokeOnMainThread(func() { C.SetBackgroundColour(unsafe.Pointer(&data)) })

@@ -288,7 +299,9 @@ func (w *Window) Run(url string) {
 	if w.menubar != nil {
 		C.gtk_box_pack_start(C.GTKBOX(unsafe.Pointer(w.vbox)), w.menubar, 0, 0, 0)
 	}
-	C.gtk_box_pack_start(C.GTKBOX(unsafe.Pointer(w.vbox)), C.GTKWIDGET(w.webview), 1, 1, 0)
+
+	C.gtk_box_pack_start(C.GTKBOX(unsafe.Pointer(w.webviewBox)), C.GTKWIDGET(w.webview), 1, 1, 0)
+	C.gtk_box_pack_start(C.GTKBOX(unsafe.Pointer(w.vbox)), w.webviewBox, 1, 1, 0)
 	_url := C.CString(url)
 	C.LoadIndex(w.webview, _url)
 	defer C.free(unsafe.Pointer(_url))
@@ -55,7 +55,8 @@ typedef struct RGBAOptions
    uint8_t b;
    uint8_t a;
    void *webview;
-    void *window;
+    void *webviewBox;
+    gboolean windowIsTranslucent;
 } RGBAOptions;

 typedef struct SetTitleArgs
@@ -421,11 +421,11 @@
    "description": "The ARIA label for hamburger menu button of mobile navigation"
  },
  "theme.NavBar.navAriaLabel": {
-    "message": "Main",
+    "message": "Menu Principal",
    "description": "The ARIA label for the main navigation"
  },
  "theme.docs.sidebar.navAriaLabel": {
-    "message": "Docs sidebar",
+    "message": "Barre latérale de la documentation",
    "description": "The ARIA label for the sidebar navigation"
  }
 }
@@ -20,59 +20,59 @@ tags:

 # Introduction

-Wails est un projet qui simplifie la possibilité d'écrire des applications de bureau inter-plateformes en utilisant Go. It uses native webview components for the frontend (not embedded browsers), bringing the power of the world's most popular UI system to Go, whilst remaining lightweight.
+Wails est un projet qui simplifie la possibilité d'écrire des applications de bureau inter-plateformes en utilisant Go. Il utilise des composants web natifs pour le frontend (pas de navigateurs intégrés) apportant à Go la puissance du système d'interface utilisateur le plus populaire au monde, tout en restant léger.

 La version 2 a été publiée le 22 septembre 2022 et a apporté de nombreuses améliorations y compris :

- Live development, leveraging the popular Vite project
- Rich functionality for managing windows and creating menus
- Microsoft's WebView2 component
- Generation of Typescript models that mirror your Go structs
- Creating of NSIS Installer
- Obfuscated builds
+- Développement en direct, en tirant parti du projet populaire Vite
+- Fonctionnalités avancées pour gérer les fenêtres et créer des menus
+- Composants Microsoft WebView2
+- Génération de modèles Typescript qui reflètent vos structures Go
+- Création de l'installateur NSIS
+- Compilations obfusquées

-Right now, Wails v2 provides powerful tooling for creating rich, cross-platform desktop applications.
+En ce moment, Wails v2 fournit un outil puissant pour créer des applications de bureau riches et multiplateforme.

-This blog post aims to look at where the project is at right now and what we can improve on moving forward.
+Ce billet de blog vise à voir où se trouve le projet en ce moment et ce que nous pouvons améliorer pour aller de l'avant.

 # Où en sommes-nous actuellement?

-It's been incredible to see the popularity of Wails rising since the v2 release. I'm constantly amazed by the creativity of the community and the wonderful things that are being built with it. With more popularity, comes more eyes on the project. And with that, more feature requests and bug reports.
+C'est incroyable de voir la popularité de Wails en hausse depuis la version v2. Je suis constamment stupéfait par la créativité de la communauté et les choses merveilleuses qui sont en train d'être construites avec elle. Avec plus de popularité, vient plus d'yeux sur le projet. Et avec cela, plus de demandes de fonctionnalités et rapports de bogues.

-Over time, I've been able to identify some of the most pressing issues facing the project. I've also been able to identify some of the things that are holding the project back.
+Au fil du temps, j'ai pu identifier certains des problèmes les plus urgents auxquels le projet est confronté. J'ai également été en mesure d'identifier certaines des choses qui tirent le projet vers l'arrière.

 ## Problèmes actuels

-I've identified the following areas that I feel are holding the project back:
+J'ai identifié les domaines suivants qui, selon moi, tirent le projet vers l'arrière :

- The API
- Bindings generation
- The Build System
+- L'API
+- Génération des liaisons
+- Le système de compilation

-### The API
+### L'API

-The API to build a Wails application currently consists of 2 parts:
+L'API pour construire une application Wails se compose actuellement de 2 parties :

- The Application API
- The Runtime API
+- La partie applicative
+- La partie exécution

-The Application API famously has only 1 function: `Run()` which takes a heap of options which govern how the application will work. Whilst this is very simple to use, it is also very limiting. It is a "declarative" approach which hides a lot of the underlying complexity. For instance, there is no handle to the main window, so you can't interact with it directly. For that, you need to use the Runtime API. This is a problem when you start to want to do more complex things like create multiple windows.
+La partie applicative ne possède qu'une fonction : `Run()` qui prend un tas d'options qui régissent le fonctionnement de l'application. Bien que cela soit très simple à utiliser, elle est également très limitée. C'est une approche "déclarative" qui masque beaucoup de la complexité sous-jacente. Par exemple, il n'y a pas de gestion de la fenêtre principale, faisant qu'il n'est pas possible d'intéragir directement avec. Pour cela, vous devez utiliser la partie exécution de l'API. Ceci est un problème lorsque vous commencez à vouloir faire des choses plus complexes comme créer plusieurs fenêtres.

-The Runtime API provides a lot of utility functions for the developer. This includes:
+La partie exécution fournit de nombreuses fonctions utilitaires pour le développeur. Incluant :

- Window management
- Dialogs
- Menus
- Events
- Logs
+- La gestion des fenêtres
+- Les boites de dialogues
+- Les menus
+- Les évènements
+- Les journaux de logs

-There are a number of things I am not happy with the Runtime API. The first is that it requires a "context" to be passed around. This is both frustrating and confusing for new developers who pass in a context and then get a runtime error.
+Il y a un certain nombre de choses dont je ne suis pas satisfait dans la partie exécution de l'API. La première est que nécessite un "contexte" pour être contourné. C'est autant frustrant que confusant pour les nouveaux développeurs qui donnent un contexte et qui obtiennent une erreur runtime.

-The biggest issue with the Runtime API is that it was designed for applications that only use a single window. Over time, the demand for multiple windows has grown and the API is not well suited to this.
+Le plus gros problème avec la partie exécution de l'API est que cela a été pensé pour des applications qui n'ont qu'une seule fenêtre. Au fil du temps, la demande pour plusieurs fenêtres a augmenté et l'API n'est pas adaptée à cela.

-### Thoughts on the v3 API
+### Réflexions sur l'API v3

-Wouldn't it be great if we could do something like this?
+Ne serait-ce pas génial si nous pouvions faire quelque chose comme ça ?

 ```go
 func main() {
@@ -86,7 +86,7 @@ func main() {
 }
 ```

-This programmatic approach is far more intuitive and allows the developer to interact with the application elements directly. All current runtime methods for windows would simply be methods on the window object. For the other runtime methods, we could move them to the application object like so:
+Cette approche programmatique est beaucoup plus intuitive et permet au développeur d'interagir avec les éléments d'application directement. Toutes les méthodes d'exécution pour les fenêtres seraient simplement des méthodes dans l'objet fenêtre. Pour toutes les autres méthodes qui étaient présentes dans la partie exécution de l'API, on pourrait les déplacer dans un objet application comme suit :

 ```go
 app := wails.NewApplication(options.App{})
@@ -94,7 +94,7 @@ app.NewInfoDialog(options.InfoDialog{})
 app.Log.Info("Hello World")
 ```

-This is a much more powerful API which will allow for more complex applications to be built. It also allows for the creation of multiple windows, [the most up-voted feature on GitHub](https://github.com/wailsapp/wails/issues/1480):
+Cela devient une API bien plus puissante, capable de construire des applications plus complexes. Il permet également la création de plusieurs fenêtres, [la fonctionnalité la plus votée sur GitHub](https://github.com/wailsapp/wails/issues/1480):

 ```go
 func main() {
@@ -113,72 +113,72 @@ func main() {
 }
 ```

-### Bindings generation
+### Génération des liaisons

-One of the key features of Wails is generating bindings for your Go methods so they may be called from Javascript. The current method for doing this is a bit of a hack. It involves building the application with a special flag and then running the resultant binary which uses reflection to determine what has been bound. This leads to a bit of a chicken and egg situation: You can't build the application without the bindings and you can't generate the bindings without building the application. There are many ways around this but the best one would be not to use this approach at all.
+L'une des fonctionnalités clés de Wails est la génération de liaisons pour permettre à vos méthodes Go d'être appelées à partir du Javascript. La méthode courante pour faire cela est un peu un hack. Il implique de construire l'application avec une option spéciale, puis d'exécuter le binaire qui utilise la réflexion pour déterminer ce qui lui a été lié. Cela mène à une situation de la poule et de l'oeuf : vous ne pouvez pas construire l'application sans les liaisons et vous ne pouvez pas générer les liaisons sans construire l'application. Il y a plusieurs façons de contourner cela, mais le meilleur serait de ne pas utiliser cette approche du tout.

-There was a number of attempts at writing a static analyser for Wails projects but they didn't get very far. In more recent times, it has become slightly easier to do this with more material available on the subject.
+Il y a eu un certain nombre de tentatives d'écriture d'un analyseur statique pour les projets Wails mais ils ne sont pas allés très loin. Plus récemment, il est devenu légèrement plus facile de le faire avec le nouveau matériel disponible sur le sujet.

-Compared to reflection, the AST approach is much faster however it is significantly more complicated. To start with, we may need to impose certain constraints on how to specify bindings in the code. The goal is to support the most common use cases and then expand it later on.
+Comparée à la réflexion, l'approche AST est beaucoup plus rapide, cependant elle est considérablement plus compliquée. Pour commencer, nous pourrions devoir imposer certaines contraintes sur la façon de spécifier les liaisons dans le code. L'objectif est de supporter les cas d'utilisation les plus courants, puis d'étendre plus tard.

-### The Build System
+### Le système de compilation

-Like the declarative approach to the API, the build system was created to hide the complexities of building a desktop application. When you run `wails build`, it does a lot of things behind the scenes:
- Builds the backend binary for bindings and generates the bindings
- Installs the frontend dependencies
- Builds the frontend assets
- Determines if the application icon is present and if so, embeds it
- Builds the final binary
- If the build is for `darwin/universal` it builds 2 binaries, one for `darwin/amd64` and one for `darwin/arm64` and then creates a fat binary using `lipo`
- If compression is required, it compresses the binary with UPX
- Determines if this binary is to be packaged and if so:
-  - Ensures the icon and application manifest are compiled into the binary (Windows)
-  - Builds out the application bundle, generates the icon bundle and copies it, the binary and Info.plist to the application bundle (Mac)
- If an NSIS installer is required, it builds it
+Comme l'approche déclarative de l'API, le système de construction a été créé pour masquer les complexités de la construction d'une application de bureau. Quand vous exécutez la commande `wails build`, ça effectue pas mal de choses de manière invisible :
+- Construit le binaire d'arrière-plan pour les liaisons et génère les liaisons
+- Installe les dépendances frontend
+- Construit les ressources du frontend
+- Détermine si l'icône de l'application est présente et si oui, l'intègre
+- Construit le binaire final
+- Si l'application est construite pour `darwin/universal`, ça va générer deux fichiers binaires, un pour `darwin/amd64` et un pour `darwin/arm64` avant d'en créer un dernier incluant les deux premiers en utilisant `lipo`
+- Si la compression est demandée, le binaire est compressé avec UPX
+- Détermine si ce binaire doit être empaqueté et si c'est le cas :
+  - S'assure que l'icône et le manifeste d'application sont compilés dans le binaire (Windows)
+  - Construit le lot d'applications, génère le lot d'icônes et le copie avec le binaire et Info.plist dans le bundle d'applications (Mac)
+- Si un installateur NSIS est demandé, il le construit

-This entire process, whilst very powerful, is also very opaque. It is very difficult to customise it and it is very difficult to debug.
+Tout ce processus, bien que très puissant, est également très opaque. Le rendant très difficile à personnalisé et débugger.

-To address this in v3, I would like to move to a build system that exists outside of Wails. After using [Task](https://taskfile.dev/) for a while, I am a big fan of it. It is a great tool for configuring build systems and should be reasonably familiar to anyone who has used Makefiles.
+Pour résoudre ce problème dans la v3, je voudrais passer à un système de compilation qui existe en dehors de Wails. Après avoir utilisé [Task](https://taskfile.dev/) pendant un certain temps, je suis un grand fan de ça. C'est un excellent outil pour configurer les systèmes de compilation et devrait être raisonnablement familier à tous ceux qui ont utilisé Makefiles.

-The build system would be configured using a `Taskfile.yml` file which would be generated by default with any of the supported templates. This would have all of the steps required to do all the current tasks, such as building or packaging the application, allowing for easy customisation.
+Le système de compilation serait configuré à l'aide d'un fichier `Taskfile.yml` qui serait généré par défaut avec n'importe lequel des modèles supportés. Cela contiendrait toutes les étapes requises pour effectuer toutes les tâches actuelles, comme la construction ou l'empaquetage de l'application, mais permettrait de facilement personnaliser ce processus.

-There will be no external requirement for this tooling as it would form part of the Wails CLI. This means that you can still use `wails build` and it will do all the things it does today. However, if you want to customise the build process, you can do so by editing the `Taskfile.yml` file. It also means you can easily understand the build steps and use your own build system if you wish.
+Il n'y aurait pas de prérequis pour pouvoir utiliser cet outil vu qu'il sera intégré comme étant une partie du CLI de Wails. Cela signifie que vous pouvez toujours utiliser `wails build` et qu'il fera tout ce qu'il fait déjà aujourd'hui. Cependant, si vous souhaitez personnaliser le processus de compilation, vous pourrez le faire en éditant le fichier `Taskfile.yml`. Cela signifie aussi que vous pourrez comprendre facilement les différentes étapes de compilation et créer votre propre processus de compilation si vous le désirez.

-The missing piece in the build puzzle is the atomic operations in the build process, such as icon generation, compression and packaging. To require a bunch of external tooling would not be a great experience for the developer. To address this, the Wails CLI will provide all these capabilities as part of the CLI. This means that the builds still work as expected, with no extra external tooling, however you can replace any step of the build with any tool you like.
+Les pièces manquantes dans le puzzle de la compilation sont les opérations atomiques comme la génération d'icônes, la compression et la création du package. Avoir une liste d'application et autres outils comme prérequis ne serait pas une bonne expérience pour le développeur. Pour résoudre ce problème, le CLI Wails fournira toutes ces fonctionnalités dans le CLI. Cela signifie que les compilations vont toujours se faire comme prévues, sans outils externes. Cependant, vous pourrez remplacer n'importe quel outil utilisé dans le processus de compilation.

-This will be a much more transparent build system which will allow for easier customisation and address a lot of the issues that have been raised around it.
+Ceci sera un système de compilation beaucoup plus transparent qui permettra une personnalisation plus facile et de résoudre un grand nombre des problèmes qui ont été soulevés autour de lui.

-## The Payoff
+## Le gain

-These positive changes will be a huge benefit to the project:
- The new API will be much more intuitive and will allow for more complex applications to be built.
- Using static analysis for bindings generation will be much faster and reduce a lot of the complexity around the current process.
- Using an established, external build system will make the build process completely transparent, allowing for powerful customisation.
+Ces changements positifs constitueront un énorme avantage pour le projet:
+- La nouvelle API sera beaucoup plus intuitive et permettra de construire des applications plus complexes .
+- Utiliser l'analyse statique pour la génération des liaisons sera beaucoup plus rapide et réduira beaucoup de la complexité vis à vis du processus actuel.
+- Utiliser un système de compilation externe établi rendra le processus de compilation complètement transparent, permettant une plus grande personnalisation.

-Benefits to the project maintainers are:
+Les avantages pour les responsables du projet sont :

- The new API will be much easier to maintain and adapt to new features and platforms.
- The new build system will be much easier to maintain and extend. I hope this will lead to a new ecosystem of community driven build pipelines.
- Better separation of concerns within the project. This will make it easier to add new features and platforms.
+- La nouvelle API sera beaucoup plus facile à maintenir et à adapter aux nouvelles fonctionnalités et plates-formes.
+- Le nouveau système de compilation sera beaucoup plus facile à maintenir et à étendre. J'espère que cela conduira à un nouvel écosystème de pipelines de construction pilotés par la communauté.
+- Une meilleure séparation des préoccupations au sein du projet. Cela facilitera l'ajout de nouvelles fonctionnalités et de nouvelles plateformes.

 ## Le Plan

-A lot of the experimentation for this has already been done and it's looking good. There is no current timeline for this work but I'm hoping by the end of Q1 2023, there will be an alpha release for Mac to allow the community to test, experiment with and provide feedback.
+Un grand nombre de tests ont déjà été réalisés et ça se passe très bien. Il n'y a pas de calendrier actuel pour ce travail, mais j'espère d'ici la fin du T1 2023, là sera une version alpha pour Mac pour permettre à la communauté de tester, d'expérimenter et de fournir des commentaires.

 ## Résumé

- The v2 API is declarative, hides a lot from the developer and not suitable for features such as multiple windows. A new API will be created which will be simpler, intuitive and more powerful.
- The build system is opaque and difficult to customise so we will move to an external build system which will open it all up.
- The bindings generation is slow and complex so we will move to static analysis which will remove a lot of the complexity the current method has.
+- L'API v2 est déclarative, mais masque beaucoup de choses au développeur et ne convient pas pour des fonctionnalités telles que les fenêtres multiples. La nouvelle API sera créée sera plus simple, intuitive et plus puissante.
+- Le système de compilation est opaque et difficile à personnaliser donc nous allons passer à un système de compilation externe qui l'ouvrira tous.
+- La génération des liaisons est lente et complexe, donc nous allons passer à l'analyse statique qui supprimera une grande partie de la complexité de la méthode actuelle.

-There has been a lot of work put into the guts of v2 and it's solid. It's now time to address the layer on top of it and make it a much better experience for the developer.
+Il y a eu beaucoup de travail dans les entrailles de la v2 et c'est solide. Il est maintenant temps d'aborder la couche au-dessus de celle-ci et d'en faire une bien meilleure expérience pour le développeur.

-I hope you are as excited about this as I am. I'm looking forward to hearing your thoughts and feedback.
+J'espère que vous êtes aussi excité que moi à ce sujet. J'ai hâte d'entendre vos réflexions et vos commentaires.

 Cordialement,

 &dash; Lea

-PS: If you or your company find Wails useful, please consider [sponsoring the project](https://github.com/sponsors/leaanthony). Thanks!
+PPS : Si vous ou votre entreprise trouvez Wails utile, veuillez envisager [de parrainer le projet](https://github.com/sponsors/leaanthony). Merci !

-PPS: Yes, that's a genuine screenshot of a multi-window application built with Wails. It's not a mockup. It's real. It's awesome. It's coming soon.
+PPS: Oui, c'est une véritable capture d'écran d'une application multi-fenêtres construite avec Wails. Ce n'est pas une maquette. C'est réel. C'est génial ! Ca va arriver bientôt.
@@ -7,4 +7,4 @@
 </p>
 ```

-The [BulletinBoard](https://github.com/raguay/BulletinBoard) application is a versital message board for static messages or dialogs to get information from the user for a script. It has a TUI for creating new dialogs that can latter be used to get information from the user. It's design is to stay running on your system and show the information as needed and then hide away. I have a process for watching a file on my system and sending the contents to BulletinBoard when changed. It works great with my workflows. There is also an [Alfred workflow](https://github.com/raguay/MyAlfred/blob/master/Alfred%205/EmailIt.alfredworkflow) for sending information to the program. The workflow is also for working with [EmailIt](https://github.com/raguay/EmailIt).
+L'application [BulletinBoard](https://github.com/raguay/BulletinBoard) est un panneau de messages versitaux pour les messages statiques ou les boîtes de dialogue pour obtenir des informations de l'utilisateur pour un script. Il a une TUI pour créer de nouvelles boîtes de dialogue qui peuvent être utilisées pour obtenir des informations de l'utilisateur. Son design est de rester en fonctionnement sur votre système et de montrer les informations au besoin, puis de se cacher. J'ai un processus pour surveiller un fichier sur mon système et pour envoyer le contenu à BulletinBoard une fois modifié. Cela fonctionne très bien avec mes workflows. Il y a auss un [workflow Alfred](https://github.com/raguay/MyAlfred/blob/master/Alfred%205/EmailIt.alfredworkflow) pour envoyer les informations au programme. Le workflow fonctionne aussi avec [EmailIt](https://github.com/raguay/EmailIt).
@@ -7,4 +7,4 @@
 </p>
 ```

-[EmailIt](https://github.com/raguay/EmailIt/) is a Wails 2 program that is a markdown based email sender only with nine notepads, scripts to manipulate the text, and templates. It also has a scripts terminal to run scripts in EmailIt on files in your system. The scripts and templates can be used from the commandline itself or with the Alfred, Keyboard Maestro, Dropzone, or PopClip extensions. It also supports scripts and themes downloaded form GitHub. Documentation is not complete, but the programs works. It’s built using Wails2 and Svelte, and the download is a universal macOS application.
+[EmailIt](https://github.com/raguay/EmailIt/) est un programme Wails 2 qui est un expéditeur de courrier électronique basé sur le markdown uniquement avec neuf blocs-notes, pour manipuler le texte et les modèles. Il a également un terminal pour exécuter des scripts dans EmailIt sur les fichiers de votre système. Les scripts et modèles peuvent être utilisés depuis la ligne de commande elle-même ou avec les extensions Alfred, Keyboard Maestro, Dropzone ou PopClip. Il supporte également les scripts et thèmes téléchargés sous GitHub. La documentation n'est pas complète, mais le programme fonctionne. Il est construit en utilisant Wails2 et Svelte, et le téléchargement est une application macOS universelle.
@@ -7,4 +7,4 @@
 </p>
 ```

-[hiposter](https://github.com/obity/hiposter) is a simple and efficient http API testing client tool. Based on Wails, Go and sveltejs.
+[hiposter](https://github.com/obity/hiposter) est un outil client de test d'API http simple et efficace. Basé sur les Wails, Go et sveltejs.
@@ -9,6 +9,6 @@
 </p>
 ```

-[Modal File Manager](https://github.com/raguay/ModalFileManager) est un gestionnaire de fichiers à double volet utilisant des technologies web. Mon design original était basé sur NW.js et peut être trouvé [ici](https://github.com/raguay/ModalFileManager-NWjs). Cette version utilise le même code frontend basé sur Svelte (mais il a été grandement modifié depuis le départ de NW.js), mais le backend est une implémentation de [Wails 2](https://wails.io/). By using this implementation, I no longer use command line `rm`, `cp`, etc. commands, but a git install has to be on the system to download themes and extensions. Il est entièrement codé en utilisant Go et fonctionne beaucoup plus rapidement que les versions précédentes.
+[Modal File Manager](https://github.com/raguay/ModalFileManager) est un gestionnaire de fichiers à double volet utilisant des technologies web. Mon design original était basé sur NW.js et peut être trouvé [ici](https://github.com/raguay/ModalFileManager-NWjs). Cette version utilise le même code frontend basé sur Svelte (mais il a été grandement modifié depuis le départ de NW.js), mais le backend est une implémentation de [Wails 2](https://wails.io/). En utilisant cette implémentation, je n'utilise plus la ligne de commande `rm`, `cp`, etc. , mais une installation de git doit être présente sur le système pour télécharger des thèmes et des extensions. Il est entièrement codé en utilisant Go et fonctionne beaucoup plus rapidement que les versions précédentes.

-Ce gestionnaire de fichiers est conçu autour du même principe que Vim: l'état est contrôlé par des actions via le clavier. Le nombre d'états n'est pas fixe, mais très programmable. Par conséquent, un nombre infini de configurations de clavier qui peuvent être créées et utilisées. C'est la principale différence par rapport aux autres gestionnaires de fichiers. There are themes and extensions available to download from GitHub.
+Ce gestionnaire de fichiers est conçu autour du même principe que Vim: l'état est contrôlé par des actions via le clavier. Le nombre d'états n'est pas fixe, mais très programmable. Par conséquent, un nombre infini de configurations de clavier qui peuvent être créées et utilisées. C'est la principale différence par rapport aux autres gestionnaires de fichiers. Il y a des thèmes et des extensions disponibles à télécharger à partir de GitHub.
@@ -7,4 +7,4 @@
 </p>
 ```

-[ScriptBar](https://GitHub.com/raguay/ScriptBarApp) is a program to show the output of scripts or [Node-Red](https://nodered.org) server. It runs scripts defined in EmailIt program and shows the output. Scripts from xBar or TextBar can be used, but currently on the TextBar scripts work well. Il affiche également la sortie des scripts sur votre système. ScriptBar ne les met pas dans la barre de menus, mais les a tous dans une fenêtre convenable pour une visualisation facile. Vous pouvez avoir plusieurs onglets pour voir plusieurs choses différentes. Vous pouvez également conserver les liens vers vos sites Web les plus visités.
+[ScriptBar](https://GitHub.com/raguay/ScriptBarApp) est un programme pour afficher la sortie de scripts ou d'un serveur [Node-Red](https://nodered.org). Il exécute des scripts définis dans le programme EmailIt et affiche la sortie. Des scripts de xBar ou TextBar peuvent être utilisés. Actuellement sur les scripts TextBar fonctionnent bien. Il affiche également la sortie des scripts sur votre système. ScriptBar ne les met pas dans la barre de menus, mais les a tous dans une fenêtre convenable pour une visualisation facile. Vous pouvez avoir plusieurs onglets pour voir plusieurs choses différentes. Vous pouvez également conserver les liens vers vos sites Web les plus visités.
@@ -1,4 +1,4 @@
-# Minecraft launcher for WarMine
+# Lanceur Minecraft pour WarMine

 ```mdx-code-block
 <p style={{ "text-align": "center" }}>
@@ -12,8 +12,8 @@
 </p>
 ```

-[Minecraft launcher for WarMine](https://warmine.ru/) is a Wails application, that allows you to easily join modded game servers and manage your game accounts.
+[Lanceur Minecraft pour WarMine](https://warmine.ru/) est une application Wails qui vous permet facilement de rejoindre le serveur de jeu contenant les mods, ainsi que la gestion de vos comptes de jeu.

-The Launcher downloads the game files, checks their integrity and launches the game with a wide range of customization options for the launch arguments from the backend.
+Le Launcher télécharge les fichiers du jeu, vérifie leur intégrité et lance le jeu avec une large gamme d'options de personnalisation.

-Frontend is written in Svelte, whole launcher fits in 9MB and supports Windows 7-11.
+Le frontend est écrit en Svelte, le lanceur entier tient dans 9Mo et prend en charge Windows 7-11.
@@ -40,12 +40,14 @@ Si vous n'êtes pas sûr d'un modèle, inspectez `package.json` et `wails.json`
 - [wails-react-template](https://github.com/flin7/wails-react-template) - Un modèle minimal pour React qui supporte le développement en direct
 - [wails-template-nextjs](https://github.com/LGiki/wails-template-nextjs) - Un modèle utilisant Next.js et TypeScript
 - [wails-vite-react-ts-tailwind-template](https://github.com/hotafrika/wails-vite-react-ts-tailwind-template) - Un modèle pour React + TypeScript + Vite + TailwindCSS
+- [wails-vite-react-ts-tailwind-shadcnui-template](https://github.com/Mahcks/wails-vite-react-tailwind-shadcnui-ts) - Un modèle avec Vite, React, TypeScript, TailwindCSS, et shadcn/ui

 ## Svelte

 - [wails-svelte-template](https://github.com/raitonoberu/wails-svelte-template) - Un modèle utilisant Svelte
 - [wails-vite-svelte-template](https://github.com/BillBuilt/wails-vite-svelte-template) - Un modèle utilisant Svelte et Vite
 - [wails-vite-svelte-tailwind-template](https://github.com/BillBuilt/wails-vite-svelte-tailwind-template) - Un modèle utilisant Svelte et Vite avec TailwindCSS v3
+- [wails-svelte-tailwind-vite-template](https://github.com/PylotLight/wails-vite-svelte-tailwind-template/tree/master) - An updated template using Svelte v4.2.0 and Vite with TailwindCSS v3.3.3
 - [wails-sveltekit-template](https://github.com/h8gi/wails-sveltekit-template) - Un modèle utilisant SvelteKit

 ## Solid
@@ -187,7 +187,28 @@ Le serveur de développement utilise une technique appelée "debouncing", ce qui

 ## Serveur de développement externe

-Certains frameworks sont fournis avec leur propre serveur de rechargement en direct, cependant ils ne seront pas en mesure de tirer parti des liaisons Wails Go. Dans ce scénario, il est préférable d'exécuter un script qui va surveiller le projet dans dossier build, dossier que Wails surveille aussi. Pour un exemple, voir le modèle svelte par défaut qui utilise [rollup](https://rollupjs.org/guide/en/). Pour [create-react-app](https://create-react-app.dev/), il est possible d'utiliser [ce script](https://gist.github.com/int128/e0cdec598c5b3db728ff35758abdbafd) pour obtenir un résultat similaire.
+Certains frameworks sont fournis avec leur propre serveur de rechargement en direct, cependant ils ne seront pas en mesure de tirer parti des liaisons Wails Go. Dans ce scénario, il est préférable d'exécuter un script qui va surveiller le projet dans dossier build, dossier que Wails surveille aussi. Pour un exemple, voir le modèle svelte par défaut qui utilise [rollup](https://rollupjs.org/guide/en/).
+
+### Create React App
+
+The process for a Create-React-App project is slightly more complicated. In order to support live frontend reloading the following configuration needs to be added to your `wails.json`:
+
+```json
+  "frontend:dev:watcher": "yarn start",
+  "frontend:dev:serverUrl": "http://localhost:3000",
+```
+
+The `frontend:dev:watcher` command will start the Create-React-App development server (hosted on port `3000` typically). The `frontend:dev:serverUrl` command then instructs Wails to serve assets from the development server when loading the frontend rather than from the build folder. In addition to the above, the `index.html` needs to be updated with the following:
+
+```html
+    <head>
+        <meta name="wails-options" content="noautoinject" />
+        <script src="/wails/ipc.js"></script>
+        <script src="/wails/runtime.js"></script>
+    </head>
+```
+
+This is required as the watcher command that rebuilds the frontend prevents Wails from injecting the required scripts. This circumvents that issue by ensuring the scripts are always injected. With this configuration, `wails dev` can be run which will appropriately build the frontend and backend with hot-reloading enabled. Additionally, when accessing the application from a browser the React developer tools can now be used on a non-minified version of the application for straightforward debugging. Finally, for faster builds, `wails dev -s` can be run to skip the default building of the frontend by Wails as this is an unnecessary step.

 ## Module Go

@@ -0,0 +1,153 @@
+# SvelteKit
+
+This guide will go into:
+
+1.  Miminal Installation Steps - The steps needed to get a minimum Wails setup working for SvelteKit.
+2.  Install Script - Bash script for accomplishing the Minimal Installation Steps with optional Wails branding.
+3.  Important Notes - Issues that can be encountered when using SvelteKit + Wails and fixes.
+
+## 1.  Minimal Installation Steps
+
+##### Install Wails for Svelte.
+
+-   `wails init -n myapp -t svelte`
+
+##### Delete the svelte frontend.
+
+-   Navigate into your newly created myapp folder.
+-   Delete the folder named "frontend"
+
+##### While in the Wails project root. Use your favorite package manager and install SvelteKit as the new frontend.  Follow the prompts.
+
+-   `npm create svelte@latest frontend`
+
+##### Modify wails.json.
+
+-   Add `"wailsjsdir": "./frontend/src/lib",` Do note that this is where your Go and runtime functions will appear.
+-   Change your package manager frontend here if not using npm.
+
+##### Modify main.go.
+
+-   The first comment `//go:embed all:frontend/dist` needs to be changed to `//go:embed all:frontend/build`
+
+##### Install/remove dependencies using your favorite package manager.
+
+-   Navigate into your "frontend" folder.
+-   `npm i`
+-   `npm uninstall @sveltejs/adapter-auto`
+-   `npm i -D @sveltejs/adapter-static`
+
+##### Change adapter in svelte.config.js
+
+-   First line of file change `import adapter from '@sveltejs/adapter-auto';` to `import adapter from '@sveltejs/adapter-static';`
+
+##### Put SvelteKit into SPA mode with prerendering.
+
+-   Create a file under myapp/frontend/src/routes/ named +layout.ts/+layout.js.
+-   Add two lines into the newly created file `export const prerender = true` and `export const ssr = false`
+
+##### Test installation.
+
+-   Navigate back into the Wails project root (one directory up).
+-   run `wails dev`
+-   If the application doesn't run please check through the previous steps.
+
+## 2.  Install Script
+
+##### This Bash Script does the steps listed above.  Make sure to read over the script and understand what the script is doing on your computer.
+
+-   Create a file sveltekit-wails.sh
+-   Copy the below code into the new file then save it.
+-   Make it executable with `chmod +x sveltekit-wails.sh`
+-   Brand is an optional param below that adds back in the wails branding.  Leave third param blank to not insert the Wails branding.
+-   Example usage: `./sveltekit-wails.sh pnpm newapp brand`
+
+##### sveltekit-wails.sh:
+
+```
+manager=$1
+project=$2
+brand=$3
+wails init -n $project -t svelte
+cd $project
+sed -i "s|npm|$manager|g" wails.json
+sed -i 's|"auto",|"auto",\n  "wailsjsdir": "./frontend/src/lib",|' wails.json
+sed -i "s|all:frontend/dist|all:frontend/build|" main.go
+if [[ -n $brand ]]; then
+	mv frontend/src/App.svelte +page.svelte
+	sed -i "s|'./assets|'\$lib/assets|" +page.svelte
+	sed -i "s|'../wails|'\$lib/wails|" +page.svelte
+	mv frontend/src/assets .
+fi
+rm -r frontend
+$manager create svelte@latest frontend
+if [[ -n $brand ]]; then
+	mv +page.svelte frontend/src/routes/+page.svelte
+	mkdir frontend/src/lib
+	mv assets frontend/src/lib/
+fi
+cd frontend
+$manager i
+$manager uninstall @sveltejs/adapter-auto
+$manager i -D @sveltejs/adapter-static
+echo -e "export const prerender = true\nexport const ssr = false" > src/routes/+layout.ts
+sed -i "s|-auto';|-static';|" svelte.config.js
+cd ..
+wails dev
+```
+
+## 3.  Important Notes
+
+##### Server files will cause build failures.
+
+-   \+layout.server.ts, +page.server.ts, +server.ts or any file with "server" in the name will fail to build as all routes are prerendered.
+
+##### The Wails runtime unloads with full page navigations!
+
+-   Anything that causes full page navigations: `window.location.href = '/<some>/<page>'` or Context menu reload when using wails dev.  What this means is that you can end up losing the ability to call any runtime breaking the app. There are two ways to work around this.
+-   Use `import { goto } from '$app/navigation'` then call `goto('/<some>/<page>')` in your +page.svelte. This will prevent a full page navigation.
+-   If full page navigation can't be prevented the Wails runtime can be added to all pages by adding the below into the `<head>` of myapp/frontend/src/app.html
+
+```
+<head>
+...
+	<meta name="wails-options" content="noautoinject" />
+	<script src="/wails/ipc.js"></script>
+	<script src="/wails/runtime.js"></script>
+...
+</head>
+```
+
+See https://wails.io/docs/guides/frontend for more information.
+
+##### Inital data can be loaded and refreshed from +page.ts/+page.js to +page.svelte.
+
+-   \+page.ts/+page.js works well with load() https://kit.svelte.dev/docs/load#page-data
+-   invalidateAll() in +page.svelte will call load() from +page.ts/+page.js https://kit.svelte.dev/docs/load#rerunning-load-functions-manual-invalidation.
+
+##### Error Handling
+
+-   Expected errors using Throw error works in +page.ts/+page.js with a +error.svelte page. https://kit.svelte.dev/docs/errors#expected-errors
+-   Unexpected errors will cause the application to become unusable.  Only recovery option (known so far) from unexpected errors is to reload the app.  To do this create a file myapp/frontend/src/hooks.client.ts then add the below code to the file.
+
+```
+import { WindowReloadApp } from '$lib/wailsjs/runtime/runtime' 
+export async function handleError() {
+	WindowReloadApp()
+}
+```
+
+##### Using Forms and handling functions
+
+-   The simplest way is to call a function from the form is the standard, bind:value your variables and prevent submission `<form method="POST" on:submit|preventDefault={handle}>`
+-   The more advanced way is to use:enhance (progressive enhancement) which will allow for convenient access to formData, formElement, submitter.  The important note is to always cancel() the form which prevents server side behavior.  https://kit.svelte.dev/docs/form-actions#progressive-enhancement  Example:
+
+```
+<form method="POST" use:enhance={({cancel, formData, formElement, submitter}) => {
+	cancel()
+	console.log(Object.fromEntries(formData))
+	console.log(formElement)
+	console.log(submitter)
+	handle()
+}}>
+```
@@ -170,3 +170,19 @@ If this does happen, simply delete `frontend/node_modules` and `frontend/package
 ## Build process stuck on "Generating bindings"

 Bindings generation process runs your application in a special mode. If application, intentionally or unintentionally, contains an endless loop (i.e. not exiting after `wails.Run()` finished), this can lead to build process stuck on the stage of bindings generation. Please make sure your code exits properly.
+
+## Mac application flashes white at startup
+
+This is due to the default background of the webview being white. If you want to use the window background colour instead, you can make the webview background transparent using the following config:
+
+```go
+    err := wails.Run(&options.App{
+        Title:  "macflash",
+        Width:  1024,
+        Height: 768,
+        // Other settings
+        Mac: &mac.Options{
+            WebviewIsTransparent: true,
+        },
+    })
+```
@@ -236,7 +236,7 @@ Tous les types de données sont correctement traduits entre Go et JavaScript. M

 :::info Note

-Struct fields _must_ have a valid `json` tag to be included in the generated TypeScript.
+Les champs Struct _doivent avoir_ le champ `json` de défini afin de pouvoir l'inclure dans le TypeScript généré.

 Les structures imbriquées anonymes ne sont pas supportées pour le moment.

@@ -53,22 +53,23 @@ Si vous n'êtes pas sûr d'un modèle, inspectez les fichiers `package.json` et
 |:-------------------- |:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |:--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | -clean               | Nettoie le répertoire `build/bin`                                                                                                                                                                                  |                                                                                                                                                                                                                       |
 | -compiler "compiler" | Utiliser un autre compilateur pour compiler, par exemple go1.15beta1                                                                                                                                               | go                                                                                                                                                                                                                    |
-| -debug               | Conserve les informations de débogage dans l'application. Permet l'utilisation des outils de développement dans la fenêtre de l'application                                                                        |                                                                                                                                                                                                                       |
-| -dryrun              | Prints the build command without executing it                                                                                                                                                                      |                                                                                                                                                                                                                       |
+| -debug               | Conserve les informations de débogage dans l'application et affiche la console de débogage. Permet l'utilisation des outils de développement dans la fenêtre de l'application                                      |                                                                                                                                                                                                                       |
+| -devtools            | Permet l'utilisation des devtools dans la fenêtre d'application en production (quand -debug n'est pas utilisé)                                                                                                     |                                                                                                                                                                                                                       |
+| -dryrun              | Affiche la commande build sans l'exécuter                                                                                                                                                                          |                                                                                                                                                                                                                       |
 | -f                   | Forcer la compilation de l'application                                                                                                                                                                             |                                                                                                                                                                                                                       |
 | -garbleargs          | Arguments à passer à garble                                                                                                                                                                                        | `-literals -tiny -seed=random`                                                                                                                                                                                        |
 | -ldflags "flags"     | Options supplémentaires à passer au compilateur                                                                                                                                                                    |                                                                                                                                                                                                                       |
-| -m                   | Skip mod tidy before compile                                                                                                                                                                                       |                                                                                                                                                                                                                       |
+| -m                   | Permet d'ignorer mod tidy avant la compilation                                                                                                                                                                     |                                                                                                                                                                                                                       |
 | -nopackage           | Ne pas empaqueter l'application                                                                                                                                                                                    |                                                                                                                                                                                                                       |
-| -nocolour            | Disable colour in output                                                                                                                                                                                           |                                                                                                                                                                                                                       |
+| -nocolour            | Désactive la couleur des logs dans le terminal                                                                                                                                                                     |                                                                                                                                                                                                                       |
 | -nosyncgomod         | Ne pas synchroniser go.mod avec la version Wails                                                                                                                                                                   |                                                                                                                                                                                                                       |
-| -nsis                | Generate NSIS installer for Windows                                                                                                                                                                                |                                                                                                                                                                                                                       |
+| -nsis                | Génère l'installateur NSIS pour Windows                                                                                                                                                                            |                                                                                                                                                                                                                       |
 | -o filename          | Nom du fichier de sortie                                                                                                                                                                                           |                                                                                                                                                                                                                       |
 | -obfuscated          | Cacher le code de l'application en utilisant [garble](https://github.com/burrowers/garble)                                                                                                                         |                                                                                                                                                                                                                       |
 | -platform            | Construit pour les [plates-formes](../reference/cli.mdx#platforms) données (séparées par des virgules) par exemple. `windows/arm64`. Notez que si vous ne donnez pas l'architecture, `runtime.GOARCH` est utilisé. | platform = le contenu de la variable d'environnement `GOOS` si elle existe, autrement `runtime.GOOS`.<br/>arch = le contenu de la variable d'environnement `GOARCH` si elle existe, autrement `runtime.GOARCH`. |
 | -race                | Construire avec le détecteur Go race                                                                                                                                                                               |                                                                                                                                                                                                                       |
 | -s                   | Ignorer la construction du frontend                                                                                                                                                                                |                                                                                                                                                                                                                       |
-| -skipbindings        | Skip bindings generation                                                                                                                                                                                           |                                                                                                                                                                                                                       |
+| -skipbindings        | Ignorer la génération des liaisons                                                                                                                                                                                 |                                                                                                                                                                                                                       |
 | -tags "extra tags"   | Options de compilation à passer au compilateur Go. Doivent être entre guillemets. Séparés par un espace ou une virgule (pas les deux)                                                                              |                                                                                                                                                                                                                       |
 | -trimpath            | Supprimer tous les chemins vers les fichiers système de l'exécutable final.                                                                                                                                        |                                                                                                                                                                                                                       |
 | -u                   | Met à jour le `go.mod de votre projet` pour utiliser la même version de Wails que le CLI                                                                                                                           |                                                                                                                                                                                                                       |
@@ -88,7 +89,8 @@ Exemple:

 :::info

-On Mac, the application will be bundled with `Info.plist`, not `Info.dev.plist`.
+Info  
+Sur Mac, l'application sera livrée avec `Info.plist`, pas `Info.dev.plist`.

 :::

@@ -164,11 +166,11 @@ Your system is ready for Wails development!
 - Un observateur est démarré et déclenchera une reconstruction de votre application de développement s'il détecte des changements dans vos fichiers go
 - Un serveur web est lancé sur `http://localhost:34115` qui sert votre application (et pas seulement le frontend) sur http. Cela vous permet d'utiliser les extensions de développement de votre navigateur favori
 - Tous les assets de l'application sont chargés à partir du disque. Si elles sont modifiées, l'application se rechargera automatiquement (pas de recompilation). Tous les navigateurs connectés rechargeront également
- A JS module is generated that provides the following:
-  - JavaScript wrappers of your Go methods with autogenerated JSDoc, providing code hinting
-  - TypeScript versions of your Go structs, that can be constructed and passed to your go methods
- A second JS module is generated that provides a wrapper + TS declaration for the runtime
- On macOS, it will bundle the application into a `.app` file and run it. It will use a `build/darwin/Info.dev.plist` for development.
+- Un module JS est généré fournissant les éléments suivants :
+  - Les méthodes Javascript permettant d'appeler vos méthodes Go avec JSDoc autogénérée, vous fournissant des indications sur les méthodes
+  - Les versions TypeScript de vos structures Go, qui peuvent être construites et transmises à vos méthodes
+- Un second module JS est généré qui fournit une déclaration des méthodes et structures pour l'exécutable
+- Sur macOS, il regroupera l'application dans un fichier `.app` et l'exécutera. Il utilisera un `build/darwin/Info.dev.plist` pour le développement.

 | Option                               | Description                                                                                                                                                                                                               | Par défaut               |
 |:------------------------------------ |:------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |:------------------------ |
@@ -179,7 +181,7 @@ Your system is ready for Wails development!
 | -debounce                            | Le temps d'attente pour le rechargement après qu'une modification d'actif est détectée                                                                                                                                    | 100 (millisecondes)      |
 | -devserver "host:port"               | L'adresse à laquelle lier le serveur de développement wails                                                                                                                                                               | "localhost:34115"        |
 | -extensions                          | Extensions pour déclencher les rebuilds (séparés par des virgules)                                                                                                                                                        | go                       |
-| -forcebuild                          | Force build of application                                                                                                                                                                                                |                          |
+| -forcebuild                          | Force la compilation de l'application                                                                                                                                                                                     |                          |
 | -frontenddevserverurl "url"          | Utiliser l'url du serveur de développement tiers pour servir les actifs, EG Vite                                                                                                                                          | ""                       |
 | -ldflags "flags"                     | Options supplémentaires à passer au compilateur                                                                                                                                                                           |                          |
 | -loglevel "loglevel"                 | Niveau de log à utiliser - Trace, Debug, Info, Warning, Error                                                                                                                                                             | Debug                    |
@@ -190,7 +192,7 @@ Your system is ready for Wails development!
 | -reloaddirs                          | Répertoires supplémentaires pour déclencher les recharges (séparés par des virgules)                                                                                                                                      | Valeur dans `wails.json` |
 | -s                                   | Ignorer la construction du frontend                                                                                                                                                                                       | false                    |
 | -save                                | Sauvegarde les options `assetdir`, `reloaddirs`, `wailsjsdir`, `debounce`, `devserver` and `frontenddevserverurl` dans `wails.json` pour quelles deviennent les informations par défaut pour les prochaines utilisations. |                          |
-| -skipbindings                        | Skip bindings generation                                                                                                                                                                                                  |                          |
+| -skipbindings                        | Ignorer la génération des liaisons                                                                                                                                                                                        |                          |
 | -tags "extra tags"                   | Options de construction à passer au compilateur (séparées par des guillemets et des espaces)                                                                                                                              |                          |
 | -v                                   | Niveau de verbosité (0 - silencieux, 1 - par défaut, 2 - verbeux)                                                                                                                                                         | 1                        |
 | -wailsjsdir                          | Le répertoire où stocker les modules JS Wails générés                                                                                                                                                                     | Valeur dans `wails.json` |
@@ -50,12 +50,14 @@ func main() {
        OnBeforeClose:      app.beforeClose,
        CSSDragProperty:   "--wails-draggable",
        CSSDragValue:      "drag",
+        EnableDefaultContextMenu: false,
        EnableFraudulentWebsiteDetection: false,
        ZoomFactor:           1.0,
        IsZoomControlEnabled: false,
        Bind: []interface{}{
            app,
        },
+        ErrorFormatter: func(err error) any { return err.Error() },
        Windows: &windows.Options{
            WebviewIsTransparent:              false,
            WindowIsTranslucent:               false,
@@ -103,6 +105,7 @@ func main() {
            Icon: icon,
            WindowIsTranslucent: false,
            WebviewGpuPolicy: linux.WebviewGpuPolicyAlways,
+            ProgramName: "wails"
        },
        Debug: options.Debug{
            OpenInspectorOnStartup: false,
@@ -359,11 +362,38 @@ Indique quelle valeur le style `CSSDragProperty` doit avoir pour faire glisser l

 Nom: CSSDragValue<br/> Type: `string`

+### EnableDefaultContextMenu
+
+EnableDefaultContextMenu active le menu contextuel par défaut du navigateur en production.
+
+Par défaut, le menu contextuel par défaut du navigateur n'est disponible qu'en développement et dans un `-debug` ou `-devtools` [build](../reference/cli.mdx#build) avec l'inspecteur de devtools, En utilisant cette option, vous pouvez activer le menu contextuel par défaut dans `production` alors que l'inspecteur devtools ne sera pas disponible à moins que le drapeau `-devtools` ne soit utilisé.
+
+Lorsque cette option est activée, par défaut, le menu contextuel ne sera affiché que pour du texte (où Couper/Copier/Coller est nécessaire), pour remplacer ce comportement, vous pouvez utiliser la propriété CSS `--default-contextmenu` sur n'importe quel élément HTML (y compris le corps ``) avec les valeurs suivantes :
+
+| Style CSS                      | Comportement                                                                                                                                                                  |
+| ------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--default-contextmenu: auto;` | (**défaut**) n'affichera le menu contextuel par défaut que si :<br/> contentEditable est vrai OU le texte a été sélectionné OU l'élément est entrée ou la zone de texte |
+| `--default-contextmenu: show;` | affichera toujours le menu de contexte par défaut                                                                                                                             |
+| `--default-contextmenu: hide;` | masquera toujours le menu contextuel par défaut                                                                                                                               |
+
+Cette règle est héritée comme n'importe quelle règle CSS normale, donc l'imbrication fonctionne comme prévu.
+
+:::note
+Cette fonctionnalité de filtrage n'est activée qu'en production, donc en développement et en construction de débogage, le menu contextuel complet est toujours disponible partout.
+:::
+
+:::warning
+Cette fonctionnalité de filtrage n'est PAS une mesure de sécurité, le développeur devrait s'attendre à ce que le menu contextuel complet puisse être divulgué à tout moment qui pourrait contenir des commandes comme (Télécharger l'image, Recharger, Enregistrer la page web), si c'est une préoccupation, le développeur DEVRAIT NE PAS activer le menu contextuel par défaut.
+:::
+
+
+Nom: EnableDefaultContextMenu<br/> Type: `bool`
+
 ### EnableFraudulentWebsiteDetection

-EnableFraudulentWebsiteDetection enables scan services for fraudulent content, such as malware or phishing attempts. These services might send information from your app like URLs navigated to and possibly other content to cloud services of Apple and Microsoft.
+EnableFraudulentWebWebDetection permet de rechercher des contenus frauduleux, tels que des programmes malveillants ou des tentatives d'hameçonnage. Ces services peuvent envoyer des informations à partir de votre application, telles que les URL vers lesquelles vous avez navigué et éventuellement d'autres contenus vers le cloud, des services d'Apple et de Microsoft.

-Name: EnableFraudulentWebsiteDetection<br/> Type: `bool`
+Nom: EnableFraudulentWebsiteDetection<br/> Type: `bool`

 ### ZoomFactor

@@ -383,6 +413,12 @@ La liste des structs Go définissant des méthodes qui doivent être liées au f

 Nom: Bind<br/> Type: `[]interface{}`

+### ErrorFormatter
+
+Une fonction qui détermine comment les erreurs sont formatées lorsqu'elles sont retournées par un appel de méthode JS-to-Go. La valeur retournée sera sous format JSON.
+
+Nom: ErrorFormatter<br/> Type: `func (error) any`
+
 ### Windows

 Ceci définit les options [spécifiques à Windows](#windows).
@@ -553,9 +589,9 @@ Nom: OnResume<br/> Type: `func()`

 #### WebviewGpuIsDisabled

-Setting this to `true` will disable GPU hardware acceleration for the webview.
+Définir ceci à `true` désactivera l'accélération matérielle GPU pour la webview.

-Name: WebviewGpuIsDisabled<br/> Type: `bool`
+Nom: WebviewGpuIsDisabled<br/> Type: `bool`

 ### Mac

@@ -739,17 +775,25 @@ Nom: WindowIsTranslucent<br/> Type: `bool`

 #### WebviewGpuPolicy

-This option is used for determining the webview's hardware acceleration policy.
+Cette option est utilisée pour déterminer la politique d'accélération matérielle effectuée par webview.

-Name: WebviewGpuPolicy<br/> Type: [`options.WebviewGpuPolicy`](#webviewgpupolicy-type)<br/> Default: `WebviewGpuPolicyAlways`
+Nom: WebviewGpuPolicy<br/> Type: [`options.WebviewGpuPolicy`](#webviewgpupolicy-type)<br/> Défaut: `WebviewGpuPolicyAlways`

-##### WebviewGpuPolicy type
+##### Type de WebviewGpuPolicy

-| Valeur                   | Description                                                          |
-| ------------------------ | -------------------------------------------------------------------- |
-| WebviewGpuPolicyAlways   | Hardware acceleration is always enabled                              |
-| WebviewGpuPolicyOnDemand | Hardware acceleration is enabled/disabled as request by web contents |
-| WebviewGpuPolicyNever    | Hardware acceleration is always disabled                             |
+| Valeur                   | Description                                                                  |
+| ------------------------ | ---------------------------------------------------------------------------- |
+| WebviewGpuPolicyAlways   | L'accélération matérielle est toujours activée                               |
+| WebviewGpuPolicyOnDemand | L'accélération matérielle est activée/désactivée à la demande du contenu web |
+| WebviewGpuPolicyNever    | L'accélération matérielle est toujours désactivée                            |
+
+#### ProgramName
+
+This option is used to set the program's name for the window manager via GTK's g_set_prgname(). This name should not be localized, [see the docs](https://docs.gtk.org/glib/func.set_prgname.html).
+
+When a .desktop file is created this value helps with window grouping and desktop icons when the .desktop file's `Name` property differs form the executable's filename.
+
+Name: ProgramName<br/> Type: string<br/>

 ### Debug

@@ -763,5 +807,5 @@ Définir cette option à `true` ouvrira l'inspecteur Web au démarrage de l'appl

 Nom: OpenInspectorOnStartup<br/> Type: `bool`

-[^1]: This requires WebKit2GTK 2.36+ support and your app needs to be build with the build tag `webkit2_36` to activate support for this feature. This also bumps the minimum requirement of WebKit2GTK to 2.36 for your app.
-[^2]: This requires WebKit2GTK 2.40+ support and your app needs to be build with the build tag `webkit2_40` to activate support for this feature. This also bumps the minimum requirement of WebKit2GTK to 2.40 for your app.
+[^1]: Cela nécessite la prise en charge de WebKit2GTK 2.36+ et votre application doit être construite avec la balise de compilation `webkit2_36` pour activer le support de cette fonctionnalité. Cela augmente aussi la version minnimale de WebKit2GTK à 2.36 pour votre application.
+[^2]: Cela nécessite la prise en charge de WebKit2GTK 2.40+ et votre application doit être construite avec la balise de compilation `webkit2_40` pour activer le support de cette fonctionnalité. Cela augmente aussi la version minnimale de WebKit2GTK à 2.40 pour votre application.&#160;[ [    &#8617;](#fnref2:2){.footnote-backref} &#8617;](#fnref:2){.footnote-backref}
@@ -2,11 +2,11 @@
 sidebar_position: 5
 ---

-# Project Config
+# Configuration du projet

-The project config resides in the `wails.json` file in the project directory. The structure of the config is:
+La configuration du projet se trouve dans le fichier `wails.json` du répertoire du projet. La structure de la configuration est :

-```json
+```json5
 {
  // Project config version
  "version": "",
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Lea Anthony	4749172aed	Test bun install	2023-09-11 20:54:49 +10:00
github-actions[bot]	a419721dcd	docs: sync translations (#2699 ) Co-authored-by: leaanthony <leaanthony@users.noreply.github.com>	2023-09-08 23:25:21 +10:00
Light	e731e2591a	Fix typo on https://wails.io/docs/reference/options#application-options (#2887 ) * Update options.mdx * Update changelog.mdx	2023-09-08 23:23:33 +10:00
Duoc Nguyen	59b25edb5c	docs: make the install command easier to copy (#2891 )	2023-09-08 13:56:40 +10:00
Zámbó, Levente	647bc87600	[v2, Linux] fix menu background color (#2873 ) * fix menu background color * remove commented line * handle transparent window and background color --------- Co-authored-by: Lea Anthony <lea.anthony@gmail.com>	2023-09-07 21:25:02 +10:00
dependabot[bot]	ebf56f6585	Bump semver from 5.7.1 to 5.7.2 in /website (#2808 ) Bumps [semver](https://github.com/npm/node-semver) from 5.7.1 to 5.7.2. - [Release notes](https://github.com/npm/node-semver/releases) - [Changelog](https://github.com/npm/node-semver/blob/v5.7.2/CHANGELOG.md) - [Commits](https://github.com/npm/node-semver/compare/v5.7.1...v5.7.2) --- updated-dependencies: - dependency-name: semver dependency-type: indirect ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2023-09-07 21:22:43 +10:00