Ricerca nel sito web

Come creare applicazioni GUI sul desktop Linux utilizzando PyGObject - Parte 1


La creazione di applicazioni su Linux può essere eseguita in diversi modi, ma ci sono modi limitati, quindi utilizzando i linguaggi di programmazione e le librerie più semplici e funzionali, ecco perché daremo una rapida occhiata alla creazione di applicazioni sotto Linux. desktop utilizzando la libreria GTK+ con linguaggio di programmazione Python chiamato “PyGObject”.

PyGObject utilizza GObject Introspection per creare collegamenti per linguaggi di programmazione come Python, PyGObject è la generazione successiva di PyGTK, si può dire che PyGObject=Python + GTK3.

Oggi inizieremo una serie sulla creazione di applicazioni GUI (Graphical User Interface) sotto il desktop Linux utilizzando la libreria GTK+ e il linguaggio PyGobject, la serie tratterà i seguenti argomenti:

A proposito di Python

Innanzitutto è necessario avere alcune conoscenze base di Python; Python è un linguaggio di programmazione molto moderno e facile da usare. È uno dei linguaggi di programmazione più famosi al mondo, utilizzando Python sarai in grado di creare molte fantastiche applicazioni e strumenti. Puoi seguire alcuni corsi gratuiti come quelli su codeacademy.com oppure leggere alcuni libri su Python su:

Informazioni su GTK+

GTK+ è un toolkit multipiattaforma open source per creare interfacce utente grafiche per applicazioni desktop. È stato avviato per la prima volta nel 1998 come toolkit GUI per GIMP, successivamente è stato utilizzato in molte altre applicazioni e divenne presto una delle librerie più famose per creare GUI. GTK+ è rilasciato sotto la licenza LGPL.

Creazione di applicazioni GUI sotto Linux

Esistono 2 modi per creare applicazioni utilizzando GTK+ e Python:

  1. Scrivere l'interfaccia grafica utilizzando solo il codice.
  2. Progettazione dell'interfaccia grafica utilizzando il programma “Glade ”; che è uno strumento RAD per progettare facilmente le interfacce GTK+, Glade genera la GUI come file XML che può essere utilizzato con qualsiasi linguaggio di programmazione per costruire la GUI, dopo aver esportato il file XML della GUI, saremo in grado di collegare il file XML con il nostro programma per svolgere i lavori che desideriamo.

Spiegheremo entrambi i modi in breve.

Il metodo solo codice

Scrivere la GUI utilizzando solo il codice può essere un po' difficile per un programmatore principiante e può far perdere molto tempo, ma usandolo, possiamo creare GUI molto funzionali per i nostri programmi, più di quelle che creiamo utilizzando alcuni strumenti come Glade.

Prendiamo il seguente esempio.

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

Copia il codice sopra, incollalo in un file “test.py” e imposta l'autorizzazione 755 sul file test.py ed esegui il file in seguito utilizzando “./test.py ", ecco cosa otterrai.

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

Facendo clic sul pulsante, viene visualizzata la frase "Hello, World!" stampata nel terminale:

Lasciami spiegare il codice in una spiegazione dettagliata.

  1. #!/usr/bin/python: il percorso predefinito per l'interprete Python (versione 2.7 nella maggior parte dei casi), questa riga deve essere la prima riga in ogni file Python.
  2. # -*- coding: utf-8 -*-: qui impostiamo la codifica predefinita per il file, UTF-8 è la migliore se vuoi supportare lingue diverse dall'inglese, lascialo così .
  3. from gi.repository import Gtk: qui stiamo importando la libreria GTK 3 per usarla nel nostro programma.
  4. Classe ourwindow(Gtk.Window): qui stiamo creando una nuova classe, che si chiama “ourwindow”, stiamo anche impostando il tipo di oggetto della classe su “Gtk.Window”.
  5. def __init__(self): Niente di nuovo, qui definiamo i componenti della finestra principale.
  6. Gtk.Window.__init__(self, title=”My Hello World Program”): stiamo utilizzando questa riga per impostare il titolo “My Hello World Program” sulla finestra “ourwindow”, puoi cambiarlo il titolo se preferisci.
  7. Gtk.Window.set_default_size(self, 400,325): non penso che questa riga abbia bisogno di spiegazioni, qui stiamo impostando la larghezza e l'altezza predefinite per la nostra finestra.
  8. Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER): Usando questa riga, saremo in grado di impostare la posizione predefinita per la finestra, in questo caso la impostiamo al centro utilizzando il parametro “Gtk.WindowPosition.CENTER”, se lo si desidera, è possibile modificarlo in “Gtk.WindowPosition.MOUSE” per aprire la finestra nella posizione del puntatore del mouse.
  9. button1=Gtk.Button(“Hello, World!”): abbiamo creato un nuovo Gtk.Button e lo abbiamo chiamato “button1”, il testo predefinito per il pulsante è “Hello, World! ”, puoi creare qualsiasi widget Gtk se lo desideri.
  10. button1.connect(“clicked”, self.whenbutton1_clicked): qui colleghiamo il segnale “clicked” con l'azione “whenbutton1_clicked”, in modo che quando si fa clic sul pulsante, l'azione “whenbutton1_clicked” è attivato.
  11. self.add(button1): Se vogliamo che i nostri widget Gtk appaiano, dobbiamo aggiungerli alla finestra predefinita, questa semplice riga aggiunge il widget “button1 ” alla finestra, è molto necessario Fai questo.
  12. defwhenbutton1_clicked(self, button): ora stiamo definendo qui l'azione "whenbutton1_clicked", stiamo definendo cosa accadrà quando viene fatto clic sul widget "button1", il widget "(self, button) ) "il parametro è importante per specificare il tipo di oggetto genitore del segnale.
  13. stampa "Ciao, mondo!": non devo spiegare altro qui.
  14. window=ourwindow(): dobbiamo creare una nuova variabile globale e impostarla sulla classe ourwindow() in modo da poterla richiamare in seguito utilizzando la libreria GTK+.
  15. window.connect(“delete-event”, Gtk.main_quit): Ora stiamo collegando il segnale “delete-event” con l'azione “Gtk.main_quit”, questo è importante per eliminare tutti i widget dopo aver chiuso automaticamente la finestra del programma.
  16. window.show_all(): mostra la finestra.
  17. Gtk.main(): esecuzione della libreria Gtk.

