Pular navegação

Category Archives: Introdução

Explicações.

Esse tal de Android me deixa bem animado com a programação para dispositivos móveis! Parece um bom investimento aprender a desenvolver para celulares…

Bem, eu queria muito saber como é rodar um sistema desses, emulado. Sei que a Google especifica um sistema 32bits para rodar, porém o meu sistema é de 64bits. Não desisti e corri atrás de informações.
Consegui encontrar uma mensagem no mainlist do grupo android-developers do groups(google) relacionada a isso.
Resumidamente: precisa-se instalar bibliotecas 32 bits, mas a lista é grande, então rode e instale tudo com:

#yum install glibc.i686 glibc-devel.i686 libstdc++.i686 zlib-devel.i686 ncurses-devel.i686 libX11-devel.i686 glibc.i686 ncurses-libs.i686 libgcc.i686 ncurses-libs.i686 libstdc++.i686 libX11.i686 zlib.i686 SDL.i686 libXext.i686 libXv.i686 libXrandr.i686 alsa-lib.i686 alsa-plugins-pulseaudio.i686

Em seguida rode o seu sistema emulado:

$./emulator -audio alsa @nomedasuaAVD

*-*

Não abordei a instalação do SDK porque é fácil pra caramba. Na verdade é só baixar e descompactar.
Agora vou estudar mais sobre isso… quem sabe eu consiga construir uma boa app!*-*

Exemplo utilizando máscara de texto.

Exemplo utilizando máscara de texto.

Hoje é um dia propício pra postagem, não me pergunte o porque.
Vou começar mostrando como se aplica máscara de entrada em um campo de texto usando uma classe pronta. Encontrei essa classe em um fórum. Provavelmente surgiu deste projeto brasileiro
(já que um dos autores é o mesmo da classe).
Siga as regras da licença.

Copie o código e salve com o nome de MaskEntry.py

#
# Copyright (C) 2006 Async Open Source
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2.1 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
# USA
#
# Author(s): Johan Dahlin <[EMAIL PROTECTED]>
#

import string
import sys

import gobject
import pango
import gtk

class MaskError(Exception):
    pass

(INPUT_CHARACTER,
 INPUT_ALPHA,
 INPUT_DIGIT) = range(3)

INPUT_FORMATS = {
    'a': INPUT_ALPHA,
    'd': INPUT_DIGIT,
    'c': INPUT_CHARACTER,
    }

