A casa de Just

Novos registros no RG3.Net estão temporariamente desativados

2010-10-23T12:00:00.001-03:00

Olá a todos.

Muito tempo sem escrever (quase um ano) e venho pra dar uma notícia que, para alguns, será ruim: o serviço de redirecionamento da RG3.Net não está aceitando novos cadastros, por enquanto.

O motivo dessa decisão: muitas pessoas usam nosso serviço para criar redirecionamentos para sites fraudulentos, com o intuito de roubar senhas de Orkut, MSN e até de contas bancárias. Todos os dias recebemos denúncias via e-mail e até mesmo por telefone, de usuários e às vezes, da polícia, solicitando que os redirecionamentos sejam removidos.

Isso trás desgastes para nós, que temos que, a todo momento, fiscalizar e bloquear contas, além do estresse de lidar com as solicitações da polícia e dos riscos legais envolvidos.

Poderíamos solicitar vários dados dos usuários na criação de uma nova conta, como endereço, CPF, etc. Porém, nossa idéia não era essa. A idéia era criar um serviço fácil de usar e com o mínimo de burocracia. Atualmente, basta o usuário informar um login e um e-mail para fazer o cadastro, mais nada. Além disso, existem diversos softwares geradores de CPF na web, ou seja, um usuário fraudulento ainda poderia se cadastrar usando o CPF de terceiros.

Portanto, estamos avaliando se é viável manter esse serviço funcionando. Sendo assim, novos cadastros não poderão ser feitos até decidirmos o que fazer.

Agradecemos a todos que nos acompanharam até agora. Não queremos deixá-los na mão, mas também precisamos estudar a viabilidade deste negócio.

Como achar a localização de um endereço IP

2009-12-22T21:05:00.000-03:00

Bem, acho que isso não é difícil de achar na Internet, mas não custa nada informar.

Um tempo atrás, alguém perguntou na lista de discussão da FUG-BR como achar a localização de algum endereço IP no mundo. Surgiram duas sugestões:

Desses dois, gostei mais do http://ip-address.cc/, pois ele aponta a localização usando o Google Maps.

Procurei mais e encontrei também http://whatismyipaddress.com/. Esse também aponta a localização com o Google Maps e ainda detectou o proxy da minha rede e também tem uma ferramenta que informa se o endereço está listado em alguma Blacklist de servidores de e-mail. Adorei isso!

Se alguém conhecer mais sites ou aplicativos que possam dar informações sobre endereços IPs, podem sugerir através dos comentários.

Outra forma também de descobrir quem detém um endereço ou faixa de IPs é através de uma pesquisa de whois (use o comando "whois" em algum sistema Unix ou use a pesquisa do registro.br).

Fucking Linux source code

2009-12-05T14:32:00.003-03:00

@menelkir postou hoje no Twitter:

@IP_FIX @paulopow grep -iR fuck /usr/src/linux/* | wc -l

Já imaginei o que era. Executei o comando e o wc contou 36 "fuck"s no código inteiro. Dos 36, destaco abaixo os que achei mais engraçados:

arch/mips/kernel/irixelf.c: #if 0 /* XXX No fucking way dude... */
arch/mips/kernel/irixioctl.c: * irixioctl.c: A fucking mess...
Documentation/DocBook/kernel-locking.tmpl: If you don't see why, please stay the fuck away from my code.
drivers/net/sunhme.c: /* This card is _fucking_ hot... */
drivers/scsi/qlogicpti.h: /* Am I fucking pedantic or what? */
fs/binfmt_aout.c: /* Fuck me plenty... */
include/linux/netfilter/xt_limit.h: /* Ugly, ugly fucker. */
sound/oss/opl3.c: * What the fuck is going on here? We leave junk in the beginning

E o melhor de todos:

lib/vsprintf.c: * Wirzenius wrote this portably, Torvalds fucked it up :-)

Aliás, tem também uma coisa que não entendi, está no primeiro "fuck" da minha lista:

#if 0

O que o cara pretendia fazer com isso???

Ah, pra quem não conhece: meu Twitter.

2009-11-25T10:12:00.002-03:00

Hoje recebi um e-mail de Abelardo Fraga, Diretor Comercial da AF Datalink, fabricante de cabos coaxiais. Ele comenta sobre o artigo O fim da paranóia, que eu escrevi em julho deste ano, falando sobre a não necessidade de usarmos stubs nos cabos coaxiais em redes Wi-Fi. Copio abaixo o e-mail de Abelardo:

"Prezado João Paulo Just

Recebi o seu artigo e achei bem interessante. Realmente usar stub não se faz necessário, e não recomendamos.

Na verdade o maior indíce de problemas que achamos em instalações e que geram problemas de transmissão do sinal são:

uso de conectores de baixa qualidade
montagem dos conectores não adequadas
danos no cabo

Claro que poderia falar de uso de cabos de baixa qualidade (mas prefiro omitir este comentário para não parcerer parcial ).

O fato é que gastamos muitos esforços na fabricação (controle do processo) dos cabos para termos um cabo com baixa perdade retorno, sem contar nos investimentos em equipamentos de controle do processo e de laboratório. A garantia da baixa perda de retorno no cabo , um manuseio adequado do cabo em campo e com uma boa conectorização são necessários e suficientes para ter uma boa transmissão de sinal.

Faço aqui o convite para conhecer a nossa fábrica qdo estiver por São Paulo."

Fica claro que não precisamos realmente usar stubs pra fazer casamento de impedância dos nossos sistemas. Uma boa conectorização e manuseio dos cabos são suficientes para tirarmos o máximo de proveito do nosso sistema, sem esquecer de usar materiais de boa qualidade, claro.

Obviamente, gambiarras só vão piorar a situação. Alguém aqui já viu stub em torres de operadoras de celular?

Calcule o casamento da sua antena

2009-07-26T21:53:00.005-03:00

Olá, pessoal.

Continuei trabalhando no assunto do post anterior, sobre stubs e casamento de impedâncias. Pra facilitar minha tarefa, fiz um programa em Java que calcula qual a porcentagem de potência do sinal emitido pelo rádio que chegará à sua antena, dadas as impedâncias complexas do cabo e da antena. O link para download está abaixo:

http://www.rg3.net/rf/impedancia.zip

O arquivo ZIP vem com o código-fonte do programa (quem quiser mexer no código, use o Eclipse). Pra rodar, basta ter o Java instalado e executar o arquivo Impedancia.jar

Pois bem, com esse programa, fiz uns testes. Um certo indivíduo andou dizendo que provedor de Internet não sabe instalar antena, que na maioria das vezes, quando um provedor instala uma antena, obtém apenas 30% de rendimento do sistema (ou seja, apenas 30% da energia emitida pelo rádio é irradiada pela antena). E que fazendo o stub, poderíamos conseguir subir esse nível pra 80%.

No texto do post anterior, mostrei através de cálculos que usando um cabo de 50 ohms e uma antena também de 50 ohms de dois fornecedores bem conhecidos, conseguiríamos 99% de rendimento (99% da energia do rádio seria irradiada pela antena). Em um post do Under-linux.org, essa mesma pessoa disse que isso era absurdo, que se os fabricantes tivessem feito a antena com aquele valor de impedância que usei, eles poderiam fazer antenas pra NASA, pois estaria muito perfeita (eu acredito no fabricante, pois pelo e-mail que recebi, me parece que eles mediram esse valor de impedância. Tem até um gráfico da Carta de Smith).

Então, decidi fazer mais cálculos. Suponha que estamos usando uma antena de exatos 50 ohms e um cabo de também exatos 75 ohms. Já é uma diferença muito grande, imagino que maior do que a diferença real entre um cabo e uma antena, ambos de 50 ohms. Usei o programinha que fiz pra medir quanta energia chegaria à antena e obtive o resultado abaixo:

De acordo com os cálculos, 96% de energia chegaria à antena. Ora, usando cabos e antenas de 50 ohms não seriam apenas uns 30%?? Como é que usando um cabo de 75 ohms e uma antena de 50 ohms conseguiríamos 96%?

Decidi continuar, e usei agora um cabo de 100 ohms e uma antena ainda de 50 ohms. Muito grande a diferença, não é? Será que um cabo comercial de 50 ohms e uma antena comercial também de 50 ohms chegariam a essa diferença tão monstruosa? Mesmo assim, vamos ver como ficaria?

Agora, 88,88% (praticamente 89%) da energia foi irradiada. Perdemos 12% de energia. E aquela história que antena de provedor de Internet só irradia 30% de energia? Será que uma instalação de provedor, usando os cabos de impedâncias corretas, é realmente pior que essa instalação usando cabos de 100 ohms e antenas de 50 ohms?

O que eu quero dizer mais uma vez, é que não precisamos nos aterrorizar com fábulas e charadas de um engenheiro marqueteiro, que só quer vender antenas. Também não estou dizendo que podemos usar qualquer cabo na instalação, claro que 12% de energia é uma perda a qual não podemos nos dar o luxo de perder, principalmente por causa do sinal que chega à antena, que é na casa dos decibéis negativos.

E pra ressaltar: não sou eu que estou inventando essas coisas, tudo isso aprendi em livros.

O fim da paranóia (pra que stubs?)

2009-07-20T13:41:00.002-03:00

Em maio, fiz o curso de antenas do Eng. Gilvan Enriconi. Porém, não saí de lá 100 % satisfeito e ainda fiquei meio em dúvida sobre algumas coisas ali ensinadas.

Uma delas é o uso de stubs para casamento de impedâncias. Porém, os rádios Wi-Fi são de 50 ohms, as antenas também são de 50 ohms e sempre usamos cabos de 50 ohms para conectá-los. Então as impedâncias já estão casadas, certo? Porém, segundo Gilvan, os cabos e antenas não possuem as impedâncias exatamente em 50 ohms. Sendo assim, obtive as impedâncias complexas e exatas de cabos e antenas que eu uso através dos fabricantes e apliquei as fórmulas para cálculo de ROE.

Minha conclusão: não precisamos de stub, como Gilvan dizia em seus cursos.

No link abaixo, vocês poderão baixar um PDF com explicações completas e os cálculos que me levaram à esta conclusão.

http://www.rg3.net/rf/o_fim_da_paranoia.pdf

Meu Twitter

2009-04-08T07:56:00.002-03:00

Há um tempo atrás (um ou dois meses, mais ou menos), criei uma conta no Twitter.

Pra que não conhece, o Twitter é um serviço de microblog. E o que seria isso? Você escreve pequenos textos de até 140 caracteres, como se fosse um blog. O bom é que na sua página do Twitter você vê rapidamente seus textos e os textos das pessoas que você está seguindo. Quando você escreve um texto, ele também fica visível na página dos seus seguidores. Só experimentando pra entender completamente.

Pra quem quiser me seguir por lá: twitter.com/jpjust

Aulas de Java

2009-04-04T09:05:00.003-03:00

Quem me conhece sabe que eu odeio Java, porém, fui chamado pra dar aula de programação Java em um centro técnico daqui da minha cidade. Aceitei a proposta como um desafio, somente assim eu iria aprender (mesmo não gostando, é bom aprender outra linguagem).

Comecei a dar as aulas em uma sexta-feira 13 (13 de março). Na primeira semana, foi só lógica de programação e algorítmos, da segunda em diante, colocamos a mão na massa com o Eclipse.

Como o curso tem somente 300 h, as coisas estão andando um pouco rápidas. Enquanto que nas Universidades estudamos algorítmos em um semestre inteiro antes de pegar uma linguagem mais complexa, já entraremos em orientação a objetos na semana que vem.

Qual o motivo desse post? Estou pensando em colocar posts ensinando o básico de Java aqui, da mesma forma que fiz com wxWidgets. Mas ainda não decidi, pois somente quando terminar o curso é que vou fazer uma auto-avaliação pra saber se poderei escrever as aulas-posts de Java com um mínimo de qualidade.

Por enquanto, estou aprendendo com meus alunos. :)

Chegamos!

2009-02-13T20:31:00.000-03:00

Já é 1234567890!!! :)

http://coolepochcountdown.com/

Fechando o ano com tag de ouro

2008-12-31T17:49:00.001-03:00

<p><strong>Desejo a todos os visitantes do meu blog boas festas,
felicidades, e um ano novo repleto de realizações!</strong></p>

</2008>

Protegendo-se com o FreeBSD

2008-12-23T09:42:00.002-03:00

Estava fuçando na net sobre alguns "tunnings" pro FreeBSD e achei isso:

Protecting yourself with FreeBSD

Essa página mostra algumas atitudes que administradores de sistemas FreeBSD podem tomar pra tentar diminuir os impactos de um ataque DDoS. O texto é antigo, mas vale ainda hoje. :)

Feliz Natal a todos e até 2009!! :D

RG3.Net agora em inglês

2008-11-06T14:44:00.002-03:00

Para o resto do mundo, pois seria muito egoísmo deixar o serviço de redirecionamentos da RG3 somente para os falantes da língua portuguesa. :)

Comecei antes de ontem a traduzir a aplicação usando o plugin I18N do Catalyst.

Com esse plugin, basta eu colocar as strings que deverão ser trauzidas dentro do método Catalyst->loc() e com a ajuda do xgettext.pl, criar e manter os arquivos .po de cada idioma. No caso do site da RG3, deixei as strings da aplicação em inglês, que vai ser o idioma padrão e criei o arquivo pt.po com as traduções pra português.

Dessa forma, se o navegador do visitante tiver suporte a português, o site vai abrir em português, caso contrário, abrirá em inglês.

Configure seu navegador com o idioma inglês e dê uma olhadinha.

O jornal Folha Online me decepcionou

2008-10-29T11:13:00.002-03:00

Hoje li uma matéria no Folha Online - Informática que dizia sobre um aluno de 15 anos que foi processado após ter descoberto uma falha no sistema da escola e avisado ao diretor.

No último parágrafo da notícia, a Folha Online usa o termpo "piratas virtuais", enquanto que na notícia do site The Register, de onde eles provavelmente tiraram as informações, de acordo com o que diz o segundo parágrafo do texto da Folha Online, usou-se o termo "hacker" (para informar que os hackers criticaram a decisão de processar o jovem, já que ele não usou a falha pra prejudicar a escola e, ao invés disso, informou o problema ao diretor, que deveria apenas corrigir e agradecer o aviso).

Então, mandei a mensagem abaixo pro pessoal da Folha Online:

"Acho que não deveriam usar o termo 'piratas virtuais' no último parágrafo. Lendo a notícia original no The Register, eles dizem '...hackers have criticized...'. A mídia precisa entender que hacker não é vândalo nem pirata, esses últimos são chamados 'crackers'. Hackers são pessoas que estudam a fundo aquilo que gostam ou praticam ao ponto de fazer coisas que muitos possam achar politicamente incorreto. Por exemplo: um hacker pode criar um vírus com o intuito de aprender novas técnicas de programação, mas apenas o cracker disseminaria esse vírus com o intuito de prejudicar terceiros. Outro exemplo que achei bom, foi quando Richard Stallman disse que 'Gilberto Gil é um hacker da música'. Espero ter contribuído."

Fiz minha parte. Porém, minutos depois, recebi o seguinte e-mail da Folha Online:

"Prezado leitor, a Folha Online não utiliza o termo 'hackers'.

Esperamos contar sempre com sua leitura e participação

Atenciosamente,

Equipe Folha Online"

Fiquei decepcionado. Por que? Porque um jornal, formador de opinião, deveria usar os termos corretos. Dessa forma, os leitores acreditam que qualquer pessoa que descobre falhas em sistemas é um pirata virtual ou criminoso da informática. A mídia deveria usar os termos corretos, para que os hackers de verdade não fossem mais taxados de foras da lei.

Inclusive, pesquisando o termo "hacker" no próprio site do jornal, pude ver que eles usam sim a palavra "hacker". Vejam o resultado da pesquisa!

Google Chrome

2008-09-03T09:18:00.003-03:00

