ODFDOM para Java: Simplificando o controle programático de documentos e seus dados, Parte 3

O terceiro de uma série em três partes, este artigo introduz como usar o Open Document Format (ODF) Document Object Model (DOM) for Java™ para criar documentos de texto (texto), planilha (planilha) e gráficos de apresentação (apresentação).

Li Wei, Software Engineer, IBM

Li Wei é um engenheiro de software lotado no Laboratório de Desenvolvimento da IBM na China, onde trabalha no departamento Instituto de Tecnologias Emergentes. Ele está envolvido em projetos relacionados a padrões como ACORD, NAVA e ODF e é membro da comunidade de desenvolvimento do ODF Toolkit. Ele pode ser contatado pelo e-mail weili@cn.ibm.com.



02/Ago/2010

Nota do editor: Você sabe muito sobre esse tópico? Deseja compartilhar seu conhecimento? Participe hoje do programa wiki do software IBM Lotus.

Usando o ODFDOM para criar documentos de texto, planilhas e gráficos de apresentação

Primeiro, vamos descrever de forma breve a estrutura de documento ODF. Documentos ODF são armazenados em um pacote ZIP que inclui content.xml, style.xml e vários outros documentos.

O Content.xml é usado para armazenar o conteúdo do documento e o style.xml é usado para armazenar as informações de estilo do documento. O arquivo content.xml também contém algumas informações de estilo e pode ser usado para criar alguns dos valores padrão, como fontes e cores, automaticamente.

Em geral, existem quatro etapas para manipular um documento ODF:

  1. Carregar um documento ODF existente ou criar um documento ODF.
  2. Inserir conteúdo no documento ODF.
  3. Definir o estilo para diferentes partes das informações.
  4. Salvar o documento.

O ODFDOM agora fornece algumas APIs convenientes com as quais é possível realizar esses quatro tipos principais de operações de documento.


Criando um arquivo texto

Nesta seção, demonstraremos um caso de uso simples: Ler um arquivo XML e dar saída em um documento ODF.

Como arquivo de texto, a hierarquia de seu content.xml é a seguinte (consulte a listagem 1):

  • O primeiro elemento é <office:body>, que é um subelemento da raiz do documento.
  • A camada seguinte é o elemento <office:text>, que representa todo o conteúdo dos elementos do documento a serem salvos no documento de saída.
  • Antes de <office:body>, <office:automatic-styles> é outro subelemento da raiz do documento, usada para armazenar várias informações de estilo dos elementos.
Listagem 1. Estrutura do nível do content.xml do arquivo de texto
    <office:document-content>
      <office:automatic-style/>
           <office:body>
              <office:text/>
           </office:body>               
    </ office:document-content>

Aqui, <office:style> e <office:automatic-styles> definem alguns estilos, mas existem algumas diferenças. <office:style> é usado geralmente para definir alguns estilos usados comumente. Geralmente, aplicamos o estilo definido em <office:style> aos elementos definindo o nome do estilo. Do ponto de vista do editor de ODF, um estilo definido em <office:style> é um conjunto de valores característicos definidos pelo usuário.

Por outro lado, um estilo definido em <office:automatic-styles> contém algumas propriedades especiais de estilo. Do ponto de vista do editor de ODF, isto significa editar certos atributos de um objeto.

O ODFDOM fornece objetos para representar o pacote ODF de vários documentos:

  • OdfTextDocument textDocument: Corresponde a um objeto de arquivo de texto (odt).
  • OdfFileDom contentDom: Corresponde ao objeto do documento XML de content.xml.
  • OdfFileDom stylesDom: Corresponde ao objeto do documento XML de styles.xml.

Um objeto de arquivo de texto poderá usar a API para obter o objeto de conteúdo (content.xml) e o objeto de estilo (styles.xml):

  • OdfFileDom contentDom = textDocument.getContentDom()
  • OdfFileDom stylesDom = textDocument.getStylesDom()

