Golang GUI: GTK + 3

Decidí escribir una aplicación de escritorio multiplataforma en Go . Hecho una versión CLI , todo funciona bien. Sí, y se admite la compilación cruzada en Go . Todo está bien en general. Pero también se necesitaba una versión GUI . Y entonces comenzó ...

La elección de la biblioteca (enlace) para la GUI

Se suponía que la aplicación era multiplataforma.
Por lo tanto, debe compilarse bajo Windows , GNU / Linux y macOS .
La elección recayó en tales bibliotecas:

• gotk3 (GTK + 3)
• receta / qt (Qt)
• zserge / webview (vista web nativa)

Devolví Electron y otros frameworks que arrastran a Chromium y node.js con ellos, porque pesan bastante y también consumen muchos recursos del sistema operativo.

Ahora un poco sobre cada biblioteca.

gotk3

Biblioteca GTK + 3 vinculante . La cobertura está lejos de todas las posibilidades, pero todos los elementos esenciales están presentes.

La aplicación se compila utilizando la go build estándar go build . La compilación multiplataforma es posible, con la excepción de macOS . Solo con macOS se puede compilar para este sistema operativo, bueno, con macOS también se puede compilar para Windows + GNU / Linux .

La interfaz se verá nativa de GNU / Linux , Windows (deberá especificar un tema especial). Para macOS no se verá nativo. Solo puede salir a menos que sea un tema terrible que emulará los elementos nativos de macOS .

receta / qt

Biblioteca de enlace Qt 5 . Soporte para QML, widgets estándar. En general, muchas personas aconsejan este enlace.

qtdeploy usando el qtdeploy especial qtdeploy . Además de las plataformas de escritorio, también hay plataformas móviles. La compilación cruzada se realiza con Docker . Para los sistemas operativos, Apple solo se puede compilar con macOS .

Si lo desea, en Qt, puede hacer que la interfaz parezca nativa en el sistema operativo de escritorio.

zserge / webview

La biblioteca, que originalmente estaba escrita en C , el autor la atornilló a muchos idiomas, incluido Go . La vista web nativa se usa para mostrar: Windows - MSHTML , GNU / Linux - gtk-webkit2 , macOS - Cocoa / WebKit . Además del código en Go, también necesitará escribir en JS , y HTML será útil.

Se compila con go build , la compilación cruzada es posible con xgo .

Puede parecer nativo tanto como lo permite un navegador estándar.

La eleccion

¿Por qué elegí gotk3 ?

En therecipe / qt, no me gustó el sistema demasiado complicado para compilar la aplicación, incluso hicieron un comando especial.

zserge / webview parece no estar mal, no pesará mucho, pero aún así es webview y puede haber problemas estándar que existen en tales aplicaciones: tal vez un lugar para ir a algún lado. Y esto no es Electron , donde siempre se incluye el Chromium avanzado, pero en algunos Windows antiguos todo puede funcionar. Y además, también tienes que escribir en JS .

Elegí gotk3 como algo promedio. Puedes compilarlo con el estándar go build , parece aceptable, ¡y de hecho me encanta GTK + 3 !

En general, pensé que todo sería simple. Y en vano sobre Go , dicen que tiene un problema con la GUI . Pero qué equivocado estaba ...

Empezando

Instale todo, desde gotk3 ( gtk , gdk , glib , cairo ) a nosotros mismos:

 go get github.com/gotk3/gotk3/... 

Además, la biblioteca GTK + 3 en sí misma debe estar instalada en su sistema para el desarrollo.

GNU / Linux

En Ubuntu :

 sudo apt-get install libgtk-3-dev 

En Arch Linux :

 sudo pacman -S gtk3 

macOS

Vía Homebrew :

  brew install gtk-mac-integration gtk+3 

Ventanas

No es tan simple aquí. Las instrucciones oficiales sugieren usar MSYS2 y hacer todo lo que ya está en él. Personalmente, escribí código en otros sistemas operativos e hice una compilación cruzada para Windows en Arch Linux , que espero escriba pronto.

Ejemplo simple

