trunk/odfdom/src/main/java/org/odftoolkit/odfdom/doc/table/OdfTableColumn.java - odftoolkit - Git at Google

 /************************************************************************
 *
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you under the Apache License, Version 2.0 (the
 *  "License"); you may not use this file except in compliance
 *  with the License.  You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing,
 *  software distributed under the License is distributed on an
 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 *  specific language governing permissions and limitations
 *  under the License.
 *
 ************************************************************************/
 package org.odftoolkit.odfdom.doc.table;

 import java.util.logging.Level;
 import java.util.logging.Logger;
 import javax.xml.xpath.XPath;

 import javax.xml.xpath.XPathConstants;
 import javax.xml.xpath.XPathExpressionException;

 import org.odftoolkit.odfdom.pkg.OdfFileDom;
 import org.odftoolkit.odfdom.pkg.OdfName;
 import org.odftoolkit.odfdom.pkg.OdfXMLFactory;
 import org.odftoolkit.odfdom.doc.OdfDocument;
 import org.odftoolkit.odfdom.dom.OdfDocumentNamespace;
 import org.odftoolkit.odfdom.dom.element.table.TableTableColumnElement;
 import org.odftoolkit.odfdom.dom.element.table.TableTableColumnGroupElement;
 import org.odftoolkit.odfdom.dom.element.table.TableTableColumnsElement;
 import org.odftoolkit.odfdom.dom.element.table.TableTableElement;
 import org.odftoolkit.odfdom.dom.element.table.TableTableHeaderColumnsElement;
 import org.odftoolkit.odfdom.dom.style.OdfStyleFamily;
 import org.odftoolkit.odfdom.dom.style.props.OdfTableColumnProperties;
 import org.odftoolkit.odfdom.incubator.doc.style.OdfStyle;
 import org.odftoolkit.odfdom.type.PositiveLength;
 import org.odftoolkit.odfdom.type.Length.Unit;
 import org.w3c.dom.Node;

 /**
  * OdfTableColumn represents table column feature in ODF document.
  * <p>
  * OdfTableColumn provides methods to get table cells that belong to this table column.
  *
  * @deprecated As of release 0.8.8, replaced by {@link org.odftoolkit.simple.table.Column} in Simple API.
  */
 public class OdfTableColumn {

 	TableTableColumnElement maColumnElement;
 	int mnRepeatedIndex;
 	private static final String DEFAULT_WIDTH = "0in";
 	private OdfDocument mDocument;

 	/**
 	 * Construct the <code>OdfTableColumn</code> feature.
 	 *
 	 * @param odfElement
 	 * 					the element that can construct this table column
 	 * @param repeatedIndex
 	 * 					the index in the repeated columns
 	 */
 	OdfTableColumn(TableTableColumnElement colElement, int repeatedIndex) {
 		maColumnElement = colElement;
 		mnRepeatedIndex = repeatedIndex;
 		mDocument = (OdfDocument) ((OdfFileDom) maColumnElement.getOwnerDocument()).getDocument();
 	}

 	/**
 	 * Get the <code>OdfTableColumn</code> instance from the <code>TableTableColumnElement</code> instance.
 	 * <p>
 	 * Each <code>TableTableColumnElement</code> instance has a one-to-one relationship to the a <code>OdfTableColumn</code> instance.
 	 *
 	 * @param colElement	the column element that need to get the corresponding <code>OdfTableColumn</code> instance
 	 * @return the <code>OdfTableColumn</code> instance represent the specified column element
 	 */
 	public static OdfTableColumn getInstance(TableTableColumnElement colElement) {
 		TableTableElement tableElement = null;
 		Node node = colElement.getParentNode();
 		while (node != null) {
 			if (node instanceof TableTableElement) {
 				tableElement = (TableTableElement) node;
 			}
 			node = node.getParentNode();
 		}
 		OdfTable table = null;
 		if (tableElement != null) {
 			table = OdfTable.getInstance(tableElement);
 		} else {
 			throw new IllegalArgumentException("the colElement is not in the table dom tree");
 		}

 		OdfTableColumn column = table.getColumnInstance(colElement, 0);
 		if (column.getColumnsRepeatedNumber() > 1) {
 			Logger.getLogger(OdfTableColumn.class.getName()).log(Level.WARNING, "the column has the repeated column number, and puzzled about get which repeated index of the column,"
 					+ "here just return the first column of the repeated columns.");
 		}
 		return column;
 	}

 	/**
 	 * Get the <code>TableTableElement</code> who contains this cell.
 	 * @return the table that contains the cell.
 	 */
 	private TableTableElement getTableElement() {
 		Node node = maColumnElement.getParentNode();
 		while (node != null) {
 			if (node instanceof TableTableElement) {
 				return (TableTableElement) node;
 			}
 			node = node.getParentNode();
 		}
 		return null;
 	}

 	/**
 	 * Get owner table of the current column.
 	 *
 	 * @return
 	 * 			the parent table of this column
 	 */
 	public OdfTable getTable() {
 		TableTableElement tableElement = getTableElement();
 		if (tableElement != null) {
 			return OdfTable.getInstance(tableElement);
 		}
 		return null;
 	}

 	/**
 	 * Get the width of the column (in Millimeter).
 	 *
 	 * @return the width of the current column (in Millimeter).
 	 */
 	public long getWidth() {
 		String sWidth = maColumnElement.getProperty(OdfTableColumnProperties.ColumnWidth);
 		if (sWidth == null) {
 			sWidth = DEFAULT_WIDTH;
 		}
 		return PositiveLength.parseLong(sWidth, Unit.MILLIMETER);
 	}

 	/**
 	 * Set the width of the column (in Millimeter).
 	 * @param width
 	 * 				the width that will be set to the column (in Millimeter).
 	 */
 	public void setWidth(long width) {
 		String sWidthMM = String.valueOf(width) + Unit.MILLIMETER.abbr();
 		String sWidthIN = PositiveLength.mapToUnit(sWidthMM, Unit.INCH);

 		splitRepeatedColumns();
 		maColumnElement.setProperty(OdfTableColumnProperties.ColumnWidth, sWidthIN);

 		//check if need set relative width
 		int index = getColumnIndex();
 		if (index >= 1) {
 			index = index - 1;
 		} else {
 			index = index + 1;
 		}
 		OdfTableColumn column = null;
 		if (index < getTable().getColumnCount()) {
 			column = getTable().getColumnByIndex(index);
 		}
 		if (column != null) {
 			long prevColumnRelWidth = column.getRelativeWidth();
 			if (prevColumnRelWidth != 0) {
 				long prevColumnWidth = column.getWidth();
 				setRelativeWidth(prevColumnRelWidth / prevColumnWidth * width);
 			}
 		}
 	}

 	//if one of the repeated column want to change something
 	//then this repeated column have to split to repeated number columns
 	//the maColumnElement should also be updated according to the original index in the repeated column
 	void splitRepeatedColumns() {
 		OdfTable table = getTable();
 		TableTableElement tableEle = table.getOdfElement();
 		int repeateNum = getColumnsRepeatedNumber();
 		if (repeateNum > 1) {
 			//change this repeated column to several single columns
 			TableTableColumnElement ownerColumnElement = null;
 			int repeatedColumnIndex = mnRepeatedIndex;
 			Node refElement = maColumnElement;
 			maColumnElement.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
 			String originalWidth = maColumnElement.getProperty(OdfTableColumnProperties.ColumnWidth);
 			String originalRelWidth = maColumnElement.getProperty(OdfTableColumnProperties.RelColumnWidth);
 			for (int i = repeateNum - 1; i >= 0; i--) {
 				TableTableColumnElement newColumn = (TableTableColumnElement) OdfXMLFactory.newOdfElement((OdfFileDom) maColumnElement.getOwnerDocument(),
 						OdfName.newName(OdfDocumentNamespace.TABLE, "table-column"));
 				if (originalWidth != null && originalWidth.length() > 0) {
 					newColumn.setProperty(OdfTableColumnProperties.ColumnWidth, originalWidth);
 				}
 				if (originalRelWidth != null && originalRelWidth.length() > 0) {
 					newColumn.setProperty(OdfTableColumnProperties.RelColumnWidth, originalRelWidth);
 				}
 				tableEle.insertBefore(newColumn, refElement);
 				refElement = newColumn;
 				if (repeatedColumnIndex == i) {
 					ownerColumnElement = newColumn;
 				} else {
 					table.updateColumnRepository(maColumnElement, i, newColumn, 0);
 				}
 			}
 			//remove this column element
 			tableEle.removeChild(maColumnElement);

 			if (ownerColumnElement != null) {
 				table.updateColumnRepository(maColumnElement, mnRepeatedIndex, ownerColumnElement, 0);
 			}
 		}
 	}

 	private long getRelativeWidth() {
 		String sRelWidth = maColumnElement.getProperty(OdfTableColumnProperties.RelColumnWidth);
 		if (sRelWidth != null) {
 			if (sRelWidth.contains("*")) {
 				Long value = Long.valueOf(sRelWidth.substring(0, sRelWidth.indexOf("*")));
 				return value.longValue();
 			}
 		}
 		return 0;
 	}

 	private void setRelativeWidth(long relWidth) {
 		maColumnElement.setProperty(OdfTableColumnProperties.RelColumnWidth, String.valueOf(relWidth) + "*");
 	}

 	/**
 	 * Returns if the column always keeps its optimal width.
 	 * @return
 	 * 			true if the column always keeps its optimal width;
 	 * 			vice versa
 	 */
 	public boolean isOptimalWidth() {
 		return Boolean.parseBoolean(maColumnElement.getProperty(OdfTableColumnProperties.UseOptimalColumnWidth));
 	}

 	/**
 	 * Set if the column always keeps its optimal width.
 	 *
 	 * @param isUseOptimalWidth
 	 * 					the flag that indicate column should keep its optimal width or not
 	 */
 	public void setUseOptimalWidth(boolean isUseOptimalWidth) {
 		maColumnElement.setProperty(OdfTableColumnProperties.UseOptimalColumnWidth, String.valueOf(isUseOptimalWidth));
 	}

 	/**
 	 * Return an instance of <code>TableTableColumnElement</code> which represents this feature.
 	 *
 	 * @return an instance of <code>TableTableColumnElement</code>
 	 */
 	public TableTableColumnElement getOdfElement() {
 		return maColumnElement;
 	}

 	/**
 	 * Get the count of cells in this column.
 	 *
 	 * @return 	the cells count in the current column
 	 */
 	public int getCellCount() {
 		return getTable().getRowCount();
 	}

 	/**
 	 * Get a cell with a specific index. The table will be automatically
 	 * expanded, when the given index is outside of the original table.
 	 *
 	 * @param index
 	 *            the cell index in this column
 	 * @return the cell object in the given cell index
 	 */
 	public OdfTableCell getCellByIndex(int index) {
 		return getTable().getCellByPosition(getColumnIndex(), index);
 	}

 	/**
 	 * Get the previous column of the current column.
 	 *
 	 * @return the previous column before this column in the owner table
 	 */
 	public OdfTableColumn getPreviousColumn() {
 		OdfTable table = getTable();
 		//the column has repeated column number > 1
 		if (maColumnElement.getTableNumberColumnsRepeatedAttribute().intValue() > 1) {
 			if (mnRepeatedIndex > 0) {
 				return table.getColumnInstance(maColumnElement, mnRepeatedIndex - 1);
 			}
 		}
 		//the column has repeated column number > 1 && the index is 0
 		//or the column has repeated column num = 1
 		Node aPrevNode = maColumnElement.getPreviousSibling();
 		Node aCurNode = maColumnElement;
 		while (true) {
 			if (aPrevNode == null) {
 				//does not have previous sibling, then get the parent
 				//because aCurNode might be the child element of table-header-columns, table-columns, table-column-group
 				Node parentNode = aCurNode.getParentNode();
 				//if the parent is table, then it means that this column is the first column in this table
 				//it has no previous column
 				if (parentNode instanceof TableTableElement) {
 					return null;
 				}
 				aPrevNode = parentNode.getPreviousSibling();
 			}
 			//else the parent node might be table-header-columns, table-columns, table-column-group
 			if (aPrevNode != null) {
 				try {
 					if (aPrevNode instanceof TableTableColumnElement) {
 						return table.getColumnInstance((TableTableColumnElement) aPrevNode, ((TableTableColumnElement) aPrevNode).getTableNumberColumnsRepeatedAttribute().intValue() - 1);
 					} else if (aPrevNode instanceof TableTableColumnsElement
 							|| aPrevNode instanceof TableTableHeaderColumnsElement
 							|| aPrevNode instanceof TableTableColumnGroupElement) {
 						XPath xpath = ((OdfFileDom) maColumnElement.getOwnerDocument()).getXPath();
 						TableTableColumnElement lastCol = (TableTableColumnElement) xpath.evaluate("//table:table-column[last()]", aPrevNode, XPathConstants.NODE);
 						if (lastCol != null) {
 							return table.getColumnInstance(lastCol, lastCol.getTableNumberColumnsRepeatedAttribute().intValue() - 1);
 						}
 					} else {
 						aCurNode = aPrevNode;
 						aPrevNode = aPrevNode.getPreviousSibling();
 					}
 				} catch (XPathExpressionException e) {
 					Logger.getLogger(OdfTableColumn.class.getName()).log(Level.SEVERE, e.getMessage(), e);
 				}
 			}
 		}
 	}

 	/**
 	 * Get the next column of the current column.
 	 *
 	 * @return the next column after this column in the owner table
 	 */
 	public OdfTableColumn getNextColumn() {
 		OdfTable table = getTable();
 		//the column has repeated column number > 1
 		if (getColumnsRepeatedNumber() > 1) {
 			if (mnRepeatedIndex < (getColumnsRepeatedNumber() - 1)) {
 				return table.getColumnInstance(maColumnElement, mnRepeatedIndex + 1);
 			}
 		}
 		Node aNextNode = maColumnElement.getNextSibling();
 		Node aCurNode = maColumnElement;
 		while (true) {
 			if (aNextNode == null) {
 				//does not have next sibling, then get the parent
 				//because aCurNode might be the child element of table-header-columns, table-columns, table-column-group
 				Node parentNode = aCurNode.getParentNode();
 				//if the parent is table, then it means that this column is the last column in this table
 				//it has no next column
 				if (parentNode instanceof TableTableElement) {
 					return null;
 				}
 				aNextNode = parentNode.getNextSibling();
 			}
 			//else the parent node might be table-header-columns, table-columns, table-column-group
 			if (aNextNode != null) {
 				try {
 					if (aNextNode instanceof TableTableColumnElement) {
 						return table.getColumnInstance((TableTableColumnElement) aNextNode, 0);
 					} else if (aNextNode instanceof TableTableColumnsElement
 							|| aNextNode instanceof TableTableHeaderColumnsElement
 							|| aNextNode instanceof TableTableColumnGroupElement) {
 						XPath xpath = ((OdfFileDom) maColumnElement.getOwnerDocument()).getXPath();
 						TableTableColumnElement firstCol = (TableTableColumnElement) xpath.evaluate("//table:table-column[first()]", aNextNode, XPathConstants.NODE);
 						if (firstCol != null) {
 							return table.getColumnInstance(firstCol, 0);
 						}
 					} else {
 						aCurNode = aNextNode;
 						aNextNode = aNextNode.getNextSibling();
 					}
 				} catch (XPathExpressionException e) {
 					Logger.getLogger(OdfTableColumn.class.getName()).log(Level.SEVERE, e.getMessage(), e);
 				}
 			}
 		}
 	}

 	/**
 	 * Get the index of this column in the owner table.
 	 *
 	 * @return the index of the column
 	 */
 	public int getColumnIndex() {
 		int result = 0;
 		OdfTable table = getTable();
 		TableTableColumnElement columnEle;
 		TableTableElement mTableElement = table.getOdfElement();
 		for (Node n : new DomNodeList(mTableElement.getChildNodes())) {
 			if (n instanceof TableTableHeaderColumnsElement) {
 				TableTableHeaderColumnsElement headers = (TableTableHeaderColumnsElement) n;
 				for (Node m : new DomNodeList(headers.getChildNodes())) {
 					if (m instanceof TableTableColumnElement) {
 						columnEle = (TableTableColumnElement) m;
 						if (columnEle == getOdfElement()) {
 							return result + mnRepeatedIndex;
 						}
 						if (columnEle.getTableNumberColumnsRepeatedAttribute() == null) {
 							result += 1;
 						} else {
 							result += columnEle.getTableNumberColumnsRepeatedAttribute();
 						}
 					}
 				}
 			}
 			if (n instanceof TableTableColumnElement) {
 				columnEle = (TableTableColumnElement) n;
 				if (columnEle == getOdfElement()) {
 					break;
 				}
 				if (columnEle.getTableNumberColumnsRepeatedAttribute() == null) {
 					result += 1;
 				} else {
 					result += columnEle.getTableNumberColumnsRepeatedAttribute();
 				}
 			}
 		}
 		return result + mnRepeatedIndex;
 	}

 	/**
 	 * Set the default cell style to this column.
 	 * <p>
 	 * The style should already exist in this document.
 	 * <p>
 	 * This method is not recommended for text document cases.
 	 * These is a style assigned to each cell in tables under text documents.
 	 * So setting the default cell style to a column may not work.
 	 *
 	 * @param style
 	 * 			the cell style of the document
 	 */
 	public void setDefaultCellStyle(OdfStyle style) {
 		splitRepeatedColumns();
 		OdfStyle defaultStyle = getDefaultCellStyle();
 		if (defaultStyle != null) {
 			defaultStyle.removeStyleUser(maColumnElement);
 		}

 		if (style != null) {
 			style.addStyleUser(maColumnElement);
 			maColumnElement.setTableDefaultCellStyleNameAttribute(
 					style.getStyleNameAttribute());
 		}
 	}

 	/**
 	 * Get the default cell style of this column.
 	 * @return the default cell style of this column
 	 */
 	public OdfStyle getDefaultCellStyle() {
 		String styleName = maColumnElement.getTableDefaultCellStyleNameAttribute();
 		OdfStyle style = maColumnElement.getAutomaticStyles().getStyle(
 				styleName, OdfStyleFamily.TableCell);

 		if (style == null) {
 			style = mDocument.getDocumentStyles().getStyle(styleName, OdfStyleFamily.TableCell);
 		}
 		return style;
 	}

 	//note: we have to use this method to modify the column repeated number
 	//in order to update mnRepeatedIndex of the each column
 	void setColumnsRepeatedNumber(int num) {
 		//update the mnRepeatedIndex for the ever repeated column
 		maColumnElement.setTableNumberColumnsRepeatedAttribute(Integer.valueOf(num));
 	}

 	int getColumnsRepeatedNumber() {
 		Integer count = maColumnElement.getTableNumberColumnsRepeatedAttribute();
 		if (count == null) {
 			return 1;
 		} else {
 			return count.intValue();
 		}
 	}
 }
	/************************************************************************
	*
	* Licensed to the Apache Software Foundation (ASF) under one
	* or more contributor license agreements. See the NOTICE file
	* distributed with this work for additional information
	* regarding copyright ownership. The ASF licenses this file
	* to you under the Apache License, Version 2.0 (the
	* "License"); you may not use this file except in compliance
	* with the License. You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing,
	* software distributed under the License is distributed on an
	* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	* KIND, either express or implied. See the License for the
	* specific language governing permissions and limitations
	* under the License.
	*
	************************************************************************/
	package org.odftoolkit.odfdom.doc.table;

	import java.util.logging.Level;
	import java.util.logging.Logger;
	import javax.xml.xpath.XPath;

	import javax.xml.xpath.XPathConstants;
	import javax.xml.xpath.XPathExpressionException;

	import org.odftoolkit.odfdom.pkg.OdfFileDom;
	import org.odftoolkit.odfdom.pkg.OdfName;
	import org.odftoolkit.odfdom.pkg.OdfXMLFactory;
	import org.odftoolkit.odfdom.doc.OdfDocument;
	import org.odftoolkit.odfdom.dom.OdfDocumentNamespace;
	import org.odftoolkit.odfdom.dom.element.table.TableTableColumnElement;
	import org.odftoolkit.odfdom.dom.element.table.TableTableColumnGroupElement;
	import org.odftoolkit.odfdom.dom.element.table.TableTableColumnsElement;
	import org.odftoolkit.odfdom.dom.element.table.TableTableElement;
	import org.odftoolkit.odfdom.dom.element.table.TableTableHeaderColumnsElement;
	import org.odftoolkit.odfdom.dom.style.OdfStyleFamily;
	import org.odftoolkit.odfdom.dom.style.props.OdfTableColumnProperties;
	import org.odftoolkit.odfdom.incubator.doc.style.OdfStyle;
	import org.odftoolkit.odfdom.type.PositiveLength;
	import org.odftoolkit.odfdom.type.Length.Unit;
	import org.w3c.dom.Node;

	/**
	* OdfTableColumn represents table column feature in ODF document.
	* <p>
	* OdfTableColumn provides methods to get table cells that belong to this table column.
	*
	* @deprecated As of release 0.8.8, replaced by {@link org.odftoolkit.simple.table.Column} in Simple API.
	*/
	public class OdfTableColumn {

	TableTableColumnElement maColumnElement;
	int mnRepeatedIndex;
	private static final String DEFAULT_WIDTH = "0in";
	private OdfDocument mDocument;

	/**
	* Construct the <code>OdfTableColumn</code> feature.
	*
	* @param odfElement
	* the element that can construct this table column
	* @param repeatedIndex
	* the index in the repeated columns
	*/
	OdfTableColumn(TableTableColumnElement colElement, int repeatedIndex) {
	maColumnElement = colElement;
	mnRepeatedIndex = repeatedIndex;
	mDocument = (OdfDocument) ((OdfFileDom) maColumnElement.getOwnerDocument()).getDocument();
	}

	/**
	* Get the <code>OdfTableColumn</code> instance from the <code>TableTableColumnElement</code> instance.
	* <p>
	* Each <code>TableTableColumnElement</code> instance has a one-to-one relationship to the a <code>OdfTableColumn</code> instance.
	*
	* @param colElement the column element that need to get the corresponding <code>OdfTableColumn</code> instance
	* @return the <code>OdfTableColumn</code> instance represent the specified column element
	*/
	public static OdfTableColumn getInstance(TableTableColumnElement colElement) {
	TableTableElement tableElement = null;
	Node node = colElement.getParentNode();
	while (node != null) {
	if (node instanceof TableTableElement) {
	tableElement = (TableTableElement) node;
	}
	node = node.getParentNode();
	}
	OdfTable table = null;
	if (tableElement != null) {
	table = OdfTable.getInstance(tableElement);
	} else {
	throw new IllegalArgumentException("the colElement is not in the table dom tree");
	}

	OdfTableColumn column = table.getColumnInstance(colElement, 0);
	if (column.getColumnsRepeatedNumber() > 1) {
	Logger.getLogger(OdfTableColumn.class.getName()).log(Level.WARNING, "the column has the repeated column number, and puzzled about get which repeated index of the column,"
	+ "here just return the first column of the repeated columns.");
	}
	return column;
	}

	/**
	* Get the <code>TableTableElement</code> who contains this cell.
	* @return the table that contains the cell.
	*/
	private TableTableElement getTableElement() {
	Node node = maColumnElement.getParentNode();
	while (node != null) {
	if (node instanceof TableTableElement) {
	return (TableTableElement) node;
	}
	node = node.getParentNode();
	}
	return null;
	}

	/**
	* Get owner table of the current column.
	*
	* @return
	* the parent table of this column
	*/
	public OdfTable getTable() {
	TableTableElement tableElement = getTableElement();
	if (tableElement != null) {
	return OdfTable.getInstance(tableElement);
	}
	return null;
	}

	/**
	* Get the width of the column (in Millimeter).
	*
	* @return the width of the current column (in Millimeter).
	*/
	public long getWidth() {
	String sWidth = maColumnElement.getProperty(OdfTableColumnProperties.ColumnWidth);
	if (sWidth == null) {
	sWidth = DEFAULT_WIDTH;
	}
	return PositiveLength.parseLong(sWidth, Unit.MILLIMETER);
	}

	/**
	* Set the width of the column (in Millimeter).
	* @param width
	* the width that will be set to the column (in Millimeter).
	*/
	public void setWidth(long width) {
	String sWidthMM = String.valueOf(width) + Unit.MILLIMETER.abbr();
	String sWidthIN = PositiveLength.mapToUnit(sWidthMM, Unit.INCH);

	splitRepeatedColumns();
	maColumnElement.setProperty(OdfTableColumnProperties.ColumnWidth, sWidthIN);

	//check if need set relative width
	int index = getColumnIndex();
	if (index >= 1) {
	index = index - 1;
	} else {
	index = index + 1;
	}
	OdfTableColumn column = null;
	if (index < getTable().getColumnCount()) {
	column = getTable().getColumnByIndex(index);
	}
	if (column != null) {
	long prevColumnRelWidth = column.getRelativeWidth();
	if (prevColumnRelWidth != 0) {
	long prevColumnWidth = column.getWidth();
	setRelativeWidth(prevColumnRelWidth / prevColumnWidth * width);
	}
	}
	}

	//if one of the repeated column want to change something
	//then this repeated column have to split to repeated number columns
	//the maColumnElement should also be updated according to the original index in the repeated column
	void splitRepeatedColumns() {
	OdfTable table = getTable();
	TableTableElement tableEle = table.getOdfElement();
	int repeateNum = getColumnsRepeatedNumber();
	if (repeateNum > 1) {
	//change this repeated column to several single columns
	TableTableColumnElement ownerColumnElement = null;
	int repeatedColumnIndex = mnRepeatedIndex;
	Node refElement = maColumnElement;
	maColumnElement.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
	String originalWidth = maColumnElement.getProperty(OdfTableColumnProperties.ColumnWidth);
	String originalRelWidth = maColumnElement.getProperty(OdfTableColumnProperties.RelColumnWidth);
	for (int i = repeateNum - 1; i >= 0; i--) {
	TableTableColumnElement newColumn = (TableTableColumnElement) OdfXMLFactory.newOdfElement((OdfFileDom) maColumnElement.getOwnerDocument(),
	OdfName.newName(OdfDocumentNamespace.TABLE, "table-column"));
	if (originalWidth != null && originalWidth.length() > 0) {
	newColumn.setProperty(OdfTableColumnProperties.ColumnWidth, originalWidth);
	}
	if (originalRelWidth != null && originalRelWidth.length() > 0) {
	newColumn.setProperty(OdfTableColumnProperties.RelColumnWidth, originalRelWidth);
	}
	tableEle.insertBefore(newColumn, refElement);
	refElement = newColumn;
	if (repeatedColumnIndex == i) {
	ownerColumnElement = newColumn;
	} else {
	table.updateColumnRepository(maColumnElement, i, newColumn, 0);
	}
	}
	//remove this column element
	tableEle.removeChild(maColumnElement);

	if (ownerColumnElement != null) {
	table.updateColumnRepository(maColumnElement, mnRepeatedIndex, ownerColumnElement, 0);
	}
	}
	}

	private long getRelativeWidth() {
	String sRelWidth = maColumnElement.getProperty(OdfTableColumnProperties.RelColumnWidth);
	if (sRelWidth != null) {
	if (sRelWidth.contains("*")) {
	Long value = Long.valueOf(sRelWidth.substring(0, sRelWidth.indexOf("*")));
	return value.longValue();
	}
	}
	return 0;
	}

	private void setRelativeWidth(long relWidth) {
	maColumnElement.setProperty(OdfTableColumnProperties.RelColumnWidth, String.valueOf(relWidth) + "*");
	}

	/**
	* Returns if the column always keeps its optimal width.
	* @return
	* true if the column always keeps its optimal width;
	* vice versa
	*/
	public boolean isOptimalWidth() {
	return Boolean.parseBoolean(maColumnElement.getProperty(OdfTableColumnProperties.UseOptimalColumnWidth));
	}

	/**
	* Set if the column always keeps its optimal width.
	*
	* @param isUseOptimalWidth
	* the flag that indicate column should keep its optimal width or not
	*/
	public void setUseOptimalWidth(boolean isUseOptimalWidth) {
	maColumnElement.setProperty(OdfTableColumnProperties.UseOptimalColumnWidth, String.valueOf(isUseOptimalWidth));
	}

	/**
	* Return an instance of <code>TableTableColumnElement</code> which represents this feature.
	*
	* @return an instance of <code>TableTableColumnElement</code>
	*/
	public TableTableColumnElement getOdfElement() {
	return maColumnElement;
	}

	/**
	* Get the count of cells in this column.
	*
	* @return the cells count in the current column
	*/
	public int getCellCount() {
	return getTable().getRowCount();
	}

	/**
	* Get a cell with a specific index. The table will be automatically
	* expanded, when the given index is outside of the original table.
	*
	* @param index
	* the cell index in this column
	* @return the cell object in the given cell index
	*/
	public OdfTableCell getCellByIndex(int index) {
	return getTable().getCellByPosition(getColumnIndex(), index);
	}

	/**
	* Get the previous column of the current column.
	*
	* @return the previous column before this column in the owner table
	*/
	public OdfTableColumn getPreviousColumn() {
	OdfTable table = getTable();
	//the column has repeated column number > 1
	if (maColumnElement.getTableNumberColumnsRepeatedAttribute().intValue() > 1) {
	if (mnRepeatedIndex > 0) {
	return table.getColumnInstance(maColumnElement, mnRepeatedIndex - 1);
	}
	}
	//the column has repeated column number > 1 && the index is 0
	//or the column has repeated column num = 1
	Node aPrevNode = maColumnElement.getPreviousSibling();
	Node aCurNode = maColumnElement;
	while (true) {
	if (aPrevNode == null) {
	//does not have previous sibling, then get the parent
	//because aCurNode might be the child element of table-header-columns, table-columns, table-column-group
	Node parentNode = aCurNode.getParentNode();
	//if the parent is table, then it means that this column is the first column in this table
	//it has no previous column
	if (parentNode instanceof TableTableElement) {
	return null;
	}
	aPrevNode = parentNode.getPreviousSibling();
	}
	//else the parent node might be table-header-columns, table-columns, table-column-group
	if (aPrevNode != null) {
	try {
	if (aPrevNode instanceof TableTableColumnElement) {
	return table.getColumnInstance((TableTableColumnElement) aPrevNode, ((TableTableColumnElement) aPrevNode).getTableNumberColumnsRepeatedAttribute().intValue() - 1);
	} else if (aPrevNode instanceof TableTableColumnsElement
	\|\| aPrevNode instanceof TableTableHeaderColumnsElement
	\|\| aPrevNode instanceof TableTableColumnGroupElement) {
	XPath xpath = ((OdfFileDom) maColumnElement.getOwnerDocument()).getXPath();
	TableTableColumnElement lastCol = (TableTableColumnElement) xpath.evaluate("//table:table-column[last()]", aPrevNode, XPathConstants.NODE);
	if (lastCol != null) {
	return table.getColumnInstance(lastCol, lastCol.getTableNumberColumnsRepeatedAttribute().intValue() - 1);
	}
	} else {
	aCurNode = aPrevNode;
	aPrevNode = aPrevNode.getPreviousSibling();
	}
	} catch (XPathExpressionException e) {
	Logger.getLogger(OdfTableColumn.class.getName()).log(Level.SEVERE, e.getMessage(), e);
	}
	}
	}
	}

	/**
	* Get the next column of the current column.
	*
	* @return the next column after this column in the owner table
	*/
	public OdfTableColumn getNextColumn() {
	OdfTable table = getTable();
	//the column has repeated column number > 1
	if (getColumnsRepeatedNumber() > 1) {
	if (mnRepeatedIndex < (getColumnsRepeatedNumber() - 1)) {
	return table.getColumnInstance(maColumnElement, mnRepeatedIndex + 1);
	}
	}
	Node aNextNode = maColumnElement.getNextSibling();
	Node aCurNode = maColumnElement;
	while (true) {
	if (aNextNode == null) {
	//does not have next sibling, then get the parent
	//because aCurNode might be the child element of table-header-columns, table-columns, table-column-group
	Node parentNode = aCurNode.getParentNode();
	//if the parent is table, then it means that this column is the last column in this table
	//it has no next column
	if (parentNode instanceof TableTableElement) {
	return null;
	}
	aNextNode = parentNode.getNextSibling();
	}
	//else the parent node might be table-header-columns, table-columns, table-column-group
	if (aNextNode != null) {
	try {
	if (aNextNode instanceof TableTableColumnElement) {
	return table.getColumnInstance((TableTableColumnElement) aNextNode, 0);
	} else if (aNextNode instanceof TableTableColumnsElement
	\|\| aNextNode instanceof TableTableHeaderColumnsElement
	\|\| aNextNode instanceof TableTableColumnGroupElement) {
	XPath xpath = ((OdfFileDom) maColumnElement.getOwnerDocument()).getXPath();
	TableTableColumnElement firstCol = (TableTableColumnElement) xpath.evaluate("//table:table-column[first()]", aNextNode, XPathConstants.NODE);
	if (firstCol != null) {
	return table.getColumnInstance(firstCol, 0);
	}
	} else {
	aCurNode = aNextNode;
	aNextNode = aNextNode.getNextSibling();
	}
	} catch (XPathExpressionException e) {
	Logger.getLogger(OdfTableColumn.class.getName()).log(Level.SEVERE, e.getMessage(), e);
	}
	}
	}
	}

	/**
	* Get the index of this column in the owner table.
	*
	* @return the index of the column
	*/
	public int getColumnIndex() {
	int result = 0;
	OdfTable table = getTable();
	TableTableColumnElement columnEle;
	TableTableElement mTableElement = table.getOdfElement();
	for (Node n : new DomNodeList(mTableElement.getChildNodes())) {
	if (n instanceof TableTableHeaderColumnsElement) {
	TableTableHeaderColumnsElement headers = (TableTableHeaderColumnsElement) n;
	for (Node m : new DomNodeList(headers.getChildNodes())) {
	if (m instanceof TableTableColumnElement) {
	columnEle = (TableTableColumnElement) m;
	if (columnEle == getOdfElement()) {
	return result + mnRepeatedIndex;
	}
	if (columnEle.getTableNumberColumnsRepeatedAttribute() == null) {
	result += 1;
	} else {
	result += columnEle.getTableNumberColumnsRepeatedAttribute();
	}
	}
	}
	}
	if (n instanceof TableTableColumnElement) {
	columnEle = (TableTableColumnElement) n;
	if (columnEle == getOdfElement()) {
	break;
	}
	if (columnEle.getTableNumberColumnsRepeatedAttribute() == null) {
	result += 1;
	} else {
	result += columnEle.getTableNumberColumnsRepeatedAttribute();
	}
	}
	}
	return result + mnRepeatedIndex;
	}

	/**
	* Set the default cell style to this column.
	* <p>
	* The style should already exist in this document.
	* <p>
	* This method is not recommended for text document cases.
	* These is a style assigned to each cell in tables under text documents.
	* So setting the default cell style to a column may not work.
	*
	* @param style
	* the cell style of the document
	*/
	public void setDefaultCellStyle(OdfStyle style) {
	splitRepeatedColumns();
	OdfStyle defaultStyle = getDefaultCellStyle();
	if (defaultStyle != null) {
	defaultStyle.removeStyleUser(maColumnElement);
	}

	if (style != null) {
	style.addStyleUser(maColumnElement);
	maColumnElement.setTableDefaultCellStyleNameAttribute(
	style.getStyleNameAttribute());
	}
	}

	/**
	* Get the default cell style of this column.
	* @return the default cell style of this column
	*/
	public OdfStyle getDefaultCellStyle() {
	String styleName = maColumnElement.getTableDefaultCellStyleNameAttribute();
	OdfStyle style = maColumnElement.getAutomaticStyles().getStyle(
	styleName, OdfStyleFamily.TableCell);

	if (style == null) {
	style = mDocument.getDocumentStyles().getStyle(styleName, OdfStyleFamily.TableCell);
	}
	return style;
	}

	//note: we have to use this method to modify the column repeated number
	//in order to update mnRepeatedIndex of the each column
	void setColumnsRepeatedNumber(int num) {
	//update the mnRepeatedIndex for the ever repeated column
	maColumnElement.setTableNumberColumnsRepeatedAttribute(Integer.valueOf(num));
	}

	int getColumnsRepeatedNumber() {
	Integer count = maColumnElement.getTableNumberColumnsRepeatedAttribute();
	if (count == null) {
	return 1;
	} else {
	return count.intValue();
	}
	}
	}