Last modified: September 18, 2024

This article is written in: 🇵🇱

Tkinter - Tworzenie interfejsów graficznych

Tkinter jest standardowym modułem Pythona służącym do tworzenia interfejsów graficznych użytkownika (GUI). Dzięki niemu możemy szybko i efektywnie tworzyć aplikacje okienkowe, które są interaktywne i przyjazne dla użytkownika. W poniższych sekcjach omówimy szczegółowo, jak zainicjalizować okno główne, dodawać do niego elementy, układać widżety oraz obsługiwać zdarzenia.

Inicjalizacja okna głównego

Aby rozpocząć pracę z Tkinter, musimy najpierw zaimportować moduł i zainicjalizować główne okno aplikacji, które będzie kontenerem dla wszystkich innych widżetów.

import tkinter as tk

root = tk.Tk()
root.title("Moja aplikacja")  # Nadanie tytułu oknu
root.geometry("300x200")      # Ustawienie wymiarów okna
root.mainloop()

Dodawanie elementów do okna

Tkinter oferuje bogaty zestaw widżetów (elementów interfejsu), takich jak przyciski, etykiety, pola tekstowe czy pola wyboru. Po zainicjalizowaniu głównego okna możemy dodawać do niego te elementy, aby stworzyć interaktywny interfejs.

Przycisk

Przyciski są podstawowymi elementami interfejsu, które pozwalają użytkownikowi na wykonywanie określonych akcji.

def on_button_click():
    print("Kliknięto przycisk!")

button = tk.Button(root, text="Kliknij", command=on_button_click)
button.pack(pady=20)

Etykieta

Etykiety służą do wyświetlania tekstu lub obrazów w interfejsie.

label = tk.Label(root, text="To jest etykieta", font=("Arial", 14))
label.pack(pady=20)

Układanie i kompozycja widżetów

Aby interfejs był czytelny i intuicyjny, ważne jest odpowiednie rozmieszczenie widżetów w oknie. Tkinter oferuje kilka metod układania, które pozwalają na precyzyjną kontrolę nad położeniem elementów.

Główne metody układania

I. pack():

Przykład:

button.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

II. grid():

Przykład:

label.grid(row=0, column=0)
entry.grid(row=0, column=1)

III. place():

Przykład:

button.place(x=50, y=100)

Użycie ramek dla lepszej organizacji

Ramki (Frame) służą do grupowania widżetów, co ułatwia zarządzanie złożonymi układami.

Przykład użycia ramek:

import tkinter as tk

root = tk.Tk()

# Tworzenie ramki
frame = tk.Frame(root, bg="lightgray", bd=5, relief="ridge")
frame.pack(pady=20, padx=20)

button1 = tk.Button(frame, text="Przycisk 1")
button2 = tk.Button(frame, text="Przycisk 2")

# Umieszczanie przycisków w siatce wewnątrz ramki
button1.grid(row=0, column=0, padx=10)
button2.grid(row=0, column=1, padx=10)

root.mainloop()

Ramka jest kontenerem dla innych widżetów. Parametry:

Używamy metody grid() wewnątrz ramki, aby precyzyjnie ułożyć przyciski.

Zalety użycia ramek:

Wskazówki:

Obsługa zdarzeń

Interaktywność aplikacji zależy od jej zdolności do reagowania na zdarzenia generowane przez użytkownika.

Podstawowe zdarzenia

Kliknięcia myszy:

Ruch myszy:

Klawiatura:

Metoda bind()

Aby powiązać zdarzenie z funkcją obsługującą, używamy metody bind().

Przykład:

from tkinter import Tk, Button

def on_mouse_enter(event):
print("Myszka najechała na przycisk")

def on_mouse_leave(event):
print("Myszka opuściła przycisk")

root = Tk()
button = Button(root, text="Najedź na mnie!")
button.bind("<enter>", on_mouse_enter)
button.bind("<leave>", on_mouse_leave)
button.pack()
root.mainloop()

Funkcje obsługujące zdarzenia przyjmują jeden argument — obiekt event, który zawiera informacje o zdarzeniu (np. pozycja kursora, stan klawiszy modyfikujących).

Łączenie wielu zdarzeń

Możemy powiązać wiele zdarzeń z jednym widżetem lub jedną funkcję obsługującą z wieloma widżetami.

Przykład:

def on_key_press(event):
print(f"Naciśnięto klawisz: {event.char}")

root.bind("<key>", on_key_press)

Uwaga o dekoratorze @event_decorator

Dekorator @event_decorator nie jest częścią standardowej biblioteki Tkinter. Standardowo zdarzenia obsługujemy za pomocą metody bind(). Jeśli chcemy używać dekoratorów do obsługi zdarzeń, musimy zaimplementować własne rozwiązanie lub skorzystać z dodatkowych bibliotek.

Przykład własnego dekoratora:

def event_handler(event_name):
def decorator(func):
    def wrapper(event):
        return func(event)
    wrapper.__name__ = func.__name__
    wrapper.__doc__ = func.__doc__
    wrapper.event_name = event_name
    return wrapper
return decorator

class MyApp:
def __init__(self, root):
    self.button = tk.Button(root, text="Kliknij mnie")
    self.button.pack()
    self.bind_events()

def bind_events(self):
    for attr in dir(self):
        func = getattr(self, attr)
        if callable(func) and hasattr(func, 'event_name'):
            self.button.bind(func.event_name, func)

@event_handler("<button-1>")
def on_click(self, event):
    print("Przycisk został kliknięty")

Uwaga: Takie rozwiązanie wymaga zaawansowanej znajomości Pythona i może nie być konieczne w prostych aplikacjach.

Zakończenie pracy

Po skonfigurowaniu interfejsu i dodaniu wszystkich niezbędnych elementów, uruchamiamy pętlę główną aplikacji, która utrzymuje interfejs aktywnym i reagującym na zdarzenia.

root.mainloop()

Możemy zamknąć aplikację, wywołując metodę root.destroy(), np. w odpowiedzi na zdarzenie.

def close_app():
  root.destroy()

button_exit = tk.Button(root, text="Zamknij", command=close_app)
button_exit.pack()

Spis Treści

    Tkinter - Tworzenie interfejsów graficznych
    1. Inicjalizacja okna głównego
    2. Dodawanie elementów do okna
      1. Przycisk
      2. Etykieta
    3. Układanie i kompozycja widżetów
      1. Główne metody układania
      2. Użycie ramek dla lepszej organizacji
    4. Obsługa zdarzeń
      1. Podstawowe zdarzenia
      2. Metoda bind()
      3. Łączenie wielu zdarzeń
      4. Uwaga o dekoratorze @event_decorator
    5. Zakończenie pracy