Arquivo para objetos

Mais DrawingArea, Orientação a objetos e herança (e glade)

Posted in Programação, pygtk, Python with tags , , , , , on 30 / junho / 2008 by medeubranco

Este artigo mistura um pouco de tudo o que foi visto nos artigos anteriores:

Criando uma simples janela em PyGTK
Criando uma simples janela em PyGTK – parte II
DrawingArea – Desenhando na tela com PyGTK
Orientação a Objetos com python
Orientação a Objetos – Herança

Como aqui vamos usar o Glade, recomendo também uma visita ao blog do OgMaciel:

Vídeo Aula: Programando com Python e Glade

Vídeo Aula: Trabalhando com o Glade

Não deixe de ver também Mantendo A Sanidade Com O Glade.

Neste artigo vamos criar um programa em que você pode desenhar um polígono desenhando com o mouse.

Para isso, vamos estender a classe gtk.DrawingArea através da herança. Nossa classe estendida vai ser um DrawingArea com recursos que nós vamos adicionar.

Paralelamente, vamos fazer uma janela com o glade, um código que vai exibir a janela inserindo nela a nossa classe filha de DrawingArea.

A nossa classe tela herdando de DrawingArea:


import gtk

# do modulo gtk, importamos DrawingArea e vamos chamar de 'DA'
from gtk import DrawingArea as DA

class tela(DA):
    def __init__(self):
        # executanto o construtor da classe pai (DrawingArea)
        DA.__init__(self)

Agora temos uma classe que faz tudo o que um DrawingArea faz. Podemos acrescentar recursos a ela.

Enquanto isso, vamos fazer a GUI no glade:
– crie uma janela;

– adicione uma “Caixa Vertical” (Vbox) com três itens;

– adicione um Rótulo (Label) na primeira seção da Caixa Vertical;

– em Empacotamento, mude para “não” as opções Expandir e Preencher;

– adicione um botão e em Geral mude o nome para ‘botão1’ (é, poderia ter ficado Button1 mesmo);

– em Empacotamento, mude para “não” as opções Expandir e Preencher;

– no espaço do meio, adicione uma ‘Porta de Visualização’ (ViewPort) ;

– mude o nome da ViewPort para ‘caixatela’

– explore as outras opções de configuração dos widgets

Sua janela deve ficar quase assim:


Voltemos à nossa classe.

O nosso widget será usado da seguinte forma:

Você pressiona o botão esquerdo do mouse sobre o widget e mantém pressionado. Arrasta então o ponteiro do mouse pela tela; uma linha será desenhada por onde passar o ponteiro. Ao soltar o botão do mouse, a linha se fechará em um polígono.

Ao Rolar a ‘rodinha’ do mouse, os últimos pontos do polígono serão removidos; continue rolando a rodinha que o polígono desaparecerá.

Temos então três eventos envolvidos na criação do desenho: botão pressionado, movimento do mouse e botão solto (‘button-press-event’, ‘button-release-event’ e ‘motion-notify-event’ ). Um quarto evento, o de rolagem da rodinha (‘scroll-event’ ), está envolvido na operação de remover pontos do polígono.


class tela(DA):
    def __init__(self):
        DA.__init__(self)
        self.definecores()

        # atributo que determina se o botão está pressionado
        self.apertou=False

        # conectando o expose-event a uma função
        # que vai pedir que a tela seja redesenhada
        self.connect('expose-event',self.expose)

        # adicionando os eventos de mouse
        self.add_events(gtk.gdk.BUTTON_PRESS_MASK |
            gtk.gdk.BUTTON_RELEASE_MASK |
            gtk.gdk.MOTION_NOTIFY |
            gtk.gdk.POINTER_MOTION_MASK
            )

        # conectando cada evento à sua função correspondente

        # botão de mouse pressionado
        self.connect('button-press-event',self.clica)
        # soltando o botão
        self.connect('button-release-event',self.solta)
        # movimento de mouse
        self.connect('motion-notify-event',self.arrasta)
        # rolando a 'rodinha'
        self.connect('scroll-event',self.rolou)

        # criando uma lista vazia
        # que vai conter os pontos da linha a ser desenhada
        # ou o polígono
        # cada ponto será uma tupla
        # com as coordenadas (x,y)
        self.linha=[]

