ensandecer de um computólogo » efl

Flisol – Manaus – Amazonas

Daniel Elias — Mon, 27 Apr 2009 13:46:49 +0000

O flisol em manaus foi um sucesso na minha opnião, graças ao comprometimento dos “pigs” da comunidade de software livre em manaus, pessoas como Antônio Junior, Davyd Smelk, Marcelo Mendes entre outros e a estes pigs deixo aqui postado meus parabéns. houve uma quantidade razoável de participantes, todas as palestras estavam cheias e as oficinas foram também bastante frequentadas.

Tirei algumas fotos do evento apartir do meu E71, a câmera não é boa mas como estava de dia até que as fotos ficaram boas. Segue abaixo algumas fotos.

A foto acima é da oficina de D-Bus.

Coordenação do Flisol indo almoçar.

Mais fotos no meu flickr.

Também não pude deixar de contribuir e fiz uma palestra sobre Python com EFL e ajudei em algumas oficinas. Como prometi na minha palestra que iria postar a minha apresentação no blog, cá estou eu postando.

Slides Python e EFl

Segue abaixo os códigos que fiz de exemplo, mas faltou tempo para comentar linha a linha. Para quem quiser estudar segue 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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

#!/usr/bin/env python2.5
# -*- coding: utf-8 -*-
# Copyleft
#
# @author: Daniel Martins

import ecore
from ecore.evas import SoftwareX11
import evas
import edje

X_DIRECTION, Y_DIRECTION = range(2)

w, h = 800, 480
ee = ecore.evas.SoftwareX11(w=w, h=h)
canvas = ee.evas

states = 0
anime = False
anime_max = 0

bg = canvas.Rectangle(color=(255, 255, 255, 255), size=ee.size)
bg.show()

def change_object(o, e):
global w, h, states, anime_max
im_w, im_h = o.image_size
if states == 0:
o.pos_set(w-im_w, 0)
elif states == 1:
(x, y) = o.pos_get()
o.pos_set(x, h-im_h)
elif states == 2:
(x, y) = o.pos_get()
o.pos_set(0, y)
elif states == 3:
(x, y) = o.pos_get()
o.pos_set(0, 0)
states = 0
return
states += 1

ball_object = canvas.Image(file="Generic_football.png", geometry=(0, 0, 66, 65))
im_w, im_h = ball_object.image_size
ball_object.fill_set(0,0, im_w, im_h)
ball_object.on_mouse_up_add(change_object)
ball_object.show()

# Load and setup UI
ee.title = "Exemplo de Python EFL"

ee.show()
ecore.main_loop_begin()

Exemplo animado:

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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

#!/usr/bin/env python2.5
# -*- coding: utf-8 -*-
# Copyleft
#
# @author: Daniel Martins

import ecore
from ecore.evas import SoftwareX11
import evas
import edje

X_DIRECTION, X_DIRECTION_NEGATIVE, Y_DIRECTION, Y_DIRECTION_NEGATIVE = range(4)

w, h = 800, 480
ee = ecore.evas.SoftwareX11(w=w, h=h)
canvas = ee.evas

states = 0
anime = False
anime_max = 0

bg = canvas.Rectangle(color=(255, 255, 255, 255), size=ee.size)
bg.show()

def anime_ball(img_obj, direction):
global anime_max
(x,y) = img_obj.pos_get()
if direction == X_DIRECTION:
img_obj.pos_set(x+5,y)
img_obj.pass_events_set(True)
if x > anime_max:
img_obj.pass_events_set(False)
return False
if direction == X_DIRECTION_NEGATIVE:
img_obj.pos_set(x-5,y)
img_obj.pass_events_set(True)
if x < anime_max:
img_obj.pass_events_set(False)
return False
elif direction == Y_DIRECTION:
img_obj.pos_set(x,y+5)
img_obj.pass_events_set(True)
if y > anime_max:
img_obj.pass_events_set(False)
return False
elif direction == Y_DIRECTION_NEGATIVE:
img_obj.pos_set(x,y-5)
img_obj.pass_events_set(True)
if y < anime_max:
img_obj.pass_events_set(False)
return False
return True

def change_object(o, e):
global w, h, states, anime_max
im_w, im_h = o.image_size
if states == 0:
anime_max = w-im_w
ecore.animator_add(anime_ball, o, X_DIRECTION)
elif states == 1:
anime_max = h-im_h
ecore.animator_add(anime_ball, o, Y_DIRECTION)
elif states == 2:
anime_max = 0
ecore.animator_add(anime_ball, o, X_DIRECTION_NEGATIVE)
elif states == 3:
anime_max = 0
ecore.animator_add(anime_ball, o, Y_DIRECTION_NEGATIVE)
states = 0
return
states += 1

ball_object = canvas.Image(file="Generic_football.png", geometry=(0, 0, 66, 65))
im_w, im_h = ball_object.image_size
ball_object.fill_set(0,0, im_w, im_h)
ball_object.on_mouse_up_add(change_object)
ball_object.show()

# Load and setup UI
ee.title = "Exemplo de Python EFL Animado"

ee.show()
ecore.main_loop_begin()

Link para baixar tudo, inclusive a imagem. Só não esqueça que para executar é preciso ter instalado as EFL e os python bindings.Para a instalação tenho um post sobre. Confira.

Espero que tenham gostado do evento tanto quanto eu gostei. Qualquer dúvida, crítica e/ou sugestão pode colocar nos comentários.

Até a próxima.

Estudando python EFL – edição especial :-P

Daniel Elias — Tue, 16 Dec 2008 05:06:38 +0000

Bom, irei participar de um treinamento de python EFL onde o instrutor será o Gustavo Barbiery, tentarei fazer um resumo do curso até mesmo para que me sirva de referência futura e postarei aqui no blog, tenho conhecidos que trabalham e estudam também EFL e python e que ficaram tristes por não poderem participar do treinamento, infelizmente não é possível que todos participem. Mas como sou um cara legal e sempre gostei de compartilhar conhecimento , além de fazer o resumo do curso que conterá muito código de exemplo. Irei também reportar a evolução do curso pelo meu Twitter em tempo real. Para isso instalei um widget no sidebar do wordpress, o qual vocês podem acompanhar ao seu lado direito da tela.

Para quem tem twitter, pode me seguir e fazer perguntas sobre a tecnologia em tempo real, para quem não tiver, pode deixar comentário no blog pois ficarei o tempo todo on line. Não atenderei todas as perguntas, irei filtrar as mais interessantes, portanto caprichem nas perguntas (se houver) que na primeira oportunidade que surgir perguntarei ao Gustavo e postarei no resumo do blog a resposta, sei que muitas das minhas dúvidas são as dúvidas de outros que começaram a trabalhar com EFL a pouco tempo, portanto muita coisa será respondida no resumo que farei do curso e não de forma imediata.

Qualquer coisa, seja sugestão ou crítica comenta ai.

Update: Posts só sairão, no final de semana. Tá cruel, muita coisa pra fazer/estudar.

Estudando python EFL – parte 2

Daniel Elias — Sat, 13 Dec 2008 19:37:03 +0000

Continuando a série de post sobre a tecnologia EFL , a qual estou estudando e trabalhando.

Este post visa ser uma visão geral do que é e como funciona esta tecnologia e está respectivamente divido em duas seções: O que é ? e Como Funciona ?.

O que é ?

EFL é um conjunto de bibliotecas escrita em C para facilitar o desenvolvimento de um gerenciador de janelas baseado no X, o famoso Enlightenment, o qual possui muitos recursos eye candy sem precisar de gerenciadores de janela com suporte a aceleração através de OpenGL, ex: compiz. E sempre fez um ótimo trabalho sem esse tipo de recurso.

Segui alguns vídeos coletados no youtube do Enlightenment em ação.

E existem outros mais. É possível implementar funcionalidades muito parecidas com as do iphone, por exemplo:

E olha um teclado virtual feito com EFL baseado no teclado do iPhone, feito pelo Gustavo Barbiery, um dos geeks que trabalha com EFL aqui no Brasil e que por sinal próxima semana estará em Manaus para dar um treinamento de EFL na FPF¸após eu ter tido muitas conversas com o chefinho.

