UNIVERSIDADE FEDERAL DE SANTA CATARINA DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICA

CURSO DE CIÊNCIAS DA COMPUTAÇÃO

FRANCISCO DE ASSIS BESEN HILLESHEIM

X SWING MENU: UMA FERRAMENTA PARA CONSTRUÇÃO DE MENUS JAVA SWING UTILIZANDO

XML

FLORIANÓPOLIS, 2004

UNIVERSIDADE FEDERAL DE SANTA CATARINA DEPARTAMENTO DE INFORMÁTICA E ESTATÍSTICA

CURSO DE CIÊNCIAS DA COMPUTAÇÃO

FRANCISCO DE ASSIS BESEN HILLESHEIM

X SWING MENU: UMA FERRAMENTA PARA CONSTRUÇÃO DE MENUS JAVA SWING UTILIZANDO

XML

Orientador: Prof. Dr. Leandro José Komosinski

Membros da Banca:

Prof. Dr.José Leomar Todesco Prof Dr. Roberto Carlos dos Santos Pacheco

FLORIANÓPOLIS, 2004

RESUMO

A criação e manutenção de interfaces gráficas de usuário representa um ponto crítico

no desenvolvimento de software em geral. Para resolver este problema, várias ferramentas e

arquiteturas foram concebidas no decorrer dos anos.

Este trabalho apresenta a ferramenta XSwingMenu que utiliza XML para criação de

objetos gráficos Java Swing referentes a barras de menu. Seu funcionamento consiste na

geração de código Java a partir de um documento XML por meio de transformações do

documento via XSLT. Além disso, XSwingMenu também provê suporte ao processo inverso,

ou seja, extração de um documento XML a partir de uma barra de menu codificada em Java

Swing já existente.

Palavras-chave: Java – XML – interface gráfica

ABSTRACT

The creation and maintenance of graphical user interfaces in general represent a

critical point in the software development. To solve this problem, some tools and

architectures had been conceived in the elapsing years.

This work presents a tool called XSwingMenu that uses XML for creating Java Swing

graphical objects describing menu bars. Its functioning consists of Java code generation from

a XML document by means of transformations of the XML document through XSLT.

Moreover, XSwingMenu also provides support to the inverse process, in another words,

extration of a document XML from a pre-existent menu bar coded in Java Swing.

Key-words: Java – XML – graphic interface

Índice de figuras

Figura 1 Exemplo de documento em XAML........................................................................ 12 Figura 2 Processo de renderização do XAML ...................................................................... 12 Figura 3 Helloworld em SwiXml ......................................................................................... 13 Figura 4 Renderização Helloworld em SwiXml.................................................................... 14 Figura 5 Execução programa Java........................................................................................ 16 Figura 6 Exemplo de barra de menu em Java Swing............................................................. 18 Figura 7 Classes relacionadas a menu em Java Swing .......................................................... 18 Figura 8 Processo de transformação de documentos XML ................................................... 22 Figura 9 Exemplo simplificado da especificação XML Schema ........................................... 24 Figura 10 Figura simplificada de script XSLT...................................................................... 27 Figura 11 Etapas do processo de geração de código ............................................................. 29 Figura 12 Estrutura de classes simplificada .......................................................................... 34 Figura 13 Exemplo de documento de XML de entrada......................................................... 39 Figura 14 Exemplo de erro de validação de um documento XML ........................................ 40 Figura 15 Exemplo de transformação bem sucedida ............................................................. 42 Figura 16 Classe gerada a partir do arquivo Exemplo1.xml .................................................. 44 Figura 17 Exemplo de classe de teste gerada automaticamente............................................. 45 Figura 18 Renderização da classe gerada.............................................................................. 45

Índice de tabelas

Tabela 1 Descrição dos elementos da linguagem.................................................................. 32 Tabela 2 Elementos da linguagem........................................................................................ 32 Tabela 3 Descrição dos atributos da linguagem .................................................................... 33 Tabela 4 Atributos da linguagem.......................................................................................... 34 Tabela 5 Comparação entre XSwingMenu e SwiXml........................................................... 37

SUMÁRIO

1 INTRODUÇÃO.................................................................................................................. 8 1.1 Contexto....................................................................................................................... 8 1.2 Objetivos...................................................................................................................... 8

1.2.1 Objetivo Geral ....................................................................................................... 8 1.2.2 Objetivos Específicos ............................................................................................ 8

1.3 Metodologia ................................................................................................................. 9 2 ESTADO DA ARTE......................................................................................................... 10

2.1 Soluções existentes..................................................................................................... 10 2.2 XUL........................................................................................................................... 10 2.3 XAML ....................................................................................................................... 11 2.4 Um Exemplo utilizando XML e Java Swing............................................................... 13

2.4.1 SwiXml ............................................................................................................... 13 3 SOLUÇÃO PROPOSTA................................................................................................... 15

3.1 Primeira parte............................................................................................................. 15 3.2 Segunda parte............................................................................................................. 16 3.3 Tecnologias envolvidas .............................................................................................. 16

3.3.1 Java, Java Swing e Menus ................................................................................... 16 3.3.2 XML ................................................................................................................... 18 3.3.3 W3C XML Schema ............................................................................................. 20 3.3.4 XSLT .................................................................................................................. 20

4 DESENVOLVIMENTO ................................................................................................... 23 4.1 Primeiro ciclo de desenvolvimento............................................................................. 23

4.1.1 Especificação da linguagem................................................................................. 23 4.1.2 Validador da linguagem....................................................................................... 25

4.2 Segundo ciclo de desenvolvimento............................................................................. 25 4.2.1 Transformador XSLT .......................................................................................... 25 4.2.2 Criação da GUI.................................................................................................... 27 4.2.3 Funcionalidades adicionais .................................................................................. 27

5 XSWINGMENU............................................................................................................... 29 5.1 Descrição ................................................................................................................... 29 5.2 Especificação da linguagem ....................................................................................... 31

5.2.1 Descrição dos elementos...................................................................................... 31 5.2.2 Elementos............................................................................................................ 32 5.2.3 Descrição dos atributos........................................................................................ 33 5.2.4 Atributos ............................................................................................................. 33

5.3 Estrutura de classes simplificada ................................................................................ 34 5.4 Tratamento de eventos................................................................................................ 35 5.5 Gerador de documentos XML .................................................................................... 36 5.6 Comparação entre XSwingMenu-0.2 e SwiXml-1.2 ................................................... 36

6 UM EXEMPLO UTILIZANDO XSWINGMENU............................................................ 38 6.1 Requerimentos ........................................................................................................... 38 6.2 Criação da especificação do Menu.............................................................................. 38 6.3 Iniciando o XSwingMenu........................................................................................... 39 6.4 Validando o arquivo XML.......................................................................................... 39 6.5 Transformando o arquivo XML em classe Java .......................................................... 41 6.6 Resultado ................................................................................................................... 42

7 CONCLUSÃO.................................................................................................................. 46 7.1 Trabalhos futuros ....................................................................................................... 46

8 REFERÊNCIAS BIBLIOGRÁFICAS............................................................................... 48 9 ANEXOS.......................................................................................................................... 50

9.1 Código fonte .............................................................................................................. 50 9.2 Artigo......................................................................................................................... 50

8

1 INTRODUÇÃO

1.1 Contexto

No desenvolvimento de software em geral, a construção de interfaces gráficas de

usuário (GUI) consiste em uma tarefa que requer um alto grau de esforço na maioria das

linguagens de programação usuais. Em decorrência desse fato, várias tentativas de simplificar

este processo foram realizadas, com e sem sucesso, ao longo dos anos. Em Java Swing,

biblioteca incorporada à linguagem Java que permite o desenvolvimento de interfaces gráficas

de usuário, este fato também ocorre.

Com a ascensão da especificação XML nos últimos anos e o surgimento de diversas

ferramentas para sua utilização, principalmente em Java, é razoável que seu uso para

especificação de interfaces gráficas de usuário seja uma alternativa para minimizar o esforço

necessário no seu desenvolvimento.

1.2 Objetivos

1.2.1 Objetivo Geral

Definir uma linguagem baseada em XML para especificação de objetos visuais da

biblioteca Swing de Java, juntamente com uma ferramenta para manipulação de documentos