Instalei hoje nos PCs da RG3. Não pude instalar no meu notebook pois ainda não fizeram o Chrome pra Linux :(

A primeira impressão que tive é que ele realmente é bem simples. Navegador foi feito pra navegar e pronto. Nada de frescuragem. Se o Firefox simplificou a cara dos navegadores, o Chrome simplificou mais ainda (e o Internet Explorer acabou tendo que acompanhar o Firefox nesse quesito).

A segunda impressão que tive é que o bixo é realmente rápido! Nunca vi coisa igual. Não sei se é porque o cache dele ainda está vazio, mas a velocidade me impressionou. Ele usa o mesmo engine do Safari, o WebKit. Inclusive, olhando o User-Agent do Chrome, vi que tem um Safari no final da string (não pude colar a string inteira aqui porque estou escrevendo esse post pelo Linux, vou pegar a string no Windows e colocar aqui depois).

Li também toda a estória em quadrinhos que a Google fez pro lançamento do Chrome e pude concluir que eles fizeram um navegador da complexidade de um sistema operacional, muito violento. Inclusive a forma de tratar as coisas, com vários processos, isolamento entre eles, etc., ficou muito bom e bem pensado.

A terceira coisa que gostei nele foi a página "New tab", que aparece quando você abre uma nova aba. Nessa página, são mostrados os thumbnails dos nove sites mais acessados, além das pesquisas mais recentes. Basta um clique pra reabrir uma página.

O site oficial está em www.google.com/chrome.

Pra quem não sabe do que estou falando ainda, leiam essa notícia.

Do FreeBSD 4.7 ao 7.0

2008-08-28T18:24:00.000-03:00

Em 7 de fevereiro deste ano, escrevi um post contando minha trajetória pelo Linux. Nos comentários deste post, um Anônimo pediu pra eu contar minha trajetória pelo FreeBSD.

Pois bem, a vida com FreeBSD também começou quando eu cursava Física na UEFS. Eu já estava me familiarizando com os RedHats 7.0 do Laboratório de Física Computacional e, inclusive, já havia instalado ele em um servidor de impressão que tinha no laboratório. Não era uma máquina parruda, apenas um Pentium 233 MHz com 64 MB de RAM.

Dois colegas de curso, Alex Gamas e Leonardo Gamas (irmãos) eram uma das minhas principais fontes de conhecimento em Linux, seguidos por Jorge Kaschy, Nazareno e Dagoberto Freitas (estes três últimos, professores), e foram os irmãos Gamas que me apresentaram o FreeBSD.

Na época, consegui um CD de instalação do FreeBSD 4.7, não lembro se foram eles que me conseguiram ou se eu baixei na Internet. Tirei o RedHat 7.0 do servidorzinho e instalei o Free. Com o Samba, eu fiz um controlador de domínio e os alunos do curso passaram a ter login e senha para acessar as máquinas. Isso ajudou bastante, porque na Universidade, vinha gente de todo canto, às vezes nem aluno era, e ficavam enchendo as máquinas com vírus.

Com o Samba e o FreeBSD 4.7 fiz também um servidor de impressão. O pessoal gostou muito. Tinham 20 MB de espaço no HD pra salvar trabalhos e podiam imprimir sem os problemas que davam antes no Windows NT, que era o sistema do servidor antes do RedHat.

O esquema de PDC (controlador de domínio) fez tanto sucesso na Universidade que um professor do curso de Matemática me chamou pra ajudar ele a fazer o mesmo no laboratório de lá. Inclusive, alguns alunos de outros cursos vinham me pedir pra usarem os PCs do nosso laboratório, pois tínhamos a fama de "o único laboratório da UEFS sem vírus", mas isso não tem nada a ver com o FreeBSD no servidor, tem a ver com as políticas de segurança que eu aplicava nos Windows NT dos PCs. Em 2004 fui pra Ilhéus cursar Ciência da Computação na UESC e desde então, nunca mais havia usado um FreeBSD.

Em 2006, quando comecei a ajudar os funcionários da RG3.Net a dar manuntenção nos servidores foi que me reencontrei com o FreeBSD, desta vez, na versão 5.2.

Em 2007, assumi a propriedade da RG3.Net e desde então, fiz algumas atualizações. O servidor do provedor tornou-se FreeBSD 6.2 (instalei uma máquina nova com o sistema do zero), que posteriormente foi atualizado para 6.3. Hoje em dia, temos outro servidor novo, com o FreeBSD 7.0. O servidor do site também foi atualizado pra versão 7.

Nessa retomada no mundo do FreeBSD foi que eu aprendi várias coisas, como usar o ports e outros programas correlatos como portsnap, portupgrade e freebsd-update.

Hoje em dia uso FreeBSD diariamente, não no meu desktop, mas nos servidores e estou feliz com isso. Inclusive, após usar Linux em servidores por muito tempo lá em Ilhéus e voltando pro FreeBSD aqui em Feira de Santana, posso afirmar: em se tratando de servidores de rede, considero o FreeBSD muito mais fácil de configurar e usar.

Enquanto isso...

2008-08-23T09:31:00.002-03:00

...já anunciaram as datas previstas para o lançamento do FreeBSD 6.4 e do 7.1.

Estou ansioso pra atualizar pro 7.1. O 7.0 está rodando bem aqui, mas tive alguns problemas com o ppp. Mas isso é assunto pra outro post.

Servidores do Fedora invadidos

2008-08-22T18:23:00.003-03:00

Olá, pessoal.

Voltei a postar no meu (quase abandonado) blog e a notícia não é boa (não que eu use Fedora, mas invasões nunca são boas).

Fiquei sabendo hoje que alguns servidores do repositório do Fedora foram invadidos. Existe um e-mail na lista de discussão fedora-announce-list que explica melhor o fato:

Infrastructure report

Distro de tolo

2008-03-28T09:31:00.002-03:00

Recebi por e-mail, na lista da FUG-BR. Fiz uma pequena alteração: adicionei o animal na nona estrofe, sendo fiél à versão original de Raulzito.

Letra de Leonardo Menezes Vaz
Música de Raul Seixas

Bah!
Eu devia estar contente, porque eu tenho um emprego
Sou um dito SysAdmin respeitável e ganho mil reais por mês...

Bah!
Eu devia agradecer por ter tido sucesso na vida como SysAdmin
Eu devia estar feliz porque consegui integrar o OpenSuSE com o Windows 2003...

Bah!
Eu devia estar alegre e satisfeito por morar em Porto Alegre
Depois de ter passado fome por vinte dias na Alemanha...

Bah!
Eu devia estar sorrindo e orgulhoso
Por finalmente ter conseguido entrar no Planet SuSE,
Mesmo que todo mundo me zoe e faça disso uma piada jocosa...

Bah!
Eu devia estar contente por ter conseguido tudo isso
mas confesso abestalhado que eu estou decepcionado...

Porque foi tão fácil conseguir, e agora eu me pergunto "e daí?"
Eu tenho uma porção de coisas prá blogar
E eu não posso ficar aqui parado...

Bah!
Eu devia estar feliz pelo Senhor
Ter me concedido o Sábado prá ir com a pessoal
No evento do Tchelinux dar palestra de OpenSUSE...

Bah!
Mesmo falando das facilidades,
da Novell, Microsoft, Lagarto, SLES, YAST
E mesmo assim não ter ninguem que use...

É você olhar no espelho e ver um SysAdmin Júnior
Saber que o YAST é uma ferramenta limitada
E que deixa só dez por cento de sua CPU livre, animal!

E você ainda acredita que ser é um CCNA, MCSS ou MCSE
É grande coisa, e que te garante um lugar no mercado...

Bah,
Eu que não me sento numa cadeira de CPD
Com a boca escancarada cheia de dentes
Esperando o OpenSuSE bootar...

Porque longe dos datacenters onde rodam SLES com YAST
existem servidores BSDs e SysAdmin de verdade que usam vi...

O castigo dos 64 bits

2008-03-10T14:53:00.002-03:00

Pois eh, quem tem processador de 64 bits sofre pra usar todos os bits.

Meu notebook eh um Athlon X2 64-bits, estava rodando Debian (amd64) nele. Havia problemas com o Flash e outras coisas que so tinham pra 32-bits. Um xunxu (workaround) com bibliotecas de 32-bits resolvia o problema, mas era muito chato fazer isso.

Esse fim de semana instalei o FreeBSD 7.0 (amd64 tambem) nele, ja estava querendo tirar o Linux pra botar FreeBSD fazia um tempo. Instalou direitinho (quer dizer, deu um pouco de trabalho pra dar boot no CD).

O problema eh que o driver da nVidia pra FreeBSD suporta somente i386, ou seja, sem driver oficial pra 64-bits no FreeBSD. Ja meio triste, tentei o driver do X.org, aquele "nv" que a gente usa no xorg.conf. Nada de iniciar o X... problema viu! O jeito foi usar o X com o "vesa", que, obviamente, nao tem os recursos de aceleracao 3D.

E isso nao acontece so no mundo do UNIX nao, tambem usei Windows Vista por umas semanas nesse notebook. Instalei a versao de 64-bits e nem os proprios drivers de 64-bits que vieram no CD do computador funcionaram direito. Como resolvi? Instalei o Windows XP de 32-bits mesmo :(

Acho que vou ter que fazer o mesmo no FreeBSD ou mesmo no Linux (se tiver que voltar pra ele). Pesquisando no Google, encontrei muitas pessoas tendo problemas com SO de 64-bits: drivers faltando, menos pacotes nos repositorios, programas nao-suportados, etc.

Vamos ver no que isso vai dar.

FreeBSD 7.0!

2008-02-28T17:11:00.003-03:00

Já foi! Lançaram ontem (me atrasei a postar no blog).

Já vou baixar e deixar o CD gravado e guardadinho pras horas certas :) E vou também atualizar o servidor da RG3 que tá rodando o 7.0-RC2 ainda. Ôh, notícia boa!!!

Que o download comece!

http://www.freebsd.org/releases/7.0R/announce.html

----- texto adicionado -----

Essa não podia deixar de postar. Tenho que adicionar essa imagem a este post. Fui baixar a ISO como tinha dito acima, e vejam só: rsrs

Tá todo mundo baixando. Na lista da FUG tá uma euforia só!

Flash Player para Linux 64-bits (amd64)

2008-02-18T08:50:00.003-03:00

Muitos vão acabar chegando aqui pelo Google, achando que encontraram a solução para o Flash Player em Linux amd64. Bem, a solução completa não tenho aqui (posso até fazer um post explicando como fiz o Flash funcionar no meu Debian amd64), mas tenho a raiz da solução do problema.

Gostaria de pedir a vocês que visitassem duas páginas:

http://www.petitiononline.com/lin64swf/petition.html
http://www.adobe.com/cfusion/mmform/index.cfm?name=wishform

A primeira, é uma petição on-line para que os desenvolvedores da Macromedia façam uma versão de 64-bits do Flash Player pra Linux. A segunda, é uma página do próprio site da Macromedia onde é possível pedir novos recursos, no caso, devemos solicitar uma versão de 64-bits do Flash Player pra Linux (foi o que eu fiz).

A expectativa é que através da petição e dos pedidos pelo site da Macromedia, eles finalmente façam uma versão de 64-bits pra Linux. Isso resolveria nossos problemas, pois não precisaríamos mais manter versões de 32-btis dos nossos navegadores pra poder ver conteúdo em Flash.

Eu por exemplo, tenho um notebook AMD64, mas preciso usar o Firefox de 32-bits por causa do Flash. Isso me deixa irritado! :P

Pois bem, vamos assinar a petição e encher o saco da Macromedia até que eles façam a bendita versão de 64-bits.

RG3.Net de cara nova

2008-02-11T21:45:00.000-03:00

Neste último domingo, dia 10 de fevereiro, terminei a aplicação de redirecionamento da RG3.Net e fiz o upload pro servidor. Instalei tudo em uma máquina recém-formatada com FreeBSD 7.0 RC1.

O que mudou?

Absolutamente tudo!

A página principal agora tem também textos sobre o provedor de Internet a Rádio que temos aqui em Feira de Santana e uns links pra testadores de velocidade.

O site do provedor está com mais detalhes sobre o serviço e os planos de acesso e também um pequeno "how-to" explicando ao cliente como criar sua conexão com a Internet.

Mas a principal mudança foi no serviço de redirecionamento. O sistema antigo era feito em PHP e tinha algumas falhas de programação. Não vou falar muito sobre elas pra não ofender o programador antigo, que eu nem sei quem é (compramos a RG3 já pronta, não fomos nós que fundamos).

O sistema novo foi desenvolvido completamente do zero em Perl com Catalyst. Com bem menos linhas de código, escrevi uma nova aplicação com recursos a mais (mais de um domínio para escolha além de três formas de recuperação de senha) e interface gráfica melhorada.

No sistema antigo, quando o usuário fazia logon, os campos de login e senha que ficavam no menu esquerdo do site eram substituídos por três links que davam acesso às opções dos redirecionamentos. Isso era ruim, pois o usuário via a mesma página, com apenas um pequeno detalhe diferente e a maioria acreditava que não estava conseguindo fazer login, já que a página que aparecia após o "Enter" era praticamente a mesma. O que isto causava? Vários e-mails do tipo "Não consigo entrar na minha conta!!!".

O sistema novo roda também no Apache, como o antigo, porém, agora com FastCGI. Pra quem não conhece, o FastCGI permite que uma aplicação Web, no meu caso, uma aplicação em Catalyst, faça um melhor gerenciamento das requisições. Coisas comuns à aplicação, como acesso ao servidor de banco de dados, por exemplo, acontece apenas uma vez, melhorando o desempenho. No sistema em PHP, cada vez que um redirecionamento era solicitado, o programa abria uma conexão com o banco, pegava os dados e fechava a conexão. Com Catalyst no FastCGI, a conexão é aberta apenas uma vez, quando a aplicação inicia. Sempre que um redirecionamento é solicitado, a aplicação usa a conexão já aberta pra obter os dados. Diferentemente do CGI puro, onde cada requisição criava um novo processo no servidor, com FastCGI apenas um processo é criado. Em alguns momentos, quando ocorrem muitas requisições, alguns processos a mais são criados, mas ainda assim, cada processo existente gerencia várias requisições, poupando memória e recursos.

Leiam mais sobre a performance do FastCGI em http://www.fastcgi.com/devkit/doc/fcgi-perf.htm

Além dessas alterações internas no sistema e mudança de interface gráfica, quatro novos domínios foram adicionados, possibilitando outras alternativas de redirecionamentos:

irg3.net

minhapagina.info

minhahome.com

minhahomepage.com

A idéia é sempre adicionar novos domínios (essa tarefa ficou bem fácil na aplicação nova :D) dando mais opções pros usuários.

Já ia esquecendo, no sistema novo, apenas um login e o e-mail são solicitados na hora do cadastro. Nem o nome a gente pergunta mais. Pra que? Geralmente não colocam o nome verdadeiro mesmo :P E pensar que no sistema antigo pedia até CPF... putz!

Do Red Hat para o Slackware para o Debian

2008-02-07T21:41:00.000-03:00

Nostalgia! De vez em quando gosto de relembrar o passado e uma parte do passado do meu eterno percurso na computação que mais gosto é quando comecei a mexer com Linux (e por tabela, FreeBSD).

Tudo começou quando entrei pro curso de Física da UEFS. Peguei um trabalho voluntário pra desenvolver a home page do departamento e me botaram pra trabalhar numa estação com Red Hat 7.0. As minhas únicas tentativas com Linux até o momento foram o Corel Linux, um Linux da Corel que não foi pra frente, e o Monkey Linux, que era um mini-linux que rodava em partições FAT32 (é, isso existia!). O Monkey Linux foi minha melhor experiência com mini-linux, pois rodava tudo nele, menos o X (que na época era o XFree86), mas depois eu descobri que o problema era que o XFree86 não tinha drivers pra minha placa de vídeo da época (SiS 6202).

Com o Red Hat foi que comecei a usar Linux de verdade. Três professores (Dagoberto, Jorge Kaschny e Nazareno) me ensinavam os básicos do sistema. Kaschny era o que mais fuçava na época. Aprendi muito com eles três e mais ainda com um colega de curso, Alex Gamas, que me deu muitas dicas na época e que junto com o irmão (Leonardo Gamas), aproximadamente um ano depois, me colocaram no mundo do FreeBSD.

Os irmãos Gamas me mostraram em seguida o Slackware. Eles me conseguiram um CD do Slackware 7.0 e eu instalei o sistema em casa. Nessa época, o Windows 98 já tinha se mandado de uma vez, dando espaço pro Red Hat. Quando comecei a usar o Slackware, delirei! Adotei como o meu Linux preferido e o utilizei por muito tempo: de 2002 até 2005. Fui até o Slackware 10.

Em 2006, comecei a usar o Debian, por pressão dos amigos de Ilhéus, quando ainda cursava Ciência da Computação na UESC. O que me levou a adotar o Debian foi o tamanho do seu repositório de pacotes pré-compilados. Eu já tinha enjoado de ter que compilar tudo pra rodar no Slackware.

Fiquei usando o Debian e continuo com ele até hoje. Acredito que seja a melhor distribuição Linux existente, pois mistura a leveza e simplicidade do Slackware com a facilidade de uso do Red Hat. Não é tão seco nem tão pesado, foi o meio-termo que encontrei no mundo do Linux. Claro que pra iniciantes e leigos, o Ubuntu seria uma melhor opção, mas aí você já sai do meio-termo e tende mais para o "pesado" do Red Hat e Fedora. :P

Em breve: wxWidgets 3.0

2007-11-23T22:07:00.000-03:00

Olá, pessoal! Quanto tempo, hein!? :P

Estive fora desde julho por falta de tempo. Vejam só:

Em março, tomei a frente de um provedor de Internet à Rádio em Feira de Santana, BA - RG3.Net. Além de ter que corrigir todos os erros de rede (tanto nos servidores quanto na estrutura wireless), gastei um bom tempo desenvolvendo uma aplicação Web (Perl com Catalyst) pra gerenciar o provedor (que estava meio bagunçado, tudo era feito no papel). Apenas nesse mês de novembro consegui um pouco mais de paz, pois corrigi os últimos problemas de hardware dessa rede wireless (o próximo passo é otimizá-la mais ainda).

Estou no último semestre da Universidade, o que significa que tenho que desenvolver algo na disciplina "Estágio Supervisionado". A sorte é que usei a própria RG3.Net como meu tema de estágio, então o que faço lá tenho que escrever em um relatório e apresentar agora em dezembro.

O site da RG3.Net também está sendo mudado (por dentro), como também os servidores. Dois deles já foram formatados e reinstalados. Lá rodava (e ainda roda) FreeBSD.

Todo esse trabalho na RG3.Net me ocupou bastante, até o WinPolicy ficou sem atualizações. Mas as coisas estão voltando ao normal. Com o fim do curso de Ciência da Computação, vou poder configurar melhor meu tempo e o blog terá seu espaço de volta :)

Na verdade, o que eu queria dizer é que o wxWidgets 3.0 está prestes a sair. Sua principal mudança vai ser que agora, UNICODE e ANSI estarão juntos em um único build da biblioteca. Algumas classes foram melhoradas e bugs corrigidos.

Mais detalhes no wxBlog.

traceroute.org e aniversário do blog

2007-07-12T21:06:00.000-03:00

Um site interessante.

Descobri ele quando estava tendo problemas de roteamento em um dos meus servidores. Pacotes que saiam de um IP específico da minha rede não saiam do país. Além disso, ninguém fora do país conseguia enviar pacotes para esse IP. Mas outros IPs da mesma rede funcionavam OK (no final das contas, foi um filtro na Embratel que estava causando o problema).

Então, comecei a testar as rotas para esse meu IP. Primeiro, fiz um traceroute a partir de um dos servidores da Dreamhost. No traceroute, percebi que no meio do caminho, o pacote era bloqueado. Eu queria fazer mais testes, vindos de outras máquinas no exterior, mas o servidor da Dreamhost era a única máquina com acesso remoto que eu podia entrar.

Nesas buscas pelo Google, encontrei o site www.traceroute.org. A partir deste site, você pode acessar outros sites em várias partes do mundo que permitem que você faça traceroutes para qualquer IP. Com ele, pude fazer testes de traceroute a partir de máquinas em vários outros países.

Muito legal este site. Recomendo aos administradores de redes. :)

PS: Comemoremos! Hoje faz exatamente 1 ano da Casa de Just! :D

numeros.pl

2007-07-09T08:10:00.000-03:00

Estava eu nesse fim de domingo, em casa, sem ter o que fazer. Nesse momento de ócio, lembrei de um numerólogo que estava dando entrevista essa semana na TV e procurei por Numerologia na Wikipédia. Comecei a ler o artigo e decidi fazer uns testes.

O problema é que é chato ficar somando os valores das letras dos nomes pra saber o número da pessoa. Então, como bom cientista da computação que sou, implementei um programinha pra fazer essa tarefa.

Pois bem, escrevi o código em Perl. Como programas em Perl são interpretados e não compilados, você vai precisar ter o interpretador instalado em seu computador pra executar o programa. Quem usa Windows, pode tentar o ActivePerl. Quem usa Linux ou outro UNIX, provavelmente já tem o Perl instalado (se não tiver, você pode baixar o fonte e compilar ou instalar o pacote correspondente). Pra executar o programa, use a linha de comando:

perl numeros.pl

O programa irá perguntar seu nome completo e sua data de nascimento. Em seguida, vai somar os valores de cada letra do nome e dar seu número na numerologia. Depois, vai somar os números da sua data de nascimento e lhe entregar o número correspondente à sua lição de vida. Aí é só usar o artigo da Wikipédia pra saber o que cada número significa.

#!/usr/bin/perl
# Referencia: http://pt.wikipedia.org/wiki/Numerologia

# Soma os digitos
sub soma {
 my $numero = 0;
 my (@digitos) = split(//, $_[0]);

 for (my $i = 0; $i < @digitos; ++$i) {
  $numero += abs($digitos[$i]);
 }
 
 if ($numero >= 10) {
  return &soma($numero);
 } else {
  return $numero;
 }
}

# Tabela de numerologia
my $tabela = ({
 a => 1, b => 2, c => 3, d => 4, e => 5, f => 6,
 g => 7, h => 8, i => 9, j => 1, k => 2, l => 3,
 m => 4, n => 5, o => 6, p => 7, q => 8, r => 9,
 s => 1, t => 2, u => 3, v => 4, w => 5, x => 6,
 y => 7, z => 8,
});

# Solicita o nome
my $nome = undef;
do {
 print "Digite seu nome completo, sem acentos ou cedilha:\n";
 $nome = lc(<STDIN>);
 
 chop($nome);
} while ($nome eq '');

# Solicida data de nascimento
my $nasc = undef;
do {
 print "Digite sua data de nascimento, ex.: 10\/11\/1982\n";
 $nasc = lc(<STDIN>);
 
 chop($nasc);
} while ($nasc eq '');


# Divide as letras e calcula a soma
my (@letras) = split(//, $nome);
my $numero = 0;

for (my $i = 0; $i < @letras; ++$i) {
 next if $letras[$i] eq ' ';
 $numero += $tabela->{$letras[$i]};
}

# Exibe o resultado
print "Seu numero: " . &soma($numero) . "\n";
print "Sua licao de vida: " . &soma($nasc) . "\n";

Novo: Slackware 12

2007-07-07T20:55:00.000-03:00

Isso aqui vai acabar virando blog de notícias de atualização de distros :P Mas pelo menos tô voltando à ativa, rsrs

Pois bem, o Slackware 12 veio essa semana e algumas mudanças são notáveis. De acordo com o anúncio oficial, o Slackware agora vem com dois tipos de kernels: kernels grandes, que vêm com todo tipo de driver possível, geralmente pra facilitar a instalação do sistema, além do kernel genérico, que tem os drivers compilados como módulo (a forma mais comum de kernel).

Outra novidade é que ele agora vem com o HAL (Hardware Abstraction Layer), aumentando a habilidade Plug and Play do Slackware.

A nova versão atualiza também a maioria dos pacotes: kernel 2.6.21.5, KDE 3.5.7, X.Org 7.2.0, gcc 4.1.2, Apache 2.2.4, etc.

Para a lista completa das mudanças, leiam o anúncio oficial.

Debian 4.0 (etch) se torna stable!

2007-04-08T19:45:00.000-03:00

Finalmente! Aguardava esse momento há alguns meses.

O Debian 4.0, codenome etch, deixou de ser testing e agora é stable. Ele havia sido congelado em dezembro do ano passado, ou seja, novos pacotes deixaram de ser adicionados e os pacotes já contidos no sistema estavam em fase de correção de bugs.

A notícia oficial pode ser lida no site do Debian:

http://www.debian.org/News/2007/20070408

Como também, instruções de download e instalação:

http://www.debian.org/distrib/

Quem usa o Justsoft GNU/Linux, já está rodando o sistema Justsoft em cima do Debian etch. Portanto, basta atualizar o sistema através do APT ou do próprio assistente de atualização que fica ao lado do relógio do GNOME.

Apesar de agora ser stable, vou esperar um pouco antes de atualizar meu servidor, que já usa Debian 3.1 (sarge).

Curso de wxWidgets, post 14: Comunicando-se pela rede

2007-03-18T00:54:00.000-03:00

Olá, pessoal! Como havia prometido no post anterior, este será sobre sockets e comunicação via rede.

Nesta primeira parte, abordarei o cliente, ou seja, o programa irá conectar em algum servidor. Tive a idéia de fazer um código para enviar e-mails, já que o protocolo SMTP é simples e fácil para mensagens em texto plano e sem anexos. Para quem não conhece o protocolo SMTP, sugiro que leia a RFC822, que descreve seu formato:

ftp://ftp.rfc-editor.org/in-notes/rfc822.txt

De qualquer forma, vou dar uma resumida no protocolo.

Nos parágrafos abaixo, <- indica uma mensagem que está vindo do servidor e -> indica uma mensagem que o cliente está enviando para o servidor.

Ao se conectar em um servidor SMTP, o cliente recebe uma mensagem de boas-vindas, geralmente com o endereço do servidor e alguns dados do software:

<- 220 spaceymail-mx1.g.dreamhost.com ESMTP

Em seguida, o cliente deve se idenficar enviando a string "EHLO" e o seu endereço. Após a identificação, o servidor dá algumas informações sobre o envio da mensagem (não relevante para nós no momento):

-> EHLO just.justsoft.com.br
<- 250-spaceymail-mx1.g.dreamhost.com
<- 250-PIPELINING
<- 250-SIZE 40960000
<- 250-ETRN
<- 250-STARTTLS
<- 250 8BITMIME

Agora o cliente deve dizer o endereço do remetente com o comando "MAIL From:" e do destinatário com "RCPT To:":

-> MAIL From: <teste@teste.com>
<- 250 Ok
-> RCPT To: <jpjust@justsoft.com.br>
<- 250 Ok

Após estas informações, o cliente começa a mensagem com o comando "DATA":

-> DATA
<- 354 End data with <CR><LF>.<CR><LF>
-> From: <just@just.com>
-> To: <jpjust@justsoft.com.br>
-> Date, Thu, 15 Mar 2007 21:00:00 +0000
-> Subject: Teste
-> 
-> teste
-> 
-> .
<- 250 Ok: queued as 6C0C3CE937

O fim da mensagem deve ser indicado com um ponto (.) sozinho em uma linha. Por último, o cliente pede para o servidor fechar a conexão com "QUIT":

-> QUIT
<- 221 Bye

E é isto! Você pode testar os comandos conectando em algum servidor SMTP pelo telnet. Basta executar o comando "telnet mx1.hotmail.com 25" para conectar no servidor SMTP do Hotmail e enviar mensagens para endereços de lá. Veja abaixo uma pequena lista com o servidor SMTP de alguns serviços de e-mail famosos:

Hotmail: mx1.hotmail.com
Yahoo!: a.mx.mail.yahoo.com
GMail: gmail-smtp-in.l.google.com
UOL: mx.uol.com.br
BOL: mx.boil.com.br

Se você usa Linux ou algum outro UNIX, use o comando host para saber o servidor SMTP de algum domínio de e-mail. Por exemplo, para saber o servidor SMTP de gmail.com:

$ host -t MX gmail.com

Voltando à programação, o que iremos fazer é um programa em wxWidgets para se conectar a um servidor SMTP e enviar um e-mail.

A parte wxWidgets da coisa

Para todo o trabalho de rede no wxWidgets, usaremos a classe wxSocketBase e uma classe derivada, a wxSocketClient.

wxSocketBase é a classe base para todas as outras classes de socket no wxWidgets. Neste post, usaremos apenas a classe wxSocketClient, que é responsável por fazer as conexões do nosso programa, que é o cliente, no servidor.

Conectando-se no servidor

Antes de fazer alguma conexão com a wxSocketClient, precisamos do endereço do servidor ao qual vamos nos conectar e também a porta da conexão. Para manusear essas informações, usaremos a classe wxIPV4address. Essa classe serve para guardar informações de um endereço, como número IP e porta. Para definir o endereço do servidor e a porta, usamos dois métodos:

wxIPV4address host;
host.Hostname(wxT("smtp.server.com"));
host.Service(wxT("25"));

No trecho de código acima, criamos um objeto de nome host, que é uma instância de wxIPV4address. Em seguida, definimos o endereço como smtp.server.com e a porta como 25.

Após criar um objeto com o endereço e a porta do servidor, podemos chamar o método wxSocketClient::Connect() para conectar no servidor:

wxSocketClient sock;
bool status;
status = sock.Connect(host);

Se a conexão for feita com sucesso, o método retorna true, que será guardado na variável status. Em caso de erro na conexão, logicamente, o método retornará false.

Por padrão, o método wxSocketClient::Connect() aguarda a conexão ser feita ou a ocorrência de um erro para prosseguir a execução. Mas é possível chamar o método e continuar a execução do programa enquanto o socket está se conectando, basta adicionar um parâmetro ao método:

sock.Connect(host, false);

O segundo parâmetro indica se o método deverá aguardar a conexão ser completada. Se você escolheu esta maneira para se conectar, poderá verificar se a conexão foi feita posteriormente com o método wxSocketBase::IsConnected() ou até mesmo, aguardar pela conexão em um ponto posterior com wxSocketClient::WaitOnConnect().

Enviando dados

Após ter sido feita a conexão, já é possível enviar e receber dados. Para fazer o envio, usamos o método wxSocketBase::Write(). Após enviar qualquer dado, podemos verificar se o envio foi feito com sucesso com o método wxSocketBase::Error():

wxString dado = wxT("EHLO localhost\r\n");
socket.Write((char *)dado.mb_str(), dado.Len());
if (socket.Error())
{
  wxMessageBox(wxT("Erro ao enviar o dado."));
}

No trecho acima, enviamos a string "EHLO localhost\r\n" e em caso de erro, uma mensagem é exibida ao usuário. Perceba o cast (char *) e o método wxString::mb_str(). Este método retorna a string no formato ANSI. Perceba também que o método wxSocketBase::Write() não define um tipo de dado específico, você pode enviar texto puro ou binário. Como no nosso exemplo de um cliente SMTP estamos enviando texto puro, obtemos o formato ANSI da string e usamos o cast (char *) para indicar ao método que estamos enviando um char. O segundo parâmetro do método indica o tamanho do dado que estamos enviando. No caso, como é texto puro em ANSI (1 byte por caracter), indicamos o tamanho da string.

Em caso de erro no envio, wxSocketBase::Error() retorna true.

Recebendo dados

Após enviar algum dado pelo socket, geralmente esperamos por uma resposta, esta é a hora de fazer a leitura do socket. Para isto, usaremos o método wxSocketBase::Read():

char buffer[1024] = {0};
socket.Read(buffer, 1024 - 1);
if (socket.Error())
{
  wxMessageBox(wxT("Erro ao fazer a leitura."));
}
int contagem = socket.LastCount();

Primeiro, criamos um buffer do tipo char com 1 KB. Em seguida, fazemos a leitura, armazenando a saída em buffer e indicando o máximo de dados que deverá ser lido (subtraímos 1 do tamanho pois devemos guardar um espaço para o terminador de string \0 da variável).

Mais uma vez, wxSocketBase::Error() entra em ação para nos informar se houve algum erro.

Neste trecho, usamos também o método wxSocketBase::LastCount(), ele retorna o número de bytes lidos no wxSocketBase::Read(). Ele também pode ser usado após um wxSocketBase::Write() para saber quantos bytes foram enviados de fato.

Fechando a conexão

Após enviarmos e recebermos todos os dados necessários para a conexão, devemos terminá-la. Basta um único método para isso, o wxSocketBase::Close():

socket.Close()

Existe também um outro método relacionado ao término de conexão, o wxSocketBase::WaitForLost(). Com ele, você pode indicar um timeout em segundos ou milissegundos. Se a conexão for fechada antes do timeout (o servidor pode fechar a conexão), o método retorna true, caso o timeout seja atingido, ele retorna false.

Outras formas de E/S

Além do wxSocketBase::Read() e do wxSocketBase::Write(), existem também o wxSocketBase::WriteMsg() e o wxSocketBase::ReadMsg(). Com esses dois métodos, é possível trocar mensagens entre duas aplicações em wxWidgets sem precisar se preocupar com a contagem de bytes enviados ou recebidos.

Mostrarei estes e outros métodos das classes de socket em posts futuros. Ainda há muito o que falar sobre sockets no wxWidgets :)

Configurando o socket

Também é possível fazer algumas configurações no socket antes de utilizá-lo. Veja abaixo.

wxSocketBase::SetTimeout(): configura o tempo de timeout em segundos para os métodos de E/S e de espera do socket. O valor padrão é de 10 minutos.

socket.SetTimeout(120); // Configura o timeout para 120 segundos

wxSocketBase::SetFlags(): configura o comportamento de espera do socket nas operações de E/S. Pode receber como argumento os valores abaixo:

wxSOCKET_NONE: Funcionamento normal.
wxSOCKET_NOWAIT: Lê ou grava o máximo possível de dados e retorna imediatamente.
wxSOCKET_WAITALL: Aguarda que todo o dado seja lido ou gravado ou que um erro ocorra para retornar.
wxSOCKET_BLOCK: Bloqueia a interface gráfica durante a operação.
wxSOCKET_REUSEADDR: Permite que o socket escute em uma porta que já está em uso (apenas para sockets de servidor).

Para configurar o socket para sempre aguardar que os dados sejam lidos ou gravados por completo antes de continuar a execução do código, use:

socket.SetFlags(wxSOCKET_WAITALL);

Outros métodos de configuração do socket serão vistos nos outros posts.

Nosso código de exemplo

Finalmente, o código do programa que irá fazer a conexão e enviar o e-mail. O código está bem documentado para que você possa entender cada parte do programa.

A interface gráfica já vai aparecer preenchida com os dados do servidor SMTP do GMail e meu endereço de e-mail de lá. Por favor, envie um e-mail para mim pelo programa de exemplo :) Obrigado.

