LibreOffice Module xmerge (master)  1
SxcDocumentDeserializer.java
Go to the documentation of this file.
1 /*
2  * This file is part of the LibreOffice project.
3  *
4  * This Source Code Form is subject to the terms of the Mozilla Public
5  * License, v. 2.0. If a copy of the MPL was not distributed with this
6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
7  *
8  * This file incorporates work covered by the following license notice:
9  *
10  * Licensed to the Apache Software Foundation (ASF) under one or more
11  * contributor license agreements. See the NOTICE file distributed
12  * with this work for additional information regarding copyright
13  * ownership. The ASF licenses this file to you under the Apache
14  * License, Version 2.0 (the "License"); you may not use this file
15  * except in compliance with the License. You may obtain a copy of
16  * the License at http://www.apache.org/licenses/LICENSE-2.0 .
17  */
18 
19 package org.openoffice.xmerge.converter.xml.sxc;
20 
21 import java.io.IOException;
22 import java.util.Iterator;
23 
32 import org.w3c.dom.Element;
33 import org.w3c.dom.Node;
34 import org.w3c.dom.NodeList;
35 
47 public abstract class SxcDocumentDeserializer implements OfficeConstants,
49 
53  private SpreadsheetDecoder decoder = null;
54 
56  private org.w3c.dom.Document settings = null;
57 
59  private org.w3c.dom.Document doc = null;
60 
62  private final ConvertData cd ;
63 
65  private StyleCatalog styleCat = null;
66 
67  private int textStyles = 1;
68  private int colStyles = 1;
69  private int rowStyles = 1;
70 
77  this.cd = cd;
78  }
79 
91  public abstract SpreadsheetDecoder createDecoder(String workbook, String[] worksheetNames, String password)
92  throws IOException;
93 
108  protected abstract String getWorkbookName(ConvertData cd) throws IOException;
109 
118  protected abstract String[] getWorksheetNames(ConvertData cd) throws IOException;
119 
135  IOException {
136 
137  // Get the name of the WorkBook from the ConvertData.
138  String[] worksheetNames = getWorksheetNames(cd);
139  String workbookName = getWorkbookName(cd);
140 
141  // Create a document
142  SxcDocument sxcDoc = new SxcDocument(workbookName);
143  sxcDoc.initContentDOM();
144  sxcDoc.initSettingsDOM();
145 
146  // Default to an initial 5 entries in the catalog.
147  styleCat = new StyleCatalog(5);
148 
149  doc = sxcDoc.getContentDOM();
150  settings = sxcDoc.getSettingsDOM();
151  initFontTable();
152  // Little fact for the curious reader: workbookName should
153  // be the name of the StarCalc file minus the file extension suffix.
154 
155  // Create a Decoder to decode the DeviceContent to a spreadsheet document
156  // ToDo - we aren't using a password in StarCalc, so we can
157  // use any value for password here. If StarCalc XML supports
158  // passwords in the future, we should try to get the correct
159  // password value here.
160 
161  decoder = createDecoder(workbookName, worksheetNames, "password");
162 
163  Debug.log(Debug.TRACE, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
164  Debug.log(Debug.TRACE, "<DEBUGLOG>");
165 
166  decoder.addDeviceContent(cd);
167  decode();
168 
169  Debug.log(Debug.TRACE, "</DEBUGLOG>");
170 
171  return sxcDoc;
172  }
173 
178  private void initFontTable() {
179 
180  String fontTable[]= new String[] { "Tahoma", "Tahoma", "swiss", "variable",
181  "Courier New", "&apos;Courier New&apos;",
182  "modern", "fixed" };
183  // Traverse to the office:body element.
184  // There should only be one.
185  NodeList list = doc.getElementsByTagName(TAG_OFFICE_FONT_DECLS);
186  Node root = list.item(0);
187 
188  for(int i=0;i<fontTable.length;) {
189 
190  // Create an element node for the table
191  Element tableElement = doc.createElement(TAG_STYLE_FONT_DECL);
192 
193  tableElement.setAttribute(ATTRIBUTE_STYLE_NAME, fontTable[i++]);
194  tableElement.setAttribute(ATTRIBUTE_FO_FONT_FAMILY, fontTable[i++]);
195  tableElement.setAttribute(ATTRIBUTE_FO_FONT_FAMILY_GENERIC, fontTable[i++]);
196  tableElement.setAttribute(ATTRIBUTE_STYLE_FONT_PITCH, fontTable[i++]);
197 
198  root.appendChild(tableElement);
199  }
200 
201  }
202 
208  protected void decode() throws IOException {
209 
210  // Get number of worksheets
211  int numSheets = decoder.getNumberOfSheets();
212  // #i33702# - check for an Empty InputStream.
213  if(numSheets == 0)
214  {
215  System.err.println("Error decoding invalid Input stream");
216  return;
217  }
218 
219  // Traverse to the office:body element.
220  // There should only be one.
221  NodeList list = doc.getElementsByTagName(TAG_OFFICE_BODY);
222  Node node = list.item(0);
223 
224  for (int i = 0; i < numSheets; i++) {
225 
226  // Set the decoder to the correct worksheet
227  decoder.setWorksheet(i);
228 
229  int len = list.getLength();
230 
231  if (len > 0) {
232 
233  // Process the spreadsheet
234  processTable(node);
235  }
236  }
237 
238  // Add the Defined Name table if there is one
239  Iterator<NameDefinition> nameDefinitionTable = decoder.getNameDefinitions();
240  if(nameDefinitionTable.hasNext()) {
241  processNameDefinition(node, nameDefinitionTable);
242  }
243 
244  // add settings
245  NodeList settingsList = settings.getElementsByTagName(TAG_OFFICE_SETTINGS);
246  Node settingsNode = settingsList.item(0);
247  processSettings(settingsNode);
248 
249  }
250 
258  protected void processSettings(Node root) {
259 
260  Element configItemSetEntry = settings.createElement(TAG_CONFIG_ITEM_SET);
261  configItemSetEntry.setAttribute(ATTRIBUTE_CONFIG_NAME, "view-settings");
262  Element configItemMapIndexed = settings.createElement(TAG_CONFIG_ITEM_MAP_INDEXED);
263  configItemMapIndexed.setAttribute(ATTRIBUTE_CONFIG_NAME, "Views");
264  Element configItemMapEntry = settings.createElement(TAG_CONFIG_ITEM_MAP_ENTRY);
265  BookSettings bs = decoder.getSettings();
266  bs.writeNode(settings, configItemMapEntry);
267 
268  configItemMapIndexed.appendChild(configItemMapEntry);
269  configItemSetEntry.appendChild(configItemMapIndexed);
270  root.appendChild(configItemSetEntry);
271  }
272 
283  protected void processNameDefinition(Node root, Iterator<NameDefinition> eNameDefinitions) throws IOException {
284 
285  Debug.log(Debug.TRACE, "<NAMED-EXPRESSIONS>");
286 
287  Element namedExpressionsElement = doc.createElement(TAG_NAMED_EXPRESSIONS);
288 
289  while(eNameDefinitions.hasNext()) {
290 
291  NameDefinition tableEntry = eNameDefinitions.next();
292  tableEntry.writeNode(doc, namedExpressionsElement);
293  }
294 
295  root.appendChild(namedExpressionsElement);
296 
297  Debug.log(Debug.TRACE, "</NAMED-EXPRESSIONS>");
298  }
299 
312  protected void processTable(Node root) throws IOException {
313 
314  Debug.log(Debug.TRACE, "<TABLE>");
315 
316  // Create an element node for the table
317  Element tableElement = doc.createElement(TAG_TABLE);
318 
319  // Get the sheet name
320  String sheetName = decoder.getSheetName();
321 
322  // Set the table name attribute
323  tableElement.setAttribute(ATTRIBUTE_TABLE_NAME, sheetName);
324 
325  // ToDo - style currently hardcoded - get real value
326  // Set table style-name attribute
327  tableElement.setAttribute(ATTRIBUTE_TABLE_STYLE_NAME, "Default");
328 
329  // Append the table element to the root node
330  root.appendChild(tableElement);
331 
332  Debug.log(Debug.TRACE, "<SheetName>" + sheetName + "</SheetName>");
333 
334  // Add the various different table-columns
335  processColumns(tableElement);
336 
337  // Get each cell and add to doc
338  processCells(tableElement);
339 
340  Debug.log(Debug.TRACE, "</TABLE>");
341  }
342 
355  protected void processColumns(Node root) throws IOException {
356 
357  for(Iterator<ColumnRowInfo> e = decoder.getColumnRowInfos();e.hasNext();) {
358 
359  ColumnRowInfo ci = e.next();
360  if(ci.isColumn()) {
362  SxcConstants.DEFAULT_STYLE, ci.getSize(), null);
363 
364  Style result[] = styleCat.getMatching(cStyle);
365  String styleName;
366  if(result.length==0) {
367 
368  cStyle.setName("co" + colStyles++);
369  styleName = cStyle.getName();
370  Debug.log(Debug.TRACE,"No existing style found, adding " + styleName);
371  styleCat.add(cStyle);
372  } else {
373  ColumnStyle existingStyle = (ColumnStyle) result[0];
374  styleName = existingStyle.getName();
375  Debug.log(Debug.TRACE,"Existing style found : " + styleName);
376  }
377 
378  // Create an element node for the new row
379  Element colElement = doc.createElement(TAG_TABLE_COLUMN);
380  colElement.setAttribute(ATTRIBUTE_TABLE_STYLE_NAME, styleName);
381  if(ci.getRepeated()!=1) {
382  String repeatStr = String.valueOf(ci.getRepeated());
383  colElement.setAttribute(ATTRIBUTE_TABLE_NUM_COLUMNS_REPEATED, repeatStr);
384  }
385  root.appendChild(colElement);
386  }
387  }
388  }
389 
402  protected void processCells(Node root) throws IOException {
403 
404  // The current row element
405  Element rowElement = null;
406 
407  // The current cell element
408  Element cellElement = null;
409 
410  // The row number - we may not have any rows (empty sheet)
411  // so set to zero.
412  int row = 0;
413 
414  // The column number - This is the expected column number of
415  // the next cell we are reading.
416  int col = 1;
417 
418  // The number of columns in the spreadsheet
419  int lastColumn = decoder.getNumberOfColumns();
420 
421  Node autoStylesNode = null;
422 
423  // Loop over all cells in the spreadsheet
424  while (decoder.goToNextCell()) {
425 
426  // Get the row number
427  int newRow = decoder.getRowNumber();
428 
429  // Is the cell in a new row, or part of the current row?
430  if (newRow != row) {
431 
432  // Make sure that all the cells in the previous row
433  // have been entered.
434  if (col <= lastColumn && rowElement != null) {
435  int numSkippedCells = lastColumn - col + 1;
436  addEmptyCells(numSkippedCells, rowElement);
437  }
438 
439  // log an end row - if we already have a row
440  if (row != 0) {
441  Debug.log(Debug.TRACE, "</tr>");
442  }
443 
444  // How far is the new row from the last row?
445  int deltaRows = newRow - row;
446 
447  // Check if we have skipped any rows
448  if (deltaRows > 1) {
449  // Add in empty rows
450  addEmptyRows(deltaRows-1, root, lastColumn);
451  }
452 
453  // Re-initialize column (since we are in a new row)
454  col = 1;
455 
456  // Create an element node for the new row
457  rowElement = doc.createElement(TAG_TABLE_ROW);
458 
459  for(Iterator<ColumnRowInfo> e = decoder.getColumnRowInfos();e.hasNext();) {
460  ColumnRowInfo cri = e.next();
461  if(cri.isRow() && cri.getRepeated()==newRow-1) {
462  // We have the correct Row BIFFRecord for this row
463  RowStyle rStyle = new RowStyle("Default",SxcConstants.ROW_STYLE_FAMILY,
464  SxcConstants.DEFAULT_STYLE, cri.getSize(), null);
465 
466  Style result[] = styleCat.getMatching(rStyle);
467  String styleName;
468  if(result.length==0) {
469 
470  rStyle.setName("ro" + rowStyles++);
471  styleName = rStyle.getName();
472  Debug.log(Debug.TRACE,"No existing style found, adding " + styleName);
473  styleCat.add(rStyle);
474  } else {
475  RowStyle existingStyle = (RowStyle) result[0];
476  styleName = existingStyle.getName();
477  Debug.log(Debug.TRACE,"Existing style found : " + styleName);
478  }
479  rowElement.setAttribute(ATTRIBUTE_TABLE_STYLE_NAME, styleName);
480  // For now we will not use the repeat column attribute
481  }
482  }
483 
484  // Append the row element to the root node
485  root.appendChild(rowElement);
486 
487  // Update row number
488  row = newRow;
489 
490  Debug.log(Debug.TRACE, "<tr>");
491  }
492 
493  if (rowElement == null) {
494  //utterly busted
495  break;
496  }
497 
498  // Get the column number of the current cell
499  int newCol = decoder.getColNumber();
500 
501  // Check to see if some columns were skipped
502  if (newCol != col) {
503 
504  // How many columns have we skipped?
505  int numColsSkipped = newCol - col;
506 
507  addEmptyCells(numColsSkipped, rowElement);
508 
509  // Update the column number to account for the
510  // skipped cells
511  col = newCol;
512  }
513 
514  // Lets start dealing with the cell data
515  Debug.log(Debug.TRACE, "<td>");
516 
517  // Get the cell's contents
518  String cellContents = decoder.getCellContents();
519 
520  // Get the type of the data in the cell
521  String cellType = decoder.getCellDataType();
522 
523  // Get the cell format
524  Format fmt = decoder.getCellFormat();
525 
526  // Create an element node for the cell
527  cellElement = doc.createElement(TAG_TABLE_CELL);
528 
529  Node bodyNode = doc.getElementsByTagName(TAG_OFFICE_BODY).item(0);
530 
531  // Not every document has an automatic style tag
532  autoStylesNode = doc.getElementsByTagName(
534 
535  if (autoStylesNode == null) {
536  autoStylesNode = doc.createElement(TAG_OFFICE_AUTOMATIC_STYLES);
537  doc.insertBefore(autoStylesNode, bodyNode);
538  }
539 
540  CellStyle tStyle = new
542  SxcConstants.DEFAULT_STYLE, fmt, null);
543  String styleName;
544  Style result[] = styleCat.getMatching(tStyle);
545  if(result.length==0) {
546 
547  tStyle.setName("ce" + textStyles++);
548  styleName = tStyle.getName();
549  Debug.log(Debug.TRACE,"No existing style found, adding " + styleName);
550  styleCat.add(tStyle);
551  } else {
552  CellStyle existingStyle = (CellStyle) result[0];
553  styleName = existingStyle.getName();
554  Debug.log(Debug.TRACE,"Existing style found : " + styleName);
555  }
556 
557  cellElement.setAttribute(ATTRIBUTE_TABLE_STYLE_NAME, styleName);
558 
559  // Store the cell data into the appropriate attributes
560  processCellData(cellElement, cellType, cellContents);
561 
562  // Append the cell element to the row node
563  rowElement.appendChild(cellElement);
564 
565  // Append the cellContents as a text node
566  Element textElement = doc.createElement(TAG_PARAGRAPH);
567  cellElement.appendChild(textElement);
568  textElement.appendChild(doc.createTextNode(cellContents));
569 
570  Debug.log(Debug.TRACE, cellContents);
571  Debug.log(Debug.TRACE, "</td>");
572 
573  // Increment to the column number of the next expected cell
574  col++;
575  }
576 
577  // Make sure that the last row is padded correctly
578  if (col <= lastColumn && rowElement != null) {
579  int numSkippedCells = lastColumn - col + 1;
580  addEmptyCells(numSkippedCells, rowElement);
581  }
582 
583  // Now write the style catalog to the document
584  if(autoStylesNode!=null) {
585  Debug.log(Debug.TRACE, "Well the autostyle node was found!!!");
586  NodeList nl = styleCat.writeNode(doc, "dummy").getChildNodes();
587  int nlLen = nl.getLength(); // nl.item reduces the length
588  for (int i = 0; i < nlLen; i++) {
589  autoStylesNode.appendChild(nl.item(0));
590  }
591  }
592 
593  if (row != 0) {
594  // The sheet does have rows, so write out a /tr
595  Debug.log(Debug.TRACE, "</tr>");
596  }
597  }
598 
613  protected void addEmptyRows(int numEmptyRows, Node root, int numEmptyCells) {
614 
615  // Create an element node for the row
616  Element rowElement = doc.createElement(TAG_TABLE_ROW);
617 
618  // ToDo - style currently hardcoded - get real value
619  // Set row style-name attribute
620  rowElement.setAttribute(ATTRIBUTE_TABLE_STYLE_NAME, "Default");
621 
622  // Set cell number-rows-repeated attribute
623  rowElement.setAttribute(ATTRIBUTE_TABLE_NUM_ROWS_REPEATED,
624  Integer.toString(numEmptyRows));
625 
626  // Append the row element to the root node
627  root.appendChild(rowElement);
628 
629  // Open Office requires the empty row to have an empty cell (or cells)
630  addEmptyCells(numEmptyCells, rowElement);
631 
632  // Write empty rows to the log
633  for (int i = 0; i < numEmptyRows; i++) {
634  Debug.log(Debug.TRACE, "<tr />");
635  }
636 
637  }
638 
652  protected void addEmptyCells(int numColsSkipped, Node row) {
653 
654  // Create an empty cellElement
655  Element cellElement = doc.createElement(TAG_TABLE_CELL);
656 
657  // ToDo - style currently hardcoded - get real value
658  // Set cell style-name attribute
659  cellElement.setAttribute(ATTRIBUTE_TABLE_STYLE_NAME, "Default");
660 
661  // If we skipped more than 1 cell, we must set the
662  // appropriate attribute
663  if (numColsSkipped > 1) {
664 
665  // Set cell number-columns-repeated attribute
666  cellElement.setAttribute(ATTRIBUTE_TABLE_NUM_COLUMNS_REPEATED,
667  Integer.toString(numColsSkipped));
668  }
669 
670  // Append the empty cell element to the row node
671  row.appendChild(cellElement);
672 
673  // Write empty cells to the log
674  for (int i = 0; i < numColsSkipped; i++) {
675  Debug.log(Debug.TRACE, "<td />");
676  }
677  }
678 
689  protected void processCellData(Element cellElement, String type,
690  String contents) {
691 
692  // Set cell value-type attribute
693  cellElement.setAttribute(ATTRIBUTE_TABLE_VALUE_TYPE, type);
694 
695  // Does the cell contain a formula?
696  if (contents.startsWith("=")) {
697 
698  cellElement.setAttribute(ATTRIBUTE_TABLE_FORMULA, contents);
699 
700  cellElement.setAttribute(ATTRIBUTE_TABLE_VALUE, decoder.getCellValue());
701  // String data does not require any additional attributes
702  } else if (!type.equals(CELLTYPE_STRING)) {
703 
704  if (type.equals(CELLTYPE_TIME)) {
705 
706  // Data returned in StarOffice XML format, so store in
707  // attribute
708  cellElement.setAttribute(ATTRIBUTE_TABLE_TIME_VALUE,
709  contents);
710 
711  } else if (type.equals(CELLTYPE_DATE)) {
712 
713  // Data returned in StarOffice XML format, so store in
714  // attribute
715  cellElement.setAttribute(ATTRIBUTE_TABLE_DATE_VALUE,
716  contents);
717 
718  } else if (type.equals(CELLTYPE_BOOLEAN)) {
719 
720  // StarOffice XML format requires stored boolean value
721  // to be in lower case
722  cellElement.setAttribute(ATTRIBUTE_TABLE_BOOLEAN_VALUE,
723  contents.toLowerCase());
724 
725  } else if (type.equals(CELLTYPE_CURRENCY)) {
726  // TODO - StarOffice XML format requires a correct style to
727  // display currencies correctly. Need to implement styles.
728  // TODO - USD is for US currencies. Need to pick up
729  // the correct currency location from the source file.
730  cellElement.setAttribute(ATTRIBUTE_TABLE_CURRENCY, "USD");
731 
732  // Data comes stripped of currency symbols
733  cellElement.setAttribute(ATTRIBUTE_TABLE_VALUE, contents);
734 
735  } else if (type.equals(CELLTYPE_PERCENT)) {
736  // Data comes stripped of percent signs
737  cellElement.setAttribute(ATTRIBUTE_TABLE_VALUE, contents);
738 
739  } else {
740  // Remaining data types use table-value attribute
741 
742  cellElement.setAttribute(ATTRIBUTE_TABLE_VALUE, contents);
743  }
744  }
745  }
746 }
abstract String getCellContents()
Return the contents of the active cell.
void addEmptyRows(int numEmptyRows, Node root, int numEmptyCells)
This method will add empty rows to the.
void addEmptyCells(int numColsSkipped, Node row)
This method will add empty cells to the.
String CELLTYPE_STRING
The cell contains data of type string.
String ATTRIBUTE_TABLE_VALUE_TYPE
Attribute tag for table:value-type of element table:table-cell.
abstract int getNumberOfColumns()
Returns the number of populated columns in the current WorkSheet.
void setName(String newName)
Sets the name of this.
Definition: Style.java:125
abstract Iterator< ColumnRowInfo > getColumnRowInfos()
Returns an Enumeration to a Vector of.
String ATTRIBUTE_TABLE_DATE_VALUE
Attribute tag for table:date-value of element table:table-cell.
String TAG_TABLE_ROW
Element tag for table:table-row.
String TAG_CONFIG_ITEM_MAP_INDEXED
Element tag for config:config-item-map-indexed.
abstract String[] getWorksheetNames(ConvertData cd)
This method will return the name of the WorkSheet from the.
abstract Iterator< NameDefinition > getNameDefinitions()
Returns an Enumeration to a Vector of.
Provides general purpose utilities.
void initFontTable()
This initializes a font table so we can include some basic font support for spreadsheets.
String TAG_STYLE_FONT_DECL
Element tag for style:font-decl.
void processCellData(Element cellElement, String type, String contents)
This method process the data in a cell and sets the appropriate attributes on the cell...
String ATTRIBUTE_TABLE_CURRENCY
Attribute tag for table:currency of element table:table-cell.
static void log(int flag, String msg)
Log message based on the flag type.
Definition: Debug.java:205
void processTable(Node root)
This method process a WorkSheet and generates a portion of the.
String TAG_CONFIG_ITEM_SET
Element tag for config:config-item-set.
String ATTRIBUTE_TABLE_STYLE_NAME
Attribute tag for table:style-name of table elements.
This is a class representing the different attributes for a worksheet contained in settings...
String ATTRIBUTE_STYLE_NAME
Attribute tag for style:name of element style:name.
int getSize()
Get the height (for rows) or width (for columns).
This interface contains constants for StarOffice XML tags, attributes (StarCalc cell types...
void decode()
Outer level method used to decode a WorkBook into a.
abstract String getWorkbookName(ConvertData cd)
This method will return the name of the WorkBook from the.
String ATTRIBUTE_TABLE_TIME_VALUE
Attribute tag for table:time-value of element table:table-cell.
String DEFAULT_STYLE
Name of the default style.
String TAG_TABLE_COLUMN
Element tag for table:table-column.
abstract void addDeviceContent(ConvertData cd)
Add the contents of a.
This is a class to define a Name Definition structure.
static final int TRACE
Trace messages.
Definition: Debug.java:46
Interface defining constants for Sxc attributes.
String TAG_OFFICE_FONT_DECLS
Element tag for office:font-decls.
String ATTRIBUTE_TABLE_NAME
Attribute tag for table:name of element table:table.
String CELLTYPE_BOOLEAN
The cell contains data of type boolean.
String ATTRIBUTE_TABLE_BOOLEAN_VALUE
Attribute tag for table:time-boolean-value of element table:table-cell.
String TAG_TABLE_CELL
Element tag for table:table-cell.
exports com.sun.star. java
abstract String getCellValue()
Return the value of the active cell.
abstract String getCellDataType()
Return the data type of the active cell.
String ATTRIBUTE_FO_FONT_FAMILY_GENERIC
Attribute tag for fo:font-family of element fo:font-family.
void add(Node node, String families[], Class<?> classes[], Class<?> defaultClass, boolean alwaysCreateDefault)
Parse the.
int i
This class specifies the format for a given spreadsheet cell.
Definition: Format.java:26
String CELLTYPE_DATE
The cell contains data of type date.
String TAG_CONFIG_ITEM_MAP_ENTRY
Element tag for config:config-item-map-entry.
String ATTRIBUTE_TABLE_NUM_ROWS_REPEATED
Attribute tag for table:number-rows-repeated of element table:table-row.
abstract BookSettings getSettings()
Returns the.
String ATTRIBUTE_FO_FONT_FAMILY
Attribute tag for fo:font-family of element fo:font-family.
abstract SpreadsheetDecoder createDecoder(String workbook, String[] worksheetNames, String password)
This.
String TAG_OFFICE_AUTOMATIC_STYLES
Element tag for office:automatic-styles.
abstract String getSheetName()
Returns the name of the current WorkSheet.
String COLUMN_STYLE_FAMILY
Family name for column styles.
void writeNode(org.w3c.dom.Document doc, Node root)
Writes out a content.xml entry for this NameDefinition object.
String ATTRIBUTE_TABLE_VALUE
Attribute tag for table:value of element table:table-cell.
String TABLE_CELL_STYLE_FAMILY
Family name for table-cell styles.
This is a class to define a table-column structure.
String ROW_STYLE_FAMILY
Family name for row styles.
void processSettings(Node root)
This method process the settings portion of the.
void processNameDefinition(Node root, Iterator< NameDefinition > eNameDefinitions)
This method process a Name Definition Table and generates a portion of the.
String TAG_NAMED_EXPRESSIONS
Element tag for table:named-expression.
abstract int getRowNumber()
Returns the number of the active row.
String ATTRIBUTE_TABLE_NUM_COLUMNS_REPEATED
Attribute tag for table:number-columns-repeated of element table:table-cell.
String ATTRIBUTE_TABLE_FORMULA
Attribute tag for table:formula of element table:table-cell.
String ATTRIBUTE_CONFIG_NAME
Attribute tag for config:name of element config:config-item.
String CELLTYPE_PERCENT
The cell contains data of type percent.
String ATTRIBUTE_STYLE_FONT_PITCH
Attribute tag for style:font-pitch of element style:font-pitch.
String CELLTYPE_TIME
The cell contains data of type time.
Any result
Provides interfaces for converting between two.
Definition: Convert.java:19
This class is used for logging debug messages.
Definition: Debug.java:39
void processCells(Node root)
This method process the cells in a.
int getRepeated()
Get the repeat count for this item.
void processColumns(Node root)
This method process the cells in a.
abstract int getNumberOfSheets()
Returns the total number of sheets in the WorkBook.
String TAG_OFFICE_BODY
Element tag for office:body.
Element writeNode(org.w3c.dom.Document parentDoc, String name)
Create a.
This is an interface used by the DiffAlgorithm and MergeAlgorithm to access a.
Definition: Iterator.java:27
abstract int getColNumber()
Returns the number of the active column.
This class is an implementation of.
String CELLTYPE_CURRENCY
The cell contains data of type currency.
String TAG_OFFICE_SETTINGS
Element tag for office:settings.
abstract boolean goToNextCell()
Move on the next populated cell in the current WorkSheet.
abstract void setWorksheet(int sheetIndex)
Sets the active WorkSheet.
void writeNode(org.w3c.dom.Document settings, Node root)
Writes out a settings.xml entry for this.
String getName()
Returns the name of this.
Definition: Style.java:116