class MaskEntry(gtk.Entry):
    def __init__(self):
        gtk.Entry.__init__(self)
        # It only makes se
        self.modify_font(pango.FontDescription("monospace"))
        self.set_property('editable', True)
        self.set_size_request(90, -1)

        self.connect('insert-text', self._on_insert_text)
        self.connect('delete-text', self._on_delete_text)

        # List of validators
        #  str -> static characters
        #  int -> dynamic, according to constants above
        self._validators = []
        self._interactive_input = True
        self._mask = None

    # Callbacks

    def _on_insert_text(self, editable, new, length, position):
        if not self._interactive_input:
            return

        if length != 1:
            print 'TODO: paste'
            self.stop_emission('insert-text')
            return

        position = self.get_position()
        next = position + 1
        validators = self._validators
        if len(validators) <= position:
            self.stop_emission('insert-text')
            return

        validator = validators[position]
        if validator == INPUT_CHARACTER:
            # Accept anything
            pass
        elif validator == INPUT_ALPHA:
            if not new in string.lowercase:
                self.stop_emission('insert-text')
                return
        elif validator == INPUT_DIGIT:
            if not new in string.digits:
                self.stop_emission('insert-text')
                return
        elif isinstance(validator, str):
            self.set_position(next)
            self.stop_emission('insert-text')
            return

        self.delete_text(position, next)

        # If the next position is a static character and
        # the one after the next is input, skip over
        # the static character
        if len(validators) > next + 1:
            if (isinstance(validators[next], str) and
                isinstance(validators[next+1], int)):
                # Ugly: but it must be done after the parent
                #       inserts the text
                gobject.idle_add(self.set_position, next+1)

    def _on_delete_text(self, editable, start, end):
        if not self._interactive_input:
            return
        if end - start != 1:
            print 'TODO: cut/delete several'
            self.stop_emission('delete-text')
            return

        validator = self._validators[start]
        if isinstance(validator, str):
            self.set_position(start)
            self.stop_emission('delete-text')
            return

        self.insert_text(' ', end)
        return False

    # Public API

    def set_mask(self, mask):
        """
        Sets the mask of the Entry.
        The format of the mask is similar to printf, but the
        only supported format characters are:
        - 'd' digit
        - 'a' alphabet, honors the locale
        - 'c' any character
        A digit is supported after the control.
        Example mask for a ISO-8601 date
        >>> entry.set_mask('%4d-%2d-%2d')
        HACK for erase data > set_mask('%0d') 
        

        @param mask: the mask to set
        """

        self._mask = mask
        if not mask:
            return

        input_length = len(mask)
        keys = INPUT_FORMATS.keys()
        lenght = 0
        pos = 0
        while True:
            if pos >= input_length:
                break
            if mask[pos] == '%':
                s = ''
                format_char = None
                # Validate/extract format mask
                pos += 1
                while True:
                    if mask[pos] not in string.digits:
                        raise MaskError(
                            "invalid format padding character: %s" % mask[pos])
                    s += mask[pos]
                    if mask[pos+1] in INPUT_FORMATS:
                        format_char = mask[pos+1]
                        break
                    pos += 1
                pos += 1
                self._validators += [INPUT_FORMATS[format_char]] * int(s)
            else:
                self._validators.append(mask[pos])
            pos += 1

        s = ''
        for validator in self._validators:
            if isinstance(validator, int):
                s += ' '
            elif isinstance(validator, str):
                s += validator
            else:
                raise AssertionError
        self.set_text(s)

    def get_field_text(self):
        """
        Get the fields assosiated with the entry
        if a field is empty it'll return an empty string
        otherwise it'll include the content

        @returns: fields
        @rtype: list of strings
        """
        if not self._mask:
            raise MaskError("a mask must be set before calling get_field_text")

        def append_field(fields, field_type, s):
            if s.count(' ') == len(s):
                s = ''
            if field_type == INPUT_DIGIT:
                s = int(s)
            fields.append(s)

        fields = []
        pos = 0
        s = ''
        field_type = -1
        text = self.get_text()
        validators = self._validators
        while True:
            if pos >= len(validators):
                append_field(fields, field_type, s)
                break

            validator = validators[pos]
            if isinstance(validator, int):
                s += text[pos]
                field_type = validator
            else:
                append_field(fields, field_type, s)
                s = ''
                field_type = -1
            pos += 1

        return fields

    def set_text(self, text):
        """
        Sets the text of the entry

        @param text:
        """
        self._interactive_input = False
        try:
            gtk.Entry.set_text(self, text)
        finally:
            self._interactive_input = True

    def delete_text(self, start, end):
        """
        Deletes text at a certain range

        @param start:
        @param end:
        """
        self._interactive_input = False
        try:
            gtk.Entry.delete_text(self, start, end)
        finally:
            self._interactive_input = True

    def insert_text(self, text, position=0):
        """
        Insert text at a specific position

        @param text:
        @param position:
        """
        self._interactive_input = False
        try:
            gtk.Entry.insert_text(self, text, position)
        finally:
            self._interactive_input = True

def main(args):
    win = gtk.Window()
    win.set_title('gtk.Entry subclass')
    def cb(window, event):
        print 'fields', widget.get_field_text()
        gtk.main_quit()
    win.connect('delete-event', cb)

    widget = MaskEntry()
    widget.set_mask('%2d/%2d/%4d')

    win.add(widget)

    win.show_all()

    widget.select_region(0, 0)
    gtk.main()

if __name__ == '__main__':
    sys.exit(main(sys.argv))

Depois disso, você poderá testa-la rodando normalmente, assim:
$ python MaskEntry.py

Para inseri-la no seu próprio programa, faça como no exemplo:

        self.dtaemi     = MaskEntry()
        self.dtaemi.set_mask('%2d/%2d/%4d')
        self.hboxDtasBusca.pack_start(self.dtaemi,False,False,0)
        texto = gtk.Label()
        texto.set_text("e")
        self.hboxDtasBusca.pack_start(texto,True,True,0)

        self.dtavenc    = MaskEntry()
        self.dtavenc.set_mask('%2d/%2d/%4d')
        self.hboxDtasBusca.pack_start(self.dtavenc,False,False,0)

Na primeira linha é criada a entrada de texto que receberá a máscara da classe.
Em seguida é configurada a máscara para esse objeto(%2d significa 2 dígitos).
No meu exemplo eu adicionei à um hbox criado anteriormente.
Pronto, tá feito.

