Spot - Une boîte à outils GUI de bureau pour Go, similaire à React

• Une boîte à outils GUI réactive, simple et multiplateforme
• Simplicité : peut être ajoutée simplement à un projet pour construire immédiatement une UI. Aucun outil supplémentaire ni étape de génération de code n’est nécessaire. Il suffit d’écrire du code Go pour créer une application GUI native sous forme de binaire autonome
• Multiplateforme : utilise des widgets natifs lorsque c’est possible, et choisit automatiquement à la compilation le backend le plus adapté à la plateforme en cours d’exécution. Deux implémentations de backend sont actuellement fournies : une basée sur FLTK et une basée sur Cocoa
• Réactif : met automatiquement à jour l’UI lorsque l’état de l’application change. Fournit des fonctions de rendu sans effets de bord et utilise le hook UseState pour gérer l’état de l’application
• Large prise en charge des widgets : Spot fournit nativement divers contrôles UI, notamment des boutons, libellés, champs de texte, curseurs et menus déroulants

Questions fréquentes (FAQ)

Que signifie « réactif » ?

• Dans Spot, réactif signifie que l’UI est automatiquement mise à jour lorsque l’état de l’application change. Cela est réalisé en reconstruisant l’arbre immuable des composants lors d’un changement d’état, puis en le comparant à l’état précédent pour déterminer quels contrôles UI doivent être mis à jour.

Que sont les « widgets natifs » utilisés par Spot ?

• Actuellement, Spot utilise le backend Cocoa sur macOS et un backend basé sur FLTK sur toutes les autres plateformes. Il est aussi possible d’utiliser FLTK sur Mac. Une meilleure prise en charge de Windows est prévue à l’avenir.

Puis-je implémenter mes propres hooks ?

• Oui, comme avec React, vous pouvez implémenter vos propres hooks. Il suffit de créer une fonction qui prend *spot.RenderContext comme premier argument, ce qui permet de se brancher sur le cycle de vie de Spot.

Comment écrire des composants personnalisés ?

• Il existe plusieurs façons de séparer l’UI en composants dans Spot. La principale consiste à créer une structure qui implémente l’interface spot.Component. Cette interface possède une seule méthode : Render(ctx *spot.RenderContext) spot.Component.

Puis-je utiliser une bibliothèque de widgets différente de celle fournie ?

• Oui, c’est possible. Il suffit de créer une structure qui implémente l’interface spot.Component et gère les widgets natifs.

Puis-je utiliser un backend autre que Cocoa ou FLTK ?

• Pour le moment, seuls ces deux backends sont pris en charge. Si vous souhaitez en ajouter un autre, vous pouvez soumettre une PR.

Quelle est la différence entre spot/ui et spot ?

• spot est le package principal qui fournit le modèle réactif et les capacités de rendu. Il est indépendant du backend et peut être utilisé avec tout ensemble de contrôles implémentant l’interface spot.Control.
• spot/ui fournit un ensemble préconstruit de contrôles GUI multiplateformes utilisables avec spot.

Quelle est la différence entre un « composant » et un « contrôle » ?

• Dans Spot, un composant est une unité logique de l’application qui inclut la logique métier et l’état. Tous les composants sont composés d’autres composants et sont finalement rendus en un ou plusieurs « contrôles ».
• Un contrôle est un type particulier de composant qui est monté dans l’arbre UI et représente un élément visuel à l’écran.

Que signifient dans Spot les termes « make », « render », « build », « mount » et « update » ?

• Make : processus de création d’une nouvelle instance de composant. Cela se fait en référençant une instance d’une structure qui implémente l’interface spot.Component, ou en appelant spot.Make avec une fonction de rendu.
• Render : processus consistant à appliquer l’état d’un composant à des briques de construction pour renvoyer une autre instance de composant. Cela se fait en appelant la méthode Render sur une instance de composant.
• Build : processus de création d’un nouvel arbre UI à partir d’une instance de composant. Il produit un arbre de contrôles en rendant récursivement les composants.
• Mount : processus de création des contrôles UI réels à partir de l’arbre de contrôles (virtuel). Cela se fait en appelant Mount sur un nœud de l’arbre, ou en appelant spot.Mount avec une instance de composant ou une fonction de rendu.
• Update : processus de mise à jour d’un arbre de contrôles (monté). Cela se fait en appelant Update sur un nœud de l’arbre.

Fonctionnalités que Spot ne prend pas encore en charge

• Mise en page automatique
• Fenêtres multiples
• Boîtes de dialogue modales
• Fenêtres redimensionnables
• Barre de menus
• Widgets personnalisés
• Accès aux widgets natifs
• Glisser-déposer
• Internationalisation

