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;
 
 import java.util.List;
 
CellRange represent a rang of cells that are adjacent with each other

CellRange provides methods to get/set/modify the properties of cell range.

 
 public class CellRange {
 
 	private int mnStartRow;
 	private int mnStartColumn;
 	private int mnEndRow;
 	private int mnEndColumn;
 	private Table maOwnerTable;
 	private boolean mbSpreadsheet;

Construct the instance of CellRange.

Parameters:
table is the container table of this cell range.
startColumn is the column index of the first cell in this cell range.
startRow is the row index of the first cell in this cell range.
endColumn is the column index of the last cell in this cell range.
endRow is the row index of the last cell in this cell range.
 
 	CellRange(Table tableint startColumnint startRowint endColumnint endRow) {
 		 = table;
 
 		if (doc instanceof SpreadsheetDocument) {
 			 = true;
 		}
 
 		//the first cell is the covered cell, then the cell range should be enlarged
 		//so that it can contains the complete cell
 		//get the cell cover info
 		 = startColumn;
 		 = startRow;
 		 = endColumn;
 		 = endRow;
 		List<CellCoverInfocoverList = .getCellCoverInfos(0, 0, endColumnendRow);
 		Cell cell;// = maOwnerTable.getOwnerCellByPosition(coverList, nStartColumn, nStartRow);
 		for (int i = startColumni <= endColumni++) {
 			cell = .getOwnerCellByPosition(coverLististartRow);
 			int rowIndex = cell.getRowIndex();
 			int colIndex = cell.getColumnIndex();
 			 = Math.min(colIndex);
 			 = Math.min(rowIndex);
 			 = Math.max(colIndex + cell.getColumnSpannedNumber() - 1);
 			 = Math.max(rowIndex + cell.getRowSpannedNumber() - 1);
 		}
 
 		for (int i = startColumni <= endColumni++) {
 			cell = .getOwnerCellByPosition(coverListiendRow);
 			int rowIndex = cell.getRowIndex();
			int colIndex = cell.getColumnIndex();
			 = Math.min(colIndex);
			 = Math.min(rowIndex);
			 = Math.max(colIndex + cell.getColumnSpannedNumber() - 1);
			 = Math.max(rowIndex + cell.getRowSpannedNumber() - 1);
		}
		for (int i = startRow + 1; i < endRowi++) {
			cell = .getOwnerCellByPosition(coverListstartColumni);
			int rowIndex = cell.getRowIndex();
			int colIndex = cell.getColumnIndex();
			 = Math.min(colIndex);
			 = Math.min(rowIndex);
			 = Math.max(colIndex + cell.getColumnSpannedNumber() - 1);
			 = Math.max(rowIndex + cell.getRowSpannedNumber() - 1);
		}
		for (int i = startRow + 1; i < endRowi++) {
			cell = .getOwnerCellByPosition(coverListendColumni);
			int rowIndex = cell.getRowIndex();
			int colIndex = cell.getColumnIndex();
			 = Math.min(colIndex);
			 = Math.min(rowIndex);
			 = Math.max(colIndex + cell.getColumnSpannedNumber() - 1);
			 = Math.max(rowIndex + cell.getRowSpannedNumber() - 1);
		}
	}

construct the empty cellRange
	}