O ODFDOM também fornece uma série de objetos para representar os vários elementos de conteúdo e estilo:

  • OdfOfficeAutomaticStyles contentAutoStyles: Os elementos correspondentes <office:automatic-styles> no content.xml.
  • OdfOfficeStyles stylesOfficeStyles: Os elementos correspondentes <office:styles> no styles.xml.
  • OdfOfficeText officeText: Os elementos correspondentes <office:text> no content.xml.

Com a API do ODFDOM também é fácil obter o objeto do elemento de conteúdo e o objeto do elemento de texto:

  • OdfOfficeAutomaticStyles autoStyles = textDocument.getContentDom (). GetAutomaticStyles ()
  • OdfOfficeStyles styles = textDocument.getDocumentStyles ();
  • OdfOfficeText text = (OfficeText) textDocument.getContentRoot ();

O ODFDOM fornece uma API para manipular documentos ODF no nível de arquivo que pode ser usada, por exemplo, para criar um arquivo de texto, carregar um arquivo de texto existente e salvar um arquivo:

  • OdfTextDocument odtDoc = OdfTextDocument.newTextDocument (); / / Criar um arquivo de texto
  • OdfTextDocument odtDoc = (OdfTextDocument) OdfDocument.loadDocument ( "text.odt"); / / Carregar um arquivo de texto existente
  • odtDoc.save ( "text.odt") / / salvar o arquivo

Certamente, um arquivo de texto não pode ficar sem atributos rich style, como fontes de texto, layout de parágrafos e marcadores. Portanto, o ODFDOM tem um método para lidar com esses atributos de estilo:

  • OdfStyle style = odtDoc.getDocumentStyles (). getStyle ( "myStyle",
    OdfStyleFamily.Paragraph);
    / / De um arquivo de texto para obter o objeto de estilos (estilo) definido pelo usuário
  • style.setProperty (OdfStyleTextProperties.FontWeight, "bold");
    / / Define o estilo para o valor específico da propriedade

O código para definir os atributos de estilo do texto é mostrado na listagem 2.

Listagem 2. Código para definir atributos de estilo de texto
     OdfTextParagraph para;
     para.setProperty (OdfStyleTextProperties.FontSize, "17pt");
     para.setProperty (OdfStyleParagraphProperties.TextAlign, "left");
     para.setProperty (OdfStyleChartProperties.DataLabelNumber, "value");

O código que usa valores característicos pode ser aplicado a um elemento específico do documento e o estilo criado desta forma é <office:automatic-style>.

Introduzimos um arquivo de texto com uso significativo de APIs. Nos exemplos seguintes, veremos um aplicativo ODFDOM que lê os dados de um arquivo XML e, a seguir, usando a operação da API do ODFDOM, os dados são salvos para um documento texto ODF em um formato especificado (consulte as listagens 3-7).

Listagem 3. Arquivo de dados XML book.xml
     <book> 
          <title> The ODFDOM tutorial </title>
          <author> IBM ODF team </ author>
          <content> introduce ODFDOM usage </ content>
     </ book>
Listagem 4. Usando a API Java DOM para analisar documentos XML para leitura
     DocumentBuilder builder = null; 
       inputDocument = null; 
       try ( 
           inputXPath = XPathFactory.newInstance (). newXPath (); 
           builder = DocumentBuilderFactory.newInstance (). newDocumentBuilder (); 
           inputDocument = builder.parse ( "book.xml"); 
       ) catch (IOException e) ( 
           System.err.println ( "Unable to read input file."); 
           System.err.println (e.getMessage ()); 
       ) catch (Exception e) ( 
           System.err.println ( "Unable to parse input file."); 
           System.err.println (e.getMessage ()); 
     )