Liste des contrôles UI pris en charge

• Button : bouton simple permettant de déclencher une action (Fl_Button, NSButton)
• Checkbox : contrôle permettant de sélectionner l’une de deux options mutuellement exclusives (Fl_Check_Button, NSButton (NSButtonTypeSwitch))
• ComboBox : menu déroulant avec saisie de texte (ComboBox, NSComboBox)
• Dial : contrôle d’état circulaire (Fl_Dial, NSProgressIndicator (avec le style NSCircular))
• Dropdown : menu déroulant permettant de choisir une option parmi plusieurs (Fl_Choice, NSComboBox)
• Image : contrôle d’image (Image, NSImageView)
• Label : libellé textuel simple, non modifiable (Fl_Box, NSTextField)
• ListBox : contrôle défilant permettant de sélectionner un ou plusieurs éléments dans une liste donnée (Fl_Select_Browser/Fl_Multi_Browser, NSTableView)
• ProgressBar : barre de progression visualisant l’avancement d’une tâche longue (Fl_Progress, NSProgressIndicator)
• Slider : contrôle de saisie par curseur horizontal (Fl_Slider, NSSlider)
• Spinner : contrôle de saisie numérique avec boutons haut/bas (Fl_Spinner, NSTextField+NSStepper)
• TextField : contrôle de saisie de texte sur une seule ligne (Fl_Input, NSTextField)
• TextView/TextEditor : zone de texte polyvalente permettant d’afficher/modifier du contenu textuel sur plusieurs lignes (Text, NSTextView)
• Window : contrôle représentant une fenêtre (de niveau supérieur) à l’écran (Fl_Window, NSWindow)

L’avis de GN⁺

• Spot facilite le développement d’applications GUI multiplateformes en Go. En particulier, son modèle réactif permet aux développeurs de se concentrer sur la logique applicative sans se soucier des mises à jour de l’UI.
• De nombreuses fonctionnalités ne sont pas encore prises en charge, ce qui peut imposer des limites pour le développement d’applications complexes. En particulier, si vous avez besoin de fonctionnalités comme la mise en page automatique ou les fenêtres multiples, il vaut mieux envisager une autre boîte à outils.
• La simplicité de Spot et sa prise en charge multiplateforme peuvent être très utiles pour de petits projets ou pour développer des prototypes. En revanche, ses limites fonctionnelles peuvent poser problème pour des applications de grande envergure.
• Si la communauté et la documentation de Spot progressent davantage, il sera plus facile pour davantage de développeurs de l’adopter et de l’utiliser. Il serait particulièrement utile d’avoir plus d’exemples sur l’écriture de hooks et de composants personnalisés.
• La possibilité d’étendre les backends de Spot est intéressante. Une meilleure prise en charge de Windows, en particulier, pourrait attirer davantage de développeurs.

[GN⁺]

Avis sur Hacker News

Résumé des commentaires de Hacker News

• Il serait utile d’indiquer les plateformes prises en charge dans le README. Il est suggéré de le rédiger comme la documentation de Flutter.
• Je veux créer des outils de développement internes avec Go, et j’utilise actuellement Wails avec satisfaction. Ce projet a aussi l’air intéressant et mérite qu’on s’y penche.
• Go pourrait offrir une bonne expérience pour le développement d’interfaces cross-platform.
  • Gérer la complexité de la build est l’une des grandes difficultés du développement cross-platform, et Go l’élimine presque entièrement.
  • Je me demande comment gérer la mise en page cross-platform lorsque la taille des contrôles natifs diffère selon les plateformes.
• Je me demande quels sont les avantages de l’approche par arbre de contrôles virtuel.
  • J’aimerais savoir quels bénéfices cela apporte par rapport à une mise à jour directe des contrôles affichés à l’utilisateur.
• Je cherchais quelque chose comme ça depuis des années.
  • J’avais besoin du support Windows, donc je suis passé au C++ pour utiliser wxWidgets.
• L’effort est à saluer, mais une solution cross-platform sans support Windows est regrettable.
• J’aurais aimé connaître ce projet il y a trois semaines.
  • Je pense qu’un framework React ou de type React porté en Go offrirait une excellente expérience de développement.
• Fltk prend en charge Windows.
  • Je me demande si Windows n’est pas encore supporté parce qu’une autre solution est utilisée.
• Je me demande si ce code implique qu’il faut régler GOMAXPROCS à au moins 2.
• Je me demande comment le build cross-platform fonctionne.
  • Ce serait bien d’avoir une commande capable de générer un .app macOS et un .exe Windows sans avoir à gérer la gestion des paquets propre à chaque plateforme, les conteneurs et les problèmes de signature.