XML baseados nessa linguagem visando aumentar a produtividade com relação a codificação

destes objetos visuais.

1.2.2 Objetivos Específicos

Permitir a especificação de barras de menu através da linguagem a ser criada. Além

disso, desenvolver uma biblioteca Java que, quando incorporada a uma aplicação, gere

objetos Swing (interface gráfica em Java) relativos ao menu desta aplicação a partir de um

9

documento XML. Assim, para o programador, a implementação do menu de seu programa se

resumiria a especificar os seus itens no formato XML.

Outro objetivo específico e pessoal seria o contato e o aprendizado das diversas

tecnologias relacionadas à manipulação de documentos XML.

1.3 Metodologia

Na fase inicial, uma pesquisa bibliográfica será realizada sobre as soluções já

existentes, juntamente com os conceitos e tecnologias abordados. Em seguida, será definido

uma proposta de solução para alcançar os objetivos traçados através do desenvolvimento de

uma ferramenta escrita em Java. Esta ferramenta, então, será responsável pela interpretação de

documentos XML que deverão estar de acordo com uma especificação referente aos objetos

gráficos em pauta (barra de menu e seus componentes) que também será desenvolvida.

Por fim, uma comparação da ferramenta desenvolvida com as demais pesquisadas

será realizada para demonstrar as suas principais diferenças, além de um exemplo prático de

como a ferramenta pode ser utilizada.

10

2 ESTADO DA ARTE

2.1 Soluções existentes

Durante muitos anos, várias tentativas de se melhorar o desenvolvimento de GUI

foram realizadas. Atualmente, pode-se encontrar diversas tecnologias multi-plataforma que

melhoraram, sim, o desenvolvimento de GUI´s, porém não são muitos eficientes (Ex:

XWindows e Xt, Smalltalk, e diversas bibliotecas de classes como Xaw, GTK, Qt, Java AWT

e Swing). Essas soluções são poderosas, mas ainda precisam do aprendizado de uma

biblioteca.

Em contrapartida, a utilização de XML ao invés de bibliotecas representa uma

solução interessante. Uma prova disso é a linguagem XUL (XML-based User-Interface

Language) que faz parte do projeto Mozilla e que já é utilizada, como por exemplo, no

browser Mozilla. Outra linguagem é XAML (Extensible Application Markup Language) que

é um dialeto XML que desenvolvedores utilizarão para construir aplicativos para o Longhorn,

a nova versão do sistema operacional Microsoft Windows.

XUL e XAML representam os maiores projetos nesta área, porém, vários outros

projetos com propostas semelhantes também podem ser encontrados. A seguir, alguns

exemplos dos principais projetos de código aberto nesta área: SwiXml, ThinLet, MyXAML,

Xulux, JellySwing/JellySWT e SwingML.

2.2 XUL

XUL é uma linguagem de interface de usuário baseada em XML do projeto Mozilla

que permite construir aplicativos multi-plataforma que podem rodar conectados ou

desconectados da Internet. A seguir segue suas principais características:

• Linguagem de marcação poderosa com suporte aos elementos clássicos de GUI

(widgets);

• Baseada em padrões existentes (Ex: Javascript e Cascading Style Sheets);

11

• Multi-plataforma;

• Separação da apresentação da lógica da aplicação;

• Fácil manutenção.

Além disso, existem outras tecnologias que são utilizadas pelo XUL como:

• XBL (Extensible Binding Language): uma linguagem de marcação que define

novos elementos para os widgets do XUL.

• Overlays: representam arquivos XUL utilizados para descrever conteúdos extra

para a UI.

• XPCOM/XPConnect: tecnologias complementares que permitem a integração de

bibliotecas externas à aplicações XUL.

• XPInstall: Mecanismo de instalação multi-plataforma do Mozilla.

XUL representa uma nova idéia de desenvolvimento de aplicações visto que

desenvolvedores habituados com os padrões tecnológicos do W3C1 podem utilizar seus

conhecimentos de programação em browsers diretamente nas aplicações desktop.

2.3 XAML

XAML define uma UI de aplicação com marcações representando controles padrões

do Windows. A seguir segue um exemplo para um formulário de Login:

<Canvas xmlns="http://schemas.microsoft.com/2003/XAML" ID="LoginPage"> <Label ID="lblUserId" FontFamily="verdana" FontSize="8" Canvas.Top="10" Canvas.Left="10"> User ID:</Label> <TextBox ID="txtUserId" FontSize="8" Canvas.Top="8" Canvas.Left="75"></TextBox> <Label ID="lblPassword" FontFamily="verdana" FontSize="8" Canvas.Top="35" Canvas.Left="10">Password:</Label> <TextBox ID="txtPassword" FontSize="8" Canvas.Top="33" Canvas.Left="75"></TextBox>

1 World Wide Web Consortium – Consórcio internacional de empresas envolvidas com a Internet e a Web.

12

<Button ID="cmdOK" Width="50" Canvas.Top="60" Canvas.Left="155">OK</Button> </Canvas>

Figura 1 Exemplo de documento em XAML

Neste exemplo, pode-se observar a idéia de XAML onde cada página é definida por

um arquivo XAML. Cada página possui um painel raiz (Canvas, DockPanel ou FlowPanel)

onde os elementos gráficos são definidos. Para criar uma aplicação, basta desenvolver um

arquivo .proj para agrupar os arquivos XAML e definir as opções de compilação, como

informação sobre a versão e se a aplicação irá rodar em um browser ou em uma janela. O

processo de renderização está demonstrado a seguir:

Figura 2 Processo de renderização do XAML

Com relação à adição de código, ela pode ser feita dentro do próprio documento

XAML ou em arquivos diferentes. As linguagens de programção aceitas são Microsoft Visual

Basic® .NET ou C#. Sobre o tratamento de eventos, ele deve ser escrito através destas

linguagens.

A renderização do XAML não é multi-plataforma porque ele constrói, a partir dos

documentos XML, objetos Avalon (que são nativos da nova versão do Microsoft Windows)

que são responsáveis pela renderização. Tal fato torna essa tecnologia dependente da

plataforma Windows. Atualmente, como o novo sistema operacional ainda não foi lançado, a

utilização de XAML ainda é incipiente.

13

2.4 Um Exemplo utilizando XML e Java Swing

A seguir, será visto um exemplo de como se pode utilizar esses novos conceitos com

a biblioteca Java Swing.

2.4.1 SwiXml

SwiXml é um pequeno motor de geração de interfaces gráficas de usuário para

aplicações Java e applets. A interface gráfica é definida através de documentos XML que são

analisados e renderizados em tempo de execução em objetos Swing.

Suas principais características são listadas a seguir:

• Focada exclusivamente na biblioteca javax.swing;

• Programadores acostumados com a biblioteca Swing podem utilizar SwiXml sem

maiores preocupações;

• SwiXml é rápido pois não adiciona novas camadas sob os objetos Swing;

• SwiXml é pequeno visto que seus componentes, presentes no arquivo swixml.jar,

ocupam 40 Kbytes.

• Só se preocupa com a interface gráfica. O comportamento dinâmico da interface e

a lógica de negócio devem ser implementados em Java.

Para se utilizar o motor do SwiXml basta acoplar, a um aplicativo Java, sua

biblioteca de classes contida no arquivo swixml.jar. Em seguida, basta invocar a classe

org.swixml.SwingEngine que é responsável pela renderização do documento XML. Eis um

exemplo de documento XML que pode ser usado:

<?xml version="1.0" encoding="UTF-8"?> <frame size="640,480" title="Hello SWIXML World" DefaultCloseOperation="JFrame.EXIT_ON_CLOSE"> <panel constraints="BorderLayout.CENTER"> <label LabelFor="tf" Font="Comic Sans MS-BOLD-12" Foreground="blue" text="Hello World!"/> <textfield id="tf" Columns="20" Text="Swixml"/> <button Text="Click Here" Action="submit"/> </panel> </frame>

Figura 3 Helloworld em SwiXml

14

A seguir, a sua renderização:

Figura 4 Renderização Helloworld em SwiXml

Pode-se notar, através do exemplo, que usuários já habituados com a biblioteca

Swing não teriam problemas em utilizar este motor visto que a linguagem utilizada no seu

