Blog do Aracomp

Aplicação da biblioteca Allegro no jogo Batalha Naval

2011-04-02T18:07:00.005-03:00

BIBLIOTECA ALLEGRO

O QUE É?

A Allegro é uma biblioteca criada para o desenvolvimento de jogos e aplicações multimídia. É uma plataforma transversal e trabalha com muitos compiladores diferentes. É gratuita, não há limitação de uso e é fácil de usar. Com ela pode ser inserido varias funções como: imagens, temporizador, entradas de dados: mouse, teclado e joystick, saída de vídeo: gráficos e texto.

Foi criada por Shawn Hargreaves que hoje trabalha na Microsoft. Sua intenção era de fazer uma biblioteca de código simples para que o iniciante na área de programação de jogos não precisasse ler uma grande quantidade de livros.

COMO INSTALAR ALLEGRO NO AMBIENTE LINUX?

Há duas maneiras de instalar a biblioteca.

-Primeira :

No Desktop siga os seguintes passos:

SYSTEM – ADMINISTRATION – SYNAPTIC PACKAGE MANAGER

Faz uma busca pelo nome allegro. Dos pacotes disponíveis, instala o pacote liballegro4.2-dev. Após baixá-lo a biblioteca estará instalada.

Figura1: Baixando o pacote pelo Synaptic Package Manager.

-Segunda:

Abra o terminal e digite: sudo apt-get install liballegro4.2-dev. Logo após, o programa pedirá o password, então digite-o. Com isso, a biblioteca será instalada.

Figura 2: Baixando o pacote pelo terminal.

EXEMPLO DE APLICAÇAO DA ALLEGRO:

Jogo Batalha Naval

O jogo Batalha Naval foi desenvolvido com aplicações da biblioteca Allegro em código fonte C. Nele precisamos incluir alguns comandos da Allegro que formam o laço principal do jogo e que sem eles não conseguiríamos utilizar nenhuma função da mesma.

São eles:

#include < allegro.h> // inclui a biblioteca

allegro_init(); //inicia a biblioteca allegro

set_color_depth(); // configuração de cores

set_gfx_mode(); // configuração de vídeo

Sendo os três últimos comandos dentro da função principal.

Para se usar as imagens necessárias, inicialmente criamos um ponteiro que aponta para todas as imagens da memória utilizadas no jogo. Esse ponteiro aponta para o tipo BITMAP, que é um formato de arquivo gráfico.

BITMAP *imagem[5];

Onde:

Imagem[0] é um buffer;

Imagem[1] é o desenho do fundo;

Imagem[2] é o desenho da água;

Imagem[3] é o desenho do barco;

Imagem[4] é o desenho da tábua;

Com o comando create_bitmap(); definimos o tamanho da imagem que queremos carregar na memória. Onde passamos como argumentos, a largura e a altura da imagem, respectivamente.

imagem[1] = create_bitmap (800, 600);

Com o comando load_bitmap(); carregamos a imagem na memória. Onde passamos como argumentos, o caminho da imagem e a paleta de cores, respectivamente.

imagem[1] = load_bitmap ("tiles/back0.bmp", NULL);

Executando estes dois comandos em cada imagem usada no jogo.

Porém, os comandos acima não são suficientes para exibição na tela, pois apenas servem para declarar, definir e carregar a imagem.

Então usamos uma das três funções que são responsáveis por desenhar a imagem na tela: a função blit();.

Esta função é responsável por “copiar” uma imagem ‘origem’ em uma imagem ‘destino’, especificando as posições de ambas, e em seguida o tamanho final.

blit( imagem[1], imagem[0], 0, 0, 0, 0, 800, 600); // “copiando” a imagem[1] e “colando” no buffer...

blit(imagem[0], screen, 0, 0, 0, 0, 800, 600); // “copiando” a imagem final e “colando” na tela.

Essa função recebe como argumentos:

1. Imagem de origem: imagem[0]

2. Imagem de destino: screen

3. Posição x da imagem de origem: 0

4. Posição y da imagem de origem: 0

5. Posição x da imagem de destino: 0

6. Posição y da imagem de destino: 0

7. Largura final da imagem copiada: 800

8. Altura final da imagem copiada: 600

Com isso, podemos ver o fundo do jogo.

Figura 3: Imagem fundo na tela.

Para desenhar os tabuleiros, temos q repetir a mesma operação, sempre respeitando as posições das imagens.

Com uma função de repetição formamos uma matriz 10 x 10 de imagens tábua. Jogando as mesmas no buffer.

blit( imagem[3], imagem[0], 0, 0, x, y, 30, 30); onde x e y variam de acordo com a posição de cada imagem de tábua na tela.

Figura 4: Imagens tábua formando um tabuleiro no buffer.

E novamente com o comando blit();, ‘copiamos’ a imagem do tabuleiro no buffer e jogamos na tela.

Figura 5: Exibição do primeiro tabuleiro na tela.

blit(imagem[0], screen, 0, 0, 50, 150, 300, 300); // comando do primeiro tabuleiro.

Figura 6: Exibição dos tabuleiros.

blit( imagem[0], screen, 0, 0, 450, 150, 300, 300); // comando do segundo tabuleiro.

Com tudo, precisamos fazer com que as figuras da água e do barco apareçam com o decorrer do jogo.

Basta usar o mesmo comando blit();, jogar a imagem da água ou barco no buffer e depois na tela, fazendo com que esta substitua a posição da imagem tábua numa determinada posição de acordo com o decorrer do jogo.

Figura 7: Exibição do barco e da água nos tabuleiros.

Mas, além das figuras, o jogador precisa ter informação referente ao jogo. Para isso é necessário colocar texto.

Então usamos a função textprintf_ex(); Para exibir textos na tela.

Figura 8: Exibição de textos na tela.

