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.

Voltar para parte superior

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.

<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.

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).

<book> 
     <title> The ODFDOM tutorial </ title> 
     <author> IBM ODF team </ author> 
     <content> introduce ODFDOM usage </ content> 
</ book>

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 ()); 
)

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).

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);

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:

É 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.

Voltar para parte superior

Criando um arquivo de planilha

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

<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:

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.

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.

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.

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.

Voltar para parte superior

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.

<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.

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.

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"); 

Voltar para parte superior

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.

Voltar para parte superior

Agradecimentos

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

Voltar para parte superior

Download

Informações sobre métodos de download

Recursos

Aprender

• Leia o artigo do developerWorks® Lotus, "ODF DOM for Java: Simplifying programmatic control of documents and their data, Part 1."
  
  
• Leia o artigo do developerWorks Lotus, “ODF DOM for Java: Simplifying programmatic control of documents and their data, Part 2 ODFDOM architecture."
  
  
• Consulte a página do produto Lotus Symphony do developerWorks®.
  
  
• Consulte a página inicial do IBM Lotus Symphony.
  
  
• Consulte a página do W3C Document Object Model.
  
  
• Consulte a página inicial do ODF Toolkit.
  
  
• Consulte a página inicial da comunidade OpenOffice.org.
  
  

Discutir

• Participar do fórum de discussão.
  
  
• Compartilhe seu conhecimento na wiki do Lotus Symphony do developerWorks.
  
  

Sobre o autor

Classificar este artigo

Comentários

Voltar para parte superior

Índice

• Usando o ODFDOM para criar documentos de texto, planilhas e gráficos de apresentação
• Criando um arquivo texto
• Criando um arquivo de planilha
• Criando um arquivo de apresentação
• Conclusão
• Agradecimentos
• Download
• Recursos
• Sobre o autor
• Comentários

Conheça a IBM da sua cidade

A IBM está mais perto do que você imagina!

---

Saiba mais