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 sobre cómo crear aplicaciones bajo Linux escritorio usando la biblioteca GTK + con el 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, se 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:

Primero que nada, debes 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. Writing the graphical interface using code only.
  2. Designing the graphical interface using the “Glade” program; which is RAD tool to design GTK+ interfaces easily, Glade generates the GUI as a XML file which can be used with any programming language to build the GUI, after exporting the GUI’s XML file, we’ll be able to link the XML file with our program to do the jobs we want.

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 con una explicación detallada.

  1. #!/usr/bin/python: The default path for the Python interpreter (version 2.7 in most cases), this line must be the first line in every Python file.
  2. # -*- coding: utf-8 -*-: Here we set the default coding for the file, UTF-8 is the best if you want to support non-English languages, leave it like that.
  3. from gi.repository import Gtk: Here we are importing the GTK 3 library to use it in our program.
  4. Class ourwindow(Gtk.Window): Here we are creating a new class, which is called “ourwindow”, we are also setting the class object type to a “Gtk.Window”.
  5. def __init__(self): Nothing new, we’re defining the main window components here.
  6. Gtk.Window.__init__(self, title=”My Hello World Program”): We’re using this line to set the “My Hello World Program” title to “ourwindow” window, you may change the title if you like.
  7. Gtk.Window.set_default_size(self, 400,325): I don’t think that this line need explanation, here we’re setting the default width and height for our window.
  8. Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER): Using this line, we’ll be able to set the default position for the window, in this case, we set it to the center using the “Gtk.WindowPosition.CENTER” parameter, if you want, you can change it to “Gtk.WindowPosition.MOUSE” to open the window on the mouse pointer position.
  9. button1 = Gtk.Button(“Hello, World!”): We created a new Gtk.Button, and we called it “button1”, the default text for the button is “Hello, World!”, you may create any Gtk widget if you want.
  10. button1.connect(“clicked”, self.whenbutton1_clicked): Here we’re linking the “clicked” signal with the “whenbutton1_clicked” action, so that when the button is clicked, the “whenbutton1_clicked” action is activated.
  11. self.add(button1): If we want our Gtk widgets to appear, we have to add them to the default window, this simple line adds the “button1” widget to the window, it’s very necessary to do this.
  12. def whenbutton1_clicked(self, button): Now we’re defining the “whenbutton1_clicked” action here, we’re defining what’s going to happen when the “button1” widget is clicked, the “(self, button)” parameter is important in order to specific the signal parent object type.
  13. print “Hello, World!”: I don’t have to explain more here.
  14. window = ourwindow(): We have to create a new global variable and set it to ourwindow() class so that we can call it later using the GTK+ library.
  15. window.connect(“delete-event”, Gtk.main_quit): Now we’re connecting the “delete-event” signal with the “Gtk.main_quit” action, this is important in order to delete all the widgets after we close our program window automatically.
  16. window.show_all(): Showing the window.
  17. Gtk.main(): Running the Gtk library.

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 u200bu200bdespués de ejecutarlo, verá los widgets Gtk disponibles a la izquierda, haga clic en el widget " ventana " para crear una nueva ventana.

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

Ahora puede agregarle algunos widgets, en la barra de herramientas 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 de la derecha, busque la señal " haga clic " 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: Here we’re creating a class called “Handler” which will include the the definitions for the actions & signals, we create for the GUI.
  2. builder = Gtk.Builder(): We created a new global variable called “builder” which is a Gtk.Builder widget, this is important in order to import the .glade file.
  3. builder.add_from_file(“myprogram.glade”): Here we’re importing the “myprogram.glade” file to use it as a default GUI for our program.
  4. builder.connect_signals(Handler()): This line connects the .glade file with the handler class, so that the actions and signals that we define under the “Handler” class work fine when we run the program.
  5. ournewbutton = builder.get_object(“button1”): Now we’re importing the “button1” object from the .glade file, we’re also passing it to the global variable “ournewbutton” to use it later in our program.
  6. ournewbutton.set_label(“Hello, World!”): We used the “set.label” method to set the default button text to the “Hello, World!” sentence.
  7. window = builder.get_object(“window1”): Here we called the “window1” object from the .glade file in order to show it later in the program.

¡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+ Reference Manual
  2. Python GObject API Reference
  3. PyGObject Reference

¿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?