Obs.: Se você selecionar um “MaskEntry” utilizando a tecla tab, ele selecionará todos os campos e não conseguirá apagar e voltar para o primeiro espaço.

Pesquisando e programando, encontrei uma ótima referência em  Pascal escrita em bom português.
Fiquei inspirado. Logo estou aqui.

Bom, hoje vou mostrar um exemplo de programa escrito em Pascal, que utiliza a biblioteca gráfica GTK+ 2.
É um exemplo simples, um botão dentro de uma janela, que não possui muita utilidade prática, mas é ótimo pra se ter uma idéia do que pode ser feito com pascal.

Utilizei o Geany IDE, mas se você deseja compilar seus programas na mão, é só digitar:
$fpc arquivo.pas

Hoje vou explicar um pouco do código. Então vamos lá…

program pascal_gtk1;

uses glib2,gtk2,gdk2, crt;

Este é o início do nosso programa. A primeira linha é o nome do programa, a segunda é o mais importante aqui. Ela importa as classes necessárias para o programa funcionar.
Neste caso estamos usando a Glib 2, GTK 2, GDK 2 e a CRT.
Se você utiliza distribuições baseadas no Debian precisará instalar o compilador e as units separadamente…
Faça então:

# apt-get install fp-compiler fp-units-base fp-units-gtk2

Se você utiliza distribuições com Yum(Red Hat, Fedora, etc), faça somente:

#yum install fpc

Se você utiliza Windows, então será um pouco mais chato de instalar tudo.
Comece com o FreePascal: http://www.freepascal.org/download.html
Em seguida baixe o GTK e todos os pacotes listados(glib, pango, gdk, atk e cairo) ou este pacote tudo em um: http://ftp.gnome.org/pub/gnome/binaries/win32/gtk+/2.14/gtk+-bundle_2.14.6-20081216_win32.zip
O pacote do freepascal vem com uma IDE própria, mas é horrível!
Siga este tutorial para maior conforto(serve pra Windows também): http://icaju.wordpress.com/2008/12/22/aprendendo-a-programar-com-pascal-e-software-livre/

Seguindo o tutorial, vamos a segunda parte.

procedure destroy ( widget : pGtkWidget ; data : pgpointer); cdecl;
begin
gtk_main_quit();
end;

procedure clique( widget : pGtkWidget ; data : pgpointer); cdecl;
begin
writeln('Olá mundo');
end;

Estes são os únicos procedimentos de nosso programa. Eles recebem os parâmetros dos sinais de chamada(leia “Mantendo a sanidade com Glade”).
O primeiro procedimento é acionado quando a usuário clica no botão de fechar da janela, ou seja, destrói o programa.
O segundo procedimento é acionado quando o botão(que será criado ainda) for clicado.
Mostrarei as conexões de sinais mais à frente.

var janela:pGtkWidget;
    botao: pGtkWidget;

Aqui são declaradas as variáveis que serão utilizadas no programa. O tipo “pGtkWidget” é usado para declarar todos os Widgets GTK em FreePascal(corrija-me se estiver errado).

begin

gtk_init (@argc, @argv);

janela:= gtk_window_new(GTK_WINDOW_TOPLEVEL);
botao := gtk_button_new_with_label('Olá mundo!');

Este é o começo da “estrutura” do programa.  A função “gtk_init” iniciará tudo que seu programa precisa pra funcionar.
Para variável “janela” está sendo declarada uma nova janela gtk de nível superior.
Para variável “botao” está sendo declarado um novo botão com etiqueta.

gtk_container_add(pGTKContainer(janela),botao);

Esta linha diz para adicionar o botão à janela(um container).

gtk_signal_connect(pGTKOBJECT (janela), 'destroy', GTK_SIGNAL_FUNC(@destroy), NULL);
//Caso o botão seja clicado:
gtk_signal_connect(pGTKOBJECT (botao), 'clicked', GTK_SIGNAL_FUNC(@clique), NULL);

Estas são as linhas mais importantes do programa. São elas que conectam os sinais do programa.
A primeira conecta o widget “janela” com o sinal de “destroy” ao procedimento “destroy”.
A segunda conecta o widget “botao” com o sinal de “clicked”(clicado) ao procedimento “clique”. Ambos os procedures foram declarados anteriormente.

gtk_widget_show_all(janela);
gtk_main ();
end.