/* A Casa de Just - http://jpjust.blogspot.com
 * Curso de wxWidgets: Enviando e-mails via SMTP
 *
 * O objetivo deste código-fonte é demonstrar diversas classes
 * ensinadas no curso de wxWidgets do blog "A Casa de Just".
 *
 * As aulas do curso de wxWidgets podem ser encontradas em forma
 * de posts no blog: http://jpjust.blogspot.com
 *
 * Copyright (c) João Paulo Just <jpjust@justsoft.com.br>
 * A Casa de Just - http://jpjust.blogspot.com
 * 18 de março de 2007, 00:48, Ilhéus, BA, Brasil.
 */

#include <wx/wx.h>
#include <wx/socket.h>
#include <string.h>
#include <time.h>

// Tamanho do buffer que será utilizado no recebimento de mensagens
#define BUFFER 256

// Enumeração dos IDs
enum
{
 ID_ENVIAR
};

// Classe: MailApp
class MailApp: public wxApp
{
public:
 virtual bool OnInit();
};

// Classe: MailFrame
class MailFrame: public wxFrame
{
public:
 MailFrame(void);
 
 DECLARE_EVENT_TABLE()
 
private:
 void EnviarMensagem(wxCommandEvent &event);  // Método para enviar a mensagem
 wxString Envia(wxSocketBase *socket, wxString msg); // Método para enviar dados pelo socket
 wxString Le(wxSocketBase *socket);   // Método para obter dados no socket
 
 wxStaticText *lb_servidor;
 wxStaticText *lb_porta;
 wxStaticText *lb_de;
 wxStaticText *lb_para;
 wxStaticText *lb_assunto;
 
 wxTextCtrl *txt_servidor;
 wxTextCtrl *txt_porta;
 wxTextCtrl *txt_de;
 wxTextCtrl *txt_para;
 wxTextCtrl *txt_assunto;
 wxTextCtrl *txt_mensagem;
 wxTextCtrl *txt_proto;

 wxButton *btn_enviar;
};

// Tabela de eventos
BEGIN_EVENT_TABLE(MailFrame, wxFrame)
 EVT_BUTTON(ID_ENVIAR, MailFrame::EnviarMensagem)
END_EVENT_TABLE()

// Método: MailApp::OnInit()
// Inicialização do programa
bool MailApp::OnInit()
{
 MailFrame *frame = new MailFrame();
 frame->Show();
 return true;
}

// Método: MailFrame::MailFrame
// Construtor do frame
MailFrame::MailFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Enviar e-mail - http://jpjust.blogspot.com"))
{
//wxMessageBox(wxNow());

 // Sizers
 wxGridSizer *sizer_g = new wxGridSizer(5, 2, 0, 0);
 wxBoxSizer *sizer_v = new wxBoxSizer(wxVERTICAL);
 
 // Texto indicativo
 lb_servidor = new wxStaticText(this, wxID_ANY, wxT("Servidor SMTP:"));
 lb_porta = new wxStaticText(this, wxID_ANY, wxT("Porta:"));
 lb_de  = new wxStaticText(this, wxID_ANY, wxT("De:"));
 lb_para  = new wxStaticText(this, wxID_ANY, wxT("Para:"));
 lb_assunto = new wxStaticText(this, wxID_ANY, wxT("Assunto:"));
 
 // Caixas de texto
 txt_servidor = new wxTextCtrl(this, wxID_ANY, wxT("gmail-smtp-in.l.google.com"), wxDefaultPosition, wxSize(200, -1));
 txt_porta = new wxTextCtrl(this, wxID_ANY, wxT("25"));
 txt_de  = new wxTextCtrl(this, wxID_ANY, wxT("seu@email.com"), wxDefaultPosition, wxSize(200, -1));
 txt_para = new wxTextCtrl(this, wxID_ANY, wxT("just1982@gmail.com"), wxDefaultPosition, wxSize(200, -1));
 txt_assunto = new wxTextCtrl(this, wxID_ANY, wxT("Post 14"), wxDefaultPosition, wxSize(200, -1));
 txt_mensagem = new wxTextCtrl(this, wxID_ANY, wxT("Eu li o post 14!"), wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE | wxTE_WORDWRAP);
 txt_proto = new wxTextCtrl(this, wxID_ANY, wxEmptyString, wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE | wxTE_WORDWRAP | wxTE_READONLY);
 
 // Botão de enviar
 btn_enviar = new wxButton(this, ID_ENVIAR, wxT("Enviar"));
 
 // Adiciona itens nos sizers
 sizer_g->Add(lb_servidor, 0, wxALL, 5);
 sizer_g->Add(txt_servidor, 0, wxALL, 5);
 sizer_g->Add(lb_porta, 0, wxALL, 5);
 sizer_g->Add(txt_porta, 0, wxALL, 5);
 sizer_g->Add(lb_de, 0, wxALL, 5);
 sizer_g->Add(txt_de, 0, wxALL, 5);
 sizer_g->Add(lb_para, 0, wxALL, 5);
 sizer_g->Add(txt_para, 0, wxALL, 5);
 sizer_g->Add(lb_assunto, 0, wxALL, 5);
 sizer_g->Add(txt_assunto, 0, wxALL, 5);
 
 sizer_v->Add(sizer_g, 0, wxALL, 0);
 sizer_v->Add(txt_mensagem, 2, wxALL | wxEXPAND, 5);
 sizer_v->Add(txt_proto, 1, wxALL | wxEXPAND, 5);
 sizer_v->Add(btn_enviar, 0, wxALL | wxALIGN_RIGHT, 5);

 SetSizerAndFit(sizer_v);
}

/////////////////////////////////////////////////
// A partir daqui, a interface gráfica já está criada e
// veremos os métodos que realmente importam neste exemplo.

// Método: Envia
// Envia 'msg' para o socket e efetua a leitura logo em seguida, retornando o resultado
wxString MailFrame::Envia(wxSocketBase *socket, wxString msg)
{
 // Se estiver desconectado, sai do método e retorna uma string vazia
 if (socket->IsDisconnected())
  return wxEmptyString;

 wxString res;

 // Envia 'msg' pelo socket
 socket->Write((char *)msg.mb_str(), msg.Len());

 // Em caso de erro, retorna uma mensagem avisando e fecha a conexão
 if (socket->Error())
 {
  return wxT(">> Ocorreu um erro ao se comunicar com o servidor!\n");
  socket->Close();
 }
 
 // Recebe a resposta enviada pelo outro host e a retorna
 return msg + Le(socket);
}

// Método: Le
// Lê o conteúdo do socket (ou seja, qualquer mensagem enviada pelo outro host)
wxString MailFrame::Le(wxSocketBase *socket)
{
 wxString res;
 char buf[BUFFER]; // Buffer para recebimento

 do
 {
  memset(buf, 0, BUFFER);
  socket->Read(buf, BUFFER - 1); // Faz a leitura e armazena no buffer
  res.Append(buf);
 // Enquanto 'res' estiver vazio (nenhuma leitura foi feita ainda) ou
 // enquanto houver dados para serem lidos, continuaremos percorrendo o laço
 } while ((socket->LastCount() > 0) || (res.Len() == 0));
 
 return res;
}

// Método: MailFrame::Envia
// Envia o e-mail
// Este método vai fazer a conexão, enviar os dados e fechar a conexão
void MailFrame::EnviarMensagem(wxCommandEvent &event)
{
 wxIPV4address host;
 wxSocketClient sock;
 wxString msg, saida;

 // Obtém a hora no formato requerido pela RFC822
 // O formato é "Dia, data mês ano hora fuso"
 // Ex.: Thu, 15 Mar 2007 20:19:00 BRT
 char hora[50] = {0};
 time_t now = time(NULL);
 strftime(hora, 50, "%a, %d %b %Y %T %Z", localtime(&now));

 // Configura o objeto 'host'
 // Aqui definimos o endereço do servidor e a porta
 host.Hostname(txt_servidor->GetValue());
 host.Service(txt_porta->GetValue());

 // Configuração do socket
 // O timeout padrão para operações de E/S será de 120 segundos
 // A flag 'wxSOCKET_NOWAIT' indica que operações de E/S irão retornar imediatamente
 // (com esta flag, o programa não irá ficar parado em um Read() ou Write() do socket)
 sock.SetTimeout(120);
 sock.SetFlags(wxSOCKET_NOWAIT);
 txt_proto->AppendText(wxT(">> Tentando se conectar...\n"));
 if (sock.Connect(host) == false)
 {
  // Erro na conexão
  txt_proto->AppendText(wxT(">> Ocorreu um erro ao tentar conectar no servidor!\n"));
  return;
 }
 txt_proto->AppendText(wxT(">> Conectado!\n"));
 txt_proto->AppendText(Le(&sock)); // Lê a mensagem de boas-vindas do servidor

 // Neste bloco, enviamos uma identificação (EHLO), o remetente (MAIL From),
 // o destinatário (RCPT To) e indicamos o início da mensagem (DATA)
 txt_proto->AppendText(Envia(&sock, wxT("EHLO ") + wxGetFullHostName() + wxT("\r\n")));
 txt_proto->AppendText(Envia(&sock, wxT("MAIL From: <") + txt_de->GetValue() + wxT(">\r\n")));
 txt_proto->AppendText(Envia(&sock, wxT("RCPT To: <") + txt_para->GetValue() + wxT(">\r\n")));
 txt_proto->AppendText(Envia(&sock, wxT("DATA\r\n")));

 // Agora, o e-mail será montado. O corpo do e-mail tem o seguinte formato:
 //
 //  From: "Nome do remetente" <email_do_remetente>
 //  To: "Nome do destinatário" <email_do_destinatário>
 //  Date: Data de envio (obedecendo a RFC822)
 //  Subject: Assunto do e-mail
 //
 //  Mensagem, linha 1...
 //  Mensagem, linha 2...
 //
 //  . (deve conter um ponto na última linha para indicar o fim da mensagem)
 msg.Clear();
 msg.Append(wxT("From: <") + txt_de->GetValue() + wxT(">\r\n"));
 msg.Append(wxT("To: <") + txt_para->GetValue() + wxT(">\r\n"));
 msg.Append(wxT("Date: ") + wxString(hora) + wxT("\r\n"));
 msg.Append(wxT("Subject: ") + txt_assunto->GetValue() + wxT("\r\n\r\n"));
 msg.Append(txt_mensagem->GetValue() + wxT("\r\n\r\n"));
 msg.Append(wxT("--\r\nVisite A Casa de Just: http://jpjust.blogspot.com\r\n"));
 msg.Append(wxT("\r\n.\r\n"));

 // O corpo do e-mail é enviado pelo socket e a resposta do servidor é
 // inserida na caixa de texto
 txt_proto->AppendText(Envia(&sock, msg));

 // Por último, fechamos a conexão com o comando QUIT
 txt_proto->AppendText(Envia(&sock, wxT("QUIT\r\n")));

 // Aguarda que a conexão seja fechada pelo servidor
 if (sock.WaitForLost(120) == false)
 {
  txt_proto->AppendText(wxT(">> Erro ao enviar mensagem!\n"));
 }
 else
 {
  txt_proto->AppendText(wxT(">> Mensagem enviada!\n"));
 }

 // Pronto! O e-mail está enviado! :)
}

IMPLEMENT_APP(MailApp)

Notícias do Blog

2007-03-08T09:11:00.000-03:00

Olá, pessoal!

O curso de wxWidgets irá voltar ao andamento normal na próxima semana, pois nestes últimos dias, estive (e ainda estou) fora para resolver pendências. Na volta do curso, postarei sobre comunicação em rede com sockets.

Estive também estudando sobre como usar banco de dados com wxWidgets e postarei sobre isso assim que estiver por dentro do assunto.

E falando em banco de dados, um leitor do blog chamado Guilherme sugeriu o uso da biblioteca SQLAPI++ para acesso a banco de dados com C++. Estive olhando os códigos de exemplo e parece ser bem melhor que as classes do wxWidgets (postarei outro dia sobre o que estou achando do acesso a banco de dados no wxWidgets). Pena que não é gratuita, custa US$ 249,00.

Se alguém conhecer alguma outra alternativa para acesso a banco de dados com C/C++, escreva um comentário. :)

Até o próximo post!

Curso de wxWidgets, post 13: Formatando texto

2007-02-07T20:26:00.000-03:00

Para finalizar o editor de textos, vamos adicionar formatação a ele. Para isto, irei usar uma função que já vimos no curso: wxGetFontFromUser().

Primeiro, vamos incluir o cabeçalho da função:

#include <wx/fontdlg.h>

Vamos também criar um novo método para a formatação. Este método irá se chamar MeuFrame::Formatar(). Vamos declarar a nova função na definição da classe:


class MeuFrame: public wxFrame
{
...
private:
...
  void Formatar(void);
}

E agora, implementemos o método:


// Formatação
void MeuFrame::Formatar(void)
{
  long inicio, fim;
  wxTextAttr attr;
  wxFont font;

  // Obtém a formatação atual (não suportado em todas as plataformas)
  txt_file->GetSelection(&inicio, &fim);
  txt_file->GetStyle(inicio, attr);
  font = attr.GetFont();

  // Altera a formatação
  font = wxGetFontFromUser(this, font);
  attr.SetFont(font);
  txt_file->SetStyle(inicio, fim, attr); // Aplica o estilo ao texto
}

Primeiro, o método tenta obter a formatação atual do texto selecionado (wxTextCtrl::GetStyle() não é suportado em todas as plataformas, testei no Linux e não funcionou). Após obter a formatação, iremos utilizá-la em wxGetFontFromUser() para inicializar os valores da janela, assim, sempre a janela de formatação for aberta, ela estará configurada com a formatação atual.

Em seguida, wxGetFontFromUser() retorna a nova formatação e podemos aplicá-la ao texto selecionado.

Agora devemos criar um botão na barra de ferramentas para este método. Vamos adicionar uma ID para este botão:


// IDs
enum
{
 ID_TBAR_NEW,
 ID_TBAR_LOAD,
 ID_TBAR_SAVE,
 ID_TBAR_FORMAT, // Este foi adicionado
 ID_TBAR_ABOUT
};

E criamos o novo botão no construtor de MeuFrame:


tbar->AddTool(ID_TBAR_FORMAT, wxString(wxT("Formatar")), \
  wxBitmap(wxT("/usr/share/pixmaps/gedit-icon.png"), wxBITMAP_TYPE_PNG));

Pronto! Está feito. :)

Próximo passo

O editor de textos pára por aqui. Estou querendo falar sobre sockets no próximo post, mas precisarei elaborar um texto maior, pois tem bastante coisa pra explicar. Se alguém quiser aprender algo específico do wxWidgets, postem nos comentários. Assim vocês me ajudam a escolher o próximo assunto. :)

Como sempre faço, o código-fonte completo está abaixo:

/* A Casa de Just - http://jpjust.blogspot.com
 * Curso de wxWidgets: Um editor de textos
 *
 * O objetivo deste código-fonte é demonstrar diversas classes
 * ensinadas no curso de wxWidgets do blog "A Casa de Just".
 *
 * As aulas do curso de wxWidgets podem ser encontradas em forma
 * de posts no blog: http://jpjust.blogspot.com
 *
 * Copyright (c) João Paulo Just <jpjust@justsoft.com.br>
 * A Casa de Just - http://jpjust.blogspot.com
 * 07 de fevereiro de 2007, 20:24, Ilhéus, BA, Brasil.
 */

#include <wx/wx.h>
#include <wx/fontdlg.h>

// IDs
enum
{
 ID_TBAR_NEW,
 ID_TBAR_LOAD,
 ID_TBAR_SAVE,
 ID_TBAR_FORMAT,
 ID_TBAR_ABOUT
};

// Classe do programa
class MeuPrograma: public wxApp
{
public:
 // Método principal
 virtual bool OnInit(void);
};

