Kivy Três Formas de Usar a Kv Language

Kivy Framework: Três Formas de Usar a Kv Language

Vamos construir três projetos para demonstrar como importar a Interface Gráfica do Kivy.

Vamos criar três algoritmos em que ilustra formas diferentes de Usar a Kv Language, linguagem de criação de interface do Framework Kivy:

Saber usar estes três modos diferentes de programação em Kivy vai poder aumentar a sua produtividade de programação com o Framework, além de você poder usar a maneira que achar melhor de aplicar em seus projetos, elegendo a melhor forma em cada script que você for codificar.

• Criação de Widgets como Buttons, Labels, Layouts
• Criar Widgets do Kivy para a Aplicação
• Usar as bibliotecas ScreenManager e Screen
• Importar interface gráfica com a classe Builder.load_string()
• Importar interface gráfica com a classe Builder.load_file()
• Importar interface gráfica com o NomeDaClasse

Separamos este projeto atual em três partes, que em três diretórios diferentes teremos cada maneira de programar em uma pasta diferente.

• /openString
• /main.py
• /openFile
• /main.py
• /gui.kv
• /className
• /main.py
• /kivygui.kv

O modo Builder.load_string()

Vamos então criar o método load_string, que é a maneira mais simples de se importar a interface gráfica do Kivy, neste modo vamos importar a classe Builder e deixar o código da interface visivel no código da aplicação.

O código completo da primeira abordagem você pode ver em um único arquivo em python, como está escrito logo abaixo.

# arquivo main.py
from kivy.app import App
from kivy.lang.builder import Builder
from kivy.uix.screenmanager import ScreenManager, Screen
Builder.load_string("""
<ScManager>:
	ScMain:
		id: sc_main
		name: "sc_main"

<ScMain>:
	BoxLayout:
		orientation: "vertical"
		Label:
			text: "Interface via Load String"
		Button:
			text: "Fechar"
			size_hint_y: 0.1
			on_release: app.stop()		
""")
class ScManager(ScreenManager):
	pass

class ScMain(Screen):
	pass

class KivyGui(App):
	def build(self):
		self.scm = ScManager()
		return self.scm
		
if __name__ == "__main__":
	KivyGui().run()

O modo Builder.load_file()

Neste modo de importação de interface gráfica, bem como o próximo que diferente do modo anterior que só tem um arquivo, teremos dois arquivos, que são a programação e algoritmo da classe principal em main.py e o arquivo da interface gráfica que aqui neste projeto tem o nome gui.kv

O código completo desta primeira abordagem em python você vê logo abaixo:

# arquivo main.py
from kivy.app import App
from kivy.lang.builder import Builder
from kivy.uix.screenmanager import ScreenManager, Screen

Builder.load_file("gui.kv")

class ScManager(ScreenManager):
	pass

class ScMain(Screen):
	pass

class KivyGui(App):
	def build(self):
		self.scm = ScManager()
		return self.scm
			
if __name__ == "__main__":
	KivyGui().run()

Como você pode ver no código acima, neste modo de importação da Kivy Language (modo load_file) teremos a importação com o método Builder.load_file("gui.kv"), em que "gui.kv" é o nome do arquivo escrito na Kv Language.

O código completo desta primeira abordagem para a interface gráfica você vê logo abaixo:

# arquivo gui.kv
<ScManager>:
	ScMain:
		id: sc_main
		name: "sc_main"

<ScMain>:
	BoxLayout:
		orientation: "vertical"
		Label:
			text: "Interface via Load File"
		Button:
			text: "Fechar"
			size_hint_y: 0.1
			on_release: app.stop()

E acima temos o código do arquivo "gui.kv"

O modo que usa o Nome da Classe

De forma análoga à anterior teremos outros dois arquivos, um para a classe principal e outro para a interface gráfica, a principal diferença desta corrente forma de programar em Kv Language, é que aqui não será necessário importar a classe Builder, e também não será necessário indicar o caminho do arquivo em .kv.

Há algumas exigências que deve ser seguida, que são: 1) O nome da classe principal deve conter a palavra "App" no final do respectivo texto.

2) Por boas práticas comece a primeira letra do nome da classe App em maiúsculo em cada nova palavra que compor o nome da classe deve iniciar com uma letra maiúscula, como em App, que a palavra em deve começar com o "A" e maiúsculo e o restante da palavra deve estar em minúsculo.
Assim, no projeto atual a classe principal tem o nome KivyGuiApp(). 3) O nome do arquivo .kv deve conter todas as letras em minúsculo que suprindo a palavra App, terá apenas o texto "kivygui" em minúsculo.

# arquivo main.py
from kivy.app import App
from kivy.uix.screenmanager import ScreenManager, Screen

class ScManager(ScreenManager):
	pass

class ScMain(Screen):
	pass

class KivyGuiApp(App):
	def build(self):
		self.scm = ScManager()
		return self.scm
			
if __name__ == "__main__":
	KivyGuiApp().run()

# arquivo kivygui.kv
<ScManager>:
	ScMain:
		id: sc_main
		name: "sc_main"

<ScMain>:
	BoxLayout:
		orientation: "vertical"
		Label:
			text: "Interface via Class Name"
		Button:
			text: "Fechar"
			size_hint_y: 0.1
			on_release: app.stop()	

Portanto caro leitor, você pode ter aprendido três formas diferentes de usar a Kv Language, use a forma que você preferir, ou combine em seus projetos a maneira que você eleger ser a mais indicada.

Considerações Finais e o que fazer a partir daqui

Esta aplicação tem público alvo a dois tipos de pessoas: As que já conhecem linguagem de programação e as que nunca programou coisa alguma, portanto, certamente que você pode ser uma pessoa de um desses grupos, ou seja, este Curso foi desenvolvido exatamente para Você. Se inscreva em meu Canal no Youtube, porque lá tem mais material sobre Kivy e Programação de Jogos e Criação de Vídeos.

Se eu instiguei sua curiosidade do Kivy, visite o Website Oficial do Kivy, instale em seu Dispositivo e aprenda mais sobre este framework por meio da API de Documentação.

Conheça o meu Canal @ZigaMultimedia no Youtube

No Canal Ziga Multimedia no Youtube tem vários outros cursos de Treinamento em Vídeo pagos e gratuitos em que você pode Aprender o Kivy, Conheçar a produção e técnicas de Desenvolvimento de Aplicativos Móveis e Jogos 3D.