Listagem 5. Criando um objeto de texto ODF
     try ( 
          OdfTextDocument odtDocument = OdfTextDocument.newTextDocument (); 
          OdfFileDom contentDom = outputDocument.getContentDom (); 
          OdfFileDom stylesDom = outputDocument.getStylesDom (); 
          contentAutoStyles = contentDom.getOrCreateAutomaticStyles (); 
          OdfOfficeStyles stylesOfficeStyles = odtDocument.getOrCreateDocumentStyles (); 
          officeText = outputDocument.getContentRoot (); 
          ) catch (Exception e) ( 
          System.err.println ( "Unable to create output file."); 
          System.err.println (e.getMessage ()); 
          odtDocument = null; 
     )

Como o conteúdo e o estilo precisam de informações adicionais para serem concluídos, precisamos inserir elementos de conteúdo na árvore DOM de conteúdo deste novo arquivo texto e inserir elementos de estilos dinâmicos na árvore de conteúdo e estilos (consulte as listagens 6 e 7).

Listagem 6. Ler o conteúdo XML em um arquivo de texto no ODF
     NodeList booklist = inputDocument.getElementsByTagName ( "book"); 
     Node book = booklist [0]; 
     String title = inputXPath.evaluate ( "book / title", book); 
     String author = inputXPath.evaluate ( "book / author", book); 
     String content = inputXPath.evaluate ( "book / content", book); 
     OdfTextHeading heading = (OdfHeading) officeText.newTextHElement (title); 
     (OdfTextParagraph) para = (OdfTextParagraph) newTextPElement (); 
     para. addContent (content);
Listagem 7. Estilo aplicado ao conteúdo de texto
     OdfStyle style1 = odtDocument.getOrCreateDocumentStyles (). 
     NewStyle ( "hStyle", OdfStyleFamily.Text); 
     style.setProperty (OdfTextProperties.FontWeight, "bold"); 
     style.setProperty (OdfTextProperties.FontStyle, "italic"); 
     style.setProperty (OdfTextProperties.FontSize, "16"); 
     heading.setStyleName ( "hStyle"); 
     
     OdfStyle style2 = odtDocument.getOrCreateDocumentStyles (). 
     NewStyle ( "pStyle", OdfStyleFamily.Text); 
     style.setProperty (OdfTextProperties.FontStyle, "italic"); 
     style.setProperty (OdfTextProperties.FontSize, "10"); 
     para.setStyleName ( "pStyle");

Finalmente, salvaremos o arquivo texto ODT:

odtDocument.save ( "text.odt")

É possível usar o OpenOffice ou o IBM® Lotus® Symphony™ para abrir este novo arquivo e ver como o ODFDOM produz resultados acessando diretamente as APIs.


Criando um arquivo de planilha

Primeiro, veremos a estrutura principal do content.xml para o documento de planilha (consulte a listagem 8).

Listagem 8. Estrutura do content.xml de planilha
     <office:document-content> 
     <office :automatic-style/>
     <office :body>
         <office:spreadsheet>
             <table:table/> 
          </ Office: spreadsheet>
     </ office: body>
     </ Office: document-content>

Em um documento de planilha, os principais elementos são:

  • <table:table>, que é o elemento raiz da tabela e todos os elementos do conteúdo da tabela são seus subelementos
  • <table:column>, que especifica a largura de uma planilha e as definições padrão de estilo
  • <table:row>, que representa uma linha da tabela e é composto de vários elementos <table:cell>

Para o elemento <table:cell>, duas propriedades, office:value-type e office: value, geralmente devem ser especificadas com um subelemento, <text:p>.

O ODFDOM tem uma série de objetos relacionados ao recurso de tabela:

OdfSpreadsheetDocumentcontent.xml
OdfTable <table:table>
OdfTableColumn<table:table-column>
OdfTableRow<table:table-row>
OdfTableCell<table:table-cell>

onde:

  • O objeto OdfTable representa uma tabela da planilha.
  • OdfTableColumn é usado para especificar uma coluna em uma planilha e o número da coluna é definido pelo valor da propriedade TableNumberColumnsRepeatedAttribute.
  • OdfTableRow é usado para representar a linha da tabela. Uma linha é composta por um ou mais objetos OdfTableCell.
  • OdfTableCell é a unidade que constitui um elemento da tabela e cada objeto de célula pode ser usado para colocar valores, parágrafos e outros conteúdos de texto; normalmente, é necessário definir estes três valores de propriedade:
    • OfficeValueAttribute
    • OfficeValueTypeAttribute
    • TextContent

