Sådan oprettes GUI-applikationer under Linux Desktop ved hjælp af PyGObject - Del 1

Oprettelse af applikationer på Linux kan ske på forskellige måder, men der er begrænsede måder at gøre det på, så ved hjælp af de enkleste og mest funktionelle programmeringssprog og biblioteker vil vi derfor hurtigt se på at oprette applikationer under Linux desktop ved hjælp af GTK + -biblioteket med Python-programmeringssprog, der kaldes “PyGObject”.

PyGObject bruger GObject Introspection til at skabe binding til programmeringssprog som Python, PyGObject er den næste generation fra PyGTK, du kan sige, at PyGObject = Python + GTK3.

I dag skal vi starte en serie om oprettelse af GUI-applikationer (grafisk brugergrænseflade) under Linux-skrivebordet ved hjælp af GTK + -biblioteket og PyGobject -sprog, serien dækker følgende emner:

Først og fremmest skal du have nogle grundlæggende viden om Python; Python er et meget moderne og brugervenligt programmeringssprog. Det er et af de mest berømte programmeringssprog i verden ved hjælp af Python vil du være i stand til at oprette mange fantastiske applikationer og værktøjer. Du kan tage nogle gratis kurser som dem på codeacademy.com, eller du kan læse nogle bøger om Python på:

GTK + er en open source-værktøjssæt på tværs af platforme til at oprette grafiske brugergrænseflader til desktop-applikationer, den blev først startet i 1998 som et GUI-værktøjssæt til GIMP, senere blev det brugt i mange andre applikationer og blev hurtigt et af de mest berømte biblioteker til at oprette GUI'er. GTK + frigives under LGPL-licensen.

Oprettelse af GUI-applikationer under Linux

Der er 2 måder til at oprette applikationer ved hjælp af GTK + & Python:

Skrivning af den grafiske grænseflade kun ved hjælp af kode.
Design af den grafiske grænseflade ved hjælp af programmet " Glade "; hvilket er RAD-værktøj til let at designe GTK + -grænseflader, Glade genererer GUI som en XML-fil, der kan bruges med ethvert programmeringssprog til at opbygge GUI, efter at have eksporteret GUIs XML-fil, vil vi være i stand til at linke XML-filen med vores program til at udføre de job, vi ønsker.

Vi forklarer begge veje kort.

At skrive GUI kun ved hjælp af kode kan være lidt svært for noob-programmører og meget tidssvind, men ved at bruge den kan vi oprette meget funktionelle GUI'er til vores programmer mere end dem, vi opretter ved hjælp af nogle værktøjer som Glade.

Lad os tage følgende eksempel.

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

Kopier ovenstående kode, indsæt den i en “ test.py ” -fil, og indstil 755 tilladelse til test.py-filen, og kør filen senere ved hjælp af “ ./test.py ”, Det er hvad du får.

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

Ved at klikke på knappen ser du sætningen “ Hej, Verden! ” udskrevet i terminalen:

Lad mig forklare koden i detaljeret forklaring.

#!/usr/bin/python : Standardstien til Python-tolken (version 2.7 i de fleste tilfælde), denne linje skal være den første linje i hver Python-fil.
# - * - kodning: utf-8 - * - : Her indstiller vi standardkodningen til filen, UTF-8 er den bedste, hvis du vil understøtte ikke-engelske sprog, lad det sådan.
fra gi.repository import Gtk : Her importerer vi GTK 3-biblioteket for at bruge det i vores program.
Class ourwindow (Gtk.Window): Her opretter vi en ny klasse, der kaldes "ourwindow", vi indstiller også klasseobjektypen til en "Gtk.Window".
def __init __ (selv) : Intet nyt, vi definerer hovedvinduets komponenter her.
Gtk.Window .__ init __ (self, title = ”My Hello World Program”) : Vi bruger denne linje til at indstille titlen "My Hello World Program" til "ourwindow" -vinduet, du kan ændre titlen, hvis du vil.
Gtk.Window.set_default_size (selv, 400.325) : Jeg tror ikke, at denne linje skal forklares, her indstiller vi standardbredde og højde for vores vindue.
Gtk.Window.set_position (selv, Gtk.WindowPosition.CENTER) : Ved hjælp af denne linje kan vi indstille standardpositionen for vinduet, i dette tilfælde indstiller vi det til centrum ved hjælp af parameteren "Gtk.WindowPosition.CENTER", hvis du vil, kan du ændre den til "Gtk.WindowPosition.MOUSE" for at åbne vinduet på musemarkørens position.
knap1 = Gtk.Button (“Hej, Verden!”) : Vi oprettede en ny Gtk.Button, og vi kaldte den “knap1”, standardteksten for knappen er “Hej, Verden! ”, Du kan oprette en hvilken som helst Gtk-widget, hvis du vil.
knap1.forbindelse (“klikket”, self.whenbutton1_clicked) : Her forbinder vi signalet “klikket” med handlingen “whenbutton1_clicked”, så når “der klikkes på knappen,“ når knappen1_klikket ”er aktiveret.
self.add (button1) : Hvis vi ønsker, at vores Gtk-widgets skal vises, skal vi føje dem til standardvinduet, denne enkle linje tilføjer widget "button1" til vinduet, det er meget nødvendigt for at gøre dette.
def whenbutton1_clicked (self, button) : Nu definerer vi handlingen "whenbutton1_clicked" her, vi definerer hvad der skal ske, når der klikkes på widget "button1", "( selv, knap) ”-parameter er vigtig for at specificere signalets overordnede objekttype.
udskriv "Hej, Verden!" : Jeg behøver ikke forklare mere her.
vindue = ourwindow() : Vi er nødt til at oprette en ny global variabel og indstille den til ourwindow() -klassen, så vi kan ringe til den senere ved hjælp af GTK + -biblioteket.
window.connect ("delete-event", Gtk.main_quit) : Nu forbinder vi signalet "delete-event" med handlingen "Gtk.main_quit", dette er vigtigt i for at slette alle widgets, når vi automatisk lukker vores programvindue.
window.show_all() : Viser vinduet.
Gtk.main() : Kører Gtk-biblioteket.