A primeira linha deste trecho fará o programa mostrar todos os widgets dentro da “janela”.
A segunda inicia o loop GTK.
A ultima linha finaliza o nosso programa.

Pra terminar, postarei o código completo.

program pascal_gtk1;

uses glib2,gtk2,gdk2, crt;

procedure destroy ( widget : pGtkWidget ; data : pgpointer); cdecl;
begin
gtk_main_quit();
end;

procedure clique( widget : pGtkWidget ; data : pgpointer); cdecl;
begin
writeln('Olá mundo');
end;

var janela:pGtkWidget;
    botao: pGtkWidget;

begin
gtk_init (@argc, @argv);

janela:= gtk_window_new(GTK_WINDOW_TOPLEVEL);
botao := gtk_button_new_with_label('Olá mundo!');

gtk_container_add(pGTKContainer(janela),botao);

gtk_signal_connect(pGTKOBJECT (janela), 'destroy', GTK_SIGNAL_FUNC(@destroy), NULL);
gtk_signal_connect(pGTKOBJECT (botao), 'clicked', GTK_SIGNAL_FUNC(@clique), NULL);

gtk_widget_show_all(janela);

gtk_main ();

end.
Programa funcionando

Programa funcionando

Observações:

Comandos iniciados com “#” significam que deverão ser executados como root.
Iniciados com “$” significam que serão executados como usuário normal.

Referências e dicas:

http://library.gnome.org/devel/gtk/stable/ (Fortemente recomendado! Em inglês)
http://linuxhard.org/wp/archives/48
http://icaju.wordpress.com/

Neste tutorial irei ensinar como criar uma ListStore em Python, utilizando o criador de interfaces Glade e PyGTK.

Primeiro crie uma interface como esta:

Salve com o nome que você quiser(no meu exemplo, eu salvei como Exemplo1.glade).

Em seguida crie os sinais da interface:

Feito isso, abra seu editor/IDE e insira o código comentado:

#!/usr/bin/env python
#-*- encoding: utf8 -*-

#Criação de uma liststore em Python, com PyGTK e Glade.
#Autor: Philip Sampaio

import gtk
import gtk.glade
import pygtk

pygtk.require("2.0")

class ListStoreSimples(object):
    def __init__(self):
        #Função de início.. é a primeira a ser carregada
        interface             =     gtk.glade.XML("Exemplo1.glade")
        self.winListStoreSimples    =    interface.get_widget("winListStoreSimples")
        self.entNome                =    interface.get_widget("entNome")
        self.entEmail            =    interface.get_widget("entEmail")
        self.trvListStore        =    interface.get_widget("trvListStore")

        #Montando a ListStore(ou tabela, como quiser)
        #A linha abaixo diz cria um modelo de liststore com 2 colunas, ambas sendo strings
        self.mdlListStore = gtk.ListStore( str, str)
        #A linha abaixo configura o modelo da treeview com o modelo acima
        self.trvListStore.set_model(self.mdlListStore)

        #Colocando as colunas
        colunaNome     = gtk.TreeViewColumn("Nome",gtk.CellRendererText(), text=0)
        colunaEmail    = gtk.TreeViewColumn("Email",gtk.CellRendererText(), text=1)
        #Adiciona à nossa treeview (trvListStore)
        self.trvListStore.append_column(colunaNome)
        self.trvListStore.append_column(colunaEmail)

        #Dicionário de conexões
        dic = {
            'on_winListStoreSimples_destroy' : ( self.on_winListStoreSimples_destroy ),
            'on_btnAdicionar_clicked'         : ( self.on_btnAdicionar_clicked)
            }

        #Conecta os sinais
        interface.signal_autoconnect(dic)
    def main(self):
        #Inicia o loop GTK
        self.winListStoreSimples.show_all()
        gtk.main()

    def on_btnAdicionar_clicked(self,widget):
        #Sinal de clique do btnAdicionar
        nome     = self.entNome.get_text()
        email     = self.entEmail.get_text()
        #Preste atenção: você irá adicionar os dados no MODELO
        self.mdlListStore.append([ nome, email])

        #As linhas comentadas abaixo são de exemplo.
        """info = [("Philip Sampaio","philip.sampaio@gmail.com"),
                ("Fulano"         ,"fulano@gmail.com"),
                ("Maria"         ,"Maria@gmail.com"),
                ("João"             ,"Joao@gmail.com")]
        for coluna in info:
            print coluna[0], coluna[1]
        """
    def on_winListStoreSimples_destroy(self,widget):
        #funcao para parar o loop gtk e encerrar o programa
        self.winListStoreSimples.hide_all()
        gtk.main_quit()

