Get best of the week

Crear una aplicación de escritorio usando Golang y Fyne

Hoy desarrollaremos una aplicación de escritorio en Golang


Desarrollar una aplicación de escritorio golang no es una tarea típica para un programador de golang. No hay tantas bibliotecas de código abierto listas para que Google lo resuelva a pedido del escritorio de Golang, ejemplos de lo que se encontraron:

  1. gotk
  2. Fyne
  3. Gxui

Se eligió a Fyne, ya que el repositorio github de este proyecto contiene la mayor cantidad de estrellas, y también es compatible con el notorio diseño de Material.

Veamos qué opciones para mostrar la interfaz que nos proporciona.

Los siguientes widgets están disponibles en el cuadro:

  • Botón.
  • Un contenedor (para agrupar widgets secundarios y dirigirlos horizontal o verticalmente).
  • Casilla de verificación, campos para ingresar texto o contraseña.
  • Formas y grupos.
  • Hipervínculo.
  • El icono.
  • La etiqueta.
  • Barra de progreso.
  • Un contenedor desplazable.
  • Cambiar.
  • Seleccione
  • Pestañas.
  • Barra de herramientas.

En el caso de que entre los elementos de la interfaz no se encuentre lo necesario, es posible implementar widgets personalizados utilizando una API simple.

Intentemos escribir una aplicación golang gui para mostrar pronósticos del tiempo para los próximos días usando Fyne. El código completo de la aplicación se puede encontrar en el enlace en github.

En primer lugar, cree un proyecto vacío en Golang e instale Fyne.

go get fyne.io/fyne

Dado que la aplicación mostrará información sobre el clima, debe obtener esta información. Para hacer esto, recurra a la API de 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)
}

Para almacenar datos, puede usar la siguiente estructura (en ella dejé solo algunos de los campos que devuelve la API), vale la pena prestar atención al hecho de que todos los campos de la estructura están en mayúscula, pero en la respuesta de la API se describen con uno pequeño.

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

Ahora podemos recibir datos meteorológicos en forma de estructura. Queda por implementar la interfaz de la aplicación de escritorio 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() //   
}

Aquí creamos nuestros widgets, los llenamos con datos y los recopilamos en grupos para organizar el orden en que se muestran.

Hecho.

Solo queda ejecutar la aplicación y ver cómo se ve. Dado que el marco es multiplataforma, puede ejecutarlo tanto en Windows como en macOS y Linux.

imagen
Lanzó la aplicación golang mac os

imagen
Y parece una aplicación golang windows

Como resultado, resultó crear una aplicación de escritorio golang multiplataforma simple, y probar Fyne en acción. Desafortunadamente, vale la pena considerar ir como un lenguaje adecuado para desarrollar aplicaciones de escritorio modernas, sin embargo, siempre es interesante tocar algo nuevo e inusual en la práctica.

Gracias a todos por su atención.

More articles:


All Articles