documento XML é parecida com a nomenclatura utilizada na biblioteca Java Swing. Apesar,

de apresentar um número de linhas de código menor e código mais claro (devido a hierarquia

dos elementos).

A questão agora é como os eventos e o comportamento dinâmico dos objetos Swing

seriam tratados. Pois bem, nas marcações utilizadas no documento XML pode-se definir o

atributo id, que deve ser único no documento, que representará o nome do objeto Swing

correspondente à marcação. Se desejado enviar mensagens ao objeto Swing, basta declarar

uma variável com o mesmo nome do atributo id. Caso um evento seja registrado no

documento XML, um objeto da classe javax.swing.Action deve ser declarado, onde o evento

será tratado. Estes atributos devem estar presentes em uma classe qualquer que deve ser

passada como parâmetro para a classe responsável pela renderização do documento.

Portanto, SwiXml é um exemplo prático de como a utilização de XML e Java Swing

pode ser realizada.

15

3 SOLUÇÃO PROPOSTA

A seguir, será descrita uma maneira de se alcançar os objetivos propostos utilizando-se

de padrões de manipulação de documentos XML estabelecidos pelo W3C para elaboração da

ferramenta XSwingMenu. Esta proposta de solução está divida em duas partes distintas:

3.1 Primeira parte

A primeira parte da solução do problema consistiria na geração de código Java a partir

de um documento XML, o que representa um diferencial em relação às outras soluções

existentes. Para que isto possa ser realizado, uma especificação de linguagem baseada em

XML deve ser criada. Para isso será utilizada uma especificação definida em W3C XML

Schema.

Com a especificação em mãos, uma ferramenta de verificação e validação dos

documentos XML, de acordo com o esquema XML definido, será desenvolvida para

encontrar possíveis erros nos documentos XML e assegurar que o processo de geração de

código seja consistente.

Para a geração de código Java, considerada a tarefa mais complexa, a idéia inicial é

utilizar a linguagem XSLT para especificar como a transformação dos documentos XML, já

checados e validados, será realizada. Caso a utilização da linguagem XSLT não abranger toda

o processo de geração de código, parte da biblioteca, será responsável por esta tarefa.

Para o desenvolvimento de todas essas tarefas será criado um programa escrito na

linguagem Java juntamente com as bibliotecas Xerces e Xalan, provenientes do projeto

Apache, para a manipulação dos documentos XML. A escolha destas bibliotecas é em virtude

do fato de pertencerem ao respeitável projeto Apache, por serem de código aberto, por

proverem juntas suporte a W3C XML Schema e XSLT, e, finalmente, por serem largamente

utilizadas por várias outras aplicações. Com relação a W3C XML Schema e a XSLT, sua

utilização foi escolhida por serem padrões W3C.

16

3.2 Segunda parte

A segunda parte da solução seria permitir o processo inverso da primeira parte, ou

seja, gerar um documento XML a partir de uma classe Java existente. Para isso, uma idéia é

utilizar reflexão computacional, além das bibliotecas já citadas na primeira parte.

Essa tarefa teria como objetivo automatizar, em partes, a migração de aplicações já

existentes que possuem barra de menu definida para que a solução tenha uma maior

abrangência. Porém, esta parte do projeto só será realizada se o andamento de

desenvolvimento da primeira parte terminar em tempo hábil. Além disso, esta parte pode ser

considerada um bom desafio por envolver outras áreas.

3.3 Tecnologias envolvidas

A seguir, as tecnologias abordadas pela solução proposta serão descritas.

3.3.1 Java, Java Swing e Menus

Java é uma linguagem de programação orientada a objetos criada pela Sun

Microsystems. Java é multiplataforma, ou seja, um programa Java pode rodar em qualquer

plataforma que disponha de uma Máquina Virtual Java como mostra a figura a seguir:

Figura 5 Execução programa Java

17

O processo de compilação de um programa Java produz bytecodes (instruções de

máquina simplificados específicos da plataforma Java). Após isso, bytecodes Java podem ser

interpretados por uma Máquina Virtual Java qualquer, escrita em código nativo, que traduz os

bytecodes em código executável.

A linguagem Java pode ser utilizada em 3 plataformas distintas, definidas pela Sun:

• Java 2 Plataform, Micro Edition – para ambientes com recursos limitados;

• Java 2 Plataform, Standard Edition – para ambientes desktop;

• Java 2 Plataform, Enterprise Edition – para ambientes distribuídos e internet.

Neste trabalho, o foco é a plataforma J2SE, especialmente a biblioteca para construção

de interfaces gráficas de usuário Java Swing que é parte integrante da JFC2.

Java Swing, que foi anunciada em 1997, é uma biblioteca gráfica multi-plataforma

para Java. Ela substitui a a biblioteca anteriormente utilizada: Abstract Windowindo Toolkit

(AWT) que tinha como base para renderização de widgets3 bibliotecas nativas. A principal

característica de Java Swing é dispor de um mecanismo de troca de look and feel para todos

os componentes gráficos através de pequenas alterações subtanciais.

Como grande parte das bibliotecas gráficas existentes, Java Swing possui

componentes que suportam a idéia de menus. Menus são componentes gráficos que permitem

a seleção de uma opção entre várias possíveis. Menus são geralmente usados para

disponibilizar acesso a opções como salvar ou abrir um arquivo, sair de um programa, entre

outros. Por convenção, os menus possuem um posicionamento diferente dos demais

componentes gráficos pois são agrupados em uma barra de menu ou em um popup menu. A

seguir, um exemplo de barra de menu com todos os componentes possíveis:

2 Java Foundation Classes – Framework gráfico para construção de interfaces gráfica de usuário baseado em Java. É composto pelas bibliotecas AWT, Swing e Java2D. 3 Widget – Componente gráfico, ou controlador, que o usuário pode interagir. Menus, janelas e botões são exemplos de widgets.

18

Figura 6 Exemplo de barra de menu em Java Swing

Neste trabalho, apenas a construção de barras de menus e seus subcomponentes serão

abordados. Abaixo será descrita a hierarquia de classes de Java Swing que representa os

componentes de um menu:

Figura 7 Classes relacionadas a menu em Java Swing

Basicamente, uma barra de menu é composta por um objeto JMenuBar, que possui

objetos da classe JMenuItem (que, através de herença, podem ser também objetos das classes

JMenu, JCheckboxMenuItem e JRadioButtonMenuItem) e/ou JSeparator. Além disso, a

classe JMenu também é composta por objetos JMenuItem e/ou JSeparator.

3.3.2 XML

19

XML (Linguagem de marcação estensível) é uma linguagem de marcação simples,

derivada de SGML. Seu objetivo principal é facilitar o compartilhamento de textos

estruturados e informação através da Internet. XML, que foi desenvolvida em 1996 pelo XML

Working Group (coordenado por Jon Bosak da Sun Microsystems), virou uma recomendação

da W3C em 1998.

A seguir serão listadas algumas características de XML:

• Compatibilidade com a Web e os protocolos da Internet;

• Legível para humanos e para máquinas;

• Suporte a codificação Unicode;

• Permite representar as principais estruturas de dados (registros, listas e

árvores);

• Sintáxe rígida torna os algoritmos de análise rápidos e eficientes;

• Constitui um padrão internacional;

• Utiliza arquivo de texto comum, ou seja, não está atrelado a tecnologia alguma;

• Independente de plataforma.

A linguagem XML pode ser utilizada em diversos tipos de aplicações como uma

maneira de representar dados. Estes dados podem ser provenientes de um banco de dados, de

um arquivo de configuração, entre outros meios.

Em XML é possível fazer validação de um documento, ou seja, garantir que sua

estrutura está de acordo com um determinado esquema. Para especificação de um esquema,

existem duas tecnologias mais utilizadas: DTD (Document Type Definition) e XML Schema.

DTD não é feito em XML e possui uma abrangência menor que o XML Schema (que será

descrito no próximo tópico). Além de validação de documentos, os dados de um documento

XML podem ser transformados em outro tipo de representação (por exemplo: XML, HTML,

PDF ou texto simples) via XSL.

Para processamento de um documento XML existem várias API´s baseadas em alguns

modelos que podem ser utilizados para analisar e manipular estruturas XML. Um desses

modelos seria DOM (Document Object Model) que é baseado em objetos, onde cada parte do