if __name__ == '__main__':
    teste = ListStoreSimples()
    teste.main()

O resultado deve ser algo como isto:
Fácil, não?
Teste e estude o código! Pergunte se precisar de ajuda!

Vou fazer uma rápida apresentação sobre este IDE.

É um IDE extremamente rápido! Possui syntax highlighting(deixa o código colorido e mais fácil de vizualizar), suporta várias linguagens, pode compilar e executar os programas(ou até páginas web.. executa em um navegador) e etc.

O que mais chama atenção é a velocidade e estabilidade.

Um Screenshot do programa:

Geany IDE

Geany IDE

Se algum dia você passou por este blog, percebeu que ele ficou muitíssimo tempo sem posts! Pois é, eu tive alguns problemas pessoais que me deixaram sem muito ânimo pra seguir postando aqui.

Mas agora estou de volta, e cheio de idéias! Vou mudar o foco do blog para ficar algo mais amplo…

Vou falar sobre tudo que puder(e se o tempo deixar!).

Então é isso ai, let’s rock baby!

Programadores, no passado, tinham o costume de criar o primeiro programa em uma linguagem de programação em estudo que mostrasse de alguma forma a frase “Hello World”(em português: “Olá mundo”). Hoje em dia, pelo menos no meu curso técnico de informática, quebraram este ritual.
Não pretendo cometer esta desonra.

Pois bem, let’s go!

Vou mostrar a construção da interface no Glade, apesar de ser um exemplo simples que podia ser feito via código(com pyGTK direto)…
Antes de prosseguir, leia este site: http://www.cin.ufpe.br/~cinlug/wiki/index.php/Mantendo_A_Sanidade_Com_O_Glade

Abra um novo projeto no Glade e crie um novo widget do tipo janela(window).
glade0011.jpg

Depois crie um Vertical Box com 2 “itens”(clique no botão e em seguida clique na interface).

glade002.jpg

Em seguida crie um Horizontal Box no primeiro item do Vertical Box. Para fazer isso, basta clicar no ícone ao lado esquerdo do Vertical box e em seguida clicar na parte superior do Vbox existente. Escolha 2 itens novamente(mas agora é em horizontal).

Feito isso, crie um “Text Entry”(conhecido como edit em algumas GUIs), um “Button”(botão) e um “Label”(etiqueta de texto) desta forma:glade0031.jpg

OBS.: Eu redimensionei a interface utilizando as bordas do widget window1.

Agora chegou a hora de dar nomes ao widgets..
Clique em cada um e dê os seguintes nomes(claro que você pode definir isto sozinho!):
Ao text entry: entnome;
ao botão: btnok
e ao label: lblresposta.
No label, ative a opção “Usar marcação”, debaixo do rótulo.

glade005.jpg
Salve o projeto em algum diretório(dãr! lógico, né? Na memória vai ficar difícil) .

Agora vem uma parte muito importante!
Definir as ligações entre a interface e o código.. Isso se faz na aba “Signals”(Sinais).
Teremos que ligar o sinal de quando o usuário clicar no botão ok, e de quando o programa for “destruído”(quando clicarmos no fechar da janela).

Definindo o sinal do botão:
glade004.jpg

Não se esqueça de dar um “Enter” para salvar a informação.
Faça o mesmo com o widget “window1”(ficou com o nome padrão mesmo :)), só que em vez de conectar ao evento “Clicked”, conecte com o evento “Destroy” que está em GtkObject(aproveite pra fuçar outros eventos, você vai encontrar eventos diferentes em alguns widgets). Deixe o padrão mesmo: on_window1_destroy.
Agora salve o projeto e feche-o se quiser.

O código

Agora vem a parte interessante.. o código!
Vou sugerir que você sabe o básico(bem básico!) de Python pois postarei o código auto-explicado, com comentários.

Hello_world.py(somente para identificar o código/script):

#!/usr/bin/python
#-*- encoding: utf8 -*-
#Arquivo: Hello_World.py

