Get best of the week

Erstellen einer Desktop-Anwendung mit Golang und Fyne

Heute werden wir eine Desktop-Anwendung auf Golang entwickeln


Das Entwickeln einer Golang-Desktop-Anwendung ist nicht gerade eine typische Aufgabe für einen Golang-Programmierer. Es gibt nicht so viele vorgefertigte Open-Source-Bibliotheken, die Google auf Anfrage von Golang Desktop lösen kann. Beispiele dafür, was gefunden wurde:

  1. gotk
  2. Fyne
  3. Gxui

Fyne wurde ausgewählt, da das Github-Repository dieses Projekts die meisten Sterne enthält und auch das berüchtigte Materialdesign unterstützt.

Mal sehen, welche Optionen für die Anzeige der Schnittstelle es bietet.

Die folgenden Widgets sind in der Box verfügbar:

  • Taste.
  • Ein Container (zum Gruppieren von untergeordneten Widgets und zum horizontalen oder vertikalen Ausrichten).
  • Kontrollkästchen, Felder zur Eingabe von Text oder Passwort.
  • Formen und Gruppen.
  • Hyperlink.
  • Das Symbol.
  • Das Etikett.
  • Fortschrittsanzeige.
  • Ein scrollbarer Container.
  • Schalter.
  • Wählen
  • Tabs.
  • Symbolleiste.

Für den Fall, dass unter den Schnittstellenelementen das erforderliche nicht gefunden wurde, können benutzerdefinierte Widgets mithilfe einer einfachen API implementiert werden.

Lassen Sie uns versuchen, eine Golang-GUI-Anwendung für die Anzeige von Wettervorhersagen für die nächsten Tage mit Fyne zu schreiben. Den vollständigen Anwendungscode finden Sie unter dem Link auf github.

Erstellen Sie zunächst ein leeres Projekt auf Golang und installieren Sie Fyne.

go get fyne.io/fyne

Da die Anwendung Wetterinformationen anzeigt, müssen Sie diese Informationen abrufen. Wenden Sie sich dazu an die Open Weather Map API.

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

Zum Speichern von Daten können Sie die folgende Struktur verwenden (darin habe ich nur einige der von der API zurückgegebenen Felder belassen). Beachten Sie, dass alle Felder der Struktur groß geschrieben sind, in der API-Antwort jedoch mit einer kleinen beschrieben werden.

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`
}

Jetzt können wir Wetterdaten in Form einer Struktur empfangen. Es bleibt die Implementierung der Golang-Desktop-Anwendungsoberfläche.

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() //   
}

Hier erstellen wir unsere Widgets, füllen sie mit Daten und sammeln sie in Gruppen, um die Reihenfolge zu organisieren, in der sie angezeigt werden.

Erledigt.

Es bleibt nur, um die Anwendung auszuführen und zu sehen, wie sie aussieht. Da das Framework plattformübergreifend ist, können Sie es sowohl unter Windows als auch unter MacOS und Linux ausführen.

Bild
Gestartete Golang Mac OS-Anwendung

Bild
Und es sieht aus wie eine Golang Windows-Anwendung.

Als Ergebnis stellte sich heraus, dass eine einfache plattformübergreifende Golang-Desktop-Anwendung erstellt und Fyne in Aktion ausprobiert wurde. Leider ist go als geeignete Sprache für die Entwicklung moderner Desktop-Anwendungen kaum in Betracht zu ziehen. In der Praxis ist es jedoch immer interessant, etwas Neues und Ungewöhnliches zu berühren.

Vielen Dank für Ihre Aufmerksamkeit.

More articles:


All Articles