documento é descrita como um tipo de nó. Esses nós, então, são agrupados em uma estrutura

20

de árvore. Existem implementações de DOM para diversas linguagens como Java, C++, Perl e

Python. Outro modelo popular seria SAX (Simple API for XML) que é um modelo baseado

em eventos, onde um documento XML é traduzido em diversas chamadas a métodos (como

startElement()). DOM e SAX possuem suas vantagens e desvantagens que devem ser levadas

em consideração de acordo com o contexto onde forem utilizados.

3.3.3 W3C XML Schema

W3C XML Schema é uma linguagem XML utilizada para descrever e restringir o

conteúdo de documentos XML. W3C XML Schema é uma recomendação W3C.

Um documento que está conforme um determinado esquema é dito válido e o processo

de checagem é chamado validação. A validação pode ser dividida basicamente em dois

momentos: validação da marcação (análise estrutural do documento) e validação do conteúdo

individual de cada nó (chamado de datatyping).

Além do W3C XML Schema existem outras linguagens de definição de esquema para

XML. Dentre elas estão: DTD, RELAX NG, Schematron e Examplotron. A mais comumente

utilizada é DTD (que apresenta um fraco suporte a datatyping), o que faz do W3C XML

Schema uma linguagem promissora.

3.3.4 XSLT

XSLT (Extensible Stylesheet Language Transformations) é uma linguagem que

permite transformar documentos XML em outros documentos XML, em documentos HTML

ou em qualquer outra coisa. Uma transformação da linguagem XSLT é feita através de um

documento XML bem-formado, chamado “folha de estilo”, que utiliza elementos e atributos

XML especializados definidos pelo Namespace4 específico da linguagem (chamado XSLT

Namespace). XSLT é uma recomendação W3C (assim como XML e XML Schema).

4 Namespace – representa um padrão W3C para identificar unicamente os elementos e atributos de um documento XML. Serve para resolver possíveis amibuidades.

21

O XSLT é tecnicamente parte da XSL (Extensible Stylesheet Language). A

especificação descreve XSL como uma família de recomendações constituida de três partes:

uma linguagem para transformar documentos XML (XSLT), uma linguagem de expressão

utilizada em XSLT para acessar ou referenciar partes de um documento XML (XPATH) e um

vocabulário XML para descrever como formatar conteúdo de documentos (XSL-FO).

Além de XSLT, existem outras alternativas para transformar documentos XML. Duas

categorias possíveis seriam (DUCHARME, 2002, p.6):

• XML relacionadas a bibliotecas adicionadas a linguagens de programação de

finalidade geral como Java, Perl, Visual Basic, Python e C++;

• Linguagens como OMNImark e Balise, projetadas especificamente para

manipular documentos XML (e tipicamente SGML).

O que diferencia XSLT das outras alternativas é que XSLT é um padrão. Isto significa

que muitos fabricantes contribuiram para este projeto e que estão comprometidos em usá-lo

em seus produtos.

A geração de código utilizando transformação de documentos (SAKAR,

CLEAVELAND, 2001) via XSLT é possível através somente de scripts XSLT juntamente

com expressões XPATH. Ainda, a geração de código é bastante flexível visto que a adição de

novos elementos e atributos no documento XML de entrada não afeta os scripts de geração de

código.

A seguir, uma figura explicando o processo de geração de um documento XML via

um processador XSLT:

22

Figura 8 Processo de transformação de documentos XML

23

4 DESENVOLVIMENTO

O objetivo deste capítulo é mostrar a maneira como foi desenvolvida a ferramenta

XSwingMenu ressaltando as dificuldades e alguns detalhes de implementação importantes

com relação as tecnologias utilizadas. Este capítulo foi dividido em dois ciclos, como descrito

anteriormente, de acordo com a solução proposta.

4.1 Primeiro ciclo de desenvolvimento

Na primeira etapa de desenvolvimento, foram alcançados dois objetivos: a

especificação da linguagem a ser utilizada nos documentos XML e o desenvolvimento de um

validador referente a esta especificação criada.

4.1.1 Especificação da linguagem

A criação da linguagem foi baseada na linguagem aceita pelo SwiXml, porém com

diversas modificações. Primeiramente, foi levado em consideração apenas as marcações

referentes à barra de menu e seus subcomponentes que serão apresentados a seguir:

• <menubar>

- filhos: <menu>

• <menu>

- filhos: <grupo>, <menuitem>, <checkboxmenuitem>, <radiobuttonmenuitem>,

<separador> e <menu>

• <grupo>

- filhos: <radiobuttonmenuitem>

• <menuitem>

• <checkboxmenuitem>

• <radiobuttonmenuitem>

• <separador>

24

As quatro primeiras marcações descritas acima possuem atributos, sendo que todas

essas marcações possuem o atributo “id” que serve como identificação dos objetos que serão

futuramente descritos (nos elementos <menu> e <grupo> este atributo é opcional).

Em seguida, foi prosposta uma especificação XML Schema que contemplasse a

linguagem definida. A seguir, um trecho do que foi especificado para um subconjunto da

linguagem:

<?xml version="1.0" encoding="UTF-8"?> <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"> <xs:element name="menubar"> <xs:complexType> <xs:sequence> <xs:element ref="menu" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="id" type="xs:ID" use="optional"/> </xs:complexType> </xs:element> <xs:element name="menu"> <xs:complexType> <xs:sequence minOccurs="0" maxOccurs="unbounded"> <xs:element ref="separador" minOccurs="0" maxOccurs="unbounded"/> <xs:element ref="menuitem" minOccurs="0" maxOccurs="unbounded"/> <xs:element ref="menu" minOccurs="0" maxOccurs="unbounded"/> </xs:sequence> <xs:attribute name="id" type="xs:ID" use="optional"/> <xs:attribute name="texto" type="xs:string" use="optional"/> </xs:complexType> </xs:element> <xs:element name="menuitem"> <xs:complexType> <xs:attribute name="id" type="xs:ID" use="required"/> <xs:attribute name="texto" type="xs:string" use="optional"/> <xs:attribute name="icone" type="xs:string" use="optional"/> <xs:attribute name="acelerador" type="xs:string" use="optional"/> </xs:complexType> </xs:element>

Figura 9 Exemplo simplificado da especificação XML Schema

Pode-se notar, a partir do esquema acima, que o tipo “xs:ID” está sendo utilizado pelo

atributo id de todos os elementos. Com isso, garante-se que o valor presente em cada atributo

id seja único no documento XML. Vale ressaltar que para a confecção deste XML Schema foi

feito baseado no tutorial gratuito fornecido pela W3Schools5.

5 W3Schools – Site onde pode-se encontrar vários tutorias sobre tecnologias utilizadas pela WEB. Disponível em: <http://www.w3schools.com/>.

25

4.1.2 Validador da linguagem

O validador tem como função analisar um documento XML de acordo com a

especificação Schema desenvolvida e, após essa análise, determinar se o documento XML é

válido ou não indicando, em caso negativo, onde estão as inconsistências. Vale lembrar que

um documento XML só pode ser validado se ele estiver bem-formado, ou seja, obece as

regras básicas que todo documento XML deve obedecer.

Para a construção do validador foi utilizada a biblioteca Xerces Java Parser 2.5.0

(Projeto XML Apache) que apresenta suporte para a recomendação XML Schema versão 1.0.

Sendo assim, a tarefa se resumiu em utilizar classes já prontas da biblioteca e em construir um

tratador de erros referentes aos possíveis problemas provenientes do processo de validação de

um documento XML.

4.2 Segundo ciclo de desenvolvimento Nesta etapa foi desenvolvido o transformador XSLT responsável pela geração de uma

classe Java que estende de javax.swing.JMenuBar a partir de um documento XML já validado

frente a especifição descrita. Além disso, o refactoring das classes existentes referentes ao

validador foi realizado, juntamente com uma GUI (Interface Gráfica de Usuário) englobando

o validador e o transformador desenvolvidos.

Por fim, foram criadas duas ferramentas adicionais: o gerador de XML a partir de

objetos javax.swing.JMenuBar e automatizador do processo de teste de renderização.

4.2.1 Transformador XSLT Como descrito na solução proposta, para criação do transformador de documentos