"""Primeira linha pode ser desnecessária na maioria das ocasiões,
mas diz a algum programa que queira abrir este script/documento, onde está
o interpretador"
""
"""Segunda linha diz ao interpretador para aceitar caracteres como acentos e cedilhas.
É opcional também, mas sem isso você não poderá usar acentos nos comentários"
""

import gtk, gtk.glade
#importa a biblioteca gtk e gtk.glade
import pygtk
#mesma coisa, importa o wrapper pygtk, para que possamos editar os widgets da interface
#podemos até criar toda a interface com o pygtk, mas é muito trabalhoso
pygtk.require("2.0")
#Versão mínima requerida para o código

class Hello_World():
    def __init__(self):
        """Função inicial, carrega a interface e conecta os sinais dos widgets"""
        interface           = gtk.glade.XML("hello_world.glade")
        self.janela         = interface.get_widget("window1")
        self.entnome        = interface.get_widget("entnome")
        self.lblresposta    = interface.get_widget("lblresposta")
        #Define as variáveis dos objetos que utilizaremos.
        #Neste caso são todos, exceto o botão
       
        dic = { "on_btnok_clicked"        : (self.on_btnok_clicked),
                "on_window1_destroy"    : (self.on_window1_destroy)
                }
        #Cria o dicionário com os sinais conectados aos callbacks
       
        interface.signal_autoconnect(dic)
        #Faz a conexão dos sinais com os callbacks
        self.janela.show_all()
        #Exibe a janela
       
        gtk.main()
        #inicia o loop GTK, e faz rodar a interface em loop
        #veja como isto funciona no tutorial "Mantendo a sanidade com o Glade"
        #cujo link postarei no final do tutorial
       
    def on_btnok_clicked(self,botao):
        """Função para quando o botão OK for clicado"""
        nome = self.entnome.get_text()
        #Pega o texto do text entry
        self.lblresposta.set_markup("<big>Hello World!</big> Este programa foi criado por "+nome)
        #Dá a resposta no label. Poderia ser usado o set_text, mas neste caso estamos usando marcação XML no exemplo
       
    def on_window1_destroy(self,janela):
        """Fecha o programa interrompendo o loop GTK"""
        gtk.main_quit()
if __name__ == "__main__":
    Hello_World()
    #roda o programa
 

————————-
Obs: Tive que trocar algumas aspas simples por duplas, mas acho que não há problema aqui.
Com os comentários o programa ficou grande, mas sem eles foram apenas 23 linhas essenciais!
Pouquíssimo código!

Para rodar o programa, digite em um terminal:
$python /caminho/do/script/Hello_World.py
OBS.: O caracter “$” não é para digitar. Ele significa que você está como usuário normal no sistema.

Você também pode rodar diretamente com o SPE ou Eric(os outros IDEs eu não sei), clicando em “Run/Stop”(no SPE).

Programa funcionando:
programa001.jpg

Fiz algumas modificações, como a largura da borda do “window1″(Para isso, vá em Propriedades > Common > Largura da borda: 10 ) e o redimensionamento da janela (Em Propriedades > General > Redimensionável: Não).

Por hora é só. Um programa bem simples, mas deu pra ter uma noção de como a “coisa” funciona.
Por favor, não deixe de postar dúvidas e críticas.

O Stani’s Python Editor (SPE) é um editor de códigos muito prático e funcional. Ele possui uma interface muito legal e de fácil compreensão.

Possui UML, PyChecker, Debugger,auto-indentação e algumas outras coisas.

Gosto dele pois é simples como a linguagem Python, mas igualmente poderoso. Na verdade o poder está nas mãos do programador e não da IDE que ele utiliza(oque quis dizer foi que o editor não deixa o programador na mão 😉 ) .

A visualização do código é muito fácil com ele. Eis um ScreenShot:

Um IDE para Python

Site do projeto: http://pythonide.stani.be/

Muitos de vocês, leitores, devem estar acostumados ao modo de desenvolvimento do Windows (VB/Delphi), oque me faz pensar que vocês odiariam ter que desenvolver uma interface gráfica somente em códigos. Pois bem, existem muitos programas que utilizam este método para construir interfaces: somente em código fonte.

Isso pode ser muito bom, devido ao controle sobre o código-fonte, já que foi tudo construído por você mesmo, programador.

Mas, como nem todo mundo tem paciência e disposição suficiente para construir interfaces gráficas via código, a maior parte das interfaces que serão criadas nos tutorias, serão feitas com o Glade.

Mas o que é o Glade?