Olhe o código acima, nas linhas 23, 25, 27 e 29. Quatro funções terão que ser definidas. Vejamos o que cada uma deve fazer:

self.clica

  • mudar a variável self.apertou para True
  • adicionar o primeiro ponto (as coordenadas do clique) à lista self.linha

self.arrasta

  • se self.apertou é True, adiciona mais um ponto À lista e desenha o último segmento.

self.solta

  • mudar a variável self.apertou para False

– self.rolou

  • remover o último ponto da lista e mandar a tela ser redesenhada
    def solta(self, tela, evento):
        self.apertou=False
        self.desenha()

    def clica(self, tela, evento):
        if evento.button==3:
            self.linha.pop()
            return
        self.linha.append((evento.x,evento.y))
        self.apertou=True

    def rolou(self,tela,evento):
        try:
            self.linha.pop()
            self.desenha()
        except:
            pass

    def arrasta(self,tela,evento):
        if self.apertou:
            self.linha.append((evento.x,evento.y))

Movendo o mouse com o botão pressionado

Após soltar o botão

O código completo da classe:


import gtk
from gtk import DrawingArea as DA

class tela(DA):
    def __init__(self):
        DA.__init__(self)
        self.definecores()

        self.apertou=False
        self.connect('expose-event',self.expose)
        self.add_events(gtk.gdk.BUTTON_PRESS_MASK |
            gtk.gdk.BUTTON_RELEASE_MASK |
            gtk.gdk.MOTION_NOTIFY |
            gtk.gdk.POINTER_MOTION_MASK
            )
        self.connect('button-press-event',self.clica)
        self.connect('button-release-event',self.solta)
        self.connect('motion-notify-event',self.arrasta)
        self.connect('scroll-event',self.rolou)
        self.linha=[]

    def definecores(self):
        self.verde=gtk.gdk.Color(0,48255,0,0)
        self.preto=gtk.gdk.Color(0,0,0,0)
        self.branco=gtk.gdk.Color(65535,65535,65535,0)
        self.vermelho=gtk.gdk.Color(65535,0,0,0)
        self.amarelinho=gtk.gdk.Color(35535,65333,15000,0)
        self.outra=gtk.gdk.Color(0,65535,65535,0)
        self.azul=gtk.gdk.Color(0,0,65535,0)

    def desenhaultimo(self):
        if len(self.linha)>1:
            x1=int(self.linha[-2][0])
            y1=int(self.linha[-2][1])
            x2=int(self.linha[-1][0])
            y2=int(self.linha[-1][1])

            self.gc.set_rgb_fg_color(self.vermelho)
            self.window.draw_line(self.gc,x1,y1,x2,y2)

            self.gc.set_rgb_fg_color(self.preto)
            self.window.draw_rectangle(self.gc,False,x1-1,y1-1,2,2,)
            self.window.draw_rectangle(self.gc,False,x2-1,y2-1,2,2,)

    def solta(self, tela, evento):
        self.apertou=False
        self.desenha()

    def clica(self, tela, evento):
        if evento.button==3:
            self.linha.pop()
            return
        self.linha.append((evento.x,evento.y))
        self.apertou=True

    def rolou(self,tela,evento):
        try:
            self.linha.pop()
            self.desenha()
        except:
            pass

    def arrasta(self,tela,evento):
        if self.apertou:
            self.linha.append((evento.x,evento.y))
            self.desenhaultimo()

    def apaga(self):
        for pt in self.linha:
            print pt
        self.linha=[]
        self.desenha()

    def desenha(self):
        a,b,c,d = self.get_allocation()
        self.gc.set_rgb_fg_color(self.branco)
        self.window.draw_rectangle(self.gc,True,0,0,c-1,d-1)

        if len(self.linha)>0:
            self.gc.set_rgb_fg_color(self.amarelinho)
            self.window.draw_polygon(self.gc,True, self.linha)
            self.gc.set_rgb_fg_color(self.preto)
            self.window.draw_polygon(self.gc,False, self.linha)

        self.gc.set_rgb_fg_color(self.preto)
        self.window.draw_rectangle(self.gc, False,2,2,c-4,d-4 )
        for pt in self.linha:
            self.window.draw_rectangle(self.gc, False,pt[0]-1, pt[1]-1,2,2)

    def expose(self,tela, evento):
        self.gc=self.get_style().fg_gc[gtk.STATE_NORMAL]
        self.gc.set_rgb_fg_color(self.branco)
        self.desenha()

