Wyszukiwanie w witrynie

Jak tworzyć aplikacje GUI w systemie Linux przy użyciu PyGObject — część 1


Tworzenie aplikacji w systemie Linux można wykonać na różne sposoby, ale jest ich niewiele, więc używając najprostszych i najbardziej funkcjonalnych języków programowania i bibliotek, dlatego szybko przyjrzymy się tworzeniu aplikacji pod Linuksem desktop przy użyciu biblioteki GTK+ z językiem programowania Python o nazwie „PyGObject”.

PyGObject wykorzystuje introspekcję GObject do tworzenia powiązań dla języków programowania takich jak Python. PyGObject to następna generacja PyGTK, można powiedzieć, że PyGObject=Python + GTK3.

Dzisiaj rozpoczniemy serię dotyczącą tworzenia aplikacji GUI (Graphical User Interface) pod Linuksem przy użyciu biblioteki GTK+ i języka PyGobject. Seria obejmie następujące tematy:

O Pythonie

Przede wszystkim musisz mieć podstawową wiedzę o Pythonie; Python to bardzo nowoczesny i łatwy w obsłudze język programowania. To jeden z najsłynniejszych języków programowania na świecie. Używając Pythona, będziesz mógł stworzyć wiele świetnych aplikacji i narzędzi. Możesz wziąć udział w bezpłatnych kursach, takich jak te na codeacademy.com, lub przeczytać książki o Pythonie pod adresem:

O GTK+

GTK+ to wieloplatformowy zestaw narzędzi typu open source do tworzenia graficznych interfejsów użytkownika dla aplikacji komputerowych. Po raz pierwszy został uruchomiony w 1998 roku jako zestaw narzędzi GUI dla GIMP, później był używany w wielu innych aplikacjach i wkrótce stała się jedną z najbardziej znanych bibliotek do tworzenia GUI. GTK+ jest udostępniane na licencji LGPL.

Tworzenie aplikacji GUI pod Linuksem

Istnieją 2 sposoby tworzenia aplikacji przy użyciu GTK+ i Pythona:

  1. Napisanie interfejsu graficznego wyłącznie przy użyciu kodu.
  2. Zaprojektowanie interfejsu graficznego z wykorzystaniem programu „Polana”; które jest narzędziem RAD do łatwego projektowania interfejsów GTK+, Glade generuje GUI jako plik XML, którego można użyć w dowolnym języku programowania do zbudowania GUI. Po wyeksportowaniu pliku XML GUI będziemy mogli połączyć plik XML z naszym program do wykonywania zadań, które chcemy.

Pokrótce wyjaśnimy oba sposoby.

Sposób oparty tylko na kodzie

Pisanie GUI przy użyciu samego kodu może być trochę trudne dla programistów noobów i bardzo czasochłonne, ale używając go, możemy stworzyć bardzo funkcjonalne GUI dla naszych programów, więcej niż te, które tworzymy przy użyciu niektórych narzędzi, takich jak Glade.

Weźmy następujący przykład.

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

Skopiuj powyższy kod, wklej go do pliku „test.py” i ustaw uprawnienia 755 dla pliku test.py, a następnie uruchom plik później za pomocą „./test.py ”, to właśnie otrzymasz.

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

Po kliknięciu przycisku w terminalu zostanie wyświetlone zdanie „Hello, World!”:

Pozwól, że wyjaśnię kod w szczegółowym wyjaśnieniu.

  1. #!/usr/bin/python: domyślna ścieżka dla interpretera Pythona (w większości przypadków wersja 2.7). Ta linia musi być pierwszą linią w każdym pliku Pythona.
  2. # -*- kodowanie: utf-8 -*-: Tutaj ustawiamy domyślne kodowanie pliku, UTF-8 jest najlepsze, jeśli chcesz obsługiwać języki inne niż angielski, zostaw tak .
  3. z gi.repository import Gtk: Tutaj importujemy bibliotekę GTK 3, aby użyć jej w naszym programie.
  4. Klasa ourwindow(Gtk.Window): Tutaj tworzymy nową klasę, która nazywa się „ourwindow ”, ustawiamy także typ obiektu klasy na „Gtk.Window ”.
  5. def __init__(self): Nic nowego, definiujemy tutaj główne komponenty okna.
  6. Gtk.Window.__init__(self, title=”Program My Hello World”): Używamy tej linii do ustawienia tytułu okna „Program My Hello World” na „nasze okno”, możesz to zmienić tytuł, jeśli chcesz.
  7. Gtk.Window.set_default_size(self, 400,325): Myślę, że tej linii nie trzeba wyjaśniać, tutaj ustawiamy domyślną szerokość i wysokość naszego okna.
  8. Gtk.Window.set_position(self, Gtk.WindowPosition.CENTER): Za pomocą tej linii będziemy mogli ustawić domyślną pozycję okna, w tym przypadku ustawiamy ją na środek korzystając z parametru „Gtk.WindowPosition.CENTER” jeśli chcesz, możesz zmienić go na „Gtk.WindowPosition.MOUSE ” aby otworzyć okno na pozycji wskaźnika myszy.
  9. button1=Gtk.Button(„Hello, World!”): Stworzyliśmy nowy Gtk.Button i nazwaliśmy go „button1 ”, domyślny tekst przycisku to „Hello, World! ”, jeśli chcesz, możesz utworzyć dowolny widget Gtk.
  10. button1.connect(„clicked”, self.whenbutton1_clicked): Tutaj łączymy sygnał „kliknięty” z akcją „whenbutton1_clicked”, tak że po kliknięciu przycisku akcja „whenbutton1_clicked” jest aktywowany.
  11. self.add(button1): Jeśli chcemy, aby nasze widżety Gtk pojawiały się, musimy dodać je do okna domyślnego, ta prosta linia dodaje widżet „button1” do okna, bardzo konieczne jest Zrób to.
  12. def kiedybutton1_clicked(self, przycisk): Teraz definiujemy tutaj akcję „whenbutton1_clicked ”, definiujemy, co się stanie po kliknięciu widżetu „button1 ”, przycisk „(self, przycisk ) ” jest ważny w celu określenia typu obiektu nadrzędnego sygnału.
  13. drukuj „Witaj, świecie!”: nie muszę tu więcej wyjaśniać.
  14. window=ourwindow(): Musimy utworzyć nową zmienną globalną i ustawić ją na klasę ourwindow(), abyśmy mogli ją później wywołać za pomocą biblioteki GTK+.
  15. window.connect(“delete-event”, Gtk.main_quit): Teraz łączymy sygnał “delete-event” z akcją “Gtk.main_quit”, jest to ważne w celu usunięcia wszystkie widżety po automatycznym zamknięciu okna programu.
  16. window.show_all(): Wyświetlanie okna.
  17. Gtk.main(): Uruchamianie biblioteki Gtk.

