Como criar um aplicativo gráfico com Python e Glade

Abril 2018

O objetivo deste tutorial é mostrar o passo a passo para a criação de um aplicativo gráfico com a linguagem de programação Python e o aplicativo gráfico GTK, usando o software Glade, visando a programação de interfaces gráficas.

Falamos, aqui, da programação de eventos. O nosso programa vai passar seu tempo esperando eventos (tal e qual um clique do usuário em um botão) e reagirá adequadamente, executando algumas partes do código.


Por que 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 é descomplicada.

O que é preciso instalar antecipadamente

Na distribuição Debian:
sudo install aptitude python-glade2 glade-3

Qual interface gráfica criar com Glade

Vamos criar uma interface mínima: um botão e uma etiqueta. Clicar no botão significará mudar o texto da etiqueta.


Lance o Glade3 (No Ubuntu: menu Aplicativos > Programação > Designer da interface do Glade) e escolha libglade como formato do projeto.

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 você são colocados os widgets; exibição da hierarquia de widgets; local que permite alterar as características de um widget.

Como criar uma interface mínima no Glade

Criar uma 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 acrescentar o botão: clique no botão e também na janela de trabalho para adicionar este botão:


Altere o texto do botão:


Finalmente o nosso 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, adicione a etiqueta: clique na ferramenta Etiqueta e clique 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

Salve tudo em myinterface.glade:


Sempre salve no formato libglade.



A criação do programa

O programa a seguir irá 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 nossa classe.

Como lançar o programa

Inicie o programa:
python myprogramme.py
para exibir a janela:


Clique no botão: a etiqueta é alterada!


Pronto, seu primeiro aplicativo gráfico foi criado.

Enriquecer o aplicativo com widgets

Agora 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 à sua interface, você deve modificar o dicionário de eventos e adicionar o nome do evento e do seu 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('Vous avez cliqué !')
, faça:
self['label1'].set_text('Vous avez cliqué !')
.

Foto: © Python.
Artigo original publicado por ninha25. Tradução feita por sebsauvage. Última modificação: 12 de março de 2018 às 08:05 por ninha25.
Este documento, intitulado 'Como criar um aplicativo gráfico com Python e Glade', está disponível sob a licença Creative Commons. Você pode copiar e/ou modificar o conteúdo desta página com base nas condições estipuladas pela licença. Não se esqueça de creditar o CCM (https://br.ccm.net/) ao utilizar este artigo.
Python - Ler e gravar arquivos CSV
Python - Ler e gravar arquivos CSV