Ahora escribimos un pequeño archivo con el código main.go :

 package main import ( "log" "github.com/gotk3/gotk3/gtk" ) func main() { //  GTK. gtk.Init(nil) //    ,   //     "destroy"     //     win, err := gtk.WindowNew(gtk.WINDOW_TOPLEVEL) if err != nil { log.Fatal("   :", err) } win.SetTitle(" ") win.Connect("destroy", func() { gtk.MainQuit() }) //         l, err := gtk.LabelNew(", gotk3!") if err != nil { log.Fatal("   :", err) } //     win.Add(l) //      win.SetDefaultSize(800, 600) //      win.ShowAll() //    GTK ( ).    //  gtk.MainQuit() gtk.Main() } 

Puede compilar usando el go build y luego ejecutar el binario. Pero solo lo ejecutamos:

 go run main.go 

Después de comenzar, obtenemos una ventana de este tipo:

Felicidades ¡Tienes una aplicación simple de README gotk3 !

Se pueden encontrar más ejemplos en Github gotk3 . No los desmontaré. ¡Mejor hagamos algo que no está en los ejemplos!

Claro

Hay tal cosa para Gtk + 3 - Glade . Este es un diseñador gráfico para GTK + . Se parece a esto:

Para no crear manualmente cada elemento y no colocarlo más tarde en algún lugar de la ventana usando el código del programa, puede lanzar todo el diseño en Glade . Luego guarde todo en un archivo * .glade similar a XML y cárguelo a través de nuestra aplicación.

Instalar Glade

GNU / Linux

En distribuciones GNU / Linux, instalar glade es fácil. En algunos Ubuntu, será:

 sudo apt-get install glade 

En Arch Linux :

 sudo pacman -S glade 

macOS

Las descargas del sitio oficial son muy antiguas. Por lo tanto, es mejor instalar a través de Homebrew :

 brew install glade 

Y luego corre:

 glade 

Ventanas

Puede descargar la última versión aquí . Personalmente no lo instalé en Windows en absoluto, por lo que no sé sobre la estabilidad de Glade allí.

Aplicación simple usando Glade

En general, diseñé algo como esta ventana:

Guardado y recibido el archivo main.glade :

 <?xml version="1.0" encoding="UTF-8"?> <!-- Generated with glade 3.22.1 --> <interface> <requires lib="gtk+" version="3.20"/> <object class="GtkWindow" id="window_main"> <property name="title" translatable="yes"> Glade</property> <property name="can_focus">False</property> <child> <placeholder/> </child> <child> <object class="GtkBox"> <property name="visible">True</property> <property name="can_focus">False</property> <property name="margin_left">10</property> <property name="margin_right">10</property> <property name="margin_top">10</property> <property name="margin_bottom">10</property> <property name="orientation">vertical</property> <property name="spacing">10</property> <child> <object class="GtkEntry" id="entry_1"> <property name="visible">True</property> <property name="can_focus">True</property> </object> <packing> <property name="expand">False</property> <property name="fill">True</property> <property name="position">0</property> </packing> </child> <child> <object class="GtkButton" id="button_1"> <property name="label" translatable="yes">Go</property> <property name="visible">True</property> <property name="can_focus">True</property> <property name="receives_default">True</property> </object> <packing> <property name="expand">False</property> <property name="fill">True</property> <property name="position">1</property> </packing> </child> <child> <object class="GtkLabel" id="label_1"> <property name="visible">True</property> <property name="can_focus">False</property> <property name="label" translatable="yes">This is label</property> </object> <packing> <property name="expand">False</property> <property name="fill">True</property> <property name="position">2</property> </packing> </child> </object> </child> </object> </interface> 

Es decir, tenemos la ventana window_main ( GtkWindow ), en la que dentro del contenedor ( GtkBox ), que contiene el campo de entrada entry_1 ( GtkEntry ), button_1 ( GtkButton ) y label_1 ( GtkLabel ). Además, también hay atributos de errores (configuré un poco), visibilidad y otros atributos que Glade agregó automáticamente.

Ahora intentemos cargar esta vista en nuestro main.go :

 package main import ( "log" "github.com/gotk3/gotk3/gtk" ) func main() { //  GTK. gtk.Init(nil) //   b, err := gtk.BuilderNew() if err != nil { log.Fatal(":", err) } //       Glade err = b.AddFromFile("main.glade") if err != nil { log.Fatal(":", err) } //      ID obj, err := b.GetObject("window_main") if err != nil { log.Fatal(":", err) } //       gtk.Window //     "destroy"     //     win := obj.(*gtk.Window) win.Connect("destroy", func() { gtk.MainQuit() }) //      win.ShowAll() //    GTK ( ).    //  gtk.MainQuit() gtk.Main() } 

Corre de nuevo:

 go run main.go 

Y obtenemos:

¡Hurra! Ahora guardamos el envío del formulario en un archivo main.glade XML , y el código en main.go !

Señales

La ventana se inicia, pero agreguemos interactividad. Deje que el texto del campo de entrada cuando haga clic en el botón entre en la etiqueta.

Para hacer esto, primero obtenemos los elementos del campo de entrada, botón y etiqueta en el código:

 //    obj, _ = b.GetObject("entry_1") entry1 := obj.(*gtk.Entry) //   obj, _ = b.GetObject("button_1") button1 := obj.(*gtk.Button) //   obj, _ = b.GetObject("label_1") label1 := obj.(*gtk.Label) 

No manejo los errores que devuelve la función GetObject() para simplificar el código. Pero en una aplicación real de trabajo, deben ser procesados.

Bueno Usando el código anterior, obtenemos nuestros elementos de formulario. Ahora manejemos la señal del botón presionado (cuando se presiona el botón). La señal GTK + es esencialmente una reacción al evento. Agrega el código:

 //      button1.Connect("clicked", func() { text, err := entry1.GetText() if err == nil { //       label1.SetText(text) } }) 

Ahora ejecuta el código:

 go run main.go 

Después de ingresar un texto en el campo y hacer clic en el botón Ir , veremos este texto en la etiqueta:

Ahora tenemos una aplicación interactiva!

Conclusión

En esta etapa, todo parece simple y no difícil. Pero tuve dificultades con la compilación cruzada (porque gotk3 se compila con CGO ), la integración con los sistemas operativos y con el diálogo de selección de archivos. Incluso agregué un diálogo nativo al proyecto gotk . Además, mi proyecto necesitaba internacionalización. También hay algunas características. Si está interesado en ver todo esto ahora en el código, puede echar un vistazo aquí .

Los códigos fuente para ejemplos del artículo están aquí .

Y si quieres leer la secuela, puedes votar. Y en caso de que resulte interesante para alguien, continuaré escribiendo.