Para entender as operações de desenho, veja o artigo anterior: DrawingArea – Desenhando na tela com PyGTK

Salve este código como desenha.py

Salve seu projeto no Glade como parapintar.glade

E execute o código abaixo, que vai reunir tudo:


#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Código parcialmente reaproveitado
do código exemplo do OgMaciel
em http://blog.ogmaciel.com/?p=413
"""

import desenha
try:
    import pygtk
    pygtk.require( "2.0" )
except:
    pass
try:
    import gtk
    import gtk.glade
except:
    sys.exit(1)

class Janelao(object):
    """
    Janela criada com o Glade
    """

    def __init__(self):
        self.xml = gtk.glade.XML( "parapintar.glade" )
        self.xml.signal_autoconnect(self)

        self.mainWindow = self.xml.get_widget( 'window1' )
        self.mainWindow.set_title( "Pintor" )

        # puxando a ViewPort criado no glade
        self.caixa=self.xml.get_widget( 'caixatela' )
        self.mainWindow.connect('destroy', gtk.main_quit)

        self.botao = self.xml.get_widget( 'botao1' )

        # criando uma instancia do nosso objeto
        self.tela=desenha.tela()
        #inserindo nosso objeto na viewport
        self.caixa.add(self.tela)

        self.botao.connect("clicked",self.apagar_tela)
        self.tela.show()
        self.mainWindow.show_all()

    def apagar_tela(self,botao):
        self.tela.apaga()

if __name__ == "__main__":
    w = Janelao()
    gtk.main()
Anúncios

Herança – orientação a objetos com python

Posted in Linux, Programação, Python with tags , , , , , on 22 / junho / 2008 by medeubranco

Atenção: se você ainda não sabe nada sobre orientação a objetos, leia o artigo anterior.

Uma característica legal de programação orientada a objetos é a Herança. Uma classe pode herdar características de outra (superclasse) e incluir suas próprias. A superclasse é mais genérica, a subclasse, que herda da superclasse, é mais especializada.

Usando o exemplo clássico dos livros e tutoriais de programação, imaginemos a superclasse “Animal”; “Mamífero” é uma subclasse de “Animal” e herda suas características. Mas “Mamífero” tem suas próprias características. “Felino” é uma subclasse de “Mamífero”; “Gato” é uma subclasse de “Felino”.

Herdando as características de “felino”, “Gato” herda também as de “Mamífero” e “Animal”. Mas gato mia e arranha o sofá, coisa que nem todo animal faz.

Em Python seria mais ou menos assim:

# definindo a classe Animal:
class Animal:
    def __init__(self):
        # codigo  para o init aqui
    # metodos de Animal aqui

#definindo a classe Mamifero, herdando de Animal
class Mamifero(Animal):
    def __init__(self):

# definindo Felino
class Felino(Mamifero):

# definindo Gato
class Gato(Felino):

No artigo sobre orientação a objetos, nós criamos a classe TiaVelha.

Agora vamos criar uma classe nova. É a Fofoqueira. Uma Fofoqueira é basicamente uma Tia Velha, mas que faz fofocas – nem toda tia velha faz fofocas. A Fofoqueira é especializada no leva-e-traz.

Acho que ficou implícito que, para criar uma Fofoqueira, basta pegar uma Tia Velha e adicionar a ela o leva-e-traz.

Vamos ao código. Se quiser executar o exemplo, primeiro crie uma pasta para nosso exercício. Salve nela o código da TiaVelha, do outro artigo, com o nome tiavelha.py.

Os métodos da Fofoqueira são leva(fofoca) e traz().

O método leva(fofoca) adiciona uma fofoca qualquer ao repertório de fofocas da Fofoqueira. A Fofoqueira não inventa nada; só repassa o que viu ou ouviu.

No método traz(), a fofoqueira solta de uma vez todas as fofocas do seu repertório.

from tiavelha import *
class fofoqueira(TiaVelha):
    def __init__(self,nome,idade):
        TiaVelha.__init__(self,nome, idade)
        self.fofocas=[]

    def leva(self,fofoca):
        self.fofocas.append(fofoca)

    def traz(self):
        for fofoca in self.fofocas:
            print fofoca

Na linha 1 importamos o conteudo do ‘módulo’ tiavelha. A classe TiaVelha agora está disponível no nosso código.

Na linha 2 a classe fofoqueira é definida; TiaVelha entre parêntesis indica que fofoqueira herda de TiaVelha.

Na linha 3 precisamos chamar o método __init__ da superclasse, pois __init__ sendo redefinido em fofoqueira substitui o método com o mesmo nome da superclasse.

Das linhas 7 a 12 colocamos os métodos típicos da fofoqueira.

Os métodos apresentar_se() e falar(), da TiaVelha estão disponíveis para fofoqueira.

Salve o códico como fofoqueira.py na mesma pasta onde salvou tiavelha.py.

Para concluir, vamos fazer um código que usa a classe fofoqueira:

import fofoqueira
lina=fofoqueira.fofoqueira('Alvelina',32)
lina.apresentar_se()
lina.falar()
lina.traz()
lina.leva( "A Luiza trocou de namorado de novo" )
lina.leva( "O Pedro terminou com a amante" )
lina.traz() 

Orientação a objetos com python para iniciantes

Posted in Linux, Programação, Python with tags , , , , , on 22 / junho / 2008 by medeubranco

Python é uma linguagem orientada a objetos. Nos artigos anteriores, não usei essa característica da linguagem para manter o “direto ao ponto”.

Este artigo é para quem ainda não sabe nada de OOP (ou POO), como é o caso do colega que o motivou.

Indo direto ao ponto, vamos pegar um “objeto” conhecido e criar uma classe que o represente.

A nossa classe vai contemplar seus atributos e seu comportamento (o que o nosso objeto faz).

Nosso objeto vai ser a tia velha. Seus atributos serão o nome e idade (que faz dela tia velha), além das coisas que ela fala (coisas típicas de tia). Seu comportamento, ou ação, é falar aleatoriamente as coisas que toda tia velha fala.

Repare que o que foi dito sobre a classe “tia velha” se aplica a toda e qualquer tia velha, independente de nome, idade ( pode ter tia velha de vinte e poucos anos, acredite ) ou de quem é o sobrinho.

vamos ao código

import random

# inicio da definicao da classe
class TiaVelha:
    def __init__(self, nome, idade):
        """
        inicializador da classe.
        cada tia velha criada
        serah criada por este metodo init
        """

        #definindo os atributos
        self.nome=nome
        self.idade=idade
        self.frases=[]

        #criando o repertorio de frases
        self.frases.append( "Como voce cresceu!" )
        self.frases.append( "Voce precisa arrumar uma namoraaaada!" )
        self.frases.append( "Voce ainda nao arrumou emprego?!!" )
        self.frases.append( "Respeita sua mae, menino!" )
        self.frases.append( "Gracinha!" )

    def falar(self):
        """
        metodo principal da tia velha
        """
        x=len(self.frases)
        n=int(random.random()*x-1)
        print self.frases[n]

    def apresentar_se(self):
        print   """
                Ola.
                Meu nome eh """ + self.nome + """
                e tenho """ + str(self.idade)  + """ anos.
                Sou uma tia velha e o que mais faco eh falar
                """

# o codigo abaixo somente
# sera executado se este
# arquivo for executado
# diretamente.
#
# nao o serah se a classe
# TiaVelha for importada
# para dentro de outro
# programa python
if __name__=='__main__':

    # criando uma 'nova' tia velha
    # com nome 'Odila' e idade 67
    # eh neste momento que __init__()
    # serah chamado
    odila=TiaVelha('Odila',67)

    # executando um metodo
    odila.apresentar_se()

    print
    print
    print

    # fazendo a tia odila falar 15 vezes
    for x in range(15):
        odila.falar()

A linha 1 import random só entrou neste programa porque no método falar(self) foi preciso usar números aleatórios.

Explicar o resto acho que é redundância.

Este artigo teve a intenção de apresentar orientação a objetos a quem ainda nada sabia a respeito.

Pesquisa e treinamento são necessários para se aprofundar no assunto.