Categoria → artigos
Fixando o Eclipse na Barra de Tarefas do Windows 7
Esta é uma dica para fixar o Eclipse na barra de tarefas do Windows 7. Apenas siga os passos a seguir.
1. Abra o eclipse.ini no diretório do Eclipse.
2. Adicione as seguintes linha no início do arquivo e salve:
-vm
[Caminho para o diretório bin da Java VM. Ex: C:\Program Files\Java\jdk1.6.0_22\bin]
3. Salve o arquivo e abra o Eclipse, e depois de aberto, tente fixar.
È simples assim. 
Motorola Milestone para desenvolvimento Android no Eclipse
Neste artigo irei explicar como fiz para utilizar o Motorola Milestone para debugar e rodar aplicações em modo de desenvolvimento no Android. Este artigo não tem propósito de ensinar Android, Java ou qualquer coisa do tipo. Somente utilizar o Milestone em ambiente de desenvolvimento. E esse artigo é um passo a passo do que fiz para conseguir isso. No meu caso estou utilizando o sistema operacional Windows 7, mas acredito que não seja muito diferente adaptar os passos para Linux e MacOS. E também meu Milestone está com o ShadowMod 0.9.14(Android 2.2.1).
1. Baixe e instale a Android SDK(instalei em c:/android-sdk): http://developer.android.com/sdk/index.html
2. Baixe e instale o driver USB da Motorola(link não oficial da Motorola): : http://code.google.com/p/shadowmodbr/downloads/list
3. Adicione os diretórios “tools” e “platform-tools” da SDK no Path do seu Sistema Operacional.
4. Ligue o modo de debug no Milestone. Fica em Configurações, Aplicativos, Desenvolvimento, Depuração USB.
5. Conecte o Milestone via cabo de dados USB em seu computador.
6. No Prompt de Comando(ou bash, qualquer coisa do gênero), dê o comando “adb devices”. Ele deverá mostrar um “código maluco”(que formalmente se chama serial number). Se não mostrar, repita os passos anteriores. Se mostrar, muito bem Fliper, o negócio tá indo.
7. Inicie o Eclipse(é necessário que ele tenha o plugin do Android instalado)..
8. Crie um projeto caso não possua um criado.
9. No arquivo “AndroidManifest.xml”, na tag “application”, adicione o seguinte atributo e valor: android:debuggable=”true”
10. Agora tente rodar ou debugar sua aplicação. Para mim isso já funcionou. Mas o artigo que segui e fiz uma “tradução livre”, diz que pode ser que apareça uma pop-up para escolher o dispositivo. Se aparecer, escolha seu dispositivo e pronto.
Fonte do artigo: http://androiddevblog.blogspot.com/2010/02/android-programming-and-debugging-on.html
Escrevendo uma extensão de Twitter para o Google Chrome utilizando o Google Web Toolkit(GWT)
Estava olhando os exemplos de como criar extensões para o Chrome, e vi que assim como o no Firefox, as extensões não são nada mais que Javascript(mas no caso do Firefox tem os XUL envolvidos e etc…). Então pensei eu: “GWT gera Javascript, então ele deve funcionar para criar extensões”. Fiz uns testes básico e conclui. Funcionou. E aqui escrevo um tutorial dizendo como fiz para fazer isso funcionar. O objetivo desse tutorial não é ensinar GWT, é somente mostrar como configurar um projeto do GWT para rodar como uma extensão do Chrome.
Antes de tudo, vou dar um aviso que vai lhe poupar de alguns problemas: Salve todos os arquivos do exemplo com codificação UTF-8.
Como exemplo, criei uma aplicação para twitter bem simples, que só lê as últimas mensagens de um usuário qualquer.
Primeiramente criei uma aplicação no Eclipse chamada “ExtensaoChrome” com o pacote base chamado “com.serathiuk.chrome.extension.teste.client”.
Depois disso, alterei o arquivo ‘ExtensaoChrome.html’ da pasta war, deixando apenas com o seguinte HTML:
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”>
<link type=”text/css” rel=”stylesheet” href=”ExtensaoChrome.css”>
<div id=”intro_panel”></div>
<script type=”text/javascript” language=”javascript” src=”extensaochrome/extensaochrome.nocache.js”></script>
Na pasta war, coloquei o arquivo icon.png(o mesmo do exemplo oficial, link no final) e o arquivo manifest.json, que tem o seguinte conteúdo:
"name": "Leitor de Twitter",
"version": "1.0",
"description": "Exemplo de extensão para Chrome utilizando GWT do site serathiuk.com.",
"browser_action": {
"default_title": "Leitor de Twitter",
"default_icon": "icon.png",
"popup": "ExtensaoChrome.html"
},
"permissions": [
"http://www.twitter.com/"
]
}
Depois disso, apaguei aqueles arquivos que são criados pelo exemplo, deixando apenas o “ExtensaoChrome.java”, que é o Entry Point da aplicação. E no EntryPoint, apaguei todas aquelas informações do exemplo, e colocando o código para fazer a aplicação funcionar:
private TextBox txtLogin;
private FlexTable tableTwitter;
public void onModuleLoad() {
HorizontalPanel h = new HorizontalPanel();
txtLogin = new TextBox();
h.add(txtLogin);
Button btn = new Button("Carregar");
btn.addClickHandler(new ClickHandler() {
public void onClick(ClickEvent event) {
carregarTwitts();
}
});
h.add(btn);
ScrollPanel align = new ScrollPanel();
align.setWidth("100%");
align.setHeight("320");
tableTwitter = new FlexTable();
tableTwitter.setCellPadding(1);
tableTwitter.setCellSpacing(1);
tableTwitter.setBorderWidth(1);
align.add(tableTwitter);
VerticalPanel v = new VerticalPanel();
v.add(h);
v.add(align);
RootPanel.get("intro_panel").add(v);
}
protected void carregarTwitts() {
String url = "http://twitter.com/statuses/user_timeline/"+txtLogin.getValue()+".json";
RequestBuilder req = new RequestBuilder(RequestBuilder.GET, URL.encode(url));
try {
req.sendRequest(null,
new RequestCallback() {
public void onResponseReceived(Request request, Response response) {
preencheValores(response.getText());
}
public void onError(Request request, Throwable exception) {
showError(exception);
}
}
);
} catch(RequestException e) {
showError(e);
}
}
protected void preencheValores(String jsonText) {
tableTwitter.removeAllRows();
JSONArray json = (JSONArray) JSONParser.parse(jsonText);
for(int i = 0; i < json.size(); i++) {
JSONObject obj = (JSONObject) json.get(i);
if(obj != null) {
JSONString str = (JSONString) obj.get("text");
tableTwitter.setText(i+1, 0, str.stringValue());
}
}
}
protected void showError(Throwable e) {
Window.alert(e.getMessage());
}
}
Agora é só compilar o projeto e adicionar a extensão ao Chrome. Para fazer isso, digite o endereço “chrome://extensions/”, clicar em “Load Unpacked Extension” e selecionar o diretório war da aplicação(ou o diretório onde está o manifest.json). Com isso a extensão estará rodando, é só clicar no ícone dela ao lado da barra de endereços.
Exemplo Oficial: http://code.google.com/chrome/extensions/getstarted.html
Código-Fonte deste exemplo: http://gwtchrome.googlecode.com/files/ExtensaoChrome.7z
Antes de tudo, vou dar um aviso que vai lhe poupar de alguns problemas: Salve todos os arquivos do exemplo com codificação UTF-8.
Como exemplo, criei uma aplicação para twitter bem simples, que só lê as últimas mensagens de um usuário qualquer.
Primeiramente criei uma aplicação no Eclipse chamada “ExtensaoChrome” com o pacote base chamado “com.serathiuk.chrome.extension.teste.client”.
Depois disso, alterei o arquivo ‘ExtensaoChrome.html’ da pasta war, deixando apenas com o seguinte HTML:
<!DOCTYPE HTML PUBLIC “-//W3C//DTD HTML 4.01 Transitional//EN”>
<link type=”text/css” rel=”stylesheet” href=”ExtensaoChrome.css”>
<div id=”intro_panel”></div>
<script type=”text/javascript” language=”javascript” src=”extensaochrome/extensaochrome.nocache.js”></script>
Na pasta war, coloquei o arquivo icon.png(o mesmo do exemplo oficial, link no final) e o arquivo manifest.json, que tem o seguinte conteúdo:
{
“name”: “Leitor de Twitter”,
“version”: “1.0″,
“description”: “Exemplo de extensão para Chrome utilizando GWT do site serathiuk.com.”,
“browser_action”: {
“default_title”: “Leitor de Twitter”,
“default_icon”: “icon.png”,
“popup”: “ExtensaoChrome.html”
},
“permissions”: [
"http://www.twitter.com/"
]
}
Depois disso, apaguei aqueles arquivos que são criados pelo exemplo, deixando apenas o “ExtensaoChrome.java”, que é o Entry Point da aplicação. E no EntryPoint, apaguei todas aquelas informações do exemplo, e colocando o código para fazer a aplicação funcionar:
public class ExtensaoChrome implements EntryPoint {
private TextBox txtLogin;
private FlexTable tableTwitter;
public void onModuleLoad() {
HorizontalPanel h = new HorizontalPanel();
txtLogin = new TextBox();
h.add(txtLogin);
Button btn = new Button(“Carregar”);
btn.addClickHandler(new ClickHandler() {
public void onClick(ClickEvent event) {
carregarTwitts();
}
});
h.add(btn);
ScrollPanel align = new ScrollPanel();
align.setWidth(“100%”);
align.setHeight(“320″);
tableTwitter = new FlexTable();
tableTwitter.setCellPadding(1);
tableTwitter.setCellSpacing(1);
tableTwitter.setBorderWidth(1);
align.add(tableTwitter);
VerticalPanel v = new VerticalPanel();
v.add(h);
v.add(align);
RootPanel.get(“intro_panel”).add(v);
}
protected void carregarTwitts() {
String url = “http://twitter.com/statuses/user_timeline/”+txtLogin.getValue()+”.json”;
RequestBuilder req = new RequestBuilder(RequestBuilder.GET, URL.encode(url));
try {
req.sendRequest(null,
new RequestCallback() {
public void onResponseReceived(Request request, Response response) {
preencheValores(response.getText());
}
public void onError(Request request, Throwable exception) {
showError(exception);
}
}
);
} catch(RequestException e) {
showError(e);
}
}
protected void preencheValores(String jsonText) {
tableTwitter.removeAllRows();
JSONArray json = (JSONArray) JSONParser.parse(jsonText);
for(int i = 0; i < json.size(); i++) {
JSONObject obj = (JSONObject) json.get(i);
if(obj != null) {
JSONString str = (JSONString) obj.get(“text”);
tableTwitter.setText(i+1, 0, str.stringValue());
}
}
}
protected void showError(Throwable e) {
Window.alert(e.getMessage());
}
}
Agora é só compilar o projeto e adicionar a extensão ao Chrome. Para fazer isso, digite o endereço “chrome://extensions/”, clicar em “Load Unpacked Extension” e selecionar o diretório war da aplicação(ou o diretório onde está o manifest.json). Com isso a extensão estará rodando, é só clicar no ícone dela ao lado da barra de endereços.
Configurando o SmartGWT em um projeto do Eclipse
A muito tempo tinha falado em escrever um artigo sobre SmartGWT, mas acabei ‘se enrolando’ e isso nunca aconteceu. Mas nos últimos dias, tenho acompanhado as estatistícas do blog com mais atenção, pois configurei o Google Analytics. Por lá, que boa parte dos visitantes daqui do blog, chegam nele pelo Google, e atrás de artigos sobre SmartGWT. Eu sempre postei notícias sobre os lançamentos aqui, mas nunca tinha feito um artigo sobre. Esse é o primeiro, e acredito que será o início de uma série deles.
Irei mostrar como configurar um projeto já criado para funcionar com SmartGWT. Já escrevi um artigo a algum tempo mostrando como configurar o Eclipse com o plugin do Google e criar um projeto do Eclipse com ele. Esse artigo explica como utilizar o Google Plugin com o GWT 1.6, mas ele funciona muito bem com o 1.7.*, e também funciona com o GWT 2.0 MS2. E o artigo foi testado e escrito se baseando no SmartGWT 1.3.
Para configurar o SmartGWT em um projeto já criado, siga os seguintes passos:
- Baixe o SmartGWT do seguinte local: http://code.google.com/p/smartgwt/
- Descompacte o arquivo .zip e copie o arquivo smartgwt.jar para o diretório “war/WEB-INF/lib” do seu projeto.
- Dê um refresh em seu projeto (clique em cima do nome dele no Package Explorer e pressione F5).
- Vá em “Configure Build Path” (botão direito em cima do projeto no Package Explorer, Build Path, Configure Build Path).
- Vá em Libraries, clique em “Add Jar” e adicione o smartgwt.jar a lista de bibliotecas.
- Vá no arquivo de configuração do módulo (um que termina com a extensão *.gwt.xml) e adicione a seguinte linha: “<inherits name=’com.smartgwt.SmartGwt’/>”
- Vá no arquivo html(o que a aplicação carrega por padrão quando ela inicia) e adicione a seguinte linha dentro do HEAD: “<script> var isomorphicDir = “[NOME_DO_MODULO]/sc/”; </script>”. O “[NOME_DO_MODULO]” deve ser substituído pelo mesmo nome que está no arquivo “.gwt.xml”. Lá ele está no atributo rename-to da tag module.
Com isso o projeto já deve funcionar com o SmartGWT. Se quiser um exemplo pronto para teste, cole o seguinte conteúdo em seu EntryPoint, adicionando as linhas dentro do seu onModule.
Button btn = new Button("Clique");
btn.addClickHandler(new ClickHandler() {
public void onClick(ClickEvent event) {
Window.alert((String) txt.getValue());
}
});
DynamicForm form = new DynamicForm();
form.setFields(txt);
VLayout v = new VLayout();
v.addMember(form);
v.addMember(btn);
v.draw();
Salve e tente rodar o exemplo. Caso funcionar corretamente, irá aparecer uma caixa de texto com um botão. Quando clicar no botão, irá aparecer em um alert o que foi digitado no campo de texto.
Introdução ao UIBinder do GWT 2.0
Uma das grandes novidades do GWT 2.0 é o UIBinder. UIBinder é uma funcionalidade que permite que você separe o layout da aplicação da parte de “negócio”(validações, interações com o servidor, etc.). Permite que você deixe toda a parte de layout separadas em arquivos XML, deixando para os arquivos Java (que irão ser compilados e transformados em Javascript) somente o que importa do código. Essa funcionalidade facilita bastante as coisas, pois melhora o entendimento e a ajuda na hora de dar manutenção no código fonte das telas. Aposto que quem já utilizou JSF (principalmente o 2.0) e o Adobe Flex, irá se sentir em casa.
Vou dar um exemplo simples, que não é um Hello World como você conhece. È só um formulário com dois campos, que adiciona tudo o que é preenchido em uma tabela. Não envolve comunicação com o servidor e nem nada. È só para dar pano de fundo para mostrar como funciona todos os elementos que fazem o UIBinder funcionar. Bom, vamos parar de blá blá blá e vamos para o que interessa.
Primeiramente, vamos configurar o módulo do UIBinder no GWT 2.0. Acredito que você já tenha um projeto GWT 2.0 criado e funcionando neste momento. Se não tiver, leia antes o tutorial que escrevi sobre. Para configurar e habilitar o UIBinder no GWT 2.0, apenas adicione a seguinte linha no seu arquivo de configuração do GWT(*.gwt.xml) :
<inherits name=’com.google.gwt.uibinder.UiBinder’/>
Depois disso vamos criar o arquivo de tela. O nome que estou dando para o mesmo é HelloWorld(tá, é um Hello World) que está no pacote ‘com.serathiuk.gwt2teste.client’ no meu caso. Sinta-se livre para mudar. O nome do arquivo será HelloWorld.ui.xml. Detalhe para o ‘ui.xml’, pois esse é o padrão da framework.
<!– Arquivo HelloWorld.ui.xml –>
<?xml version=”1.0″ encoding=”UTF-8″?>
<ui:UiBinder xmlns:ui=’urn:ui:com.google.gwt.uibinder’
xmlns:g=’urn:import:com.google.gwt.user.client.ui’>
<g:HTMLPanel>
Nome: <g:TextBox ui:field=”txtNome” /><br/>
E-mail: <g:TextBox ui:field=”txtEmail” /><br/>
<g:Button ui:field=”btnTeste” text=”Teste” />
<br/>
<g:FlexTable ui:field=”flexTable”/>
</g:HTMLPanel>
</ui:UiBinder>
Agora iremos criar o arquivo HelloWorld.java, que se encontra no mesmo pacote que o arquivo de tela(HelloWorld.ui.xml).
package com.serathiuk.gwt2teste.client;
import com.google.gwt.core.client.GWT;
import com.google.gwt.event.dom.client.ChangeEvent;
import com.google.gwt.event.dom.client.ClickEvent;
import com.google.gwt.uibinder.client.UiBinder;
import com.google.gwt.uibinder.client.UiField;
import com.google.gwt.uibinder.client.UiHandler;
import com.google.gwt.user.client.Window;
import com.google.gwt.user.client.ui.Button;
import com.google.gwt.user.client.ui.Composite;
import com.google.gwt.user.client.ui.FlexTable;
import com.google.gwt.user.client.ui.TextBox;
import com.google.gwt.user.client.ui.Widget;
public class HelloWorld extends Composite {
interface Binder extends UiBinder {}
private static Binder binder = GWT.create(Binder.class);
@UiField Button btnTeste;
@UiField TextBox txtNome;
@UiField TextBox txtEmail;
@UiField FlexTable flexTable;
public HelloWorld() {
initWidget(binder.createAndBindUi(this));
}
@UiHandler(“btnTeste”)
public void onClickBtnTeste(ClickEvent event) {
int num = flexTable.getRowCount();
flexTable.setText(num, 0, txtNome.getValue());
flexTable.setText(num, 1, txtEmail.getValue());
}
@UiHandler(“txtNome”)
public void onChangeTxtNome(ChangeEvent event) {
Window.alert(txtNome.getValue());
}
}
E como ficou meu onModuleLoad do meu EntryPoint:
RootPanel.get().add(new HelloWorld());
}
O UIBinder funciona da seguinte maneira. No arquivo XML da tela, temos os componentes TextBox txtNome e txtEmail e existe um Button chamado btnTeste. Também tem uma FlexTable com o nome flexTable. Você já deve ter percebido que todos esses componentes tem o atributo “ui:field”. Esse atributo é responsável por dizer qual será o atributo da classe Java que aquele componente representa. Na classe Java, temos os atributos txtNome, txtEmail, btnTeste e flexTable também, e eles estão anotados com a annotation “UIField”. Essa anotação é responsável por dizer que aquele atributo representa um componente na tela. O atributo deve ter o mesmo nome que o correspondente na tela, e não pode ser private. Você não precisa se preocupar em instanciar esse atributo, pois via Injeção de Dependência, o próprio GWT se encarrega disso. Você pode trabalhar normalmente com o componente, mudando tamanho, configurações, etc… pelo Java. Mas recomendo deixar essas coisas para o arquivo de tela.
Para adicionar um evento a um componente é simples. É criado um método, com qualquer nome que desejar, e utiliza a annotation ‘UiHandler’ neste método. Essa annotation irá receber um valor, que é o componente da tela que ele representa. Em nosso exemplo existem 2. O ‘onClickBtnTeste’ e o ‘onChangeTxtNome’, que poderiam ser trocados facilmente por ‘aoClicarNoBtnTeste’ e ‘aoAlterarTxtNome’. Vai do gosto do freguês. E eles sempre iriam ser chamados quando o botão fosse clicado no primeiro caso, ou quando o nome fosse alterado, no segundo caso.
Mas você deve estar se perguntando: “O nome do método pode ter o nome que eu desejar, e o campo Nome pode ter mais de um tipo de evento, mas não é especificado na annotation qual evento que eu quero. Como ele sabe é aquele método deve ser chamado no onChange?”. È pelo parâmetro que é passado no método. No caso do onClickBtnTeste, ele recebe como parâmetro um objeto da classe ClickEvent, enquanto o onChangeTxtNome recebe como parâmetro um objeto da classe ChangeEvent. Se um dia resolver mudar o tipo de evento que aquele método representa, basta apenas alterar o parâmetro para o correspondente da ação que você deseja.
Lembrando que no objeto do parâmetro vem muitas informações úteis, como o componente que invocou esse evento, funcionalidade de parar o evento e algumas coisas a mais.
Acho que deu para entender como começar a utilizar o UIBinder. Acredito que ele se tornará o novo padrão para desenvolvimento com GWT, e acredito que nas próximas versões do Google Plugin, teremos mais facilidades para utiliza-lo. Não demorará muito para aparecer RAD’s utilizando a tecnologia.
Qualquer crítica, sugestão e essas coisas entrem em contato.
Utilizando o Google Web Toolkit(GWT) 2.0 Milestone 2 no Eclipse com Debug
No último artigo, mostrei como configurar uma aplicação GWT 2.0 no Eclipse, com o Google Plugin, mas o Debug não funciona corretamente utilizando aquela configuração. È preciso algumas alterações para a aplicação funcionar corretamente. O tutorial leva em conta que você seguiu todos os passos do tutorial anterior.
1) Vá nas configurações de Build Path, Libraries e adicione o gwt-servlet.jar e dê um ok.
2) Vá em Run Configurations, crie um novo em “Java Application”.
3) Em Project coloque o projeto atual.
4) Em Main Class, coloque a classe ‘com.google.gwt.dev.DevMode’.
5) Marque os items “include system libraries…” e o “Include Inherited mains…”
6) Mude para aba arguments
7) Em “Program arguments” coloque o seguinte valor: “-startupUrl <Arquivo HTML> <Endereço do Arquivo XML do GWT>”. Ex.: “-startupUrl GWT20Teste.html com.serathiuk.gwt2teste.GWT20Teste”
8) Em VM Arguments coloque o valor: “-Xmx256M”
9) Em Classpath, em Users Entries, adicione o gwt-servlet.jar, a biblioteca do GWT e o diretório src da aplicação.
10) Dê um Run e teste agora.
Utilizando Google Web Toolkit(GWT) 1.6 com o Eclipse Ganymede
Como prometido em janeiro, começo a série de tutorias sobre GWT. Faz tempo que tinha postado que iria começar a postar sobre, mas resolvi esperar sair a versão 1.6 do GWT. Demorou mais que eu esperei essa versão, mas saiu e com algumas novidades bacanas e coisas que eu nem esperava. Eu já tinha um esboço pronto deste primeiro tutorial. Mas tinha escrito ele para utilizar GWT 1.5 com Cypal Studio. Mas o Google lançou um plugin próprio para utilizar GWT no Eclipse. Então resolvi reescrever o tutorial. Tentei deixar o mais simples e objetivo possível. Acredito eu que consegui atingir isso. Estou levando em conta que você já possui o Eclipse Ganymede(3.4) em sua máquina. Caso não possua, vá em http://www.eclipse.org/downloads e baixe o ‘Eclipse IDE for Java EE Developers’.
Instalando o Google Plugin
- Com o Eclipse aberto, vá em Help/Software Updates
- Entre na aba ‘Avaliable Software’
- Clique em ‘Add Site’
- Coloque o endereço http://dl.google.com/eclipse/plugin/3.4 e clique em OK
Tela Cadastro Plugin Eclipse
- Marque todos os item como na imagem e clique no botão Install.
Tela Seleção Modulos Plugin GWT
- Espere ele verificar e baixar os requisitos e pendências (esta parte pode demorar)
Tela Procurando Pendencias GWT
- Depois disso é só dar um Next, aceitar os termos(faça de conta que você leu) e clique em Finish.
- Depois disso ele vai instalar o plugin e acabou aí. Reinicie o Eclipse e o plugin já vai estar disponível para uso.
Criando e testando um projeto GWT
- Com o Eclipse aberto, vá em File / New / Other
- No item Google, selecione ‘Web Application Project’ e clique em Next.
Seleção Tipo Projeto GWT
- Em Project Name coloque o nome do projeto(utilizei ProjetoTeste) e em Package preencha o pacote da Aplicação(utilizei com.serathiuk.teste.projetoteste). Deixe tudo marcado como está e clique em Finish.
Tela Configuração Projeto GWT
- Pronto. O projeto está criado. Vamos testa-lo.
- Para testa-lo, vá em Run / Run Configuration
- Selecione o item com o nome do projeto em Web Application.
Tela Rodar Aplicação GWT
- Clique em Run.
- Se funcionar tudo ok, irá aparecer uma janela como a da imagem.
Tela Hosted Mode GWT
Considerações finais
Este artigo tinha como intuito dar o primeiro pontapé no GWT. Não foi feito nada demais, só rodamos um exemplo já existente. Mas no próximo pretendo escrever como fazer um formulário simples acessando dados do servidor. Mas é isso. Espero que tenham gostado e critiquem a vontade nos comentários.
Série de Artigos sobre GWT(Google Web Toolkit)
Olá. Vou começar a escrever e postar aqui no blog uma série de artigos sobre GWT. Já estou escrevendo o primeiro e pretendo escrever mais. Mas antes de terminar o primerio e começar a postar aqui este artigos, resolvi dar uma introdução sobre e explicar o que planejo.
Primeiramente digo que de inicio pretendo “começar pelo início”. O que isso quer dizer? Pretendo começar com artigos básicos sobre como utilizar o GWT, configurar o GWT no Eclipse(se for necessário aprofundo falando sobre Netbeans, IntelliJ ou outra IDE), utilizar Remote Services, utilizar os componentes básicos do GWT, utilizar com PHP no lado Servidor e etc. Ou seja, pretendo que tudo funcione como fosse um livro que cada post seja um capítulo por exemplo.
Mas pretendo ir além do “GWT Puro”. Pretendo também falar também sobre SmartGWT e GWT-EXT. Mas das 2 vou dar mais preferência para os SmartGWT. Motivos para isso no post “SmartGWT 1.0b1 lançado“.
O primeiro da série ainda não tenho previsão para postagem. Mas acredito que até Quarta ele esteja pronto. Mas enquanto isso, vai alguns link’s para servir de introdução do assunto.
GWT:
http://code.google.com/intl/pt-BR/webtoolkit/
http://www.gwt.com.br/
GWT-EXT:
http://www.gwt-ext.com/
http://www.extjs.com/
SmartClient:
http://www.smartclient.com/smartgwt
http://www.smartclient.com
SmartGWT/GWT-EXT:
http://www.jroller.com/sjivan/
Ps.: Mesmo com essa série de artigos sobre GWT, pretendo ainda continuar a postar minhas inutilidades. Nem repare.
SmartGWT 1.0b1 lançado
A alguns dias atrás foi lançado(depois de algum tempo que foi anunciado o projeto) o SmartGWT. O SmartGWT é um wrapper dara SmartClient, que traz novos componentes, mais parecidos com desktop, para o GWT(Google Web Toolkit). Esse projeto é de autoria de Sanjiv Jivan, o mesmo que criou o GWT-EXT, que é um wrapper para o ExtJS.
Apesar de não ter utilizado ainda o SmartGWT, o que tenho que dizer é que é um projeto bem promissor e na sua primeira versão parece superar o GWT-EXT em muitos quesitos. O maior dele, acredito eu, seja os memory leak’s. A Isomorphic Software, empresa que desenvolve o SmartClient, diz que o mesmo é livre de memory leak’s. E pelos clientes deles, acredito que eles não iam falar apenas pelo “marketing”. Para quem utiliza GWT-EXT ou até mesmo ExtJS, sabe que o mesmo tem graves problemas com referências circulares em JS, “orphan nodes” e outras coisas. Para aplicações realmente grandes, isso se torna um grande problema, por a aplicação ficar acumulando a memória do navegador com coisas que deveriam ser eliminadas.
Para a versão 3(ou 2.3, não me lembro) do ExtJS, eles prometem acabar com esses problemas. Mas temos um problema aí. A licença. Até a versão 2.0.2 do ExtJS tinhamos uma licença como LGPL. A partir da versão 2.1, a licença foi alterada para GPLv3. E GPLv3 é(me corrijam se eu estiver errado) uma licença que te obriga a compartilhar o código, e “contamina” todos os projetos que utiliza código licenciado com a mesma. Ou seja, é uma licença que não serve para ser utilizada comercialmente, pois nesse caso o código necessita ser restrito, para grande parte das aplicações(não, o mundo não é tão ideal como o Stallman quer). E nesse caso, por caso disso, o GWT-EXT não pode acompanhar a evolução do ExtJS. O GWT-EXT ficou restrito a versão 2.0.2 do ExtJS, a última em LGPL. E no caso do ExtJS, ele tem LGPL misturado com uma licença própria, que impede de criar um fork do ExtJS. Então o melhor a ser feito foi tentar corrigir os problemas do ExtJS via GWT-EXT, para as aplicações que já existem não ficarem ser suporte e criar algo novo que possa ser evoluir para novos usuários. E aí que entra o SmartGWT.
O SmartClient era de código fechado até 2007. Eles da Isomorphic abriram o código e licenciaram como LGPL. E prometem mante-lo assim. E apoiam o projeto do SmartGWT. Ou seja, tudo caminha para que o SmartGWT seja uma ótima alternativa para o GWT-EXT. Tudo isso se os Lordes de Kobol concordarem. heheeh.
Links:
SmartGWT: http://code.google.com/p/smartgwt/
SmartClient: http://www.smartclient.com/
Sobre o Blog
Olá. Se você visita regularmente o blog(diferente do autor que não faz isso), você deve ter notado que ele está um tanto que desatualizado. Faz um bom tempo que não postava nada de novo. Pois bem. Pretendo fazer isso mudar.
Meu grande problema com o blog é que eu estava me centrando em postar apenas “coisas da profissão”, ou seja, coisas sobre desenvolvimento de software e afins. Pois bem. Resolvi mudar isso. Vou continuar postando sobre quando achar algo interessante, mas também vou abrir o leque de assuntos. Vou começar a postar sobre tudo o que acho interessante. Claro que não vou transformar o blog num “Jacaré Banguela”, “Kibe Loco” e afins e postar um monte de coisas engraçadas aleatoriamente(não que eu ache isso ruim). Vou apenas abrir o leque de assunto, como já disse. Falar sobre música, cinema, séries, etc. Ou seja, postar tudo o que vim na cabeça e eu achar que mereça estar aqui. Logo logo o blog terá novidades e terá menos teias de aranhas. heheh.