Det er det, let er det ikke? Og meget funktionelt, hvis vi vil oprette nogle store applikationer. For mere information om oprettelse af GTK + -grænseflader ved hjælp af den eneste kode, kan du besøge det officielle dokumentationswebsted på:

Python GTK3 Tutorials

Som jeg sagde i begyndelsen af artiklen, er Glade et meget let værktøj til at oprette de grænseflader, vi har brug for til vores programmer, det er meget berømt blandt udviklere, og mange gode applikationsgrænseflader blev oprettet ved hjælp af det. Denne måde kaldes “Hurtig applikationsudvikling”.

Du skal installere Glade for at begynde at bruge det på Debian/Ubuntu/Mint-kørsel:

$ sudo apt-get install glade

På RedHat/Fedora/CentOS skal du køre:

# yum install glade

Når du har downloadet og installeret programmet, og efter at du har kørt det, vil du se de tilgængelige Gtk-widgets til venstre. Klik på widget “ vindue ” for at oprette et nyt vindue.

Du vil bemærke, at der oprettes et nyt tomt vindue.

Du kan nu tilføje nogle widgets til den, i venstre værktøjslinje skal du klikke på widget “ knap ” og klikke på det tomme vindue for at tilføje knappen til vinduet.

Du vil bemærke, at knap-id'et er " knap1 ", henvises nu til fanen Signaler i højre værktøjslinje, og søg efter " klikket " signalet og indtast " knap1_klikket ”under den.

Nu hvor vi har oprettet vores GUI, lad os eksportere den. Klik på menuen “ Fil ” og vælg “ Gem ”, gem filen i dit hjemmekatalog i navnet “ myprogram.glade ” og Afslut.

Opret nu en ny " test.py " -fil, og indtast følgende kode inde i den.

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

Gem filen, giv den 755 tilladelser som før, og kør den ved hjælp af " ./test.py ", og det er hvad du får.

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

Klik på knappen, og du vil bemærke, at sætningen “ Hej, verden! ” er trykt i terminalen.

Lad os nu forklare de nye ting:

klassehåndterer : Her opretter vi en klasse, der hedder "Håndterer", der inkluderer definitionerne for handlinger og signaler, vi opretter til GUI.
builder = Gtk.Builder() : Vi oprettede en ny global variabel kaldet "builder", som er en Gtk.Builder-widget, dette er vigtigt for at importere .glade-filen.
builder.add_from_file (“myprogram.glade”) : Her importerer vi filen “myprogram.glade” for at bruge den som en standard GUI til vores program.
builder.connect_signals (Handler()) : Denne linje forbinder .glade-filen med handlerklassen, så de handlinger og signaler, som vi definerer under "Handler" -klassen, fungerer fint, når vi kør programmet.
ournewbutton = builder.get_object ("button1") : Nu importerer vi "button1" -objektet fra .glade-filen, vi sender det også til den globale variabel "ournewbutton" at bruge det senere i vores program.
ournewbutton.set_label (“Hej, Verden!”) : Vi brugte metoden “set.label” til at indstille standardknappeteksten til “Hej, Verden!” sætning.
vindue = builder.get_object (“window1”) : Her kaldte vi “window1” -objektet fra .glade-filen for at vise det senere i programmet.

Og det er det! Du har oprettet dit første program under Linux!

Selvfølgelig er der meget mere komplicerede ting at gøre for at skabe en rigtig applikation, der gør noget, det er derfor, jeg anbefaler dig at se nærmere på GTK + -dokumentationen og GObject API på:

GTK + referencehåndbog
Python GObject API-reference
PyGObject-reference

Har du udviklet nogen applikation før under Linux-skrivebordet? Hvilket programmeringssprog og værktøjer har brugt til at gøre det? Hvad synes du om at oprette applikationer ved hjælp af Python & GTK 3?