Outras línguas:

Introdução à Eagle

Eagle é uma camada de abstração acima de Toolkits Gráficos para deixar programação GUI o mais fácil possível. A Eagle possibilita isso reduzindo o que pode ser feito, porém provê componentes de alto nível com uma API fácil de usar.

Eagle não foi feita para criar qualquer interface de usuário, mas sim focada em interfaces específicas com 5 áreas (esquerda, direita, cima, baixo e centro), cada uma provê barras de rolagem e componentes de "layout" para conteúdo: esquerda, direita e centro provem barras de rolagens e layout verticais, enquanto cima e baixo usam horizontal. Eagle trata cada janela como uma aplicação (App), porém seu aplicativo pode ter várias destas.

Cada App provê uma janela de preferências, uma sub-janela presa a ela e que será responsável por salvar e recuperar o valor de seus componentes automaticamente junto com outros componentes persistentes da App.

Todo componente tem um nome de identificação (id) e pode ser acessado por ele, portanto você pode evitar variáveis globais para acessar componentes. Cada id tem o escopo da aplicação a qual ele pertence e portanto uma instância de componente pode estar em apenas uma App. Você também pode acessar as instâncias dos componentes com get_widget_by_id( id, app_id ), app_id pode ser omitido, a primeira aplicação declarada será usada, isto é útil quando você tem apenas uma, economizando digitação. Alguns componentes não precisam receber um id (App, botões customizados como CloseButton) já que você geralmente não usa seus ids diretamente (provavelmente eles já fazem tudo, como QuitButton que sai do programa), estes serão nomeados sequencialmente. Todo widget pode ser acessador usando a sintaxe de dicionário do Python, sendo a chave o id.

Todos os componentes de entrada podem ser persistentes, isto é, seus conteúdos serão salvos em um arquivo depois de modificados e serão carregados automaticamente deste arquivo quando a aplicação iniciar. Componetes que estão nas preferências da App serão marcados como persistentes automaticamente, outros componentes devem ser marcados com o parâmetro persistent=True.

Todos os componetes de entrada ou saída têm uma API comum para mudar/pegar o seu valor, você pode usar os métodos set_value( new_value ) ou get_value() se você gosta de Programação Orientada a Objetos ou você pode usar as funções set_value( component_id, new_value, app_id ) ou get_value( component_id, app_id ) se não gosta. Eagle tem um suporte especial para componentes de entrada e saída se você usar a sintaxe de dicionário: ele já usa automaticamente set_value ou get_value conforme necessário:

# é mais fácil escrever
valor = minha_app[ "my_widget" ]
minha_app[ "my_widget" ] = valor

# do que
meu_widget = get_widget_by_id( minha_app, "meu_widget" )
valor = meu_widget.get_value()
meu_widget.set_value( valor )

Exemplo de acesso usando a sintaxe de dicionário.

Componentes de entrada e Botões provem um "callback" (uma função que será chamada pela biblioteca) para notificar qualquer ação. Os componentes de entrada chamam a função com app_id, component_id e valor como parâmetros quando seu conteúdo muda, enquanto botões chamam a função com app_id e component_id quando clicado. Eagle, diferentemente de outros toolkits como GTK, Qt, Tk e outros, não provê vários callbacks para o mesmo componente, como duplo-clique ou mouse-over, apenas o callback que faz mais sentido. Isso deixa a programação muito mais fácil e a GUI com usabilidade consistente. Porém existem algumas exceções: App provê 2 callbacks: um para notificar que algum dado foi alterado (se você usa o mesmo callback para todo componente de entrada, você pode usar esse e evitar digitação!) e outro que é chamado antes da App fechar, Canvas ao redimensionar em adição às callbacks eventos de mouse, Table para quando a seleção mudou em adição às callbacks para quando os dados mudaram.

Show room da Eagle

Show room da Eagle.

Eagle show room annotated

Show room da Eagle com anotações.

Instalando Eagle

O código da Eagle esta disponível em um repositório SVN: http://code.google.com/p/eagle-py/

Para baixar: svn co http://eagle-py.googlecode.com/svn/trunk/ eagle-py cd eagle-py

