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
19package org.openoffice.xmerge.converter.xml.sxc;
20
21import java.io.IOException;
22import java.util.Iterator;
23
32import org.w3c.dom.Element;
33import org.w3c.dom.Node;
34import org.w3c.dom.NodeList;
35
47public abstract class SxcDocumentDeserializer implements OfficeConstants,
49
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();
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
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
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
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);
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()) {
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
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}
ConvertData is used as a container for passing Document objects in and out of the Convert class.
This Exception is thrown by convert algorithms.
A StyleCatalog holds a collection of Style objects.
Style[] getMatching(Style s)
Given a Style s return all Style objects that match.
Element writeNode(org.w3c.dom.Document parentDoc, String name)
Create a Node named name in Document parentDoc, and write the entire StyleCatalog to it.
void add(Node node, String families[], Class<?> classes[], Class<?> defaultClass, boolean alwaysCreateDefault)
Parse the Document starting from node and working downward, and add all styles found,...
An object of class Style represents a style in an OpenOffice document.
Definition: Style.java:34
String getName()
Returns the name of this Style.
Definition: Style.java:116
void setName(String newName)
Sets the name of this Style.
Definition: Style.java:125
This is a class representing the different attributes for a worksheet contained in settings....
void writeNode(org.w3c.dom.Document settings, Node root)
Writes out a settings.xml entry for this BookSettings object.
Represents a text Style in an OpenOffice document.
Definition: CellStyle.java:35
This is a class to define a table-column structure.
boolean isRow()
Does this ColumnRowInfo represent a row?
int getRepeated()
Get the repeat count for this item.
int getSize()
Get the height (for rows) or width (for columns).
boolean isColumn()
Does this ColumnRowInfo represent a column?
Represents a text Style in an OpenOffice document.
This class specifies the format for a given spreadsheet cell.
Definition: Format.java:26
This is a class to define a Name Definition structure.
void writeNode(org.w3c.dom.Document doc, Node root)
Writes out a content.xml entry for this NameDefinition object.
Represents a text Style in an OpenOffice document.
Definition: RowStyle.java:34
This class is a abstract class for encoding a "Device" Document format into an alternative spreadshee...
abstract String getCellContents()
Return the contents of the active cell.
abstract Iterator< ColumnRowInfo > getColumnRowInfos()
Returns an Enumeration to a Vector of ColumnRowInfo.
abstract int getNumberOfColumns()
Returns the number of populated columns in the current WorkSheet.
abstract String getSheetName()
Returns the name of the current WorkSheet.
abstract BookSettings getSettings()
Returns the BookSettings.
abstract int getRowNumber()
Returns the number of the active row.
abstract Format getCellFormat()
Return a Format object describing the active cells formatting.
abstract void addDeviceContent(ConvertData cd)
Add the contents of a ConvertData to the workbook.
abstract String getCellDataType()
Return the data type of the active cell.
abstract String getCellValue()
Return the value of the active cell.
abstract boolean goToNextCell()
Move on the next populated cell in the current WorkSheet.
abstract int getColNumber()
Returns the number of the active column.
abstract void setWorksheet(int sheetIndex)
Sets the active WorkSheet.
abstract int getNumberOfSheets()
Returns the total number of sheets in the WorkBook.
abstract Iterator< NameDefinition > getNameDefinitions()
Returns an Enumeration to a Vector of NameDefinition.
General spreadsheet implementation of DocumentDeserializer for the SxcPluginFactory.
void processCellData(Element cellElement, String type, String contents)
This method process the data in a cell and sets the appropriate attributes on the cell Element.
void processNameDefinition(Node root, Iterator< NameDefinition > eNameDefinitions)
This method process a Name Definition Table and generates a portion of the Document.
final ConvertData cd
A ConvertData object assigned to this object.
void processCells(Node root)
This method process the cells in a Document and generates a portion of the Document.
void addEmptyCells(int numColsSkipped, Node row)
This method will add empty cells to the Document.
abstract String[] getWorksheetNames(ConvertData cd)
This method will return the name of the WorkSheet from the ConvertData.
void processColumns(Node root)
This method process the cells in a Document and generates a portion of the Document.
void initFontTable()
This initializes a font table so we can include some basic font support for spreadsheets.
void processTable(Node root)
This method process a WorkSheet and generates a portion of the Document.
SpreadsheetDecoder decoder
A SpreadsheetDecoder object for decoding from device formats.
void decode()
Outer level method used to decode a WorkBook into a Document.
abstract String getWorkbookName(ConvertData cd)
This method will return the name of the WorkBook from the ConvertData.
abstract SpreadsheetDecoder createDecoder(String workbook, String[] worksheetNames, String password)
This abstract method will be implemented by concrete subclasses and will return an application-specif...
Document deserialize()
Method to convert a set of "Device" Document objects into a SxcDocument object and returns it as a Do...
void processSettings(Node root)
This method process the settings portion of the Document.
void addEmptyRows(int numEmptyRows, Node root, int numEmptyCells)
This method will add empty rows to the Document.
This class is an implementation of OfficeDocument for the SXC format.
This class is used for logging debug messages.
Definition: Debug.java:39
static final int TRACE
Trace messages.
Definition: Debug.java:46
static void log(int flag, String msg)
Log message based on the flag type.
Definition: Debug.java:205
A DocumentDeserializer represents a converter that converts "Device" Document objects into the "Offic...
A Document represents any Document to be converted and the resulting Document from any conversion.
Definition: Document.java:36
This interface contains constants for StarOffice XML tags, attributes (StarCalc cell types,...
String TAG_TABLE_CELL
Element tag for table:table-cell.
String ATTRIBUTE_FO_FONT_FAMILY_GENERIC
Attribute tag for fo:font-family of element fo:font-family.
String ATTRIBUTE_CONFIG_NAME
Attribute tag for config:name of element config:config-item.
String ATTRIBUTE_TABLE_VALUE
Attribute tag for table:value of element table:table-cell.
String ATTRIBUTE_TABLE_VALUE_TYPE
Attribute tag for table:value-type of element table:table-cell.
String ATTRIBUTE_TABLE_STYLE_NAME
Attribute tag for table:style-name of table elements.
String ATTRIBUTE_STYLE_NAME
Attribute tag for style:name of element style:name.
String ATTRIBUTE_TABLE_NUM_COLUMNS_REPEATED
Attribute tag for table:number-columns-repeated of element table:table-cell.
String TAG_TABLE_COLUMN
Element tag for table:table-column.
String ATTRIBUTE_FO_FONT_FAMILY
Attribute tag for fo:font-family of element fo:font-family.
String CELLTYPE_CURRENCY
The cell contains data of type currency.
String TAG_OFFICE_BODY
Element tag for office:body.
String TAG_CONFIG_ITEM_MAP_ENTRY
Element tag for config:config-item-map-entry.
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_OFFICE_AUTOMATIC_STYLES
Element tag for office:automatic-styles.
String CELLTYPE_DATE
The cell contains data of type date.
String TAG_TABLE_ROW
Element tag for table:table-row.
String CELLTYPE_TIME
The cell contains data of type time.
String CELLTYPE_STRING
The cell contains data of type string.
String TAG_STYLE_FONT_DECL
Element tag for style:font-decl.
String ATTRIBUTE_TABLE_FORMULA
Attribute tag for table:formula of element table:table-cell.
String ATTRIBUTE_TABLE_DATE_VALUE
Attribute tag for table:date-value of element table:table-cell.
String TAG_CONFIG_ITEM_MAP_INDEXED
Element tag for config:config-item-map-indexed.
String ATTRIBUTE_TABLE_CURRENCY
Attribute tag for table:currency of element table:table-cell.
String ATTRIBUTE_TABLE_NUM_ROWS_REPEATED
Attribute tag for table:number-rows-repeated of element table:table-row.
String ATTRIBUTE_STYLE_FONT_PITCH
Attribute tag for style:font-pitch of element style:font-pitch.
String TAG_CONFIG_ITEM_SET
Element tag for config:config-item-set.
String ATTRIBUTE_TABLE_TIME_VALUE
Attribute tag for table:time-value of element table:table-cell.
String TAG_NAMED_EXPRESSIONS
Element tag for table:named-expression.
String CELLTYPE_PERCENT
The cell contains data of type percent.
String TAG_OFFICE_SETTINGS
Element tag for office:settings.
String TAG_OFFICE_FONT_DECLS
Element tag for office:font-decls.
String ATTRIBUTE_TABLE_NAME
Attribute tag for table:name of element table:table.
Interface defining constants for Sxc attributes.
String COLUMN_STYLE_FAMILY
Family name for column styles.
String TABLE_CELL_STYLE_FAMILY
Family name for table-cell styles.
String DEFAULT_STYLE
Name of the default style.
String ROW_STYLE_FAMILY
Family name for row styles.
This is an interface used by the DiffAlgorithm and MergeAlgorithm to access a Document.
Definition: Iterator.java:27
int i
Document and PluginFactory implementations for XML based formats.
Provides general purpose utilities.
Provides interfaces for converting between two Document formats, and supports a "merge" interface for...
Definition: Convert.java:19
Any result
ResultType type