Cómo crear aplicaciones GUI en un escritorio Linux usando PyGObject - Parte 1


La creación de aplicaciones en Linux se puede hacer de diferentes maneras, pero hay formas limitadas de hacerlo, por lo que utilizando los lenguajes de programación y las bibliotecas más simples y funcionales, es por eso que vamos a echar un vistazo rápido a la creación de aplicaciones en Linux. escritorio usando la biblioteca GTK + con lenguaje de programación Python que se llama "PyGObject".

PyGObject usa GObject Introspection para crear enlaces para lenguajes de programación como Python, PyGObject es la próxima generación de PyGTK, puede decir que PyGObject u003d Python + GTK3.

Hoy, vamos a comenzar una serie sobre la creación de aplicaciones GUI (Interfaz gráfica de usuario) en el escritorio de Linux utilizando la biblioteca GTK + y el lenguaje PyGobject ; la serie cubrirá los siguientes temas:

En primer lugar, debe tener algunos conocimientos básicos en Python; Python es un lenguaje de programación muy moderno y fácil de usar. Es uno de los lenguajes de programación más famosos del mundo. Con Python, podrá crear muchas aplicaciones y herramientas excelentes. Puede tomar algunos cursos gratuitos como los de codeacademy.com o puede leer algunos libros sobre Python en:

GTK + es un conjunto de herramientas multiplataforma de código abierto para crear interfaces gráficas de usuario para aplicaciones de escritorio, se inició por primera vez en 1998 como un conjunto de herramientas GUI para GIMP, más tarde, se utilizó en muchas otras aplicaciones y pronto se convirtió en una de las bibliotecas más famosas para crear GUI. GTK + se lanza bajo la licencia LGPL.

Creación de aplicaciones GUI en Linux

Hay 2 formas de crear aplicaciones usando GTK + y Python:

  1. Escribir la interfaz gráfica utilizando solo código.
  2. Diseñar la interfaz gráfica usando el programa " Glade "; que es una herramienta RAD para diseñar interfaces GTK + fácilmente, Glade genera la GUI como un archivo XML que se puede usar con cualquier lenguaje de programación para construir la GUI, después de exportar el archivo XML de la GUI, podremos vincular el archivo XML con nuestro programa para hacer los trabajos que queremos.

Explicaremos ambas formas en breve.

Escribir la GUI usando solo código puede ser un poco difícil para los programadores novatos y una pérdida de tiempo, pero al usarla, podemos crear GUI muy funcionales para nuestros programas, más que las que creamos con algunas herramientas como Glade.

Tomemos el siguiente ejemplo.

#!/usr/bin/python
# -*- coding: utf-8 -*-

from gi.repository import Gtk

class ourwindow(Gtk.Window):

    def __init__(self):
        Gtk.Window.__init__(self, title="My Hello World Program")
        Gtk.Window.set_default_size(self, 400,325)
        Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER)

        button1 = Gtk.Button("Hello, World!")
        button1.connect("clicked", self.whenbutton1_clicked)

        self.add(button1)
        
    def whenbutton1_clicked(self, button):
      print "Hello, World!"

window = ourwindow()        
window.connect("delete-event", Gtk.main_quit)
window.show_all()
Gtk.main()

Copie el código anterior, péguelo en un archivo “ test.py ” y establezca el permiso 755 en el archivo test.py y ejecute el archivo más tarde usando “ ./test.py ”, Eso es lo que obtendrá.

# nano test.py
# chmod 755 test.py
# ./test.py

Al hacer clic en el botón, verá la frase " ¡Hola, mundo! " impresa en la terminal:

Déjame explicarte el código en una explicación detallada.

  1. #!/usr/bin/python : la ruta predeterminada para el intérprete de Python (versión 2.7 en la mayoría de los casos), esta línea debe ser la primera línea en cada archivo de Python.
  2. # - * - codificación: utf-8 - * - : Aquí configuramos la codificación predeterminada para el archivo, UTF-8 es la mejor si desea admitir idiomas que no sean el inglés, deje así.
  3. de gi.repository import Gtk : Aquí estamos importando la biblioteca GTK 3 para usarla en nuestro programa.
  4. Class ourwindow (Gtk.Window): Aquí estamos creando una nueva clase, que se llama "ourwindow", también estamos configurando el tipo de objeto de clase en "Gtk.Window".
  5. def __init __ (self) : Nada nuevo, aquí definimos los componentes de la ventana principal.
  6. Gtk.Window .__ init __ (self, title u003d "My Hello World Program") : Estamos usando esta línea para establecer el título "My Hello World Program" en la ventana "ourwindow", puede cambiar el título si lo desea.
  7. Gtk.Window.set_default_size (self, 400,325) : No creo que esta línea necesite explicación, aquí estamos configurando el ancho y alto predeterminados para nuestra ventana.
  8. Gtk.Window.set_position (self, Gtk.WindowPosition.CENTER) : Usando esta línea, podremos establecer la posición predeterminada para la ventana, en este caso, la configuramos al centro usando el parámetro "Gtk.WindowPosition.CENTER", si lo desea, puede cambiarlo a "Gtk.WindowPosition.MOUSE" para abrir la ventana en la posición del puntero del mouse.
  9. button1 u003d Gtk.Button ("Hello, World!") : Creamos un nuevo Gtk.Button, y lo llamamos "button1", el texto predeterminado para el botón es "Hello, World! ”, Puede crear cualquier widget Gtk si lo desea.
  10. button1.connect ("clicked", self.whenbutton1_clicked) : aquí estamos vinculando la señal "clicked" con la acción "whenbutton1_clicked", de modo que cuando se hace clic en el botón, el " la acción whenbutton1_clicked ”está activada.
  11. self.add (button1) : Si queremos que aparezcan nuestros widgets Gtk, tenemos que agregarlos a la ventana predeterminada, esta línea simple agrega el widget "button1" a la ventana, es muy necesario para hacer esto.
  12. def whenbutton1_clicked (self, button) : Ahora estamos definiendo la acción "whenbutton1_clicked" aquí, estamos definiendo lo que sucederá cuando se haga clic en el widget "button1", el "( self, button) ”es importante para especificar el tipo de objeto principal de la señal.
  13. imprima "¡Hola, mundo!" : No es necesario que explique más aquí.
  14. window u003d ourwindow() : Tenemos que crear una nueva variable global y configurarla en la clase ourwindow() para poder llamarla más tarde usando la biblioteca GTK +.
  15. window.connect ("delete-event", Gtk.main_quit) : ahora estamos conectando la señal "delete-event" con la acción "Gtk.main_quit", esto es importante en para eliminar todos los widgets después de cerrar la ventana del programa automáticamente.
  16. window.show_all() : muestra la ventana.
  17. Gtk.main() : Ejecutando la biblioteca Gtk.