OfficeValueTypeAttribute é usado para especificar o tipo de dados armazenados (caracteres, números, data, hora, fórmulas e assim por diante); OfficeValueAttribute é usado para armazenar valores; e TextContent é usado para armazenar o valor visto por um usuário.

Agora, criaremos uma tabela com três linhas e quatro colunas para ilustrar como aplicar algumas das operações de API do ODFDOM no recurso de tabela (consulte a listagem 9):

  1. Crie um objeto de planilha OdfSpreadsheetDocument.
  2. Obtenha a raiz de OdfOfficeSpreadsheet.
  3. Crie um objeto OdfTable.
  4. Crie um elemento <table:column> e defina o atributo table:number-columns-repeated como o número de colunas nesta tabela.
  5. Use um loop para criar elementos <table:row> para cada linha.
  6. Use um loop para criar elementos <table:cell> para cada célula em uma linha e preencha os valores.
  7. Salve a planilha.
Listagem 9. Criando uma planilha
     int data [][]= ((1,2,3,4), (5,6,7,8), (9,10,11,12)); 
     OdfSpreadsheetDocument odfdoc = OdfSpreadsheetDocument.newSpreadsheetDocument (); 
     OdfOfficeSpreadsheet spreadsheet = odfdoc.getContentRoot (); 
     OdfTable table = (OdfTable) spreadsheet.newTableTableElement (); 
     OdfTableColumn column = (OdfTableColumn) table.newTableTableColumnElement (); 
     column.setTableNumberColumnsRepeatedAttribute (new Integer (4)); 
     for (int i = 0; i <3; i) ( 
     OdfTableRow row = (OdfTableRow) table.newTableTableRowElement (); 
     / / row.setStyleName ( "ro1"); 
     for (int j = 0; j <4; j) ( 
     OdfTableCell cell = (OdfTableCell) row.newTableTableCellElement (); 
     cell.setOfficeValueAttribute (new Double (data [i] [j])); 
     cell.setOfficeValueTypeAttribute ( "float"); 
     cell.setTextContent ((new Double (data [i] [j]). toString ())); 
     ) 
     ) Odfdoc.save (ResourceUtilities.createTestResource ( "table3R4C.ods"));

O recurso de tabela sempre contém valores de data e hora e as representações destes valores poderá ser diferente para países e regiões diferentes. O ODFDOM é capaz de fornecer não só os meios apropriados para definir formatos de data e hora, mas também algumas classes especiais de estilo para muitos tipos de formatos.

Por exemplo, OdfNumberDateStyle é usado para tratar formatos de datas, OdfNumberTimeStyle é usado para tratar formatos de hora e OdfNumberStyle é usado para tratar formatos de número.

Esses elementos de estilo devem ser colocados abaixo do elemento <office:automatic-styles> (consulte a listagem 10) da seguinte forma:

  1. Obtenha o objeto de OdfAutomaticStyles com getStylesDom ().
  2. Crie objetos das classes de estilo correspondentes.
  3. Defina formatos específicos dos objetos de estilo.
Listagem 10. Defina o estilo do número
     OdfOfficeAutomaticStyles autoStyles = odfdoc.getStylesDom (). GetAutomaticStyles (); 
     OdfNumberDateStyle dataStyle = (OdfNumberDateStyle) 
     autoStyles.newNumberDateStyleElement ( "numberDateStyle"); 
     dataStyle.buildFromFormat ( "yyyy-MM-dd"); 
     OdfNumberTimeStyle timeStyle = (OdfNumberTimeStyle) 
     autoStyles.newNumberTimeStyleElement ( "numberTimeStyle"); 
     timeStyle.buildFromFormat ( "hh: mm: ss"); 
     OdfNumberStyle numberStyle = (OdfNumberStyle) 
     autoStyles.newNumberNumberStyleElement ( "numberStyle"); 
     numberStyle.buildFromFormat ( "# 0.00");