XML para classes Java utilizou-se a linguagem XSLT. O processo de transformação pode ser

dividido em dois momentos: Adição de identificadores omitidos (XML – XML) e Geração de

código Java (XML – Java).

26

Na primeira parte, o documento XML validado é sujeito a uma transformação XML –

XML com intuito de garantir que todos os elementos contidos no documento possuam um

identificador único (representado no atributo id da especificação). Tal processo é realizado

pois na etapa seguinte, o atributo id será utilizado como identificador do objeto gerado por

cada elemento.

Na segunda parte, após a adição dos identificadores, a criação da classe Java resultante

é realizada. Para isso, cada elemento do documento é mapeado para um componente Java

Swing específico relacionado a construção de menus. Como no validador, esse processo de

transformação é automatizado pela biblioteca Xalan-Java versão 2.6.0 (que implementa XSLT

versão 1.0 e XPath versão 1.0), o que significa dizer que toda especificação da transformação

está contida em arquivos do tipo XSL.

A seguir, um exemplo simplificado de como o XSLT foi utilizado para construção do

cabeçalho da classe gerada juntamente com a definição de atributos:

<?xml version="1.0" encoding="UTF-8"?> <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0"> <xsl:output method="text" indent="no"/> <xsl:strip-space elements="*"/> <xsl:template match="menubar"> /* * <xsl:value-of select="@id"/>.java * * Codigo gerado automaticamente pelo XSwingMenu 0.2 * Francisco Hillesheim - hillen@inf.ufsc.br */ public class <xsl:value-of select="@id"/> extends javax.swing.JMenuBar { <xsl:for-each select="descendant::menu"> protected javax.swing.JMenu <xsl:value-of select="@id"/>; </xsl:for-each> <xsl:for-each select="descendant::menuitem"> protected javax.swing.JMenuItem <xsl:value-of select="@id"/>; </xsl:for-each> public <xsl:value-of select="@id"/>() { inicializaComponentes(); } private void inicializaComponentes() { <xsl:apply-templates/>

27

} } </xsl:template>

Figura 10 Figura simplificada de script XSLT

Pode-se notar no exemplo de como as expressões XPATH são utilizadas em XSLT e

como são poderosas visto a maneira simplificada de se realizar a declaração dos atributos.

Outro ponto, é que XSLT é uma linguagem funcional o que pode não agradar a todos os

desenvolvedores.

4.2.2 Criação da GUI Após o validador e o transformador prontos, uma interace de usuário foi elaborada

para viabilizar as duas funcionalidades. Primeiramente, o usuário tem a opção de escolher o

arquivo XML a ser analisado. O conteúdo desse arquivo aparece na tela para verificação pelo

usuário. Com isso, o usuário pode, então, chamar o processo de validação. Se a validação for

efetuada com sucesso, o usuário escolhe o local onde deseja gerar a classe Java e pode chamar

o processo de transformação. Caso contrário, se a validação não for bem sucedida, a interface

gráfica deve mostrar os erros de validação que ocorreram.

A interface gráfica, como não poderia deixar de ser, foi feita em Java Swing. A

ferramenta utilizada para sua elaboração foi (como todo o código da ferramenta) o Netbeans6

3.6.

4.2.3 Funcionalidades adicionais

Para complementar as funcionalidades do XSwingMenu, foram adicionadas duas

ferramentas: gerador de XML e automatizador de testes de renderização.

O gerador de XML foi feito a partir da leitura de todos os componentes presentes em

um javax.swing.JMenuBar. A cada componente encontrado era montado um elemento

correspondente a linguagem criada que depois era adicionado a uma árvore DOM. Ao final do

6 Netbeans – Ferramenta para desenvolvimento de programas Java. Disponível em: <http://www.netbeans.org/>.

28

processo, esta árvore DOM era traduzida em um documento XML. Para todos esses processos

foi utilizadas classes presente na biblioteca Xerces, o que simplificou todo esse processo de

manipulação da árvore DOM.

Já com relação ao automatizador de teste de renderização, foi elaborado um

mecanismo de se chamar os processos “java” e “javac” para execução e compilação das

classes criadas. No mais, uma classe utilitária foi adicionada na ferramenta para possuir o

código da classe de teste (visto que ele é praticamente imutável). Com essa funcionalidade, o

processo de teste da barra de menu feita a partir do documento XML fica mais produtivo.

29

5 XSWINGMENU

5.1 Descrição

XSwingMenu é uma ferramenta para criação de menus Java Swing através de

documentos XML. Seu cerne consiste na geração de código (classes Java) através da

transformação de documentos XML. Pode-se dividir seu funcionamento em quatro partes:

• Validação do documento de entrada (via W3C XML Schema);

• Manipulação de dados (via DOM);

• Transformações do documento XML e geração de código (via XSLT);

• Renderização automática da barra de menu gerada.

A seguir, uma figura que mostra em detalhes todo o processo de geração de código de

acordo com (segundo Artigo XSLT):

Figura 11 Etapas do processo de geração de código

30

Descrição das etapas de acordo com o XSwingMenu:

1. Input Docs – Representa o documento XML que possue a especificação da barra de

menu.

2. Parser – Etapa onde o documento XML é validado (via W3C XML Schema) e sua

representação de árvore é carregada em memória (via DOM). É de responsabilidade

do parser de indicar, caso existir, os erros de validação.

3. Input Language Syntax Tree - Representa a árvore gerada pelo parser.

4. Transformation/Selection – Esta etapa é dividida em dois momentos:

Transformação: a árvore em memória é transformada via script XSLT em outra árvore

de acordo com algum objetivo, no caso do XSwingMenu neste momento são

adicionados identificadores aos elementos que ainda não possuem, com o intuito de

viabilizar a geração de código. Seleção: a árvore já transformada é, então, utilizada

para geração de código Java.

5. Ouput Language Syntax Tree – Representa a árvore resultante da geração de código

da etapa anterior.

6. Writer – Escreve no sistema de arquivos a árvore resultante da geração de código.

Realiza o processo inverso do parser.

7. Output Docs – Representa o arquivo resultante (.java) do processo de geração de

código.

Após a geração da classe, caso desejado, um JFrame de teste pode ser

automaticamente renderizado juntamente com a barra de menu gerada para visualização do

resultado obtido. Porém, como esta funcionalidade necessita de compilar e executar as classes

geradas (barra de menu e janela de teste), é necessário que os programas “javac” e “java”

estajam disponíveis através das variáveis de ambiente do sistema operacional em questão.

XSwingMenu faz uso das seguintes ferramentas livres para automatização de builds,

manipulação e transformação de documentos XML:

• Apache Ant (automatização do build e execução)

• Apache Xerces2 Java Parser 2.5.0 (parser XML)

• Apache Xalan-Java version 2.6.0 (processador XSLT)

31

Além da geração de código, que é o principal propósito da ferramenta, XSwingMenu

também provê um mecanismo de engenharia reversa, ou seja, geração de documentos XML a

partir de um objeto já existente (ver detalhes no item 5.5).

Portanto, XSwingMenu pode ser utilizado tanto em aplicações já existentes quanto em

novas aplicações o que representa uma maior abrangência de situações para criação e

manipulação de barras de menu em Java Swing.

5.2 Especificação da linguagem

A seguir será mostrada uma especificação detalhada do esquema da linguagem XML

de entrada aceita pelo XSwingMenu.

5.2.1 Descrição dos elementos

Elemento Descrição

<menubar> Elemento raiz do documento. Representa uma barra de menu e

todos os seus itens. Por ser elemento raiz, possui o nome da classe

a ser gerada e seu respectivo package. Classe Swing

correspondente: javax.swing.JMenuBar

<menu> Representa um menu da barra de menu. É nele que estão presentes

os demais componentes. Classe Swing correspondente:

javax.swing.JMenu

<menuitem> Representa um item de menu. Seus eventos de ação são

automaticamente tratados. Classe Swing correspondente:

javax.swing.JMenuItem

<checkboxmenuitem> Representa um item de menu com checkbox. Seus eventos de ação

e alteração de estado são automaticamente tratados. Classe Swing

correspondente: javax.swing.JCheckboxMenuItem

<radiobuttonmenuitem> Representa um item de menu com radiobutton. Geralmente está