// Classe do frame
class MeuFrame: public wxFrame
{
public:
 // Construtor
 MeuFrame(void);
 
 // Eventos
 void OnToolBarClick(wxCommandEvent &event);

 // Métodos auxiliares
 void Novo(void);
 void Abrir(void);
 void Salvar(void);
 void Formatar(void);
 void Sobre(void);
 
 DECLARE_EVENT_TABLE()

private:
 // Widgets do frame
 wxTextCtrl *txt_file;
 wxToolBar *tbar;
 wxStatusBar *stbar;
};

// Inicialização do programa
bool MeuPrograma::OnInit(void)
{
 wxInitAllImageHandlers(); // Inicia todos os hadlers de imagens do wxBitmap

 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

// Tabela de eventos
BEGIN_EVENT_TABLE(MeuFrame, wxFrame)
 EVT_TOOL_RANGE(ID_TBAR_NEW, ID_TBAR_ABOUT, MeuFrame::OnToolBarClick)
END_EVENT_TABLE()

// Construtor do frame
MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Editor de textos - http://jpjust.blogspot.com"))
{
 // Sizer e widgets
 wxBoxSizer *sizer_v = new wxBoxSizer(wxVERTICAL);
 
 txt_file = new wxTextCtrl(this, wxID_ANY, wxEmptyString,
  wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE);

 // Barra de ferramentas
 tbar = new wxToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTB_TEXT);

 tbar->AddTool(ID_TBAR_NEW, wxString(wxT("Novo")), \
  wxBitmap(wxT("/usr/share/pixmaps/gedit-icon.png"), wxBITMAP_TYPE_PNG));
 
 tbar->AddTool(ID_TBAR_LOAD, wxString(wxT("Abrir")), \
  wxBitmap(wxT("/usr/share/pixmaps/gnome-folder.png"), wxBITMAP_TYPE_PNG));
  
 tbar->AddTool(ID_TBAR_SAVE, wxString(wxT("Salvar")), \
  wxBitmap(wxT("/usr/share/pixmaps/gnome-cd.png"), wxBITMAP_TYPE_PNG));
  
 tbar->AddSeparator();

 tbar->AddTool(ID_TBAR_FORMAT, wxString(wxT("Formatar")), \
  wxBitmap(wxT("/usr/share/pixmaps/gedit-icon.png"), wxBITMAP_TYPE_PNG));
 
 tbar->AddSeparator();

 tbar->AddTool(ID_TBAR_ABOUT, wxString(wxT("Sobre")), \
  wxBitmap(wxT("/usr/share/pixmaps/gnome-info.png"), wxBITMAP_TYPE_PNG));
 
 tbar->Realize();

 // Barra de status
 stbar = new wxStatusBar(this);
 stbar->SetStatusText(wxT("Sem título"));
 
 // Posicionamento
 sizer_v->Add(txt_file, 1, wxALL | wxEXPAND, 5);
 
 SetSizerAndFit(sizer_v);
 
 // Insere a barra de ferramentas e a barra de status
 SetToolBar(tbar);
 SetStatusBar(stbar);
}

// Limpa a tela para um novo arquivo
void MeuFrame::Novo(void)
{
 int msg = wxMessageBox(wxT("Deseja salvar o arquivo atual antes de criar um novo?"), \
  wxT("Novo arquivo"), wxYES_NO | wxCANCEL);

 if (msg == wxYES)  // Salva
  Salvar();
 else if (msg == wxCANCEL) // Cancela a operação
  return;

 // Cria um novo arquivo
 txt_file->Clear();
 stbar->SetStatusText(wxT("Sem título"));
}

// Abre um arquivo
void MeuFrame::Abrir(void)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxOPEN | wxFILE_MUST_EXIST);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 txt_file->LoadFile(Filename);
 
 // Atualiza o nome
 stbar->SetStatusText(Filename);
}

// Salva o arquivo aberto
void MeuFrame::Salvar(void)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxSAVE | wxOVERWRITE_PROMPT);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 txt_file->SaveFile(Filename);
 
 // Atualiza o nome do arquivo
 stbar->SetStatusText(Filename);
}

// Formatação
void MeuFrame::Formatar(void)
{
 long inicio, fim;
 wxTextAttr attr;
 wxFont font;

 // Obtém a formatação atual (não suportado em todas as plataformas)
 txt_file->GetSelection(&inicio, &fim);
 txt_file->GetStyle(inicio, attr);
 font = attr.GetFont();

 // Altera a formatação
 font = wxGetFontFromUser(this, font);
 attr.SetFont(font);
 txt_file->SetStyle(inicio, fim, attr); // Aplica o estilo ao texto
}

// Janela "Sobre"
void MeuFrame::Sobre(void)
{
 wxMessageBox(wxT("Curso de wxWidgets\n\nhttp://jpjust.blogspot.com"), wxT("Sobre"), wxICON_INFORMATION);
}

// Método para a barra de ferramentas
void MeuFrame::OnToolBarClick(wxCommandEvent &event)
{
 switch (event.GetId())
 {
 case ID_TBAR_NEW:
  Novo();
  break;

 case ID_TBAR_LOAD:
  Abrir();
  break;
  
 case ID_TBAR_SAVE:
  Salvar();
  break;
  
 case ID_TBAR_FORMAT:
  Format();
  break;
 }
}

IMPLEMENT_APP(MeuPrograma)

Curso de wxWidgets, post 12: Adicionando uma barra de status

2007-01-29T10:15:00.000-03:00

O post de hoje vai ser bem simples e rápido, iremos apenas adicionar uma barra de status ao nosso editor de textos. Essa barra de status irá informar o nome do arquivo que estamos editando.

Para a barra de status, vamos usar a classe wxStatusBar. O construtor é bem simples:

wxStatusBar(wxWindow* parent, wxWindowID id = wxID_ANY, long style = wxST_SIZEGRIP,
  const wxString& name = "statusBar")

parent: A janela que vai conter a barra de status.

id: ID da barra, para os eventos.

style: Estilo da barra. Existe apenas o estilo wxST_SIZEGRIP, que exibe um "puxador" no canto
direito da barra no Windows.

name: Nome da barra.

Nenhum dos parâmetros são obrigatórios, existe o construtor sem parâmetros também. Mas recomenda-se usar this como primeiro parâmetro, para associar a barra com a janela que a está contendo. E é assim que nós iremos fazer no nosso editor de textos. Na definição da classe MeuFrame, temos que adicionar a barra como um atributo em private:

private:
  wxStatusBar *stbar;

No construtor de MeuFrame, iremos instanciar o objeto e definir um texto inicial para a barra de status:

// Barra de status
stbar = new wxStatusBar(this);
stbar->SetStatusText(wxT("Sem título"));

O método wxStatusBar::SetStatusText() recebe dois parâmetros: o primeiro, é o texto que você irá colocar na barra, o segundo e opcional, é o número do campo da barra que irá receber o texto.

No nosso exemplo, estamos usando apenas um campo de texto, mas podem existem barras com vários. Você pode ajustar o número de campos da sua barra com o método wxStatusBar::SetFieldsCount(). Por exemplo, se quiser três campos na sua barra, use o método da seguinte forma:

stbar->SetFieldsCount(3);

E para alterar o texto do segundo campo, use:

stbar->SetStatusText(wxT("Campo 2"), 1);
// O primeiro campo é o zero

Como temos apenas um campo em nossa barra, não precisamos especificar o número dele.

Em seguida, devemos "colar" esta barra de status na janela. Fazemos isso com o método wxFrame::SetStatusBar(), ainda no construtor:

SetStatusBar(stbar);

Pronto, a barra já está criada e dentro da nossa janela. Vamos agora atualizar os métodos MeuFrame::Abrir() e MeuFrame::Salvar(), que deverão modificar o texto da barra de status.

No código do nosso editor de textos, procure as linhas:

lb_filename->SetLabel(Filename);

Essas linhas modificam o nome do arquivo no nosso wxStaticText. Iremos remover essas linhas e no lugar delas, colocar:

stbar->SetStatusText(Filename);

Agora o editor de textos já está com a barra pronta. Já que não vamos mais usar o lb_filename, podemos removê-lo do construtor e da definição de MeuFrame.

Compile o novo código e veja a barra em funcionamento:

Código-fonte atualizado

O código completo e atualizado está abaixo. No novo código, eu removi o lb_filename, como mostrado neste post. Também removi btn_load e btn_save, já que agora temos a barra de ferramentas. Além disso, criei o método MeuFrame::Novo(), para criar um novo arquivo e seu respectivo botão na barra de ferramentas. Também removi a mensagem de boas-vindas. Olhe o código inteiro para ver as modificações e entendê-las.

/* A Casa de Just - http://jpjust.blogspot.com
 * Curso de wxWidgets: Um editor de textos
 *
 * O objetivo deste código-fonte é demonstrar diversas classes
 * ensinadas no curso de wxWidgets do blog "A Casa de Just".
 *
 * As aulas do curso de wxWidgets podem ser encontradas em forma
 * de posts no blog: http://jpjust.blogspot.com
 *
 * Copyright (c) João Paulo Just <jpjust@justsoft.com.br>
 * A Casa de Just - http://jpjust.blogspot.com
 * 29 de janeiro de 2007, 9:48, Ilhéus, BA, Brasil.
 */

#include <wx/wx.h>
#include <wx/textfile.h>

// IDs
enum
{
 ID_TBAR_NEW,
 ID_TBAR_LOAD,
 ID_TBAR_SAVE,
 ID_TBAR_ABOUT
};

// Classe do programa
class MeuPrograma: public wxApp
{
public:
 // Método principal
 virtual bool OnInit(void);
};

// Classe do frame
class MeuFrame: public wxFrame
{
public:
 // Construtor
 MeuFrame(void);
 
 // Eventos
 void OnToolBarClick(wxCommandEvent &event);

 // Métodos auxiliares
 void Novo(void);
 void Abrir(void);
 void Salvar(void);
 void Sobre(void);
 
 DECLARE_EVENT_TABLE()

private:
 // Widgets do frame
 wxTextCtrl *txt_file;
 wxToolBar *tbar;
 wxStatusBar *stbar;
};

// Inicialização do programa
bool MeuPrograma::OnInit(void)
{
 wxInitAllImageHandlers(); // Inicia todos os hadlers de imagens do wxBitmap

 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

// Tabela de eventos
BEGIN_EVENT_TABLE(MeuFrame, wxFrame)
 EVT_TOOL_RANGE(ID_TBAR_NEW, ID_TBAR_ABOUT, MeuFrame::OnToolBarClick)
END_EVENT_TABLE()

// Construtor do frame
MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Editor de textos - http://jpjust.blogspot.com"))
{
 // Sizer e widgets
 wxBoxSizer *sizer_v = new wxBoxSizer(wxVERTICAL);
 
 txt_file = new wxTextCtrl(this, wxID_ANY, wxEmptyString,
  wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE);
 
 // Barra de ferramentas
 tbar = new wxToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTB_TEXT);

 tbar->AddTool(ID_TBAR_NEW, wxString(wxT("Novo")), \
  wxBitmap(wxT("/usr/share/pixmaps/gedit-icon.png"), wxBITMAP_TYPE_PNG));
 
 tbar->AddTool(ID_TBAR_LOAD, wxString(wxT("Abrir")), \
  wxBitmap(wxT("/usr/share/pixmaps/gnome-folder.png"), wxBITMAP_TYPE_PNG));
  
 tbar->AddTool(ID_TBAR_SAVE, wxString(wxT("Salvar")), \
  wxBitmap(wxT("/usr/share/pixmaps/gnome-cd.png"), wxBITMAP_TYPE_PNG));
  
 tbar->AddSeparator();
 
 tbar->AddTool(ID_TBAR_ABOUT, wxString(wxT("Sobre")), \
  wxBitmap(wxT("/usr/share/pixmaps/gnome-info.png"), wxBITMAP_TYPE_PNG));
 
 tbar->Realize();

 // Barra de status
 stbar = new wxStatusBar(this);
 stbar->SetStatusText(wxT("Sem título"));
 
 // Posicionamento
 sizer_v->Add(txt_file, 1, wxALL | wxEXPAND, 5);
 
 SetSizerAndFit(sizer_v);
 
 // Insere a barra de ferramentas e a barra de status
 SetToolBar(tbar);
 SetStatusBar(stbar);
}

// Limpa a tela para um novo arquivo
void MeuFrame::Novo(void)
{
 int msg = wxMessageBox(wxT("Deseja salvar o arquivo atual antes de criar um novo?"), \
  wxT("Novo arquivo"), wxYES_NO | wxCANCEL);

 if (msg == wxYES)  // Salva
  Salvar();
 else if (msg == wxCANCEL) // Cancela a operação
  return;

 // Cria um novo arquivo
 txt_file->Clear();
 stbar->SetStatusText(wxT("Sem título"));
}

// Abre um arquivo
void MeuFrame::Abrir(void)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxOPEN | wxFILE_MUST_EXIST);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 txt_file->LoadFile(Filename);
 
 // Atualiza o nome
 stbar->SetStatusText(Filename);
}

// Salva o arquivo aberto
void MeuFrame::Salvar(void)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxSAVE | wxOVERWRITE_PROMPT);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 txt_file->SaveFile(Filename);
 
 // Atualiza o nome do arquivo
 stbar->SetStatusText(Filename);
}

// Janela "Sobre"
void MeuFrame::Sobre(void)
{
 wxMessageBox(wxT("Curso de wxWidgets\n\nhttp://jpjust.blogspot.com"), wxT("Sobre"), wxICON_INFORMATION);
}

// Método para a barra de ferramentas
void MeuFrame::OnToolBarClick(wxCommandEvent &event)
{
 switch (event.GetId())
 {
 case ID_TBAR_NEW:
  Novo();
  break;

 case ID_TBAR_LOAD:
  Abrir();
  break;
  
 case ID_TBAR_SAVE:
  Salvar();
  break;
  
 case ID_TBAR_ABOUT:
  Sobre();
  break;
 }
}

IMPLEMENT_APP(MeuPrograma)

Justsoft GNU/Linux

2007-01-16T01:46:00.000-03:00

Neste dia 15, a Justsoft disponibilizou em seu site a sua distribuição Linux baseada no Debian etch. O Justsoft GNU/Linux vem sido desenvolvido desde dezembro do ano passado, com o objetivo de fornecer uma distribuição voltada aos usuários finais, tanto domésticos como corporativos.

A idéia principal desta distribuição é seguir os requisitos de software do projeto do governo Computador para Todos, com inúmeros aplicativos já instalados, tornando possível a venda de computadores com o Justsoft GNU/Linux pré-instalado.

Além de atender os requisitos do programa do governo, o Justsoft GNU/Linux também inclui outros pacotes extras, que facilitam a vida do usuário, como por exemplo, drivers e aplicativos para impressoras, software para webcam, etc.

O Justsoft GNU/Linux consiste de uma série de meta-pacotes que instalam dependências do repositório Debian, customizando a distribuição (ao estilo Debian CDD). Os usuários podem optar por baixar o CD de instalação no site da Justsoft ou simplesmente instalar o Debian etch e em seguida, adicionar o repositório do Justsoft GNU/Linux:

deb http://apt.justsoft.com.br/justsoft paranoid main

Depois, basta instalar o pacote justsoft-cdd:

# apt-get update
# apt-get install justsoft-cdd

No site da Justsoft pode ser acessada a página da distribuição, com mais informações, download e screenshots.

Curso de wxWidgets, post 11: Construindo barras de ferramentas

2007-01-09T23:41:00.000-03:00

Agora vamos dar uma incrementada no nosso editor de textos, adicionando uma barra de ferramentas nele. A classe resposável por isto é a wxToolBar.

O procedimento básico é criar a barra, instanciando um objeto da classe e em seguida, atribuir um método ao evento de clique dos botões da barra.

Como sempre, vamos iniciar pelo construtor:

wxToolBar(wxWindow* parent, wxWindowID id, const wxPoint& pos = wxDefaultPosition,
  const wxSize& size = wxDefaultSize, long style = wxTB_HORIZONTAL | wxNO_BORDER,
  const wxString& name = wxPanelNameStr)

parent: A janela que conterá a barra.

id: ID da barra.

pos: Posição.

size: Tamanho.

style: O estilo da barra.

name: Nome da barra.

Apesar dos parâmetros pos e size, nós não precisamos especificar tamanho e a posição da barra de ferramentas. Apenas iremos criá-la normalmente e "prendê-la" no topo da janela. Para isto, vamos declarar a barra como um atributo privado da classe do nosso frame e instanciá-la no construtor.

Na definição da classe de MeuFrame:

private:
 wxToolBar  *tbar;

No construtor de MeuFrame:

tbar = new wxToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTB_TEXT);

Precisaremos também adicionar IDs para os botões da barra na lista de enum do nosso código:

enum
{
 ID_BTNLOAD,
 ID_BTNSAVE,
 ID_TBAR_LOAD,
 ID_TBAR_SAVE,
 ID_TBAR_ABOUT
};

Agora que a barra de ferramentas está criada, podemos adicionar nossos botões a ela. Fazemos isso também no construtor de MeuFrame, depois da instanciação da barra.

Para o nosso editor de textos, iremos adicionar três botões, "Abrir", "Salvar" e "Sobre", além de um separador antes do "Sobre". Isto será feito através do método wxToolBar::AddTool() e wxToolBar::AddSeparator() para o separador:

tbar->AddTool(ID_TBAR_LOAD, wxString(wxT("Abrir")), \
 wxBitmap(wxT("/usr/share/pixmaps/gnome-folder.png"), wxBITMAP_TYPE_PNG));
 
tbar->AddTool(ID_TBAR_SAVE, wxString(wxT("Salvar")), \
 wxBitmap(wxT("/usr/share/pixmaps/gnome-cd.png"), wxBITMAP_TYPE_PNG));
 
tbar->AddSeparator();

tbar->AddTool(ID_TBAR_ABOUT, wxString(wxT("Sobre")), \
 wxBitmap(wxT("/usr/share/pixmaps/gnome-info.png"), wxBITMAP_TYPE_PNG));

tbar->Realize();

Perceba que eu usei o método wxToolBar::Realize() após adicionar os botões. Isto irá atualizar a barra.

No código acima, usei algumas imagens que estão instaladas no meu computador. Você pode alterar o caminho das imagens acima para outras existentes no seu sistema. Obviamente, se você está compilando no Windows, os caminhos acima não funcionarão.

No final deste post, falarei um pouco sobre o uso da classe wxBitmap.

Por último, vamos dizer ao frame quem é sua barra de ferramentas. Para isto, usamos o método wxFrame::SetToolBar():

// Insere a barra de ferramentas
SetToolBar(tbar);

Neste ponto, a barra já irá aparecer na janela do editor.

Criando eventos para a barra de ferramentas

A parte mais simples já foi feita. Agora vamos dar vida à barra!

No nosso exemplo do editor de textos, fiz uma modificação para facilitar o código. Criei os métodos Abrir(), Salvar() e Sobre(). Os códigos de carregamento e gravação do arquivo, que antes estavam em OnLoadClick() e OnSaveClick() foram pra Abrir() e Salvar() respectivamente. Sobre() tem um código para exibir um pop-up.

Mas o método mais importante que iremos criar é o MeuFrame::OnToolBarClick(). Veja sua definição:

void OnToolBarClick(wxCommandEvent &event);

Este método tratará os eventos de clique na barra de ferramentas. Antes de mostrar sua implementação, veja a definição do evento na tabela de eventos:

EVT_TOOL_RANGE(ID_TBAR_LOAD, ID_TBAR_ABOUT, MeuFrame::OnToolBarClick)

Para os botões normais (wxButton), nós precisamos definir um evento para cada botão. No caso da barra de ferramentas, definimos o range dos IDs dos botões da barra. No nosso exemplo, associamos este eventos a todos os IDs desde ID_TBAR_LOAD até ID_TBAR_ABOUT. Isso é muito útil quando criamos uma barra com muitos botões.

Você pode ver os outros eventos disponíveis para o wxToolBar na documentação da classe.

Mas como na definição, todos os IDs irão chamar o mesmo método, como iremos dar funções diferentes para cada botão da barra? Devemos tratar isto dentro do método. Agora mostrarei sua implementação:

// Método para a barra de ferramentas
void MeuFrame::OnToolBarClick(wxCommandEvent &event)
{
 switch (event.GetId())
 {
 case ID_TBAR_LOAD:
   Abrir();
   break;

 case ID_TBAR_SAVE:
   Salvar();
   break;
 
 case ID_TBAR_ABOUT:
   Sobre();
   break;
 }
}

O switch (event.GetId()) vai criar um switch com a ID do evento. Então, podemos dar diferentes tarefas para os botões dentro do switch, como mostrado acima.

Bem, este é o básico sobre wxToolBar. Nosso editor de texto agora está assim:

Tente modificar as imagens da barra (detalhes abaixo), ou adicionar novos botões. Lembre-se de checar as IDs na definição do evento caso você adicione ou remova botões.

Alguns tópicos sobre o uso do wxBitmap na barra de ferramentas

Não falei sobre wxBitmap ainda, também não vou entrar em detalhes agora, falarei apenas o suficiente para usar imagens no wxToolBar.

A classe wxBitmap serve basicamente para tratar imagens, exibindo-as no seu programa ou em outros widgets. No caso do wxToolBar, nós usamos o wxBitmap para definir as imagens que serão exibidas em cada botão da barra.

No nosso exemplo, eu usei um construtor bastante simples:

wxBitmap(const wxString& name, long type)

Este construtor carrega uma imagem de um arquivo do tipo especificado. Como usei arquivos .PNG, usei o tipo wxBITMAP_TYPE_PNG. Existem diversos outros tipos que você pode encontrar na documentação do construtor.

Mas o wxBitmap também pode tratar tipos de uma outra classe chamada wxImage. O tipo que usei, por exemplo, não é de wxBitmap e sim de wxImage.

O tipo wxBMPHandler está diponível por padrão no programa. Para usar outros tipos (como o wxBITMAP_TYPE_PNG que eu usei), devemos "instalar" eles. Para isto, usamos o método wxInitAllImageHandlers(), que deve ser chamado no método OnInit() da classe principal do nosso programa.