E como o EFL faz muito com pouco processamento, foi portado para outras arquiteturas como ARM, onde roda em dispositivos como o Internet Tablet N810 da Nokia e existem algumas aplicações rodando com EFL, mas a aplicação de referência de uso do EFL no Maemo é o Canola, que é um player para o maemo. Alguns vídeos do canola em ação:

E roda também em celulares, e já está sendo feito uma plataforma completa para dispositivos móveis, o Illumine, e um dos geeks é um dos criadores do EFL, o Rasterman (Carsten Haitzler) e olhem só sua gang que já roda illumine:

Rasterman Gang's

E tudo isso e muito mais foi desenvolvido primariamente com EFL, Ficou afim de entender melhor e começar a desenvolver ? Bom…. posso guiá-lo pelo caminho que percorri no estudo.

Como funciona ?

Já que na primeira parte instalamos as técnologias básicas(ecore, evas, edje), vamos dá uma olhada em seu funcionamento.

Bem, vamos começar pelo começo.

Arquitetura completa do EFL.

Concentre-se na parte azul da arquitetura, o core EFL.

Evas é o canvas onde tudo é renderizado e também gera sinais para aplicação.

Ecore é o responsável por capturar todos os eventos de uma janela originados do X11 e direcionar esses eventos para os devidos callbacks, possui também um mecanismo de MainLoop e uma série de ferramentas que auxiliam o trabalho com EFL e tarefas comuns de programação.

Alguns componentes do Ecore:

Ecore_Con – Comunicação em rede
Ecore_IPC – Comunicação entre processos
Ecore_Config – Sistema de configuração
e outros.

Edje é um meio de separar o código da aplicação do código da interface, basicamente é o responsável por te prover o mecanismo de manipulação de objetos da interface, ou seja, manipular o canvas(evas) de forma descritiva e orientada a estados. Apartir do momento que você faz essa separação ou dividi a aplicação em camadas, você imediatamente ganha vantagens, como por exemplo no Enlightenment e no canola a interface é feita com Edje e por isso possui um mecanismo de Temas(Themes) avançado e flexível de temas, ou seja, você pode mudar toda a interface sem mexer no código da aplicação.

Fazendo uma analogia a arquitetura de desenvolvimento web, seria mais ou menos assim, olhe a figura do MVC abaixo

Sabemos que no desenvolvimento web, o Model é responsável pela lógica de negócio da aplicação, o Controller é responsável por capturar as requisições que vem da View e processa-lás junto a Model e então devolver a resposta a View, a View é a camada de apresentação que no contexto web é o html/css/javascript.

Olhando essa arquitetura MVC podemos fazer a seguinte analogia, que o View é o Edje, o Controller é o Ecore. E o Evas é o browser onde tudo é renderizado.

Consegui explicar alguma coisa ? Se não, deixe um comentário.

Falei alguma besteira ? Se sim, deixe um comentário corrigindo e colocarei os devidos créditos.

Próximos posts (Aguardem):

Estudando python EFL – parte 3 (Ecore-Evas)

Estudando python EFL – parte 4 (Edje)

VIM Highlight de Arquivos Edje

Daniel Elias — Tue, 26 Aug 2008 21:17:34 +0000

Para facilitar o desenvolvimento com arquivos edje (.edc) você pode baixar um plugin do repositório do EFL e então instalar este plugin para o vim.

Segue os passos:

$ mkdir $HOME/.vim/plugin

$ cd $HOME/.vim/plugin

$ svn co https://svn.enlightenment.org/svn/e/trunk/edje/data/edc.vim

pronto, você tem highlight quando editar os seus arquivos .edc, se o seu highlight não estiver habilitado automagicamente, quando você editar configure o tipo do arquivo:

:set filetype=edc

Já ajuda!

Estudando python EFL – parte 1

Daniel Elias — Sun, 24 Aug 2008 01:45:53 +0000

Bom, nos últimos tempos tenho estudado o Maemo, que utiliza o GTK como base dos widgets e de expansão da plataforma, mas vendo aplicações como canola que usa EFL, acredito que para uma aplicação mais interativa e eye-candy realmente vale a pena considerar o EFL como tecnologia para o desenvolvimento de aplicações para maemo, imaginei que a instalação do ambiente fosse algo mais trivial (e é depois que aprendi), com a ajuda do Gustavo Barbiery consegui finalizar a configuração do ambiente. E agora estou escrevendo um how-to para complementar o aprendizado.