O Glade é um programa para desenvolvimento de interfaces gráficas para GTK+(The Gimp Toolkit).

Com ele, é possível criar interfaces independentes de códigos, para que possa haver uma separação de códigos e interface. Isso beneficia muito o programador(ou programadores envolvidos no mesmo projeto), já que é muito mais fácil corrigir erros modificando só uma área do programa- interface ou código-fonte. Além disso, não acostuma o programador a mexer nas duas coisas ao mesmo tempo- estética e funcionalidade(design e código).

Acho que um programador não é obrigado a saber desenhar interfaces de usuários, já que o trabalho dele é programar, e não desenhar(desenhar é só um modo de falar, o programador é obrigado a saber várias coisas sobre acessibilidade, cores e etc).
Com o Glade(ou outro GUI deste tipo), o trabalho pode ser muito bem dividido, aumentando a produtividade!

Imagens do software

Tela principal do Glade

Está é a interface do Glade 3.
Do lado esquerdo temos a palheta de widgets(é como se chamam os objetos da interface), a direita temos a treeview dos widgets já criados, e abaixo disso temos as propriedades dos widgets.

Glade em ação.

Um exemplo funcional.

Explicarei mais afundo algumas coisas sobre o Glade, mas basicamente construirei interfaces nele e modificarei em pyGTK.

Essa pagina é uma lista de IDEs para desenvolvimento em Python com uma pequena descrição das mesmas para que as pessoas possam decidir qual delas se adapta melhor aos seus requisitos. Essa listagem surgiu a partir de uma discussão ocorrida na lista python-brasil. O autor de opiniões pessoais é colocado entre parêntesis.

IDEs são ambientes integrados para desenvolvimento de software.

Atualmente eu uso o SPE, pois este atende todas as minhas necessidades além de ser muito estável e de fácil entendimento(Philip Sampaio).

 

Livres

Idlehttp://www.python.org – O IDLE vem com o Python. É feito com Tkinter e se você se acostumar pode lhe ajudar bastante. É bem simples de ser usado também.

SPEhttp://pythonide.blogspot.com/ – Desenvolvido com wxPython é livre e tem algumas funcionalidades interessantes. Tem wxGlade como plugin para desenho de telas gráficas.

Pidahttp://pida.berlios.de/ – É uma IDE desenvolvida com PyGTK e visa a integração com o Vim. Oferece recursos como project management, source code management, code browser, code refactor, profiler, debugger entre outros.

Eric4http://www.die-offenbachs.de/eric/index.html – Dos IDEs esse é o que mais gosto. Não é exatamente o que eu uso (OsvaldoSantanaNeto) mas acho que é o mais completo de todos. É feito com a biblioteca QT e se integra às ferramentas da QT e com outros softwares como o Bicycle Repair Man (refactoring) e TabNanny (verificação de indentações). O autor dos bindings python para o Qt4, lançou um instalador para windows que contém as bibliotecas e os programas de desenvolvimento do Qt4, o pyqwt e o Eric4, o que facilita bastante a instalação no windows. Segue o link para o instalador: http://www.riverbankcomputing.com/Downloads/PyQt4/GPL/.

Boa-Constructorhttp://boa-constructor.sf.net – Essa é a “única” IDE ao estilo RAD do Delphi/VB. Funciona com o wxPython na versão 2.4 e é acho que é a mais fácil de ser usada apesar de não promover boas práticas de desenvolvimento como a de separar lógica de negócios de apresentação (telas). As outras IDEs não possuem mecanismos para desenho de telas gráficas mas podem usar ferramentas como Glade e/ou wxGlade.

Eclipsehttp://www.eclipse.org – Diferente de todos os outros. Pesado, grande, monstruoso mas muito poderoso. É feito em Java e é ideal para desenvolvimento Java. Mas existem plugins para se desenvolver em Python com ele (e detalhe: atualmente é um brasileiro quem o mantém) que é o ppydev: http://pydev.sourceforge.net/

EasyEclipsehttp://www.easyeclipse.org/site/distributions/python.html

DrPythonhttp://drpython.sourceforge.net/ – usa wxPython. Criado para ser utilizado em escolas.

IPythonhttp://ipython.scipy.org/ – Um shell com muitos recursos, através das comandos “mágicos”. Bastante útil, modo texto apenas. Você pode usa-lo como um shell “acoplado” aos seus programas também.

KDevelophttp://www.kdevelop.org/ – IDE livre para GNU/Linux e outros *nixes-like.

