Get best of the week

Création d'une application de bureau à l'aide de Golang et Fyne

Aujourd'hui, nous allons développer une application de bureau sur Golang


Développer une application de bureau golang n'est pas une tâche typique pour un programmeur golang. Il n'y a pas tellement de bibliothèques open source prêtes à l'emploi pour Google pour le résoudre à la demande de golang desktop, des exemples de ce qui a été trouvé:

  1. gotk
  2. Fyne
  3. Gxui

Fyne a été choisi parce que le référentiel github de ce projet contient le plus grand nombre d'étoiles, et il prend également en charge la conception de matériaux notoire.

Voyons quelles options pour afficher l'interface qu'il nous fournit.

Les widgets suivants sont disponibles dans la boîte:

  • Bouton.
  • Un conteneur (pour regrouper les widgets enfants et les diriger horizontalement ou verticalement).
  • Case à cocher, champs de saisie de texte ou de mot de passe.
  • Formes et groupes.
  • Hyperlien.
  • L'icône.
  • L'étiquette.
  • Barre de progression.
  • Un conteneur déroulant.
  • Commutateur.
  • Sélectionner
  • Onglets.
  • Barre d'outils.

Dans le cas où parmi les éléments d'interface le nécessaire n'était pas trouvé, il est possible d'implémenter des widgets personnalisés à l'aide d'une simple API.

Essayons d'écrire une application golang gui pour afficher les prévisions météorologiques pour les prochains jours en utilisant Fyne. Le code d'application complet peut être trouvé sur le lien sur github.

Tout d'abord, créez un projet vide sur Golang et installez Fyne.

go get fyne.io/fyne

Étant donné que l'application affichera des informations météorologiques, vous devez obtenir ces informations. Pour ce faire, passez à l'API Open Weather Map.

func getWeatherForecast(result interface{}) error {
  var url = fmt.Sprintf("https://api.openweathermap.org/data/2.5/forecast?q=Voronezh&cnt=4&units=metric&appid=%s", openWeatherMapApiKey) //    
  response, err := http.Get(url)
  if err != nil {
     fmt.Print(err)
  }
  defer response.Body.Close()
  return json.NewDecoder(response.Body).Decode(result)
}

Pour stocker des données, vous pouvez utiliser la structure suivante (je n'y ai laissé que certains des champs que l'API renvoie), il convient de prêter attention au fait que tous les champs de la structure sont en majuscules, mais dans la réponse de l'API, ils sont décrits avec un petit.

type WeatherInfo struct {
  List []WeatherListItem `json:list`
}

type WeatherListItem struct {
  Dt      int           `json:dt`
  Main    WeatherMain   `json:main`
  Weather []WeatherType `json:weather`
}

type WeatherMain struct {
  Temp      float32 `json:temp`
  FeelsLike float32 `json:feels_like`
  Humidity  int     `json:humidity`
}

type WeatherType struct {
  Icon string `json:icon`
}

Maintenant, nous pouvons recevoir des données météorologiques sous la forme d'une structure. Il reste à implémenter l'interface de l'application de bureau golang.

func setupUi(weatherInfo WeatherInfo) {
  app := app.New()

  w := app.NewWindow("   ")

  var vBox = widget.NewVBox() //        

  for i := 0; i < len(weatherInfo.List); i++ {
     var weatherForDay = weatherInfo.List[i] //     
     var weatherMainGroup = widget.NewVBox(
        widget.NewLabel(fmt.Sprintf(": %.2f °C", weatherForDay.Main.Temp)),
        widget.NewLabel(fmt.Sprintf(" : %.2f °C", weatherForDay.Main.FeelsLike)),
        widget.NewLabel(fmt.Sprintf(": %d%%", weatherForDay.Main.Humidity)),
     ) //  3    

     var weatherTypeGroup = widget.NewVBox()
     for weatherTypeI := 0; weatherTypeI < len(weatherForDay.Weather); weatherTypeI++ {
        var resource, _ = fyne.LoadResourceFromURLString(fmt.Sprintf("http://openweathermap.org/img/wn/%s.png", weatherForDay.Weather[weatherTypeI].Icon)) //   ,   
        var icon = widget.NewIcon(resource)
        weatherTypeGroup.Append(icon)
     }

     var time = time2.Unix(int64(weatherInfo.List[i].Dt), 0).String()
     vBox.Append(widget.NewGroup(time)) 
     vBox.Append(widget.NewHBox(weatherMainGroup, weatherTypeGroup))
  }
  vBox.Append(widget.NewButton("", func() {
     app.Quit()
  }))

  w.SetContent(vBox) //    

  w.ShowAndRun() //   
}

Ici, nous créons nos widgets, les remplissons de données et les collectons en groupes pour organiser l'ordre dans lequel ils sont affichés.

Terminé.

Il ne reste plus qu'à exécuter l'application et à voir à quoi elle ressemble. Étant donné que le cadre est multiplateforme, vous pouvez l'exécuter à la fois sur Windows et macOS et Linux.

image
Lancement de l'application golang mac os

image
Et cela ressemble à une application golang windows

En conséquence, il s'est avéré créer une application de bureau golang multiplateforme simple et essayer Fyne en action. Malheureusement, go ne vaut guère la peine d'être considéré comme un langage approprié pour développer des applications de bureau modernes, cependant, il est toujours intéressant de toucher quelque chose de nouveau et d'inhabituel dans la pratique.

Merci à tous pour votre attention.

More articles:


All Articles