Merge the current cell range to one cell
	public void merge() {
		//note: after merge, the cell row/column count might  be changed
		int rowCount = .getRowCount();
		int colCount = .getColumnCount();
		//if the cell range is the whole table, then merge it to a big cell
		//as to the spreadsheet document, it should still keep the original cell count,
		//rather than merge to a big cell.
		if (rowCount == ( -  + 1)
				&& colCount == ( -  + 1)
			if (firstCell.getOdfElement() instanceof TableTableCellElement) {
				TableTableCellElement firstCellElement = (TableTableCellElement) (firstCell.getOdfElement());
				firstCellElement.removeAttributeNS(..getUri(), "number-columns-spanned");
				firstCellElement.removeAttributeNS(..getUri(), "number-rows-spanned");
			}
			//just copy the text of the other cells to this first cell
			for (int i = i <  + 1; i++) {
				for (int j = j <  + 1; j++) {
					Cell cellBase = .getCellByPosition(ji);
					if (j !=  || i != ) {
						//copy the content of this cell to the first cell
						firstCell.appendContentFrom(cellBase);
					}
				}
			}
			return;
//if the cell range covered all the table row, and the merged column > 1
		//the merged column can be removed
		else if (rowCount == ( -  + 1)
				&& colCount > ( -  + 1)
				&& ( - ) > 0) {
			//the first cell, set the span attribute
			if (firstCell.getOdfElement() instanceof TableTableCellElement) {
				TableTableCellElement firstCellElement = (TableTableCellElement) (firstCell.getOdfElement());
				firstCellElement.removeAttributeNS(..getUri(), "number-columns-spanned");
				firstCellElement.setTableNumberRowsSpannedAttribute(Integer.valueOf( -  + 1));
			}
			//the other cell, copy the content to first cell
			//if it is also in the first column of the cell range, set to the covered cell
			//other cell not in the first column will be removed when remove the column
			for (int i = i <  + 1; i++) {
				for (int j = j <  + 1; j++) {
					Cell cellBase = .getCellByPosition(ji);
					if (j !=  || i != ) {
						//append content to first cell
						firstCell.appendContentFrom(cellBase);
						//change the cell in the first column of cell range to covered cell
						if ((j == ) && (cellBase.getOdfElement() instanceof TableTableCellElement)) {
							//change the normal cell to be the covered cell
							TableTableCellElement firstColumnCell = (TableTableCellElementcellBase.getOdfElement();
									(OdfFileDomfirstColumnCell.getOwnerDocument(),
									OdfName.newName(."covered-table-cell"));
							Row parentRow = cellBase.getTableRow();
							parentRow.getOdfElement().insertBefore(coveredCellfirstColumnCell);
							parentRow.getOdfElement().removeChild(firstColumnCell);
						}
					}
				}
			}
			double nCellRangeWidth = widthList.get(widthList.size() - 1) - widthList.get(0);
			firstColumn.setWidth(nCellRangeWidth);
			return;
//if the cell range covered all the table column, the merged row can be removed
		else if (rowCount > ( -  + 1)
				&& colCount == ( -  + 1)
				&& ( - ) > 0) {
			//the first cell, set the span attribute
			if (firstCell.getOdfElement() instanceof TableTableCellElement) {
				TableTableCellElement firstCellElement = (TableTableCellElement) (firstCell.getOdfElement());
				firstCellElement.removeAttributeNS(..getUri(), "number-rows-spanned");
			}
			//the other cell, copy the content to first cell
			//if it is also in the first row of the cell range, set to the covered cell
			//other cell not in the first row will be removed when remove the row
			for (int i = i <  + 1; i++) {
				for (int j = j <  + 1; j++) {
					Cell cellBase = .getCellByPosition(ji);
					if (j !=  || i != ) {
						//append content to first cell
						firstCell.appendContentFrom(cellBase);
						//change the cell in the first row of cell range to covered cell
						if ((i == ) && (cellBase.getOdfElement() instanceof TableTableCellElement)) {
							//change the normal cell to be the covered cell
									(OdfFileDomfirstRowCell.getOwnerDocument(),
									OdfName.newName(."covered-table-cell"));
							Row parentRow = cellBase.getTableRow();
							parentRow.getOdfElement().insertBefore(coveredCellfirstRowCell);
							parentRow.getOdfElement().removeChild(firstRowCell);
						}
					}
				}
			}
			return;
//don't remove any row/column
		else {
			//first keep the column and row count in this cell range
			//the first cell, set the span attribute
			if (firstCell.getOdfElement() instanceof TableTableCellElement) {
				//first cell number columns repeated attribute may > 1.
				firstCell.splitRepeatedCells();
				TableTableCellElement firstCellElement = (TableTableCellElement) (firstCell.getOdfElement());
			}
			//the other cell, set to the covered cell
			for (int i = i <  + 1; i++) {
				for (int j = j <  + 1; j++) {
					Cell cellBase = .getCellByPosition(ji);
					if (j !=  || i != ) {
						if (cellBase.getOdfElement() instanceof TableTableCellElement) {
							//change the normal cell to be the covered cell
									OdfName.newName(."covered-table-cell"));
							TableTableRowElement parentRowEle = cellBase.getTableRow().getOdfElement();
							parentRowEle.insertBefore(coveredCellcell);
							//copy the content of this cell to the first cell
							firstCell.appendContentFrom(cellBase);
							cellBase.removeContent();
							//set the table column repeated attribute
							int repeatedNum = cell.getTableNumberColumnsRepeatedAttribute();
							int num = ( - j + 1) - repeatedNum;
							if (num >= 0) {
								if(repeatedNum > 1){
								}
								parentRowEle.removeChild(cell);
else {
								int tableNumberColumnsRepeatedValue =  - j + 1;
								if(tableNumberColumnsRepeatedValue > 1){
									coveredCell.setTableNumberColumnsRepeatedAttribute(tableNumberColumnsRepeatedValue);
								}
							}
else if (cellBase.getOdfElement() instanceof TableCoveredTableCellElement) {
							try {
								//copy the content of this cell to the first cell
								firstCell.appendContentFrom(cellBase);
								cellBase.removeContent();
catch (Exception e) {
								Logger.getLogger(CellRange.class.getName()).log(.e.getMessage(), e);
							}
						}
					}
				}
			}
		}
	}
	//vector store the x coordinate of each column which reference to the left start point of owner table
	//the returned value is all measured with "mm" unit
		List<Doublelist = new ArrayList<Double>();
		Double length = Double.valueOf(0.0);
		for (int i = 0; i < .getColumnCount() - 1; i++) {
			int repeateNum = col.getColumnsRepeatedNumber();
			if (repeateNum == 1) {
					list.add(length);
				}
				length = Double.valueOf(length + col.getWidth());
else {
				for (int j = 0; j < repeateNumj++) {
					if (isColumnInCellRange(i + j)) {
						list.add(length);
						length = Double.valueOf(length + col.getWidth());
					}
				}
				i += repeateNum - 1;
			}
		}
		//x coordinate of last column right point 
		list.add(length);
		return list;
	}
	//vector store the x coordinate of each will split column start point
		//get each cell in the cell range(the cell here means the real cell, not the covered cell)
		//then get the real(uncovered) cell x coordinate
		List<DoubletmpList = new ArrayList<Double>();
		for (int i = i <  + 1; i++) {
			for (int j = j <  + 1; j++) {
				if (.isCoveredCellInOwnerTable(coverListij)) {
					continue;
else {
					//the real cell, record the x coordinate of the left point
					Double width = widthList.get(i - );
					if (!tmpList.contains(width)) {
						tmpList.add(width);
					}
				}
			}
		}
		//last, reorder the tmpVector and split it to splitNum between each item
		Double[] widthArray = (Double[]) tmpList.toArray();
		Arrays.sort(widthArray);
		List<DoublertnValues = new ArrayList<Double>();
		double colWidth;
		double unitWidth;
		rtnValues.add(widthArray[0]);
		for (int i = 1; i < widthArray.lengthi++) {
			colWidth = Double.valueOf(widthArray[i] - widthArray[i - 1]);
			unitWidth = colWidth / splitNum;
			for (int j = 1; j < splitNumj++) {
				double eachWidth = unitWidth * j + widthArray[i - 1];
				rtnValues.add(Double.valueOf(eachWidth));
			}
			rtnValues.add(widthArray[i]);
		}
		return rtnValues;
	}

Get the name of the named cell range.

Returns:
the name of the cell range
	}

Set the name of the current cell range.

Parameters:
cellRangeName the name that need to set
	public void setCellRangeName(String cellRangeName) {
		try {
			//create name range element
					contentDom,
					OdfName.newName(."named-expressions"));
			TableNamedRangeElement nameRange = (TableNamedRangeElementnameExpress.newTableNamedRangeElement(startCellRange + ":" + endCellRangecellRangeName);
			nameRange.setTableBaseCellAddressAttribute(endCellRange);
			contentRoot.appendChild(nameExpress);
			 = cellRangeName;
catch (Exception ex) {
			Logger.getLogger(CellRange.class.getName()).log(.nullex);
		}
	}

Get the Table instance who contains this cell range.

Returns:
the table that contains the cell range.
	public Table getTable() {
		return ;
	}

Get the number of rows in this cell range.

Returns:
rows number in the cell range
	public int getRowNumber() {
		return ( -  + 1);
	}

Get the number of columns in this cell range.

Returns:
columns number in the cell range
	public int getColumnNumber() {
		return ( -  + 1);
	}

Returns a single cell that is positioned at specified column and row.

Parameters:
clmIndex the column index of the cell inside the range.
rowIndex the row index of the cell inside the range.
Returns:
the cell at the specified position relative to the start position of the cell range
Throws:
java.lang.IndexOutOfBoundsException if the column/row index is bigger than the column/row count
	public Cell getCellByPosition(int clmIndexint rowIndexthrows IndexOutOfBoundsException {
		return .getCellByPosition( + clmIndex + rowIndex);
	}

Check if the given column in is this cell range.

Parameters:
colIndex the given column index
Returns:
true if the given column index is in the current cell range
	private boolean isColumnInCellRange(int colIndex) {
		if (colIndex <  || colIndex > ) {
			return false;
else {
			return true;
		}
	}

Returns a single cell that is positioned at specified cell address.

Parameters:
address the cell address of the cell inside the range.
Returns:
the cell at the specified cell address relative to the start position of the cell range
	public Cell getCellByPosition(String address) {
		//if the address also contain the table name,  but the table is not the maOwnerTable
		//what should do? get the table then getcellByPosition?
	}
New to GrepCode? Check out our FAQ X