Então, para colocar imagens nos botões da barra de ferramentas, devemos iniciar os handlers para todos os tipos suportados com wxInitAllImageHandlers() no método OnInit() da classe principal. Em seguida, abrir a imagem com wxBitmap e passar o objeto como parâmetro de wxToolBar::AddTool().

Futuramente irei falar melhor sobre wxBitmap e wxImage, mas por enquanto, deixarei apenas o suficiente para usarmos o wxToolBar.

Veja o código-fonte completo do editor de textos no estado atual:

/* A Casa de Just - http://jpjust.blogspot.com
* Curso de wxWidgets: Um editor de textos
*
* O objetivo deste código-fonte é demonstrar diversas classes
* ensinadas no curso de wxWidgets do blog "A Casa de Just".
*
* As aulas do curso de wxWidgets podem ser encontradas em forma
* de posts no blog: http://jpjust.blogspot.com
*
* Copyright (c) João Paulo Just 
* A Casa de Just - http://jpjust.blogspot.com
* 9 de janeiro de 2007, 22:45, Ilhéus, BA, Brasil.
*/

#include 
#include 

// IDs
enum
{
 ID_BTNLOAD,
 ID_BTNSAVE,
 ID_TBAR_LOAD,
 ID_TBAR_SAVE,
 ID_TBAR_ABOUT
};

// Classe do programa
class MeuPrograma: public wxApp
{
public:
 // Método principal
 virtual bool OnInit(void);
};

// Classe do frame
class MeuFrame: public wxFrame
{
public:
 // Construtor
 MeuFrame(void);
 
 // Eventos
 void OnLoadClick(wxCommandEvent &event);
 void OnSaveClick(wxCommandEvent &event);
 void OnToolBarClick(wxCommandEvent &event);

 // Métodos auxiliares
 void Abrir(void);
 void Salvar(void);
 void Sobre(void);
 
 DECLARE_EVENT_TABLE()

private:
 // Widgets do frame
 wxButton *btn_load;
 wxButton *btn_save;
 
 wxStaticText *lb_filename;
 
 wxTextCtrl *txt_file;
 
 wxToolBar *tbar;
};

// Inicialização do programa
bool MeuPrograma::OnInit(void)
{
 wxInitAllImageHandlers(); // Inicia todos os hadlers de imagens do wxBitmap

 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

// Tabela de eventos
BEGIN_EVENT_TABLE(MeuFrame, wxFrame)
 EVT_BUTTON(ID_BTNLOAD, MeuFrame::OnLoadClick)
 EVT_BUTTON(ID_BTNSAVE, MeuFrame::OnSaveClick)
 EVT_TOOL_RANGE(ID_TBAR_LOAD, ID_TBAR_ABOUT, MeuFrame::OnToolBarClick)
END_EVENT_TABLE()

// Construtor do frame
MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Arquivos"))
{
 // Sizer e widgets
 wxBoxSizer *sizer_h = new wxBoxSizer(wxHORIZONTAL);
 wxBoxSizer *sizer_v = new wxBoxSizer(wxVERTICAL);
 
 btn_load = new wxButton(this, ID_BTNLOAD, wxT("Abrir"));
 btn_save = new wxButton(this, ID_BTNSAVE, wxT("Salvar"));
 
 lb_filename = new wxStaticText(this, wxID_ANY,
  wxT("Sem titulo.txt"));
 
 txt_file = new wxTextCtrl(this, wxID_ANY, wxEmptyString,
  wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE);
 
 // Barra de ferramentas
 tbar = new wxToolBar(this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxTB_TEXT);
 
 tbar->AddTool(ID_TBAR_LOAD, wxString(wxT("Abrir")), \
  wxBitmap(wxT("/usr/share/pixmaps/gnome-folder.png"), wxBITMAP_TYPE_PNG));
  
 tbar->AddTool(ID_TBAR_SAVE, wxString(wxT("Salvar")), \
  wxBitmap(wxT("/usr/share/pixmaps/gnome-cd.png"), wxBITMAP_TYPE_PNG));
  
 tbar->AddSeparator();
 
 tbar->AddTool(ID_TBAR_ABOUT, wxString(wxT("Sobre")), \
  wxBitmap(wxT("/usr/share/pixmaps/gnome-info.png"), wxBITMAP_TYPE_PNG));
 
 tbar->Realize();
 
 // Posicionamento
 sizer_h->Add(btn_load, 0, wxALL, 5);
 sizer_h->Add(btn_save, 0, wxALL, 5);
 sizer_h->Add(lb_filename, 1, wxALL, 5);
 
 sizer_v->Add(sizer_h, 0, wxALL, 0);
 sizer_v->Add(txt_file, 1, wxALL | wxEXPAND, 5);
 
 SetSizerAndFit(sizer_v);
 
 // Insere a barra de ferramentas
 SetToolBar(tbar);
 
 // Boas-vindas
 wxMessageBox(wxT("Seja bem-vindo(a) a mais um maravilhoso programa! :)"),
  wxT("Bem-vindo(a)!"), wxICON_INFORMATION);
}

// Abre um arquivo
void MeuFrame::Abrir(void)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxOPEN | wxFILE_MUST_EXIST);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 txt_file->LoadFile(Filename);
 
 // Atualiza o nome
 lb_filename->SetLabel(Filename);
}

// Salva o arquivo aberto
void MeuFrame::Salvar(void)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxSAVE | wxOVERWRITE_PROMPT);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 txt_file->SaveFile(Filename);
 
 // Atualiza o nome do arquivo
 lb_filename->SetLabel(Filename);
}

// Janela "Sobre"
void MeuFrame::Sobre(void)
{
 wxMessageBox(wxT("Curso de wxWidgets\n\nhttp://jpjust.blogspot.com"), wxT("Sobre"), wxICON_INFORMATION);
}

// Botão de leitura
void MeuFrame::OnLoadClick(wxCommandEvent &event)
{
 Abrir();
}

// Botão de salvamento
void MeuFrame::OnSaveClick(wxCommandEvent &event)
{
 Salvar();
}

// Método para a barra de ferramentas
void MeuFrame::OnToolBarClick(wxCommandEvent &event)
{
 switch (event.GetId())
 {
 case ID_TBAR_LOAD:
  Abrir();
  break;
  
 case ID_TBAR_SAVE:
  Salvar();
  break;
  
 case ID_TBAR_ABOUT:
  Sobre();
  break;
 }
}

IMPLEMENT_APP(MeuPrograma)

Feliz 2007, o blog está de volta!

2007-01-07T20:04:00.000-03:00

Olá meus caros leitores!! FELIZ 2007 (atrasado) A TODOS!!! :)

Como eu mencionei no post anterior, dei uma pausa no curso de wxWidgets devido à quantidade de provas e atividades no curso de Ciência da Computação. Aproveitei e viajei no Natal e Reveillon pra descansar um pouco e agora estou de volta. A partir de terça, o curso de wxWidgets voltará e o blog entrará em ação novamente.

Obrigado a todos que visitaram a minha casa em 2006 e aos que continuaram fazendo-o mesmo durante o período de recesso.

Um abraço e até terça! :)

Curso de wxWidgets: Uma pausa

2006-12-13T20:05:00.000-03:00

Olá, pessoal.

Como perceberam, já tem um tempo que não posto nada sobre o curso de wxWidgets. Bem, vou dar uma pausa nele por enquanto, pois estou terminando trabalhos e provas de final de semestre na Universidade e estou meio sem tempo. O curso voltará na segunda semana de Janeiro, sem falta. :)

Hotmail no Mozilla Thunderbird

2006-11-23T20:47:00.000-03:00

Se você usa o Mozilla Thunderbird e tem conta no Hotmail, provavelmente já teve vontade de baixar suas mensagens pelo software cliente.

Existem vários programas que intermediam a conexão entre o cliente e o Hotmail. Já usei alguns, mas não me agradaram muito. Enfim, encontrei hoje uma extensão para o Thunderbird.

O nome da extensão é WebMail. Basta você instalar a extensão mais o módulo do Hotmail. Essa extensão possui também módulos para outros serviços de webmails.

O primeiro passo é baixar a extensão do WebMail na página de download. Em seguida, baixe o módulo do Hotmail na mesma página. Após instalar as extensões, reinicie o Thunderbird.

O passo seguinte, é configurar a extensão. Clique em Ferramentas -> Extensões. Selecione a extensão do WebMail e clique em Preferências.

Na janela de preferências, certifique-se de que POP e SMTP estão OK (bola verde e texto Running). Caso não estejam rodando, pode ser que você não esteja com permissões para usar portas baixas. Neste caso, clique na aba Ports e escolha portas acima de 1024 para POP e SMTP. Se você precisar modificar as portas, reinicie o Thunderbird novamente.

Por último, adicione sua conta do Hotmail. Basta adicionar a conta normalmente, como você faria com qualquer outra conta POP3. Só que no momento de especificar o servidor POP de entrada, use localhost. Termine o resto do assistente de nova conta normalmente.

Se você mudou as portas POP e SMTP na extensão, você terá que fazer o mesmo na configuração da sua conta. Clique em Editar -> Configuração de contas. Procure sua conta do Hotmail e clique na seção Configurações do servidor. Configure a porta para o mesmo número que você escolheu na configuração da extensão. Em seguida, vá para Servidor de saída (SMTP), lá no final, e adicione o servidor SMTP localhost com a porta SMTP que você escolheu nas configurações da extensão.

Pronto! Seu Thunderbird está pronto para baixar e-mails do Hotmail. :)

Curso de wxWidgets, post 10: Mais sobre arquivos com wxTextFile

2006-11-20T20:07:00.000-03:00

Agora será apresentada a classe wxTextFile. Essa classe permite manipular arquivos de texto e possui alguns métodos bastante úteis. Como eu havia comentado no post 8, eu senti falta de alguns métodos interessantes em wxFile, como por exemplo, ler uma linha inteira de um arquivo. Só depois que eu descobri a wxTextFile :P

A abertura de um arquivo para leitura se dá com o método wxTextFile::Open():

wxTextFile File;
File.Open("arquivo.txt");

Caso o arquivo não possa ser aberto ou não exista, wxTextFile::Open() retornará falso.

Agora, basta caminharmos pelas linhas e ler o conteúdo do arquivo. Podemos saber o número de linhas em um arquivo com wxTextFile::GetLineCount() (retornando o número de linhas) e ler cada linha com wxTextFile::GetLine() (retornando um objeto wxString com o conteúdo da linha lida). Veja um exemplo de leitura linha a linha:

for (unsigned int line = 0; line < File.GetLineCount(); line++)
  txt_file->AppendText(File.GetLine(line) + wxT("\n"));

O laço acima percorre cada linha do arquivo e adiciona em um objeto do tipo wxTextCtrl.

Após ter lido todo o arquivo, podemos fechá-lo com wxTextFile::Close():

File.Close();

Já no caso de gravações, temos que criar o arquivo com wxTextFile::Create():

wxTextFile File;
File.Create("arquivo.txt");

Caso o arquivo não possa ser criado, wxTextFile::Create() retornará falso.

Agora, basta chamar wxTextFile::AddLine() para adicionar linhas no arquivo:

File.AddLine(wxT("Linha 1"));
File.AddLine(wxT("Linha 2"));
File.AddLine(wxT("Linha 3"));

Por último, devemos gravar as alterações no disco e fechar o arquivo:

File.Write();
File.Close();

Existem também outros métodos interessantes:

wxTextFile::GoToLine(size_t n) leva você até a linha n.

wxTextFile::GetFirstLine(), GetNextLine(), GetPrevLine(), GetLastLine() retornam a primeira linha, a próxima, a anterior e a última respectivamente.

Você também pode inserir uma linha em um local específico com wxTextFile::InsertLine() e pode remover qualquer linha com wxTextFile::RemoveLine().

O exemplo de editor de textos

Modifiquei o programa do post 9 para usar wxTextFile no lugar de wxFile. Vejam o programa alterado abaixo:

/* A Casa de Just - http://jpjust.blogspot.com
 * Curso de wxWidgets: Exemplo de um editor de textos usando wxTextFile
 *
 * O objetivo deste código é demonstrar o uso da classe wxTextFile
 * para efetuar leitura e escrita em um arquivo de texto, além
 * de mostrar o uso básico das classes wxApp, wxFrame, wxStaticText,
 * wxButton, wxTextCtrl e wxBoxSizer, assim como o tratamento de
 * eventos e as funções wxFileSelector() e wxMessageBox()
 * (tópicos abordados do post 2 ao post 8 do curso).
 *
 * wxTextCtrl possui dois métodos para carregar e salvar um arquivo
 * (wxTextCtrl::LoadFile() e wxTextCtrl::SaveFile()), porém, wxTextFile
 * é utilizado para demonstrar seu uso. No trecho onde a leitura e
 * escrita são feitas, existem comentários explicando como utilizar
 * estes métodos.
 *
 * Copyright (c) João Paulo Just <jpjust@justsoft.com.br>
 * A Casa de Just - http://jpjust.blogspot.com
 * 20 de novembro de 2006, 20:25, Ilhéus, BA, Brasil.
 */

#include <wx/wx.h>
#include <wx/textfile.h>

// IDs
enum
{
 ID_BTNLOAD,
 ID_BTNSAVE
};

// Classe do programa
class MeuPrograma: public wxApp
{
public:
 // Método principal
 virtual bool OnInit(void);
};

// Classe do frame
class MeuFrame: public wxFrame
{
public:
 // Construtor
 MeuFrame(void);
 
 // Eventos
 void OnLoadClick(wxCommandEvent &event);
 void OnSaveClick(wxCommandEvent &event);
 
 DECLARE_EVENT_TABLE()

private:
 // Widgets do frame
 wxButton *btn_load;
 wxButton *btn_save;
 
 wxStaticText *lb_filename;
 
 wxTextCtrl *txt_file;
};

// Inicialização do programa
bool MeuPrograma::OnInit(void)
{
 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

// Tabela de eventos
BEGIN_EVENT_TABLE(MeuFrame, wxFrame)
 EVT_BUTTON(ID_BTNLOAD, MeuFrame::OnLoadClick)
 EVT_BUTTON(ID_BTNSAVE, MeuFrame::OnSaveClick)
END_EVENT_TABLE()

// Construtor do frame
MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Arquivos"))
{
 // Sizer e widgets
 wxBoxSizer *sizer_h = new wxBoxSizer(wxHORIZONTAL);
 wxBoxSizer *sizer_v = new wxBoxSizer(wxVERTICAL);
 
 btn_load = new wxButton(this, ID_BTNLOAD, wxT("Abrir"));
 btn_save = new wxButton(this, ID_BTNSAVE, wxT("Salvar"));
 
 lb_filename = new wxStaticText(this, wxID_ANY,
  wxT("Sem titulo.txt"));
 
 txt_file = new wxTextCtrl(this, wxID_ANY, wxEmptyString,
  wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE);
 
 // Posicionamento
 sizer_h->Add(btn_load, 0, wxALL, 5);
 sizer_h->Add(btn_save, 0, wxALL, 5);
 sizer_h->Add(lb_filename, 1, wxALL, 5);
 
 sizer_v->Add(sizer_h, 0, wxALL, 0);
 sizer_v->Add(txt_file, 1, wxALL | wxEXPAND, 5);
 
 SetSizerAndFit(sizer_v);
 
 // Boas-vindas
 wxMessageBox(wxT("Seja bem-vindo(a) a mais um maravilhoso programa! :)"),
  wxT("Bem-vindo(a)!"), wxICON_INFORMATION);
}

// Botão de leitura
void MeuFrame::OnLoadClick(wxCommandEvent &event)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxOPEN | wxFILE_MUST_EXIST);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 // Tenta abrir o arquivo com wxTextFile
 wxTextFile File;
 if (File.Open(Filename) == false)
  return;
 
 // Lê o conteúdo do arquivo linha a linha
 for (unsigned int line = 0; line < File.GetLineCount(); line++)
  txt_file->AppendText(File.GetLine(line) + wxT("\n"));
 
 // Não é preciso todo este código para ler um arquivo
 // e exibí-lo em um wxTextCtrl. O trecho acima foi
 // escrito apenas para que você entenda a classe wxTextFile.
 // wxTextCtrl possui um método próprio para ler o
 // conteúdo de um arquivo. Tente comentar o trecho acima
 // e usar o método abaixo para fazer a leitura:
 
 //txt_file->LoadFile(Filename);
 
 // Fecha o arquivo
 File.Close();
 
 // Atualiza o nome
 lb_filename->SetLabel(Filename);
}

// Botão de salvamento
void MeuFrame::OnSaveClick(wxCommandEvent &event)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxSAVE | wxOVERWRITE_PROMPT);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 // Tenta criar o arquivo com wxTextFile
 wxTextFile File;
 if (File.Create(Filename) == false)
  return;
 
 // Limpa o arquivo, caso exista conteúdo nele
 File.Clear();
 
 // Percorre a caixa de texto gravando o conteúdo
 // no arquivo aberto, linha a linha
 for (unsigned int line = 0; line < txt_file->GetNumberOfLines(); line++)
  File.AddLine(txt_file->GetLineText(line));
 
 // Neste ponto, eu também poderia usar um método
 // de wxTextCtrl para salvar o arquivo. Tente
 // comentar o trecho de gravação acima e descomente
 // a linha abaixo para testar:
 
 //txt_file->SaveFile(Filename);
 
 // Salva o arquivo em disco e fecha
 File.Write();
 File.Close();
 
 // Atualiza o nome do arquivo
 lb_filename->SetLabel(Filename);
}

IMPLEMENT_APP(MeuPrograma)

Curso de wxWidgets, post 9: Um exemplo de um editor de textos

2006-11-11T23:19:00.000-03:00

Resolvi fazer um exemplo de um editor de textos, usando a maioria das classes estudadas até agora. Além de mostrá-las em ação, vou pagar a semana que fiquei sem postar no mês passado :P. O código completo do exemplo está abaixo. Compile e veja o programa funcionando. Não deixe de ler os comentários, existem algumas informações importantes neles.

/* A Casa de Just - http://jpjust.blogspot.com
* Curso de wxWidgets: Exemplo de um editor de textos usando wxFile
*
* O objetivo deste código é demonstrar o uso da classe wxFile
* para efetuar leitura e escrita em um arquivo de texto, além
* de mostrar o uso básico das classes wxApp, wxFrame, wxStaticText,
* wxButton, wxTextCtrl e wxBoxSizer, assim como o tratamento de
* eventos e as funções wxFileSelector() e wxMessageBox()
* (tópicos abordados do post 2 ao post 8 do curso).
*
* wxTextCtrl possui dois métodos para carregar e salvar um arquivo
* (wxTextCtrl::LoadFile() e wxTextCtrl::SaveFile()), porém, wxFile
* é utilizado para demonstrar seu uso. No trecho onde a leitura e
* escrita são feitas, existem comentários explicando como utilizar
* estes métodos.
*
* Copyright (c) João Paulo Just 
* A Casa de Just - http://jpjust.blogspot.com
* 8 de novembro de 2006, 21:03, Ilhéus, BA, Brasil.
*/

#include <wx/wx.h>
#include <wx/file.h>

#define BUF_SIZE 128 // Tamanho do buffer de leitura/escrita

// IDs
enum
{
 ID_BTNLOAD,
 ID_BTNSAVE
};

// Classe do programa
class MeuPrograma: public wxApp
{
public:
 // Método principal
 virtual bool OnInit(void);
};

// Classe do frame
class MeuFrame: public wxFrame
{
public:
 // Construtor
 MeuFrame(void);
 
 // Eventos
 void OnLoadClick(wxCommandEvent &event);
 void OnSaveClick(wxCommandEvent &event);
 
 DECLARE_EVENT_TABLE()

private:
 // Widgets do frame
 wxButton *btn_load;
 wxButton *btn_save;
 
 wxStaticText *lb_filename;
 
 wxTextCtrl *txt_file;
};

// Inicialização do programa
bool MeuPrograma::OnInit(void)
{
 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

// Tabela de eventos
BEGIN_EVENT_TABLE(MeuFrame, wxFrame)
 EVT_BUTTON(ID_BTNLOAD, MeuFrame::OnLoadClick)
 EVT_BUTTON(ID_BTNSAVE, MeuFrame::OnSaveClick)
END_EVENT_TABLE()

// Construtor do frame
MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Arquivos"))
{
 // Sizer e widgets
 wxBoxSizer *sizer_h = new wxBoxSizer(wxHORIZONTAL);
 wxBoxSizer *sizer_v = new wxBoxSizer(wxVERTICAL);
 
 btn_load = new wxButton(this, ID_BTNLOAD, wxT("Abrir"));
 btn_save = new wxButton(this, ID_BTNSAVE, wxT("Salvar"));
 
 lb_filename = new wxStaticText(this, wxID_ANY,
  wxT("Sem titulo.txt"));
 
 txt_file = new wxTextCtrl(this, wxID_ANY, wxEmptyString,
  wxDefaultPosition, wxDefaultSize, wxTE_MULTILINE);
 
 // Posicionamento
 sizer_h->Add(btn_load, 0, wxALL, 5);
 sizer_h->Add(btn_save, 0, wxALL, 5);
 sizer_h->Add(lb_filename, 1, wxALL, 5);
 
 sizer_v->Add(sizer_h, 0, wxALL, 0);
 sizer_v->Add(txt_file, 1, wxALL | wxEXPAND, 5);
 
 SetSizerAndFit(sizer_v);
 
 // Boas-vindas
 wxMessageBox(wxT("Seja bem-vindo(a) a mais um maravilhoso programa! :)"),
  wxT("Bem-vindo(a)!"), wxICON_INFORMATION);
}

// Botão de leitura
void MeuFrame::OnLoadClick(wxCommandEvent &event)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxOPEN | wxFILE_MUST_EXIST);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 // Abre o arquivo para leitura com wxFile
 wxFile File(Filename, wxFile::read);
 
 // Verifica se o arquivo foi aberto
 if (!File.IsOpened())
  return;
 
 // Lê o conteúdo do arquivo em partes
 // do tamanho de BUF_SIZE
 char buffer[BUF_SIZE] = {0};
 txt_file->Clear();
 
 while (!File.Eof())
 {
  // Lê BUF_SIZE - 1 bytes (deixa um espaço
  // para o \0 do final da string
  if (File.Read(buffer, BUF_SIZE - 1) > 0)
  {
   // Converte o conteúdo de buffer, que
   // deve estar em UTF8 (ANSI) para o formato
   // da sua compilação do wxWidgets
   wxString Buf(buffer, wxConvUTF7);
   txt_file->AppendText(Buf);
   memset(buffer, 0, BUF_SIZE);
  }
  else
  {
   wxMessageBox(wxT("Erro de leitura!"),
    wxT("Erro"), wxICON_ERROR);
   return;
  }
 }
 
 // Não é preciso todo este código para ler um arquivo
 // e exibí-lo em um wxTextCtrl. O trecho acima foi
 // escrito apenas para que você entenda a classe wxFile.
 // wxTextCtrl possui um método próprio para ler o
 // conteúdo de um arquivo. Tente comentar o trecho acima
 // e usar o método abaixo para fazer a leitura:
 
 //txt_file->LoadFile(Filename);
 
 // Fecha o arquivo
 File.Close();
 
 // Atualiza o nome
 lb_filename->SetLabel(Filename);
}

