Zoeken op website

GUI-applicaties maken onder Linux Desktop met PyGObject - Deel 1

Het maken van applicaties op Linux kan op verschillende manieren worden gedaan, maar er zijn een beperkt aantal manieren om dit te doen, dus door gebruik te maken van de eenvoudigste en meest functionele programmeertalen en bibliotheken. Daarom gaan we snel kijken naar het maken van applicaties onder Linux. desktop met behulp van de GTK+-bibliotheek met Python-programmeertaal die “PyGObject” wordt genoemd.

PyGObject gebruikt GObject Introspection om bindingen te creëren voor programmeertalen zoals Python. PyGObject is de volgende generatie van PyGTK, je kunt zeggen dat PyGObject=Python + GTK3.

Vandaag gaan we een serie starten over het maken van GUI-applicaties (Graphical User Interface) onder de Linux-desktop met behulp van de GTK+-bibliotheek en de PyGobject-taal. De serie behandelt de volgende onderwerpen:

Over Python

Allereerst moet je enige basiskennis van Python hebben; Python is een zeer moderne en gemakkelijk te gebruiken programmeertaal. Het is een van de beroemdste programmeertalen ter wereld. Met Python kun je veel geweldige applicaties en tools maken. Je kunt een aantal gratis cursussen volgen, zoals die op codeacademy.com, of je kunt een aantal boeken over Python lezen op:

Over GTK+

GTK+ is een open-source platformonafhankelijke toolkit om grafische gebruikersinterfaces voor desktoptoepassingen te creëren. Het werd voor het eerst in 1998 gestart als een GUI-toolkit voor GIMP, later werd het in veel andere toepassingen gebruikt en werd al snel een van de beroemdste bibliotheken om GUI's te maken. GTK+ wordt vrijgegeven onder de LGPL-licentie.

GUI-applicaties maken onder Linux

Er zijn 2 manieren om de applicaties te maken met GTK+ en Python:

  1. De grafische interface schrijven met alleen code.
  2. Het ontwerpen van de grafische interface met behulp van het programma “Glade ”; Dit is een RAD-tool om eenvoudig GTK+-interfaces te ontwerpen. Glade genereert de GUI als een XML-bestand dat met elke programmeertaal kan worden gebruikt om de GUI te bouwen. Na het exporteren van het XML-bestand van de GUI kunnen we het XML-bestand koppelen aan onze programma om de banen te doen die we willen.

We leggen beide manieren kort uit.

De enige code-manier

Het schrijven van de GUI met alleen code kan een beetje moeilijk zijn voor beginnende programmeurs en erg tijdverspillend, maar door het te gebruiken kunnen we zeer functionele GUI's voor onze programma's maken, meer dan die we maken met behulp van sommige tools zoals Glade.

Laten we het volgende voorbeeld nemen.

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

Kopieer de bovenstaande code, plak deze in een “test.py” bestand en stel 755-rechten in voor het test.py bestand en voer het bestand later uit met “./test.py ”, dat is wat u krijgt.

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

Door op de knop te klikken, ziet u de zin “Hallo, wereld! ” afgedrukt in de terminal:

Laat me de code in gedetailleerde uitleg uitleggen.

  1. #!/usr/bin/python: het standaardpad voor de Python-interpreter (in de meeste gevallen versie 2.7). Deze regel moet de eerste regel in elk Python-bestand zijn.
  2. # -*- codering: utf-8 -*-: Hier stellen we de standaardcodering voor het bestand in. UTF-8 is het beste als u niet-Engelse talen wilt ondersteunen, laat dit zo .
  3. van gi.repository import Gtk: hier importeren we de GTK 3-bibliotheek om deze in ons programma te gebruiken.
  4. Klasse ourwindow(Gtk.Window): Hier maken we een nieuwe klasse, die “ourwindow” wordt genoemd, we stellen ook het klasseobjecttype in op een “Gtk.Window”.
  5. def __init__(self): Niets nieuws, we definiëren hier de hoofdvenstercomponenten.
  6. Gtk.Window.__init__(self, title=”Mijn Hello World-programma”): We gebruiken deze regel om de titel van het “Mijn Hello World-programma” in te stellen op het venster “ons venster”. U kunt dit wijzigen de titel als je wilt.
  7. Gtk.Window.set_default_size(self, 400,325): ik denk niet dat deze regel uitleg nodig heeft, hier stellen we de standaardbreedte en hoogte voor ons venster in.
  8. Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER): met behulp van deze regel kunnen we de standaardpositie voor het venster instellen, in dit geval stellen we deze in op het midden met behulp van de parameter "Gtk.WindowPosition.CENTER", kunt u deze desgewenst wijzigen in "Gtk.WindowPosition.MOUSE" om het venster te openen op de positie van de muisaanwijzer.
  9. button1=Gtk.Button(“Hallo, Wereld!”): We hebben een nieuwe Gtk.Button gemaakt, en we noemden deze “button1”, de standaardtekst voor de knop is “Hallo, Wereld! ”, kunt u elke Gtk-widget maken als u dat wilt.
  10. button1.connect(“clicked”, self.whenbutton1_clicked): Hier koppelen we het “clicked” signaal aan de “whenbutton1_clicked” actie, zodat wanneer op de knop wordt geklikt, de “whenbutton1_clicked” actie plaatsvindt is geactiveerd.
  11. self.add(button1): Als we willen dat onze Gtk-widgets verschijnen, moeten we ze toevoegen aan het standaardvenster. Deze eenvoudige regel voegt de widget “button1” toe aan het venster, het is zeer noodzakelijk om doe dit.
  12. def wanneerbutton1_klikte(self, button): Nu definiëren we hier de actie “whenbutton1_clicked”, we definiëren wat er gaat gebeuren wanneer op de widget “button1” wordt geklikt, de “(self, button ) ”parameter is belangrijk om het signaalouderobjecttype te specificeren.
  13. print “Hallo wereld!”: meer hoef ik hier niet uit te leggen.
  14. window=ourwindow(): We moeten een nieuwe globale variabele maken en deze instellen op de klasse ourwindow() zodat we deze later kunnen aanroepen met behulp van de GTK+-bibliotheek.
  15. window.connect(“delete-event”, Gtk.main_quit): Nu verbinden we het signaal “delete-event” met de actie “Gtk.main_quit”, dit is belangrijk om te kunnen verwijderen alle widgets nadat we ons programmavenster automatisch sluiten.
  16. window.show_all(): Het venster tonen.
  17. Gtk.main(): Het uitvoeren van de Gtk-bibliotheek.

