Com crear aplicacions GUI a l'escriptori Linux utilitzant PyGObject - Part 1

La creació d'aplicacions a Linux es pot fer de diferents maneres, però hi ha maneres limitades de fer-ho, de manera que utilitzant els llenguatges i biblioteques de programació més senzills i funcionals, per això farem una ullada ràpida a la creació d'aplicacions sota Linux. escriptori utilitzant la biblioteca GTK+ amb llenguatge de programació Python que s'anomena \PyGObject.

PyGObject utilitza GObject Introspection per crear enllaços per a llenguatges de programació com Python, PyGObject és la propera generació de PyGTK, es pot dir que PyGObject = Python + GTK3.

Avui començarem una sèrie sobre la creació d'aplicacions GUI (Interfície gràfica d'usuari) a l'escriptori Linux mitjançant la biblioteca GTK+ i el llenguatge PyGobject, la sèrie tractarà els temes següents:

En primer lloc, heu de tenir uns coneixements bàsics en Python; Python és un llenguatge de programació molt modern i fàcil d'utilitzar. És un dels llenguatges de programació més famosos del món, amb Python, podreu crear moltes aplicacions i eines fantàstiques. Podeu fer alguns cursos gratuïts com els de codeacademy.com o podeu llegir alguns llibres sobre Python a:

GTK+ és un conjunt d'eines multiplataforma de codi obert per crear interfícies gràfiques d'usuari per a aplicacions d'escriptori, es va iniciar per primera vegada l'any 1998 com un conjunt d'eines GUI per al GIMP, més tard, es va utilitzar en moltes altres aplicacions i aviat es va convertir en una de les biblioteques més famoses per crear GUI. GTK+ es publica sota la llicència LGPL.

Creació d'aplicacions GUI sota Linux

Hi ha dues maneres de crear les aplicacions amb GTK+ i Python:

Escriure la interfície gràfica només amb codi.
Dissenyant la interfície gràfica mitjançant el programa \Glade, que és una eina RAD per dissenyar interfícies GTK+ fàcilment, Glade genera la GUI com un fitxer XML que es pot utilitzar amb qualsevol llenguatge de programació per crear la GUI, després d'exportar el fitxer XML de la GUI, podrem enllaçar el fitxer XML amb el nostre programa per fer els treballs que vulguem.

Explicarem les dues maneres en breu.

Escriure la GUI només amb codi pot ser una mica difícil per als programadors noob i perdre molt de temps, però utilitzant-la, podem crear GUI molt funcionals per als nostres programes, més que les que creem amb algunes eines com Glade.

Prenguem l'exemple següent.

#!/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()

Copieu el codi anterior, enganxeu-lo en un fitxer \test.py i configureu el permís 755 al fitxer test.py i executeu el fitxer més tard amb \./test.py”, això és el que obtindreu.

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

En fer clic al botó, veuràs la frase \Hola, món! impresa al terminal:

Permeteu-me explicar el codi amb una explicació detallada.

#!/usr/bin/python: el camí predeterminat per a l'intèrpret de Python (versió 2.7 en la majoria dels casos), aquesta línia ha de ser la primera línia de cada fitxer de Python.
# -*- codificació: utf-8 -*-: aquí establim la codificació predeterminada per al fitxer, UTF-8 és el millor si voleu suportar idiomes que no siguin anglesos, deixeu és així.
des de gi.repository import Gtk: aquí estem important la biblioteca GTK 3 per utilitzar-la al nostre programa.
Class ourwindow(Gtk.Window): aquí estem creant una nova classe, que s'anomena \ourwindow, també estem establint el tipus d'objecte de classe a \Gtk.Window.
def __init__(self): res de nou, aquí estem definint els components de la finestra principal.
Gtk.Window.__init__(self, title=”El meu programa Hello World”): estem utilitzant aquesta línia per establir el títol del \El meu programa Hello World a \la nostra finestra finestra, podeu canviar el títol si voleu.
Gtk.Window.set_default_size(self, 400.325): no crec que aquesta línia necessiti explicació, aquí estem establint l'amplada i l'alçada per defecte per a la nostra finestra.
Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER): amb aquesta línia, podrem establir la posició per defecte de la finestra, en aquest cas, l'establirem al centre mitjançant el paràmetre \Gtk.WindowPosition.CENTER, si voleu, podeu canviar-lo a \Gtk.WindowPosition.MOUSE per obrir la finestra a la posició del punter del ratolí.
button1 = Gtk.Button(“Hola, món!”): hem creat un Gtk.Button nou i l'hem anomenat \button1, el text predeterminat del botó és\Hola, món!”, podeu crear qualsevol giny de Gtk si voleu.
button1.connect(clic, self.whenbutton1_clicked): aquí estem enllaçant el senyal \clic amb l'acció \whenbutton1_clicked, de manera que quan es faci clic al botó, s'activa l'acció \whenbutton1_clicked.
self.add(button1): si volem que apareguin els nostres ginys Gtk, els hem d'afegir a la finestra per defecte, aquesta senzilla línia afegeix el giny \button1” a la finestra, és molt necessari fer-ho.
def whenbutton1_clicked(self, button): ara estem definint l'acció \whenbutton1_clicked, definirem què passarà quan es faci clic al giny \button1, el El paràmetre \(self, button)” és important per especificar el tipus d'objecte principal del senyal.
imprimir Hola, món!: no cal que ens expliqui més aquí.
window = ourwindow(): hem de crear una nova variable global i establir-la a la nostra classe window() perquè puguem cridar-la més tard mitjançant la biblioteca GTK+.
window.connect(“delete-event”, Gtk.main_quit): ara estem connectant el senyal \delete-event” amb l'acció \Gtk.main_quit, això és important per eliminar tots els ginys després de tancar automàticament la finestra del nostre programa.
window.show_all(): mostra la finestra.
Gtk.main(): executant la biblioteca Gtk.