// Botão de salvamento
void MeuFrame::OnSaveClick(wxCommandEvent &event)
{
 wxString Filename;
 
 // Abre diálogo de arquivo
 Filename = wxFileSelector(wxT("Selecione o arquivo"),
  wxEmptyString, wxEmptyString, wxEmptyString,
  wxT("*.txt"), wxSAVE | wxOVERWRITE_PROMPT);
 
 // Se arquivo inválido, sai do método
 if (Filename == wxEmptyString)
  return;
 
 // Abre o arquivo para escrita com wxFile
 wxFile File(Filename, wxFile::write);
 
 // Verifica se o arquivo foi aberto
 if (!File.IsOpened())
  return;
 
 // Percorre a caixa de texto gravando o conteúdo
 // no arquivo aberto
 for (unsigned int line = 0; line <>GetNumberOfLines(); line++)
 {
  wxString Buf = txt_file->GetLineText(line);
  if (File.Write(Buf + wxT("\n"), wxConvUTF7) < 0)
  {
   wxMessageBox(wxT("Erro de gravação!"),
    wxT("Erro"), wxICON_ERROR);
   return;
  }
 }
 
 // Neste ponto, eu também poderia usar um método
 // de wxTextCtrl para salvar o arquivo. Tente
 // comentar o trecho de leitura acima e descomente
 // a linha abaixo para testar:
 
 //txt_file->SaveFile(Filename);
 
 // Fecha o arquivo
 File.Close();
 
 // Atualiza o nome do arquivo
 lb_filename->SetLabel(Filename);
}

IMPLEMENT_APP(MeuPrograma)

Screenshot

Curso de wxWidgets, post 8: Manipulando arquivos

2006-11-07T14:10:00.000-03:00

Manipular arquivos em C não é complicado, mas de qualquer forma, irei apresenter uma classe do wxWidgets que o ajuda nesta tarefa, a wxFile.

wxFile é simples de usar. Seu construtor:

wxFile(const char* filename, wxFile::OpenMode mode = wxFile::read)

filename: O caminho do arquivo a ser aberto.

mode: Modo de acesso. Pode ser wxFile::read, wxFile::write ou wxFile::read_write.

Para abrir um arquivo para leitura, basta especificar o caminho do arquivo e usar o modo wxFile::read:

wxFile arquivo("c:\\arquivo.txt", wxFile::read);

Leitura e escrita? Use wxFile::read_write:

wxFile arquivo("c:\arquivo.txt", wxFile::read_write);

Após aberto, já podemos manipular o arquivo. A leitura é feita com o método wxFile::Read():

char linha[256];
int lido, max = 255;

wxFile arquivo("c:\\arquivo.txt", wxFile::read);
lido = arquivo.Read(linha, max);

lido irá conter a quantidade de bytes lidos pelo método. linha irá guardar o conteúdo lido e max indica o máximo de bytes a ser lido (neste caso, usado para delimitar a quantidade de dados que será guardado em linha). No caso de leitura de arquivos de texto, a quantidade de bytes a serem lidos deve ser o tamanho do buffer menos 1, para deixar espaço para o \0 de final de string em C.

Para gravar, simplesmente use o método wxFile::Write()

wxString Linha = wxT("Nova linha de texto!");
bool gravado;

wxFile arquivo("c:\\arquivo.txt", wxFile::read);
gravado = arquivo.Write(Linha);

Este método usa como argumento um wxString. Existe um segundo argumento, usado para fazer conversão do tipo da string. A conversão é utilizada caso você esteja usando wxWidgets em uma compilação (UNICODE, por exemplo) e deseja gravar o arquivo em outro formato (no caso, ANSI).

Se você prefere gravar no formato cru, como no C puro, existe também o método wxFile::Write(const void* buffer, wxFileOffset count) que funciona de forma semelhante ao wxFile::Read(). Ele recebe como argumento uma variável qualquer com algum conteúdo e um valor indicando a quantidade de bytes a serem gravados.

É preciso saber que essas operações serão feitas no início do arquivo. Ou seja, se você pede para ler 10 bytes, a classe wxFile irá ler os primeiros 10 bytes do arquivo. Se logo em seguida você solicitar uma escrita, seu buffer será gravado a partir do 11º byte. Para fazer leituras e escritas em outras partes do arquivo, use wxFile::Seek():

wxFileOffset Seek(wxFileOffset ofs, wxSeekMode mode = wxFromStart)

ofs: Offset a percorrer.

mode: Origem da busca. Pode ser wxFromStart, wxFromEnd ou wxFromCurrent.

Se você quiser fazer uma leitura a partir do 20º byte, por exemplo, basta usar o método wxFile::Seek() antes do wxFile::Read():

arquivo.Seek(20, wxFromStart);
arquivo.Read(buffer, 100);

O exemplo acima lê 100 bytes a partir do 20°, guardando o conteúdo em buffer. O mesmo vale para escritas, basta usar wxFile::Seek() antes de wxFile::Write().

Caso queira gravar no final do arquivo, use wxFile::SeekEnd():

arquivo.SeekEnd();
arquivo.Write(Linha);

Após ter feito todas as leituras e escritas desejadas, feche o arquivo com wxFile::Close().

Outros métodos interessantes

Além de leitura e escrita, podemos fazer outras coisas com wxFile. Por exemplo, obter o tamanho do arquivo aberto com wxFile::Length():

int tamanho = arquivo.Length();

Ou até verificar se o arquivo existe com wxFile::Exists():

bool existe = wxFile::Exists("c:\\arquivo.txt");

Finalizando

Na minha opinião pessoal, não há uma vantagem grandiosa em usar wxFile. Quero dizer, usar wxFile não nos dá tanta vantagem para tratar arquivos quanto wxString nos dá para tratar strings. Eu senti falta de um método que lesse n bytes, gravando-os em um wxString ou algum método que pudesse ler toda uma linha de uma vez.

Olhei o manual da próxima versão (2.7.2, futuramente 2.8.0) e não vi nada deste tipo em wxFile. Acabei ficando com vontade de implementar isso. :)

Curso de wxWidgets, post 7: Interagindo com o usuário

2006-10-30T22:17:00.000-03:00

Já sabemos criar janelas no wxWidgets, podemos interagir com o usuário através delas, mas existem outras formas de fazer isso, sem precisarmos criar janelas cheias de widgets.

Nesse post vamos conhecer wxMessageBox(), wxGetTextFromUser(), wxGetPasswordFromUser(), wxGetColourFromUser(), wxGetFontFromUser() e wxFileSelector().

wxMessageBox()

Jà vimos o wxMessageBox() em posts anteriores, com ele podemos mostrar janelas pop-up para o usuário, emitindo avisos e até mesmo fazendo perguntas:

int wxMessageBox(const wxString& message, const wxString& caption = "Message",
  int style = wxOK, wxWindow *parent = NULL, int x = -1, int y = -1)

message: A mensagem a ser exibida.

caption: O título da janela.

style: Estilo. Pode ser wxYES_NO, wxCANCEL, wxOK, wxICON_EXCLAMATION, wxICON_HAND,
  wxICON_ERROR, wxICON_QUESTION e wxICON_INFORMATION.

parent: A janela mãe do pop-up.

x, y: Coordenadas da janela pop-up.

Apenas o parâmetro message é obrigatório. Os mais importantes são message, caption e style. Os estilos indicam qual a configuração da janela pop-up, como os botões que ela vai ter e o ícone. Tente combinar os estilos e criar algumas janelas.

wxMessageBox(wxT("Está gostando do curso?"), wxT("A casa de Just"),
  wxICON_QUESTION | wxYES_NO);

wxGetTextFromUser() e wxGetPasswordFromUser()

Uma boa ajuda para obter textos do usuário, como um scanf() no C, mas em janela :)

wxString wxGetTextFromUser(const wxString& message, const wxString&
  caption = "Input text", const wxString& default_value = "",
  wxWindow *parent = NULL, int x = wxDefaultCoord, int y = wxDefaultCoord,
  bool centre = true)

wxString wxGetPasswordFromUser(const wxString& message,
  const wxString& caption = "Input text", const wxString& default_value = "",
  wxWindow *parent = NULL, int x = wxDefaultCoord, int y = wxDefaultCoord,
  bool centre = true)

message: Mensagem a ser exibida.

caption: Título da janela.

default_value: Valor padrão.

parent: A janela mãe do pop-up.

x, y: Coordenadas da janela.

centre: Centraliza a mensagem.

Como no wxMessageBox(), apenas message é obrigatório. Essa função retorna um objeto do tipo wxString com o texto que o usuário digitou. Em wxGetPasswordFromUser(), o texto que o usuário digita fica mascarado com asteriscos, é utilizado para obter senhas.

wxString nome = wxGetTextFromUser(wxT("Qual seu nome?"));

wxString senha = wxGetPasswordFromUser(wxT("Digite sua senha:"));

wxGetColourFromUser()

Quer solicitar alguma cor ao usuário? O wxWidgets pode ajudar com uma janela pronta para escolha de cores.

wxColour wxGetColourFromUser(wxWindow *parent, const wxColour& colInit)

parent: A janela mãe do pop-up.

colInit: Uma cor pré-selecionada para o pop-up.

Todos os parâmetros são opcionais. A função retorna um objeto do tipo wxColour com a cor que o usuário escolheu.

wxColour cor = wxGetColourFromUser();

wxGetFontFromUser()

Também é possível solicitar uma fonte ao usuário. Da mesma forma que com wxGetColourFromUser(), uma simples função pode fazer isso.

wxFont wxGetFontFromUser(wxWindow *parent, const wxFont& fontInit)

parent: A janela mãe do pop-up.

fontInit: Uma fonte pré-selecionada para o pop-up.

Novamente, todos os parâmetros são opcionais. A função retorna um objeto do tipo wxFont.

wxFont fonte = wxGetFontFromUser();

wxFileSelector()

Vamos agora selecionar arquivos.

wxString wxFileSelector(const wxString& message, const wxString& default_path = "",
  const wxString& default_filename = "", const wxString& default_extension = "",
  const wxString& wildcard = "*.*", int flags = 0, wxWindow *parent = NULL,
  int x = -1, int y = -1)

message: Mensagem a ser exibida.

default_path: Diretório inicial.

default_filename: Nome de arquivo inicial.

default_extension: Extensão para o arquivo que será selecionado.

wildcard: Curinga para exibição dos arquivos. Exemplo: "Bitmaps|*.bmp|Todos os arquivos|*.*".
  Este exemplo faz um menu dropdown com as duas opções.

flags: Estilo da janela. Pode ser wxOPEN, wxSAVE, wxOVERWRITE_PROMPT, wxFILE_MUST_EXIST,
  wxMULTIPLE ou 0. A janela pode abrir, salvar, perguntar caso sobrescreva, etc.

parent: A janela mãe do pop-up.

x, y: Coordenadas do pop-up.

Apenas message é obrigatório. A função retorna um objeto do tipo wxString com o caminho completo do arquivo.

wxString arquivo = wxFileSelector(wxT("Selecione o arquivo"));

Finalizando

Existem também outras funções para interação com o usuário, você pode vê-las na página "Dialog functions".

Como foi mostrado, não é necessário ficar fazendo janelas para coisas comuns como solicitar um arquivo ou uma cor. Explore as outras funções para descobrir coisas novas. :)

Blog atrasado

2006-10-26T20:04:00.000-03:00

Olá, pessoal.

Como já puderam perceber, o blog e o curso de wxWidgets andam atrasados. O fato é que nessas duas últimas semanas eu não tive tempo para elaborar o próximo post do curso. Estou fazendo provas na UESC e também estou usando meu tempo para resolver outros problemas adversos.

Mas na próxima semana, o curso de wxWidgets voltará normalmente. O próximo post é sobre interação com usuário. Se alguém tiver uma sugestão, é só deixar um comentário. :)

Desculpem-me a falta de posts. A Casa de Just não morreu!!! :D

Curso de wxWidgets, post 6: Strings com wxString

2006-10-11T19:54:00.000-03:00

Até aqui, você já tem condições de criar um aplicativo simples em wxWidgets, com uma interface gráfica razoável e alguns eventos. Agora, gostaria de falar sobre o tratamento de strings no wxWidgets.

Quando alguém aprende a programar em C (não C++), sente um pouco de dificuldade com o tratamento de strings no início. Como nós sabemos, as strings em C são na verdade vetores de char terminados com \0. A manipulação dessas strings se dá através de funções da biblioteca string.h: strcmp(), strcat(), strtok(), strstr()...

Já com C++, surge uma classe chamada string, da biblioteca string, com o objetivo de facilitar a manipulação das strings em C++ (quanta string! :P). Essa classe possui alguns métodos interessantes como string::append(), string::assign(), string::compare() e, inclusive, um método que retorna a string no formato de vetor do C padrão, a string::c_str().

Com a classe string do C++, evitamos problemas de referência de ponteiros e de manipulação de strings em geral, que podiam acontecer no C padrão. Mas agora que estamos usando wxWidgets, temos em mãos uma nova classe chamada wxString. Uma classe para manipulação de strings, como a classe string do C++, mas com algumas facilidades a mais.

Nada melhor que exemplos para demonstrar a classe wxString. Primeiro, vamos declarar um objeto do tipo wxString e atribuir um valor a ele:

wxString Texto;
Texto = wxT("Nossa nova string!");

Você pode fazer tudo em uma linha só, se preferir:

wxString Texto = wxT("Nossa nova string!");

Agora já temos um objeto wxString com a string "Nossa nova string!" atribuída a ele. O que podemos fazer em seguida? Vamos começar adicionando mais string:

Texto.Append(wxT(" Com wxString, claro."));

O método wxString::Append() adiciona texto ao final da string contida no objeto. O conteúdo do objeto Texto agora é "Nossa nova string! Com wxString, claro.".

Também é possível alterar todo o conteúdo do objeto. Podemos fazer isto com uma nova atribuição:

Texto = wxT("Aprendendo wxWidgets com Just.");

Depois da linha acima, o conteúdo do objeto será alterado para "Aprendendo wxWidgets com Just.". Vamos agora criar outra string:

wxString Texto2 = wxT("Aprendendo wxWidgets com Just.");

Temos agora dois objetos: Texto e Texto2. Podemos compará-los:

if (Texto == Texto2)
  wxMessageBox(wxT("São iguais."));

Com esse trecho de código, iremos ver uma caixa de mensagem que dirá "São iguais.". Atenção! As string são sensíveis à capitulação, ou seja, "Just", "just" e "JuSt" são todas diferentes entre si.

Podemos também verificar se uma string está dentro da outra. Por exemplo:

if (Texto.Contains(wxT("wxWidgets")))
  wxMessageBox(wxT("Texto encontrado."));

O método wxString::Contains() verifica se a string passada como parâmetro está contida na string atribuída ao objeto, retornando true ou false.

Os amantes do C puro (como eu) que nunca abrem mão do sprintf, têm uma alternativa com a classe wxString. Vamos criar uma string formatada, com alguns trechos dependentes de variáveis. Por exemplo:

int a, b;
a = 2;
b = 3;
wxString Soma;
Soma.Printf(wxT("A soma de %d com %d é %d."), a, b, a + b);

Qual será o conteúdo do objeto Soma? Se você pensou em "A soma de 2 com 3 é 5.", acertou em cheio. Com o método wxString::Printf(), podemos atribuir uma string ao objeto da mesma forma que fazemos isso em um vetor de char com a função sprintf do C. Existe também um método static que tem a mesma função, o wxString::Format(). Com esse método, não precisamos de um objeto instanciado para criar strings formatadas. Veja:

wxMessageBox(wxString::Format(wxT("A soma de %d com %d é %d."), a, b, a + b));

wxMessageBox() irá mostrar a mesma string do exemplo anterior, sem precisarmos instanciar um objeto para isso.

Temos também o método wxString::c_str(), caso queiramos obter um vetor de char, como no C puro:

char *soma_c = Soma.c_str();

Na versão ANSI do wxWidgets, wxString::c_str() retorna a string no formato ANSI. Esse mesmo método retorna a string no formato UNICODE, na versão UNICODE do wxWidgets. Se quiser obter o formato ANSI, independentemente da versão da compilação da biblioteca, use wxString::mb_str(). Para o mesmo, no formato UNICODE, temos wxString::wc_str().

Acredito ter mostrado exemplos suficientes dos métodos da classe wxString. Como sempre recomendo, leiam a documentação da classe para ver os outros métodos e utilizações dela. Recomendo também o tópico "wxString overview".

Por último, já que estamos usando wxWidgets, vamos usar wxString para manipular nossas strings. Dessa forma, a coisa toda fica mais fácil e temos mais opções, como demonstrei acima. :)

Curso de wxWidgets, post 5: Criando eventos

2006-10-03T21:21:00.000-03:00

Bem, já criamos um programa, fizemos uma janela e colocamos widgets nela (um wxStaticText, um wxTextCtrl e um wxButton). Mas que tal se esse botão fizesse alguma coisa além de enfeitar a janela? :)

Aí é que entram os eventos. O que vamos fazer é associar um evento a um método da classe que será responsável pela ação deste evento. Na nossa janela, iremos associar um evento de clique no botão "Hello!" a um método que iremos criar na classe MeuFrame.

Vamos começar criando um ID para o evento. Basta usar um #define ou um enum para isto. No nosso exemplo, usaremos um enum:

enum
{
 ID_BTN_HELLO
};

Esse ID será usado na criação do widget do botão, no lugar do famoso wxID_ANY. Agora, vamos ao método. Ele vai se chamar OnHelloClick(). Eu gosto de colocar "On" como prefixo de um evento e a ação como sufixo, no caso, "Click", mas você pode usar o nome que desejar, como CliqueNoBotao(), por exemplo. Na definição da classe, adicionamos o protótipo do método:

public:
 MeuFrame(void);
 void OnHelloClick(wxCommandEvent &event);

O método deve retornar void. No caso de um evento de clique em um wxButton, o parâmetro é um objeto do tipo wxCommandEvent, mas isso vai variar de evento para evento (detalhes mais adiante).

Em seguida, implementamos o método:

void MeuFrame::OnHelloClick(wxCommandEvent &event)
{
 if (txt_name->GetValue() == wxEmptyString)
  wxMessageBox(wxT("Digite um nome na caixa de texto."), wxT("Aviso"), wxICON_EXCLAMATION);
 else
  wxMessageBox(wxT("Olá, ") + txt_name->GetValue() + wxT("!"), wxT("Olá"), wxICON_INFORMATION);
}

O que acontece acima? Primeiro, verificamos se existe uma string na caixa de textos. Se não houver, a mensagem "Digite um nome na caixa de texto" é exibida. Se houver uma string, ela será usada para exibir a mensagem "Olá, (string)!". Não se preocupe com o conteúdo desse método por enquanto, no próximo post falarei sobre a classe wxString. Porém, vou adiantar um pouco sobre métodos dos widgets.

Logo na primeira linha do método acima, chamamos wxTextCtrl::GetValue(), esse método retorna um objeto do tipo wxString, contendo a string digitada na caixa de texto. Recomendo que você dê uma olhada na relação dos métodos dos widgets ao utilizá-los pela primeira vez, isso é bom para que você saiba o que pode ser feito com cada widget.

Precisamos declarar a tabela de eventos (que será criada ainda). Fazemos isso na definição da classe:

private:
 wxStaticText    *lb_hello;
 wxTextCtrl      *txt_name;
 wxButton        *btn_say;

 DECLARE_EVENT_TABLE()

Depois de criar o método e declarar a tabela de eventos da classe, vamos montá-la. Uma tabela de eventos começa com a macro BEGIN_EVENT_TABLE(classe, tipo) e termina com a macro END_EVENT_TABLE(). Entre essas duas macros, outras são inseridas, associando eventos a métodos. No caso do clique do botão, usaremos a macro EVT_BUTTON(id, func):

BEGIN_EVENT_TABLE(MeuFrame, wxFrame)
 EVT_BUTTON(ID_BTN_HELLO, OnHelloClick)
END_EVENT_TABLE()

Na macro EVT_BUTTON(), passamos como parâmetro a ID do evento e o método que será chamado. Para saber qual macro usar em cada tipo de widget, basta olhar na sua própria documentação. Por último, basta fazer uma alteração na criação do widget do botão, trocando o valor wxID_ANY por ID_BTN_HELLO (o parâmetro ID do construtor do widget):

lb_say = new wxButton(this, ID_BTN_HELLO, wxT("Hello!"));

Agora, é só compilar e executar o nosso exemplo:

Agora tente criar novos botões e eventos para eles. Leia o tópico "Event handling overview", do manual do wxWidgets. Na seção "Event macros summary" você encontra uma lista de classes de eventos, como a wxCommandEvent usada no exemplo do botão. Lembre-se que para saber qual macro usar em cada evento, basta ler a documentação do widget em questão.

Como está nosso programa até agora?

Após quatro posts de código (do 2 até este), pode ser que as coisas tenham ficado embaralhadas para alguns visitantes. Colei abaixo o código completo do nosso programa.

#include "wx/wx.h"

enum
{
 ID_BTN_HELLO
};

class MeuPrograma: public wxApp
{
public:
 virtual bool OnInit(void);
};

