InFog

Um blog sobre GNU, Linux, Open Source, Desenvolvimento e Nerdices em Geral

Curso de Python – Aula 19 – PyGTK e sua documentação

Tags: , ,

Olá pessoal!

Aqui vamos nós para mais uma aula de Python!

Mas antes disso eu gostaria de lembra-los que a vaquinha para nos ajudar na viagem de lua de mel ainda está rolando! Já tivemos algumas contribuições e eu agradeço muito aos que ajudaram, mas infelizmente ainda estamos longe até mesmo de 10% do valor =( Se você quiser ajudar também basta clicar na simpática vaquinha abaixo e doar.

Vakinha Lua de Mel em Buenos Aires

Dado o recado vamos à aula!

Hoje veremos um pouco mais sobre os conectores e também vamos aprender a encontrar respostas na documentação do PyGTK.

É através dos conectores que nós conseguimos ligar as ações do usuário na interface às funções do programa. Na aula 16, nosso primeiro contato com PyGTK, já existe uma demonstração de um conector ligando o evento “clique” de um botão à função “ola_mundo“.

Primeiro precisamos saber que não existe apenas o sinal ‘clicked’, alguns widgets do PyGTK apresentam outros tipos de sinais, então nossa missão é descobrir que sinais são esses. Mas como faremos isso? Simples, basta ter alguns conhecimentos que você já deve possuir: Leitura e Navegação na Web heheh. Na página de referência do PyGTK você encontra a documentação de todos os componentes desta API.

Pois bem, vamos fazer o seguinte exemplo: Uma janela com um rótulo e um botão, quando o mouse passar sobre o botão o rótulo deve dizer “O mouse está sobre o botão!” e quando deixa-lo a mensagem muda para “O mouse saiu de cima do botão!”. Aqui está um modelo para a janela:

aula_19_1

Janelinha bonitinha, não? Fiz no Inkscape =)

Bem, agora que já temos o modelo precisamos escrever o código para esta janela:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#!/usr/bin/env python
# -*- coding=utf-8 -*-
import pygtk
import gtk
class CJanela():
    __doc__ = """
        Classe CJanela, desenha uma janela com um label e um botão em uma
        caixa vertical.
    """

    def __init__(self):
        self.janela = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.janela.set_title("Aula 19, Sinais")
        self.rotulo = gtk.Label()
        self.botao = gtk.Button("Passe o mouse")
        self.caixa = gtk.VBox()
        self.caixa.pack_start(self.rotulo)
        self.caixa.pack_start(self.botao)
        self.janela.add(self.caixa)
        self.janela.show_all()
janela = CJanela()
gtk.main()

Vejam que desta vez estou usando uma metodologia diferente, fiz uma classe CJanela que é a responsável por exibir a janela e seu conteúdo. Acredite em mim esta metodologia facilita muito o acesso aos widgets.

Ora, ora, já temos a janela com o rótulo e o botão, agora nos resta programar as ações e “mouse sobre” e “mouse sai”. Então vamos recorrer à documentação do PyGTK, como vamos usar os sinais do botão então é a documentação deste que devemos ver.

Vejam na área “gtk.Button Signal Prototypes“, este widget nos oferece seis sinais: activate, clicked, enter, leave, pressed e released. Para o que queremos fazer os sinais ‘enter’ e ‘leave’ serão suficientes. Reparem que na referência diz que o sinal ‘clicked’ é praticamente o único que uma aplicação precisa, mas não aqui nas aulas do InFog heheh.

Então vamos criar as funções ‘mouse_sobre’ e ‘mouse_saiu’, elas serão as responsáveis por alterar o texto do rótulo, e usaremos os conectores para ligar os sinais do botão à estas funções, vejam o código:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#!/usr/bin/env python
# -*- coding=utf-8 -*-
import pygtk
import gtk
class CJanela():
    __doc__ = """
        Classe CJanela, desenha uma janela com um label e um botão em uma
        caixa vertical.
    """

    def __init__(self):
        self.janela = gtk.Window(gtk.WINDOW_TOPLEVEL)
        self.janela.set_title("Aula 19, Sinais")
        self.rotulo = gtk.Label()
        self.botao = gtk.Button("Passe o mouse")
        self.botao.connect('enter', self.mouse_sobre)
        self.botao.connect('leave', self.mouse_saiu)
        self.caixa = gtk.VBox()
        self.caixa.pack_start(self.rotulo)
        self.caixa.pack_start(self.botao)
        self.janela.add(self.caixa)
        self.janela.show_all()
    def mouse_sobre(self, widget):
        self.rotulo.set_text("O mouse está sobre o botão!")
    def mouse_saiu(self, widget):
        self.rotulo.set_text("O mouse saiu de cima do botão!")
janela = CJanela()
gtk.main()

Vejam o resultado:

captura_de_tela-aula-19-sinais

captura_de_tela-aula-19-sinais-1

Bem simples né? O legal do PyGTK é que na maioria das vezes, para aplicações mais simples, a sua preocupação será com o negócio e não com o PyGTK com em sí, já que sua manipulação não é algo tão complexo.

E essa foi a nossa aula de hoje, espero que tenham gostado e aprendido bastante.

Lição de Casa!