A seguir, especificaremos um estilo de célula e associaremos esses objetos de estilos de data e número a objetos do estilo da célula (consulte a listagem 11):

  1. Crie um objeto de OdfStyle cuja família seja table-cell.
  2. Obtenha o nome dos estilos de data e número com getStyleNameAttribute ().
  3. Defina a propriedade style:data-stylename do objeto de estilo da célula como o nome dos estilos de data e número com setStyleDataStyleNameAttribute().
  4. Aplique este estilo de célula a uma célula específica.
Listagem 11. Aplique os estilos de célula
Cell style for date cells:

     OdfStyle style; 
     style = autoStyles.newStyle (OdfStyleFamily.TableCell); 
     String dataCellStyleName = style.getStyleNameAttribute (); 
     style.setStyleDataStyleNameAttribute ( "numberDateStyle"); 
     cell.setStyleName (dataCellStyleName); 
     
     And for time cells:
     
     style = autoStyles.newStyle (OdfStyleFamily.TableCell); 
     String timeCellStyleName = style.getStyleNameAttribute (); 
     style.setStyleDataStyleNameAttribute ( "numberTimeStyle"); 
     cell.setStyleName (timeCellStyleName); 
     
     And for the temperatures:
     
     style = autoStyles.newStyle (OdfStyleFamily.TableCell); 
     String numberCellStyleName = style.getStyleNameAttribute (); 
     style.setStyleDataStyleNameAttribute ( "numberStyle"); 
     cell.setStyleName (numberCellStyleNam);

Neste exemplo, criamos uma planilha simples, mas, na verdade, planilhas podem ser bem complexas. Por exemplo, elas podem ter células de tabela que usam várias linhas e colunas, com um aplicativo de uma variedade de estilos e objetos e mídia integrados.

Estes recursos complexos podem ser implementados pela API do ODFDOM, mas o código poderá ser complexo. À medida que o ODFDOM cresce, no entanto, essas planilhas complexas poderão tornar-se mais fáceis de criar.


Criando um arquivo de apresentação

Vamos começar definindo os termos relevantes no content.xml de apresentação (consulte a listagem 12):

  • <office:presentation> é o elemento raiz de um documento gráfico de apresentação.
  • <draw:page>, que é um subelemento de <office:presentation>, apresenta um slide em uma apresentação. Somente elementos gráficos podem ser armazenados em <draw:page>, de forma que os elementos de texto, como <text:title>, deverão ser colocados sob <draw:frame> para que sejam colocados em um slide.
  • <style:master-page> é uma página de modelo genérica e um subelemento de <style:master-style>. Estilos, como o segundo plano, são definidos em uma página principal, e cada slide pode ser associado a uma página principal; portanto, o modelo correspondente é aplicado a ela.
Listagem 12. Estrutura do arquivo content.xml de apresentação
     <office:document-content> 
     <office :automatic-style/>
     <office :body>
          <office:presentation>
              <draw:page/>
          </ office: presentation>
     </ office: body>
     </ Office: document-content>

Nesta seção, ilustraremos como criar um arquivo de apresentação, inserir um slide, listar o título, aplicar um modelo de página principal e, a seguir, salvar este novo slide.

A Tabela 1 lista as classes ODF que são usadas no código.

Tabela 1. Classes ODF e finalidades
Classe ODF Finalidade
OdfPresentationDocumentArquivo de apresentação
OdfStyleDomDOM do estilo
OdfOfficePresentationelemento <office:presentation>
OdfOfficeStyleselementos de estilo <office:styles> do documento
OdfOfficeAutomaticStyleO <style:automatic-styles> é colocado em um estilo automático
OdfStylePageLayout <style:page-layout> define o layout de uma página
OdfOfficeMasterStyles<office:master-styles> define o estilo principal de uma página
OdfStyleMasterPage<style:master-page> é o subelemento de <office:master-styles> usado para definir uma página principal de modelos de estilo
OdfDrawPage O elemento <draw:page> é usado para representar uma página em uma apresentação ou um slide
OdfDrawFrame<draw:frame> é um elemento contêiner no qual outros elementos são colocados

