Wéi erstellen ech GUI Uwendungen ënner Linux Desktop mat PyGObject - Deel 1


Uwendungen op Linux erstellen ka mat verschiddene Weeër gemaach ginn, awer et gi limitéiert Weeër fir ze maachen, sou datt Dir déi einfachst an déi funktionell Programméierungssproochen a Bibliothéike benotzt, dofir wäerte mir e séiere Bléck iwwer d'Erstelle vun Uwendungen ënner dem Linux maachen. Desktop mat der GTK + Bibliothéik mat Python Programméiersprooch déi PyGObject genannt gëtt.

PyGObject benotzt d'GObject Introspection fir Bindung fir Programméierungssprooche wéi Python ze kreéieren, PyGObject ass déi nächst Generatioun vu PyGTK, Dir kënnt soen datt PyGObject = Python + GTK3.

Haut wäerte mir eng Serie starten iwwer d'Schafe vun GUI (Graphical User Interface) Uwendungen ënner dem Linux Desktop mat GTK + Bibliothéik an PyGobject Sprooch, d'Serie wäert déi folgend Themen ofdecken:

Als éischt musst Dir e puer Basiskenntnisser am Python hunn; Python ass eng ganz modern an einfach ze benotzen Programméierungssprooch. Et ass eng vun de bekanntste Programméierungssproochen op der Welt, mat Python kënnt Dir vill super Uwendungen & Tools erstellen. Dir kënnt e puer gratis Coursen huelen wéi déi op codeacademy.com oder Dir kënnt e puer Bicher iwwer Python liesen op:

GTK+ ass en Open-Source Cross-Plattform Toolkit fir grafesch User Interfaces fir Desktop Uwendungen ze kreéieren, et gouf fir d'éischt am Joer 1998 als GUI Toolkit fir de GIMP gestart, spéider gouf et a villen aneren Uwendungen benotzt an gouf séier ee vun de bekanntste Bibliothéiken fir GUIs ze kreéieren. GTK+ gëtt ënner der LGPL Lizenz verëffentlecht.

GUI Uwendungen ënner Linux erstellen

Et ginn 2 Weeër fir d'Applikatiounen mat GTK + & Python ze kreéieren:

  1. Schreift de grafeschen Interface nëmme mat Code.
  2. Design vun der grafescher Interface mat dem \Glade Programm; wat RAD Tool ass fir GTK+ Interfaces einfach ze designen, Glade generéiert d'GUI als XML Datei déi mat all Programméierungssprooch benotzt ka ginn fir ze bauen d'GUI, nodeems mir d'XML-Datei vun der GUI exportéiert hunn, kënne mir d'XML-Datei mat eisem Programm verbannen fir déi Aarbechten ze maachen déi mir wëllen.

Mir erkläre béid Weeër kuerz.

D'GUI nëmme mat Code ze schreiwen ka e bësse schwéier sinn fir Noob Programméierer a ganz Zäitverschwendung, awer mat der Hëllef kënne mir ganz funktionell GUIs fir eis Programmer erstellen, méi wéi déi, déi mir erstellen mat e puer Tools wéi Glade.

Loosst eis dat folgend Beispill huelen.

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

Kopéiert den uewe genannte Code, paste se an eng \test.py Datei a setzt 755 Erlaabnis op d'test.py Datei a lafe spéider d'Datei mat \./test.py, dat ass wat Dir kritt.

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

Andeems Dir op de Knäppchen klickt, gesitt Dir de Saz \Hallo, Welt! am Terminal ausgedréckt:

Loosst mech de Code an detailléiert Erklärung erklären.

  1. #!/usr/bin/python: De Standardwee fir de Python Dolmetscher (Versioun 2.7 an de meeschte Fäll), dës Linn muss déi éischt Zeil an all Python-Datei sinn.
  2. # -*- coding: utf-8 -*-: Hei setzen mir d'Standardkodéierung fir d'Datei, UTF-8 ass am Beschten wann Dir net-englesch Sproochen ënnerstëtzen wëllt, loosst et esou.
  3. vum gi.repository import Gtk: Hei importéiere mir d'GTK 3 Bibliothéik fir se an eisem Programm ze benotzen.
  4. Class ourwindow(Gtk.Window): Hei kreéiere mir eng nei Klass, déi ourwindow genannt gëtt, mir setzen och de Klassenobjekttyp op eng Gtk.Window.
  5. def __init__(self): Näischt Neies, mir definéieren hei d'Haaptfensterkomponenten.
  6. Gtk.Window.__init__(self, title=Mäi Hallo Welt Programm): Mir benotzen dës Linn fir den Titel Mäi Hello Welt Programm op eis Window ze setzen Fënster, kënnt Dir den Titel änneren wann Dir wëllt.
  7. Gtk.Window.set_default_size(self, 400,325): Ech denken net datt dës Linn Erklärung brauch, hei setzen mir d'Standardbreed an Héicht fir eis Fënster.
  8. Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER): Mat dëser Linn kënne mir d'Standardpositioun fir d'Fënster festleeën, an dësem Fall setzen mir se an d'Mëtt mam \Gtk.WindowPosition.CENTER Parameter, wann Dir wëllt, kënnt Dir et op \Gtk.WindowPosition.MOUSE änneren fir d'Fënster op der Mauszeigerpositioun opzemaachen.
  9. button1 = Gtk.Button(“Hallo, Welt!”): Mir hunn en neie Gtk.Button erstallt, a mir hunn en button1 genannt, den Standardtext fir de Knäppchen ass Hallo, Welt!, Dir kënnt all Gtk Widget erstellen wann Dir wëllt.
  10. button1.connect(“clicked”, self.whenbutton1_clicked): Hei verlinke mir de \geklickte\ Signal mat der \whenbutton1_clicked\ Aktioun, sou datt wann de Knäppchen geklickt gëtt, d'Aktioun \whenbutton1_clicked ass aktivéiert.
  11. self.add(button1): Wa mir wëllen datt eis Gtk Widgets erschéngen, musse mir se an d'Standardfenster derbäisetzen, dës einfach Linn füügt den \button1 Widget un d'Fënster, et ass ganz néideg dëst ze maachen.
  12. def whenbutton1_clicked(self, button): Elo definéiere mir d'Aktioun \whenbutton1_clicked hei, mir definéieren wat geschitt wann de \button1 Widget geklickt gëtt, de De Parameter (Selbst, Knäppchen) ass wichteg fir de Signal Elterenobjekttyp ze spezifizéieren.
  13. Drécken Hallo, Welt!: Ech muss hei net méi erklären.
  14. window = ourwindow(): Mir mussen eng nei global Variabel erstellen an se op ourwindow() Klass setzen fir datt mir se spéider mat der GTK+ Bibliothéik ruffen.
  15. window.connect(“delete-event”, Gtk.main_quit): Elo verbannen mir de \delete-event\ Signal mat der \Gtk.main_quit\ Aktioun, dëst ass wichteg fir all Widgets ze läschen nodeems mir eis Programmfenster automatesch zoumaachen.
  16. window.show_all(): D'Fënster weisen.
  17. Gtk.main(): D'Gtk-Bibliothéik lafen.

Dat ass et, einfach ass net? A ganz funktionell wa mir e puer grouss Applikatiounen erstellen wëllen. Fir méi Informatioun iwwer d'Schafe vun GTK+ Interfaces mam Code-nëmme Wee, kënnt Dir déi offiziell Dokumentatiouns Websäit besichen:

Python GTK3 Tutorials

Wéi ech am Ufank vum Artikel gesot hunn, Glade ass e ganz einfacht Tool fir d'Interfaces ze kreéieren déi mir fir eis Programmer brauchen, et ass ganz berühmt ënner Entwéckler a vill super Applikatiounsinterfaces goufe benotzt. Dëse Wee gëtt Rapid Applications Development genannt.