Então use o distutils do Python para instalar: python setup.py install

Olá Mundo!

Vamos criar um programa simples, ele mostrará a mensagem Olá Mundo como um botão, e quando clicado mostrará a mesma mensagem na saída padrão e sairá do programa.

from eagle import *

def meu_callback( app, widget ):
   print "Ola Mundo"
   quit()

App(
   title="Ola Mundo",
   center=Button(
      id="botao",
      label="Ola Mundo",
      callback=meu_callback,
      )
   )

run()

helloworld.py

A primeira coisa que devemos fazer é importar os símbolos do módulo eagle. Para simplificar, nós importamos tudo.

Então definimos uma função que recebe dois parâmetros, uma referéncia para a aplicação e o widget que foi a fonte do evento. Esta função é bem simples, ela imprime (print) a mensagem e então chama a função quit() da Eagle, que pára o laço principal (que é executado em run()).

Em seguida nós declaramos a interface de usuário, passando um título e um widget para a posição central. Este widget é a instância da classe Button, que recebe como argumento o id, um rótulo (label) e a função para chamar quando o botão for pressionado (callback).

Quase acabamos, apenas precisamos entrar no laço principal e a Eagle vai reagir às ações chamando as callbacks definidas.

Você pode conferir a API (em inglês) destes elementos em http://www.gustavobarbieri.com.br/eagle/docs/api/:

Vários widgets

Como já foi dito, você pode adicionar vários widgets em cada uma das 6 áreas (esquerda, direita, centro, cima, baixo e preferencias). Apenas use uma lista ou tupla do Python!

from eagle import *

App(
   title="Olhe, Varios Widgets!",
   center=(
      Button( id="b1", label="Botao 1" ),
      Button( id="b2", label="Botao 2" ),
      )
   )

run()

multiplewidgets.py

Entrada do Usuário

Quase todo programa precisa se comunicar com o usuário. A Eagle é otimizado para isso, deixando esta tarefa comum uma moleza!

from eagle import *

def entrada_do_usuario( app, wid, texto ):
   print app, wid, texto

def define_texto( app, wid ):
   app[ "entrada" ] = "algum texto"

App(
   title="Digite alguma coisa ou aperte o botao",
   center=(
      Entry( id="entrada", label="Entrada:", callback=entrada_do_usuario ),
      Button( id="botao", label="Redefine o texto", callback=define_texto ),
      )
   )

run()

userinput.py

Canvas: áreas de Desenho

A Eagle nasceu para ajudar a criar GUIs para programas de Computação Gráfica e Processamento de Imagens, portanto ele tem um canvas fácil de usar onde você pode desenhar.

from eagle import *

def mouse_callback( app, wid, botao, x, y ):
   if mouse_callback.ultimo_ponto is not None:
      x0, y0 = mouse_callback.ultimo_ponto
      app[ "canvas" ].draw_line( x0, y0, x, y, "red" )
   mouse_callback.ultimo_ponto = ( x, y )
mouse_callback.ultimo_ponto = None

def desenha_imagem( app, wid ):
   img = Image( filename="img.png" )
   app[ "canvas" ].draw_image( image=img, x=10, y=10 )

App(
   title="Desenhe algo ou aperte o botao",
   center=(
      Canvas( id="canvas", label="Canvas:", width=800, height=600, callback=mouse_callback ),
      Button( id="botao", label="Desenhar Imagem", callback=desenha_imagem ),
      )
   )

run()

canvas.py

Este exemplo requer uma explanação por causa da estranha função mouse_callback. O que fazemos é lembrar o último ponto desenhado usando um atributo de função last_point. Lembre-se que em Python tudo é um objeto, as funções também, então você pode usar um atributo, como em outros objetos, e simular variáveis estáticas (em C).

Sobre este Documento

Este documento foi escrito por Gustavo Sverzut Barbieri e traduzido por Bruno Gola e é licensiado sob Creative Commons - Attribution/Share Alike.

Pegue a versão mais recente em:

http://www.gustavobarbieri.com.br/eagle/docs/eagle-pt.html
Outras línguas: