Obsah
1. Tvorba grafického uživatelského rozhraní v Pythonu s využitím knihovny Kivy
3. Vytvoření nového projektu závislého na knihovně Kivy
4. Výsledný projektový soubor pyproject.toml
7. Aplikace tvořená jediným oknem s nápisem
8. Specifikace základních vlastností okna aplikace
10. Změna stylů textových návěští v jazyku Kv
11. Další ukázka modifikace stylu vykreslování
12. Okna a dialogy s ovládacími prvky uloženými do kontejnerů
13. Dialog pro přihlášení (login) do aplikace
14. Specifikace velikosti okna s přihlašovacím dialogem
15. Konfigurace vlastností kontejneru (padding a spacing)
16. Reakce na událost typu on start
17. Popis GUI přihlašovacího dialogu v jazyku Kv
18. Inicializace přihlašovacího dialogu z Pythonu
19. Repositář s demonstračními příklady
1. Tvorba grafického uživatelského rozhraní v Pythonu s využitím knihovny Kivy
V předchozích částech seriálu o tvorbě aplikací s grafickým uživatelským rozhraním v Pythonu jsme si popsali již několik knihoven a frameworků určených pro tvorbu GUI. Nejprve jsme se zabývali knihovnou nazvanou Tkinter (ta je v Pythonu standardem pro tvorbu GUI, takže většinou odpadají problémy s její instalací, protože je součástí standardní instalace Pythonu) a následně pak i knihovnu nazvanou appJar, která je na Tkinteru založena a umožňuje poměrně snadnou a rychlou tvorbu aplikací s jednodušším grafickým uživatelským rozhraním (ovšem pro složitější aplikace se již příliš nehodí).
Obrázek 1: Knihovnu Tkinter používá například populární vývojové prostředí Thonny.
V navazujících článcích jsme se zabývali i aplikacemi psanými v Pythonu, které pro grafické uživatelské rozhraní (ale i pro další oblasti) používají vazbu na populární framework Qt. Přitom existuje hned několik možností, jak propojit Python a framework Qt. Základ tvoří knihovny PyQt (s duální licencí GNU GPL v3 a Riverbank Commercial License) a PySide (s licencí LGPL) pro Qt ≤ 4.8, další možností je PySide2 určená pro Qt 5.x a PySide6 pro verzi 6.x (číslování je poněkud divné, ale od verze 6 alespoň logické). Jedná se s velkou pravděpodobností o nejpropracovanější technologii určenou pro klasické GUI typu WIMP (viz další text).
Obrázek 2: GUI s kreslicí plochou; založeno na PySide.
Ovšem popsali jsme si i další knihovny, například PyGTK a v neposlední řadě taktéž knihovnu nazvanou PySimpleGUI. Všechny tyto knihovny podporují „klasické“ grafické uživatelské rozhraní založená na konceptu WIMP (Window, Icon, Menu, Pointer), což již nemusí být v dnešní době zařízení s dotykovým displejem (a vůbec alternativním způsobem ovládání) ideální technologie.
Obrázek 3: GUI s kreslicí plochou; založeno na PySide.
2. Knihovna Kivy
Ovšem vývoj knihoven a frameworků určených pro tvorbu grafického uživatelského rozhraní se v posledních několika letech značně posunul a to v několika různých směrech: podporou více monitorů, většího rozlišení se škálováním GUI, dotykového ovládání, GUI pro mobilní zařízení a akcelerovaný výstup (mnohdy využívající vektorovou grafiku). Poměrně často se nyní můžeme setkat s frameworkem Kivy.
Programátoři, co nesnášíte BS, ale máte rádi business! Y Soft je česká firma s globálním dopadem (100+ zemí, 1M+ uživatelů a >100% meziroční růst). R&D úplně bez manažerů (130 developerů). Otevíráme 30 pozic pro Cloud a AI: Praha/Brno/Ostrava/remote. Zodpovědnost ano, mikro-management ne. Pojď někam, kde můžeš věci změnit.
Jedná se vlastně o ucelenou platformu určenou především pro tvorbu aplikací pro mobilní platformy, tedy pro Android a iOS. Ve skutečnosti je ale možné Kivy použít i na běžných desktopech s operačními systémy Mac OS X, Microsoft Windows a samozřejmě (a to v neposlední řadě) i s Linuxem. V tomto případě však nebudou k dispozici všechny možnosti ovládání, především rozhraní multitouch určené primárně pro dotykové obrazovky.
Obrázek 4: Kivy se soustředí spíše na tvorbu GUI pro mobilní telefony a tablety s multitouch ovládáním. Nicméně lze použít i pro tvorbu desktopových aplikací.
Už z této poznámky je asi zřejmé, že se Kivy bude v mnoha ohledech odlišovat od všech výše uvedených knihoven a frameworků, které jsou určeny především pro běžné desktopy ovládané kombinací klávesnice a myši. Kivy však jde ještě dále, protože programátorům nabízí prakticky všechny technologie, které jsou pro moderní GUI aplikace vyžadovány. A protože se jedná o knihovnu určenou především pro mobilní zařízení, je podporována i OpenGL ES (typicky verze 2), takže vykreslování ovládacích prvků je akcelerováno. Navíc je možné pro deklaraci GUI použít speciální jazyk nazvaný Kv, který zde hraje podobnou roli jako například QML (Qt Modeling Language) v případě frameworku Qt.
Obrázek 5: Použití knihovny PySimpleGUI.
Dnes si na několika demonstračních příkladech ukážeme samotné základy, na kterých je Kivy postavena.
Obrázek 6: Pygubu je editor grafického uživatelského rozhraní (pochopitelně pro Python).
3. Vytvoření nového projektu závislého na knihovně Kivy
Tento článek je zaměřen na praktické ukázky použití knihovny Kivy. Musíme si tedy připravit projekt v Pythonu a následně do něj knihovnu Kivy přidat formou přímé závislosti (dependency). Pro vytvoření projektu použijeme buď nástroj PDM – viz též PDM: moderní správce balíčků a virtuálních prostředí Pythonu nebo (což je v současnosti výhodnější) nástroj uv:
$ uv init Initialized project `kivy-projects`
Projekt bude vytvořen v novém (původně prázdném) adresáři a jeho projektový soubor pyproject.toml může vypadat následovně:
[project]
name = "kivy-projects"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.13"
dependencies = [
"kivy[base]>=2.3.1",
]
Příkazem pdm add nebo uv add do projektu přidáme knihovnu kivy:
$ uv add "kivy[base]" Using CPython 3.13.9 interpreter at: /usr/bin/python3.13 Creating virtual environment at: .venv Resolved 17 packages in 637ms Prepared 11 packages in 3.47s ░░░░░░░░░░░░░░░░░░░░ [0/11] Installing wheels... Installed 11 packages in 79ms + certifi==2025.11.12 + charset-normalizer==3.4.4 + docutils==0.22.3 + filetype==1.2.0 + idna==3.11 + kivy==2.3.1 + kivy-garden==0.1.5 + pillow==10.4.0 + pygments==2.19.2 + requests==2.32.5 + urllib3==2.6.2
4. Výsledný projektový soubor pyproject.toml
V adresáři s projektem by po zadání příkazů uvedených v předchozí kapitole měl vzniknout projektový soubor nazvaný pyproject.toml s následujícím obsahem:
[project]
name = "kivy-projects"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.13"
dependencies = [
"kivy[base]>=2.3.1",
]
Kromě toho vznikne i soubor uv.lock s přesnou specifikací verzí přímých i nepřímých závislostí.
5. Widgety (ovládací prvky)
Při tvorbě GUI se setkáme se třemi základními pojmy:
- Ovládací prvky (widgety) s viditelnou reprezentací
- Kontejnery (někdy též správci geometrie)
- Události vznikající v několika zdrojích, na které může GUI aplikace nějakým způsobem reagovat
Základem prakticky všech v současnosti používaných grafických uživatelských rozhraní jsou takzvané widgety, které jsou někdy poněkud nepřesně označovány také jako komponenty. Z pohledu uživatele aplikací s grafickým uživatelským rozhraním se jedná o grafické prvky zobrazené na obrazovce, které mají předem známé chování a předvídatelnou funkci. V mnoha případech je chování widgetů standardizováno či alespoň doporučováno – viz například doporučení pro (dnes již notně zastaralý) Motif, Microsoft Windows, Mac OS a v neposlední řadě také doporučení pro GNOME a KDE. Velká část widgetů se snaží svým vzhledem do jisté míry reflektovat objekty z reálného světa (tlačítka, „teploměry“, přepínače programů, objekty známé z papírových formulářů apod.). Z pohledu programátora je naproti tomu widget objektem, kterému lze nastavit určitý stav a který reaguje na události, které při své práci generuje uživatel (přesouvání objektů na obrazovce, stlačování obrazů tlačítek pomocí myši či stylusu, psaní textu, gesta na dotykové obrazovce atd.).
6. Kontejnery
Samotné widgety nejsou na obrazovce prakticky nikdy zcela osamocené, ostatně většina knihoven pro GUI by samostatný widget nedokázala zobrazit. Ve skutečnosti se téměř vždy nachází v nějakém okně, dialogu či dalším nadřazeném widgetu. Programátoři grafických uživatelských rozhraní se často setkají s pojmem kontejner. Jedná se o komponentu, na kterou lze vkládat různé widgety a mnohdy i další kontejnery. Obecně tak interně vzniká stromová datová struktura jejíž kořen je představován plochou na obrazovce, na které jsou umístěna okna aplikací (dnes je ovšem i samotná plocha obrazovky součástí větší virtuální plochy zobrazované obecně na více monitorech). V těchto oknech se dále nachází kontejnery a widgety. V mnoha grafických uživatelských rozhraních přitom mohou být vybrané widgety (zdaleka ne však všechny) současně i kontejnery. Kontejnery kromě jiného řeší i rozmístění widgetů na své ploše.
Způsobů pro rozmisťování widgetů do kontejnerů existuje více. Základní dělení je na kontejnery, kde jsou widgety umisťovány absolutně (do této kategorie patří WinAPI, MFC, OWL a VCL) a naopak kontejnery, které widgety většinou umisťují podle své velikosti a vzájemných vztahů (zde se nachází javovské AWT, Swing, GTK, Qt, Tk/Tkinter, Kivy a mnoho dalších). My dnes použijeme pouze jeden kontejner nazvaný GridLayout, ale existují i další kontejnery.
7. Aplikace tvořená jediným oknem s nápisem
Nyní si ukažme, jak může vypadat kód (prakticky) nejjednodušší aplikace s grafickým uživatelským rozhraním vytvořená s využitím knihovny Kivy. Aplikace je tvořena jedinou třídou odvozenou od třídy kivy.app.App s metodou build. V této metodě (prozatím) pouze vytváříme widget typu „textové návěští“, který se vloží doprostřed okna:
from kivy.app import App
from kivy.uix.label import Label
class TestApp(App):
def build(self):
# okno bude obsahovat jediné textové návěští
return Label(text="Hello World")
TestApp().run()
Po spuštění tohoto skriptu by se mělo zobrazit následující okno. Způsob vykreslení jeho titulku a okrajů však může být odlišný:
Obrázek 7: Okno s jediným textovým návěštím.
Aplikace postupně vypisuje i logovací informace do terminálu (což lze v případě potřeby zakázat):
[INFO ] [Logger ] Record log in /home/ptisnovs/.kivy/logs/kivy_25-12-16_32.txt [INFO ] [Kivy ] v2.3.1 [INFO ] [Kivy ] Installed at "/tmp/ramdisk/kivy-projects/.venv/lib64/python3.13/site-packages/kivy/__init__.py" [INFO ] [Python ] v3.13.9 (main, Oct 14 2025, 00:00:00) [GCC 15.2.1 20250808 (Red Hat 15.2.1-1)] [INFO ] [Python ] Interpreter at "/tmp/ramdisk/kivy-projects/.venv/bin/python3" [INFO ] [Logger ] Purge log fired. Processing... [INFO ] [Logger ] Purge finished! [INFO ] [Factory ] 195 symbols loaded [INFO ] [Image ] Providers: img_tex, img_dds, img_sdl2, img_pil (img_ffpyplayer ignored) [INFO ] [Text ] Provider: sdl2 [INFO ] [Window ] Provider: sdl2 [INFO ] [GL ] Using the "OpenGL" graphics system ... ... ... [INFO ] [GL ] Texture max units <32> [INFO ] [Window ] auto add sdl2 input provider [INFO ] [Window ] virtual keyboard not allowed, single mode, not docked [INFO ] [ProbeSysfs ] device match: /dev/input/event6 [INFO ] [MTD ] Read event from [INFO ] [Base ] Start application main loop [INFO ] [GL ] NPOT texture support is available
8. Specifikace základních vlastností okna aplikace
Samotné okno má, podobně jako jednotlivé ovládací prvky (widgety) mnoho vlastností, které je možné modifikovat. Ovšem záleží na tom, ve kterém okamžiku tato modifikace nastane. V případě, že se mají změnit vlastnosti okna ještě před jeho vykreslením, můžeme tento kód umístit do metody nazvané on_start, která je popsána v nápovědě ke třídě App:
class App(kivy._event.EventDispatcher) | App(**kwargs) | | Application class, see module documentation for more information. | | :Events: | `on_start`: | Fired when the application is being started (before the | :func:`~kivy.base.runTouchApp` call. | `on_stop`: | Fired when the application stops. | `on_pause`: | Fired when the application is paused by the OS. | `on_resume`: | Fired when the application is resumed from pause by the OS. Beware: | you have no guarantee that this event will be fired after the | `on_pause` event has been called.
Jak název této metody naznačuje, bude zavolána ve chvíli, kdy je aplikace (resp. přesněji řečeno její okno) inicializována:
from kivy.app import App
from kivy.uix.label import Label
from kivy.core.window import Window
class TestApp(App):
def build(self):
# okno bude obsahovat jediné textové návěští
return Label(text="Hello World")
def on_start(self):
# specifikace barvy pozadí v barvovém prostoru RGBA
Window.clearcolor = (0.0, 0.5, 0.5, 1.0)
TestApp().run()
Výsledné okno nyní bude mít odlišnou barvu pozadí:
Obrázek 8: Okno s jediným textovým návěštím a explicitně nastaveným pozadím.
9. Popis GUI v jazyku Kv
Jednou z největších předností frameworku Kivy (v porovnání s Tkinterem i dalšími GUI knihovnami) je podpora pro popis grafického uživatelského rozhraní (tedy jednotlivých oken resp. dialogů) ve specializovaném a snadno pochopitelném jazyku (DSL). To navíc umožňuje oddělit samotné GUI od programové logiky (separation of concerns), ale taktéž je možné, aby vznikaly různé vizuální editory GUI atd. Tento koncept pochopitelně není nový, protože se s ním vývojáři mohli setkat už kdysi v Delphi nebo Visual Basicu (a současně je na tomto konceptu postaven QML a vlastně i HTML+CSS).
Podívejme se, jak může popis GUI vypadat. Okno naší aplikace má obsahovat jen jediné návěští, které lze definovat takto:
Label:
text:
"Hello world"
font_size: "64pt"
Načtení popisu GUI ze souboru TestApp.kv a následné spuštění aplikace zajišťuje skript:
from kivy.app import App
from kivy.lang import Builder
class TestApp(App):
def build(self):
builder = Builder.load_file("TestApp.kv")
return builder
application = TestApp()
application.run()
Po spuštění skriptu se zobrazí okno, které bude mít následující obsah:
Obrázek 9: Okno s obsahem, který je popsán v jazyku Kv.
10. Změna stylů textových návěští v jazyku Kv
Díky tomu, že je GUI specifikováno v samostatném souboru, je možné snadno (bez nutnosti volání metod z Pythonu nebo nastavování atributů) modifikovat popis GUI pouhou editací souboru Kv. Příkladem může být změna fontu prvního slova za tučnou variantu a barvy druhého slova za světle červenou. Povšimněte si, že Kv je sice odlišné od HTML/CSS, ale používají se zde podobně pojmenované značky, i když s využitím odlišné syntaxe:
Label:
text:
"[b]Hello[/b] [color=ff0099]world[/color]"
markup: True
font_size: "64pt"
Skript, který celou aplikaci inicializuje, se změní jen nepatrně – načítá se odlišný soubor se specifikací GUI:
from kivy.app import App
from kivy.lang import Builder
class TestApp(App):
def build(self):
builder = Builder.load_file("TestApp2.kv")
return builder
application = TestApp()
application.run()
Výsledek by měl vypadat takto – každé ze slov bude mít nastavený odlišný vizuální styl:
Obrázek 10: Okno s obsahem, který je popsán v jazyku Kv.
11. Další ukázka modifikace stylu vykreslování
Nastavovat je možné i další vizuální atributy zobrazeného textového návěští (nebo i dalších widgetů). Proveďme tedy ještě jednu úpravu – každý znak nápisu bude mít odlišnou velikost (resp. přesněji řečeno jeho font bude mít odlišnou velikost). V tomto případě pro každý ze znaků specifikujeme parametr size.
Tento demonstrační příklad uvádím zejména z toho důvodu, aby bylo zřejmé, jakým způsobem se zapisuje text, který je vhodné v popisu GUI rozdělit na více řádků – je nutné jeho uzavření do běžných kulatých závorek:
Label:
text:
("[size=60pt]H[/size]"
"[size=56pt]e[/size]"
"[size=52pt]l[/size]"
"[size=48pt]l[/size]"
"[size=44pt]o[/size]"
"[size=40pt] [/size]"
"[size=36pt]w[/size]"
"[size=32pt]o[/size]"
"[size=28pt]r[/size]"
"[size=24pt]l[/size]"
"[size=20pt]d[/size]")
markup: True
font_size: "64pt"
Skript pro načtení popisu grafického uživatelského rozhraní:
from kivy.app import App
from kivy.lang import Builder
class TestApp(App):
def build(self):
builder = Builder.load_file("TestApp3.kv")
return builder
application = TestApp()
application.run()
Obrázek 11: Okno s obsahem, který je popsán v jazyku Kv.
12. Okna a dialogy s ovládacími prvky uloženými do kontejnerů
V šesté kapitole jsme se seznámili s konceptem takzvaných kontejnerů. Těch v knihovně Kivy existuje několik. Dnes se ovšem v demonstračních příkladech seznámíme jen s jediným z nich; ostatní typy kontejnerů budou popsány v navazujícím článku. Kontejner, který bude použit dnes, se jmenuje GridLayout, což je přiléhavý název, protože umožňuje widgety vkládat do pomyslné (neviditelné) mřížky, která leží na ploše okna. Tomuto kontejneru je nutné předat minimálně jeden parametr – a tím je počet sloupců mřížky.
Popis celého okna resp. dialogu bude v tomto případě umístěn do třídy odvozené od třídy GridLayout:
class LoginScreen(GridLayout):
...
...
...
Jak jsme si již řekli na začátku této kapitoly, je nutné specifikovat minimálně počet sloupců mřížky. To je snadné, protože postačuje modifikovat atribut cols:
def __init__(self, **var_args):
super(LoginScreen, self).__init__(**var_args)
self.cols = 2
Posléze již můžeme do okna/dialogu vkládat jednotlivé widgety. Ty budou postupně umisťovány na jeden řádek a pokud se překročí počet sloupců, bude další widget umístěný na následujícím řádku pomyslné (neviditelné) mřížky:
self.add_widget(Label(text="widget1"))
self.add_widget(Label(text="widget2"))
self.add_widget(Label(text="widget3"))
...
...
...
13. Dialog pro přihlášení (login) do aplikace
V dalším demonstračním příkladu je ukázána jednoduchá aplikace, která obsahuje jediné okno (formulář) určené pro zadání údajů nutných pro přihlášení do aplikace. Dialog obsahuje trojici textových návěští, trojici vstupních textových polí (ty si podrobněji popíšeme příště) a taktéž tlačítko (i to si popíšeme příště). Dialog má nastavenou mřížku se dvěma sloupci, což nám snadno umožňuje umístit textové návěští vedle vstupního textového pole:
from kivy.app import App
from kivy.core.window import Window
from kivy.uix.gridlayout import GridLayout
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
class LoginScreen(GridLayout):
def __init__(self, **var_args):
super(LoginScreen, self).__init__(**var_args)
self.cols = 2
# prvni radek mrizky
self.add_widget(Label(text="Name"))
self.username = TextInput(multiline=False)
self.add_widget(self.username)
# druhy radek mrizky
self.add_widget(Label(text="Password"))
self.password1 = TextInput(password=True, multiline=False)
self.add_widget(self.password1)
# treti radek mrizky
self.add_widget(Label(text="Comfirm password"))
self.password2 = TextInput(password=True, multiline=False)
self.add_widget(self.password2)
# ctvrty radek mrizky
self.button = Button(text="Login")
self.add_widget(self.button)
class Application(App):
def build(self):
return LoginScreen()
if __name__ == "__main__":
Application().run()
Po spuštění skriptu by se měl zobrazit tento dialog:
Obrázek 12: První varianta dialogu pro přihlášení do aplikace.
14. Specifikace velikosti okna s přihlašovacím dialogem
Dialog vytvořený skriptem uvedeným v předchozí kapitole ve skutečnosti není moc pěkný. Zejména by bylo vhodné zmenšit celkovou velikost okna s dialogem. To je v Kivy možné, i když možná poněkud krkolomným způsobem – nastavením atributu Window.size při inicializaci aplikace. Předat je nutné dvojici (šířka, výška):
class Application(App):
def build(self):
Window.size = (400, 120)
return LoginScreen()
Nyní bude okno skutečně menší, čemuž se automaticky přizpůsobí i jednotlivé v něm umístěné widgety:
Obrázek 13: Druhá varianta dialogu pro přihlášení do aplikace.
Upravený skript vypadá následovně:
from kivy.app import App
from kivy.core.window import Window
from kivy.uix.gridlayout import GridLayout
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
class LoginScreen(GridLayout):
def __init__(self, **var_args):
super(LoginScreen, self).__init__(**var_args)
self.cols = 2
# prvni radek mrizky
self.add_widget(Label(text="Name"))
self.username = TextInput(multiline=False)
self.add_widget(self.username)
# druhy radek mrizky
self.add_widget(Label(text="Password"))
self.password1 = TextInput(password=True, multiline=False)
self.add_widget(self.password1)
# treti radek mrizky
self.add_widget(Label(text="Comfirm password"))
self.password2 = TextInput(password=True, multiline=False)
self.add_widget(self.password2)
# ctvrty radek mrizky
self.button = Button(text="Login")
self.add_widget(self.button)
class Application(App):
def build(self):
Window.size = (400, 120)
return LoginScreen()
if __name__ == "__main__":
Application().run()
15. Konfigurace vlastností kontejneru (padding a spacing)
Náš dialog byl sice po vizuální stránce skutečně vylepšen, ovšem ukazuje se jeho další nevýhoda – jednotlivé widgety jsou na sebe příliš „nalepeny“ (tj. jsou zmenšeny přesně tak, aby se vešly do buněk neviditelné mřížky). I to je však možné napravit, a to konkrétně nastavením atributů padding a spacing. Těmi je možné ovlivnit šířku a výšku okrajů okna a taktéž mezery mezi buňkami (a tedy i mezery mezi widgety). Pokusme se například zvětšit tyto mezery na deset délkových jednotek (což mohou být při výchozím nastavení pixely):
def __init__(self, **var_args):
super(LoginScreen, self).__init__(**var_args)
self.cols = 2
self.padding = 10
self.spacing = 10
Výsledek již vypadá poněkud lépe:
Obrázek 14: Třetí varianta dialogu pro přihlášení do aplikace.
Opět si pro úplnost uveďme celý skript, po jehož spuštění se vykreslí dialog z obrázku číslo 14:
from kivy.app import App
from kivy.core.window import Window
from kivy.uix.gridlayout import GridLayout
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
class LoginScreen(GridLayout):
def __init__(self, **var_args):
super(LoginScreen, self).__init__(**var_args)
self.cols = 2
self.padding = 10
self.spacing = 10
# prvni radek mrizky
self.add_widget(Label(text="Name"))
self.username = TextInput(multiline=False)
self.add_widget(self.username)
# druhy radek mrizky
self.add_widget(Label(text="Password"))
self.password1 = TextInput(password=True, multiline=False)
self.add_widget(self.password1)
# treti radek mrizky
self.add_widget(Label(text="Comfirm password"))
self.password2 = TextInput(password=True, multiline=False)
self.add_widget(self.password2)
# ctvrty radek mrizky
self.button = Button(text="Login")
self.add_widget(self.button)
class Application(App):
def build(self):
Window.size = (400, 180)
return LoginScreen()
if __name__ == "__main__":
Application().run()
16. Reakce na událost typu on start
Vraťme se ještě na chvíli ke kódu, který nastavil velikost formuláře. Prozatím jsme změnu velikosti realizovali přímo v metodě build, tedy následujícím způsobem:
class Application(App):
def build(self):
Window.size = (400, 180)
return LoginScreen()
To je sice možné řešení, ale výhodnější je změnit velikost okna v metodě (callback metodě) on_start. Tato metoda je zavolána automaticky při inicializaci aplikace:
class Application(App):
def build(self):
return LoginScreen()
def on_start(self):
Window.size = (400, 180)
Výsledkem bude stále stejný dialog:
Obrázek 15: Čtvrtá varianta dialogu pro přihlášení do aplikace.
Opět si (pro úplnost) uveďme celý skript tvořící tento demonstrační příklad:
from kivy.app import App
from kivy.core.window import Window
from kivy.uix.gridlayout import GridLayout
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
class LoginScreen(GridLayout):
def __init__(self, **var_args):
super(LoginScreen, self).__init__(**var_args)
self.cols = 2
self.padding = 10
self.spacing = 10
# prvni radek mrizky
self.add_widget(Label(text="Name"))
self.username = TextInput(multiline=False)
self.add_widget(self.username)
# druhy radek mrizky
self.add_widget(Label(text="Password"))
self.password1 = TextInput(password=True, multiline=False)
self.add_widget(self.password1)
# treti radek mrizky
self.add_widget(Label(text="Comfirm password"))
self.password2 = TextInput(password=True, multiline=False)
self.add_widget(self.password2)
# ctvrty radek mrizky
self.button = Button(text="Login")
self.add_widget(self.button)
class Application(App):
def build(self):
return LoginScreen()
def on_start(self):
Window.size = (400, 180)
if __name__ == "__main__":
Application().run()
17. Popis GUI přihlašovacího dialogu v jazyku Kv
V deváté kapitole jsme si řekli, že knihovna Kivy podporuje definici celého GUI okna či dialogu v jazyce Kv, díky čemuž je možné oddělit popis GUI od vlastního programového kódu. Ukažme si tedy, jak by mohla vypadat definice GUI pro náš přihlašovací dialog. Není to nic složitého – specifikujeme typ kontejneru, jeho atributy (okraje a počet sloupců) a poté již můžeme vkládat jednotlivé widgety:
GridLayout:
id: login_layout
padding: [10, 10, 10, 10]
spacing: 10
cols:2
Label:
text: "Name"
font_size: 18
TextInput:
font_size: 18
multiline:False
Label:
text: "Password"
font_size: 18
TextInput:
font_size: 18
multiline:False
password:True
Label:
text: "Confirm password"
font_size: 18
TextInput:
font_size: 18
multiline:False
password:True
Button:
text: "Login"
font_size: "18sp"
size: 250,100
18. Inicializace přihlašovacího dialogu z Pythonu
Vzhledem k tomu, že již máme celý popis dialogu, který se má zobrazit, bude Pythonovský skript ve skutečnosti velmi krátký. Pouze v něm nadefinujeme třídu představující celou aplikaci a v metodě build načteme popis formuláře uvedený v předchozí kapitole. V metodě on_start, kterou již taktéž známe, nastavíme celkovou velikost formuláře, resp. přesněji řečeno okna s formulářem:
from kivy.app import App
from kivy.lang import Builder
from kivy.core.window import Window
class Application(App):
def build(self):
builder = Builder.load_file("login_form_5.kv")
return builder
def on_start(self):
Window.size = (400, 180)
if __name__ == "__main__":
Application().run()
Výsledný formulář by měl vypadat následovně:
Obrázek 16: Pátá varianta dialogu pro přihlášení do aplikace.
19. Repositář s demonstračními příklady
Demonstrační příklady, s nimiž jsme se dnes seznámili a které jsou určeny pro Python 3.11 (a libovolnou vyšší verzi Pythonu) a knihovnu Kivy, jsou dostupné, jak je zvykem, na GitHubu. V tabulce níže jsou uvedeny odkazy na jednotlivé zdrojové kódy i na definice formulářů:
20. Odkazy na Internetu
- Welcome to KivyMD’s documentation!
https://kivymd.readthedocs.io/en/latest/ - Kivy Tutorial
https://www.geeksforgeeks.org/python/kivy-tutorial/ - Stránky projektu Kivy
https://kivy.org/#home - Two Ways To Change Background Colors – Python Kivy GUI Tutorial
https://kivycoder.com/two-ways-to-change-background-colors-python-kivy-gui-tutorial-11/ - 5 Best Ways to Adjust Window Size in Kivy with Python
https://blog.finxter.com/5-best-ways-to-adjust-window-size-in-kivy-with-python/ - Python | Make a simple window using kivy
https://www.geeksforgeeks.org/python/python-make-a-simple-window-using-kivy/ - Python | Ellipse (different polygons) in Kivy
https://www.geeksforgeeks.org/python/python-ellipse-different-polygons-in-kivy/ - Getting Started » Kv Design Language
https://kivy.org/doc/stable/gettingstarted/rules.html - Python | Kivy .kv File
https://www.geeksforgeeks.org/python/python-kivy-kv-file/ - Kivy na GitHubu
https://github.com/kivy/kivy - PySimpleGUI
https://www.pysimplegui.org/en/latest/ - DearPyGui na GitHubu
https://github.com/hoffstadt/DearPyGui - PySimpleGUI Tutorial
https://www.tutorialspoint.com/pysimplegui/index.htm - PySimpleGUI – Canvas Element
https://www.tutorialspoint.com/pysimplegui/pysimplegui_canvas_element.htm - Dokumentace ke knihovně PySimpleGUI
https://www.pysimplegui.org/en/latest/ - Dokumentace ke knihovně DearPyGui
https://dearpygui.readthedocs.io/en/latest/index.html# - The Hitchhiker's Guide to Pyhton: GUI Applications
http://docs.python-guide.org/en/latest/scenarios/gui/ - 7 Top Python GUI Frameworks for 2017
http://insights.dice.com/2014/11/26/5-top-python-guis-for-2015/ - Stránky projektu wxPython
https://wxpython.org/ - wxPython Project Phoenix (na GitHubu)
https://github.com/wxWidgets/Phoenix/blob/wxPython-4.0.3/README.rst - wxPython API Documentation
https://docs.wxpython.org/index.html - wxWidgets
https://wxwidgets.org/ - wxPython 4.0.3 na PyPi
https://pypi.org/project/wxPython/4.0.3/ - wxGlade – a GUI builder for wxWidgets
http://wxglade.sourceforge.net/ - Repositář projektu wxGlade
https://github.com/wxGlade/wxGlade/ - wxGlade’s documentation
http://wxglade.sourceforge.net/docs/index.html - Graphical User Interfaces (GUI)
https://pythonspot.com/gui/ - wxPyWiki
https://wiki.wxpython.org/FrontPage - Getting started with wxPython
https://wiki.wxpython.org/Getting%20Started#A_First_Application:_.22Hello.2C_World.22 - wxPython GUI tutorial
https://pythonspot.com/wxpython-gui-tutorial/ - wxPython tutorial
http://zetcode.com/wxpython/ - Build wxPython On Raspberry Pi
https://wiki.wxpython.org/BuildWxPythonOnRaspberryPi - wxPython History
https://wxpython.org/pages/history/index.html - Installing wxPython 4.0 (Project Phoenix) on Fedora 27
https://blog.wizardsoftheweb.pro/installing-wxpython-on-fedora/ - Category:Software that uses wxWidgets
https://en.wikipedia.org/wiki/Category:Software_that_uses_wxWidgets - Hra Breakout napísaná v Tkinteri
https://www.root.cz/clanky/hra-breakout-napisana-v-Tkinteri/ - GUI Programming in Python
https://wiki.python.org/moin/GuiProgramming - Cameron Laird's personal notes on Python GUIs
http://phaseit.net/claird/comp.lang.python/python_GUI.html - Python GUI development
http://pythoncentral.io/introduction-python-gui-development/ - Hand Coded GUI Versus Qt Designer GUI
https://stackoverflow.com/questions/387092/hand-coded-gui-versus-qt-designer-gui - Qt Creator Manual
http://doc.qt.io/qtcreator/ - Qt Designer Manual
http://doc.qt.io/qt-5/qtdesigner-manual.html - Qt Creator (Wikipedia)
https://en.wikipedia.org/wiki/Qt_Creator - QIODevice
https://pyside.github.io/docs/pyside/PySide/QtCore/QIODevice.html#PySide.QtCore.QIODevice - QFile
https://pyside.github.io/docs/pyside/PySide/QtCore/QFile.html#PySide.QtCore.QFile - QUiLoader
https://pyside.github.io/docs/pyside/PySide/QtUiTools/QUiLoader.html#PySide.QtUiTools.PySide.QtUiTools.QUiLoader.load - QSvgWidget
https://pyside.github.io/docs/pyside/PySide/QtSvg/QSvgWidget.html - QByteArray
https://pyside.github.io/docs/pyside/PySide/QtCore/QByteArray.html - Differences Between PySide and PyQt
https://wiki.qt.io/Differences_Between_PySide_and_PyQt - PySide 1.2.1 tutorials
https://pyside.github.io/docs/pyside/tutorials/index.html - PySide tutorial
http://zetcode.com/gui/pysidetutorial/ - Drawing in PySide
http://zetcode.com/gui/pysidetutorial/drawing/ - Qt Core
https://pyside.github.io/docs/pyside/PySide/QtCore/Qt.html - Signals & Slots
http://doc.qt.io/qt-4.8/signalsandslots.html - Signals and Slots in PySide
http://wiki.qt.io/Signals_and_Slots_in_PySide - Intro to PySide/PyQt: Basic Widgets and Hello, World!
http://www.pythoncentral.io/intro-to-pysidepyqt-basic-widgets-and-hello-world/ - Leo editor
http://leoeditor.com/ - IPython Qt Console aneb vylepšený pseudoterminál
https://mojefedora.cz/integrovana-vyvojova-prostredi-ve-fedore-ipython-a-ipython-notebook/#k06 - Python GUI development
http://pythoncentral.io/introduction-python-gui-development/ - Graphic User Interface FAQ
https://docs.python.org/2/faq/gui.html#graphic-user-interface-faq - Tkinter
https://wiki.python.org/moin/Tkinter - Tkinter 8.5 reference: a GUI for Python
http://infohost.nmt.edu/tcc/help/pubs/Tkinter/web/index.html - Tkinter (Wikipedia)
https://en.wikipedia.org/wiki/Tkinter - appJar
http://appjar.info/ - appJar (Wikipedia)
https://en.wikipedia.org/wiki/AppJar - appJar na Pythonhosted
http://pythonhosted.org/appJar/ - appJar widgets
http://appjar.info/pythonWidgets/ - Stránky projektu PyGTK
http://www.pygtk.org/ - PyGTK (Wikipedia)
https://cs.wikipedia.org/wiki/PyGTK - Stránky projektu PyGObject
https://wiki.gnome.org/Projects/PyGObject - Stránky projektu PyQt
https://riverbankcomputing.com/software/pyqt/intro - What's on the Kivy Roadmap?
https://github.com/orgs/kivy/discussions/10 - Graphical user interface (Wikipedia)
http://en.wikipedia.org/wiki/Graphical_user_interface - The Real History of the GUI
http://articles.sitepoint.com/article/real-history-gui - History of the graphical user interface (Wikipedia)
http://en.wikipedia.org/wiki/History_of_the_graphical_user_interface