Eis as etapas (consulte a listagem 13):

  1. Crie um objeto de OdfPresentationDocument.
  2. Obtenha o objeto de OdfOfficePresentation.
  3. Obtenha o objeto de OdfOfficeStyles, que representa o elemento de estilo do documento; crie um se este elemento não existir.
  4. Crie um elemento de <style:page-layout>; este elemento está sob o elemento OdfOfficeAutomaticStyle, portanto pode ser obtido usando getAutomaticStyles ().
  5. Obtenha o objeto de OdfOfficeMasterStyles com o método getOfficeMasterStyles() da classe OdfPresentationDocument.
  6. Crie um objeto de OdfStyleMasterPage, onde deveremos especificar o nome desta página principal e o nome do estilo do layout. (O nome do estilo de layout criado na etapa 4 poderá ser usado.
  7. Um documento de apresentação é composto de slides, portanto a próxima etapa é criar um objeto de OdfDrawPage com o método newDrawPageElement (MasterPageStyleName), onde poderemos especificar uma página principal. Depois que este método for chamado, a página principal será aplicada ao novo slide.
  8. Como somente elementos gráficos podem ser armazenados em <draw:page>, precisamos criar um objeto de OdfDrawFrame para adicionar conteúdo de texto.
  9. Criaremos dois objetos de OdfDrawFrame. Um é usado para armazenar o título; o outro é usado para armazenar a imagem.

Desta forma, o documento de apresentação é criado, depois do que é possível salvá-lo como um documento ODP e usar o OpenOffice ou o IBM Lotus Symphony para abri-lo.

Listagem 13. Crie arquivos de apresentação
     OdfPresentationDocument presentationDoc = 
     OdfPresentationDocument.newPresentationDocument (); 
     OdfOfficePresentation presentation1 = presentationDoc.getContentRoot (); 
     presentationDoc.getOrCreateDocumentStyles (); 
     presentationDoc.getStylesDom (). getAutomaticStyles (). 
     newStylePageLayoutElement ( "PM01"); 
     OdfOfficeMasterStyles officeMasterStyles = presentationDoc.getOfficeMasterStyles (); 
                                                                 
         OdfStyleMasterPage masterPage = (OdfStyleMasterPage) officeMasterStyles.
         newStyleMasterPageElement ( "master-name-1", "PM01"); 
         OdfDrawPage page4 = (OdfDrawPage) presentation1.newDrawPageElement 
         ( "master-name-1"); 
         OdfDrawFrame frame1 = (OdfDrawFrame) page4.newDrawFrameElement (); 
         frame1.newDrawTextBoxElement (). setTextContent ( "title"); 
         OdfDrawFrame frame2 = (OdfDrawFrame) page4.newDrawFrameElement (); 
         frame2.newDrawImageElement (). setXlinkHrefAttribute ( "http://impage"); 
         presentationDoc.save ( "presentation.odp");

Conclusão

Usando os três exemplos detalhados neste artigo, ilustramos como usar a API do ODFDOM para criar o conteúdo, estilos e outros recursos de documentos ODF de texto, planilha e apresentação.


Agradecimentos

O autor estende um agradecimento especial à Líder de Projeto, Ying Chun (Daisy) Guo, por suas contribuições para este artigo.


Download

DescriçãoNomeTamanho
Código de amostraPart3-ODFDOM-practice_EN.zip10KB

Recursos

Aprender

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Lotus
ArticleID=973470
ArticleTitle=ODFDOM para Java: Simplificando o controle programático de documentos e seus dados, Parte 3
publish-date=08022010