Ir para conteúdo


Foto

Interface Gráfica No Python


3 respostas neste tópico

#1 Dracom

Dracom

    LordDracom

  • Membros
  • 478 posts
  • Gender:Male
  • Location:Rio de Janeiro
  • Interests:Aprender

Postado 29 outubro 2006 - 20:16

Interessei-me recentemente pela linguagem, e gostaria de saber de links, tutoriais, apostilas ou qualquer coisa semelhante que pudesse me ajudar a desenvolver uma pequena aplicação em python que utilize interface gráfica (botões, campo de testo, etc...).
Obrigado unsure.gif
___________________________________________
O único computador que esta realmente protegido é aquele que esta desligado.

#2 Kakao

Kakao
  • Membros
  • 428 posts
  • Gender:Male
  • Location:Brasília

Postado 29 outubro 2006 - 20:34

O módulo standard para GUI é o Tkinter. http://pt.wikipedia.org/wiki/Tkinter

Tutorial em português se você ainda não conhece:
http://www.pythonbra...et=python24.pdf

Página com links para documentação:
http://www.pythonbra...umentacaoPython


#3 Dracom

Dracom

    LordDracom

  • Membros
  • 478 posts
  • Gender:Male
  • Location:Rio de Janeiro
  • Interests:Aprender

Postado 31 outubro 2006 - 21:20

vlw kakao
___________________________________________
O único computador que esta realmente protegido é aquele que esta desligado.

#4 Nogueira

Nogueira
  • Membros
  • 4 posts

Postado 09 novembro 2006 - 11:44

Eu recomendo como fazer o seu trabalho o seguinte:


PyGtkWin
Tutorial de instalação de PyGtk e Glade no Windows
Este é o meu primeiro tutorial para o PythonBrasil, então espero que ele seja útil pra você. Estarei falando sobre como instalar o trio Gtk, Glade e PyGtk no Windows. Vou mostrar passo-a-passo como fazer e espero que funcione para você
Fiz um teste com um fonte feito no Linux e o resultado foi muito bom, e não tive de mexer em nada pra funcionar. Então, vamos lá!
Baixando os programas
Gtk e Glade
Site: http://gladewin32.sourceforge.net/
Agora vamos instalar o Gtk na sua máquina para que programas feitos com essa biblioteca possam rodar nela. No site tem dois arquivos, um é o pacotão da alegria, que tem tudo - Glade, Runtime Gtk, libglade, e algumas coisas a mais. O outro é o pacotinho da contentação - que tem apenas o Runtime - Eu instalei o pacotão da alegria, que já vem com tudo, mas como disse antes, a escolha é sua.
• Pacotão da alegria é o gtk-win32-devel
• Pacotinho da contentação é o gtk-win32
Com o Gtk instalado já podemos rodar programas como o Gimp e outros.
PyGtk
Site: http://www.pcpm.ucl....orts/pygtk.html
Baixe o pacote em desenvolvimento.
Agora é hora de fazer a ponte entre o Gtk e o Python. Basta baixar o pacote e instalar, o que é bem simples.
Testando
Para testar, execute o Idle ou o próprio interpretador Python e de o comando:
>>> import gtk
Se o interpretador não chiar, você conseguiu smile.gif, senão tente seguir novamente os passos e caso alguma coisa continue a dar errado, mande uma email pra lista, que ajudamos a resolver.
Se quiser rodar algum programa, baixe o programa abaixo execute este exemplo.
Conclusão
É isso aí... Espero ter ajudado e até a próxima.
última edição 2006-02-05 01:01:31 efetuada por DouglasAndrade

LibGlade
libglade 2.4.0 tutorial versão 0.1
Wilson Freitas
1. Prefácio
1. Motivação
2. Introdução
1. Do que estamos falando?
3. Iniciando
1. Glade e a janela vazia
2. Fechando a janela
4. Seguindo adiante
1. Colocando uma caixa de diálogo
5. Para Contribuir
6. Créditos
7. Copyright
8. Referências
Prefácio
Motivação
A maior motivação para escrever esse primeiro tutorial foi: eu quero contribuir com Software Livre e quero fazer parte da comunidade, quero aprender e produzir, quero disseminar informação. Bem, como eu já tinha isso em mente, fui ao V FISL 2004, onde assisti uma palestra muito interessante sobre como ser um desenvolvedor de software livre, ministrada pelo Kiko e o Kov, dois grandes desenvolvedores e figuras da comunidade. Depois da apresentação, procurei os dois e falei: "eu quero ajudar". Simples assim. Foi aí que o Kiko falou que eu poderia contribuir com o projeto PyGtk e que seria interessante começar escrevendo um tutorial sobre libglade. E cá estou escrevendo sobre libglade. Antes disso, eu nunca havia usado o Glade, a libglade e também as bibliotecas GTK+ e GNOME. Já programava em Python e C o que facilitou alguma coisa. Depois de algumas semanas estudando essas bibliotecas, me senti finalmente seguro para escrever essa documentação. Espero que seja útil para alguém assim como foi importante para mim escrevê-la. Me coloco a disposição para dúvidas, sugestões e correções. Por favor, me ajude a tornar esse documento cada vez mais útil.
Quero registrar aqui o agradecimento ao Kiko e ao Kov pela oportunidade. Do coração, valeu a força.
Introdução
Do que estamos falando?
O assunto aqui é Libglade. Libglade é uma biblioteca que permite carregar uma interface gráfica (GUI) a partir de um arquivo XML e conecta os signal haldlers as funções de callback. A libglade foi desenvolvida por James Henstridge, mesmo autor do PyGtk, o binding de GTK+ para Python.
A libglade foi originalmente desenvolvida em C e já existem bindings para diversas linguagens (Python, C++, Java), contudo o foco deste tutorial é mostrar o uso da libglade com Python e PyGtk.
Um bom exemplo do poder da libglade é o Glade3 que está sendo completamente reescrito e não trará mais geração de código, a solução adotada foi o uso da libglade interpretando o XML gerado. Outros grandes projetos como o Gnumeric e o Evolution já usam a libglade.
Esse tutorial foi desenvolvido com:
• libglade-2.4.0
• glade-2.6.0
• pygtk-2.2.0
• python-2.3.3-r1
• gtk+-2.4.1
• gnome-2.6
sobre Gentoo linux (2.6.7-gentoo-r11).
Para maiores detalhes a respeito de PyGtk, aconselho o PyGTK 2.0 Tutorial escrito por John Finlay, é o documento must read sobre o assuto.
Iniciando
Glade e a janela vazia
Antes de começar qualquer coisa com libglade, precisamos de um XML que descreva um interface. Para isso usei o Glade.

Essa é uma sessão bastante imediata do glade. Basicamente, criei um projeto GTK+ e adicionei um objeto gtk.Window a ele. Ao salvar esse projeto, ele gera o seguinte arquivo XML.
<?xml version="1.0" standalone="no"?>
<!DOCTYPE glade-interface SYSTEM "http://glade.gnome.o...glade-2.0.dtd">

<glade-interface>