contido em um <grupo> para que no máximo um item do grupo

esteja selecionado. Seus eventos de ação e alteração de estado são

32

automaticamente tratados. Classe Swing correspondente:

javax.swing.JRadioButtonMenuItem

<grupo> Corresponde a um grupo de radiobutton´s. Permite apenas que um

de seus agrupados esteja selecionado. Classe Swing

correspondente: javax.swing.ButtonGroup.

<separador> Representa um separador entre itens de um <grupo> ou <menu>.

Corresponde a chamada do método addSeparator() do container

em questão.

Tabela 1 Descrição dos elementos da linguagem

5.2.2 Elementos

Elemento Elementos filhos Atributos

<menubar> <menu> id, package

<menu> <separador>, <menuitem>,

<checkboxmenuitem>, <menu>,

<radiobuttonmenuitem>, <grupo>

id (opcional), texto,

descricao, icone, mnemonico,

ativado

<menuitem> nenhum id, texto, descricao, icone,

mnemonico, ativado,

acelerador, selecionado

<checkboxmenuitem> nenhum id, texto, descricao, icone,

mnemonico, ativado,

acelerador, selecionado,

selecionado

<radiobuttonmenuitem> nenhum id, texto, descricao, icone,

mnemonico, ativado,

acelerador, selecionado,

selecionado

<grupo> <radiobuttonmenuitem>,

<separador>

id (opcional)

<separador> nenhum nenhum

Tabela 2 Elementos da linguagem

33

5.2.3 Descrição dos atributos

Atributo Descrição

id Utilizado como identificador único dentro do documento XML. Na geração de

código, este atributo se torna o identificador do componente em questão.

package Refere-se ao package da classe a ser gerada.

texto Corresponde ao método setText(...) do componente em questão, ou seja, o texto

exibido pelo componente.

descricao Representa um “tooltip” que é uma mensagem exibida quando o ponteiro do

mouse aponta para o componente. Corresponde ao método setToolTip(...) do

componente em questão.

icone Utilizado para indicar o caminho onde um ícone (imagem JPEG ou GIF) pode

ser encontrado. Método correspondente: setIcon(new ImageIcon(...))

docomponente em questão.

mnemonico Usado para indicar o mnemonico do componente em questão. Método

correspondente: setMnemonic(java.awt.event.KeyEvent.VK_...).

acelerador Representa um conjunto de teclas para acelerar o acionamento do componente.

