Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* 
  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.simple.table;
 
 
 
Column represents table column feature in ODF document.

Column provides methods to get table cells that belong to this table column.

 
 public class Column extends Component {
 
 	private static final String DEFAULT_WIDTH = "0in";
 	private final int DEFAULT_REL_TABLE_WIDTH = 65535;
 	private Document mDocument;

Construct the Column feature.

Parameters:
odfElement the element that can construct this table column
repeatedIndex the index in the repeated columns
 
 	Column(TableTableColumnElement colElementint repeatedIndex) {
 		 = colElement;
 		 = repeatedIndex;
 	}

Get the Column instance from the TableTableColumnElement instance.

Each TableTableColumnElement instance has a one-to-one relationship to the a Column instance.

Parameters:
colElement the column element that need to get the corresponding Column instance
Returns:
the Column instance represent the specified column element
 
 	public static Column getInstance(TableTableColumnElement colElement) {
 		TableTableElement tableElement = null;
 		Node node = colElement.getParentNode();
 		while (node != null) {
 			if (node instanceof TableTableElement) {
 				tableElement = (TableTableElementnode;
 			}
 			node = node.getParentNode();
 		}
 		Table table = null;
 		if (tableElement != null) {
			table = Table.getInstance(tableElement);
else {
			throw new IllegalArgumentException("the colElement is not in the table dom tree");
		}
		Column column = table.getColumnInstance(colElement, 0);
		if (column.getColumnsRepeatedNumber() > 1) {
			Logger.getLogger(Column.class.getName()).log(
					"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 TableTableElement who contains this cell.

Returns:
the table that contains the cell.
		while (node != null) {
			if (node instanceof TableTableElement) {
				return (TableTableElementnode;
			}
			node = node.getParentNode();
		}
		return null;
	}

Get owner table of the current column.

Returns:
the parent table of this column
	public Table getTable() {
		if (tableElement != null) {
			return Table.getInstance(tableElement);
		}
		return null;
	}

Get the width of the column (in Millimeter).

Returns:
the width of the current column (in Millimeter).
	public double getWidth() {
		if (sWidth == null) {
			sWidth = ;
		}
		return PositiveLength.parseDouble(sWidth.) ;
	}

Set the width of the column (in Millimeter).

Parameters:
width the width that will be set to the column (in Millimeter).
	public void setWidth(double width) {
		double roundingFactor = 10000.0;
		//TODO:need refactor to PositiveLength.
		double inValue = Math.round(roundingFactor * width / ..unitInMillimiter()) / roundingFactor;
		String sWidthIN = String.valueOf(inValue) + ..abbr();
		//width before modification
		double columnWidth = getWidth();
		if(columnWidth < 0)	{
			columnWidth = 0;
		}
		Table table = getTable();
		// check if need set relative width
		if (!(table.getOwnerDocument() instanceof SpreadsheetDocument)) {
			int index = getColumnIndex();
			int columnCount = table.getColumnCount();
			if (index == columnCount-1) {
				//if the column to resize is the rightmost
				index = index - 1;
else {
				index = index + 1;
			}
			if (index >= 0) {
				Column column = null;
				if (index < columnCount) {
					column = table.getColumnByIndex(index);
else if (columnCount >= 2) {
					column = table.getColumnByIndex(columnCount - 2);
				}
				double nextColumnWidth = 0;
				if (column != null) {
					nextColumnWidth = column.getWidth();
					setRelativeWidth((long) ( / table.getWidth() * width));
				}
				// total width of two columns
				double columnsWidth = nextColumnWidth + columnWidth;
				// calculates the new width of the next / previous column
				double newWidthNextColumn = columnsWidth - width;
				if (newWidthNextColumn < 0) {
					newWidthNextColumn = 0;
				}
				inValue = Math.round(roundingFactor * newWidthNextColumn / ..unitInMillimiter())
roundingFactor;
				sWidthIN = String.valueOf(inValue) + ..abbr();
				double relWidth = ( / table.getWidth()) * newWidthNextColumn;
				column.setRelativeWidth((long)relWidth);
			}
		}
	}
	// 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
		Table table = getTable();
		TableTableElement tableEle = table.getOdfElement();
		int repeateNum = getColumnsRepeatedNumber();
		if (repeateNum > 1) {
			// change this repeated column to several single columns
			TableTableColumnElement ownerColumnElement = null;
			String columnWidthStr = null;
			long columnWidth = 0;
			int repeatedColumnIndex = ;
			Node refElement = ;
			if (originalWidth != null) {
				columnWidthStr = Length.mapToUnit(originalWidth.);
				columnWidth = PositiveLength.parseLong(columnWidthStr.);
			}
			for (int i = repeateNum - 1; i >= 0; i--) {
								"table-column"));
				if (originalWidth != null && originalWidth.length() > 0) {
				}
				if (originalRelWidth != null && originalRelWidth.length() > 0) {
					long relWidth = (long) (( / table.getWidth()) *	columnWidth);
					newColumn.setProperty(., String.valueOf(relWidth) + "*");
				}
				tableEle.insertBefore(newColumnrefElement);
				refElement = newColumn;
				if (repeatedColumnIndex == i) {
					ownerColumnElement = newColumn;
else {
					table.updateColumnRepository(inewColumn, 0);
				}
			}
			// remove this column element
			if (ownerColumnElement != null) {
				table.updateColumnRepository(ownerColumnElement, 0);
				// update column element.
				 = ownerColumnElement;
			}
		}
	}
//	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) {
		if (relWidth < 40) {
else {
		}
	}

Returns if the column always keeps its optimal width.

Returns:
true if the column always keeps its optimal width; vice versa
	public boolean isOptimalWidth() {
	}

Set if the column always keeps its optimal width.

Parameters:
isUseOptimalWidth the flag that indicate column should keep its optimal width or not
	public void setUseOptimalWidth(boolean isUseOptimalWidth) {
	}

Return an instance of TableTableColumnElement which represents this feature.

Returns:
an instance of TableTableColumnElement
	}

Get the count of cells in this column.

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

Parameters:
index the cell index in this column
Returns:
the cell object in the given cell index
	public Cell getCellByIndex(int index) {
	}

Get the previous column of the current column.

Returns:
the previous column before this column in the owner table
		Table table = getTable();
		// the column has repeated column number > 1
			if ( > 0) {
			}
		}
		// the column has repeated column number > 1 && the index is 0
		// or the column has repeated column num = 1
		Node aCurNode = ;
		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((TableTableColumnElementaPrevNode,
										.intValue() - 1);
else if (aPrevNode instanceof TableTableColumnsElement
							|| aPrevNode instanceof TableTableHeaderColumnsElement
							|| aPrevNode instanceof TableTableColumnGroupElement) {
								"//table:table-column[last()]"aPrevNode.);
						if (lastCol != null) {
									.intValue() - 1);
						}
else {
						aCurNode = aPrevNode;
						aPrevNode = aPrevNode.getPreviousSibling();
					}
catch (XPathExpressionException e) {
					Logger.getLogger(Column.class.getName()).log(.e.getMessage(), e);
				}
			}
		}
	}

Get the next column of the current column.

Returns:
the next column after this column in the owner table
	public Column getNextColumn() {
		Table table = getTable();
		// the column has repeated column number > 1
		int columnsRepeatedNumber = getColumnsRepeatedNumber();
		if (columnsRepeatedNumber > 1) {
			if ( < (columnsRepeatedNumber - 1)) {
			}
		}
		Node aCurNode = ;
		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((TableTableColumnElementaNextNode, 0);
else if (aNextNode instanceof TableTableColumnsElement
							|| aNextNode instanceof TableTableHeaderColumnsElement
							|| aNextNode instanceof TableTableColumnGroupElement) {
								"//table:table-column[first()]"aNextNode.);
						if (firstCol != null) {
							return table.getColumnInstance(firstCol, 0);
						}
else {
						aCurNode = aNextNode;
						aNextNode = aNextNode.getNextSibling();
					}
catch (XPathExpressionException e) {
					Logger.getLogger(Column.class.getName()).log(.e.getMessage(), e);
				}
			}
		}
	}