<widget class="GtkWindow" id="window1">
<property name="visible">True</property>
<property name="title" translatable="yes">window1</property>
<property name="type">GTK_WINDOW_TOPLEVEL</property>
<property name="window_position">GTK_WIN_POS_NONE</property>
<property name="modal">False</property>
<property name="resizable">True</property>
<property name="destroy_with_parent">False</property>
<property name="decorated">True</property>
<property name="skip_taskbar_hint">False</property>
<property name="skip_pager_hint">False</property>
<property name="type_hint">GDK_WINDOW_TYPE_HINT_NORMAL</property>
<property name="gravity">GDK_GRAVITY_NORTH_WEST</property>

<child>
<placeholder/>
</child>
</widget>

</glade-interface>
Isso já é o suficiente para vermos como funciona a libglade. O programa abaixo lê o arquivo XML e carrega a interface.
Toggle line numbers
1 import gtk, gtk.glade
2
3 gtk.glade.XML("empty.glade")
4 gtk.main()
Essa é a interface gerada por esse programa de 4 linhas.

Todo o trabalho sujo é feito pela classe gtk.glade.XML. Nela é feito o parse do XML e os objetos são carregados e estão prontos para serem manipulados.
Note que, ao fechar a janela, o programa ainda fica rodando, para finalizar basta digitar Crtl-C no console onde foi executado o programa. Isso acontece porque não foi feito nenhum tratamento de sinais no programa.
Fechando a janela
Para fechar a janela deve-se tratar o sinal que é disparado quando ela é destruída. Para isso, selecione a aba de sinais no Glade, escolha qual sinal quer tratar, nesse caso é destroy e informe qual é o handler para esse sinal.

O handler deve ser mapeado com uma função ou método de uma classe, e esse será executado quando o sinal for disparado. O código com o tratamento de sinais fica:
Toggle line numbers
1 import gtk, gtk.glade
2
3 dic = { "gtk_main_quit" : gtk.main_quit }
4
5 gladefile = gtk.glade.XML("empty.glade")
6 gladefile.signal_autoconnect(dic)
7
8 gtk.main()
Olhando novamente para a chamada gtk.glade.XML("empty.glade"), observa-se que um objeto é retornado. Esse objeto é o GladeXML que é identificado pela variável gladefile. Através desse objeto, tem-se acesso a toda estrurura montada no XML. O método signal_autoconnect recebe mapeamento das funções de callback com os handlers. É exatamente na chamada a signal_autoconnect que a libglade conecta o programa a interface fazendo com que os sinais sejam tratados da maneira definida.
Execute e veja que o programa agora é encerrado normalmente, executando a função gtk_main_quit quando o sinal destroy é disparado. Sei que não é de nenhuma utilidade uma janela vazia que fecha, mas entenda que a interface foi criada sem nenhuma interação com widgets e todo o trabalho de criar a estrutura da interface gráfica fica a cargo do glade e da libglade. E convenhamos que a criação da interface na mão é um pé saco, mesmo em Python smile.gif. Note que com a libglade é possível alterar a interface gráfica quantas vezes se fizer necessário, sem precisar recompilar o código para isso. É simples, rápido e limpo. O lema aqui é: quanto menos código, melhor.
Seguindo adiante
Ousando um pouco mais agora e com o intuito de levar a bancarrota os bancos de investimento, vamos construir uma calculadora de investimentos chamada InvestCalc. Ela calcula os dividendos de um investimento, para isso basta fornecer o montante investido mensalmente ou anualmente, a taxa de juros e o período de duração do investimento que ela informa o valor obtido no investimento. Segue uma amostra da interface desenvolvida no Glade.

Para calcular o valor obtido, é preciso obter as referências para os widgets de entrada de dados (gtk.Entry, gtk.Combo, gtk.SpinButton). Isso é feito através do seguinte método:
Toggle line numbers
1 ...
2 widget = gladefile.get_widget('widget_name')
Onde gladefile é uma referência para gtk.glade.XML e widget_name é o nome dado ao widget no Glade.

no XML fica assim:
...
<child>
<widget class="GtkEntry" id="entry_amount">
<property name="visible">True</property>
...
o código para obter as referências dos widgets de entrada de dados fica:
Toggle line numbers
1 ...
2
3 w_duration = gladefile.get_widget('spinbutton_duration')
4 w_return_rate = gladefile.get_widget('entry_return')
5 w_amount = gladefile.get_widget('entry_amount')
6 w_total_investment = gladefile.get_widget('label_total_investment')
7 w_duration_period = gladefile.get_widget('combo_duration_period')
8 w_amount_period = gladefile.get_widget('combo_amount_period')
9 help_dialog = gladefile.get_widget('dialog_help')
Obtidas as referências, vem o tratamento de sinais. Como foi visto anteriormente, o sinal também é associado ao widget através do Glade, só precisa informar qual sinal e o nome do handler para ele. Veja na figura que o sinal clicked do widget button_calculate está associado ao handler on_button_calculate_clicked.

Agora só precisa associar o sinal a uma função de callback no programa. Isso é feito colocando o handler como chave em um dicionário e a função como valor. Esse dicionário é passado como parâmetro para o método que faz a auto-conexão dos sinais.
Toggle line numbers
1 ...
2 def on_button_calculate_clicked(*args):
3 import math
4 # entry boxes
5 amount = float(w_amount.get_text())
6 return_rate = float(w_return_rate.get_text())
7 # spin button
8 duration = w_duration.get_value_as_int()
9 # combo boxes
10 duration_period = w_duration_period.entry.get_text()
11 amount_period = w_amount_period.entry.get_text()
12
13 if duration_period == 'Years':
14 duration *= 12
15 return_rate /= 100
16
17 total = 0.0
18 for i in range(duration):
19 if amount_period == 'Year':
20 if i%12 == 0:
21 total += (total*return_rate) + amount
22 else:
23 total += total * return_rate
24 else:
25 total += (total*return_rate) + amount
26
27 # label
28 w_total_investment.set_text('$ %.2f' % total)
29
30 dic = { 'on_window1_destroy' : lambda win: gtk.main_quit(),
31 'on_button_calculate_clicked' : on_button_calculate_clicked,
32 ... }
33 ...
34 gladefile.signal_autoconnect(dic)
Toda vez que o botão Calculate for clicado a função on_button_calculate_clicked será executada e o valor obtido inpresso na label. Veja o InvestCalc em ação:

Atente para o uso dos widgets que foram obtidos anteriormente. Os valores foram capturados das caixas de texto e combo boxes, calculados e impressos em um label. Todos esse objetos, assim como toda a interface, foram instanciados pela libglade. Pode-se mudar os botões e os demais widgets de posição e não mexer em uma linha sequer de código. Pode-se mudar todo o design sem precisar recompilar o programa. Lembre-se: quanto menos código, melhor.
Colocando uma caixa de diálogo
Toda aplicação que se preze deve ter uma caixa de diálogo com pelo menos o nome do autor. Pois bem, para incluir essa caixa criei o botão button_help e associei ao sinal clicked o handler on_button_help_clicked. No Glade, criei uma caixa de diálogo chamada dialog_help com um botão Close. A esse botão, associei o seu sinal clicked ao handler on_closebutton_dialog_clicked. Criei as duas funções callback e e as adicionei ao dicionário para a auto-conexão, como segue:
Toggle line numbers
1 ...
2 def on_button_help_clicked(*args):
3 help_dialog.show()
4
5 def on_closebutton_dialog_clicked(*args):
6 help_dialog.hide()
7
8 dic = { 'on_window1_destroy' : lambda win: gtk.main_quit(),
9 'on_button_calculate_clicked' : on_button_calculate_clicked,
10 'on_button_help_clicked' : on_button_help_clicked,
11 'on_closebutton_dialog_clicked' : on_closebutton_dialog_clicked }
12
13 gladefile.signal_autoconnect(dic)
ao clicar no botão Help aparecerá:

o código na integra:
Toggle line numbers
1
2 import gtk
3 import gtk.glade
4
5 gladefile = gtk.glade.XML('investcalc.glade')
6
7 # widgets
8
9 w_duration = gladefile.get_widget('spinbutton_duration')
10 w_return_rate = gladefile.get_widget('entry_return')
11 w_amount = gladefile.get_widget('entry_amount')
12 w_total_investment = gladefile.get_widget('label_total_investment')
13 w_duration_period = gladefile.get_widget('combo_duration_period')
14 w_amount_period = gladefile.get_widget('combo_amount_period')
15 help_dialog = gladefile.get_widget('dialog_help')
16
17 # callback functions
18
19 def on_button_calculate_clicked(*args):
20 import math
21 amount = float(w_amount.get_text())
22 return_rate = float(w_return_rate.get_text())
23 duration = w_duration.get_value_as_int()
24 duration_period = w_duration_period.entry.get_text()
25 amount_period = w_amount_period.entry.get_text()
26
27 if duration_period == 'Years':
28 duration *= 12
29 return_rate /= 100
30
31 total = 0.0
32 for i in range(duration):
33 if amount_period == 'Year':
34 if i%12 == 0:
35 total += (total*return_rate) + amount
36 else:
37 total += total * return_rate
38 else:
39 total += (total*return_rate) + amount
40
41 w_total_investment.set_text('$ %.2f' % total)
42
43 def on_button_help_clicked(*args):
44 help_dialog.show()
45
46 def on_closebutton_dialog_clicked(*args):
47 help_dialog.hide()
48
49 dic = { 'on_window1_destroy' : lambda win: gtk.main_quit(),
50 'on_button_calculate_clicked' : on_button_calculate_clicked,
51 'on_button_help_clicked' : on_button_help_clicked,
52 'on_closebutton_dialog_clicked' : on_closebutton_dialog_clicked }
53
54 gladefile.signal_autoconnect(dic)
55
56 gtk.main()
Todo o código produzido para esse artigo pode ser encontrado aqui http://www.aboutwils...ial-code.tar.gz. Divirta-se.
Para Contribuir
Este documento, assim como muitos outros software livres, foi criado por voluntários. Se existe algum tópico a respeito do tema que este documento não contempla, por favor ajude a mantê-lo completo enviando essas informações ou escrevendo você mesmo uma seção ou trecho de alguma seção.
Atente para o fato de que esse documento é livre e qualquer conteúdo adicionado a ele também deverá ser.
Se você realmente quiser contribuir, envie um email para Wilson Freitas <wilson (a) econofisica com br>.
Obrigado.
Créditos
Agora eu vou falar sobre o que tornou esse documento possível:
• Jonh Finlay, <finlay (a) moeraki com> pelo tutorial de PyGtk.
• txt2tags http://txt2tags.sf.net.
• Lissandra pelo carinho e Pedrinho pelo bom humor.
• E todos os que eu espero que leiam e ajudem a contribuir com esse documento.
Copyright
Libglade Tutorial © 2004 Wilson Freitas.
Esse documento está licenciado sob a GNU Free Documentation License, publicada pela Free Software Foundation.
É permitido distribuir cópias deste manual, desde que se forneça o Copyright em todas as cópias.
Se você pretende incluir este documento em alguma publicação, por favor contate o responsável e nós trabalharemos para garantir que todo documento esteja atualizada e de acordo com as informações disponíveis.
Referências
• Página do Libglade, http://www.jamesh.id...tware/libglade/
• Guia de referência Libglade, http://developer.gno...e/libglade.html
• Artigo do Linux Journal é uma das melhores referências sobre o assunto. http://www.linuxjour...le.php?sid=6586
• Outro artigo do Linux Journal. Este fala mais sobre Glade, mas vale uma conferida. http://www.linuxjour...le.php?sid=7421
• Tutorial de PyGTK, definitivamente O Tutorial sobre o assunto. http://www.pygtk.org...rial/index.html
• Glade, porque sem ele não tem conversa. http://glade.gnome.org
última edição 2006-02-20 16:21:55 efetuada por WilsonFreitas

