Skapa ditt första grafiska användargränssnitt i Python med Glade och GTK+

Innehållsförteckning

Viktiga takeaways

Python-utvecklare kan använda GTK+ och Glade för att skapa intuitiva GUI:er med ett visuellt gränssnitt.
Att ställa in miljön för det här exemplet innebär installation av Python, GTK+, Glade och PyGObject.
Att använda GTK+ och Glade för Python GUI-utveckling påskyndar processen och skiljer GUI-design från kod.

Python är ett tillgängligt språk som är perfekt för dataanalys och webbutveckling. Men det är ett utmärkt val för GUI-apputveckling också. GTK+ och Glade förenklar processen att skapa enkla appar för flera plattformar.

GTK+ och Glade Interface Designer för Python-utvecklare

GTK+ (GIMP Toolkit) och Glade Interface Designer är en fantastisk kombination för Python-utvecklare som vill skapa intuitiva och tilltalande grafiska användargränssnitt.

GTK+ är en multiplattformsverktygslåda som du kan använda för GUI-utveckling. Den är kompatibel med en mängd olika operativsystem, inklusive Linux, Windows och macOS.

Glade Interface Designer, ett komplementverktyg till GTK+, låter dig designa GUI:er utan att behöva skriva layoutkod. Du kan använda den för att skapa ett GUI i en WYSIWYG-miljö med några få klick och enkla dra-och-släpp-funktioner.

Konfigurera din Python-miljö för GTK+ och Glade Development

Att ställa in din miljö är ett viktigt första steg för att säkerställa ett smidigt och effektivt arbetsflöde.

1. Installera Python

Börja med att se till att du har Python installerat på ditt system. Du kommer att se Python 3-kod i exemplen du läser, eftersom den erbjuder bättre stöd och integration för GTK+ och Glade. För Linux och macOS är Python vanligtvis förinstallerat.

Windows-användare kan ladda ner Python från den officiella Python-webbplatsen.

2. Installera GTK+

Du kan installera GTK+ med en pakethanterare.

För Ubuntu och Debian-baserade Linux-system använd:

 sudo apt-get install libgtk-3-dev

För Fedora och liknande:

 sudo dnf install gtk3-devel

På macOS, med Homebrew:

 brew install gtk+3

Windows-användare kan ladda ner GTK+ från GTK:s officiella nedladdningssida. Men om du har MSYS2 installerat kan du öppna MSYS2-kommandoraden och använda det här kommandot:

 pacman -S mingw-w64-x86_64-python-gobject

3. Installera Glade

Du kan använda kommandoraden för att installera Glade.

För Ubuntu och Debian-baserade Linux-distributioner:

 sudo apt-get install glade

På Fedora:

 sudo dnf install glade

macOS-användare kan använda Homebrew:

 brew install glade

Windows-användare kan använda följande kommando med MSYS2:

 pacman -S mingw-w64-x86_64-glade

4. Python-bindningar för GTK+

Installera PyGObject för att integrera GTK+ med Python. Kommandot du kommer att använda för detta är:

 pip install PyGObject

Om det finns ett fel som ”Bygghjulet för pycairo (pyproject.toml) kördes inte” under PyGObject-installationen, måste du också installera cairo-paketet.

För Ubuntu och Debian-baserade Linux-distributioner:

 sudo apt-get install libcairo2-dev

För Fedora:

 sudo yum install cairo-devel

På macOS:

 brew install pygobject3

5. Konfigurera en virtuell miljö (valfritt)

Det är bra att använda en virtuell miljö för dina Python-projekt. Detta isolerar dina projektberoenden. Skapa och aktivera en virtuell miljö på Linux med dessa terminalkommandon:

 python -m venv myenv
source myenv/bin/activate

På Windows använd:

 python -m venv myenv
myenv\Scripts\activate

På macOS, för att säkerställa att den virtuella miljön kan komma åt paketen som brygginstallationer, använd:

 python -m venv --system-site-packages myenv
source myenv/bin/activate

6. Verifiera installationen

För att verifiera att GTK+ och Glade är installerade, skapa ett enkelt Python-skript som importerar GTK:

 import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtkprint("GTK+ version:", Gtk.get_major_version(), Gtk.get_minor_version())