Això és, fàcil no? I molt funcional si volem crear algunes aplicacions grans. Per obtenir més informació sobre com crear interfícies GTK+ utilitzant només codi, podeu visitar el lloc web de documentació oficial a:

Tutorials de Python GTK3

Com he dit al principi de l'article, Glade és una eina molt fàcil per crear les interfícies que necessitem per als nostres programes, és molt famós entre els desenvolupadors i es van crear moltes interfícies d'aplicacions fantàstiques utilitzant-la. Aquesta manera s'anomena \Desenvolupament ràpid d'aplicacions.

Heu d'instal·lar Glade per començar a utilitzar-lo, a Debian/Ubuntu/Mint executeu:

$ sudo apt-get install glade

A RedHat/Fedora/CentOS, executeu:

# yum install glade

Després de descarregar i instal·lar el programa, i després d'executar-lo, veureu els ginys de Gtk disponibles a l'esquerra, feu clic al giny \finestra per crear una nova finestra.

Notareu que es crea una nova finestra buida.

Ara podeu afegir-hi alguns widgets, a la barra d'eines de l'esquerra, feu clic al giny \botó i feu clic a la finestra buida per afegir el botó a la finestra.

Notareu que l'identificador del botó és \button1, ara consulteu la pestanya Senyals a la barra d'eines de la dreta i cerqueu el senyal \clic i introduïu\button1_clicked a sota.

Ara que hem creat la nostra GUI, exportem-la. Feu clic al menú \Fitxer i trieu \Desa, deseu el fitxer al vostre directori d'inici amb el nom \myprogram.glade” i surt.

Ara, creeu un fitxer \test.py nou i introduïu-hi el codi següent.

#!/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()

Deseu el fitxer, doneu-li 755 permisos com abans i executeu-lo amb \./test.py, i això és el que obtindreu.

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

Feu clic al botó i notareu que la frase \Hola, món!” està impresa al terminal.

Ara anem a explicar les coses noves:

Manejador de classes: aquí estem creant una classe anomenada \Manejador que inclourà les definicions de les accions i senyals que creem per a la GUI.
builder = Gtk.Builder(): hem creat una nova variable global anomenada \builder que és un giny de Gtk.Builder, això és important per importar el fitxer .glade.< /li>
builder.add_from_file(“myprogram.glade”): aquí estem important el fitxer \myprogram.glade” per utilitzar-lo com a GUI predeterminat per al nostre programa.
builder.connect_signals(Handler()): aquesta línia connecta el fitxer .glade amb la classe de controlador, de manera que les accions i senyals que definim a la classe \Handler funcionen bé quan executem el programa.
ournewbutton = builder.get_object(“button1”): ara estem important l'objecte \button1” del fitxer .glade, també l'estem passant a la variable global\ournewbutton” per utilitzar-lo més endavant al nostre programa.
ournewbutton.set_label(Hola, món!): hem utilitzat el mètode \set.label per establir el text del botó predeterminat a \Hola, món! sentència.
window = builder.get_object(“window1”): aquí hem anomenat l'objecte \window1” des del fitxer .glade per mostrar-lo més endavant al programa.

I ja està! Heu creat amb èxit el vostre primer programa amb Linux!

Per descomptat, hi ha coses molt més complicades a fer per crear una aplicació real que faci alguna cosa, per això us recomano que feu una ullada a la documentació de GTK+ i a l'API de GObject a:

Manual de referència de GTK+
Referència de l'API de Python GObject
Referència de PyGObject

Heu desenvolupat alguna aplicació abans a l'escriptori Linux? Quin llenguatge de programació i eines han utilitzat per fer-ho? Què en penseu de crear aplicacions amb Python i GTK 3?