Método correspondente: setAccelerator(javax.swing.KeyStroke.getKeyStroke("

... ")).

selecionado Indica se o item deve estar selecionado ou não no momento da inicialização.

Método correspondente: setSelected(...).

ativado Indica se o item deve estar ativado ou não no momento da inicialização. Método

correspondente: setEnabled(...).

Tabela 3 Descrição dos atributos da linguagem

5.2.4 Atributos

Atributo Tipo Uso Exemplo

id xs:ID obrigatório "btn_abrir"

package xs:string opcional “meuprojeto.menu”

texto xs:string opcional “Abrir”

descricao xs:string opcional “Clique aqui para abrir um arquivo.”

icone xs:string opcional “icones/Open16.gif”

34

mnemonico mnemonicos* opcional “A”

acelerador xs:string opcional "control A"

selecionado xs:boolean opcional “true”, “1”

ativado xs:boolean opcional “false”, “0”

Tabela 4 Atributos da linguagem

A coluna “Tipo” da tabela acima representa os tipos primitivos ou não utilizados para

restringir o universo de valores aceito pelo atributo.

* O tipo mnemonicos é uma restrição criada a partir do tipo xs:string que permite

apenas os caracteres utilizados na tabela de mnemonicos contida na classe

java.awt.event.KeyEvent (Documentação disponível em : http://java.sun.com/j2se/1.4.2/docs/

api/java/awt/event/KeyEvent). Obs: Os caracteres iniciais (“VK_”) presentes em todos os

mnemonicos devem ser omitido pois já são incluidos automaticamente na geração da classe.

5.3 Estrutura de classes simplificada

Para a criação da ferramenta foram desenvolvidos os seguintes pacotes com suas

respectivas classes:

Figura 12 Estrutura de classes simplificada

35

O pacote engine é o responsável pela validação, transformação e geração de

documentos XML. Já o pacote gui é responsável pela interface com o usuário. O pacote util

possui apenas classes utilitárias.

A interface gráfica se relaciona com o motor (engine) da ferramenta através das

classes XSMEngine e XSMGerador. A classe XSMEngine possui referência as classes

XSMValidador e XSMTransformador, portanto é responsável pela parte de validação e

geração de código. Já a classe XSMGerador, que faz uso das classes XSMAtributo e

XSMElemento, é utilizada para a geração de documentos XML a partir de um objeto

javax.swing.JMenuBar.

5.4 Tratamento de eventos

A ferramenta XSwingMenu ao gerar uma classe Java a partir de um documento XML

provê automaticamente suporte ao tratamento de eventos dos componentes: JMenuItem,

JRadioButtonMenuItem e JCheckboxMenuItem.

Esse tratamento é feito da seguinte forma: A classe gerada já possui 4 tipos de

construtores (construtor padrão, construtor com ActionListener, construtor com ItemListener

e construtor com ActionListener e ItemListener).

Quando o usuário, em sua aplicação, utiliza um dos construtores para inicializar sua

barra de menu, ele estará atrelando o ActionListener e/ou ItemListener passado como

parâmetro a todos os componentes JMenuItem (somente ActionListener),

JRadioButtonMenuItem (ActionListener e ItemListener) e JCheckboxMenuItem (somente

ItemListener).

Para facilitar na identificação da origem do evento, todos os componentes com eventos

automaticamente tratados terão na propriedade ActionCommand (presente em todos os objetos

que estendem javax.swing.JMenuItem) o valor do atributo id do componente presente no

documento XML mais a string “AC”. Além disso, a classe gerada possuirá todos esses valores

em constantes estáticas com o intuito de simplificar a obtenção desses valores.

36

Desta maneira, boa parte da necessidade de tratamento de eventos estará coberta no

caso de barras de menu. Entretanto, caso em alguma situação esta abordagem de tratamento

de evento não seja adequada, uma maneira de resolver isto seria estender a classe gerada e a

partir desta nova classe (que terá acesso a todos os atributos da classe gerada, visto que eles

são todos protected) codificar o que for necessário.

5.5 Gerador de documentos XML

Para que barras de menu já existentes em Java Swing possam ser reutilizadas pela

ferramenta, foi desenvolvido um mecanismo de geração de documentos XML (seguindo a

especificação aceita pelo XSwingMenu) a partir de um objeto javax.swing.JMenuBar.

Esta funcionalidade pode ser acionada a partir do arquivo build.xml via Ant. Para isso,

primeiramente deve-se configurar o arquivo build.xml para referenciar o classpath da classe

alvo e também alterar a classe xswingmenu.gui.GeradorXML para instanciar um objeto da

classe em questão. O resultado desta geração poderá ser encontrado na pasta “gerados” da

ferramenta.

Em suma, o gerador percorre todos os componentes do objeto JMenuBar em questão,

identifica os seus tipos e propriedades abordados pelo XSwingMenu e gera uma árvore DOM

que em seguida é materializada em um documento XML. Portanto, as propriedades que não

são abordadas pela ferramenta serão descartadas.

5.6 Comparação entre XSwingMenu-0.2 e SwiXml-1.2

Para mostrar as principais diferenças entre XSwingMenu e SwiXml, será feito um

quadro comparativo das principais características de cada ferramenta. É importante ressaltar

que o objetivo desta comparação é apenas demonstrar que a utilização de XML para

desenvolvimento de interfaces gráficas pode ser feita de diversas maneiras, cada uma mais ou

menos apropriada de acordo com a situação e escopo abordados.

37

XSwingMenu-0.2 SwiXml-1.2

Escopo Barras de menu Quase todos os componentes do pacote

javax.swing

Geração de código Sim Não. Componentes são renderizados em

tempo de execução

Engenharia reversa Sim Não

Necessário adição

de biblioteca a

aplicação

Não Sim (apenas 40 Kb de tamanho)

Tratamento de

eventos

Via construtor ou

herança da classe

gerada

O acesso aos componentes (atributos) é feito

por atributos públicos de uma classe auxiliar.

A partir daí que os eventos podem ser

tratados.

Tabela 5 Comparação entre XSwingMenu e SwiXml

Mais uma vez, vale salientar que esta comparação entre as duas ferramentas só seria

válida se o escopo do problema fosse somente barras de menu.

38

6 UM EXEMPLO UTILIZANDO XSWINGMENU

O objetivo deste capítulo é mostrar um exemplo passo-a-passo de como a ferramenta

XSwingMenu pode ser usada para gerar uma barra de menu através de um documento XML

simples.

6.1 Requerimentos

Para execução deste exemplo, se faz necessário que a máquina local tenha instalada

uma JDK 1.4 ou superior. Além disso, seria opcional a utilização da ferramenta Ant

proveniente do projeto Apache, visto que o XSwingMenu possui um arquivo build.xml,

produzido para ser usado juntamente com o Ant, que visa automatizar o processo de

compilação e execução do programa. Caso o usuário pretenda utilizar a opção de criação de

teste automatizado, deve-se assegurar que os programas “javac” e “java” estejam disponíveis.

O JDK pode ser baixado gratuitamente pelo site da Sun Microsystems. Já o Ant pode

ser encontrado no site do projeto Apache. Ferramentas para desenvolvimento Java, como

Netbeans e Eclipse, possuem em sua maioria suporte ao Ant.

6.2 Criação da especificação do Menu

Neste exemplo será criado uma barra de menu simples contendo um menu “Arquivo”

com alguns elementos clássicos como “Abrir”, “Salvar” e “Sair”. Além disso, um grupo de

radiobutton´s foi adicionado para tornar o exemplo mais interessante. A seguir, a

especificação de acordo com o esquema definido:

<?xml version="1.0" encoding="UTF-8" ?> <menubar id ="Exemplo1" > <menu texto="Arquivo" mnemonico="O"> <menuitem id="abrir" texto="Abrir" mnemonico="A"/> <separador/> <menuitem id="salvar" texto="Salvar" mnemonico="S"/> <separador/> <menu texto="Arquivos em uso..."> <grupo> <radiobuttonmenuitem texto="Arquivo1.xml"/>

39

<radiobuttonmenuitem texto="Arquivo2.xml" selecionado="true"/> </grupo> </menu> <separador/> <menuitem id="abrir" texto="Sair" mnemonico="R"/> <separador/> </menu> </menubar>

Figura 13 Exemplo de documento de XML de entrada

Esta especificação foi armazenada no arquivo Exemplo1.xml. Para fins de

demonstração, foi incluído propositalmente um erro na especificação do documento. O erro é

a utilização do id = “abrir” em dois elementos do documento (o que não é permitido).

6.3 Iniciando o XSwingMenu

Após criado o arquivo XML, pode-se iniciar a ferramenta. Uma maneira fácil é iniciar

a ferramenta através do arquivo build.xml utilizando Ant do projeto Apache. Outra maneira

seria executar a classe xswingmenu.gui.JFramePrincipal, não esquecendo de adicionar as

bibliotecas presentes na pasta lib da ferramenta.

6.4 Validando o arquivo XML

Com a ferramento rodando, basta que o usuário indique o arquivo a ser validado. Após

selecionado o arquivo Exemplo1.xml, o seu conteúdo será exibido pela ferramenta. Para

iniciar o processo de validação o usuário deve pressionar o botão “Validar” presente na parte

inferior da tela. A seguir uma demonstração:

40

Figura 14 Exemplo de erro de validação de um documento XML

Conforme exposto anteriormente, a especificação do documento está incorreta visto

que há dois identificadores (id) com o mesmo nome em elementos diferentes. Com a presença

de erros, a ferramenta indica em que parte do documento o erro foi encontrado (parte

selecionada em vermelho) e exibe as mensagens de erro geradas pelo Validador. Vale lembrar

que estas mensagens são geradas pela biblioteca Xerces no processo de validação de um

documento XML por um determinado W3C XML Schema.

Corrigindo-se os erros encontrados pelo validador (através da troca do valor do

atributo id do último menuitem para “sair”) e iniciando novamente o processo de validação,

41

uma mensagem é apresentada ao usuário informando que o documento XML é válido e que o

processo de transformação (ou seja, geração de código) pode ser realizado.

6.5 Transformando o arquivo XML em classe Java

Para transformar um arquivo XML qualquer é necessário que este seja válido. Por esse

motivo, a ferramenta só dispõe a GUI referente a transformação após a validação do arquivo

XML. Sendo esta condição satisfeita, o usuário pode escolher o diretório onde será gerada a

classe Java correspondente à especificação presente no arquivo XML e iniciar o processo de

transformão através do botão “Transformar”, como mostra a figura abaixo:

42

Figura 15 Exemplo de transformação bem sucedida

6.6 Resultado

A transformação da etapa anterior resultou na seguinte classe Java:

/* * Exemplo1.java * * Codigo gerado automaticamente pelo XSwingMenu 0.2 * Francisco Hillesheim - hillen@inf.ufsc.br */ public class Exemplo1 extends javax.swing.JMenuBar { protected javax.swing.JMenu menuN400005;

43

protected javax.swing.JMenu menuN400017; protected javax.swing.JMenuItem abrir; protected javax.swing.JMenuItem salvar; protected javax.swing.JMenuItem sair; protected javax.swing.JRadioButtonMenuItem r1; protected javax.swing.JRadioButtonMenuItem r2; protected java.awt.event.ActionListener actionListener; protected java.awt.event.ItemListener itemListener; public static final String abrirAC = "abrir"; public static final String salvarAC = "salvar"; public static final String sairAC = "sair"; public static final String r1AC = "r1"; public static final String r2AC = "r2"; public Exemplo1() { this.actionListener = null; this.itemListener = null; inicializaComponentes(); } public Exemplo1(java.awt.event.ActionListener al) { this.actionListener = al; this.itemListener = null; inicializaComponentes(); } public Exemplo1(java.awt.event.ItemListener il) { this.actionListener = null; this.itemListener = il; inicializaComponentes(); } public Exemplo1(java.awt.event.ActionListener al, java.awt.event.ItemListener il) { this.actionListener = al; this.itemListener = il; inicializaComponentes(); } private void inicializaComponentes() { menuN400005 = new javax.swing.JMenu(); menuN400005.setText("Arquivo"); menuN400005.setMnemonic(java.awt.event.KeyEvent.VK_O); this.add(menuN400005); abrir = new javax.swing.JMenuItem(); abrir.setText("Abrir"); abrir.setMnemonic(java.awt.event.KeyEvent.VK_A); abrir.setActionCommand(abrirAC); if (actionListener != null) { abrir.addActionListener(actionListener); } menuN400005.add(abrir); menuN400005.addSeparator();salvar = new javax.swing.JMenuItem(); salvar.setText("Salvar"); salvar.setMnemonic(java.awt.event.KeyEvent.VK_S); salvar.setActionCommand(salvarAC); if (actionListener != null) {

44

salvar.addActionListener(actionListener); } menuN400005.add(salvar); menuN400005.addSeparator(); menuN400017 = new javax.swing.JMenu(); menuN400017.setText("Arquivos em uso..."); menuN400005.add(menuN400017); javax.swing.ButtonGroup grupoN40001A = new javax.swing.ButtonGroup(); r1 = new javax.swing.JRadioButtonMenuItem(); r1.setText("Arquivo1.xml"); r1.setActionCommand(r1AC); if (actionListener != null) { r1.addActionListener(actionListener); } if (itemListener != null) { r1.addItemListener(itemListener); } grupoN40001A.add(r1); menuN400017.add(r1); r2 = new javax.swing.JRadioButtonMenuItem(); r2.setText("Arquivo2.xml"); r2.setSelected(true); r2.setActionCommand(r2AC); if (actionListener != null) { r2.addActionListener(actionListener); } if (itemListener != null) { r2.addItemListener(itemListener); } grupoN40001A.add(r2); menuN400017.add(r2); menuN400005.addSeparator();sair = new javax.swing.JMenuItem(); sair.setText("Sair"); sair.setMnemonic(java.awt.event.KeyEvent.VK_R); sair.setActionCommand(sairAC); if (actionListener != null) { sair.addActionListener(actionListener); } menuN400005.add(sair); menuN400005.addSeparator(); } }

Figura 16 Classe gerada a partir do arquivo Exemplo1.xml

Com a seguinte classe de teste (caso desejado teste automático):

import java.awt.event.*; import javax.swing.*; public class Exemplo1Teste extends JFrame implements ActionListener, ItemListener { public static void main(String[] args) throws Exception { javax.swing.JFrame frame = new Exemplo1Teste();

45

frame.setTitle("XSwingMenu Teste"); frame.setSize(frame.getToolkit().getScreenSize()); frame.setDefaultCloseOperation(javax.swing.JFrame.EXIT_ON_CLOSE); javax.swing.JMenuBar barra = new Exemplo1((ActionListener)frame, (ItemListener)frame); frame.setJMenuBar(barra); frame.show(); } public void actionPerformed(java.awt.event.ActionEvent e) { JOptionPane.showMessageDialog(this, "'" + e.getActionCommand() + "' foi ACIONADO."); } public void itemStateChanged(java.awt.event.ItemEvent e) { String item = "'" + ((javax.swing.JMenuItem) e.getItem()).getActionCommand() + "'"; item += " foi "; item += (e.getStateChange() == e.SELECTED) ? "SELECIONADO" : "DESELECIONADO"; javax.swing.JOptionPane.showMessageDialog(this, item); } }

Figura 17 Exemplo de classe de teste gerada automaticamente

A seguir, a renderização do JFrame de teste:

Figura 18 Renderização da classe gerada

46

7 CONCLUSÃO

O produto final deste trabalho, XSwingMenu, representa mais uma maneira de se

abordar um ponto crítico, com relação a produtividade, no desenvolvimento de software: a

criação e manutenção de interfaces gráficas de usuário. Deve-se considerar, claro, que

XSwingMenu não é uma ferramenta completa para solução de problema, e sim, para um

determinado escopo: barras de menu da biblioteca Java Swing.

Neste sentido, a ferramenta desenvolvida atendeu o objetivo principal proposto por

esse trabalho, o de simplificar a vida do desenvolvedor de software na criação de barras de

menu. Como exemplo disso, visto no capítulo 6, pode-se verificar por meio do número de

linhas utilizadas e organização dos elementos entre o documento XML de entrada e a classe

Java gerada que o documento XML é mais claro e conciso na representação de uma barra de

menu.

Por outro lado, este trabalho foi enriquecedor por permitir o contato, na prática, com

diversas tecnologias relaciandas a XML como XML Schema, XSLT, XPATH, XML

Namespace, DOM, SAX, entre outras. Estas siglas, que anteriormente representavam uma

“sopa de letras”, agora possuem seus propósitos mais claros que certamente serão levados em

conta para a resolução de futuros desafios profissionais.

7.1 Trabalhos futuros

Para continuidade e aperfeiçoamento deste trabalho, existem algumas sugestões que

podem ser desenvolvidas. Entre estas sugestões, pode-se destacar:

Ampliação do escopo abordado: Neste trabalho, o escopo foi somente barras de

menu. Pode-se, por meio de alterações basicamente do XML Schema e scripts XSLT

produzidos, aumentar este escopo para, por exemplo, abranger popup menus ou qualquer

outro componente de GUI.

47

Geração de código para outras bibliotecas: Um trabalho interessante seria alterar o

processo de geração de código via XSLT para produzir não só objetos Java Swing, e sim

objetos de qualquer biblioteca de qualquer linguagem desejado. Um exemplo seria a geração

de objetos SWT (que estão sendo amplamente utilizados) a partir do XSwingMenu.

Adição de um editor XML ao XSwingMenu: Para aumentar a produtividade e

simplificar o processo de criação de documentos XML para o XSwingMenu, a adição de um

editor XML a ferramenta traria maior comodidade ao desenvolvedor visto que todo o

processo poderia ser abordado dentro da própria ferramenta.

Realizar pesquisa bibliográfica mas aprofundada sobre XUL: A questão da

utilização de XML no desenvolvimento de interfaces gráficas está em alta nestes últimos.

Com o lançamento iminente da nova versão do Microsoft Windows (LongHorn) e a crescente

utilização do XUL proveniente do projeto Mozilla, este tema provavelmente será alvo de mais

discussões sobre suas vantagens e desvantagens. Além disso, várias ferramentas (gratuitas ou

não) foram e estão sendo desenvolvidas baseadas nesta tendência, o que justificaria uma

pesquisa bibliográfica mais completa sobre esta área.

48

8 REFERÊNCIAS BIBLIOGRÁFICAS

SAKAR, Soumen; CLEAVELAND, Craig. Code. Generation Using XML Based

Document Transformation, Novembro, 2001. Disponível em: <http://www.theserverside.

com/articles/content/XMLCodeGen/xmltransform.pdf>. Acesso em: 27 outubro 2004.

DUCHARME, Bob. XSLT guia prático. Tradução:Kirten Woltmann. Rio de Janeiro:

Ciência Moderna Ltda, 2002.

BOJANIC, Peter. The Joy of XUL, Dezembro, 2003. Disponível em:

<http://www.mozilla.org/projects/xul/joy-of-xul.html>. Acessado em: 10 de setembro de

2004.

MICROSOFT. "Longhorn" Markup Language (code-named "XAML") Overview.

Disponível em: <http://longhorn.msdn.microsoft.com/lhsdk/core/overviews/

about%20xaml.aspx>. Acessado em: 20 de outubro de 2004.

SUN MICROSYSTEMS, INC. Java Technology. Disponível em: <http://java.sun.com>.

Acessado em: 23 de setembro de 2004.

SUN MICROSYSTEMS, INC. How to Use Menus. Disponível em: <http://java.sun.com

/docs/books/tutorial/uiswing/components/menu.html>. Acessado em: 15 de setembro de 2004.

MCFARLANE, Nigel. New GUIs: XML Is the Heir Apparent, Outubro, 2002. Disponível

em: < http://www.devx.com/DevX/Article/9605>. Acessado em: 15 de setembro de 2004.

IBM.. developerWorks : XML: New to XML. Disponível em <http://www-106.ibm.com/

developerworks/xml/newto/>. Acessado em: 22 de setembro de 2004.

VLIST, Eric van der. Comparing XML Schema Languages. Disponível em:

<http://www.xml.com/pub/a/2001/12/12/schemacompare.html>. Acessado em: 23 de

setembro de 2004.

49

VLIST, Eric van der. Using W3C XML Schema. Disponível em:

<http://www.xml.com/pub/a/2000/11/29/schemas/part1.html>. Acessado em: 23 de setembro

de 2004.

OPEN XUL ALLIANCE. Open XUL Alliance – Creating A Rich Internet for Everyone.

Disponível em <http://xul.sourceforge.net/>. Acessado em: 15 de outubro de 2004.

W3C. World Wide Web Consortium. Disponível em: <http://www.w3c.org/>. Acessado

em: 8 de outubro de 2004.

W3C. Extensible Markup Language (XML) 1.0 (Third Edition). Disponível em:

<http://www.w3c.org/TR/2004/REC-xml-20040204/>. Acessado em: 20 de setembro de

2004.

W3C. W3C XML Schema. Disponível em: < http://www.w3.org/XML/Schema>. Acessado

em: 20 de setembro de 2004.

W3C. XSL Transformations (XSLT). Disponível em: <http://www.w3.org/TR/xslt>.

Acessado em: 20 de setembro de 2004.

THE APACHE XML PROJECT. Xerces Java Parser Readme. Disponível em:

<http://xml.apache.org/xerces-j/>. Acessado em: 1 de outrubro de 2004.

THE APACHE XML PROJECT. Xalan-Java version 2.6.0. Disponível em:

<http://xml.apache.org/xalan-j/>. Acessado em: 1 de outrubro de 2004.

WIKIPEDIA. Wikipedia, the free encyclopeia. Disponível em:

<http://en.wikipedia.org/wiki/Main_Page>. Acessado em: 28 de setembro de 2004.

PAULUS, Wolf. SwiXml. Disponível em: <http://www.swixml.org/>. Acessado em: 1 de

setembro de 2004.

50

9 ANEXOS

9.1 Código fonte

9.2 Artigo