Como criar um aplicativo gráfico com Python e Glade
Para executar projetos de programação na criação de interfaces gráficas, pode-se usar a linguagem Python, o app GTK e o software Glade. Falamos, aqui, da programação de eventos, onde um programa vai passar seu tempo esperando outros eventos (tal e qual um clique do usuário em um botão) e reagirá adequadamente, executando algumas partes do código. Veja como fazer isso na continuidade do tutorial</ital>.
Por que usar a linguagem Python + GTK + Glade
A resposta é simples, porque a Python é uma linguagem limpa, portátil e fácil de aprender; o app GTK é, na verdade, uma biblioteca gráfica bem projetada e portátil; o software Glade pode criar rapidamente interfaces gráficas com o mouse, separando corretamente a interface gráfica do código do programa. A manutenção dos programas é, graças a este grupo de tecnologias bem descomplicada.
O que é preciso instalar previamente
Na distribuição Debian é necessário intalar o seguinte:
sudo install aptitude python-glade2 glade-3
Qual interface gráfica pode-se criar com Glade
Com o Glade é possível criar uma interface mínima: um botão e uma etiqueta e clicar no botão significará mudar o texto da etiqueta.
Abra o Glade3 (No Ubuntu: menu Aplicativos > Programação > Designer da interface do Glade) e escolha libglade como formato do projeto.
Como se apresenta a interface do Glade
Glade é composto por 4 zonas: uma área contendo widgets disponíveis (elementos gráficos) prontos para o uso (botões, caixas de seleção, etc.); uma janela de trabalho, onde são colocados os widgets; a exibição da hierarquia de widgets; um local que permite alterar as características de um widget.
Como criar uma interface mínima no Glade
O mínimo será criar janelas, botões e etiquetas.
Criar uma janela
Comecemos por acrescentar a janela. Clique no ícone do Windows (Janela) e clique na área de trabalho. Isso criará uma janela:
Como você pode ver, Glade atribuiu automaticamente um nome para nossa janela: window1.Você pode alterá-lo, mas por enquanto, vamos manter esse nome:
Nossa janela deve reagir quando a fechamos. Então, vamos para aba Signals (Sinais) e clicar para adicionar um evento delete (excluir) na linha
delete-event
(excluir evento), (delete-event corresponde a uma solicitação de fechamento de uma janela):
Por padrão, as janelas são invisíveis quando criadas. Vá para a aba Common (comum), e passe o atributo Visível para Sim para torná-la visível:
Em uma janela, há várias maneiras de organizar os elementos: lado a lado, um acima do outro, em grade, etc. Aqui nós vamos colocar um acima do outro. Para tanto, clique no Vertical Box (contentor vertical) e clique na janela: Agora é este contentor o encarregado de organizar os widgets na janela:
Escolha o número de elementos a serem colocados: coloque 2 (1 botão e 1 etiqueta):
Como adicionar o botão
Vamos, agora, acrescentar o botão. Para tanto, clique no botão e também na janela de trabalho para adicionar este botão:
Altere o texto do botão:
Finalmente, o botão irá reagir quando você clicar nele: na aba Signals, adicione
on_button1_clicked
no evento clicked (clicado):
Como acrescentar a etiqueta
Da mesma forma, adicionemos a etiqueta: clique na ferramenta Etiqueta e , em seguida, na janela de trabalho para criá-la:
Altere o texto da etiqueta:
Veja como ficou
Você pode ver a hierarquia dos widgets criados:
Nossos dois widgets (botão e etiqueta) estão no contentor vertical vbox1, ele mesmo contido na janela. A maior parte das interfaces gráficas são projetadas assim: uma hierarquia de widgets imbrincados uns nos outros.
Como salvar a programação da interface gráfica
Vamos salvar o projeto da interface na pasta myinterface.glade:
E, o melhor é salvar no formato libglade.
A criação do programa
O programa irá, na continuidade, carregar a interface recém criada:
#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
import pygtk
pygtk.require("2.0")
import gtk
import gtk.glade
class monprogramme:
def __init__(self):
self.widgets = gtk.glade.XML('moninterface.glade',"window1")
events = { 'on_button1_clicked': self.monclic,
'delete': self.delete }
self.widgets.signal_autoconnect(events)
def delete(self, source=None, event=None):
gtk.main_quit()
def monclic(self, source=None, event=None):
self.widgets.get_widget('label1').set_text('Vous avez cliqué !')
return True
if __name__ == '__main__':
app = monprogramme()
gtk.main()
Entender o programa
Em primeiro lugar, foi carregado o arquivo Glade (
gtk.glade.XML
) ('moninterface.glade) e, nesse arquivo, foi selecionada a nossa janela (window1). Depois, para cada evento definido na interface, foi anexado (
signal_autoconnect
), um método que será chamado:
No evento
'on_button1_clicked
(que foi colocado no botão), é o método
self.monclic
que será solicitado. Em seguida, foi modificada a etiqueta (
... get_widget ('label1'). Set_text (...)
).
No evento
delete
da janela, o método será chamado
delete ()
que reagirá ao fechamento da janela quando sair (
GTK. main_quit ()
).
Finalmente, o main (principal) chama a classe.
Como lançar o programa
Inicie o programa:
python myprogramme.py
para exibir a janela:
Clique no botão, a etiqueta é imediatamente alterada!
Pronto, seu primeiro aplicativo gráfico foi criado.
Enriquecer o aplicativo com widgets
Antes de concluir, você pode adicionar e imbricar todos os widgets que quiser. A partir desse momento, você é livre para definir eventos seus widgets e para programar o código que reagirá a esses eventos (cliques em diferentes botões, caixas marcadas, etc.).
Algumas dicas
Sempre que você adicionar um evento à uma interface, você deve modificar o dicionário de eventos e adicionar o nome do evento e do respectivo método. É tedioso, mas, podemos fazer melhor - adicionar o método autoConnect descrito abaixo; você só precisa nomear seus métodos
gtk_*
. Por exemplo, basta criar um método chamado <bold>gtk_on_button1_clicked<bold> para levar automaticamente em consideração o evento
on_button1_clicked
. Nosso programa ficara desta forma:
#!/usr/bin/python
# -*- coding: iso-8859-1 -*-
import pygtk
pygtk.require("2.0")
import gtk
import gtk.glade
class meuprograma:
def __init__(self):
self.widgets = gtk.glade.XML('minhainterface.glade',"window1")
self.autoConnect()
def autoConnect(self):
eventHandlers = {}
for (itemName,value) in self.__class__.__dict__.items():
if callable(value) and itemName.startswith('gtk_'):
eventHandlers[itemName[4:]] = getattr(self,itemName)
self.widgets.signal_autoconnect(eventHandlers)
def gtk_delete(self, source=None, event=None):
gtk.main_quit()
def gtk_on_button1_clicked(self, source=None, event=None):
self.widgets.get_widget('label1').set_text('Você clicou!')
return True
if __name__ == '__main__':
app = meuprograma()
gtk.main()
Acessar mais facilmente os widgets
Adicione este método à sua classe:
def __getitem__(self, key):
return self.widgets.get_widget(key)
E, seus widgets serão mais facilmente acessíveis. Por exemplo, ao invés de fazer:
self.widgets.get_widget('label1').set_text('Você clicou!')
, faça:
self['label1'].set_text('Você clicou!')
.
Foto: © Vladimir Cosic - 123rf.com.
- Glade python
- Glade app - Melhores respostas
- Python glade - Melhores respostas
- Ler csv python - Dicas -Python
- Qual IDE seria a melhor para se trabalhar com PHP e PYTHON? - Fórum Softwares e aplicativos
Assine nossa newsletter!