Get the index of this column in the owner table.

Returns:
the index of the column
	public int getColumnIndex() {
		int result = 0;
		Table table = getTable();
		TableTableElement mTableElement = table.getOdfElement();
		for (Node n : new DomNodeList(mTableElement.getChildNodes())) {
			if (n instanceof TableTableHeaderColumnsElement) {
				for (Node m : new DomNodeList(headers.getChildNodes())) {
					if (m instanceof TableTableColumnElement) {
						columnEle = (TableTableColumnElementm;
						if (columnEle == getOdfElement()) {
							return result + ;
						}
						if (columnEle.getTableNumberColumnsRepeatedAttribute() == null) {
							result += 1;
else {
						}
					}
				}
			}
			if (n instanceof TableTableColumnElement) {
				columnEle = (TableTableColumnElementn;
				if (columnEle == getOdfElement()) {
					break;
				}
				if (columnEle.getTableNumberColumnsRepeatedAttribute() == null) {
					result += 1;
else {
				}
			}
		}
		return result + ;
	}

Set the default cell style to this column.

The style should already exist in this document.

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.

Parameters:
style the cell style of the document
	public void setDefaultCellStyle(OdfStyle style) {
		OdfStyle defaultStyle = getDefaultCellStyle();
		if (defaultStyle != null) {
		}
		if (style != null) {
		}
	}

Get the default cell style of this column.

Returns:
the default cell style of this column
		if (style == null) {
		}
		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
	}
		if (count == null) {
			return 1;
else {
			return count.intValue();
		}
	}
New to GrepCode? Check out our FAQ X