class MeuFrame: public wxFrame
{
public:
 MeuFrame(void);
 void OnHelloClick(wxCommandEvent &event);

private:
 wxStaticText *lb_hello;
 wxTextCtrl  *txt_name;
 wxButton  *btn_say;
 
 DECLARE_EVENT_TABLE()
};

bool MeuPrograma::OnInit(void)
{
 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

BEGIN_EVENT_TABLE(MeuFrame, wxFrame)
 EVT_BUTTON(ID_BTN_HELLO, MeuFrame::OnHelloClick)
END_EVENT_TABLE()

MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Meu Programa"))
{
 // Criação dos sizers
 wxBoxSizer *sizer_v = new wxBoxSizer(wxVERTICAL);
 wxBoxSizer *sizer_h = new wxBoxSizer(wxHORIZONTAL);
 
 // Criação dos widgets
 lb_hello = new wxStaticText(this, wxID_ANY, wxT("Digite seu nome na caixa:"));
 txt_name = new wxTextCtrl(this, wxID_ANY);
 btn_say = new wxButton(this, ID_BTN_HELLO, wxT("Hello!"));
 
 // Posicionamento dos widgets
 sizer_h->Add(txt_name, 1, wxALL, 5);
 sizer_h->Add(btn_say, 0, wxALL, 5);
 
 sizer_v->Add(lb_hello, 0, wxALL, 5);
 sizer_v->Add(sizer_h, 0, wxALL | wxEXPAND, 5);
 
 SetSizerAndFit(sizer_v);
}

void MeuFrame::OnHelloClick(wxCommandEvent &event)
{
 if (txt_name->GetValue() == wxEmptyString)
  wxMessageBox(wxT("Digite um nome na caixa de texto."), wxT("Aviso"), wxICON_EXCLAMATION);
 else
  wxMessageBox(wxT("Olá, ") + txt_name->GetValue() + wxT("!"), wxT("Olá"), wxICON_INFORMATION);
}

IMPLEMENT_APP(MeuPrograma)

Slackware 11.0 lançado

2006-10-03T07:02:00.000-03:00

Eu já estava agoniado com tantos RCs do Slackware 11.0, mas nessa madrugada, às 1:05, recebi um e-mail da lista slackware-announce que dizia: Slackware 11.0 is released!

Nessa nova versão, tem o kernel 2.4.33.3 ainda como padrão, o 2.6.17.13 como opção no diretório /extra e o 2.6.18 no diretório /testing. O KDE é o 3.5.4, XFCE 4.2.3.2, últimas versões do Firefox e Thunderbird, SeaMonkey 1.0.5 (substituindo a suíte Mozilla), além de glibc 2.3.6, gcc 3.4.6, X11R6.9.0 da X.Org, etc.

Bem, o recado está dado! Visitem o site oficial do Slackware para baixar essa nova versão. Hoje mesmo vou atualizar um dos meus servidores :P

Curso de wxWidgets, post 4: Posicionando com sizers

2006-09-26T20:00:00.000-03:00

Se você tentou adicionar novos widgets no frame do nosso "Hello, world!", possa ser que tenha tido problemas para posicioná-los. É isto que vamos fazer agora!

Bem, no wxWidgets, você não precisa especificar as coordenadas de cada widget (nem deve). Ao invés disso, usamos os sizers, que são objetos do wxWidgets que auxiliam no posicionamento dos widgets. Funciona mais ou menos como uma tabela, você adiciona sizers horizontais ou verticais e vai inserindo os widgets nas "células" deles.

No post de hoje, vamos fazer a seguinte janela para demonstrar o uso de sizers:

Para que você entenda o funcionamento dos sizers, vou mostrar como ela foi divida por eles:

Nesta janela foram usados dois sizers: um vertical (vermelho) e um horizontal (azul). O sizer horizontal tem dois widgets: um wxTextCtrl e um wxButton. O sizer vermelho tem um wxStaticText e o sizer horizontal. O sizer horizontal vai ficar dentro do vertical, de forma a fazer esta arrumação.

Para fazer esta janela, vamos modificar o nosso "Hello, world!". Na definição da classe do frame, declare os widgets que vamos usar:

class MeuFrame: public wxFrame
{
public:
 MeuFrame(void);

private:
 wxStaticText    *lb_hello;
 wxTextCtrl      *txt_name;
 wxButton        *btn_say;
};

E no construtor do frame, vamos criar os sizers, os widgets e posicioná-los:

MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Meu Programa"))
{
 // Criação dos sizers
 wxBoxSizer *sizer_v = new wxBoxSizer(wxVERTICAL);
 wxBoxSizer *sizer_h = new wxBoxSizer(wxHORIZONTAL);

 // Criação dos widgets
 lb_hello = new wxStaticText(this, wxID_ANY, wxT("Digite seu nome na caixa:"));
 txt_name = new wxTextCtrl(this, wxID_ANY);
 btn_say = new wxButton(this, wxID_ANY, wxT("Hello!"));

 // Posicionamento dos widgets
 sizer_h->Add(txt_name, 1, wxALL, 5);
 sizer_h->Add(btn_say, 0, wxALL, 5);

 sizer_v->Add(lb_hello, 0, wxALL, 5);
 sizer_v->Add(sizer_h, 0, wxALL | wxEXPAND, 5);

 SetSizerAndFit(sizer_v);
}

Vamos entender melhor os sizers. No início do construtor, criamos os dois sizers que vamos utilizar. No wxBoxSizer, você insere os widgets nas "células" e ele os encaixa usando o tamanho mínimo necessário por aquele widget. Como parâmetro do wxBoxSizer, passamos sua orientação, que pode ser wxHORIZONTAL ou wxVERTICAL.

Em seguida, criamos os widgets normalmente, chamando os construtores de cada um deles.

Por último, os widgets são inseridos nos sizers com o método wxSizer::Add(). Neste método, passamos os seguintes parâmetros:

txt_name: o widget a ser inserido.

1: a proporção (se ele deve se esticar na orientação do sizer e em que proporção de acordo com os outros widgets no mesmo sizer).

wxALL | wxEXPAND: flags deste elemento. wxALL diz que deve haver um espaçamento em todas as direções do widget e wxEXPAND diz que esse widget deve expandir para usar todo o espaço dado a ele. Outras flags podem ser encontradas na documentação do wxSizer.

5: o tamanho da borda que será usada com wxALL.

Por último, devemos dizer ao frame qual o sizer principal e que ele deve ser usado como base para o tamanho da janela. Para isso, chamamos o método wxWindow::SetSizerAndFit() e passamos o sizer vertical como parâmetro, já que ele contém todos os widgets e sizers dentro dele.

O uso de sizers é bastante fácil. Basta criar os sizers, criar os widgets e adicionar os widgets nos sizers. Experimente adicionar outros widgets junto com mais sizers, criando arrumações diferentes.

Leia também a documentação do wxWidgets para ver os outros sizers e veja o tópico "Sizer overview", esta página contém informações úteis na utilização de sizers.

PS.: Caso tenha dúvida em qualquer assunto de algum post do curso, deixe um comentário com sua pergunta. Se os leitores participarem no blog, outras pessoas também aprenderão.

WinPolicy na rede Globo

2006-09-23T15:21:00.000-03:00

Um usuário do WinPolicy postou a seguinte mensagem na comunidade do WinPolicy no Orkut:

"O WinPolicy apareceu por um acaso nessa reportagem da Rede Globulo de Cuiaba. A materia nao trata sobre o WinPolicy, mas sobre senhas na internet e em geral, e em um dos takes de filmagem aparece claramente no computador de uma Lan House láááááááááá de Cuiaba o WinPolicy sendo utilizado:

http://www.youtube.com/watch?v=eJDEjKIP4n0&NR

Aparece logo nos 00:17" de vídeo... muito legal..."

A URL do post original é:

http://www.orkut.com/CommMsgs.aspx?cmm=3711091&tid=2488845812591714844&start=1

Propaganda gratuita na rede Globo! Que legal! rsrs :)

Curso de wxWidgets, post 3: Entendendo o "Hello, world!" do post 2

2006-09-19T18:16:00.000-03:00

Agora sim, vamos ver como aquilo tudo funciona! :) Estou supondo que todos já conseguiram compilar o wxWidgets e botar ele pra trabalhar. Quem ainda não conseguiu, deixe comentários no post 2.

Voltando ao "Hello, world!"... Em primeiro lugar, devemos incluir os cabeçalhos do wxWidgets (acho que isso é óbvio):

#include "wx/wx.h"

Essa linha inclui os principais cabeçalhos do wx, mas você pode também inserir apenas os cabeçalhos das classes que deseja usar. Por exemplo, se em seu programa você estiver usando apenas um wxFrame e um wxButton, você poderia fazer assim:

#include "wx/app.h"    // Este é para o wxApp
#include "wx/frame.h"  // Este é para o wxFrame
#include "wx/button.h" // Este é para o wxButton

Iniciando o programa

Como todo programador C/C++ sabe, o programa sempre começa na função main(). Com wxWidgets, essa função não será mais utilizada. Na verdade, ela é utilizada internamente pelo wxApp, então, ao invés de usar main(), no wxWidgets usamos wxApp::OnInit().

Primeiro, precisamos criar uma classe que irá representar nosso programa. Essa classe deverá ser derivada de wxApp. Veja o código:

class MeuPrograma: public wxApp
{
public:
virtual bool OnInit(void);
};

Esse trecho de código vai criar a classe MeuPrograma que é derivada de wxApp (para os novatos em orientação a objetos, isso significa que a nossa nova classe vai herdar todos os atributos e métodos de wxApp. É como um wxApp + os métodos e atributos que criarmos nesta classe). O método sobrecarregado MeuPrograma::OnInit() será o main() do nosso programa. É este método que será chamado ao executarmos o aplicativo.

Criação da janela principal

Porém, queremos criar uma janela para o nosso programa. Uma janela em wxWidgets é um wxFrame. Então, para criarmos nossa janela específica, vamos criar uma classe para a janela. Essa classe deve ser derivada de wxFrame, já que queremos usar todo o "comportamento" de um wxFrame, mas com algumas coisas a mais e específicas que iremos implementar:

class MeuFrame: public wxFrame
{
public:
 MeuFrame(void);
};

Como na classe MeuPrograma, a classe MeuFrame é uma classe derivada de wxFrame, todos os métodos e atributos dela serão herdadas por nossa classe.

Implementando o programa

Bem, já temos uma classe para nosso aplicativo (MeuPrograma) e uma para nossa janela (MeuFrame). Agora, vamos voltar ao MeuPrograma::OnInit(). Devemos começar a programar aqui:

bool MeuPrograma::OnInit(void)
{
 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

Primeiro, declaramos um ponteiro do tipo MeuFrame e criamos uma instância da nossa classe. Na segunda linha, chamamos o método wxFrame::Show() para exibir a janela. Esse método faz com que a janela seja mostrada na tela. Na terceira linha, o método wxApp::SetTopWindow() define a janela instanciada em frame como a janela principal do nosso programa. E por último, return true indica que a inicialização do programa foi feita com sucesso e que ele deve continuar rodando. Se algo acontecesse errado, um return false iria fechar o programa imediatamente.

Bem, isto é o que de fato deve ser feito em wxApp::OnInit(). O resto da implementação deve ficar em outras classes. Mas por enquanto, vamos apenas criar nossa janela. Devemos implementar o construtor dela:

MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Meu programa"))
{
}

Nada é feito neste construtor. Na verdade, apenas passamos alguns parâmetros para o construtor do wxFrame. O primeiro parâmetro indica qual janela é pai desta janela. Como esta é a janela principal, ela não tem pai (NULL). O segundo parâmetro diz qual a ID desta janela. Como não fizemos nenhum evento da janela em si, não é preciso especificar uma ID agora (wxID_ANY). O terceiro parâmetro configura o título da janela (wxT("Meu programa")). Verifique a ajuda do construtor do wxFrame para ver os detalhes de todos os parâmetros.

Agora, devemos dizer ao wxWidgets qual é a nossa classe de aplicativo com a macro:

IMPLEMENT_APP(MeuPrograma)

Pronto! Este é o nosso "Hello, world!" explicado. Mas agora, vamos adicionar algumas coisas a ele.

Adicionando objetos

Primeiro, que tal um texto escrito "Hello, world!"? A classe para textos estáticos no wxWidgets é a wxStaticText. Os principais parâmetros do seu construtor (usaremos apenas estes):

wxWindow *parent: a janela pai deste objeto.
wxWindowID id: a ID deste objeto (caso desejamos criar um evento para ele).
wxString &label: o texto que será exibido.

Primeiro, vamos declarar nosso objeto na definição de MeuFrame. Basta adicionar a declaração na definição da classe, vai ficar assim:

class MeuFrame: wxFrame
{
public:
 MeuFrame(void);

private:
 wxStaticText *text;
};

E em seguida, instanciamos a classe no construtor de MeuFrame, adicionando a seguinte linha:

text = new wxStaticText(this, wxID_ANY, wxT("Hello, world!"));

Vai ficar assim:

MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Meu programa"))
{
 text = new wxStaticText(this, wxID_ANY, wxT("Hello, world!"));
}

Compile o programa novamente e execute. Você vai ver o texto "Hello, world!". Explicando os parâmetros:

this: indica que a janela MeuFrame é a janela pai do objeto.
wxID_ANY: indica que não estamos associando nenhuma ID específica ao objeto.
wxT("Hello, world!"): o texto que será exibido.

Uma breve explicação sobre a macro wxT()

Vocês devem ter notado que todas as strings estão envoltas na macro wxT(). Bem, antigamente, as strings eram representadas no formato ASCII, cada caractere ocupava um byte na memória. Porém, alguns idiomas contém caracteres especiais, como o japonês, chinês, árabe..., e um byte não era suficiente para representar todos eles, já que com um byte podemos representar apenas 256 valores diferentes. Surgiram então várias codificações de caracteres para representar cada idioma ou região. Então, para padronizar isso, o padrão UNICODE foi criado. Neste padrão, mais de um byte pode ser utilizado.

Mas o wxWidgets pode estar sendo utilizado em um sistema operacional sem suporte a UNICODE, ou até mesmo, o wxWidgets pode ter sido compilado sem suporte a UNICODE, como eu ensinei no post 2. Para não haver problemas com isso e tornar seu código portável, use a macro wxT(). Essa macro não faz nada em compilações sem UNICODE, mas vai converter a string ASCII para UNICODE, caso sua compilação do wxWidgets esteja usando UNICODE.

Faça mais no "Hello, world!"

Para prática, sugiro criar outros objetos na nossa janela. Algumas sugestões: wxButton, wxTextCtrl, wxComboBox, wxCheckBox e wxRadioBox.

No próximo post, vou mostrar como posicionar os objetos na janela (você vai perceber esse problema quando tentar adicionar novos objetos). Em caso de dúvidas, deixem comentários. :)

Curso de wxWidgets, post 2: Configurando uma IDE e compilando o wxWidgets

2006-09-11T21:11:00.000-03:00

Bom, vamos começar! Primeiro, escolha uma IDE para programar. Algumas sugestões:

Eclipse: minha IDE favorita. O problema é que não é muito leve, já que foi feita em Java e pra Java :) Mas eu recomendo, tem muitos recursos bons embutidos. Se decidir usar o Eclipse, você precisa instalar um plug-in chamado CDT, ele adiciona recursos para programação em C/C++ no Eclipse (como eu disse, ele foi feito pra Java). http://www.eclipse.org

MinGW Developer Studio: Uma espécie de clone do Microsoft Visual Studio. É leve e bem legal. O problema é que não está mais sendo desenvolvido. http://www.parinyasoft.com

Dev-C++: Uma IDE leve, desenvolvida em Delphi. Não tem muitos recursos como o Eclipse, mas também é agradável de usar. http://www.bloodshed.net

Todas essas IDEs usam o compilador GCC da GNU. O GCC é instalado junto com as IDEs. No caso do Eclipse, você precisa instalar o compilador a parte. Sendo assim, basta baixar o MinGW no site http://www.mingw.org (o link direto para o download da versão 5.0.2 é http://prdownloads.sf.net/mingw/MinGW-5.0.2.exe?download). Baixe também o MSYS (http://prdownloads.sf.net/mingw/MSYS-1.0.11-2004.04.30-1.exe?download), ele é uma espécie de shell para Windows, será necessário mais tarde para compilar o wxWidgets além de possuir alguns programas necessários para o Eclipse.

Se você usa Linux, baixe o Eclipse e certifique-se de que possui o GCC instalado na sua distribuição.

Instalando o MinGW e o MSYS

Se você estiver usando Linux, pule esta parte.

Primeiro, instale o MinGW. O executável vai baixar os pacotes selecionados da Internet e instalar em C:\MinGW. Faça a instalação completa, apesar de precisarmos apenas dos compiladores, do make e da API do Windows (Win32). A instalação é fácil (leia: next, next, next...) :P.

Após instalar o MinGW, vamos ao MSYS. Ele vai fazer uma instalação gráfica e em seguida vai abrir um prompt de comando. Ele vai perguntar onde o MinGW está instalado. Se estiver em C:\MinGW, responda como c:/mingw.

As instalações ainda não acabaram. Precisamos atualizar a variável de ambiente PATH. No Windows NT e seus derivados (2000, 2003 e XP), clique com o botão direito em “Meu Computador -> Propriedades”. Vá na aba “Avançado” e clique no botão “Variáveis de ambiente”. Procure pela variável “PATH” e clique em “Editar”. No final do valor da variável, adicione: ;C:\MinGW\bin;C:\msys\1.0\bin. No Windows 95, 98 e Me, edite C:\autoexec.bat para configurar o valor de PATH.

Isso fará com que os programas instalados possam ser acessados em qualquer diretório pelo prompt do DOS. Então vamos fazer um teste. Abra o prompt do DOS e execute primeiro gcc --version. Será exibida a versão do GCC instalado, significa que o MinGW foi instalado. Em seguida, tente o comando uname -a, esse comando vai mostrar a versão do Windows, significa que o MSYS foi instalado.

Se algum dos comandos não funcionar, tente refazer a instalação do programa que falhou.

Compilando o wxWidgets

Primeiro, baixe a biblioteca do site oficial em http://www.wxwidgets.org. Se estiver no Linux, baixe o wxGTK, no Windows, baixe o wxMSW.

Depois do download, é hora de compilar! No Linux, abra uma janela do terminal ou vá para o modo texto. No Windows, abra o MSYS.

Descompacte o código fonte do wxWidgets em um diretório qualquer e entre neste diretório:

$ cd /caminho/para/o/wx