Dir musst Glade installéieren fir se ze benotzen, op Debian/Ubuntu/Mint Run:

$ sudo apt­-get install glade

Op RedHat/Fedora/CentOS, lafen:

# yum install glade

Nodeems Dir de Programm eroflueden an installéiert hutt, a nodeems Dir et leeft, gesitt Dir déi verfügbar Gtk Widgets op der lénker Säit, klickt op de \Fënster Widget fir eng nei Fënster ze kreéieren.

Dir wäert feststellen datt eng nei eidel Fënster erstallt gëtt.

Dir kënnt elo e puer Widgets derbäi setzen, op der lénker Toolbar klickt op de Widget \Knäppchen a klickt op déi eidel Fënster fir de Knäppchen an d'Fënster ze addéieren.

Dir wäert feststellen datt d'Knäppchen ID \button1 ass, kuckt elo op d'Signaler Reiter an der rietser Toolbar, a sicht no dem \geklickte Signal a gitt\button1_clicked drënner.

Elo datt mir eis GUI erstallt hunn, loosst eis et exportéieren. Klickt op de Menü \Datei a wielt \Späicheren, späichert d'Datei an Ärem Heemverzeichnis am Numm \myprogram.glade > an erausgoen.

Erstellt elo eng nei \test.py Datei, a gitt de folgende Code dran.

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

Späichert d'Datei, gitt et 755 Permissiounen wéi virdrun, a lafen se mat ./test.py, an dat ass wat Dir kritt.

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

Klickt op de Knäppchen, an Dir wäert feststellen datt de Saz \Hallo, Welt! am Terminal gedréckt gëtt.

Loosst eis elo déi nei Saachen erklären:

  1. Klasse Handler: Hei kreéiere mir eng Klass mam Numm Handler déi d'Definitioune fir d'Aktiounen & Signaler enthält, déi mir fir de GUI erstellen.
  2. Builder = Gtk.Builder(): Mir hunn eng nei global Variabel mam Numm \Builder erstallt, wat e Gtk.Builder Widget ass, dëst ass wichteg fir d'.glade Datei z'importéieren.< /li>
  3. builder.add_from_file(“myprogram.glade”): Hei importéiere mir d'myprogram.glade Datei fir se als Standard-GUI fir eise Programm ze benotzen.
  4. builder.connect_signals(Handler()): Dës Linn verbënnt d'.glade-Datei mat der Handlerklass, sou datt d'Aktiounen an d'Signaler, déi mir ënner der Handler-Klass definéieren, gutt funktionéieren wann mir lafen de Programm.
  5. ournewbutton = builder.get_object(“button1”): Elo importéiere mir den \button1 Objet aus der .glade Datei, mir ginn et och un déi global Variabel\ournewbutton fir se spéider an eisem Programm ze benotzen.
  6. ournewbutton.set_label(“Hallo, Welt!”): Mir hunn d'Methode \set.label benotzt fir den Default-Knäppchentext op \Hallo, Welt! Saz.
  7. window = builder.get_object(“window1”): Hei hu mir den \window1 Objet aus der .glade Datei genannt fir se spéider am Programm ze weisen.

An dat ass et! Dir hutt Ären éischte Programm ënner Linux erstallt!

Natierlech ginn et vill méi komplizéiert Saachen ze maachen fir eng richteg Applikatioun ze kreéieren déi eppes mécht, dofir empfeelen ech Iech e Bléck an d'GTK+ Dokumentatioun an d'GObject API op:

  1. GTK+ Referenzhandbuch
  2. Python GObject API Referenz
  3. PyGObject Referenz

Hutt Dir eng Applikatioun virdrun ënner dem Linux Desktop entwéckelt? Wéi eng Programméierungssprooch an Tools hu benotzt fir et ze maachen? Wat mengt Dir iwwer d'Erstelle vun Uwendungen mat Python & GTK 3?