Eso es todo, ¿no es fácil? Y muy funcional si queremos crear algunas aplicaciones de gran tamaño. Para obtener más información sobre cómo crear interfaces GTK + utilizando la forma de solo código, puede visitar el sitio web de documentación oficial en:

Tutoriales de Python GTK3

Como dije al principio del artículo, Glade es una herramienta muy fácil para crear las interfaces que necesitamos para nuestros programas, es muy famosa entre los desarrolladores y se crearon muchas interfaces de aplicaciones geniales con ella. Esta forma se denomina "Desarrollo rápido de aplicaciones".

Debe instalar Glade para comenzar a usarlo, en Debian/Ubuntu/Mint ejecute:

$ sudo apt­-get install glade

En RedHat/Fedora/CentOS, ejecute:

# yum install glade

Después de descargar e instalar el programa, y después de ejecutarlo, verá los widgets Gtk disponibles a la izquierda, haga clic en el widget " ventana " para crear una nueva ventana.

Notará que se crea una nueva ventana vacía.

Ahora puede agregarle algunos widgets, en la barra de herramientas de la izquierda, haga clic en el widget " botón " y haga clic en la ventana vacía para agregar el botón a la ventana.

Notará que el ID del botón es " button1 ", ahora consulte la pestaña Señales en la barra de herramientas derecha, busque la señal " clic en " e ingrese " button1_clicked ”debajo de él.

Ahora que hemos creado nuestra GUI, exportémosla. Haga clic en el menú " Archivo " y seleccione " Guardar ", guarde el archivo en su directorio de inicio con el nombre " myprogram.glade " y Salida.

Ahora, cree un nuevo archivo “ test.py ” e ingrese el siguiente código dentro de él.

#!/usr/bin/python
# -*- coding: utf-8 -*-

from gi.repository import Gtk

class Handler:
    def button_1clicked(self, button):
      print "Hello, World!"

builder = Gtk.Builder()
builder.add_from_file("myprogram.glade")
builder.connect_signals(Handler())

ournewbutton = builder.get_object("button1")
ournewbutton.set_label("Hello, World!")

window = builder.get_object("window1")

window.connect("delete-event", Gtk.main_quit)
window.show_all()
Gtk.main()

Guarde el archivo, dele 755 permisos como antes y ejecútelo usando " ./test.py ", y eso es lo que obtendrá.

# nano test.py
# chmod 755 test.py
# ./test.py

Haga clic en el botón y verá que la frase " ¡Hola, mundo! " está impresa en la terminal.

Ahora expliquemos las cosas nuevas:

  1. Class Handler : Aquí estamos creando una clase llamada "Handler" que incluirá las definiciones de las acciones y señales que creamos para la GUI.
  2. constructor u003d Gtk.Builder() : Creamos una nueva variable global llamada "constructor" que es un widget Gtk.Builder, esto es importante para importar el archivo .glade.
  3. builder.add_from_file ("myprogram.glade") : aquí estamos importando el archivo "myprogram.glade" para usarlo como una GUI predeterminada para nuestro programa.
  4. builder.connect_signals (Handler()) : esta línea conecta el archivo .glade con la clase del controlador, de modo que las acciones y señales que definimos en la clase "Handler" funcionan bien cuando ejecutar el programa.
  5. ournewbutton u003d builder.get_object ("button1") : Ahora estamos importando el objeto "button1" del archivo .glade, también lo estamos pasando a la variable global "ournewbutton" para usarlo más adelante en nuestro programa.
  6. ournewbutton.set_label ("¡Hola, mundo!") : Usamos el método "set.label" para establecer el texto del botón predeterminado en "¡Hola, mundo!" sentencia.
  7. window u003d builder.get_object ("window1") : Aquí llamamos al objeto "window1" del archivo .glade para mostrarlo más tarde en el programa.

¡Y eso es! ¡Ha creado con éxito su primer programa en Linux!

Por supuesto, hay cosas mucho más complicadas que hacer para crear una aplicación real que haga algo, por eso te recomiendo que eches un vistazo a la documentación de GTK + y la API de GObject en:

  1. GTK + Manual de referencia
  2. Referencia de la API de Python GObject
  3. Referencia de PyGObject

¿Ha desarrollado alguna aplicación antes en el escritorio de Linux? ¿Qué lenguaje de programación y qué herramientas han utilizado para hacerlo? ¿Qué opinas sobre la creación de aplicaciones con Python y GTK 3?