A idéia é escrever um conjunto de posts para compartilhar os conhecimentos adquiridos, ajudando os mais novos (assim como eu) entrar no desenvolvimento de aplicações para maemo ou desktop utilizando esta tecnologia. Pretendo nos posts ter 2 seções uma com resumo e outra explicando com mais detalhes para os que não possuem muita experiência com linux possam entender e aprender.

Para constar, estou usando o Ubuntu 8.10.

Resumido:

Instalar os pacotes build-essential libpng12-dev libjpeg62-dev python-setuptools librsvg2-dev python2.5-dev subversion autoconf automake autotools-dev m4 libtool cvs git-core libdbus-1-dev
Fazer o checkout do código do trunk do svn do enlightenment dos seguintes pacotes: eina eet evas ecore embryo edje etk edje_editor.
Compilar os códigos na seguinte ordem: eina eet evas ecore embryo edje etk edje_editor.
Fazer checkout dos bindings do efl para python do SVN: cython python-efl-utils python-evas python-ecore python-edje python-etk.
Instalar os pacotes na seguinte ordem: python-efl-utils python-evas.

Após instalar o python-evas, você precisa instalar os headers para compilar o python-ecore, então: python setup.py install_headers

Continuar a instalação dos pacotes dos bindings: python-ecore, python-edje e python-etk

Detalhado:

Instalar os pacotes essenciais para compilar os códigos, usando apt-get ou aptitude:

$ apt-get install build-essential libpng12-dev libjpeg62-dev python-setuptools librsvg2-dev python2.5-dev subversion autoconf automake autotools-dev m4 libtool cvs git-core libdbus-1-dev

Após instalar esses pacotes é preciso fazer o checkout do repositório do enlightenment, você pode criar uma pasta no seu home e entre no diretório:

$ mkdir $HOME/e_src

$ cd $HOME/e_src

entrar na pasta e fazer o checkout dos códigos eina eet evas ecore embryo edje etk edje_editor:

$ svn co https://svn.enlightenment.org/svn/e/trunk/eina eina

$ svn co https://svn.enlightenment.org/svn/e/trunk/eet eet

$ svn co https://svn.enlightenment.org/svn/e/trunk/evas evas

$ svn co https://svn.enlightenment.org/svn/e/trunk/ecore ecore

$ svn co https://svn.enlightenment.org/svn/e/trunk/embryo embryo

$ svn co https://svn.enlightenment.org/svn/e/trunk/edje edje

$ svn co https://svn.enlightenment.org/svn/e/trunk/etk etk

$ svn co https://svn.enlightenment.org/svn/e/trunk/edje_editor edje_editor

$ svn co https://svn.enlightenment.org/svn/e/trunk/e_dbus e_dbus

após ter feito o checkout do código, você precisar exportar os códigos para não mexer no código que veio pelo svn assim você pode aproveitar sempre as alterações do código, para atualizar sua cópia do svn basta:

$ svn up

crie uma pasta onde conterá o código exportado para compilação e entre na diretório:

$ mkdir $HOME/e_src_exported

$ cd $HOME/e_src_exported

exportando:

$ svn export $HOME/e_src/eina eina

$ svn export $HOME/e_src/eet eet

$ svn export $HOME/e_src/evas evas

$ svn export $HOME/e_src/ecore ecore

$ svn export $HOME/e_src/embryo embryo

$ svn export $HOME/e_src/edje edje

$ svn export $HOME/e_src/e_dbus e_dbus

após exportar, precisamos compilar, começaremos pelo eina e estes comandos devem ser repetidos para cada diretório:

$ cd eina

$ sh autogen.sh

$ make

$ sudo make install

$ sudo ldconfig

$ cd ..

depois o eet:

$ cd eet

$ sh autogen.sh

$ make

$ sudo make install

$ sudo ldconfig

$ cd ..

depois evas:

$ cd evas

$ sh autogen.sh

$ make

$ sudo make install

$ sudo ldconfig

$ cd ..

depois ecore:

$ cd ecore

$ sh autogen.sh

$ make

$ sudo make install

$ sudo ldconfig

$ cd ..

depois o embryo:

$ cd embryo