To wszystko, prawda? I bardzo funkcjonalny, jeśli chcemy stworzyć kilka dużych aplikacji. Aby uzyskać więcej informacji na temat tworzenia interfejsów GTK+ przy użyciu samego kodu, możesz odwiedzić oficjalną witrynę z dokumentacją pod adresem:

Poradniki Pythona GTK3

Sposób projektanta Glade

Tak jak mówiłem na początku artykułu, Glade to bardzo proste narzędzie do tworzenia interfejsów potrzebnych do naszych programów, cieszy się dużą popularnością wśród programistów i przy jego pomocy powstało wiele świetnych interfejsów aplikacji. Ten sposób nazywa się „szybkim tworzeniem aplikacji”.

Aby zacząć z niego korzystać, musisz zainstalować Glade w systemie Debian/Ubuntu/Mint:

sudo apt­-get install glade

W systemie RedHat/Fedora/CentOS uruchom:

yum install glade

Po pobraniu i zainstalowaniu programu, a także jego uruchomieniu, po lewej stronie zobaczysz dostępne widżety Gtk, kliknij widżet „okno”, aby utworzyć nowe okno.

Zauważysz, że utworzone zostało nowe, puste okno.

Możesz teraz dodać do niego kilka widżetów, na lewym pasku narzędzi kliknij widżet „przycisk”, a następnie kliknij puste okno, aby dodać przycisk do okna.

Zauważysz, że identyfikator przycisku to „przycisk1”. Teraz przejdź do zakładki Sygnały na prawym pasku narzędzi, wyszukaj sygnał „kliknięty” i wpisz „button1_clicked ” pod nim.

Teraz, gdy stworzyliśmy nasz GUI, wyeksportujmy go. Kliknij menu „Plik” i wybierz „Zapisz”, zapisz plik w swoim katalogu domowym pod nazwą „myprogram.glade” i Wyjście.

Teraz utwórz nowy plik „test.py” i wprowadź w nim następujący kod.

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

Zapisz plik, nadaj mu 755 uprawnień tak jak poprzednio i uruchom go za pomocą „./test.py” i to właśnie otrzymasz.

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

Kliknij przycisk, a zauważysz, że w terminalu wydrukowane zostało zdanie „Hello, World!”.

Wyjaśnijmy teraz nowe rzeczy:

  1. Obsługa klas: Tutaj tworzymy klasę o nazwie „Obsługa”, która będzie zawierać definicje akcji i sygnałów, które tworzymy dla GUI.
  2. builder=Gtk.Builder(): Stworzyliśmy nową zmienną globalną o nazwie „builder”, która jest widżetem Gtk.Builder, jest to ważne w celu zaimportowania pliku .glade.
  3. builder.add_from_file(„myprogram.glade”): Tutaj importujemy plik „myprogram.glade”, aby używać go jako domyślnego GUI dla naszego programu.
  4. builder.connect_signals(Handler()): Ta linia łączy plik .glade z klasą obsługi, dzięki czemu akcje i sygnały, które definiujemy w klasie „Handler” działają poprawnie po uruchomieniu programu .
  5. ournewbutton=builder.get_object(„button1”): Teraz importujemy obiekt „button1 ” z pliku .glade, przekazujemy go również do zmiennej globalnej „ournewbutton ”, aby go użyć później w naszym programie.
  6. ournewbutton.set_label („Hello, World!”): Użyliśmy metody „set.label ”, aby ustawić domyślny tekst przycisku na „Hello, World! " zdanie.
  7. window=builder.get_object(„window1”): Tutaj wywołaliśmy obiekt „window1 ” z pliku .glade, aby pokazać go później w programie.

I to wszystko! Udało Ci się stworzyć swój pierwszy program pod Linuksem!

Oczywiście jest dużo bardziej skomplikowanych rzeczy do zrobienia, aby stworzyć prawdziwą aplikację, która coś robi, dlatego polecam zajrzeć do dokumentacji GTK+ i API GObject pod adresem:

  1. Podręcznik referencyjny GTK+
  2. Dokumentacja API Pythona GObject
  3. Odniesienie do PyGObject

Czy tworzyłeś już jakąś aplikację na komputer z systemem Linux? Jakiego języka programowania i narzędzi użyto do tego? Co sądzisz o tworzeniu aplikacji przy użyciu Pythona i GTK 3?