Agora você vai precisar executar o script de configuração. Geralmente uso da seguinte forma (no Windows, troque o /usr/local/wx/2.6 para algo do tipo /c/wxMSW-2.6:

$ ./configure --prefix=/usr/local/wx/2.6 --disable-debug --enable-shared --disable-unicode

--prefix=/diretorio:
O diretório onde o wxWidgets vai ser instalado

--disable-debug:
Desabilita símbolos de debug (são usados para debugar no GDB)

--enable-shared:
Compila a biblioteca em vários arquivos .so ou .dll

--disable-unicode:
Desabilita o suporte a UNICODE (meio problemático no Windows 9x e NT, pois precisam de uma biblioteca a parte, por isso costumo desabilitar, não vamos escrever programas em árabe mesmo :P)

O script de configuração será executado e vai exibir um pequeno relatório no final. Leia a saída e verifique se condiz com a configuração feita.

Após feita a configuração, compile!

$ make

E depois de toda a compilação (pode demorar um pouco), instale!

$ make install

No Linux, basta agora executar ldconfig pra atualizar a lista de bibliotecas. No Windows, temos que copiar as DLLs pro diretório do sistema:

$ cp -af /c/wxMSW-2.6/lib/*.dll /c/WINDOWS/System32/

Também é necessário copiar uma DLL do MinGW:

$ cp -af /c/MinGW/bin/mingwm10.dll /c/WINDOWS/System32/

Pronto! wxWidgets e compiladores instalados.

Vamos fazer um pequeno teste

Abra sua IDE e copie o seguinte código fonte:

#include <wx/wx.h>

class MeuPrograma: public wxApp
{
public:
 virtual bool OnInit(void);
};

class MeuFrame: public wxFrame
{
public:
 MeuFrame(void);
};

bool MeuPrograma::OnInit(void)
{
 MeuFrame *frame = new MeuFrame();
 frame->Show();
 SetTopWindow(frame);
 return true;
}

MeuFrame::MeuFrame(void)
 :wxFrame(NULL, wxID_ANY, wxT("Meu Programa"))
{
}

IMPLEMENT_APP(MeuPrograma)

Compile ele na sua IDE. Provavelmente ela ainda não vai estar configurada para usar o wxWidgets, mas você pode compilar manualmente, basta abrir um terminal ou o MSYS no Windows e digitar o comando:

$ g++ -o wx testewx.cpp `wx-config --cxxflags` `wx-config --libs`

No Windows, você vai precisar especificar o caminho do wx-config por completo, /c/wxMSW-2.6/bin/wx-config --cxxflags...):

$ g++ -o wx testewx.cpp `/c/wxMSW-2.6/bin/wx-config --cxxflags` `/c/wxMSW-2.6/bin/wx-config --libs`

E execute o programa:

$ ./wx

Você deverá ver uma janela vazia com o título “Meu Programa”. Esse é nosso “Hello, World”. No próximo post vou explicar esse programa com detalhes.

wxWidgets é isso aí! Se não deu certo, refaça tudo, passo a passo até achar o erro. Por enquanto, tente entender o código sozinho ou até mesmo modificá-lo.

Entendendo o wx-config e configurando sua IDE

Todo programador C/C++ sabe que ao usar a linha de comando, podemos passar alguns argumentos para o gcc e para o g++, como por exemplo, incluir uma biblioteca. Quem nunca usou -lm para incluir o math.h? O que o wx-config faz é justamente isso. Experimente executar wx-config --cxxflags e wx-config --libs no seu terminal. O que você vai ver são os argumentos que devem ser incluídos no g++ na hora de compilar (--cxxflags) e na hora de “linkar” (--libs).

Se você quer usar uma IDE para compilar seus programas em wxWidgets, você precisa inserir esses parâmetros nas propriedades do seu projeto. No Eclipse, por exemplo, basta clicar com o botão direito do mouse na pasta do projeto e escolher a opção “Properties” no menu de contexto. Clique em “C/C++ Build” no painel à esquerda e insira `wx-config --cxxflags` nos argumentos de comando do g++ em “GCC C++ Compiler” e `wx-config --libs` em “GCC C++ Linker”. Veja a figura abaixo:

Se estiver usando Windows, você precisa executar o wx-config no MSYS, copiar a saída e inserir no Eclipse. Ou, você pode configurar cada configuração individualmente (Preprocessor, Directories, Optimization...)

OBSERVAÇÃO: No Eclipse do Windows, substitua o /c da saída do wx-config por c:/. Por exemplo: ao invés de -I/c/wxMSW-2.6/include, use -Ic:/wxMSW-2.6/include.

Windows Vista

2006-09-05T19:55:00.001-03:00

Estava eu curioso para ver o sucessor do Windows XP, o Vista. Então, abri o aMule e fiz uma busca. Baixei o DVD do Windows Vista beta 2 e instalei em um computador com a seguinte configuração de hardware:

Pentium 4 HT 3.0 GHz
512 MB de memória RAM
Plca de vídeo on-board
HD de 80 GB (não lembro a marca)
Placa de rede on-board SiS
Placa de rede off-board D-Link AirPlus G+ (rede sem-fio)

Comecei a instalação. Concordo que o novo instalador está realmente bonito, isso me deixou mais ansioso pra ver a cara do novo Windows.

Ao final da instalação, os tambores batiam enquanto o Windows Vista carregava nesse computador. Efetuei logon e entrei no sistema. Papel de parede bonito...

Bem, logo de cara pude perceber que a nova barra de tarefas do Windows Vista parece o painél do KDE, o botão "Iniciar" virou um círculo preto com o logotipo do Windows (estilo o menu K). As bordas das janelas parecem ter sido inspiradas nos inúmeros temas existentes para o GNOME e KDE. Os botões parecem com os do Mac e a cara do Windows Explorer me lembrou uma mistura de Nautilus (GNOME) com Konqueror (KDE) - não falando do tema, mas da organização das coisas.

Ora, mas ficou bonito!!! Isso é que importa. Mais importante que essa beleza toda (que eu já havia saboreado no Linux) é minha memória RAM. Esse Vista é um ladrão! Basta efetuar logon no sistema para consumir 380 MB (inserimos um pen drive USB e o consumo de memória subiu pra 400 MB).

Pra quem gosta de jogar paciência, campo minado e aqueles joguinhos do Windows, sugestão: compre uma placa 3D. Ao abrir Paciência, ele me avisou que eu não tenho placa aceleradora 3D, portanto, o jogo poderia ficar lento... e ficou (e como!!!). Ah! Se você pretende ver vídeos no seu Vista, compre uma placa 3D também, pois sem ela o Media Player nem abre o vídeo (pelo menos não abriu nessa on-board).

Bem, o novo KDE 3.5 roda suavemente em um laptop Pentium III 600 MHz com 312 MB de RAM e é mais bonito que o Windows Vista.

Não escrevi esse post pra esculhambar a Microsoft, mas acho que ela poderia ter feito um trabalho melhor. E não falo de interface gráfica bonita, mas de programação eficiente que não sugue tantos recursos da máquina. Minha opinião é que esse tipo de coisa é proposital, pra alavancar o consumo de hardwares caros.

Pelo menos o WinPolicy rodou sem problemas no Windows Vista. :)

Curso de wxWidgets em C++

2006-09-01T19:56:00.000-03:00

Olá, pessoal.

Decidi finalmente começar meu curso de wxWidgets através do meu blog. Eu já vinha idealizando ele desde o meu primeiro dia de blogueiro. É um tipo de "Aprenda você mesmo wxWidgets em x posts" (o "x" significa que não sei em qual post vou parar). O objetivo é ensinar como fazer bons softwares com interfaces gráficas usando C++.

Muita gente pensa que programar em C e C++ é extremamente complicado. A culpa é da API do Windows! Realmente ela é um pouco chata de aprender, pelo menos esta é minha opinião. Aí, infelizmente, as pessoas tendem a correr pro Java.

OBSERVAÇÃO: A partir deste ponto, é necessário avisar que no percurso deste curso, e provavelmente em alguns outros posts do meu blog, você verá frases e afirmações não muito amigáveis à esta linguagem. Não tenho nada contra Java, até conheço um pouco da linguagem (não tanto quanto C e C++), mas faço isso porque gosto de pirraçar programadores Java, é meu esporte favorito.

Voltando ao curso, minha tarefa aqui é resgatar as pobres almas perdidas no mundo do Java, Delphi, Visual Basic e outros, trazendo-as pro lado do C/C++. Você vai aprender que programar com interfaces gráficas em C++ usando wxWidgets é ainda mais fácil que programar em Java.

"O que eu NÃO vou aprender?"

Processos de desenvolvimento de software, documentação, análise, etc. Bem, provavelmente eu fale um pouco sobre essas coisas, mas não vou entrar em detalhes. O objetivo do curso é o wxWidgets no C++.

"O que é preciso para estudar através deste curso?"

Bem, se você já souber C e C++, já é o suficiente. Mas se você sabe pouco ou nada sobre estas linguagens, não se desespere! Existe um curso on-line de C da UFMG em http://ead1.eee.ufmg.br/cursos/C/ . Mas é bom lembrar que você precisa saber pelo menos o básico de orientação a objetos em C++, já que o wxWidgets é orientado a objetos.

"Que bom! Quais serão os tópicos estudados?"

Não tenho um cronograma fixo para seguir, mas pretendo começar da seguinte forma:

- Introdução a wxWidgets, como configurar, instalar e usar;
- "Hello, world" em wxWidgets;
- E aí vamos nos infiltrando nas outras classes da Framework...

Referências bibliográficas

Para dúvidas de C++, uso o livro "C++: Como Programar" de Deitel. Para dúvidas sobre o wxWidgets, uso a documentação on-line no endereço http://www.wxwidgets.org/
Mais uma vez, recomendo o curso de C da UFMG.

Outros detalhes

Tentarei escrever um post por semana, isso vai dar tempo para os visitantes estudarem o post e para que eu possa preparar o próximo ("tentarei", porque preciso dividir meu tempo com outras coisas, inclusive o lazer). Cada post também terá um código de exemplo do assunto abordado e os visitantes poderão deixar comentários, podendo tirar dúvidas com outros visitantes ou comigo mesmo, ou até mesmo sugerir alguma coisa.

Então, espero que isso dê certo. Além de divulgar o conhecimento, pretendo também melhorar o meu próprio conhecimento. :)

Produtividade na programação (ou no desenvolvimento de softwares)

2006-08-20T13:26:00.000-03:00

Quem está no curso de Ciência da Computação da UESC sabe dos últimos e-mails que rolaram na lista de discussão dos alunos, sobre a utilização de ferramentas RAD para criar interfaces gráficas em C++. Um dos colegas do curso defendeu o uso de ferramentas RAD nesta etapa do desenvolvimento.

Bem, ele defende veementemente qualquer ferramenta que se propôe a facilitar e agilizar alguma etapa do desenvolvimento de um software, mas acho que ele esquece de analisar se essa ferramenta não vai acabar atrapalhando e atrasando etapas posteriores do desenvolvimento, resultando em um projeto mais demorado do qual se não fosse utilizada tal ferramenta.

Eu dei minha contribuição na lista de discussão. Argumentei que nem sempre agilizar uma etapa agiliza o todo. Como a discussão era sobre criação de interfaces gráficas, também argumentei que essa etapa do desenvolvimento leva pouco tempo e que se feita corretamente, o tempo dela pode se tornar desprezível em relação ao todo.

O e-mail que eu postei na lista de discussão está abaixo. Ele vai ser o post de hoje do meu blog:

"A conversa sobre usar ou não uma ferramenta RAD pra criar interfaces gráficas me fez pensar sobre produtividade na programação. Então, vou expôr o que eu pensei e o que eu acho sobre isso.

As empresas estão atrás de produtividade. É verdade, claro. E também é verdade que devemos ser produtivos, para assim termos um emprego, ganhar dinheiro e nos manter, sempre pensando em ter algo mais pra entretenimento e futilidades extras. "Mas Just é um cara tão GNU!! Como pode dizer isso??" Ora, eu também gosto de dinheiro :)

Entrando na conversa de programação, não adianta muito fazer as janelas (ou outras interfaces gráficas) bem rapidamente. O cara abre a IDE, desenha tudo rapidinho e depois vem a pergunta: "E agora? O que eu faço?" É preciso programar! Escrever código, claro!

Aí entram as grandes empresas. Essas sim precisam ser muito produtivas e rápidas. Como já foi discutido na lista antes e continuou sendo essa semana, empresas grandes e importantes exigem experiência. Bem, um programador experiênte consegue criar uma interface gráfica na mão tão rapidamente quanto usando uma IDE RAD. E ainda, criar a interface na mão pode fazer o desenvolvimento se tornar mais rápido por um todo.

O que eu quero dizer, é que se você desenha a interface com uma IDE RAD, ela fica pronta rapidamente, mas dá trabalho pra fazer algumas alterações. Se você faz via código, dependendo da sua experiência na framework e na linguagem utilizada, você cria a janela tão rapidamente quanto se usasse uma IDE RAD. E ainda, se quiser fazer alterações futuras, fica bem simples. É só adicionar uma linha, ou alterar outra, e por ai vai.

Mas ainda não acabei. Acrescento ainda, que durante todo o processo de desenvolvimento de um software, a interface gráfica pode ser algo em torno de 10% do projeto total. Vou citar como exemplo o WinPolicy (todo mundo já deve tá de saco cheio dele :P). Fiz as interfaces dele via código (aproveitei essa etapa pra aprender wxWidgets, hoje eu criaria a mesma interface muito mais rápido que antes). Depois de fazer as interfaces, foi só programação das funcionalidades. Lancei a versão 3.0. Adicionava algum recurso, corrigia bugs, 3.0.1, 3.0.2, 3.1, 3.1.1, 3.1.2 e agora está em 3.1.3. Quer dizer, a criação da interface gráfica tomou em torno de 10% do tempo e do código do software inteiro. O importante é programar bem pra fazer o resto com velocidade e qualidade.

Citando outro exemplo, estou terminando um outro projeto. Como já sabia mais de wxWidgets, a interface gráfica foi um tapa! Depois disso, fui implementando as funções do software. Essa semana terminei a versão beta. Pretendo lançar ele em breve.

Concluindo: não viagem nessa de querer uma ferramenta que faça tudo pra vocês, ou então a única experiência que vocês vão ter vai ser em clicar nos botões de uma ferramenta específica. No dia que ela cair em desuso, lascou-se! Se você aprende a programar bem, você não fica dependente de ferramenta. Além disso, essa experiência vai ajudar muito pra aprender outras linguagens e frameworks."

Explicando um pouco mais, acho melhor aprender a programar bem do que usar uma ferramenta bem. Se você entende bem a programação e o uso das frameworks, caso seja preciso aprender outra linguagem ou framework, vai ficar mais fácil do que se treinar em uma nova ferramenta de "clique-e-arraste".

Estão aí meus argumentos. Acredito estar correto. Espero receber comentários sobre o assunto. :)

Backports (Debian)

2006-08-04T19:32:00.000-03:00

Todo usuário do Debian sarge deve ter um problema em comum: apesar do sistema ser realmente estável, alguns softwares estão bastante desatualizados. Exemplos:

- Firefox 1.0.4
- Thunderbird 1.0.2
- OpenOffice.org 1.1.3
- Gaim 1.2.1
- e por aí vai...

Existe a opção de você não utilizar os pacotes Debian desses softwares e baixar o fonte no site oficial e compilar. Mas qual a graça de usar Debian sem o apt?

Essa semana, enquanto pesquisava sobre como instalar o Catalyst no Debian sarge (ele tem pacotes no testing e no unstable, mas não no stable), encontrei um site chamado Debian Backports, que fornece os pacotes do Debian testing (alguns do unstable), compilados com as libs do stable (sarge). E lá estava o libcatalyst-perl, que é do testing, mas preparado para o sarge :)

O Backports funciona assim: você inclui o repositório deles em /etc/apt/sources.list e pode instalar os pacotes mais recentes com o apt-get:

deb http://www.backports.org/debian/ sarge-backports main contrib non-free

Depois é preciso adicionar essas linhas em /etc/apt/preferences (isso vai desativar os pacotes do Backports e fazer o apt usar os pacotes do sarge como padrão):

Package: *
Pin: release a=sarge-backports
Pin-Priority: 200

Para instalar um pacote que está no Backports:

# apt-get update
# apt-get -t sarge-backports install mutt

Pronto. Seja feliz no Debian sarge! :)

OpenOffice.org 2 no Debian sarge (stable)

2006-07-26T19:54:00.000-03:00

Como os usuários Debian sabem, a versão do OpenOffice.org no Debian sarge (stable) é a 1.1.3, a versão 2 só está presente no etch (testing) e no sid (unstable).

Porém, eu decidi fazer um downgrade. Usava o Debian etch em casa, e decidi voltar para o sarge. Porque? Porque alguns pacotes sempre faltam nas versões testing do Debian, além de eu desconfiar que o atual X.Org do testing está com o desempenho um pouco abalado e que algumas fontes estão estranhas (paranóia minha).

Eu sempre sentia um pouco de vontade de voltar pro sarge, mas duas coisas me impediam, na verdade, a falta delas: o OpenOffice.org do sarge é o 1.1.3 e o Firefox é o 1.0.4.

Bem, o Firefox eu posso baixar a versão mais nova no site oficial e instalar. O OpenOffice.org também... mas como muitos devem ter notado, o antigo instalador standalone do OpenOffice.org sumiu!!! Agora são apenas RPMs... que droga... e eles não dão pacotes .deb.

Mas nem tudo está perdido. Descobri recentemente que o site brasileiro do OpenOffice.org fornece pacotes .deb (que bom!). E mesmo que você decida usar os pacotes oficiais (RPM), isso é possível com uma ferramenta chamada alien, um conversor de "quase qualquer coisa" para ".deb". E antes que eu me esqueça (e você também):

# apt-get install alien

Então, se você baixar o BrOffice, basta descompactar o arquivo e fazer:

# dpkg -i *.deb

Mas se você prefere a versão oficial em inglês, descompacte o arquivo baixado e entre no diretório criado por ele. Lá dentro, você verá um diretório chamado "RPMS", "cd nele". Agora, vamos ao alien:

# alien *.rpm

Os RPMs irão se transformar em .deb. Após isso:

# dpkg -i *.deb

Pronto! OpenOffice.org 2 instaldo no Debian sarge. Mas isso é muito simples, ainda não está digno de um post no meu blog. Vamos ao problema!

Se seu Debian sarge estiver atualizado, após instalar o OpenOffice.org, tente abrir o Impress. Tentou? Acho que você levou um belo CRASH! Ele simplesmente fecha e abre o Writer. E se você fizer alguma coisa mais elaborada no Writer, ele também fecha.

"Qual o problema?", você me pergunta. Após passar uma noite de ódio com esse problema (eu tava querendo fazer um trabalho pra Universidade), acabei descobrindo após fuçar no oráculo. O OpenOffice.org 2 está conflitando com a versão 2.1.7-2.5 do libfreetype6. A solução é fazer um downgrade para a versão 2.1.7-2.4.

# apt-get install libfreetype6=2.1.7-2.4

Agora, tente abrir o Impress e verá que ele funciona. :)

Emulando PCs

2006-07-18T20:42:00.000-03:00

Trabalho no desenvolvimento de uma distribuição Linux personalizada no CEPEDI. No entanto, preciso testar o programa de instalação de várias formas. Já pensou, sempre que mudar alguma coisa no instalador, ter que regravar o CD-RW e dar boot em um PC? Por isso uso o QEMU, um emulador de PC pra Linux.

Alguns já usaram o VMware (eu nunca). Mas o VMware é um software pra Windows (não sei se possui versão pra outros SOs) e custa uma graninha. O QEMU é gratuito por ser OpenSource e sua utilização é muito fácil.

O site oficial é http://fabrice.bellard.free.fr/qemu/, mas se você usa Debian:

# apt-get install qemu

Recomendo instalar também o kqemu, ou QEMU Accelerator. É um módulo do kernel que acelera o desempenho do QEMU. Ele tenta rodar a maioria dos códigos dos aplicativos do sistema do PC emulado diretamente no seu processador. Não existe pacote no repositório Debian oficial, você vai ter que compilar na mão.

Após instalado o QEMU, sua utilização é fácil. Você pode até criar uma imagem de disco (um HD em um arquivo):

# qemu-img create meu_hd.img 1024M

Esse comando cria um arquivo de 1 GB pra servir de imagem. Feito isso, coloque um CD de qualquer SO no seu drive de CD e execute o comando:

# qemu -hda meu_hd.img -cdrom /dev/cdrom -boot d

Ele vai emular um PC cujo HD é seu arquivo de imagem, o CD-ROM é seu drive e vai dar boot pelo CD. Alguns argumentos mais comuns:

-hda O /dev/hda do seu PC virtual
-hda, -hdc e -hdd Similar ao -hda
-cdrom Seu drive de CD-ROM
-floppy Seu drive de disquete
-boot [a|c|d] Boot pelo disquete (a), HD (c) ou CD-ROM (d)
-m tamanho Memória RAM do PC virtual
-k pt-br Teclado ABNT2

No site do QEMU, a documentação completa mostra outros argumentos de linha de comando.

Eu usei o QEMU em casa pra emular o Windows 98 e testar o WinPolicy. Funcionou bem:

Novo site da Justsoft

2006-07-15T23:40:00.000-03:00

Não tinha nada de interessante pra postar hoje, então resolvi falar do que fiquei fazendo a tarde toda: mudando o site da Justsoft.

Está parecido com o antigo, as poucas diferenças são a família das fontes, que agora é "Tahoma, Verdana, sans-serif", a barra superior e algumas imagens que coloquei na página.

Na barra superior agora tem uma imagem relevante aos computadores, também passei o logotipo pro lado esquerdo - o lado mais emotivo do cérebro fica à direita, assim, as imagens à esquerda ficam gravadas no lado direito do cérebro e as pessoas tendem a lembrar melhor do logotipo dessa forma. Na página de download do WinPolicy, coloquei uma figurinha que achei bem legal.

As imagens foram tiradas do Alamy, um site que distribui imagens. Você pode baixá-las gratuitamente (as Royalty-Free) ou comprá-las. A diferença das gratuitas para as compradas é a resolução e tamanho, além de que algumas não possuem versão gratuita.

Kororaa - XGL em Live!

2006-07-14T22:11:00.000-03:00

Pra quem viu vídeos do Novell XGL, gostou, mas ainda não o viu pessoalmente (meu caso), o Kororaa te ajuda.

Foi Cesar Lawinsky, formado em Computação na UESC, que me falou que estava testando o XGL. Então perguntei se ele tinha compilado o fonte, mas ele disse que tava usando uma distribuição live que já vinha com o XGL. Essa distribuição é o Kororaa. Fui ao oráculo e encontrei o site oficial: http://kororaa.org/

De acordo com o próprio site, o Kororaa é uma versão binária do Gentoo, com algumas coisas a mais. O Kororaa não-live não vem com o XGL pré-configurado, apenas a versão XGL Live CD o possui. O endereço do download desta versão é http://kororaa.org/static.php?page=static060318-181203

Screenshots? Mas é claro! http://www.tuxmachines.org/gallery/korxgl2

Ainda não experimentei ele pessoalmente porque não tenho placa de vídeo "das boas" em casa. A minha é uma Savage on-board. :(

uptimed

2006-07-13T20:41:00.000-03:00

Se você administra um servidor Linux, BSD ou outro UNIX-like, com certeza você dá uma olhadinha no uptime da máquina de vez em quando. Pois bem, existe uma forma de registrar os maiores uptimes do seu servidor e consultar o ranking a qualquer hora, com um software chamado "uptimed".

Após instalar o uptimed, ele vai registrar o uptime da sua máquina e o horário do boot. Se ela for reiniciada, esse registro fica salvo e um novo registro é criado. Após um certo tempo e alguns reboots, você pode usar o programa "uprecords" para ver a lista dos maiores uptimes da sua máquina. Veja um exemplo:

Se você usa Debian, basta digitar o comando:

# apt-get install uptimed

Caso não, baixe o programa no endereço http://freshmeat.net/projects/uptimed/

Começando

2006-07-12T18:55:00.000-03:00

Olá, pessoal! :)

Também criei um blog, incentivado por Jhenny, que também já tem o seu.

Aqui pretendo interagir com outras pessoas interessadas em programação em C/C++ (talvez Perl também), sistemas UNIX-like e computação em geral. Provavelmente, C/C++ será o tópico mais discutido (minhas linguagens favoritas).

Mas, quem sou eu?

Atualmente sou estudante de Ciência da Computação na Universidade Estadual de Santa Cruz, em Ilhéus, BA. Já havia cursado cinco semestres de Bacharelado em Física na Universidade Estadual de Feira de Santana (também na Bahia) e três semestres de Sistemas de Informação na Faculdade de Tecnologia e Ciências de Feira de Santana. Cursei Física simplesmente por gostar do assunto, mas minha vontade era cursar Computação, por isso entrei no curso de Sistemas de Informação, mas não gostei muito, era muita administração e pouca Computação. Então fui pra Ciência da Computação e me encontrei na academia. Também havia tentado Ciência da Computação na Universidade Federal de Pernambuco, mas não consegui sobreviver à segunda fase das provas. :P

Além de estudar, sou administrador de Redes do CEPEDI (Centro de Pesquisa e Desenvolvimento em Informática e Eletro-eletrônica de Ilhéus), antigamente era programador. Também tenho uma empresa na Incubadora de Empresas de Base Tecnológica de Ilhéus, a Justsoft.

Pela Justsoft, desenvolvi o WinPolicy, um software para gerenciamento de políticas de segurança do Windows. Minha empresa também trabalha com desenvolvimento de distribuições Linux personalizadas e softwares para gerenciamento de redes e estações de trabalho.

Pois bem, profissionalmente sou isso aí. Em breve começarei a postar textos sobre programação, UNIX, etc, como havia dito logo acima. :)