textprintf_ex(screen,font,170,460,makecol(255,255,255),-1,”PARABÉNS VOCÊ VENCEU!!!");

textprintf_ex(screen,font,170,480,makecol(255,255,255),-1,"Deseja Jogar Novamente? 1- SIM, 2- NÃO");

Essa função recebe como argumentos:

- Destino do texto: screen

- Tipo da fonte: font //sempre usamos esse tipo de fonte, pois é a fonte padrão da Allegro.

- Posição x e posição y da fonte na tela: 170, 480.

- Cor do texto: makecol(225,225, 255) - (Branca)

- Cor de fundo do texto: -1 - (Transparente)

- Texto: “Deseja jogar novamente? 1- SIM, 2 - NÃO”

Essa função makecol(); é responsável por indicar cores. Ela é composta de 3 trios de valores separados por uma vírgula.

O primeiro trio é a “quantidade” de vermelho, o segundo é a quantidade de “verde”, e o terceiro é a quantidade de “azul”. Sendo este tipo de ‘colorido’ chamado de RGB.Com seus valores variando de 000 – 225. E para um fundo transparente ao invés de usar a função makecol(); utiliza- se o valor -1 no argumento.

E para finalizar, usamos a função allegro_exit();.

COMO COMPILAR

gcc < nomedoarquivo>.c -o < nomedojogo>`allegro-config --libs`

Figura 9: Compilar usando allegro.

CONCLUSÃO:

A biblioteca Allegro é de grande ajuda para quem quer utilizar interface gráfica, mas não tem muito domínio em programação. E sendo ela voltada principalmente para o desenvolvimento de jogos, torna-a uma boa alternativa comercial, já que o mercado de jogos cresce bastante. Como os comandos da biblioteca são bem práticos e de simples aplicação, facilita o desenvolvimento do código, tornando-se uma boa ferramenta para programadores iniciantes em aplicações gráficas.

AGRADECIMENTOS:

Bruno Rafael

Emanuel Franco

BIBLIOGRAFIA:

http://www.bdjogos.com/linguagens.php?id=3

http://www.lcg.ufrj.br/Cursos/mab604/allegro/view

http://www.tuliofaria.net/arquivos/Artigo_Allegro.pdf

TUTORIAL FEITO POR:

CECÍLIA MAYARA G. DA SILVA

FLAVIANY RODRIGUES PINHEIRO

LARISSE VITAL DA SILVA

Tutorial SQL

2010-12-14T19:36:00.030-03:00

TUTORIAL SQL

SUMARIO

1. INTRODUÇÃO

2. SINTAXE
3. DDL E DML
4. DDL E RESTRIÇÕES DO CREATE
5. DML
5.1 SELECT
5.2 SELECT DISTINCT
5.3 CLAUSULA WHERE
5.4 OPERADORES AND E OR
5.5 ORDER BY
5.6 INSERT
5.7 UPDATE
5.8 DELETE
6. FUNÇÕES
6.1 AVG
6.2 COUNT
6.3 FIRST
6.4 LAST
6.5 MAX
6.6 MIN
6.7 SUM
7. BIBLIOGRAFIA

SQL

SQL é uma linguagem padrão para acessar e manipular bancos de dados.

O que é SQL?

Structured Query Language, ou Linguagem de Consulta Estruturada ou SQL, é uma linguagem de pesquisa declarativa para banco de dados relacional (base de dados relacional. Muitas das características originais do SQL foram inspiradas na álgebra relacional.
SQL é um padrão ANSI (American National Standards Institute)

O que pode fazer o SQL?

Com SQL podemos recuperar dados, inserir, atualizar e excluir registros, além de criar novas bases de dados e também criar novas tabelas, novos procedimentos e novas visões de um banco de dados. SQL pode também definir permissões em tabelas, procedimentos e visões.

Sintaxe SQL

Tabelas de banco de dados

Um banco de dados na maioria das vezes contém uma ou mais tabelas. Cada tabela é identificada por um nome. As tabelas contêm registros (Tuplas) com dados.
Abaixo está um exemplo de uma tabela chamada "Pessoas":

A tabela acima contém três Tuplas, com cinco colunas (Id, Apelido, Nome, Endereço e Cidade).

Instruções SQL

A maioria das ações que você precisa para executar em um banco de dados é feito com instruções SQL. A seguinte instrução SQL selecionará todos os registros na tabela Pessoas:

• SELECT * FROM Pessoas

Sintaxe
SELECT * FROM

DDL e DML

SQL pode ser dividida em duas partes: A Data Definition Language (DDL) e a Data Manipulation Language (DML).

DDL (Linguagem de Definição de Dados)

Uma DDL permite ao utilizador definir tabelas novas e elementos associados.

Os comandos básicos da DDL são três (CREATE, ALTER, DROP):

• CREATE DATABASE - Cria um novo banco de dados
• ALTER DATABASE - Altera um banco de dados
• CREATE TABLE - Cria uma nova tabela
• ALTER TABLE - Altera uma tabela
• DROP TABLE - Apaga uma tabela
• CREATE INDEX – Cria um Índice (chave de busca)
• DROP INDEX - Exclui um índice

DML (Linguagem de Manipulação de Dados)

São utilizados para realizar inclusões, consultas, exclusões e alterações de dados presentes em registros.

• SELECT - Extrai dados de um banco de dados.
• UPDATE - Atualiza dados em um banco de dados.
• DELETE - Apaga dados de um banco de dados.
• INSERT INTO - Insere novos dados em um banco de dados.

OBS: Não confunda Alter com Update e Drop com Delete! Alter e Drop são para manipular a estrutura das tabelas e Update e Delete para manipulação de tuplas)!!!

DDL (Linguagem de Definição de Dados)

Para exemplificarmos os comandos de DDL comentados acima, faremos abaixo um schema para criação de um BD de uma loja chamada loja1 e criaremos uma tabela chamada Pessoas. Com esses comandos seremos capazes de criar e apagar qualquer BD e tabelas.

• create database Loja1
• create schema Loja1

Os Comandos acima são para criação de um schema ou database do nosso BD(Ambos comandos realizam a mesma função).

• CREATE TABLE `loja1`.`Pessoas` (
`ID` INTEGER UNSIGNED NOT NULL AUTO_INCREMENT,
`Apelido` VARCHAR(45) NOT NULL,
`Nome` VARCHAR(45) NOT NULL,
`Endereço` VARCHAR(45),
`Cidade` VARCHAR(45),
PRIMARY KEY (`ID`)
)

Para apagarmos a tabela é só usar DROP TABLE PESSOAS. Lembre-se que se apagar a tabela tudo que ela a conter será apagada também!
Para apagarmos a database é só usar DROP DATABASE LOJA1.

O comando acima criará uma tabela Pessoas na databarse loja1 com os atributos id, apelido, nome, endereço, cidade com seus tipos (integer e varchar) e suas restrições (not null e auto_increment).

Restrições de Integridade na Clausula Create

• not null: indica que ao atributo não pode ser atribuído o valor null(nulo).
• primary key ( A1,..., An): Indica os atributos que formam a chave primária.
• check(P): verifica que em todo momento o predicado P se satisfaça na relação.
• unique: indica que o atributo deve ter um valor único em cada tupla, i,e, chave secundaria.
• foreign key A1 references R(B1): indica que o atributo A1 é chave estrangeira e referencia o atributo B1 de uma tupla da relação R.

DML (Linguagem de Manipulação de Dados)

SELECT

A instrução SELECT é usada para selecionar dados de um banco de dados. O resultado é armazenado em uma tabela e é mostrada na tela.

Sintaxe
SELECT FROM WHERE

Veja que o comando abaixo selecionou o Id, o Apelido e o Nome de todos da tabela Pessoas e o resultado foi armazenado em uma nova tabela e retornado na tela. O comando WHERE só precisa ser usado se quisermos colocar alguma condição, veremos mais abaixo.

SELECT id, apelido, nome FROM pessoas

Note que o * no comando abaixo faz selecionar todas as tuplas e atributos da tabela Pessoas

SELECT * FROM Pessoas

SELECT DISTINCT

Em uma tabela, algumas das colunas podem conter valores duplicados. Este não é um problema, no entanto, às vezes você vai querer listar apenas os distintos (diferentes) valores em uma tabela.
A palavra-chave DISTINCT pode ser utilizada para retornar apenas distintos (diferentes) valores.

Sintaxe
SELECT DISTINC FROM

Agora queremos selecionar apenas os valores distintos na coluna chamada "Cidade" da tabela Pessoas mostrada acima.

• SELECT DISTINC cidade FROM Pessoas

Note que não aprece a duplicação da Cidade Arapiraca

Cláusula WHERE

A cláusula WHERE é usada para extrair apenas os registros que satisfazem o critério especificado.

Sintaxe
SELECT FROM WHERE

Agora vamos selecionar o id e o nome da pessoa com id = 2.

SELECT Id, nome FROM pessoas WHERE id=2

Note que o Where só retorna as tuplas que satisfaz a condição dada acima.

Com a cláusula WHERE, os seguintes operadores podem ser usados:

OPERADORES AND E OR

Os operadores AND e OR são usados para filtrar registros com base em mais de uma condição. O operador AND exibe um registro se a primeira e segunda condição for verdadeira. O operador OR exibe um registro se a primeira ou a segunda condição for verdadeira.

Sintaxe

SELECT FROM WHERE

Agora Vamos selecionar apenas as pessoas com o nome igual a "João" e o apelido igual a "Cabeção":

SELECT * FROM Pessoas WHERE nome= 'João' AND Cidade= 'Arapiraca'

ORDER BY

A palavra-chave ORDER BY classificar os registros em ordem crescente por padrão. Se você quiser classificar os registros em ordem decrescente, você pode usar a palavra chave DESC.

Sintaxe
SELECT FROM ORDER BY

Agora queremos selecionar todas as pessoas da tabela acima, no entanto, queremos ordenar as pessoas por seu nome.

SELECT * FROM Pessoas ORDER BY Nome

Observe que a tabela ficou ordenada pelo atributo nome.

Agora queremos selecionar todas as pessoas da tabela acima, no entanto, queremos ordenar as pessoas por seu ID em ordem decrescente.

SELECT * FROM Pessoas ORDER BY ID DESC

Observe que a tabela ficou ordenada pelo atributo ID.

INSERT INTO

A instrução INSERT INTO é utilizada para inserir uma nova linha em uma tabela. É possível escrever a instrução INSERT INTO em duas formas (sintaxes).
A primeira forma não especifica o nome da coluna onde os dados serão inseridos, apenas os seus valores:

Sintaxe 1
INSERT INTO Nome_Tabela VALUES (valor1, valor2, valor3,...)

Sintaxe 2
INSERT INTO Nome_Tabela(coluna1,coluna2, coluna3,...)
VALUES (valor1, valor2, valor3,...)

Agora Vamos inserir uma nova linha na tabela Pessoas com cada sintaxe.

INSERT INTO Pessoas
VALUES (4,’Hulk’, 'Marcelo', 'Rua M 24', 'Maceió')

INSERT INTO Pessoas (Id, Apelido, Nome,)
VALUES (5, 'Chorão', 'Junior')

Note que com a sintaxe 2 podemos deixar algum atributo sem valor, só temos que observar as restrições da tabela! Quando criamos essa tabela na pagina 6 note que não colocamos restrição nenhuma nesses 2 atributos.

UPDATE

A instrução UPDATE é usada para atualizar registros em uma tabela.

Sintaxe
UPDATE nome_tabela
SET atributo1 = valor1, atributo2 = valor2,...
WHERE

Observe a cláusula WHERE no UPDATE. A cláusula WHERE especifica o registro ou registros que devem ser atualizadas. Se você omitir a cláusula WHERE, todos os registros serão atualizados!

Agora queremos atualizar os dados do "Junior" da tabela Pessoas.

UPDATE Pessoas
SET (Endereço = 'Rua J 100', Cidade = 'Lagoa da Canoa')
WHERE Id = 5 AND nome='Junior'

Tenha cuidado ao atualizar registros, pois, você pode cometer erros como o mostrado abaixo.

UPDATE Pessoas SET Cidade='Maceió'

Com o código acima atualizamos erroneamente a cidade de todas as pessoas, pois não colocamos a condição de qual tupla seria atualizada.

DELETE

A instrução DELETE é usado para excluir registros em uma tabela.

Sintaxe
DELETE FROM nome_tabela
WHERE

Agora vamos eliminar a pessoa João da tabela Pessoas.

DELETE FROM Pessoas
WHERE nome=’João’

Podemos apagar também todos os atributos da Tabela sem afetar sua estrutura.

DELETE FROM Pessoas

Veja que todas as pessoas foram excluídas, mas a estrutura da tabela não foi alterada!

Funções

Funções agregadas SQL retornar um único valor, calculado a partir dos valores em uma coluna.

• AVG - Retorna o valor médio
• COUNT - Retorna o número de linhas
• FIRST - Retorna o primeiro valor
• LAST - Retorna o último valor
• MAX - Retorna o maior valor
• MIN - Retorna o menor valor
• SUM - Retorna a soma

AVG

O AVG retorna o valor médio de uma coluna numérica.

Sintaxe
SELECT AVG (nome_coluna) FROM nome_tabela

Para mostrar o funcionamento vamos aplicar o AVG na coluna salário da tabela abaixo

(SELECT AVG (Salário) FROM Emp_salario

Após ser feita a consulta acima na tabela Emp_salario o resultado será 800.

COUNT

A função count retorna o número de linhas que corresponde a um critério especificado.

Sintaxe
SELECT COUNT (nome_coluna) FROM nome_tabela

Vamos contar quantas pessoas ganham acima de 600,00 da tabela Emp_salario.

SELECT COUNT (Salário) FROM Emp_salario WHERE (salário>600)

Após ser feita a consulta acima o resultado será 3.

FIRST

O FIRST retorna o primeiro valor da coluna selecionada.

Sintaxe
SELECT FIRST (column_name) FROM table_name

Vamos recuperar qual o primeiro valor da coluna salário.

SELECT FIRST (salário) FROM Emp_salario

Após ser feita a consulta acima o resultado será 1000.

LAST

A função last retorna o último valor da coluna selecionada.

Sintaxe
SELECT LAST (nome_coluna) FROM nome_tabela

Vamos recuperar o ultimo valor da coluna salário. Para isso usaremos a consulta abaixo.

SELECT LAST (salário) FROM Emp_salario

Após ser feita a consulta acima o resultado será 600.

MAX

A função max retorna o maior valor da coluna selecionada.

Sintaxe
SELECT MAX (nome_coluna) FROM nome_tabela

Vamos recuperar qual o maior salário da tabela abaixo. Para isso usaremos a consulta abaixo.

SELECT MAX (salário) FROM Emp_salario

Após ser feita a consulta acima o resultado será 1200.

MIN

O MIN retorna o menor valor da coluna selecionada.

Sintaxe
SELECT MIN (nome_coluna) FROM nome_tabela

Vamos recuperar qual o menor salário da tabela acima. Para isso usaremos a consulta abaixo.

SELECT MIN (salário) FROM Emp_salario

Após ser feita a consulta acima o resultado será 500, representando o menor salário existente dos empregados da tabela acima.

SUM

A função SUM retorna a soma total de uma coluna numérica.

Sintaxe
SELECT SUM (nome_coluna) FROM nome_tabela

Vamos recuperar a soma dos salários da tabela abaixo. Para isso usaremos a consulta abaixo.

SELECT SUM (salário) FROM Emp_salario

Após ser feita a consulta acima o resultado será 4000, representado pela soma de todos os salários da tabela acima.

Bibliografia

Elmasri & Navathe
Sistemas de Banco de dados, 4a ed., 2005.
Capítulo 1: Banco de dados e usuários de banco de dados
Capítulo 2: Conceitos e arquitetura do SGBD

C. A. Heuser
Engenharia de Software, 4a ed., 1998.
Capítulo 2 - Introdução

Site de programação em varias linguagens
http://www.w3schools.com/default.asp

Uma Abordagem Simples sobre Adobe Flex!

2010-11-05T15:16:00.008-03:00

Tutorial sobre FLEX

1. Breve Histórico

Adobe Flex, antes chamado de Macromedia Flex e depois rebatizado como Adobe Flex pela Adobe é uma tecnologia lançada em março de 2004 pela Macromedia e suporta o desenvolvimento de aplicações ricas para a Internet (RIAs). Baseada na plataforma do Macromedia Flash, no início era composta por um SDK, um IDE e integração com o J2EE também conhecido como Flex Data Services que é um servidor que fornece uma série de serviços que podem elevar as funcionalidades de uma aplicação FLEX, como:

- serviços de mensageria;

- integração nativa com Hibernate e Enterprise JavaBeans;

- push de dados, sincronia e lock de dados;

Em 2005 a Adobe adquiri a Macromedia e passa a requerer uma licença para o Flex Data Services que, por sua vez, passa a se chamar LiveCycle Data Services;

A mais nova versão do FLEX surgiu em 22 de março de 2010, o FLEX 4.0, que inova na integração da linguagem com o design.

2. O que é?

"É um framework multi-plataforma para desenvolvimento de aplicações RIA, levando um modelo de programação padrão e conhecido por profissionais e desenvolvedores.

Nele usamos uma linguagem de marcação (MXML) que é baseada no XML para definir a interface da aplicação e o Actionscript 3.0 para a parte lógica. As aplicações Flex levam a extensão .mxml e podem ser criadas em qualquer editor de texto comum, como por exemplo o Bloco de Notas."

Fonte: E-genial

O MXML é uma linguagem de marcação baseada em XML introduzido pela primeira vez pela Macromedia em março de 2004. Ele é usado em combinação com ActionScript, que faz a parte lógica da aplicação, para desenvolver aplicativos ricos para internet, além de poder trabalhar com várias linguagens servidor, entre elas pode se destacar o PHP, Java, ColdFusion, ASP.NET.

3. Instalação:

Para começar a programar em FLEX o desenvolvedor possui basicamente dois caminhos a seguir.

Para aqueles que tenham aquele espírito aventureiro, existe a alternativa de baixar gratuitamente a SDK e usar um editor qualquer, que a principio só precisa ser compatível com os padrões do XML, juntos (editor+sdk) é possível desenvolver as famosas aplicações RIA.

Umas das opções de editor encontrado na net seria o “MXML EDITOR” também conhecido por TOMI(The Open Source MXML IDE) que possui entre outras coisas, os destaques das palavras reservadas que tanto nos auxiliam no desenvolvimento.

Entretanto, se o desenvolvedor for do tipo prático e que precisa de facilidade e velocidade, a melhor opção é a ferramenta Flex Builder. Ela foi simplesmente feita para o Flex. Nela encontram-se a sdk e editor prontamente instalados e integrados. Além de possuir a interface amigável do eclipse (o flex builder foi feito com base no eclipse galileo) e todas as facilidades encontradas nas IDEs mais modernas, tais como eclipse e netbeans, e como uma das partes fundamentais do FLEX é o desenvolvimento de interfaces o Flex Builder tambem possui um completo recurso de “Drag And Drop”, no qual facilmente e rapidamente o desenvolvedor pode dispor os elementos que julgar necessário em sua aplicação.

Bem... uma vez que optemos pelo uso do Flex Builder, a instalação é a mais trivial possível, trata-se do clássico “next->next->next... ->finish”.

E o uso da ferramenta é muito semelhante ao do Eclipse, a disposição dos ícones é basicamente a mesma (veja as imagens).

Exemplos:

Como já foi dito, o Flex faz uso de duas linguagens. O MXML para interfaces das aplicações e o ActionScript para a logica que a aplicação necessita ter.

Num mesmo arquivo podemos escrever a interface em MXMLe o programa (entenda por programa a parte do ActionScript) ou ainda deixar em arquivos separados, ou seja, o arquivo MXML precisaria importar os Scripts para que a aplicação funcione corretamente.

Abaixo temos um exemplo trivial de “Hello World!”.

Uma aplicação em MXML, pode ser vista como uma disposição de camadas, chamadas de layers, essas camadas organizam e dão logica para a interface, definindo assim “o que está sobre o que”.

Normalmente temos como camada base de uma interface o “Panel” e sobre o Panel dispomos outras camadas, botões, campos etc.

Explicando o código acima, podemos destacar 3 partes básicas:

1 - Identificação: as duas primiras linhas, que identificam a aplicação e versão da linguagem usada;

2 - Interface: entre as tags encontra-se descrita a interface, que no caso apenas carrega um button;

3 - Script: entre as tags encontra-se o script do programa, que neste caso, apenas implementa uma função que “joga” a palavra “Mundo” na tela, usando uma caixa de alerta, função esta chamada através de um evento de clique no button acima descrito.

O resultado da aplicação descrita resulta na imagem abaixo.

4. Aprofundamento

Para quem se interessar de verdade e quiser conhecer um pouco mais sobre a tecnologia FLEX da Adobe, segue os links:

http://flex.org/

http://www.adobe.com/br/products/flex/

http://www.adobe.com/devnet/flex.html

http://labs.adobe.com/technologies/flex/

5. Conclusão

O Flex possui plataforma com suporte para Windows, Mac e Linux, mostrando-se muito portável. Tem na linguagem MXML grande importância na definição da interface auxiliando no desenvolvimento do código. É de se ressaltar, também, que a integração com vídeo é um ponto forte juntamente com todas as outras ferramentas da Adobe. São disponibilizados Vários plugins gratuitos para a plataforma e a tecnologia possui suporte direto com JAVA e AJAX.

Com tudo isso, por ser uma tecnologia criada pela Adobe, há um forte sentimento em fazer com que ela evolua e se solidifique.

6. Referências

http://blog.mxml.com.br/submetendo-um-formulario-no-flex-usando-o-metodo-get-com-php

http://www.adobe.com/br/products/coldfusion/

http://imasters.uol.com.br/artigo/4551/flex/usando_mxml/

http://www.adobe.com/br/products/flashcatalyst/

http://imasters.uol.com.br/artigo/15510/flex/adobe_flex_4_adobe_flash_builder/

http://imasters.uol.com.br/artigo/14342/flex/novo_flex_4_gumbo/

http://imasters.uol.com.br/artigo/16314/flex/adobe_flex_4_duvidas_que_voce_tem_mas_nao_teve_coragem_de_perguntar/

http://www.igorcosta.com/blog/?p=31

http://www.vedovelli.com.br/?p=62

Tutorial feito por:

Antonio Carlos Pereira Pacheco

Guilherme Oliveira Amorim

Allen Deyjan

Tutorial Flash Lite

2010-10-14T20:17:00.009-03:00

Para começar a desenvolver aplicativos Flash Lite primeiramente você precisa do software Adobe Flash Professional, aqui está o link para fazer o download da versão trial: https://www.adobe.com/cfusion/tdrc/index.cfm?product=flash . Na hora da instalação instale tudo, porque no pacote de instalação inclui um software que tem o objetivo de servir como emulador para dispositivos móveis, o Adobe Device Central.

Para desenvolver aplicativos Flash Lite, é necessário um conhecimento no desenvolvimento de desenhos vetoriais no Adobe Flash Professional para a parte de interface gráfica, e para a parte lógica o conhecimento da linguagem de programação para o Flash, o ActionScript. Neste Tutorial focaremos na linguagem ActionScript. Pode-se encontrar tutoriais ensinando a mexer com o Adobe Flash na literatura e na internet. Neste link você pode encontrar toda a documentação do Flash, tutoriais, AcitonScript e o Flash Lite: http://help.adobe.com/pt_BR/Flash/10.0_Welcome/WS0440A5AD-E290-4bd6-A402-B09F727E9A05.html

Primeiros Passos

Primeiramente execute o software Adobe Device Central. No campo New Document você escolhe a versão do player e a versão do ActionScript:

No Player Version selecione Flash Lite 3.1:

Automaticamente ele seleciona a versão do ActionScript a ser usado. No canto da tela você pode escolher o tipo de aparelho que você queira emular:

No próprio Adobe Device já vem instalado a pasta Flash Lite. Se você deseja usar outros emuladores, no próprio Adobe Device tem uma aba chamada Browse clique nele e irá abrir uma lista de dispositivos:

No campo 2, da pesquisa você digita a marca do aparelho que você deseja desenvolver:

Na lista irá aparecer todos os aparelhos que suportam Flash. Para salvar um desses devices, você criar uma pasta no campo Test Devices. Para criar uma nova pasta é só clicar com o botão direito do mouse no campo e escolher a opção Add New Group:

Irá aparecer uma nova pasta renomeie:

Agora você tem sua própria pasta, para colocar um dos devices na lista que você procurou, clicar no dispositivo escolhido e arrastar para sua pasta:

Escolhi o aparelho Nokia 5200, que suporta a versão Flash Lite 2.0, podendo usar as versões do ActionScript 2.0 e 1.0:

Na aba onde se encontra a opção Browse você clica na aba Create:

Selecione a sua pasta, o device escolhido e clique em Create, abaixo da sua tela. O Próprio Adobe Device irá abrir o Adobe Flash com as especificações do aparelho, como tamanho da tela, versão do Flash Lite e do ActionScript.

Hello World

O Adobe Flash será aberto com as configurações do emulador. Nosso primeiro Hello World será somente código sem necessidade de mexer em desenho vetorial no Adobe Flash.

Na timeline você clica na primeiro frame e vá na aba Window e clique em Action (ou simplesmente tecle F9) para abrir uma janela de edição onde você irá colocar o código ActionScript:

1->Aba Window

2->Abre a janela Action

3->Primeiro Frame

Ao fazer isso abrirá uma janela de edição:

Agora vamos para a parte de codificação:

Primeiro vamos criar um campo de texto, em ActionScript 2.0 usaremos o createTextField. Digite esse código:

Esses atributos do createTextField significam:

"textbox_txt" -> nome da instância do novo campo de texto;

this.getNextHighestDepth() -> especifica a profundidade do campo de texto novo;

10 -> Um inteiro que especifica a coordenada x do novo campo de texto;

10 -> Um inteiro que especifica a coordenada y do novo campo de texto;

100 -> Um inteiro positivo que especifica a largura do campo de texto novo;

22 -> Um inteiro positivo que especifica a altura do campo de texto novo.

Feito isso iremos dizer que tipo de textField nós iremos querer. Digite o seguinte código:

Isso significa que a caixa de texto pode ser editada, existem três tipos:

INPUT -> Esta é uma caixa de texto você pode editar o texto. Você pode usar isso para que os usuários insiram números, nomes, ou outro texto. Este texto é selecionável;

DYNAMIC ->Esta é uma caixa de texto que só pode ser editadas pelo código. Você pode usá-lo para mostrar a pontuação de um usuário, ou outras informações que podem mudar. Este texto é selecionável;

STATIC ->Este é um tipo de texto que você não pode criar com o código. Você deve usar as ferramentas gráficas para criar texto estático. Este tipo de texto não é selecionável.

Depois de feito isso você agora vai dizer o máximo de caracteres que irá suportar seu TextField (no máximo 16 caracteres) e finalmente o que irá aparecer na tela:

Nosso código irá ficar assim:

Pronto temos tudo pronto para executar nosso primeiro aplicativo Flash Lite, salve seu projeto em uma pasta. Para executar seu aplicativo você vá na aba Control->Text Movie->in Device Central:

Ou no atalho do teclado Ctrl+ENTER. Feito isso vai abrir o Device Central com emulador:

Pronto temos nosso primeiro Hello World feito em ActionScript 2.0:

Agora faremos um Hello World mais fácil, usando as ferramentas do Adobe Flash.

Repita os mesmos passos para criação do projeto feito isso. Na Tela de edição, colocaremos um campo de texto, clicamos na ferramenta Text Tool e colocamos um campo de texto na nossa tela:

Na tela de propriedades você pode editar a fonte do texto, tamanho, cor etc. No campo Variable você digita o nome da variável que iremos usar para mostrar no campo nosso texto. Coloquei o nome de mainText.

Feito na TimeLine clique no primeiro frame (como nos passos anteriores para colocar um código actionscript) e tecle F9, que é o atalho para abrir a janela Action e na tela você digita esse código simples:

E pronto. Tecle Ctrl+Enter e o resultado é o seguinte:

Isso é tudo pessoal, para mais informações vai a seguir links da própria Adobe que ajudam no desenvolvimento:

http://www.adobe.com/support/flash/

Aqui você encontra dicas sobre o Adobe Flash, ActionScript, instalação etc.

Tutorial GRAILS (Groovy on Rails)

2010-09-27T20:01:00.000-03:00

Grails: Programação Ágil e Descomplicada

“Como obter, instalar, utilizar e inovar”

Por Felipe Prochazka / Cledson Medeiros

1 – Definição do Grails

Grails (Groovy on Rails) é um framework para construção de aplicações para web através da linguagem de programação Groovy (uma linguagem dinâmica para a plataforma Java). Foi desenvolvido em código aberto e pretende ser um framework de alta produtividade graças à utilização do paradigma da programação por convenção que preserva o desenvolvedor dos detalhes de configuração.

Foi inicialmente chamado de "Groovy on Rails" até ser renomeado para Grails, após um pedido do fundador do projeto Ruby on Rails, David Heinemeier Hansson Os trabalhos iniciaram em julho de 2005 e a versão 0.1 foi liberada em março de 2006. Portanto, é uma tecnologia relativamente nova, onde quem a domina, ganha destaque em sua área de atuação.

Atualmente, em setembro de 2010, o Grails está na versão 1.3.4 (utilizada neste tutorial) e conta com mais de 500 pluguins e este número não para de crescer, devido a facilidade de se construí-los, seguindo uma arquitetura modular que permite usar diversos componentes no desenvolvimento ágil das aplicações web com a mesma desenvoltura de uma aplicação desktop, só que com o paradigma de programação por convenção, que já cria todo um esqueleto (Rails) que além de otimizar o trabalho do programador, permite aumentar a consciência dos mesmos em relação a padrões de projeto e engenharia de software em geral.

O Grails permite que desenvolvedores Java ou desenvolvedores web, ou ainda, desenvolvedores de outras linguagens, não necessariamente voltadas para a web, se sintam mais integrados, confiantes e determinados a aprender cada vez mais sobre este incrível framework, no mínimo, revolucionário para a comunidade Java e para o mundo.

2- Obtendo o Grails e Instalando o Java JDK

2.1 – Baixe o Grails

http://grails.org/Download - Selecionando a versão mais recente. Vale à pena ressaltar que foi utilizada a versão 1.3.4 na elaboração das aplicações deste tutorial. Caso, já esteja disponível uma versão mais recente, talvez ao abrir algum projeto antigo, possa dar algum tipo de erro, mas isso é facilmente resolvido como o comando grails upgrade, que veremos ainda neste tutorial, então baixe qualquer tipo de versão atual sem se preocupar.

2.2 – Baixe, Instale o Java JDK e configure as variáveis de ambiente do Grails:

2.21- Windows 7:

http://www.oracle.com/technetwork/java/javase/downloads/jdk6-jsp-136632.html

http://www.baixaki.com.br/download/java-se-development-kit-jdk-for-windows.htm

Após a instalação, é necessário configurar as variáveis de ambiente para que estas sejam acessadas pelas aplicações Java e também configurar o PATH do grails para poder ser utilizado pela linha de comando. É um procedimento bem simples, vejamos como isso pode ser setado:

· Windows 7:

Iniciar -> botão direito em Computador -> selecione Propriedades -> Configurações Avançadas do Sistema (no menu à esquerda) -> aba Avançado -> Variáveis de Ambiente

A seguinte janela será exibida, com uma ligeira diferença nas variáveis de ambiente, devido às aplicações instaladas no computador:

Verifique se as seguintes variáveis de ambiente, tanto do Java JDK quanto do Grails, existem, caso contrário deverão ser criadas:

· Variáveis de usuário:

Variável: JAVA_HOME Valor: C:\Program Files (x86)\Java\jdk1.6.0_18

Obs.: Este é o caminho para o jdk versão 1.6.0_18, você deverá para a pasta da versão atual do seu Java JDK.

Variável: Path Valor: %PATH%;%JAVA_HOME%\\bin;C:\GRAILS\bin

· Variáveis do Sistema:

Variável: GRAILS_HOME Valor: C:\GRAILS

Obs.: Este é o caminho para o Grails, você deverá para a pasta da versão atual do seu Grails. Quando se baixou o source do grails, a pasta foi renomeada simplesmente para GRAILS.

Como pode ter percebido, sempre que você for inserir um novo valor numa mesma variável, se separa por ponto e vírgula. Caso,t enha alguma dúvida em como configurar as variáveis de ambiente, assista este video: http://www.youtube.com/watch?v=vzZOYTFJ33 (feito baseado no Windows Vista ou superior).

Agora, abra o prompt de comando, digite grails e verifique o Grails está funcionando:

E digite javac para verificar se o Java está configurado:

Se tudo estiver bem configurado, podemos prosseguir para rodar exemplos deste framework. Neste tutorial, recomendamos duas abordagens:

1. Usar o prompt de comando para rodar aplicações e realizar a edição dos códigos com o Notepad++ ou Jedit, e ter mais controle na organização de pastas.

2. Utilizar a excelente IDE Netbeans versão 6.9 ou superior, que facilita bastante as coisas. Existem outras opções como a IDE Spring (baseada no Eclipse) ou o IntelliJ IDEA, a escolha da IDE depende do gosto de cada um, mas o Netbeans se mostrou mais amigável para o programador brasileiro, devido uma interface mais limpa e traduzida para o português, inclusive as pastas do framework.

3- Instalando a IDE Netbeans

É bastante simples baixar o Netbeans configurado para se utilizar o Grails, bastante baixar a versão mais completa (ou a versão voltada para programação Java) no site:

http://netbeans.org/downloads/index.html

Recomenda-se baixar a versão completa, pois já dá suporte a um ambiente de desenvolvimento completo, visando integrar com todo tipo de tecnologia, além do Groovy, linguagem base do Grails.

Depois de instalado, rode o Netbeans, e dentro da IDE, vá para a janela Opções e defina a localização do Grails no painel "Groovy". Se você quiser utilizar o Groovy, também defina a localização do Groovy.

Antes de começar a programar nesta robusta IDE, vejamos como podemos utilizar apenas a linha de comando para executar aplicativos em Grails de forma bem prática e simplificada.

4- Hello World usando Linha de Comando

Na linha de comando do Windows 7:

· Crie um nome diretório a seu gosto, por exemplo grails-app, e o acesse:

pc> mkdir grails_app

pc> cd grails_app

grails_app>

· Dentro da pasta grails-app, execute o seguinte comando para criar um aplicativo Grails com o nome Hello:

grails_apps> grails create-app Hello

Novos arquivos serão criados na pasta grails-app e, que serviram de esqueleto(rails) para a aplicação Hello.

Vejamos o que contêm as principais pastas contidas neste diretório:

src:

groovy: Contém arquivos Groovy (outros que não são controllers, domain, ou classes de serviço)

java: Contém arquivos Java

test: Para testes de unidade

web-app: Contém arquivos de configuração relacionados a customização da aplicação

grails-app: Contém o principais arquivos da aplicação, como as classes do domínio e os controladores, organizados em subdiretórios.

conf: Contém as ferramentas de configuração

controllers: Contém os controladores

domain: Contém as classes do domínio

i18n: Contém arquivos de mensagem segundo padrão de internalização.

services: Contém classes que oferecem algum serviço para a aplicação

views: Contém templates de visualização

Vale a pena ressaltar que não há nenhuma mensagem de Hello World implementada, é preciso alterar o código para se chegar nisso. Vejamos como podemos começar a edição da nossa aplicação Hello.

No prompt de comando, estando na pasta Hello, execute:

· Criando o controller Hello

Hello> grails create-controller Hello

Agora já foi criado o controlador da aplicação, que realiza a comunicação entre camada de visualização com a camada de domínio, onde fica a lógica de programação. Um controller processa os pedidos e cria ou prepara a resposta. Este controlador criado só tem o esqueleto pronto, é preciso editar a sua classe.

Na pasta grails-app\controllers, abra o arquivo HelloController.groovy com algum editor de texto compatível como o Jedit (download: http://www.jedit.org/index.php?page=download ) e realize a seguinte alteração:

· Editando o controller Hello

class HelloController {

def hello = {render "Hello World !!"}

}

· Executando a aplicação Hello

Hello> grails run-app

Abra o navegador web (browser) de sua escolha e digite no campo de endereço

http://localhost:8080/Hello/ , onde localhost é um servidor local, 8080 é a porta default, e o Hello, o nome da aplicação Grails.

Uma tela semelhante a esta será exibida, mostrando que além do framework está rodando, o controlador HelloController está implementado:

Clique no HelloController e verá o resultado da implementação:

Parabéns por ter chegado até aqui no universo Grails e, é apenas o começo, há muitos exemplos interessantes a serem “mastigados” neste tutorial.

4- Hello World usando a IDE Netbeans

Depois de iniciar o Netbeans, clique em Arquivo (File) e selecione Novo Projeto (New Project), e faça conforme a imagem, escolhendo a categoria de projeto como Groovy, ou seja, um projeto do tipo aplicação Grails (Grails App):

Assim o esqueleto do projeto Hello será criado:

Em seguida clique com botão direito na pasta Controladores e selecione novo>Controlador do Grails e no campo nome do artefato coloque como Hello.

Dentro da pasta Controladores\hello será criado o arquivo HelloController.groovy, realize a edição do esqueleto da classe, conforme a seguir:

package hello

class HelloController {def hello = {render "Hello World !!"}}

Em seguida, selecione a pasta principal do projeto Hello com o botão direito e escolha executar:

Aguarde alguns instantes, o console da IDE começará o processo para a preparação da aplicação e ativação do servidor.

O navegador será automaticamente aberto e direcionado para: Http://localhost:8080/Hello

O resultado final é semelhante ao mostrado no tópico 3 deste tutorial.

4- Exemplo Prático de CRUD (Blog) e a instalação de pluguins

O scaffolding é o termo utilizado pelo framework para encorporar a geração automatizada de artefatos necessários a uma operação básica de CRUD (Create, Read, Update e Delete). Sua utilização pode substituir todo o código gerado automaticamente nos controladores por apenas uma única linha. Utilizando o exemplo do artigo anterior, poderíamos substituir o código da nossa classe ContatoController para a definição de scaffold descrita abaixo e esta continuará executando as mesmas operações.

Exemplo de aplicação do scaffolding:

class ContatoController{

def scaffold = Contato

}

O código acima apresentado acima permite que as operações de CRUD sejam geradas de forma implícita para nosso artefato Contato, o qual foi criado como classe de domínio de nossa aplicação. Fácil não?. Se você achou isso fácil é porque ainda não sabe que além de deixar muito código implícito, o Grails também gera automaticamente as “convenções” para as URL's de acesso a aplicação. Para a nossa classe de domínio Contado, por exemplo, as chamadas disponibilizadas seriam:

· http://localhost:8080/agenda/Contato/list – responsável por listar todos os elementos gravados do tipo Contato

· http://localhost:8080/agenda/Contato/create – responsável por liberar uma view pronta para realizar novos cadastros do objeto Contato

· http://localhost:8080/agenda/Contato/edit/id – responsável por editar um registro a partir de um determinado id

· http://localhost:8080/agenda/Contato/show/id – responsável por exibir um registro a partir de um id específico

Simples, não acha?. É, realmente os padrões de projeto estão se tornando parte obrigatória para deixar aplicações compreensíveis e de fácil manutenção. No caso do Grails, os padrões chegam até às descrições de URL, as quais, apresentam por definição após o nome do domínio o nome do projeto seguido da classe e operação realizada. Para compreendermos esses padrões e os conceitos acima descritos, o restante deste artigo tratará dos passos para a criação de um blog que conterá as classes de domínio Post e Comentários como definidas abaixo.

Diagrama de classes da aplicação blog

Para a criação do blog a partir do modelo da figura, siga os seguintes passos:

1. Crie um novo projeto Grails e chame-o de blog.Para isso, execute no terminal o comando grails create-app blog

2. Estando dentro da pasta do projeto, crie as classes de domínio com grails create-domain-class. Após criadas, vá na pasta grails-app/domain e edite-as para adicionar as propriedades contidas no diagrama da figura. Lembre-se, as definições são criadas com tipo e nome_variável sem ponto e virgula no final.

3. Com as classes de domínio devidamente construídas, crie as classes de controle paraPost e Comentários com o comando grails create-controller Post e depois repita o processo com a Comentario. Feito isso, modifique-as e defina o scaffold como visto no exemplo do quadro. Ex.: A classe Controller para Post ficaria def scafold = Post

4. Por fim, crie as classes de visão com grails generate-views Post e depois repita o processo para a classe de domínio Comentario

Se os passos acima forem executados corretamente já teremos um primeiro modelo do que está se tornando nosso blog e este já pode ser testado. Para isso, ainda na pasta raiz do projeto digite grails run-app e vá ao browser e digite o endereço http://localhost:8080/blog.Como pode ser observado, nosso blog ainda não possui um requisito muito importante definido no diagrama de classes, a relação entre os nossos Posts e Comentários. Essa relação deve ser feita, não só para melhorar a compreensão visual, mas também para manter a integridade de nossa base de dados. No Grails, esse processo é executado utilizando-se algumas palavras reservadas, tais como, hasMany e belongsTo. Essas declarações permitem dizer ao nosso blog que há muitos comentários (hasMany) para um determinado Post (belongsTo). Tais acrescimos de código devem ser feitos nas classes de domínio e ficam como definido a seguir.

Relacionamento das classes de domínio Post.groovy e Comentario.groovy

//Modificador da classe Post.groovy
static hasMany = [comentarios:Comentario]

//Modificador da classe Comentario.groovy
static belongsTo = [post:Post]

Com a modificação realizada, gere novamente as views para Post e Comentario e teste a aplicação novamente. Perceba que, um novo campo aparecerá no controlador de comentários, permitindo agora associa-lo a um objeto do tipo post. No Grails, os relacionamentos podem ser feitos utilizando as seguintes relações: one-to-one, many-to-one, many-to-many, hasMany ebelongsTo. No entanto, ao utilizar o scaffold, a definição many-to-many não funcionará por não ser comportada pelo processo automatizado. Neste caso, se houver a necessidade de utilizá-lo, deve-se programá-lo manualmente.

Agora que você já conheceu os relacionamentos, vamos continuar a resolver os problemas do nosso blog. Um deles é a falta de validação de nossos campos, permitindo que o operador digite url's invalidas ou deixe algum campo em branco. Para solucionar isso, precisamos compreender um conceito chamado de Constrants.

As contrains estão diretamente relacionadas às limitações que alguns campos em nosso sistema devem ter. Por exemplo, se um usuário passar a informação de e-mail errada, o sistema deve estar apto a identificar tal erro e informa-lo ao operador. Como na limitação dos relacionamentos, as constraints ficam nas classes de domínio da aplicação. Como exemplo, vamos tratar o formato da URL da classe Comentario.groovy. Edite a classe e acrescente em seu código a linha definida no exemplo a seguir.

Um exemplo de tratamento de exceções com Constrains:

static constraints = {url(url:true)}

Com o código do exemplo acima já adicionado, gere novamente as views e tente cadastrar uma URL em um formato inválido para verificar como o framework realiza o tratamento das exceções. Bom, não? O que achou de programar pouco e fazer muito?. Você não viu tudo ainda, vamos modificar as classes Post.groovy e Comentario.groovy para criar mais algumasconstraints. Para tanto, abra as mesmas e modifique-as como definido nos trechos de código abaixo:

Adição das constrains na classe Post.groovy:

class Post {

String titulo

String conteudo

Data publicacao = new Date()

static hasMany = [comentarios:Comentario]

static constraints = {

titulo(blank:false)

conteudo(blank:false)

data(blank:false)

}

Adição das constraints na classe Comentario.groovy:

class Comentario {

String nome

String url

String comentario

static belongsTo = [post:Post]

static constraints = {

nome(blank:false)

url(url:true)

comentario(blank:false)

}

Feito as modificações acima apresentadas, gere novamente as views e teste sua aplicação. Se você quiser saber mais sobre as Constraints e as formas de configuração, consulte a documentação oficial em http://grails.org/doc/1.1/.

Agora proferimos algumas limitações, vamos estudar um pouco sobre os plugins no Grails. Como em qualquer outra linguagem, o Grails também possui vários plugins que podem lhe ajudar a melhorar a aparência de suas aplicações. Para este exemplo, utilizaremos o Richuicom o objetivo de melhorar o cadastro das datas e comentários de nosso blog. Para instala-lo, digite na pasta raiz do projeto o seguinte comando: grails install-plugin richui. Isso baixará oplugin do site oficial e instalará o mesmo em nosso projeto. Essa operação pode levar algum tempo dependendo de sua conexão com a internet.

Já com o Richui instalado, vamos as modificações. Em /blog/grails-app/views há uma pasta para as visões do Post e outra para o Comentário. Entre na pasta post e abra para edição a página create.gsp. No cabeçalho (<head>) insira as linhas <resource:richTextEditor type="advanced" /> e <resource:dateChooser />. Ainda com o arquivo aberto, busque a seguinte linha de código <g:datePicker name="publicacao" value="${postInstance?.publicacao}"></g:datePicker> e substitua por <richui:dateChooser name="publicacao" value="${postInstance?.publicacao}" format="dd/MM/yyyy"/>. Da mesma forma, troque a linha <input type="text" id="conteudo" name="conteudo" value="${fieldValue(bean:postInstance,field: 'conteudo')}"/> por <richui:richTextEditor name="conteudo" value="${fieldValue(bean: postInstance,field:'con teudo')}"/>. Feito isso, vá ao browser e abra novamente sua aplicação. O resultado será conforme a figura a seguir.

Resultado das modificações com o plugin Richui

A aplicação já se encontra pronta com o layout default, caso queira personalizar com um novo tipo de layout prossiga no tutorial deste tópico.

E então, estamos progredindo na criação de nosso blog? Quanto tempo você gastaria para refazer o exemplo? Cinco minutos? Bom, ainda não acabamos. Estamos com uma aplicação que possui a parte administrativa, agora, vamos criar a página de acesso aos usuários do nosso blog. Para isso, utilizaremos um modelo html pronto que pode ser baixado pelo site:

http://www.michelsilva.net/index.php?option=com_docman&task=doc_download&gid=43&Itemid=41

Para torná-lo acessível aos nossos usuários, siga os passos abaixo:

· Baixe e descompacte o arquivo blog.zip

· Copie as imagens do diretório images para /blog/web-app/images

· Copie o arquivo css da pasta css para /blog/web-app/css

· Copie o arquivo index.html para a pasta /blog/grails-app/views/layouts e mude seu nome para index.gsp. Feito isso, abra-o e modifique seu código da seguinte forma:

o Em <head> procure a tag <link rel="stylesheet" href="css/style.css" type="text/css" /> e modifique-a para <link rel="stylesheet" href="${createLinkTo(dir:'css', file:'style.css')}" type="text/css" />. Esse comando no href faz com que o arquivo style.css seja buscado em web-app/csspor convenção.

o Como última linha da tag <head> coloque <g:layoutHead /> para definir futuramente uma view que possa modificar componentes desse local.

o Agora, apague o html começando na linha <div id="left"> até o </div> da tag<div id="right"> e substitua todo esse código pela tag <g:layoutBody />. Como no <head> estou marcando no código onde farei as modificações de corpo de forma dinâmica.

· Como próximo passo, vamos criar dentro da pasta /blog/grails-app/views uma pasta chamada home e nela um arquivo com o nome home.gsp. O conteúdo desse arquivo é definido no código-fonte 1 abaixo. A sua função é ler de um controlador uma lista de posts e por meio de um for (each) lista-los na tela. Para deixa-los no formato do layout, um teste condicional com a variável i (${ (i % 2) == 0 ? 'left' : 'right'}) é realizado para trocar dinamicamente o id do css utilizado em nosso layout. Se você é um bom observador, viu também que estamos chamando nosso layout pela tag <meta name="layout" content="index" />. Isso permite o redirecionamento do resultado e a visualização dos posts cadastrados.

· Por fim, crie um novo controlador chamado Home e modifique seu código como definido no código-fonte 2 abaixo. Sua função é buscar todos os posts cadastrados e redireciona-los para o arquivo home.gsp que se encontra na pasta /blog/grails-app/views. Esse, por sua vez, executa a listagem e retorna o resultado final para o arquivo index.gsp da pasta/blog/grails-app/views/layouts.

Código-Fonte 1 - Definição do arquivo view home.gsp

<head>

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

<meta name="layout" content="index" />

<title> Meu blogão </title>

</head>

<body>

<g:each in="${postList}" status="i" var="post">

<div id="${ (i % 2) == 0 ? 'left' : 'right'}">

<h2>${post.titulo}</h2>

<p align="justify"> ${post.conteudo}</p>

<div id="notice">

<p>Coloque aqui uma chamada em destaque em seu blog</p>

</div>

</g:each>

</body>

Código-Fonte 2 - Definilção da classe controller home.gsp

class HomeController {

def home = {

[postList:Post.list()]

}

Neste ponto, um novo link aparecerá na página inicial de nosso blog linkando-o ao nosso novo controlador HomeController. Ao chegar a esse ponto finalizamos o aplicativo e o mesmo pode ser testado.

5- Macetes do Grails

· Evitando problemas de compilação na IDE Netbeans

Sempre que for utilizar outros projetos, seja para alterá-los ou rodá-los, clique na barrinha de executando e clique no X para fechar o projeto atual antes de mexer em outros projetos (feche os processos run-app, antes de executar novamente o comando run-app), isso irá evitar conflitos por recursos, como problemas na base de dados, conforme a figura abaixo:

· Evitando problemas com atualização das Views(layout) do projeto:

Sempre que fizer alguma alteração na estrutura do código seja de uma classe de domínio seja de um controlador, é recomendável clicar com o botão direito sobre o arquivo groovy da classe de domínio alterada e selecionar Gerar Visualizações (assim as views, ou seja, o que será exibido pelo mecanismo CRUD, será atualizado).

· Evitando o problema com versões antigas do Grails

Sempre que um projeto antigo de uma versão mais antiga for usado no Grails, é necessário realizar o comando grails upgrade pela linha de comando ou ainda clicar sobre o projeto com o botão direito e selecionar “Executar/Depurar comando do Grails”:

Em seguida selecione o comando upgrade na lista de comandos e clique no botão executar:

6- Noções de Teste de Software usando Grails

Teste de Software pode ser essencial para testar a qualidade do projeto e para verificar se tudo está saindo conforme o planejado, sem necessariamente precisar testar manualmente as funcionalidades da aplicação. O Grails já possue o teste de integração e de unidade já embutidos, bastando apenas editá-los ou criá-los quando necessário.

Digamos que temos a seguinte classe de domínio em nossa aplicação:

class Professor {

}

Altere para:

class Professor {

   String login
   String nome
   String sobrenome

   static hasMany = [disciplinas: Disciplina]

   static constraints = {
     login(blank:false,unique:true)
     nome(blank:false)
     sobrenome(blank:false)
   }

   String toString(){
      "$nome $sobrenome"
   }

}

E queremos escrever um teste simples para validar algumas coisas, como se o login, o nome e o sobrenome foram cadastrados, então podemos escrever um teste de integração do tipo (este código groovy deverá ser criado na pasta Testes de integração):

class ProfessorTests extends GroovyTestCase {

  void setUp() {
    Professor.list()*.delete()
  }

  void testPersist() {
    new Professor(login: "login1", nome: "nome1", sobrenome:"sobrenome1").save()
    new Professor(login: "login2", nome: "nome2", sobrenome:"sobrenome2").save()
    new Professor(login: "login3", nome: "nome3", sobrenome:"sobrenome3").save()
    new Professor(login: "login4", nome: "nome4", sobrenome:"sobrenome4").save()
    new Professor(login: "login5", nome: "nome5", sobrenome:"sobrenome5").save()
    assert 5 == Professor.count()
  }

  void testToString() {
    def professor = new Professor(login: "mary", nome: "Mariazinha",
         sobrenome: "Silva")
    assertToString(professor, "Mariazinha Silva")
  }

}

Como se pode averiguar no código anterior no método void testPersist() foram realizadas 5 inserções de cadastro de professor com respectivos login, nome e sobrenome, e salvos no banco de dados, em seguida, foi contado o número de registros e comparado com 5 pelo assert, logo este teste tem que passar, caso contrário o teste falhou por algum problema na inserção ou na comparação realizada pelo contador. Já em void testToString, um objeto professor foi definido com login, nome e sobrenome, em seguida o assertToString, comparou o objeto professor, com a String passada como parâmetro, como a String contem dentro do objeto, o teste deve passar.

Se desejar um relatório mais detalhado dos detalhes basta, entrar na pasta Target\test-reports\html e clicar com o botão direto no arquivo índex.html e clicar com o botão direito e selecionar exibir:

A seguinte tela será exibida, contendo mais detalhes dos testes:

7- Referências Bibliográficas

www.grails.org – Acessado em 30-08-2010

RODOLPH, Jason. Getting Started with Grails (E-book) - http://www.infoq.com/minibooks/grails

http://www.itexto.net/devkico/?p=231 - Básico do Groovy para quem for aprender Grails – Acessado em 19-09-2010

http://www.grails.org/Success+Stories - Acessado em 20-9-2010

http://grails.org/doc/latest/ - Acessado em 21-09-2010

http://www.infoq.com/minibooks/grails - Acessado em 21-09-2010

[PDF] Mastering Grails: Build your first Grails application – Acessado em 21-09-2010

Tutorial Django

2010-09-20T20:05:00.002-03:00

Neste tutorial você aprenderá a instalar e configurar o Django, além de praticar através de um exemplo.

Instalando no Windows

Baixe e instale primeiramente o Python (http://www.python.org/download/).

A instalação é simples execute o arquivo baixado clique em “Next” e escolha o diretório em que o python será instalado. Ex.: “C:\Python27\”.

Você deve apenas se preocupar em configurar o python na variável de ambiente para que o sistema possa reconhecê-lo automaticamente. Para ter acesso a variável de de ambiente aperte as teclas Windows + Pause (a tecla Windows é a tecla com o logotipo do windows).

Janela Propriedades do sistema, clique na aba Avançado e em seguida no botão Variáveis de ambiente.

Na caixa Variáveis do sistema clique sobre a variável com nome path e clique em editar.

Na janela editar variável de sistema edite a linha valor da variável adicionando o caminho do diretório de instalação do python. Supondo que você instalou em C:\Python27\ adicione “;C:\Python27\” no final da linha.

Após esta etapa o python já estará instalado e configurado.

Agora vamos a instalação do Django que você pode baixar em http://www.djangoproject.com/download/.

Ao baixar o arquivo ele vem com a extensão tar.gz, a maioria dos descompactadores mais novos já suportam esta extensão, mas se o seu não suporta você pode baixar o 7-zip (http://www.7-zip.org/) que também é um software livre.

Descompacte o arquivo onde quiser.

Dentro da pasta onde você descompactou crie um arquivo e chame de “instalar.bat”, edite usando o bloco de notas e digite:

python setup.py install

pause

Salve, feche o arquivo e execute.

Feito isso, o Django estará instalado.

Atenção: talvez não seja necessário o passo a seguir. Verifique se sua versão do python já possui a biblioteca pySQLite.

Agora vamos seguir para o último passo: instalar a biblioteca do banco de dados SQLite. O SQLite é um banco de dados simples, sem muitos recursos. É ideal para o ambiente de criação e desenvolvimento. Não dá pra fazer muitas coisas com ele, mas você dificilmente vai precisar de fazer muitas coisas enquanto cria seu site.

Para o Django trabalhar em conjunto com o SQLite, é preciso apenas instalar uma biblioteca, chamada pySQLite, e nada mais. Então, vá até a página seguinte e faça o download do tarball (código-fonte, com extensão .tar.gz). http://oss.itsystementwicklung.de/trac/pysqlite/#Downloads.

Se a instalação do pySQLite apresentar erros de compilação no Windows, tente instalar com um dos instaladores executáveis disponíveis na página de download acima. Isso às vezes ocorre por consequência de algum tipo de incompatibilidade entre compiladores.

Após o download, faça o mesmo que fez com o Django:

1. descompacte usando o 7-zip

2. crie o arquivo instalar.bat com aquele mesmo código dentro

3. execute

4. pronto.

Agora você tem um ambiente de desenvolvimento instalado para começar a usar.

Instalando no Linux

Geralmente no linux já vem o Python e o PySQL instalados.

Desta maneira é apenas necessário instalar o Django executando o seguinte comando no diretório onde está o arquivo Django-1.2.3.tar.gz:

tar xzvf Django-1.2.3.tar.gz

cd Django-1.2.3

sudo python setup.py install

Pronto!

Neste tutorial desenvolvemos com Django na IDE Eclipse (http://www.eclipse.org/downloads/).

Para utilizar o Django na IDE Eclipse é necessário baixar o plug-in Pydev, você pode fazer isso utilizando o próprio eclipse.

Abra o eclipse utilize o menu Help>Install New Software...

Na janela install clique no botão Add...

Na janela Add Site digite o nome: PyDev e Location: http://pydev.org/updates

Deverá aparecer duas opções:

Marque a caixa de seleção PyDev e espere o download e configuração do plugin.

Após isto você terá um ambiente de desenvolvimento Django e poderá utilizar a IDE Eclipse para programar.

Agora vamos à prática...

Criando uma Agenda

Criando um projeto com Administrador

Após configurado o eclipse, vamos criar um projeto Django, clique em novo e escolha a opção PROJECT, depois escolha a opção Django Project e NEXT.

Depois iremos dar um nome ao projeto, que iremos chamar de Agenda, iremos escolher a versão do Python, ou a versão 2.6 ou 2.7, a 3.0 não é compatível com o Django 1.2, agora NEXT.

Por último iremos escolher a versão do Django é o banco de dados que iremos usar. Vamos usar a versão 1.2 do Django e vamos usar o Sqlite3 para modelar o banco, pois é mais simples de usar para esse exemplo.

Agora basta da um clique em FINISH e o eclipse vai criar uma estrutura iqual a essa.

Vamos em Run, então o eclipse irá executar o servidor do Django, par ver se esta tudo correto abra um Browser (Firefox, Chrome. Etc) e vamos digitar o endereço “http://localhost:8000/” e iremos ver a seguinte página.

Agora vamos habilitar a página do administrador do Django, vamos em settings.py, primeiro procure por “LANGUAGE_CODE = 'en-us'” e mude para “LANGUAGE_CODE = 'pt-br'”, assim nossa página adminstrador do Django será em português.

Procure por “'django.contrib.admin',” dentro de “INSTALLED_APPS” e descomete essa linha apagando o “#”, preste atenção para que essa linha siga a identação das demais. Feito isso vamos em urls.py e descometamos essas duas linhas, ”from django.contrib import admin” e “admin.autodiscover()”, e depois descometamos “(r'^admin/',include(admin.site.urls)),”.

Agora é hora de usarmos o comando “syncdb” para sincronizar os dados da aplicação com o bando e gerar as tabelas do mesmo, vamos da um clique com o botão direito do mouse em Agenda e escolher Django -- > Sync DB. Com isso vamos criar as tabelar referente a pagina administrador do Django e vamos criar um superusuário com nome, e-mail e senha, lembre-se desses dados para os próximos passos. Depois de executado podemos notar que um arquivo foi adicionado na pasta src, esse arquivo é o nosso banco.

Vamos rodar nosso projeto outra vem em RUN e recarregar nossa pagina, se tudo foi feito certinho até agora vamos ver esse erro:

Esse erro ocorreu porque agora temos uma página e só usamos a url do servidor, vamos agora tentar entrar nessa url: “http://localhost:8000/admin/” e você verá essa página:

Após o login entraremos nessa página:

Adicionando uma aplicação com Template

Para adicionar uma aplicação vamos da um clique com o botão direito do mouse em Agenda-->Django-->create application, vamos dar o nome de contato a nossa aplicação, depois de aperta OK, vai ser criado uma pasta com o nome contato e quatro arquivos dentro. Vamos agora criar a classe que vai definir nosso contato, abra o arquivo “models.py”, nesse arquivo vamos definir todas as entidades que serão usadas na aplicação contato, edite o arquivo models.py até ficar assim:

Acabamos de criar uma classe Contato que herda da classe Models e tem os atributos nome, fixo, cel e endereco como campos de caracteres(CharField) com o tamanho especificado no parâmetro e um atributo email com um campo de e-mail(EmailField).

Vamos fazer com que nossa aplicação se torne parte do nosso sistema, para que isso ocorra vamos abrir novamente o settings.py e adicionar contato no INSTALLED_APPS:

Agora é só rodar o camando SYNC DB que já usamos antes e vamos ver mais uma tabela sendo criada, vamos então fazer com que nossa pagina de administrador possa interagir com a entidade que criamos, para isso dentro da pasta contado crie um arquivo com o nome “admin.py” e edite esse arquivo até ficar assim:

Vamos rodar o servidor e ir ver a pagina do administrador, la veremos que Contato já faz parte da nossa página, e temos a opção de adicionar um contato e modificar um contato existente.

Clique em adicionar e vamos criar um contato, preencha os dados e clique em salvar, note que o Django já faz tratamento de erro caso você coloque um e-mail não valido. Após criar um contado vamos ver que ele vai aparecer em uma lista.

Note que o objeto esta com o nome “Contato object”, e isso não é interessante. Para mudar isso vamos em models.py para criar uma função que vai retorna o nome do contato.

Recarregando a pagina após a modificação veremos que agora aparece o nome do contato.

Já é hora de usarmos templetes para a nossa aplicação, dentro da pasta Agenda vamos criar uma outra pasta com o nome “templates”, depois de fazermos isso dizer ou Django onde esta esta pasta, para isso abra o settings.py e acrescente esse import em destaque como mostra na figura, ele importa o “os” para facilitar na hora de pegar o endereço da pasta onde esta o projeto.

Com o import feito, vamos adicionar mais uma mudança no settings.py, só que dessa vez em “TEMPLATE_DIRS” adicionando o caminho da pasta templates como na figura.

Criando um Template

Crie um arquivo com o nome “base.html”, ele é nosso HTML estático que será usado pelos outros HTMLs. Edite-o para que fique assim.

Com essas tags “{% block content %}{% endblock %}” podemos enviar dados do Django que será transformado em HTML.

Agora dentro da pasta templates criaremos outra pasta com o nome “contato”, nesta pasta ficará todas os HTMLs de contato, dentro dela vamos criar um arquivo com o nome “list.html”, vamos usá-lo para listar os nossos contatos. Antes de editar esse arquivo precisamos criar a função que vai passa a lista dos contatos para o HTML, abra o views.py e edite-o assim:

Estamos importando a classe Contato que criamos no models.py e importando funções do Django para redirecionar os dados para um HTML. No começo da função criamos a variável contatos e atribuímos a ela todos os contatos, e estamos retornando uma reposta com o endereço do arquivo list.html que criamos antes e a variável contatos.

Precisamos agora criar a url que irá chamar essa função, então vamos em urls.py e adicionamos a seguinte linha como mostra a figura.

Assim criamos um url “contato/listar” com o endereço da função que criamos antes, já é hora de editarmos o list.html, vamos deixar o arquivo desse jeito:

A gora temos um HTML que vai receber a variável contatos e vai exibir a lista de contatos, podemos perceber que na primeira linha estamos estendendo a base.html e juntando com o list.html, o “block content” de list.html vai substituir o “block content” da base.html.

Depois de salvar tudo vamos rodar o projeto para ativar o servidor e vamos acessar a página “http://localhost:8000/contato/listar”, e se tudo der certo vamos ver a lista de contatos que você cadastrou na página do administrador.

Usando Genéricos

Vamos usar agora as funções genéricas do Django para criar e editar um contato. Já podemos fazer isso através da página do administrador, mais vamos fazer isso usando template. Vamos abrir o urls.py e vamos acrescentar mais duas urls, uma para editar e outra para criar, vamos deixar o urls.py assim.

Primeiro importe Contato como mostra na segunda linha, então vamos fazer a url criar que tem como parâmetro a função genérica “create_object” , e depois passamos o modelo de Contato, o template que vai ser usado e o endereço que vai ser redirecionado depois de salvo. A url editar é bem parecida com a url criar, mais com algumas diferenças, a primeira é esse parte do endereço “(?P<object_id>\d+)” que tem a função de pegar o id do objeto que será editado, e a segunda é a função genérica que dessa vez é a “update_object”.

Já temos as urls, falta agora criar o arquivo “generic_form.html” que usamos como parâmetro. Os genérico devem ser usador por todas as aplicações, então vamos criar esse arquivo dentro da pasta templates, depois de criado vamos editá-lo da seguinte forma.

Agora podemos rodar o projeto e criar novos contatos e editar os já existentes.

Para aprender mais visite:

http://docs.djangoproject.com/en/dev/intro/tutorial01/

http://docs.djangoproject.com/en/1.2/

http://docs.djangobrasil.org/intro/tutorial01.html

http://www.aprendendodjango.com/

Referencias:

http://www.djangoproject.com/

Autores:
   Felipe Rios
   Pedro Henrique
   Thiago Lins

Tutorial WRT (Web RunTime)

2010-08-31T23:04:00.008-03:00

Autores:

Helder May
Lais Cardoso
Tiago Emmanuel

TUTORIAL WRT

Este tutorial ensina a construir um aplicativo que utiliza a plataforma WRT Nokia. Essa plataforma, nada mais é do que uma maneira de poder rodar widgets diretamente do celular, fora do browser, como se fossem aplicativos nativos. Web widgets são pequenos pedaços de códigos executados no cliente, funcionam como extensões de página Web, são desenvolvidos utilizando linguagens de uso comum na Web (HTML, JavaScript, CSS). A ferramenta utilizada para a construção deste aplicativo foi o Aptana Studio e o Nokia WRT plugin para o Aptana Studio, o Aptana Studio pode ser adquirido gratuitamente através do endereço http://www.aptana.org.

CRIANDO UM NOVO PROJETO WRT

De Aptana, selecione Arquivo-> Novo-> New Project.

Na caixa de diálogo New Project, selecione "Nokia Web Runtime (WRT)" -> "New Nokia Web Runtime Widget Wizard" e clique no botão "Next".

No Widget Nokia diálogo New Project, selecione a opção "Basic Widget with WRTKit " e clique no botão "Next". Estamos usando o Widget Basic with WRTKit em vez da versão sem suporte WRTKit porque queremos aproveitar UI pronta que Nokia disponibiliza no WRTKit, ao invés de ter que criar tudo do zero.

Dê um nome ao projeto, por exemplo, "DiggClient". E marque "Use default location" ou selecione a sua localização preferencial para os arquivos de projeto e clique no botão "Next".

Nós não precisamos mudar o nome do elemento identificador. Deixe a opção “Enable HomeScreen” desmarcada, nós não precisamos falar sobre HomeScreen widgets neste tutorial.
Neste ponto, o modelo possui informações suficientes para criar um projeto esqueleto, no entanto, ao invés de clicar no botão "Finish", nesta fase, que você irá clicar no botão “Next”.

Substitua os nomes padrão para o HTML principal, CSS e JavaScript com arquivos "diggclient" e clique no botão "Finish".

Pronto! Aptana criou um completamente funcional "Olá Mundo" Web Runtime Widget para você. Antes de ver o nosso novo widget em ação, vamos dar uma olhada no que o Aptana e o Nokia WRT plugin criaram para você.

O QUE TORNA UM PROJETO WRT WIDGET?

Aptana criou um conjunto de arquivos para você quando você clicou no botão “Finish”. Se você expandir o projeto DiggClient dentro do Aptana você verá algo similar ao seguinte:

Info.plist

O arquivo que vamos olhar é Info.plist. Info.plist é uma parte obrigatória de cada widget ele irá residir no diretório raiz do seu projeto widget. O próprio arquivo XML é um dicionário que fornece o tempo de execução Web com informações-chave sobre o seu widget. Se você examinar o conteúdo do Info.plist, arquivo criado por você no Aptana, você verá algo como o seguinte:

Observe que o nome do projeto que você forneceu para o modelo aparece no arquivo Info.plist como o widget DisplayName, como o identificador de widget.
Observe também que diggclient.html é definido como o valor da chave MainHTML. O arquivo referido pela chave MainHTML é carregado pelo Web runtime quando o widget é lançado.
Também estão incluídos no arquivo Info.plist a chave da versão, o que corresponde ao número da versão da sua aplicação widget. Finalmente, observe que o widget está autorizado a acessar os recursos da rede porque a chave AllowNetworkAccess é definido como verdadeiro, enquanto MiniViewEnabled é definida como false, o que significa que este item não suporta a tela inicial.
diggclient.html
Seu widget deve criar uma página HTML simples que é carregada pelo ambiente WRT e existe para manter a vida do seu widget. O conteúdo desta página HTML pode mudar dinamicamente de acordo como o seu widget funciona, porém você não pode navegar para fora da página HTML. O nome da página HTML é definido pela chave MainHTML no arquivo Info.plist. O arquivo pode ser chamado . Html, neste caso o nome do widget está - diggclient.html. Outras pessoas gostam de usar index.html, a escolha é de sua preferência. Tal como acontece com o arquivo Info.plist, o arquivo HTML é obrigatória e deve residir no diretório raiz do seu projeto widget.
Seu arquivo diggclient.html deve ficar parecido com este:

Porque o nosso widget está usando o WRTKit para elementos da interface do usuário o que não exigem muito HTML. O arquivo de exemplo acima, é muito típico de widgets WRT WRTKit. Quase todo o trabalho real é feito por JavaScript em um widget baseado em WRTKit.
O que precisamos fazer em HTML é definir uma estrutura de documento básico para o seu widget, referindo-se a um ou mais arquivos JavaScript na seção head do seu documento HTML. Normalmente, esses arquivos serão referenciados por JavaScript que contêm a lógica que implementa o seu widget. No caso do nosso tutorial widget, nós nos referimos a diggclient.js, que é o arquivo de nosso widget JavaScript e WRTKit.js que é o ponto de entrada para a biblioteca Nokia UI WRTKit.
Para definir o layout e aparência dos elementos do widget UI, que são incentivados a fazer uso de folhas de estilo em cascata, para que os nossos links de arquivos HTML usem diggclient.css, o nosso widget tem sua própria folha de estilo em cascata. Tecnicamente não haverá nada se você adicionar todos as definições de CSS e JavaScript código no arquivo HTML do widget, mas é mais fácil para gerenciar seus projetos, se você separar o HTML, CSS e JavaScript.
É também de salientar que é perfeitamente possível criar um widget WRT totalmente em HTML sem a utilização de CSS e JavaScript. Esses widgets tendem a não ser visualmente muito atraentes, pois não podem fazer uso da WRTKit ou quaisquer outras bibliotecas JavaScript, no entanto, é possível criar widgets, portanto o uso de Javascript e CSS é opcional e não obrigatória.
Tanto o JavaScript e CSS arquivos, se presentes, podem residir em qualquer diretório dentro do seu projeto widget, incluindo o diretório root.
O nosso widget usa JavaScript e a função chamada quando o elemento é carregado é dado pelo valor do atributo onload do elemento body. Assim, o nosso widget chama a função JavaScript, init () no carregamento.
Icon.png
Observe que Aptana tem incluído um arquivo icon.png nos arquivos do projeto criados. Um ícone é opcional. Se você incluir um ícone para o seu widget, ele deve residir no diretório raiz do seu projeto de widget e deve ser no formato PNG. A resolução recomendada para um ícone é de 88 por 88 pixels. O ícone será dimensionado pelo tempo de execução, dependendo do dispositivo em que o widget está sendo executado. Se você não incluir um ícone para o seu widget, o runtime irá fornecer o ícone padrão da aplicação S60 para representar o seu widget no shell do dispositivo.
diggclient.js
diggclient.js é onde a maior parte da implementação nosso widget pode ser encontrada. Mas ao invés de examinar o arquivo em detalhes agora, vamos voltar a ele depois de ver o seu widget funcionando.

VER PARA CRER

Para ver o widget em ação, basta clicar duas vezes sobre diggclient.html na lista de arquivos em seu projeto Aptana. Aptana irá abrir o arquivo e exibir o conteúdo no painel principal do editor.
Na parte inferior do painel principal em Aptana Studio, você deve ver dois guias - um identificado como "Source", que é o guia aberto por padrão, e uma outra aba chamada "Nokia Web Runtime (WRT)".

Selecione o guia "Nokia Web Runtime (WRT)" e você verá um preview totalmente interativo de seu widget correndo em Aptana Studio. Se tudo estiver certo, você deverá ver algo semelhante a isto:

Brinque com o seu widget. Digite o seu nome na caixa de texto e clique em "Diga Olá!" para receber uma saudação:

Observe que o menu Opções é funcional, dando um exemplo de um simples aviso e uma opção para sair do widget. Nada mau para menos de 15 linhas de HTML! Mas, claro, por enquanto você percebe que o verdadeiro trabalho está sendo feito pelo código JavaScript ainda invisível.

O SCRIPT

No início do script, vamos declarar algumas variáveis JavaScript que seram usadas para representar partes da UI do nosso widget:

Este pequeno bloco de código que mostra inicialmente declaração de variáveis para representar diversos objetos da interface do usuário: uiManager, MainView, helloButton, nameField e aboutLabel. Finalmente, nós declaramos MENU_ITEM_ABOUT, que define a posição do "About" na opção do menu do widget.
uiManager, MainView, helloButton, nameField aboutLabel irão se tornar objetos WRTKit UI. O uiManager se tornará o elemento raiz de uma hierarquia de objetos WRTKit em nosso widget, um ou outro entre MainView ou aboutView será definido como a visão atual sobre o objeto uiManager em todos os momentos. O helloButton & nameField serão controles no MainView e aboutLabel será um controle no aboutView.

NOSSO PONTO DE ENTRADA

Lembre-se da discussão de diggclient.html, que define o atributo onload do documento body de tag HTML a nossa "init ()", significando que esta é a função JavaScript que será chamada quando o nosso documento HTML é carregado. Nós tomaremos a função init() pedaço por pedaço. Para a função, temos o seguinte:

A primeira coisa que fazemos na nossa função init() é montar o nosso menu de opções. Fazemos isso através da criação de um objeto MenuItem, passando a seqüência de caracteres para representar este item no menu, junto com a posição que esse item irá ocupar no menu, o MenuItem é um construtor. Em seguida, partimos MenuItem que é de propriedade onSelect para apontar para uma função que será chamada quando este item de menu é selecionado. Neste caso, queremos que a função menuItemSelected () seja chamada quando o nosso item de menu é selecionado. A última coisa que podemos fazer para representar o nosso menu é acrescentar ao nosso objeto MenuItem widget no menu.
Observe que essa última etapa mostra um outro benefício para a declaração explicita de variáveis, não foi declarado nada chamado "menu" em qualquer lugar, então o JavaScript cria para nós,? Não! Neste caso, o menu é na verdade um objeto fornecido por WRT para cada widget. Na verdade, WRT oferece um conjunto de objetos para cada elemento, o mais fundamentais são:
widget - fornece um conjunto de métodos e propriedades que se aplicam globalmente para o seu widget como um todo. Pode ser acessado através da palavra widget palavra-chave.
menu - oferece APIs para manipular o menu de opções e teclas de seu widget. Podem ser acessados através da palavra-chave menu. Observe que o menu de opções é sempre associado com a tecla esquerda no seu código não se pode mudar isso - uma implicação disso é que o texto da tecla esquerda é sempre "Options", em Inglês, ou o equivalente na língua da interface do usuário atual do dispositivo. Uma opção para sair do widget é sempre acrescentado pelo WRT para o conjunto de itens de menu que seu widget define.
MenuItem - oferece APIs para representar e manipular os itens em um widget de menu. MenuItem é um tipo de referência aos objetos do tipo MenuItem que sempre são criados usando o operador new.
Em seguida, permitir a navegação guia e mostrar as teclas de função - mas apenas se o widget está sendo executado dentro do WRT:

O motor WRT amplia a janela de objeto construído JavaScript com uma nova propriedade, widget. Felizmente, JavaScript permite que você teste para uma propriedade simplesmente avaliando uma expressão da forma object.property, então podemos facilmente testar para ver se nós estamos executando no ambiente WRT pela codificação:

Se window.widget avalia como “true”, o WRT está disponível para nós, mas se a expressão for avaliada como falso, não estamos operando em um ambiente em que o WRT está disponível.
Por que precisamos que se cheque se o ambiente é WRT? Estamos criando um widget WRT não estamos? Bem, sim estamos, mas o cérebro do seu widget são apenas funções JavaScript. O JavaScript pode ser executado em uma variedade de ambientes, tais como navegador de seu PC ou no telemóvel. Além disso, em princípio, alguns ou todos os códigos que compõem o seu widget podem vir de outro lugar - um site, um elemento de outra plataforma, uma biblioteca JavaScript. Alternativamente, você pode reutilizar o código que você escreve para agilizar o seu widget em outro projeto. Para apoiar esses cenários – é de ajuda a depuração - é bom para garantir que você está no ambiente WRT antes de tentar usar WRT e suas características específicas.
Por padrão, o modo de navegação pelo cursor está ativado, mas nós não queremos isso para o nosso widget assim chamamos setNavigationEnabled (false) para ativar a navegação por TAB. Alguns widgets avançados podem utilizar a navegação por cursor, que se baseia na utilização de um ponteiro na tela, similar ao browser S60. Guia de navegação é normalmente usado por widgets simples que têm apenas alguns elementos da interface do usuário, geralmente organizados em uma pilha vertical. Note que o seu widget pode alternar entre guia e navegação por cursor em qualquer tempo, conforme necessário.
Agora é hora de criar alguns objetos de interface do usuário:

Quando criamos nosso projeto widget, nós selecionamos a opção Widget Basic com o apoio de WRTKit. Fizemos isso para que pudéssemos aproveitar os controles de interface do usuário mais ricos fornecidos pela Nokia no WRTKit. Para poder usar o WRTKit, precisamos criar um objeto UIManager que irá gerir a apresentação de pontos de vista do nosso widget e gerir os recursos para nós.
Tendo criado o objeto WRTKit UIManager, criamos duas visões - MainView e aboutView. Observe que ambas as visões são criadas como objetos ListView. ListView é um dos controles de interface do usuário fornecida pelo WRTKit que organiza os controles adicionados à lista de controle como uma pilha vertical. Dois parâmetros são passados para o construtor ListView, sendo que ambos são strings: um id que identifica a exibição da lista resultante e uma legenda que ocupa a área no topo da lista. Uma razão para especificar um id de um objeto deve ser a capacidade de identificar um objeto específico como a fonte de um evento em um manipulador de eventos. No entanto, se você não precisa identificar um determinado objeto em um manipulador de eventos, você pode definir o id como null. A legenda pode ser uma string vazia se você quiser ter uma área de legenda, sem qualquer conteúdo, ou nulo se você quiser uma exibição de lista sem uma área de legenda.
Neste ponto, nós criamos um gerenciador de interface do usuário e dois pontos de vista vazios. Para adicionar algum conteúdo para nossos pontos de vista deve-se fazer o seguinte:

Aqui vamos criar um objeto TextField, que permite que o usuário digite algum texto, como um aviso de "Digite seu nome". Em seguida, adicione o TextField em nosso MainView. Lembrando que MainView é um controle ListView e que controla atualmente o conteúdo como uma pilha vertical, você pode ver que o texto "Digite seu nome" aparecerá no topo da janela, sob a legenda do MainView.
Em seguida, adicione um controle FormButton ao MainView. Um FormButton é um controle de botão de base que nos permite anexar um manipulador de evento (ou EventListener em WRTKit), que será chamado quando a tecla é pressionada. Quando chamamos o construtor FormButton voltamos a passar um id (null) e também uma string que é usada como a etiqueta na face do botão.
Nós vincularemos um manipulador de eventos para o controle FormButton chamando addEventListener() no objeto FormButton, passando o nome do evento que deseja tratar ("ActionPerformed") e o nome da função que queremos fazer a chamada quando o evento ocorre (helloButtonClicked ()). Se você está se perguntando onde o nome do evento "ActionPerformed" vem, ele é definido como um evento da classe abstrata ActionControl, a partir do qual é derivado FormButton.
A visão de cima é trivial e consiste simplesmente em um controle de rótulo que irá mostrar algumas informações sobre o widget para o usuário. Então nós criamos uma instância da classe WRTKit Label e adicioná-lo ao nosso aboutView.
Tudo o que resta para completar a construção e inicialização de nosso widget é simplesmente dizer que o objeto uiManager inicialmente faz a utilização:

BUTTON MANIPULADOR DE EVENTOS E NOTIFICAÇÕES

Vejamos agora o que acontece quando o usuário clica em nosso botão "Diga Olá!". Nós já sabemos que temos configurado o controle FormButton para chamar uma função helloButtonClicked() quando o botão for pressionado. Aqui está o código dessa função:

A fim de apresentar uma notificação pop-up para o usuário, a primeira coisa que precisamos fazer é pegar o texto atual que o usuário tenha digitado no campo de texto, atribuindo o resultado da função getText() no nameField a uma variável.
Chamamos então uiManager 's ShowNotification a (...) para apresentar uma notificação de diálogo ao usuário. Se o nameField está vazio, apresentamos uma nota de aviso, pedindo ao usuário para digitar o seu nome. Se o nameField contém pelo menos um caractere, nós apresentamos uma nota de informação, cumprimentando o usuário para o mundo dos widgets WRT. Em cada caso, três parâmetros são passados para ShowNotification (...):
• duração (em milissegundos) para mostrar a nota
• tipo de nota (que influencia o ícone mostrado na janela)
• mensagem a ser mostrada para o usuário
Quando a duração da nota tiver expirado, a nota é removida da tela e destruída pelo uiManager.
Observe que não se faz uso do parâmetro do evento passado para o nosso manipulador de eventos. Não é necessário neste caso simples, mas vamos olhar novamente para os manipuladores de eventos e as informações passadas a eles mais tarde neste tutorial.

MENU DE MANUSEIO DE EVENTO

Em nosso método init(), definimos a propriedade onSelect aboutMenuItem para se referir à função menuItemSelected(). Sempre "Sobre" é selecionado a partir do nosso menu de opções, a função menuItemSelected () será chamada.

Você pode usar a mesma função para lidar com a seleção de várias ou todas as opções de menu, razão pela qual passa um inteiro WRT id como identificador da função. Esta identificação é a posição do item selecionado no menu. Lembrando que a posição do nosso "Sobre" é definida pela variável MENU_ITEM_ABOUT, você pode ver que sempre que o usuário escolhe "Sobre" no menu de opções, o showAboutView function() é chamado.

showAboutView() define o conteúdo textual do aboutLabel de uma mensagem sobre o software que está incluído em seu widget, passando a mensagem como uma string para a função setText() objeto Label.
Antes de podermos mostrar o aboutView, é preciso modificar as teclas de função em uso. Estamos apenas realmente preocupados com a tecla direita porque se deixá-la como "Exit", não haverá nenhuma maneira para que o usuário retorne à exibição principal do nosso widget. Vamos mudar as teclas de função para o ponto de vista chamando outra função, setAboutViewSoftkeys().
Agora, podemos mostrar ao usuário chamando a função uiManager 'setView(s), passando o objeto aboutView como o parâmetro.

ALTERAR OS SOFTKEYS E RETORNAR PARA A VISTA PRINCIPAL

Como mencionado acima, é preciso mudar a tecla de função direita usada na exibição “Sobre” para fornecer um mecanismo para que o usuário volte à tela principal. Nós poderíamos ter alcançado este objetivo, modificando o menu de opções - talvez por retirar a opção “Sobre” e substituí-la por uma opção principal - mas isso não seria uma solução muito intuitiva.
A forma como vamos conseguir isso é mudar a tecla direita de "Exit" para "Ok". Ao mesmo tempo, vamos atribuir uma função de manipulador para implementar a lógica de comutação de volta à janela principal quando o softkey "Ok " é selecionado pelo usuário. O código para fazer isso é o seguinte:

Como você pode ver a partir do código, a função que é chamada quando o usuário seleciona o softkey "Ok" é showMainView():

showMainView() redefine o softkey direito como "Exit", limpando o texto atualmente atribuído à tecla de função direita e definindo a função de manipulador para null. Avisos WRT fornecem a saída do texto e uma função de manipulador adequado automaticamente.
Então tudo o que precisamos fazer para voltar a exibição principal do nosso widget é dizer ao uiManager para mostrar o nosso MainView novamente.

Referências

Marcos Fábio – Apresentação ministrada no embedded;
Vídeo aulas editora Europa – JavaScript e HTML;
http://forum.nokia.com/taglibs/fn-1.0;
http://developer.symbian.org/wiki/index.php