Rá! Pensou que ia ficar só nisso né? Agora é a hora de botar a cachola para funcionar! A lição de hoje é simples, quero que vocês façam uma janela com um rótulo e quatro botões: “maximizar“, “desfazer maximização“, “tela cheia” e “desfazer tela cheia“. Quando clicados os botões devem fazer as devidas ações e o rótulo deve mostrar o status da janela, exemplo: “Janela Maximizada“, “Janela em Tela Cheia“, etc. Boa sorte! E não se esqueça de contribuir com a nossa Vakinha!

15 Comentários

Curso de Python – Aula 18 – Refrescando a memória e praticando.

Tags: ,

Olá pessoal!

A aula de hoje não é bem uma aula, mas sim um desafio muito interessante para vocês. No site do Python Brasil existe uma Lista de Exercícios, e a primeira leva de exercícios é sobre Estrutura Sequêncial. Na verdade estes exercícios são válidos para qualquer linguagem de programação que você queira praticar, mas aqui vamos usar para Python.

Eu acredito que essa primeira sequencia de 17 exercícios é muito boa para relembrar alguns conceitos e treinar. Então vou fazer algo há muito pedido por vocês, uma lista com todas as aulas. Essa lista vai ficar aqui neste post, por enquanto, mas depois vou coloca-la na lateral do blog, assim facilita ainda mais achar as aulas.

Aqui está a tão aguardada lista:

Aula 1 – A proposta

Aula 2 – Conceitos e variáveis

Aula 3 – Comentários, docstrings e números

Aula 4 – Mais números e a biblioteca Math

Aula 5 – Matemática, recados e strings

Aula 6 – Um pouco mais sobre strings

Aula 7 – Python 3 e “Que caminho seguir?”

Aula 8 – Mais sobre operadores e conhecendo as listas e o “for”

Aula 9 – Mais sobre listas e um pouco de “aleatoriedade”

Aula 10 – Entrada de dados e formatação de strings

Aula 11 – Funções e exercícios

Aula 12 – Manipulando arquivos

Aula 13 – Passando argumentos via terminal

Aula 14 – Orientação à Objetos

Aula 15 – Mais sobre Orientação à Objetos

Aula 16 – Iniciando no PyGTK

Aula 17 – Mais sobre o PyGTK

Ufa, que trabalhão, mas agora fica mais fácil de manter hehe.

Bem, então é isso, tentem fazer os 17 exercícios da lista e boa sorte! Em breve mais PyGTK!

9 Comentários

Sobre as Aulas de Python, a Revista Espírito Livre e o WP Multi Language Changer

Tags: , , , ,

Olá pessoal!

Hum, deixa eu adivinhar, vocês devem estar esperando a próxima aula de Python, certo? Ok, eu também percebi que a regularidade das aulas caiu um pouco, afinal de contas já faz 15 dias desde a útima publicação, mas não fiquem tristes! Novas aulas virão, eu só dei uma pausa para descansar um pouco e pensar em uns assuntos interessantes, o PyGTK ainda vai render aulas bem interessantes. Um outro motivo de eu ter parado as aulas é que várias pessoas começaram a fazer os exercícios agora devido à  esta dica no Viva o Linux, obrigado Luiz Vieira! Bem , para fechar esse assunto eu deixo a promessa de que no próximo fim de semana teremos uma nova aula, certo?

Também quero falar para vocês do lançamento da primeira edição da Revista Espírito Livre, um ótimo projeto encabeçado pelo João Fernando, da Iniciativa Espírito Livre, e que conta com colunas e artigos de muita gente que vocês devem conhecer da cena do Software Livre nacional e internacional. E eu tive o prazer de ser convidado para escrever uma coluna para a revista, nesta edição falei sobre a LPI e para a próxima ainda estou pensando, mas já aceito sugestões! Então não perca tempo, baixe agora o seu exemplar, aproveite o fim de domingo para ler muita coisa legal.

Uma outra notícia legal que tenho para vocês é o lançamento do meu primeiro plugin para WordPress, o WP Multi Language Changer, ok, o nome não ficou muito bom, mas dá a ideia do que ele faz =)

Escrever este plugin para o WordPress não foi algo tão complexo de ser feito, a documentação do site do WordPress não é lá tão farta assim e eles mesmo indicam outra página onde você pode encontrar todos os “hooks” e “actions” disponíveis, mas mesmo assim foi uma experiência bem legal. Como eu tinha uma vaga ideia de que o desenvolvimento do plugin não seria algo tão complexo eu decidi aprender a brincar com o tal do Git, o sistema de versionamento do sr. Torvalds. Eu já uso o Subversion há um certo tempo e posso dizer que o Git é um carinha “diferente”. Fazer o chackout e os commits da vida foi bem tranquilo, até que o sr PotHix resolveu fazer um fork do plugin e me enviar uma requisição de “pull“, ou seja adicionar as alterações dele ao projeto principal. Como foi apenas uma linha eu me tentei a apenas copiar o que ele mudou e pronto. Mas acabei levando uma bronca… “Aprenda a usar”, “Faça o merge direito”, “Vai ficar copiando e colando código para sempre?” … E resolvi fazer a coisa do jeito certo, usando esse texto, indicado pelo próprio PotHix, eu consegui fazer o merge e no fim das contas descobri como isso é fácil, aliás, com uns 4 comandos dá para fazer =) Depois eu ensino isso hehe.

No fim das contas foi mais “aventura” aprender a usar o Git do que fazer o plugin em sí.

Bem, vou ficando por aqui, obrigado à todos que estão acompanhando pacientemente as aulas de Python!

3 Comentários

© 2009 InFog. All Rights Reserved.

This blog is powered by Wordpress and Magatheme by Bryan Helmig.