När du kör det här skriptet kommer det att mata ut den installerade GTK+-versionen. Om allt går bra har du satt upp din utvecklingsmiljö.

Skapa en enkel GUI-app med Glade Interface Designer och Python

Du kan designa din GUI-app i Glade Interface Designer och exportera layouten som en projektfil. Du kan sedan komma åt den projektfilen från din Python-kod.

Designa ditt GUI med Glade

Glades dra-och-släpp-gränssnitt gör det enkelt att fokusera på designen utan att fastna i den underliggande koden. Starta Glade från ditt systems programmeny eller kommandorad med detta kommando:

 glade

Du bör se Glade-gränssnittet där du kan börja skapa din GUI-layout.

Knappen Skapa nytt projekt längst upp till vänster tillhandahåller en tom arbetsyta för din GUI-design. Glade erbjuder ett brett utbud av widgets i toppfältet, inklusive knappar, textinmatningar och etiketter. Dra dessa widgets till din duk för att börja styla ditt GUI. Du kan ändra storlek på och placera widgets efter dina designbehov.

Välj först GtkWindow-widgeten från Toplevels-menyn:

På sidan Allmänt i det högra fältet i Glade ser du ett ID-alternativ. Detta ID är det unika namnet på widgeten du lade till. För det här exemplet, tilldela ID:t myMainWindow till det GtkWindow du lade till.

Du kan nu lägga till widgets i huvudfönstret som du har skapat. Gå till Behållare i det översta fältet, välj GtkBox-widgeten och dra den till din arbetsyta. Ge den sedan ett ID, myMainBox.

När du har lagt till GtkBox-widgeten ser du olika alternativ till höger om din arbetsyta som är specifika för den widgeten. Du kan redigera hela din design här utan att skriva någon kod.

Lägg sedan till en kontrollwidget till din design. För att göra det, gå till Kontroll i det översta fältet, välj GtkButton som exempel och dra den var som helst i GtkBox. Ge det ID, myButton. Om du vill kan du också ändra texten på knappen genom att använda fliken Allmänt i den högra panelen.

GtkButton är en klickbar widget, så du kan definiera en Python-hanterare för den och skriva lämplig kod senare. Gå till fliken Signaler i den högra menyn och ange en hanterare för den klickade signalen. För detta exempel, kalla det on_button_clicked.

Du kan nu spara din GUI-design som en projektfil. Spara filen som myDesign.glade.

Använda Glade Design File från Python Code

Skapa en app.py-fil i samma katalog som din myDesign.glade-fil. Klistra in följande kod i den här filen:

 import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from gi.repository import Gdkclass MyApp:
    def __init__(self):
        
        self.builder = Gtk.Builder()
        self.builder.add_from_file("myDesign.glade")
        
        self.window = self.builder.get_object("myMainWindow")
        self.window.connect("destroy", Gtk.main_quit)
        
        self.button = self.builder.get_object("myButton")
        self.button.connect("clicked", self.on_button_clicked)
        
        self.color_toggle = False
    def on_button_clicked(self, widget):
        
        color = "#FF0000" if self.color_toggle else "#00FF00"
        self.window.modify_bg(Gtk.StateType.NORMAL, Gdk.color_parse(color))
        self.color_toggle = not self.color_toggle
    def run(self):
        self.window.show_all()
        Gtk.main()
if __name__ == "__main__":
    app = MyApp()
    app.run()

Denna kod kommer att ändra färgen på bakgrunden varje gång du klickar på knappen. Notera anropen till self.builder.get_object() som skickar ID:n för widgetarna som du definierade i Glade.

Kör ditt Python-skript med det här kommandot för att se resultatet:

 python3 app.py

Fördelar med att använda GTK+ och Glade för Python GUI-utveckling

Att använda GTK+ och Glade för Python GUI-utveckling ger tydliga fördelar. Vanligtvis tar det mycket tid och ansträngning att skapa ett GUI. Men med Glade Interface Designer kan du påskynda processen. Glade erbjuder också ett brett utbud av widgets, alla lika lätta att använda som knappen i exemplet.

En viktig fördel med Glade är dess förmåga att hålla GUI-design separat från koden. Detta gör det enklare att underhålla och uppdatera GUI. Detta tillvägagångssätt leder till renare, bättre organiserad kod, i linje med moderna programmeringsmetoder.