$ sh autogen.sh

$ make

$ sudo make install

$ sudo ldconfig

$ cd ..

depois e por último o edje:

$ cd edje

$ sh autogen.sh

$ make

$ sudo make install

$ sudo ldconfig

$ cd ..

depois o etk:

$ cd etk

$ sh autogen.sh

$ make

$ sudo make install

$ sudo ldconfig

$ cd ..

depois o edje_editor:

$ cd edje_editor

$ sh autogen.sh

$ make

$ sudo make install

$ cd ..

depois o e_dbus:

$ cd e_dbus

$ sh autogen.sh

$ make

$ sudo make install

$ cd ..

Antes de instalar os bindings é preciso instalar algumas dependências:

$ wget -c http://www.cython.org/Cython-0.10.3.tar.gz

$ git clone git://git.profusion.mobi/users/ulisses/python-dispatcher.git

E após, instale o Cython:

$ tar -zxvf Cython-0.10.3.tar.gz

$ cd Cython-0.10.3

$ sudo python setup.py install

$ cd ..

e o Python-Dispather:

$ cd python-dispatcher

$ sudo python setup.py install

$ cd ..

Após ter compilado e instalado os componentes essenciais do EFL, você precisa compilar e instalar os bindings para python, baixando os pacotes dentro do mesmo diretório pra onde exportou o código do svn:

$ svn co https://svn.enlightenment.org/svn/e/trunk/BINDINGS/python/python-evas

$ svn co https://svn.enlightenment.org/svn/e/trunk/BINDINGS/python/python-ecore

$ svn co https://svn.enlightenment.org/svn/e/trunk/BINDINGS/python/python-edje

$ svn co https://svn.enlightenment.org/svn/e/trunk/BINDINGS/python/python-etk

$ svn co https://svn.enlightenment.org/svn/e/trunk/BINDINGS/python/python-e_dbus

Exportando:

$ cd $HOME/e_src_exported

$ svn export $HOME/e_src/python-evas python-evas

$ svn export $HOME/e_src/python-ecore python-ecore

$ svn export $HOME/e_src/python-edje python-edje

$ svn export $HOME/e_src/python-etk python-etk

depois o python-evas:

$ cd python-evas

$ sudo python setup.py install

$ sudo python setup.py install_headers

$ cd ..

depois o python-ecore:

$ cd python-ecore

$ sudo python setup.py install

$ cd ..

depois o python-edje:

$ cd python-edje

$ sudo python setup.py install

$ cd ..

depois o python-etk:

$ cd python-etk

$ sudo python setup.py install

$ cd ..

depois o python-e_dbus:

$ cd python-e_dbus

$ sudo python setup.py install

$ cd ..

Pronto! você possui uma instalação funcional.

Para testar, você pode o exemplo que o Gustavo Barbiery fez, você precisa fazer o checkout:

$ mkdir $HOME/efl_demo

$ cd $HOME/efl_demo

$ svn co https://svn.enlightenment.org/svn/e/trunk/BINDINGS/python/python-edje/examples/evas-demo/01-app_launcher 01-app_launcher

$ cd 01-app_launcher

$ edje_cc 01-app_launcher.edc

$ python 01-app_launcher.py

Se tudo funcionar, pronto você realmente tem uma instalação funcional do python efl.

Fontes:

http://wiki.enlightenment.org/

Basicamente, não tem muita referência de instalação do efl e esse é um dos motivos de eu estar escrevendo o post.

Qualquer coisa comenta ai!

Update 24/01/09: Adicionado compilação do e_dbus e python-e_dbus.

Update 01/09/08: Considerando uma instalação inicial inclui mais alguns pacotes para instalar antes de iniciar a compilação: autoconf automake autotools-dev m4 libtool

Update 14/10/08: Houve mudanças nos repositórios do EFL, e agora é preciso compilar também o pacote EINA. Incluído Eina e correções na hora de instalar os bindings

Update 22/12/08: Esse modo de instalação que fiz funcionava bem com a versão antiga do efl, antes do eina. Atualizei para a versão do SVN e inclui a instalação de mais 2 pacotes do EFL, 1 binding e um utilitário(python-dispatcher) e a remoção do python-efl-utils. E tudo feito no ubuntu 8.10.