InternacionalizePyGtk
Internacionalizando programas feitos com PyGtk e Libglade
Pedro Kröger
Última atualização: 02.10.2004
1. Introdução
2. Breve introdução à internacionalização
3. Ferramentas utilizadas
4. Extraindo as mensagens do Glade
5. Gerando o arquivo de tradução
6. Criando arquivos de tradução
7. Fazendo seu programa reconhecer as traduções
8. Contribuições
9. Copyright
10. Links
Introdução
Se você tem escrito programas usando o PyGtk e libglade (veja tutorial em LibGlade) pode ter interesse em torná-los internacionalizados. Ou seja, a linguagem do programa (o menu, mensagens de texto, etc.) será definida pela locale do sistema.
Breve introdução à internacionalização
Ferramentas utilizadas
• PyGtk
• Glade
• Python 2.3
• GNU gettext
• Gtk+ 2.4.1
• Libglade 2.4.0
Extraindo as mensagens do Glade
Você precisará do intltool, um utilitário para internacionalizar documentos em XML. Se você usa Debian basta digitar:
apt-get install intltool
O programa intltool-extract extrai as strings de um arquivo glade (no exemplo "meuprograma.glade" e gera um arquivo .h (no exemplo "meuprograma.glade.h"):
intltool-extract --type="gettext/glade" meuprograma.glade
Você não precisa editar esse arquivo (.h), ele será lido pelo xgettext.
Gerando o arquivo de tradução
xgettext -k_ -kN_ -o messages.pot *.py *.h
vai criar um arquivo de tradução "messages.pot" a partir dos códigos fonte de python e dos arquivos .h gerados pelo intltool-extract.
Criando arquivos de tradução
Para que seja possível criar traduções para diferentes línguas é necessário criar um arquivo para cada uma. Isso é feito com msginit. Nesse exemplo ele cria o arquivo pt_BR.po adequado para a tradução para o português brasileiro:
msginit -i messages.pot -l pt_BR
Tendo traduzido o arquivo pt_BR.po é necessário gerar o arquivo que será usado pelo programa:
msgfmt pt_BR.po -o po/pt/LC_MESSAGES/meuprograma.maior
Não importa o nome do diretório onde você coloque o arquivo *.maior, mas a estrutura desse diretório tem que ser <diretório>/<locale>/LC_MESSAGES/<nome-do-programa>.maior. Onde <locale> é algo como pt ou pt_BR.
Fazendo seu programa reconhecer as traduções
Tipicamente um programa de python usando o libglade terá strings para serem traduzidas tanto no programa python quanto no arquivo glade. Para lidar com as strings na parte em python pode-se usar o módulo gettext. Todas as strings a serem traduzidas deverão usar o método gettext desse módulo:
Toggle line numbers
1 print gettext.gettext("Texto a ser traduzido")
Porém é muito mais prático usar o formato _(<string>), mas para isso deve-se definir _ como gettext.gettext:
Toggle line numbers
1 _ = gettext.gettext
2
3 print _("Texto a ser traduzido")
O local padrão para os arquivos com mensagens de tradução é geralmente "/usr/share/locale", mas enquanto estiver desenvolvendo seu programa é bastante útil tê-los em um diretório local, algo como "i18n" ou "po":
Toggle line numbers
1 APP='meuprograma'
2 DIR='po'
Um exemplo mais completo ficaria como:
Toggle line numbers
1 import gettext
2
3 APP='meuprograma'
4 DIR='po'
5
6 gettext.bindtextdomain(APP, DIR)
7 gettext.textdomain(APP)
8
9 _ = gettext.gettext
10
11 gtk.glade.bindtextdomain(APP, DIR)
12 gtk.glade.textdomain(APP)
13
14 gui = gtk.glade.XML("meuprograma.glade")
15 .....
Contribuições
Esse texto ainda está sendo escrito, por favor não deixe de mandar correções e sugestões para kroger em pedrokroeger.net.
Copyright
© 2004 Pedro Kroger.
Esse documento está licenciado sob a GNU Free Documentation License, publicada pela Free Software Foundation.
É permitido distribuir cópias deste manual, desde que se forneça o Copyright em todas as cópias.
Se você pretende incluir este documento em alguma publicação, por favor contate o responsável e nós trabalharemos para garantir que todo documento esteja atualizada e de acordo com as informações disponíveis.
Links
http://www.async.com...e=faq22.002.htp
última edição 2005-06-06 13:29:31 efetuada por OsvaldoSantanaNeto
• MoinMoin Powered
• Python Powered
• Valid HTML 4.01

PyGtkCellRenderCombo
Toggle line numbers
1 import gtk
2
3 janela = gtk.Window(gtk.WINDOW_TOPLEVEL)
4 janela.set_title("TreeView com Combo")
5 janela.connect("delete_event", gtk.main_quit)
6
7 modelo= gtk.ListStore(str)
8 modelo.append(['Cartucho de Impressora'])
9 modelo.append(['Computador 486 Semi-Novo'])
10 modelo.append(['Computador Top de Linha'])
11 modelo.append(['Monitor 21"'])
12 modelo.append(['Mouse Ps2'])
13 modelo.append(['Teclado ABNT2'])
14 modelo.append(['Impressora LX-300L'])
15
16 combo= gtk.CellRendererCombo()
17 combo.set_property("model", modelo)
18 combo.set_property('text-column', 0)
19 combo.set_property('editable', True)
20
21 barra = gtk.CellRendererProgress()
22
23 tGrade= gtk.TreeView()
24 mgrade= gtk.ListStore(str, str, str, str, str, int)
25 tGrade.set_model(mgrade)
26 coluna1= gtk.TreeViewColumn("Ordem", gtk.CellRendererText(), text= 0)
27 coluna2= gtk.TreeViewColumn("Produto", combo, text=1)
28 coluna3= gtk.TreeViewColumn("Valor", gtk.CellRendererText(), text= 2)
29 coluna4= gtk.TreeViewColumn("Qtd", gtk.CellRendererText(), text= 3)
30 coluna5= gtk.TreeViewColumn("Total", gtk.CellRendererText(), text= 4)
31 coluna6= gtk.TreeViewColumn("Ok", barra, value=5)
32 coluna1.set_resizable(True)
33 coluna2.set_resizable(True)
34 coluna3.set_resizable(True)
35 coluna4.set_resizable(True)
36 coluna5.set_resizable(True)
37 coluna2.set_expand(True)
38 coluna1.set_sort_column_id(0)
39 coluna2.set_sort_column_id(1)
40 coluna3.set_sort_column_id(2)
41 coluna4.set_sort_column_id(3)
42 coluna5.set_sort_column_id(4)
43 tGrade.append_column(coluna1)
44 tGrade.append_column(coluna2)
45 tGrade.append_column(coluna3)
46 tGrade.append_column(coluna4)
47 tGrade.append_column(coluna5)
48 tGrade.append_column(coluna6)
49 #tGrade.get_selection().set_mode(gtk.SELECTION_SINGLE)
50 msg = '(escolha um produto)'
51 mgrade.append(['Qualquer', msg, '5.00', '2', '10.00', 10])
52 mgrade.append(['Outro', msg,'15.00', '22', '110.00', 30])
53
54 def on__combo__edited(renderer, path, new_text, model):
55 coluna_produto = 1
56 model[path][coluna_produto] = new_text
57
58 combo.connect("edited", on__combo__edited, mgrade)
59
60 janela.add(tGrade)
61 janela.show_all()
62 gtk.main()

PyGtkComboBoxEntry
Receita: Várias Rotinas Usando ComboBoxEntry no PyGtk
Exemplo de várias rotinas de comboboxentry para usar no seu aplicativo.
Código
Toggle line numbers
1 #-*- encoding: utf8 -*-
2
3 ##
4 # Esse programa é livre, você pode distribuir e/ou modifica-lo sob os
5 # termos da licença geral publica GNU publicada pela fundação de software
6 # livre (Free Software Foundation), contida na segunda versão da licença
7 # ou (em sua opinião) outra versão mais recente.
8 # Esse programa é distribuído na esperança de ser útil e satisfatório,
9 # mas DESTITUÍDO DE QUALQUER GARANTIA, destituído igualmente da
10 # COMPATIBILIDADE DE MÁQUINA ou CONVENIÊNCIA PARA PROPÓSITOS
11 # PARTICULARES. Veja a licença geral publica GNU para opter mais detalhes.
12 # http://www.gnu.org/copyleft/gpl.html
13 ##
14
15 ###############################################################################
16 ## Nome do Arquivo: utilitario
17 ## Autor: Guedes, Maurilio<billguedes>
18 ## Data da Criação: 26/11/2004
19 ## Data da Modificação: 03/07/2005
20 ## Finalidade: Funções úteis do dia-a-dia
21 ##
22 ##
23 ##
24 ###############################################################################
25
26 import pygtk
27 pygtk.require('2.0')
28 import gtk
29
30 def combo_entry_autocompletar(combo, coluna= 0, caracter= 1):
31 '''
32 Uso: combo_entry_autocompletar(combo, coluna, tecla)
33 combo -> ponteiro do comboboxentry
34 coluna -> número da coluna que usará o autocomplemento
35 caracter -> apartir de quantos e caracteres digitados ocorerá o autocomplemento
36
37 Adiciona o recurso de autocomplemento no comboboxentry
38 '''
39
40 completar= gtk.EntryCompletion()
41 completar.set_model(combo.get_model())
42 completar.set_minimum_key_length(caracter)
43 completar.set_text_column(coluna)
44 combo.child.set_completion(completar)
45
46 def combo_entry_selecao(combo, retorno_coluna= 0, coluna= 0):
47 '''
48 Uso: combo_entry_selecao(combo, retorno_coluna= 0, coluna= 0)
49 combo -> ponteiro do comboboxentry
50 retorno_coluna -> número da coluna para retorno
51 coluna -> número da coluna que será comparada
52
53 Seleciona o texto do registro atual no comboboxentry
54 '''
55
56 texto = combo.child.get_text()
57 lista= combo.get_model()
58 if texto:
59 for registro in lista:
60 if registro[coluna] == texto: return registro[retorno_coluna]
61 combo.child.grab_focus()
62 # combo.child.select_region(0, -1)
63
64 # Rotina vista em http://www.pythonbra.../PyGtkMensagens
65 mensagem_erro('Você Deve Escolher um Item da Lista!')
66 return 0
67
68 def combo_entry_selecionar(texto, combo, coluna= 0):
69 '''
70 Uso: combo_entry_selecionar(texto,combo, coluna)
71 texto -> texto a ser selecionado no comboboxentry
72 combo -> ponteiro do comboboxentry
73 coluna -> número da coluna que será comparada
74
75 Seleciona o texto no comboboxentry
76 '''
77
78 indice= 0
79 modelo= combo.get_model()
80 for registro in modelo:
81 if registro[coluna] == texto:
82 combo.set_active(indice)
83 break
84 indice+= 1
85
86 def carregar_data(dia, mês, ano):
87 '''
88 Uso: carregar_data(dia, mês, ano)
89 dia -> ponteiro do comboboxentry referente ao dia
90 mês -> ponteiro do comboboxentry referente ao mês
91 ano -> ponteiro do comboboxentry referente ao ano
92
93 Carrega o dia, mês e ano nos comboboxentry correspondente
94 '''
95
96 modelo= gtk.ListStore(str)
97 for i in range(1, 32):
98 texto= str('%02.f') % i
99 modelo.append([texto])
100 dia.set_model(modelo)
101
102 modelo= gtk.ListStore(str, str)
103 modelo.append(['Janeiro', '01'])
104 modelo.append(['Fevereiro', '02'])
105 modelo.append(['Março', '03'])
106 modelo.append(['Abril', '04'])
107 modelo.append(['Maio', '05'])
108 modelo.append(['Junho', '06'])
109 modelo.append(['Julho', '07'])
110 modelo.append(['Agosto', '08'])
111 modelo.append(['Setembro', '09'])
112 modelo.append(['Outubro', '10'])
113 modelo.append(['Novembro', '11'])
114 modelo.append(['Dezembro', '12'])
115 mês.set_model(modelo)
116
117 modelo= gtk.ListStore(str)
118 for i in range(1900, 2100):
119 modelo.append([i])
120 ano.set_model(modelo)
121
122 combo_entry_autocompletar(dia)
123 combo_entry_autocompletar(mês)
124 combo_entry_autocompletar(ano)
125
126 def carregar_semana(combo):
127 '''
128 Uso: carregar_semana(combo)
129 combo -> ponteiro do comboboxentry
130
131 Carrega os dias da semana no combo especificado
132 '''
133
134 modelo= gtk.ListStore(str, str)
135 modelo.append(['Domingo', '1'])
136 modelo.append(['Segunda-Feira', '2'])
137 modelo.append(['Terça-Feira', '3'])
138 modelo.append(['Quarta-Feira', '4'])
139 modelo.append(['Quinta-Feira', '5'])
140 modelo.append(['Sexta-Feira', '6'])
141 modelo.append(['Sábado', '7'])
142 combo.set_model(modelo)
143 combo_entry_autocompletar(combo)
Exemplo de uso
Toggle line numbers
1 #-*- encoding: utf8 -*-
2
3 ##
4 # Esse programa é livre, você pode distribuir e/ou modifica-lo sob os
5 # termos da licença geral publica GNU publicada pela fundação de software
6 # livre (Free Software Foundation), contida na segunda versão da licença
7 # ou (em sua opinião) outra versão mais recente.
8 # Esse programa é distribuído na esperança de ser útil e satisfatório,
9 # mas DESTITUÍDO DE QUALQUER GARANTIA, destituído igualmente da
10 # COMPATIBILIDADE DE MÁQUINA ou CONVENIÊNCIA PARA PROPÓSITOS
11 # PARTICULARES. Veja a licença geral publica GNU para opter mais detalhes.
12 # http://www.gnu.org/copyleft/gpl.html
13 ##
14
15 ###############################################################################
16 ## Nome do Arquivo: teste.py
17 ## Autor: Guedes, Maurilio<billguedes>
18 ## Data da Criação: 19/08/2005
19 ## Data da Modificação: 20/08/2005
20 ## Finalidade: Testar o uso do arquivo utilitario.py
21 ##
22 ##
23 ##
24 ###############################################################################
25
26 import pygtk
27 pygtk.require('2.0')
28 import gtk, time
29 import utilitario
30
31 class Principal:
32 '''Classe principal'''
33
34 def __init__(self):
35 '''Incialização padrão'''
36
37 # Cria uma janela
38 self.janela = gtk.Window(gtk.WINDOW_TOPLEVEL)
39 self.janela.set_title("Usando a Rotina Utilitário") # Coloca um título
40 self.janela.set_border_width(5) # Especifica uma porda de 5 pixels
41 self.janela.set_position(gtk.WIN_POS_CENTER) # Centraliza a janela
42
43 # Fecha o aplicativo ao destruir a janela
44 self.janela.connect("destroy", gtk.main_quit)
45
46 # Cria uma caixa vertical
47 self.caixa= gtk.VBox(False, 0)
48 self.janela.add(self.caixa) # Adiciona a caixa na janela
49
50 # Cria uma caixa horizontal
51 self.caixa2= gtk.HBox(False, 0)
52
53 # Cria um comboboxentry
54 self.dia= gtk.combo_box_entry_new_text()
55 self.dia.set_size_request(60, 25) # Muda largura e altura
56
57 # Cria um comboboxentry
58 self.mês= gtk.combo_box_entry_new_text()
59 self.mês.set_size_request(120, 25) # Muda largura e altura
60
61 # Cria um comboboxentry
62 self.ano= gtk.combo_box_entry_new_text()
63 self.ano.set_size_request(90, 25) # Muda largura e altura
64
65 self.caixa2.pack_start(self.dia, True, True, 0) # Adiciona o combo na caixa
66 self.caixa2.pack_start(self.mês, True, True, 0) # Adiciona o combo na caixa
67 self.caixa2.pack_start(self.ano, True, True, 0) # Adiciona o combo na caixa
68
69 # Cria uma moldura
70 self.moldura= gtk.Frame('Data')
71 self.moldura.add(self.caixa2) # Adiciona a caixa na moldura
72
73 # Cria uma caixa horizontal
74 self.caixa3= gtk.HBox(False, 0)
75
76 # Cria um comboboxentry
77 self.semana= gtk.combo_box_entry_new_text()
78 self.semana.set_size_request(60, 25) # Muda largura e altura
79
80 # Adiciona o combo na caixa
81 self.caixa3.pack_start(self.semana, True, True, 0)
82
83 # Cria uma moldura
84 self.moldura2= gtk.Frame('Semana')
85 self.moldura2.add(self.caixa3) # Adiciona a caixa na moldura
86
87 # Cria um separador
88 self.separador= gtk.HSeparator()
89
90 # Cria um botão
91 self.botao= gtk.Button('O Que Escolhi?')
92
93 # Execute o método "escolher" ao clicar
94 self.botao.connect('clicked', self.escolher)
95
96 # Cria um botão
97 self.botao2= gtk.Button('Hoje é ...')
98
99 # Execute o método "carregar_hoje" ao clicar
100 self.botao2.connect('clicked', self.carregar_hoje)
101
102 # Cria uma caixa horizontal
103 self.caixa4= gtk.HBox(False, 0)
104 self.caixa4.pack_start(self.botao, True, True, 0) # Adiciona o botão na caixa
105 self.caixa4.pack_start(self.botao2, True, True, 0) # Adiciona o botão na caixa
106
107 # Carrega dia, mês e ano nos combos especificados
108 utilitario.carregar_data(self.dia, self.mês, self.ano)
109
110 # Carrega os dias da semana no combo especificado
111 utilitario.carregar_semana(self.semana)
112
113 # Adiciona as molduras na caixa
114 self.caixa.pack_start(self.moldura, True, True, 0)
115 self.caixa.pack_start(self.moldura2, True, True, 0)
116
117 # Adiciona o separador na caixa com espaçamento de 5 pixels
118 self.caixa.pack_start(self.separador, True, True, 5)
119
120 # Adiciona a caixa (contendo os botões) na caixa
121 self.caixa.pack_start(self.caixa4, True, True, 0)
122
123 # Mostra todas os widgets adicionados na janela
124 self.janela.show_all()
125
126 def escolher(self, widget= None):
127 '''Executa o código abaixo'''
128
129 dia= utilitario.combo_entry_selecao(self.dia) # Captura o dia do combo
130 mês= utilitario.combo_entry_selecao(self.mês) # Captura o mês do combo
131 ano= utilitario.combo_entry_selecao(self.ano) # Captura o ano do combo
132
133 # Captura o semana do combo
134 semana= utilitario.combo_entry_selecao(self.semana)
135
136 # Se dia, mês ou ano retornarem False, não faz mas nada
137 if not dia or not mês or not ano: return False
138
139 # Formata o texto para exibir na mensagem
140 texto= 'Você Escolheu <b>%s/%s/%s</b> e <b>%s</b>' % (dia, mês, ano, semana)
141
142 # Rotina vista em http://www.pythonbra.../PyGtkMensagens
143 utilitario.mensagem(texto) # Exibe uma mensagem
144
145 def carregar_hoje(self, widget= None):
146 '''Executa o código abaixo'''
147
148 # Captura ano, mês, dia..... do sistema
149 ano, mês, dia, hora, minuto, segundo, semana, juliano, verao= time.localtime()
150
151 # Seleciona o dia no comboboxentry
152 utilitario.combo_entry_selecionar(str(dia), self.dia)
153
154 # Seleciona o mês no comboboxentry
155 utilitario.combo_entry_selecionar(str( '%02d' % mês),self.mês, 1)
156
157 # Seleciona o ano no comboboxentry
158 utilitario.combo_entry_selecionar(str(ano), self.ano)
159
160 # Seleciona a semana no comboboxentry
161 utilitario.combo_entry_selecionar(str(self.retornar_dia_semana(semana)),
162 self.semana, 1)
163
164 def retornar_dia_semana(self, dia_semana_sistema= 0):
165 '''
166 Uso: retornar_dia_semana(dia_semana_sistema)
167 dia_semana_sistema -> dia da semana pelo python
168
169 Retorna o dia da semana personalizado
170 '''
171
172 dia= [2, 3, 4, 5, 6, 7, 1]
173 return dia[dia_semana_sistema]
174
175 if __name__ == '__main__':
176 '''Se o aplicativo é principal, execute esse método'''
177
178 # Chama a classe 'Principal'
179 p= Principal()
180
181 # Inicia o aplicativo
182 gtk.main()
Agradecimento
Agradeço aos amigos Antonio Prado e Acidx (Leandro) pela ajuda em algumas rotinas.
Volta para CookBook.
________________________________________
Guedes, Maurilio <billguedes.python at terra.com.br>
Depois continue a sua pesquisa no google e então poderá as suas restantes dúvisas. Um abraço.




Eu recomendo como fazer o seu trabalho o seguinte:


PyGtkWin
Tutorial de instalação de PyGtk e Glade no Windows
Este é o meu primeiro tutorial para o PythonBrasil, então espero que ele seja útil pra você. Estarei falando sobre como instalar o trio Gtk, Glade e PyGtk no Windows. Vou mostrar passo-a-passo como fazer e espero que funcione para você
Fiz um teste com um fonte feito no Linux e o resultado foi muito bom, e não tive de mexer em nada pra funcionar. Então, vamos lá!
Baixando os programas
Gtk e Glade
Site: http://gladewin32.sourceforge.net/
Agora vamos instalar o Gtk na sua máquina para que programas feitos com essa biblioteca possam rodar nela. No site tem dois arquivos, um é o pacotão da alegria, que tem tudo - Glade, Runtime Gtk, libglade, e algumas coisas a mais. O outro é o pacotinho da contentação - que tem apenas o Runtime - Eu instalei o pacotão da alegria, que já vem com tudo, mas como disse antes, a escolha é sua.
• Pacotão da alegria é o gtk-win32-devel
• Pacotinho da contentação é o gtk-win32
Com o Gtk instalado já podemos rodar programas como o Gimp e outros.
PyGtk
Site: http://www.pcpm.ucl....orts/pygtk.html
Baixe o pacote em desenvolvimento.
Agora é hora de fazer a ponte entre o Gtk e o Python. Basta baixar o pacote e instalar, o que é bem simples.
Testando
Para testar, execute o Idle ou o próprio interpretador Python e de o comando:
>>> import gtk
Se o interpretador não chiar, você conseguiu smile.gif, senão tente seguir novamente os passos e caso alguma coisa continue a dar errado, mande uma email pra lista, que ajudamos a resolver.
Se quiser rodar algum programa, baixe o programa abaixo execute este exemplo.
Conclusão
É isso aí... Espero ter ajudado e até a próxima.
última edição 2006-02-05 01:01:31 efetuada por DouglasAndrade

LibGlade
libglade 2.4.0 tutorial versão 0.1
Wilson Freitas
1. Prefácio
1. Motivação
2. Introdução
1. Do que estamos falando?
3. Iniciando
1. Glade e a janela vazia
2. Fechando a janela
4. Seguindo adiante
1. Colocando uma caixa de diálogo
5. Para Contribuir
6. Créditos
7. Copyright
8. Referências
Prefácio
Motivação
A maior motivação para escrever esse primeiro tutorial foi: eu quero contribuir com Software Livre e quero fazer parte da comunidade, quero aprender e produzir, quero disseminar informação. Bem, como eu já tinha isso em mente, fui ao V FISL 2004, onde assisti uma palestra muito interessante sobre como ser um desenvolvedor de software livre, ministrada pelo Kiko e o Kov, dois grandes desenvolvedores e figuras da comunidade. Depois da apresentação, procurei os dois e falei: "eu quero ajudar". Simples assim. Foi aí que o Kiko falou que eu poderia contribuir com o projeto PyGtk e que seria interessante começar escrevendo um tutorial sobre libglade. E cá estou escrevendo sobre libglade. Antes disso, eu nunca havia usado o Glade, a libglade e também as bibliotecas GTK+ e GNOME. Já programava em Python e C o que facilitou alguma coisa. Depois de algumas semanas estudando essas bibliotecas, me senti finalmente seguro para escrever essa documentação. Espero que seja útil para alguém assim como foi importante para mim escrevê-la. Me coloco a disposição para dúvidas, sugestões e correções. Por favor, me ajude a tornar esse documento cada vez mais útil.
Quero registrar aqui o agradecimento ao Kiko e ao Kov pela oportunidade. Do coração, valeu a força.
Introdução
Do que estamos falando?
O assunto aqui é Libglade. Libglade é uma biblioteca que permite carregar uma interface gráfica (GUI) a partir de um arquivo XML e conecta os signal haldlers as funções de callback. A libglade foi desenvolvida por James Henstridge, mesmo autor do PyGtk, o binding de GTK+ para Python.
A libglade foi originalmente desenvolvida em C e já existem bindings para diversas linguagens (Python, C++, Java), contudo o foco deste tutorial é mostrar o uso da libglade com Python e PyGtk.
Um bom exemplo do poder da libglade é o Glade3 que está sendo completamente reescrito e não trará mais geração de código, a solução adotada foi o uso da libglade interpretando o XML gerado. Outros grandes projetos como o Gnumeric e o Evolution já usam a libglade.
Esse tutorial foi desenvolvido com:
• libglade-2.4.0
• glade-2.6.0
• pygtk-2.2.0
• python-2.3.3-r1
• gtk+-2.4.1
• gnome-2.6
sobre Gentoo linux (2.6.7-gentoo-r11).
Para maiores detalhes a respeito de PyGtk, aconselho o PyGTK 2.0 Tutorial escrito por John Finlay, é o documento must read sobre o assuto.
Iniciando
Glade e a janela vazia
Antes de começar qualquer coisa com libglade, precisamos de um XML que descreva um interface. Para isso usei o Glade.

Essa é uma sessão bastante imediata do glade. Basicamente, criei um projeto GTK+ e adicionei um objeto gtk.Window a ele. Ao salvar esse projeto, ele gera o seguinte arquivo XML.
<?xml version="1.0" standalone="no"?>
<!DOCTYPE glade-interface SYSTEM "http://glade.gnome.o...glade-2.0.dtd">

<glade-interface>

<widget class="GtkWindow" id="window1">
<property name="visible">True</property>
<property name="title" translatable="yes">window1</property>
<property name="type">GTK_WINDOW_TOPLEVEL</property>
<property name="window_position">GTK_WIN_POS_NONE</property>
<property name="modal">False</property>
<property name="resizable">True</property>
<property name="destroy_with_parent">False</property>
<property name="decorated">True</property>
<property name="skip_taskbar_hint">False</property>
<property name="skip_pager_hint">False</property>
<property name="type_hint">GDK_WINDOW_TYPE_HINT_NORMAL</property>
<property name="gravity">GDK_GRAVITY_NORTH_WEST</property>

<child>
<placeholder/>
</child>
</widget>

</glade-interface>
Isso já é o suficiente para vermos como funciona a libglade. O programa abaixo lê o arquivo XML e carrega a interface.
Toggle line numbers
1 import gtk, gtk.glade
2
3 gtk.glade.XML("empty.glade")
4 gtk.main()
Essa é a interface gerada por esse programa de 4 linhas.

Todo o trabalho sujo é feito pela classe gtk.glade.XML. Nela é feito o parse do XML e os objetos são carregados e estão prontos para serem manipulados.
Note que, ao fechar a janela, o programa ainda fica rodando, para finalizar basta digitar Crtl-C no console onde foi executado o programa. Isso acontece porque não foi feito nenhum tratamento de sinais no programa.
Fechando a janela
Para fechar a janela deve-se tratar o sinal que é disparado quando ela é destruída. Para isso, selecione a aba de sinais no Glade, escolha qual sinal quer tratar, nesse caso é destroy e informe qual é o handler para esse sinal.

O handler deve ser mapeado com uma função ou método de uma classe, e esse será executado quando o sinal for disparado. O código com o tratamento de sinais fica:
Toggle line numbers
1 import gtk, gtk.glade
2
3 dic = { "gtk_main_quit" : gtk.main_quit }
4
5 gladefile = gtk.glade.XML("empty.glade")
6 gladefile.signal_autoconnect(dic)
7
8 gtk.main()
Olhando novamente para a chamada gtk.glade.XML("empty.glade"), observa-se que um objeto é retornado. Esse objeto é o GladeXML que é identificado pela variável gladefile. Através desse objeto, tem-se acesso a toda estrurura montada no XML. O método signal_autoconnect recebe mapeamento das funções de callback com os handlers. É exatamente na chamada a signal_autoconnect que a libglade conecta o programa a interface fazendo com que os sinais sejam tratados da maneira definida.
Execute e veja que o programa agora é encerrado normalmente, executando a função gtk_main_quit quando o sinal destroy é disparado. Sei que não é de nenhuma utilidade uma janela vazia que fecha, mas entenda que a interface foi criada sem nenhuma interação com widgets e todo o trabalho de criar a estrutura da interface gráfica fica a cargo do glade e da libglade. E convenhamos que a criação da interface na mão é um pé saco, mesmo em Python smile.gif. Note que com a libglade é possível alterar a interface gráfica quantas vezes se fizer necessário, sem precisar recompilar o código para isso. É simples, rápido e limpo. O lema aqui é: quanto menos código, melhor.
Seguindo adiante
Ousando um pouco mais agora e com o intuito de levar a bancarrota os bancos de investimento, vamos construir uma calculadora de investimentos chamada InvestCalc. Ela calcula os dividendos de um investimento, para isso basta fornecer o montante investido mensalmente ou anualmente, a taxa de juros e o período de duração do investimento que ela informa o valor obtido no investimento. Segue uma amostra da interface desenvolvida no Glade.

Para calcular o valor obtido, é preciso obter as referências para os widgets de entrada de dados (gtk.Entry, gtk.Combo, gtk.SpinButton). Isso é feito através do seguinte método:
Toggle line numbers
1 ...
2 widget = gladefile.get_widget('widget_name')
Onde gladefile é uma referência para gtk.glade.XML e widget_name é o nome dado ao widget no Glade.

no XML fica assim:
...
<child>
<widget class="GtkEntry" id="entry_amount">
<property name="visible">True</property>
...
o código para obter as referências dos widgets de entrada de dados fica:
Toggle line numbers
1 ...
2
3 w_duration = gladefile.get_widget('spinbutton_duration')
4 w_return_rate = gladefile.get_widget('entry_return')
5 w_amount = gladefile.get_widget('entry_amount')
6 w_total_investment = gladefile.get_widget('label_total_investment')
7 w_duration_period = gladefile.get_widget('combo_duration_period')
8 w_amount_period = gladefile.get_widget('combo_amount_period')
9 help_dialog = gladefile.get_widget('dialog_help')
Obtidas as referências, vem o tratamento de sinais. Como foi visto anteriormente, o sinal também é associado ao widget através do Glade, só precisa informar qual sinal e o nome do handler para ele. Veja na figura que o sinal clicked do widget button_calculate está associado ao handler on_button_calculate_clicked.

Agora só precisa associar o sinal a uma função de callback no programa. Isso é feito colocando o handler como chave em um dicionário e a função como valor. Esse dicionário é passado como parâmetro para o método que faz a auto-conexão dos sinais.
Toggle line numbers
1 ...
2 def on_button_calculate_clicked(*args):
3 import math
4 # entry boxes
5 amount = float(w_amount.get_text())
6 return_rate = float(w_return_rate.get_text())
7 # spin button
8 duration = w_duration.get_value_as_int()
9 # combo boxes
10 duration_period = w_duration_period.entry.get_text()
11 amount_period = w_amount_period.entry.get_text()
12
13 if duration_period == 'Years':
14 duration *= 12
15 return_rate /= 100
16
17 total = 0.0
18 for i in range(duration):
19 if amount_period == 'Year':
20 if i%12 == 0:
21 total += (total*return_rate) + amount
22 else:
23 total += total * return_rate
24 else:
25 total += (total*return_rate) + amount
26
27 # label
28 w_total_investment.set_text('$ %.2f' % total)
29
30 dic = { 'on_window1_destroy' : lambda win: gtk.main_quit(),
31 'on_button_calculate_clicked' : on_button_calculate_clicked,
32 ... }
33 ...
34 gladefile.signal_autoconnect(dic)
Toda vez que o botão Calculate for clicado a função on_button_calculate_clicked será executada e o valor obtido inpresso na label. Veja o InvestCalc em ação:

Atente para o uso dos widgets que foram obtidos anteriormente. Os valores foram capturados das caixas de texto e combo boxes, calculados e impressos em um label. Todos esse objetos, assim como toda a interface, foram instanciados pela libglade. Pode-se mudar os botões e os demais widgets de posição e não mexer em uma linha sequer de código. Pode-se mudar todo o design sem precisar recompilar o programa. Lembre-se: quanto menos código, melhor.
Colocando uma caixa de diálogo
Toda aplicação que se preze deve ter uma caixa de diálogo com pelo menos o nome do autor. Pois bem, para incluir essa caixa criei o botão button_help e associei ao sinal clicked o handler on_button_help_clicked. No Glade, criei uma caixa de diálogo chamada dialog_help com um botão Close. A esse botão, associei o seu sinal clicked ao handler on_closebutton_dialog_clicked. Criei as duas funções callback e e as adicionei ao dicionário para a auto-conexão, como segue:
Toggle line numbers
1 ...
2 def on_button_help_clicked(*args):
3 help_dialog.show()
4
5 def on_closebutton_dialog_clicked(*args):
6 help_dialog.hide()
7
8 dic = { 'on_window1_destroy' : lambda win: gtk.main_quit(),
9 'on_button_calculate_clicked' : on_button_calculate_clicked,
10 'on_button_help_clicked' : on_button_help_clicked,
11 'on_closebutton_dialog_clicked' : on_closebutton_dialog_clicked }
12
13 gladefile.signal_autoconnect(dic)
ao clicar no botão Help aparecerá:

o código na integra:
Toggle line numbers
1
2 import gtk
3 import gtk.glade
4
5 gladefile = gtk.glade.XML('investcalc.glade')
6
7 # widgets
8
9 w_duration = gladefile.get_widget('spinbutton_duration')
10 w_return_rate = gladefile.get_widget('entry_return')
11 w_amount = gladefile.get_widget('entry_amount')
12 w_total_investment = gladefile.get_widget('label_total_investment')
13 w_duration_period = gladefile.get_widget('combo_duration_period')
14 w_amount_period = gladefile.get_widget('combo_amount_period')
15 help_dialog = gladefile.get_widget('dialog_help')
16
17 # callback functions
18
19 def on_button_calculate_clicked(*args):
20 import math
21 amount = float(w_amount.get_text())
22 return_rate = float(w_return_rate.get_text())
23 duration = w_duration.get_value_as_int()
24 duration_period = w_duration_period.entry.get_text()
25 amount_period = w_amount_period.entry.get_text()
26
27 if duration_period == 'Years':
28 duration *= 12
29 return_rate /= 100
30
31 total = 0.0
32 for i in range(duration):
33 if amount_period == 'Year':
34 if i%12 == 0:
35 total += (total*return_rate) + amount
36 else:
37 total += total * return_rate
38 else:
39 total += (total*return_rate) + amount
40
41 w_total_investment.set_text('$ %.2f' % total)
42
43 def on_button_help_clicked(*args):
44 help_dialog.show()
45
46 def on_closebutton_dialog_clicked(*args):
47 help_dialog.hide()
48
49 dic = { 'on_window1_destroy' : lambda win: gtk.main_quit(),
50 'on_button_calculate_clicked' : on_button_calculate_clicked,
51 'on_button_help_clicked' : on_button_help_clicked,
52 'on_closebutton_dialog_clicked' : on_closebutton_dialog_clicked }
53
54 gladefile.signal_autoconnect(dic)
55
56 gtk.main()
Todo o código produzido para esse artigo pode ser encontrado aqui http://www.aboutwils...ial-code.tar.gz. Divirta-se.
Para Contribuir
Este documento, assim como muitos outros software livres, foi criado por voluntários. Se existe algum tópico a respeito do tema que este documento não contempla, por favor ajude a mantê-lo completo enviando essas informações ou escrevendo você mesmo uma seção ou trecho de alguma seção.
Atente para o fato de que esse documento é livre e qualquer conteúdo adicionado a ele também deverá ser.
Se você realmente quiser contribuir, envie um email para Wilson Freitas <wilson (a) econofisica com br>.
Obrigado.
Créditos
Agora eu vou falar sobre o que tornou esse documento possível:
• Jonh Finlay, <finlay (a) moeraki com> pelo tutorial de PyGtk.
• txt2tags http://txt2tags.sf.net.
• Lissandra pelo carinho e Pedrinho pelo bom humor.
• E todos os que eu espero que leiam e ajudem a contribuir com esse documento.
Copyright
Libglade Tutorial © 2004 Wilson Freitas.
Esse documento está licenciado sob a GNU Free Documentation License, publicada pela Free Software Foundation.
É permitido distribuir cópias deste manual, desde que se forneça o Copyright em todas as cópias.
Se você p



Responder



  


8 usuário(s) está(ão) lendo este tópico

0 membros, 8 visitantes, 0 membros anônimos