Tutto qui, facile no? E molto funzionale se vogliamo creare applicazioni di grandi dimensioni. Per ulteriori informazioni sulla creazione di interfacce GTK+ utilizzando la modalità solo codice, puoi visitare il sito Web della documentazione ufficiale all'indirizzo:

Esercitazioni su Python GTK3

Il modo di progettare Glade

Come ho detto all’inizio dell’articolo, Glade è uno strumento molto semplice per creare le interfacce di cui abbiamo bisogno per i nostri programmi, è molto famoso tra gli sviluppatori e molte fantastiche interfacce applicative sono state create utilizzandolo. Questo metodo si chiama “Sviluppo rapido di applicazioni”.

Devi installare Glade per iniziare a usarlo, su Debian/Ubuntu/Mint:

sudo apt­-get install glade

Su RedHat/Fedora/CentOS, esegui:

yum install glade

Dopo aver scaricato e installato il programma, e dopo averlo eseguito, vedrai i widget Gtk disponibili sulla sinistra, fai clic sul widget “finestra” per creare una nuova finestra.

Noterai che viene creata una nuova finestra vuota.

Ora puoi aggiungere alcuni widget, sulla barra degli strumenti di sinistra, fare clic sul widget "pulsante" e fare clic sulla finestra vuota per aggiungere il pulsante alla finestra.

Noterai che l'ID del pulsante è "pulsante1", ora fai riferimento alla scheda Segnali nella barra degli strumenti di destra, cerca il segnale "cliccato" e inserisci "button1_clicked " sotto di esso.

Ora che abbiamo creato la nostra GUI, esportiamola. Fare clic sul menu “File” e scegliere “Salva”, salvare il file nella directory home con il nome “mioprogramma.glade” e Uscita.

Ora crea un nuovo file “test.py” e inserisci al suo interno il seguente codice.

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

Salva il file, assegnagli i permessi 755 come prima ed eseguilo utilizzando "./test.py", ed è ciò che otterrai.

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

Fai clic sul pulsante e noterai che la frase "Hello, World!" è stampata nel terminale.

Adesso spieghiamo le novità:

  1. Gestore di classe: qui stiamo creando una classe chiamata "Handler" che includerà le definizioni per le azioni e i segnali che creiamo per la GUI.
  2. builder=Gtk.Builder(): Abbiamo creato una nuova variabile globale chiamata “builder ” che è un widget Gtk.Builder, questo è importante per importare il file .glade.
  3. builder.add_from_file(“myprogram.glade”): qui stiamo importando il file “myprogram.glade” per utilizzarlo come GUI predefinita per il nostro programma.
  4. builder.connect_signals(Handler()): questa riga collega il file .glade con la classe handler, in modo che le azioni e i segnali che definiamo nella classe "Handler" funzionino correttamente quando eseguiamo il programma .
  5. ournewbutton=builder.get_object(“button1”): ora stiamo importando l'oggetto “button1” dal file .glade, lo stiamo anche passando alla variabile globale “ournewbutton” per usarlo più avanti nel nostro programma.
  6. ournewbutton.set_label(“Hello, World!”): abbiamo utilizzato il metodo “set.label” per impostare il testo predefinito del pulsante su “Hello, World! " frase.
  7. window=builder.get_object(“window1”): Qui abbiamo chiamato l'oggetto “window1 ” dal file .glade per mostrarlo più avanti nel programma.

E questo è tutto! Hai creato con successo il tuo primo programma sotto Linux!

Naturalmente ci sono cose molto più complicate da fare per creare una vera applicazione che faccia qualcosa, ecco perché ti consiglio di dare un'occhiata alla documentazione di GTK+ e all'API GObject su:

  1. Manuale di riferimento GTK+
  2. Riferimento API GObject Python
  3. Riferimento a PyGObject

Hai già sviluppato qualche applicazione sotto il desktop Linux? Quali linguaggi di programmazione e quali strumenti sono stati utilizzati per farlo? Cosa ne pensi della creazione di applicazioni utilizzando Python e GTK 3?