Dat is alles, gemakkelijk nietwaar? En zeer functioneel als we enkele grote applicaties willen maken. Voor meer informatie over het maken van GTK+-interfaces met alleen code kunt u de officiële documentatiewebsite bezoeken op:

Python GTK3-tutorials

De Glade Designer-manier

Zoals ik in het begin van het artikel al zei, is Glade een heel eenvoudig hulpmiddel om de interfaces te maken die we nodig hebben voor onze programma's. Het is erg beroemd onder ontwikkelaars en er zijn veel geweldige applicatie-interfaces mee gemaakt. Deze manier wordt “Snelle applicatie-ontwikkeling” genoemd.

U moet Glade installeren om het te kunnen gebruiken, op Debian/Ubuntu/Mint-uitvoering:

sudo apt­-get install glade

Op RedHat/Fedora/CentOS voer je het volgende uit:

yum install glade

Nadat je het programma hebt gedownload en geïnstalleerd, en nadat je het hebt uitgevoerd, zie je aan de linkerkant de beschikbare Gtk-widgets. Klik op de widget “venster” om een nieuw venster te maken.

U zult merken dat er een nieuw leeg venster wordt aangemaakt.

U kunt er nu enkele widgets aan toevoegen. Klik in de linkerwerkbalk op de widget “knop” en klik op het lege venster om de knop aan het venster toe te voegen.

U zult merken dat de knop-ID “knop1” is. Ga nu naar het tabblad Signalen in de rechter werkbalk en zoek naar het signaal “geklikt” en voer “button1_clicked ” eronder.

Nu we onze GUI hebben gemaakt, gaan we deze exporteren. Klik op het menu “Bestand ” en kies “Opslaan”, sla het bestand op in uw thuismap onder de naam “mijnprogramma.glade ” en Uitgang.

Maak nu een nieuw “test.py” bestand en voer de volgende code daarin in.

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

Sla het bestand op, geef het 755 rechten zoals voorheen, en voer het uit met “./test.py”, en dat is wat je krijgt.

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

Klik op de knop en u zult merken dat de zin “Hallo, wereld! ” in de terminal wordt afgedrukt.

Laten we nu de nieuwe dingen uitleggen:

  1. class Handler: hier maken we een klasse met de naam 'Handler', die de definities bevat voor de acties en signalen die we voor de GUI maken.
  2. builder=Gtk.Builder(): We hebben een nieuwe globale variabele gemaakt met de naam “builder”, wat een Gtk.Builder-widget is. Dit is belangrijk om het .glade-bestand te kunnen importeren.
  3. builder.add_from_file(“myprogram.glade”): Hier importeren we het bestand “myprogram.glade” om het te gebruiken als standaard GUI voor ons programma.
  4. builder.connect_signals(Handler()): deze regel verbindt het .glade-bestand met de handler-klasse, zodat de acties en signalen die we definiëren onder de klasse “Handler” prima werken wanneer we het programma uitvoeren .
  5. ournewbutton=builder.get_object(“button1”): Nu importeren we het object “button1” uit het .glade-bestand, we geven het ook door aan de globale variabele “ournewbutton” om het te gebruiken verderop in ons programma.
  6. ournewbutton.set_label(“Hallo, Wereld!”): We hebben de “set.label”-methode gebruikt om de standaardknoptekst in te stellen op “Hallo, Wereld! " zin.
  7. window=builder.get_object(“window1”): Hier hebben we het object “window1” uit het .glade-bestand aangeroepen om het later in het programma te tonen.

En dat is het! Je hebt met succes je eerste programma onder Linux gemaakt!

Natuurlijk zijn er veel ingewikkelder dingen die je moet doen om een echte applicatie te maken die iets doet. Daarom raad ik je aan om een kijkje te nemen in de GTK+ documentatie en GObject API op:

  1. GTK+-referentiehandleiding
  2. Python GObject API-referentie
  3. PyGObject-referentie

Heb je eerder een applicatie ontwikkeld onder de Linux-desktop? Welke programmeertaal en tools zijn hiervoor gebruikt? Wat vind je van het maken van applicaties met Python & GTK 3?