PythonWinhttp://pywin32.sf.net/ – IDE que acompanha as extensões Win32 para Python (PyWin32). Oferece auto-completion e debugging, e tem recursos extras voltados à programação Windows (coletor de exceções para componentes COM criados, COM browser, geração de arquivos .py com informações sobre objetos COM (static dispatch), etc.).

PythonCardhttp://pythoncard.sourceforge.net – é uma GUI para construção de aplicações multiplataforma em Windows, Mac OS X e Linux, usando a linguagem de programação Python. O lema de PythonCard é “coisas simples devem ser simples de fazer e coisas complexas devem devem ser possiveis”. É a ferramenta para quem deseja desenvolver aplicações gráficas de maneira rápida e fácil, com um mínimo de esforço e codificação; simples mas poderoso. Utiliza a biblioteca wxPython, mas separa a lógica do código da apresentação utilizando um tipo de arquivo de definição de recursos. (RômuloCampelo – 08/04/2005)

TruStudiohttp://trustudio.unipro.ru e http://sourceforge.net/projects/trustudio – Esta IDE é um plugin para o Eclipse (mais informações sobre este acima), tornando o suporte a PHP e Python bem mais completo e poderoso.

PyScripterhttp://mmm-experts.com/Downloads.aspx?ProductId=3 – Acompanha o conjunto de componentes python para Delphi (embora não requira que o Delphi esteja instalado para funcionar). Suporta debugging, auto-completion, navegação no código entre outros recursos. Na versão atual (3.31) o instalador parece ter um problema pois abre a IDE durante a instalação, diz que não pôde localizá-la e não cria um atalho, porém você pode criar um a partir do pasta onde foi instalada (geralmente C:Arquivos de ProgramasPythonForDelphi).

PyPEhttp://pype.sourceforge.net/index.shtml – Não se trata de um IDE propriamente dito, mas é um editor Python, leve, funcional e rico em recursos interessantes e multiplataforma. Além disso, é desenvolvido utilizando wxPython.

 

Proprietários

Winghttp://www.wingware.com – Das IDEs proprietárias essa é uma das que mais gosto ( OsvaldoSantanaNeto ). A empresa wingware recentemente lançou o wingide101 para auxiliar no ensino de python e é uma versão com menos recursos que as versões professional e personal, mas que tem funcionalidades interessantes, como depurador gráfico, shell interativo. Segue o link: http://wingware.com/wingide-101/index

Komodohttp://www.activestate.com – Essa é outra IDE bem poderosa também. Trabalha com outras linguagens além de Python e roda em Linux e Windows. Existe uma licença gratuita que pode ser usada para aprendizado.

BlackAdderhttp://www.thekompany.com/products/blackadder/ – Feita pelo pessoal que desenvolve o KDE.

 

Editores de texto

vimhttp://www.vim.org/ – Esse é o que eu uso ( OsvaldoSantanaNeto ). Tem em todo GNU/Linux e é altamente configurável.

Emacshttp://www.gnu.org/software/emacs/emacs.html – Esse editor é muito difícil de se usar (assim como o vim também), mas uma vez que se aprende a usá-lo ele pode se tornar uma IDE Python poderosíssima, principalmente em modo Python (http://sourceforge.net/projects/python-mode/). Mais “Emacs Goodies” em http://www.python.org/emacs/ ou na propria Wiki em PythonComEmacs.

SciTEhttp://www.scintilla.org/SciTE.html – Excelente editor de textos voltado para programação. Suporta uma grande lista de linguagens, pode rodar e debugar os programas, é fácil de usar e é muito configurável. Disponível para Windows e X (ambiente gráfico dos UNIXes).

jexthttp://www.jext.org/ – Muito bom editor! Suporta muitas linguagens e possui plugins para Python (executar, por exemplo).

joehttp://sourceforge.net/projects/joe-editor/ – Editor de texto para dinossauros -) Utiliza os mesmos comandos do WordStar, SideKick, etc. Disponivel via apt-get e emerge. (NiloMenezes).

Uma lista com outros (muitos) editores podem ser encontrados em http://www.python.org/moin/PythonEditors

Autor: Eduardo De Oliveira Padoan

Este texto foi retirado do site PythonBrasil.org, modificado por Philip Sampaio e está disponível sob os termos da Creative Commons Attribution 2.5 exceto quando explicitamente especificado outra licença.