Algumas mudanças

Acho que se eu disser novamente que vou recomeçar a postar, você irá rir disso. Pois bem, não direi isso.

Quero dizer que estou vivo e que aconteceram coisas muito legais nesse tempo todo!

Fiz 18 anos de idade! A liberdade agora está estampada na minha testa! XD
Me alistei no serviço militar, o que não foi nada legal porque tive que ir até 3 juntas por aqui(pq não sabia qual era e me informaram errado)!
Mas foi uma boa experiência!

Bom, o melhor é que estou trabalhando (supostamente) com o que gosto de fazer! Ser desenvolvedor web!

Bom, vou fazer cursinho no meu tempo vago, mas quando tiver tempo e arrumar meu PC(minha placa-mãe foi pro saco!) eu volto a postar.

Abraços!

Adicionando máscara de entrada em um campo 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.

O GTK e o Pascal – I

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

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/

Fim de uma etapa

Finalmente terminei meu TCC, conseqüentemente meu curso técnico de informática na Escola Técnica Parque da Juventude – São Paulo – olha o orgulho – !
Também terminei o ensino médio, sem repetir nenhum ano XD ([é porque tem gente que ainda consegue essa proeza nos dias de hoje).
Estou bastante feliz pois além de concluir tudo numa boa, fiz uma ótima apresentação com meu TCC.
Pena não ter nenhum vídeo.

Obrigado a todos que me ajudaram!
Próximo passo é a 2ª fase da Fuvest.
Logo logo postarei novamente!

Democracia digital

É muito bom ver que algumas áreas de nosso governo são tão empenhadas em democratizar o acesso à informação.. mas as vezes é decepcionante:

Caso você NÃO possua o navegador proprietário Internet Explorer, e muito menos possua alguma versão do Windows, você terá a agradável surpresa de não vizualizar este site!
Claro que você pode formatar seu hd e instalar uma cópia do Windows só para acessar este site. Mas para isso, você pagará no mínimo R$400,00(a não ser que sua consciência permita comprar uma cópia pirata).

Você também pode instalar o IEs4Linux. Mas convenhamos: haja paciência!
Para testar, acesse o Censo da secretaria da educação de São Paulo e clique em algum dos links do site.

Criando uma ListStore em Python

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!

Mais um ótimo IDE: Geany

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

As novidades do emesene

A versão em desenvolvimento do emesene, mensageiro instantâneo para redes Windows Live Messenger^TM, está cheia de novidades, como o suporte ao novo protocolo usado pela Microsoft^TM(msnp15). Se você teve algum problema para se logar, é por causa deste protocolo e as vezes dava problema até no Live Messenger^TM.

Outra novidade é que as cores, e inclusive os gradientes, do MSN Plus! já estão disponíveis nesta nova versão(versões de testes). O suporte a webcams está avançando… você já pode visualizar a webcam de seu amigo =D (embora eu não tenha testado).

Para testar as versões em desenvolvimento do emesene, você deve instalar o Subversion que é um “controle de versões”.

Para isto, abra seu terminal e digite:

Para quem usa Ubuntu ou Debian, etc:

#apt-get install subversion

Para quem usa Red Hat, Fedora:

#yum install subversion

Para obter obter o emesene-trunk(trunk é o nome dado a versões “não oficiais”) faça:

$svn co https://emesene.svn.sourceforge.net/svnroot/emesene/trunk/emesene/ emesene-trunk

Este comando copiará todo o código fonte do emesene e salvará na pasta emesene-trunk(criada com o mesmo comando). Em seguida:

$cd emesene-trunk
e
$./emesene

Você perceberá que não é muito conveniente ficar fazendo isso toda vez que for iniciar o programa. Então crie um lançador apontando para o emesene ;D.

Para manter os códigos atualizados, você deve entrar na pasta emesene-trunk e digitar o comando svn up.

Lembre-se que estas são versões em desenvolvimento e podem ser muito instáveis! Recomenda-se usar a versão dos repositórios da sua distro!
Quem deseja estudar Python e a biblioteca PyGTK, vai se deliciar com esta belezura.
Para mais informações sobre o desenvolvimento deste (ótimo) software, acesse: http://emesene.org/smf/

Até mais.

Recomeçando a postar

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!

Instalando a ZeosLib no Delphi 7

Sim, eu desenvolvo em Delphi! Preferiria aprender Python no meu técnico, mas eles consideram “fora de mercado”. Querem criar mão-de-obra barata(Ok, você pode ganhar muito com isso!).

Mas, como diz uma grande amiga minha, nem tudo é como agente quer… Tenho que usar Windows contra a minha vontade, mas tudo bem. Conhecimento que vier é lucro.

A dica está aqui, e serve para quem está com problemas em instalar pelo método ensinado aqui.

Em breve eu mostro com instalar no Lazarus.