LibreOffice Module xmerge (master)  1
SxcDocumentSerializer.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.ArrayList;
23 import java.util.Iterator;
24 
32 import org.w3c.dom.Element;
33 import org.w3c.dom.NamedNodeMap;
34 import org.w3c.dom.Node;
35 import org.w3c.dom.NodeList;
36 
48 public abstract class SxcDocumentSerializer implements OfficeConstants,
50 
52  private Format fmt = null;
53 
55  private int rowID = 1;
56 
58  private int colID = 1;
59 
61  private int rowsRepeated = 1;
62 
64  private int colsRepeated = 1;
65 
67  private StyleCatalog styleCat = null;
68 
73  private ArrayList<ColumnRowInfo> ColumnRowList;
74 
78  protected SpreadsheetEncoder encoder = null;
79 
86  fmt = new Format();
87  }
88 
103  public abstract ConvertData serialize() throws ConvertException,
104  IOException;
105 
113  public void traverseSettings(Node node) throws IOException {
114  if (node.hasChildNodes()) {
115 
116  NodeList nodeList = node.getChildNodes();
117  int len = nodeList.getLength();
118  for (int i = 0; i < len; i++) {
119  Node child = nodeList.item(i);
120 
121  if (child.getNodeType() == Node.ELEMENT_NODE) {
122  String nodeName = child.getNodeName();
123 
124  if (nodeName.equals(TAG_CONFIG_ITEM_SET)) {
125 
126  traverseSettings(child);
127 
128  } else if (nodeName.equals(TAG_CONFIG_ITEM_MAP_INDEXED)) {
129 
130  traverseSettings(child);
131 
132  } else if (nodeName.equals(TAG_CONFIG_ITEM_MAP_ENTRY)) {
133 
134  BookSettings bs = new BookSettings(child);
135  encoder.addSettings(bs);
136 
137  } else {
138 
139  Debug.log(Debug.TRACE, "<OTHERS " + XmlUtil.getNodeInfo(child) + " />");
140  }
141  }
142  }
143  }
144  }
145 
153  protected void loadStyles(SxcDocument sxcDoc) {
154 
155  styleCat = new StyleCatalog(25);
156  NodeList nl = null;
157  String families[] = new String[] { SxcConstants.COLUMN_STYLE_FAMILY,
160  Class<?> classes[] = new Class[] { ColumnStyle.class,
161  RowStyle.class,
162  CellStyle.class};
163  /*
164  * Process the content XML for any other style info.
165  */
166  org.w3c.dom.Document contentDom = sxcDoc.getContentDOM();
167  nl = contentDom.getElementsByTagName(TAG_OFFICE_AUTOMATIC_STYLES);
168  if (nl.getLength() != 0) {
169  styleCat.add(nl.item(0), families, classes, null, false);
170  }
171 
172  org.w3c.dom.Document stylesDom = sxcDoc.getStyleDOM();
173  nl = stylesDom.getElementsByTagName(TAG_OFFICE_STYLES);
174  if (nl.getLength() != 0) {
175  styleCat.add(nl.item(0), families, classes, null, false);
176  }
177  }
178 
186  protected void traverseBody(Node node) throws IOException {
187 
188  Debug.log(Debug.TRACE, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
189  Debug.log(Debug.TRACE, "<DEBUGLOG>");
190 
191  if (node.hasChildNodes()) {
192 
193  NodeList nodeList = node.getChildNodes();
194  int len = nodeList.getLength();
195 
196  for (int i = 0; i < len; i++) {
197  Node searchNode = nodeList.item(i);
198  if (searchNode.getNodeType() == Node.ELEMENT_NODE) {
199 
200  String nodeName = searchNode.getNodeName();
201 
202  if (nodeName.equals(TAG_NAMED_EXPRESSIONS)) {
203 
204  traverseNamedExpressions(searchNode);
205 
206  } else {
207 
208  Debug.log(Debug.TRACE, "Skipping " + XmlUtil.getNodeInfo(searchNode) + " />");
209  }
210  }
211  }
212 
213  for (int i = 0; i < len; i++) {
214  Node child = nodeList.item(i);
215 
216  if (child.getNodeType() == Node.ELEMENT_NODE) {
217  String nodeName = child.getNodeName();
218 
219  if (nodeName.equals(TAG_TABLE)) {
220 
221  traverseTable(child);
222 
223  } else {
224 
225  Debug.log(Debug.TRACE, "<OTHERS " + XmlUtil.getNodeInfo(child) + " />");
226  }
227  }
228  }
229  }
230 
231  Debug.log(Debug.TRACE, "</DEBUGLOG>");
232  }
233 
241  protected void traverseNamedExpressions(Node node) throws IOException {
242 
243  Debug.log(Debug.TRACE, "<NAMED:EXPRESSIONS>");
244 
245  if (node.hasChildNodes()) {
246 
247  NodeList nodeList = node.getChildNodes();
248  int len = nodeList.getLength();
249 
250  for (int i = 0; i < len; i++) {
251  Node child = nodeList.item(i);
252 
253  if (child.getNodeType() == Node.ELEMENT_NODE) {
254  NameDefinition nd = new NameDefinition(child);
255  encoder.setNameDefinition(nd);
256  }
257  }
258  }
259 
260  Debug.log(Debug.TRACE, "</NAMED:EXPRESSIONS>");
261  }
262 
270  protected void traverseTable(Node node) throws IOException {
271 
272  Debug.log(Debug.TRACE, "<TABLE>");
273 
274  ColumnRowList = new ArrayList<ColumnRowInfo>();
275 
276  // Get table attributes
277  // ToDo - extract style from attribute
278 
279  NamedNodeMap att = node.getAttributes();
280 
281  String tableName =
282  att.getNamedItem(ATTRIBUTE_TABLE_NAME).getNodeValue();
283 
284  rowID = 1;
285 
286  encoder.createWorksheet(tableName);
287 
288  if (node.hasChildNodes()) {
289 
290  NodeList nodeList = node.getChildNodes();
291  int len = nodeList.getLength();
292 
293  for (int i = 0; i < len; i++) {
294  Node child = nodeList.item(i);
295 
296  if (child.getNodeType() == Node.ELEMENT_NODE) {
297  String nodeName = child.getNodeName();
298 
299  if (nodeName.equals(TAG_TABLE_ROW)) {
300  // TODO - handle all the possible rows
301  // spelled out in the entities
302 
303  traverseTableRow(child);
304 
305  } else if (nodeName.equals(TAG_TABLE_COLUMN)) {
306 
307  traverseTableColumn(child);
308 
309  } else if (nodeName.equals(TAG_TABLE_SCENARIO)) {
310 
311  // TODO
312 
313  } else {
314 
315  Debug.log(Debug.TRACE, "<OTHERS " + XmlUtil.getNodeInfo(child) + " />");
316  }
317  }
318  }
319  }
320 
321  // Add column width info to the current sheet
322  encoder.setColumnRows(ColumnRowList);
323 
324  Debug.log(Debug.TRACE, "</TABLE>");
325  }
326 
334  protected void traverseTableRow(Node node) throws IOException {
335 
336  // Get the attributes of the row
337  NamedNodeMap cellAtt = node.getAttributes();
338 
339  if (cellAtt != null) {
340 
341  Node rowStyle =
342  cellAtt.getNamedItem(ATTRIBUTE_TABLE_STYLE_NAME);
343 
344  Node tableNumRowRepeatingNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_NUM_ROWS_REPEATED);
345  int repeatedRows = 1;
346 
347  if(tableNumRowRepeatingNode!=null) {
348  String repeatStr = tableNumRowRepeatingNode.getNodeValue();
349  Debug.log(Debug.TRACE, "traverseTableRow() repeated-rows : " + repeatStr);
350  repeatedRows = Integer.parseInt(repeatStr);
351  }
352 
353  String styleName = "";
354 
355  if ( rowStyle != null) {
356  styleName = rowStyle.getNodeValue();
357  }
358  if(styleName.equalsIgnoreCase("Default") || styleName.length()==0) {
359 
360  Debug.log(Debug.TRACE, "No defined Row Style Attribute was found");
361 
362  } else {
363 
364  RowStyle rStyle = ( RowStyle)styleCat.lookup(styleName,
366  RowStyle.class);
367 
368  int rowHeight = rStyle != null ? rStyle.getRowHeight() : 0;
369 
370  Debug.log(Debug.TRACE, "traverseTableRow() Row Height : " + rowHeight);
371  ColumnRowInfo ri = new ColumnRowInfo( rowHeight,
372  repeatedRows,
374  rowHeight!=0);
375  ColumnRowList.add(ri);
376  }
377 
378  // Get the attribute representing the number of rows repeated
379  Node rowsRepeatedNode =
380  cellAtt.getNamedItem(ATTRIBUTE_TABLE_NUM_ROWS_REPEATED);
381 
382  // There is a number of rows repeated attribute:
383  if (rowsRepeatedNode != null) {
384  // Get the number of times the row is repeated
385  String rowsRepeatedString = rowsRepeatedNode.getNodeValue();
386  rowsRepeated = Integer.parseInt(rowsRepeatedString);
387  } else {
388  // The row is not repeated
389  rowsRepeated = 1;
390  }
391  }
392 
393  Debug.log(Debug.TRACE, "<TR>");
394 
395  if (node.hasChildNodes()) {
396 
397  NodeList nodeList = node.getChildNodes();
398  int len = nodeList.getLength();
399 
400  for (int i = 0; i < len; i++) {
401  Node child = nodeList.item(i);
402 
403  if (child.getNodeType() == Node.ELEMENT_NODE) {
404  String nodeName = child.getNodeName();
405 
406  if (nodeName.equals(TAG_TABLE_CELL)) {
407 
408  traverseCell(child);
409 
410  } else {
411 
412  Debug.log(Debug.TRACE, "<OTHERS " + XmlUtil.getNodeInfo(child) + " />");
413  }
414  }
415  }
416  }
417 
418  // Increase the row counter by the number of rows which are repeated
419  rowID += rowsRepeated;
420 
421  // Re-initialize number of rows repeated before processing the next
422  // row data.
423  rowsRepeated = 1;
424 
425  // When starting a new row, set the column counter back to the
426  // first column.
427  colID = 1;
428 
429  // Re-initialize number of columns repeated before processing
430  // the next row data.
431  colsRepeated = 1;
432 
433  Debug.log(Debug.TRACE, "</TR>");
434  }
435 
445  protected void traverseTableColumn(Node node) throws IOException {
446 
447  Debug.log(Debug.TRACE, "traverseColumn() : ");
448  NamedNodeMap cellAtt = node.getAttributes();
449  Node tableStyleNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_STYLE_NAME);
450  Node tableNumColRepeatingNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_NUM_COLUMNS_REPEATED);
451  Node tableDefaultCellStyle = cellAtt.getNamedItem(ATTRIBUTE_DEFAULT_CELL_STYLE);
452 
453  int repeatedColumns = 1;
454  int columnWidth = 0;
456 
457  if(tableNumColRepeatingNode!=null) {
458  Debug.log(Debug.TRACE, "traverseColumn() repeated-cols : " + tableNumColRepeatingNode.getNodeValue());
459  repeatedColumns = Integer.parseInt(tableNumColRepeatingNode.getNodeValue());
460  col.setRepeated(repeatedColumns);
461  }
462 
463  String cellStyleName = "";
464 
465  if(tableDefaultCellStyle!=null) {
466  cellStyleName = tableDefaultCellStyle.getNodeValue();
467 
468  Debug.log(Debug.TRACE, "traverseColumn() default-cell-style : " + cellStyleName);
469  }
470 
471  CellStyle cellStyle = null;
472 
473  if(cellStyleName.equalsIgnoreCase("Default") || cellStyleName.length()==0) {
474 
475  Debug.log(Debug.TRACE, "No default cell Style Attribute was found");
476 
477  } else {
478 
479  cellStyle = (CellStyle)styleCat.lookup(cellStyleName,
481  CellStyle.class);
482  }
483 
484  if (cellStyle != null) {
485  Format defaultFmt = new Format(cellStyle.getFormat());
486  col.setFormat(defaultFmt);
487  }
488 
489  String styleName = "";
490 
491  if(tableStyleNode!=null) {
492  styleName = tableStyleNode.getNodeValue();
493  }
494 
495  if(styleName.equalsIgnoreCase("Default") || styleName.length()==0) {
496 
497  Debug.log(Debug.TRACE, "No defined Style Attribute was found");
498 
499  } else {
500 
501  ColumnStyle cStyle = (ColumnStyle)styleCat.lookup(styleName,
503  ColumnStyle.class);
504 
505  columnWidth = cStyle != null ? cStyle.getColWidth() : 0;
506  col.setSize(columnWidth);
507  Debug.log(Debug.TRACE, "traverseColumn() Column Width : " + columnWidth);
508 
509  }
510  ColumnRowList.add(col);
511  }
512 
520  protected void traverseCell(Node node) throws IOException {
521 
522  NamedNodeMap cellAtt = node.getAttributes();
523 
524  fmt.clearFormatting();
525 
526  // Get the type of data in the cell
527  Node tableValueTypeNode =
528  cellAtt.getNamedItem(ATTRIBUTE_TABLE_VALUE_TYPE);
529 
530  // Get the number of columns this cell is repeated
531  Node colsRepeatedNode =
532  cellAtt.getNamedItem(ATTRIBUTE_TABLE_NUM_COLUMNS_REPEATED);
533 
534  // Get the style type
535  Node tableStyleNode =
536  cellAtt.getNamedItem(ATTRIBUTE_TABLE_STYLE_NAME);
537 
538  String styleName = "";
539 
540  if(tableStyleNode!=null) {
541  styleName = tableStyleNode.getNodeValue();
542  }
543 
544  CellStyle cStyle = null;
545 
546  if(styleName.equalsIgnoreCase("Default")) {
547 
548  Debug.log(Debug.TRACE, "No defined Style Attribute was found");
549 
550  } else if(styleName.length()!=0) {
551 
552  cStyle = (CellStyle)styleCat.lookup(styleName,
554  CellStyle.class);
555  }
556 
557  if (cStyle != null) {
558  Format definedFormat = cStyle.getFormat();
559  fmt = new Format(definedFormat);
560  }
561 
562  // There is a number of cols repeated attribute
563  if (colsRepeatedNode != null) {
564  // Get the number of times the cell is repeated
565  String colsRepeatedString = colsRepeatedNode.getNodeValue();
566  colsRepeated = Integer.parseInt(colsRepeatedString);
567  } else {
568  // The cell is not repeated
569  colsRepeated = 1;
570  }
571 
572 
573  // if there is no style we need to check to see if there is a default
574  // cell style defined in the table-column's
575 
576  if (fmt.isDefault() && styleName.length()==0) {
577  int index = 1;
578  for(Iterator<ColumnRowInfo> e = ColumnRowList.iterator();e.hasNext();) {
579  ColumnRowInfo cri = e.next();
580  if(cri.isColumn()) {
581  if(colID>=index && colID<(index+cri.getRepeated())) {
582  fmt = new Format(cri.getFormat());
583  }
584  index += cri.getRepeated();
585  }
586  }
587  }
588 
589  if (tableValueTypeNode != null) {
590 
591  String cellType =
592  tableValueTypeNode.getNodeValue();
593 
594  if (cellType.equalsIgnoreCase(CELLTYPE_STRING)) {
595 
596  // has text:p tag
598  Node tableStringValueNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_STRING_VALUE);
599  Debug.log(Debug.TRACE,"Cell Type String : " + tableStringValueNode);
600  if(tableStringValueNode != null) {
601  fmt.setValue(tableStringValueNode.getNodeValue());
602  }
603 
604  } else if (cellType.equalsIgnoreCase(CELLTYPE_FLOAT)) {
605 
606  // has table:value attribute
607  // has text:p tag
608 
609  // Determine the number of decimal places StarCalc
610  // is displaying for this floating point output.
613  Node tableValueNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_VALUE);
614  fmt.setValue(tableValueNode.getNodeValue());
615 
616 
617  } else if (cellType.equalsIgnoreCase(CELLTYPE_TIME)) {
618 
619  // has table:time-value attribute
620  // has text:p tag - which is the value we convert
621 
623  Node tableTimeNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_TIME_VALUE);
624  fmt.setValue(tableTimeNode.getNodeValue());
625 
626  } else if (cellType.equalsIgnoreCase(CELLTYPE_DATE)) {
627 
628  // has table:date-value attribute
629  // has text:p tag - which is the value we convert
630 
632  Node tableDateNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_DATE_VALUE);
633  fmt.setValue(tableDateNode.getNodeValue());
634 
635  } else if (cellType.equalsIgnoreCase(CELLTYPE_CURRENCY)) {
636 
637  // has table:currency
638  // has table:value attribute
639  // has text:p tag
640 
643  Node tableValueNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_VALUE);
644  fmt.setValue(tableValueNode.getNodeValue());
645 
646  } else if (cellType.equalsIgnoreCase(CELLTYPE_BOOLEAN)) {
647 
648  // has table:boolean-value attribute
649  // has text:p tag - which is the value we convert
650 
652  Node tableBooleanNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_BOOLEAN_VALUE);
653  fmt.setValue(tableBooleanNode.getNodeValue());
654 
655  } else if (cellType.equalsIgnoreCase(CELLTYPE_PERCENT)) {
656 
657  // has table:value attribute
658  // has text:p tag
659 
662  Node tableValueNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_VALUE);
663  fmt.setValue(tableValueNode.getNodeValue());
664 
665  } else {
666 
667  Debug.log(Debug.TRACE,"No defined value type" + cellType);
668  // Should never get here
669 
670  }
671  }
672 
673  Node tableFormulaNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_FORMULA);
674 
675  if(tableFormulaNode != null)
676  {
677  if(tableValueTypeNode == null) { // If there is no value-type Node we must assume string-value
679  Node tableStringValueNode = cellAtt.getNamedItem(ATTRIBUTE_TABLE_STRING_VALUE);
680  fmt.setValue(tableStringValueNode.getNodeValue());
681  }
682  String cellFormula = tableFormulaNode.getNodeValue();
683  addCell(cellFormula);
684  } else {
685 
686  // Text node, Date node, or Time node
687 
689  "TextNode, DateNode, TimeNode or BooleanNode\n");
690  // This handles the case where we have style information but no content
691  if (node.hasChildNodes()) {
692  NodeList childList = node.getChildNodes();
693  int len = childList.getLength();
694 
695  for (int i = 0; i < len; i++) {
696  Node child = childList.item(i);
697  if (child.getNodeType() == Node.ELEMENT_NODE) {
698  String childName = child.getNodeName();
699  if (childName.equals(TAG_PARAGRAPH)) {
700  traverseParagraph(child);
701  }
702  }
703  }
704  } else if(!fmt.isDefault()) {
705  addCell("");
706  }
707  }
708 
709  // Increase the column counter by the number of times the
710  // last cell was repeated.
711  colID += colsRepeated;
712 
713  // Re-initialize the number of columns repeated before processing
714  // the next cell data.
715  colsRepeated = 1;
716 
717  }
718 
726  protected void traverseParagraph(Node node) throws IOException {
727 
728  NamedNodeMap cellAtt = node.getAttributes();
729 
730  int debug_i=0;
731  Node debug_attrib = null;
732  if (cellAtt == null || cellAtt.item(0) == null) {
733  Debug.log(Debug.INFO, "No Paragraph Attributes\n");
734  } else {
735  while ((debug_attrib = cellAtt.item(debug_i++)) != null) {
736  Debug.log(Debug.INFO, "Paragraph Attribute " + debug_i +
737  ": " + debug_attrib.getNodeName() + " : " +
738  debug_attrib.getNodeValue() + "\n");
739  }
740  }
741 
742  if (node.hasChildNodes()) {
743 
744  NodeList nodeList = node.getChildNodes();
745 
746  int len = nodeList.getLength();
747 
748  StringBuffer buffer = new StringBuffer();
749 
750  for (int i = 0; i < len; i++) {
751 
752  Node child = nodeList.item(i);
753 
754  // TODO: need to handle space/tabs/newline nodes later
755  short nodeType = child.getNodeType();
756 
757  switch (nodeType) {
758 
759  case Node.TEXT_NODE:
760  buffer.append(child.getNodeValue());
761  break;
762 
763  case Node.ENTITY_REFERENCE_NODE:
764 
765  NodeList nodeList2 = child.getChildNodes();
766  int len2 = nodeList2.getLength();
767 
768  for (int j = 0; j < len2; j++) {
769  Node child2 = nodeList2.item(j);
770 
771  if (child2.getNodeType() == Node.TEXT_NODE) {
772  buffer.append(child2.getNodeValue());
773  }
774  }
775 
776  break;
777  }
778  }
779 
780  String s = buffer.toString();
781  addCell(s);
782 
783  }
784  }
785 
798  protected void addCell(String cellValue) throws IOException {
799 
800  int col = colID;
801  int row = rowID;
802 
803  for (int i = 0; i < rowsRepeated; i++) {
804 
805  // Log the columns when there are rowsRepeated.
806  if (i > 0) {
807  Debug.log(Debug.TRACE, "</TR>");
808  Debug.log(Debug.TRACE, "<TR>");
809  }
810 
811  col = colID;
812 
813  for (int j = 0; j < colsRepeated; j++) {
814 
815  Debug.log(Debug.TRACE, "<TD>");
816 
817  // Add the cell data to the encoded spreadsheet document
818  encoder.addCell(row, col, fmt, cellValue);
819 
820  Debug.log(Debug.TRACE, cellValue);
821  Debug.log(Debug.TRACE, "</TD>");
822 
823  col++;
824  }
825 
826  row++;
827 
828  }
829 
830  }
831 
844  protected int getDecimalPlaces(Node node) {
845 
846  int decimals = 0;
847  Element element = null;
848 
849  // cast org.w3c.dom.Node to org.w3c.dom.Element
850  if (node instanceof Element) {
851  element = (Element) node;
852  } else {
853  return decimals;
854  }
855 
856  // Traverse to the text:p element, there should only be one.
857  NodeList list = element.getElementsByTagName(TAG_PARAGRAPH);
858 
859  if (list.getLength() != 1) {
860  return decimals;
861  }
862 
863  Node paragraph = list.item(0);
864  if (paragraph.hasChildNodes()) {
865 
866  NodeList nodeList = paragraph.getChildNodes();
867  int len = nodeList.getLength();
868  for (int j = 0; j < len; j++) {
869 
870  Node child = nodeList.item(j);
871  if (child.getNodeType() == Node.TEXT_NODE) {
872 
873  String s = child.getNodeValue();
874  int k = s.lastIndexOf('.');
875  if (k > 0) {
876  s = s.substring(k+1);
877  decimals = s.length();
878  }
879  }
880  }
881  }
882 
883  return decimals;
884  }
885 }
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.
void traverseTableRow(Node node)
This method traverses the table:table-row element.
static final int INFO
Informational messages.
Definition: Debug.java:42
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.
void traverseNamedExpressions(Node node)
This method traverses the table:table element.
Provides general purpose utilities.
void setValue(String newValue)
In the case of formula the contents are set as the formula string and the value of the formula is a f...
Definition: Format.java:210
void setSize(int dimension)
Set the height (for rows) or width (for columns).
abstract void setNameDefinition(NameDefinition nd)
Set the name definition of this spreadsheet.
static void log(int flag, String msg)
Log message based on the flag type.
Definition: Debug.java:205
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...
This interface contains constants for StarOffice XML tags, attributes (StarCalc cell types...
void setRepeated(int repeated)
Set the repeat count for this item.
String ATTRIBUTE_TABLE_STRING_VALUE
Attribute tag for table:string-value of element table:table-cell.
void setCategory(String newCategory)
Set the formatting category of this object, ie number, date, currency.
Definition: Format.java:180
String ATTRIBUTE_TABLE_TIME_VALUE
Attribute tag for table:time-value of element table:table-cell.
String TAG_TABLE_COLUMN
Element tag for table:table-column.
const char * tableName
Style lookup(String name, String family, String parent, Class<?> styleClass)
Return the first.
This is a class to define a Name Definition structure.
static final int TRACE
Trace messages.
Definition: Debug.java:46
String ATTRIBUTE_DEFAULT_CELL_STYLE
Attribute tag for table:default-cell-style-name of element table:table-column.
Interface defining constants for Sxc attributes.
ArrayList< ColumnRowInfo > ColumnRowList
An array of column widths of the current worksheet.
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
void traverseSettings(Node node)
This method traverses office:settings
void add(Node node, String families[], Class<?> classes[], Class<?> defaultClass, boolean alwaysCreateDefault)
Parse the.
boolean isDefault()
Tests if the current.
Definition: Format.java:375
String TAG_TABLE_SCENARIO
Element tag for table:scenario.
int i
void traverseParagraph(Node node)
This method traverses the text:p element.
abstract void createWorksheet(String sheetName)
Create a new WorkSheet within the WorkBook.
void loadStyles(SxcDocument sxcDoc)
Handles the loading of defined styles from the style.xml file as well as automatic styles from the co...
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 void addCell(int row, int column, Format fmt, String cellContents)
Add a cell to the current WorkSheet.
String TAG_OFFICE_AUTOMATIC_STYLES
Element tag for office:automatic-styles.
tuple index
String COLUMN_STYLE_FAMILY
Family name for column styles.
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.
void traverseCell(Node node)
This method traverses a table:table-cell element.
Class containing static utility methods for handling XML trees.
Definition: XmlUtil.java:30
abstract void setColumnRows(ArrayList< ColumnRowInfo > columnRows)
Set the width of the columns in the WorkBook.
void traverseTableColumn(Node node)
This method traverses the table:table-column
This is a class to define a table-column structure.
String CELLTYPE_FLOAT
The cell contains data of type float.
String ROW_STYLE_FAMILY
Family name for row styles.
void traverseBody(Node node)
This method traverses office:body
void setDecimalPlaces(int precision)
Set the precision of the number to be displayed.
Definition: Format.java:237
abstract ConvertData serialize()
Method to convert a DOM.
String TAG_NAMED_EXPRESSIONS
Element tag for table:named-expression.
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.
void addCell(String cellValue)
This method will take the input cell value and add it to the spreadsheet.
int getRowHeight()
Returns the height of this row.
Definition: RowStyle.java:107
String CELLTYPE_PERCENT
The cell contains data of type percent.
int getColWidth()
Returns the width of this column.
String CELLTYPE_TIME
The cell contains data of type time.
Provides interfaces for converting between two.
Definition: Convert.java:19
static String getNodeInfo(Node node)
Returns the name and type of an XML DOM.
Definition: XmlUtil.java:120
String TAG_OFFICE_STYLES
Element tag for office:styles.
int rowsRepeated
The number of times the current row is repeated.
This class is used for logging debug messages.
Definition: Debug.java:39
void traverseTable(Node node)
This method traverses the table:table element.
int getRepeated()
Get the repeat count for this item.
int getDecimalPlaces(Node node)
This method takes a table:table-cell
abstract void addSettings(BookSettings s)
Adds settings to the WorkBook.
StyleCatalog styleCat
The number of times the current column is repeated.
This is an interface used by the DiffAlgorithm and MergeAlgorithm to access a.
Definition: Iterator.java:27
int colsRepeated
The number of times the current column is repeated.
This class is an implementation of.
String CELLTYPE_CURRENCY
The cell contains data of type currency.