Package ag.ion.bion.officelayer.internal.text

Source Code of ag.ion.bion.officelayer.internal.text.TextTable

/****************************************************************************
* ubion.ORS - The Open Report Suite                                        *
*                                                                          *
* ------------------------------------------------------------------------ *
*                                                                          *
* Subproject: NOA (Nice Office Access)                                     *
*                                                                          *
*                                                                          *
* The Contents of this file are made available subject to                  *
* the terms of GNU Lesser General Public License Version 2.1.              *
*                                                                          *
* GNU Lesser General Public License Version 2.1                            *
* ======================================================================== *
* Copyright 2003-2005 by IOn AG                                            *
*                                                                          *
* This library is free software; you can redistribute it and/or            *
* modify it under the terms of the GNU Lesser General Public               *
* License version 2.1, as published by the Free Software Foundation.       *
*                                                                          *
* This library is distributed in the hope that it will be useful,          *
* but WITHOUT ANY WARRANTY; without even the implied warranty of           *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU        *
* Lesser General Public License for more details.                          *
*                                                                          *
* You should have received a copy of the GNU Lesser General Public         *
* License along with this library; if not, write to the Free Software      *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,                    *
* MA  02111-1307  USA                                                      *
*                                                                          *
* Contact us:                                                              *
*  http://www.ion.ag                                                       *
*  info@ion.ag                                                             *
*                                                                          *
****************************************************************************/

/*
* Last changes made by $Author: markus $, $Date: 2007-08-07 14:40:35 +0200 (Di, 07 Aug 2007) $
*/
package ag.ion.bion.officelayer.internal.text;

import java.util.ArrayList;
import java.util.List;

import ag.ion.bion.officelayer.clone.CloneException;
import ag.ion.bion.officelayer.clone.ICloneService;
import ag.ion.bion.officelayer.internal.text.table.TextTableCellRangeName;
import ag.ion.bion.officelayer.internal.text.table.TextTableCloneService;
import ag.ion.bion.officelayer.internal.text.table.TextTablePropertyStore;
import ag.ion.bion.officelayer.text.AbstractTextComponent;
import ag.ion.bion.officelayer.text.ITextDocument;
import ag.ion.bion.officelayer.text.ITextRange;
import ag.ion.bion.officelayer.text.ITextTable;
import ag.ion.bion.officelayer.text.ITextTableCell;
import ag.ion.bion.officelayer.text.ITextTableCellRange;
import ag.ion.bion.officelayer.text.ITextTableColumn;
import ag.ion.bion.officelayer.text.ITextTableProperties;
import ag.ion.bion.officelayer.text.ITextTableRow;
import ag.ion.bion.officelayer.text.TextException;
import ag.ion.bion.officelayer.text.table.IFormula;
import ag.ion.bion.officelayer.text.table.IFormulaService;
import ag.ion.bion.officelayer.text.table.ITextTablePropertyStore;
import ag.ion.bion.officelayer.text.table.TextTableCellNameHelper;
import ag.ion.noa.text.XInterfaceObjectSelection;

import com.sun.star.beans.XPropertySet;
import com.sun.star.container.XNamed;
import com.sun.star.lang.IllegalArgumentException;
import com.sun.star.table.XCell;
import com.sun.star.table.XCellRange;
import com.sun.star.text.XText;
import com.sun.star.text.XTextContent;
import com.sun.star.text.XTextSection;
import com.sun.star.text.XTextTable;
import com.sun.star.text.XTextViewCursorSupplier;
import com.sun.star.uno.UnoRuntime;

/**
* Table of an OpenOffice.org text document.
*
* @author Andreas Br�ker
* @author Markus Kr�ger
* @version $Revision: 11561 $
*/
public class TextTable extends AbstractTextComponent implements ITextTable {

  private XTextTable xTextTable = null;
  private XCellRange xCellRange = null;
  private List formulaCells = null;

  // ----------------------------------------------------------------------------
  /**
   * Constructs new TextTable.
   *
   * @param textDocument
   *            text document to be used
   * @param xTextTable
   *            OpenOffice.org XTextTable interface
   *
   * @throws IllegalArgumentException
   *             if the submitted text document or OpenOffice.org XTextTable
   *             interface is not valid
   *
   * @author Andreas Br�ker
   */
  public TextTable(ITextDocument textDocument, XTextTable xTextTable)
      throws IllegalArgumentException {
    super(textDocument);
    if (xTextTable == null)
      throw new IllegalArgumentException(
          "Submitted OpenOffice.org XTextTable interface is not valid.");
    this.xTextTable = xTextTable;
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns OpenOffice.org XTextContent interface.
   *
   * @return OpenOffice.org XTextContent interface
   *
   * @author Andreas Br�ker
   */
  public XTextContent getXTextContent() {
    return xTextTable;
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns OpenOffice.org XTextTable interface.
   *
   * @return OpenOffice.org XTextTable interface
   *
   * @author Andreas Br�ker
   */
  public XTextTable getXTextTable() {
    return xTextTable;
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns text range of the text table.
   *
   * @return text range of the text table
   *
   * @author Markus Kr�ger
   * @date 31.07.2007
   */
  public ITextRange getTextRange() throws Exception {
    XTextContent textContent = getXTextContent();
    textDocument.setSelection(new XInterfaceObjectSelection(textContent));
    XTextViewCursorSupplier xTextViewCursorSupplier = (XTextViewCursorSupplier) UnoRuntime
        .queryInterface(XTextViewCursorSupplier.class, textDocument
            .getXTextDocument().getCurrentController());
    xTextViewCursorSupplier.getViewCursor().goLeft((short) 1, false);
    return textDocument.getViewCursorService().getViewCursor()
        .getTextCursorFromEnd().getEnd();
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns properties of the text table.
   *
   * @return properties of the text table
   *
   * @author Andreas Br�ker
   */
  public ITextTableProperties getProperties() {
    XPropertySet xPropertySet = (XPropertySet) UnoRuntime.queryInterface(
        XPropertySet.class, xTextTable);
    return new TextTableProperties(xPropertySet);
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns name of the table.
   *
   * @return name of the table
   *
   * @author Andreas Br�ker
   */
  public String getName() {
    XNamed xNamed = (XNamed) UnoRuntime.queryInterface(XNamed.class,
        xTextTable);
    return xNamed.getName();
  }

  // ----------------------------------------------------------------------------
  /**
   * Sets data of cell with the submitted name.
   *
   * @param cellName
   *            name of the cell
   * @param xTextContent
   *            content to be inserted
   *
   * @throws Exception
   *             if any error occurs
   *
   * @author Andreas Br�ker
   */
  public void setCellData(String cellName, XTextContent xTextContent)
      throws Exception {
    XCell xCell = xTextTable.getCellByName(cellName);
    XText xText = (XText) UnoRuntime.queryInterface(XText.class, xCell);
    xText.setString("");
    xText.insertTextContent(xText.getStart(), xTextContent, true);
  }

  // ----------------------------------------------------------------------------
  /**
   * Adds submitted text content to the cell with the submitted name.
   *
   * @param cellName
   *            name of the cell
   * @param xTextContent
   *            text content to be added
   *
   * @throws Exception
   *             if any error occurs
   *
   * @author Andreas Br�ker
   */
  public void addCellData(String cellName, XTextContent xTextContent)
      throws Exception {
    XCell xCell = xTextTable.getCellByName(cellName);
    XText xText = (XText) UnoRuntime.queryInterface(XText.class, xCell);
    xText.insertTextContent(xText.getEnd(), xTextContent, true);
  }

  // ----------------------------------------------------------------------------
  /**
   * Sets data of the cell with the submitted name.
   *
   * @param cellName
   *            name of the cell
   * @param content
   *            content to be inserted
   *
   * @throws Exception
   *             if any error occurs
   *
   * @author Andreas Br�ker
   */
  public void setCellData(String cellName, String content) throws Exception {
    XCell xCell = xTextTable.getCellByName(cellName);
    XText xText = (XText) UnoRuntime.queryInterface(XText.class, xCell);
    xText.setString(content);
  }

  // ----------------------------------------------------------------------------
  /**
   * Adds submitted content to the cell with the submitted name.
   *
   * @param cellName
   *            name of the cell
   * @param content
   *            content to be added
   *
   * @throws Exception
   *             if any error occurs
   *
   * @author Andreas Br�ker
   */
  public void addCellData(String cellName, String content) throws Exception {
    XCell xCell = xTextTable.getCellByName(cellName);
    XText xText = (XText) UnoRuntime.queryInterface(XText.class, xCell);
    xText.getEnd().setString(content);
  }

  // ----------------------------------------------------------------------------
  /**
   * Sets data of the cell with the submitted name.
   *
   * @param cellName
   *            name of the cell
   * @param content
   *            content to be inserted
   *
   * @throws Exception
   *             if any error occurs
   *
   * @author Andreas Br�ker
   */
  public void setCellData(String cellName, double content) throws Exception {
    XCell xCell = xTextTable.getCellByName(cellName);
    xCell.setValue(content);
  }

  // ----------------------------------------------------------------------------
  /**
   * Sets formula into the cell with the submitted name.
   *
   * @param cellName
   *            name of the cell
   * @param formula
   *            formula to be inserted
   *
   * @throws Exception
   *             if any error occurs
   *
   * @author Andreas Br�ker
   */
  public void setCellFormula(String cellName, String formula)
      throws Exception {
    XCell xCell = xTextTable.getCellByName(cellName);
    xCell.setFormula(formula);
  }

  // ----------------------------------------------------------------------------
  /**
   * Adds row(s) to the table.
   *
   * @param count
   *            number of rows to be added
   *
   * @throws TextException
   *             if the row(s) can not be added
   *
   * @author Andreas Br�ker
   */
  public void addRow(int count) throws TextException {
    if (count > 0)
      xTextTable.getRows().insertByIndex(getRowCount(), count);
  }

  // ----------------------------------------------------------------------------
  /**
   * Adds row(s) at submitted index to the table.
   *
   * @param index
   *            index to be used
   * @param count
   *            number of rows to be added
   *
   * @throws TextException
   *             if the row(s) can not be added
   *
   * @author Andreas Br�ker
   */
  public void addRow(int index, int count) throws TextException {
    if (index > -1 && count > 0)
      xTextTable.getRows().insertByIndex(index, count);
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns number of available rows.
   *
   * @return number of available rows.
   *
   * @author Andreas Br�ker
   * @author Markus Kr�ger
   */
  public int getRowCount() {
    String[] cellNames = xTextTable.getCellNames();
    int rows = 0;
    for (int i = 0; i < cellNames.length; i++) {
      int row = TextTableCellNameHelper.getRowIndex(cellNames[i]);
      row = row + 1;
      if (row > rows)
        rows = row;
    }
    return rows;
  }

  // ----------------------------------------------------------------------------
  /**
   * Adds column(s) to the table.
   *
   * @param count
   *            number of columns to be added
   *
   * @throws TextException
   *             if the column(s) can not be added
   *
   * @author Andreas Br�ker
   */
  public void addColumn(int count) throws TextException {
    if (count > 0)
      xTextTable.getColumns().insertByIndex(getColumnCount(), count);
  }

  // ----------------------------------------------------------------------------
  /**
   * Adds column(s) at submitted index the table.
   *
   * @param index
   *            index to be used
   * @param count
   *            number of columns to be added
   *
   * @throws TextException
   *             if the column(s) can not be added
   *
   * @author Andreas Br�ker
   */
  public void addColumn(int index, int count) throws TextException {
    if (index > -1 && count > 0)
      xTextTable.getColumns().insertByIndex(index, count);
  }

  // ----------------------------------------------------------------------------
  /**
   * Adds column(s) at submitted index the table.
   *
   * @param index
   *            index to be used
   * @param count
   *            number of columns to be added
   * @param after
   *            true, if the rows shoud be addes after submitted index
   *
   * @throws TextException
   *             if the column(s) can not be added
   *
   * @author Andreas Br�ker
   */
  public void addColumn(int index, int count, boolean after)
      throws TextException {
    if (index > -1 && count > 0) {
      if (after) {
        xTextTable.getColumns().insertByIndex(index, count);
      } else {
        xTextTable.getColumns().insertByIndex(index - 1, count);
      }
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns a column at submitted index the table.
   *
   * @param index
   *            index to be used
   *
   * @return column of a table
   *
   * @throws TextException
   *             if any error occurs
   *
   * @author Markus Kr�ger
   */
  public ITextTableColumn getColumn(int index) throws TextException {
    return getColumns()[index];
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns all columns of a table.
   *
   * @return columns of a table
   *
   * @throws TextException
   *             if any error occurs
   *
   * @author Markus Kr�ger
   */
  public ITextTableColumn[] getColumns() throws TextException {
    TextTableColumn[] textTableColumns = new TextTableColumn[getColumnCount()];
    for (int i = 0; i < textTableColumns.length; i++) {
      textTableColumns[i] = new TextTableColumn(this, i);
    }
    return textTableColumns;
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns number of available columns.
   *
   * @return number of available columns
   *
   * @author Andreas Br�ker
   * @author Markus Kr�ger
   */
  public int getColumnCount() {
    String[] cellNames = xTextTable.getCellNames();
    int cols = 0;
    for (int i = 0; i < cellNames.length; i++) {
      int col = TextTableCellNameHelper.getColumnIndex(cellNames[i]);
      col = col + 1;
      if (col > cols)
        cols = col;
    }
    return cols;
  }

  // ----------------------------------------------------------------------------
  /**
   * Spread all columns evenly.
   *
   * @throws TextException
   *             if necessary properties are not available
   *
   * @author Markus Kr�ger
   */
  public void spreadColumnsEvenly() throws TextException {
    spreadColumnsEvenly(0, getColumnCount() - 1);
  }

  // ----------------------------------------------------------------------------
  /**
   * Spread columns in range evenly.
   *
   * @param startIndex
   *            index of the first column in range
   * @param endIndex
   *            index of the last column in range
   *
   * @throws TextException
   *             if necessary properties are not available
   *
   * @author Markus Kr�ger
   */
  public void spreadColumnsEvenly(int startIndex, int endIndex)
      throws TextException {
    if (endIndex > startIndex && startIndex > -1) {
      long tableWidth = getProperties().getWidth();
      long rangeWidth = 0;
      TextTableColumn textTableColumn = null;

      // get the width of the give range
      for (int i = startIndex; i <= endIndex; i++) {
        textTableColumn = new TextTableColumn(this, i);
        rangeWidth = rangeWidth + textTableColumn.getWidth();
      }

      // determine the evenly column width, so that all have the same size
      long evenColumnWidth = (rangeWidth / (endIndex - startIndex + 1));

      // set the first column almost as wide as the whole space for the
      // column range
      // - this needs to be done in a loop, because that way the other
      // collumns are on the right side of the
      // column with the enIndex with a minimal width (needed to set the
      // right width in the next loop)
      // - the last column gets its width automaticly
      for (int i = endIndex - 1; i >= startIndex; i--) {
        textTableColumn = new TextTableColumn(this, i);
        textTableColumn.setWidth((short) tableWidth);
      }
      // set the width for each column
      // the last column gets its width automaticly
      for (int i = startIndex; i <= endIndex; i++) {
        textTableColumn = new TextTableColumn(this, i);
        textTableColumn.setWidth((short) evenColumnWidth);
      }
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns cell with the submitted name.
   *
   * @param name
   *            name of the cell
   *
   * @return cell with the submitted name
   *
   * @throws TextException
   *             if the cell is not available
   *
   * @author Andreas Br�ker
   */
  public ITextTableCell getCell(String name) throws TextException {
    try {
      XCell xCell = xTextTable.getCellByName(name);
      if (xCell != null)
        return new TextTableCell(textDocument, xCell);
      else
        throw new TextException("A column with the name " + name
            + " is not available.");
    } catch (Exception exception) {
      TextException textException = new TextException(exception
          .getMessage());
      textException.initCause(exception);
      throw textException;
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns all cells with formulas.
   *
   * @return cells with formulas
   *
   * @author Markus Kr�ger
   */
  public ITextTableCell[] getCellsWithFormula() {
    if (formulaCells == null)
      analyseTableFormulas();
    return (ITextTableCell[]) formulaCells
        .toArray(new ITextTableCell[formulaCells.size()]);
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns cell with the submitted column and row index.
   *
   * @param columnIndex
   *            column index of the cell
   * @param rowIndex
   *            row index of the cell
   *
   * @return cell with the submitted column and row index
   *
   * @throws TextException
   *             if the cell is not available
   *
   * @author Andreas Br�ker
   */
  public ITextTableCell getCell(int columnIndex, int rowIndex)
      throws TextException {
    String columnCharacters = TextTableCellNameHelper
        .getColumnCharacter(columnIndex);
    int rowCounter = TextTableCellNameHelper.getRowCounterValue(rowIndex);
    return getCell(columnCharacters + rowCounter);
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns cell range on the basis submitted index informations.
   *
   * @param firstColumnIndex
   *            index of first column inside the range
   * @param firstRowIndex
   *            index of first row inside the range
   * @param lastColumnIndex
   *            index of last column inside the range
   * @param lastRowIndex
   *            index of last row inside the range
   *
   * @return cell range on the basis submitted index informations
   *
   * @throws TextException
   *             if the cell range is not available
   *
   * @author Andreas Br�ker
   */
  public ITextTableCellRange getCellRange(int firstColumnIndex,
      int firstRowIndex, int lastColumnIndex, int lastRowIndex)
      throws TextException {
    String cellRangeName = TextTableCellNameHelper.getRangeName(
        firstColumnIndex, firstRowIndex, lastColumnIndex, lastRowIndex);
    try {
      if (xCellRange == null)
        xCellRange = (XCellRange) UnoRuntime.queryInterface(
            XCellRange.class, xTextTable);
      XCellRange newXCellRange = xCellRange.getCellRangeByPosition(
          firstColumnIndex, firstRowIndex, lastColumnIndex,
          lastRowIndex);
      TextTableCellRangeName textTableCellRangeName = new TextTableCellRangeName(
          cellRangeName);
      TextTableCellRange textTableCellRange = new TextTableCellRange(
          textDocument, newXCellRange, textTableCellRangeName);
      return textTableCellRange;
    } catch (Exception exception) {
      TextException textException = new TextException(exception
          .getMessage());
      textException.initCause(exception);
      throw textException;
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns cell range on the basis of the submitted cell range name.
   *
   * @param cellRangeName
   *            name of the cell range
   *
   * @return cell range on the basis of the submitted cell range name
   *
   * @throws TextException
   *             if the cell range is not available
   *
   * @author Andreas Br�ker
   * @author Markus Kr�ger
   */
  public ITextTableCellRange getCellRange(String cellRangeName)
      throws TextException {
    /*
     * try { if(xCellRange == null) xCellRange =
     * (XCellRange)UnoRuntime.queryInterface(XCellRange.class, xTextTable);
     * XCellRange newXCellRange =
     * xCellRange.getCellRangeByName(cellRangeName); TextTableCellRangeName
     * textTableCellRangeName = new TextTableCellRangeName(cellRangeName);
     * TextTableCellRange textTableCellRange = new
     * TextTableCellRange(textDocument,newXCellRange,
     * textTableCellRangeName); return textTableCellRange; } catch(Exception
     * exception) { TextException textException = new
     * TextException(exception.getMessage());
     * textException.initCause(exception); throw textException; }
     */
    return getCellRange(TextTableCellNameHelper
        .getCellRangeStartColumnIndex(cellRangeName),
        TextTableCellNameHelper
            .getCellRangeStartRowIndex(cellRangeName),
        TextTableCellNameHelper
            .getCellRangeEndColumnIndex(cellRangeName),
        TextTableCellNameHelper.getCellRangeEndRowIndex(cellRangeName));
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns text table row.
   *
   * @return text table row
   *
   * @author Andreas Br�ker
   * @author Markus Kr�ger
   */
  public ITextTableRow[] getRows() {
    ITextTableRow[] textTableRow = new ITextTableRow[getRowCount()];
    String[] cellNames = xTextTable.getCellNames();
    int lastRowIndex = 0;
    String rangeName = "A1";
    String oldCellName = rangeName;
    if (xCellRange == null)
      xCellRange = (XCellRange) UnoRuntime.queryInterface(
          XCellRange.class, xTextTable);
    for (int i = 0; i < cellNames.length; i++) {
      int thisRowIndex = TextTableCellNameHelper
          .getRowIndex(cellNames[i]);
      if (thisRowIndex != lastRowIndex) {
        rangeName = rangeName + ":" + oldCellName;
        TextTableCellRangeName textTableCellRangeName = new TextTableCellRangeName(
            rangeName);
        TextTableCellRange textTableCellRange = new TextTableCellRange(
            textDocument, xCellRange.getCellRangeByName(rangeName),
            textTableCellRangeName);
        textTableRow[lastRowIndex] = new TextTableRow(
            textTableCellRange);
        rangeName = cellNames[i];
        lastRowIndex = thisRowIndex;
      }
      oldCellName = cellNames[i];
    }
    rangeName = rangeName + ":" + oldCellName;
    TextTableCellRangeName textTableCellRangeName = new TextTableCellRangeName(
        rangeName);
    TextTableCellRange textTableCellRange = new TextTableCellRange(
        textDocument, xCellRange.getCellRangeByName(rangeName),
        textTableCellRangeName);
    textTableRow[lastRowIndex] = new TextTableRow(textTableCellRange);

    return textTableRow;
  }

  // ----------------------------------------------------------------------------
  /**
   * Gets the clone service of the element.
   *
   * @return the clone service
   *
   * @throws CloneException
   *             if the clone service could not be returned
   *
   * @author Markus Kr�ger
   */
  public ICloneService getCloneService() throws CloneException {
    return new TextTableCloneService(this, textDocument.getXTextDocument());
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns text table row.
   *
   * @param index
   *            index to be used
   *
   * @return text table row
   *
   * @author Miriam Sutter
   * @author Andreas Br�ker
   * @author Markus Kr�ger
   */
  public ITextTableRow getRow(int index) {
    if (xCellRange == null)
      xCellRange = (XCellRange) UnoRuntime.queryInterface(
          XCellRange.class, xTextTable);
    ITextTableRow textTableRow = null;
    try {
      String[] cellNames = xTextTable.getCellNames();
      String endCellName = "A" + (index + 1);
      for (int i = 0; i < cellNames.length; i++) {
        if (TextTableCellNameHelper.getRowIndex(cellNames[i]) == index) {
          endCellName = cellNames[i];
        }
      }
      String rangeName = "A" + (index + 1) + ":" + endCellName;
      TextTableCellRangeName textTableCellRangeName = new TextTableCellRangeName(
          rangeName);
      TextTableCellRange textTableCellRange = new TextTableCellRange(
          textDocument, xCellRange.getCellRangeByName(rangeName),
          textTableCellRangeName);
      textTableRow = new TextTableRow(textTableCellRange);
    } catch (Exception exception) {
      // do nothing
    }
    return textTableRow;
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns the property store of the table.
   *
   * @return store a property store of the table
   *
   * @throws TextException
   *             if the property store is not available
   *
   * @author Sebastian R�sgen
   */
  public ITextTablePropertyStore getPropertyStore() throws TextException {
    return new TextTablePropertyStore(this);
  }

  // ----------------------------------------------------------------------------
  /**
   * Removes a specified row.
   *
   * @param index
   *            index of the row
   *
   * @throws TextException
   *             if the row could not removed
   *
   * @author Miriam Sutter
   */
  public void removeRow(int index) throws TextException {
    try {
      xTextTable.getRows().removeByIndex(index, 1);
    } catch (Exception exception) {
      TextException textException = new TextException(
          "The specified row could not be removed");
      textException.initCause(exception);
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Removes rows.
   *
   * @param index
   *            index of the first row
   * @param count
   *            number of rows to remove
   *
   * @throws TextException
   *             if the rows could not removed
   *
   * @author Miriam Sutter
   */
  public void removeRows(int index, int count) throws TextException {
    try {
      xTextTable.getRows().removeByIndex(index, count);
    } catch (Exception exception) {
      TextException textException = new TextException(
          "The specified row could not be removed");
      textException.initCause(exception);
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Removes the table.
   *
   * @throws TextException
   *             if the table can not be removed
   *
   * @author Miriam Sutter
   * @author Andreas Br�ker
   */
  public void remove() throws TextException {
    try {
      textDocument.getTextService().getTextContentService()
          .removeTextContent(this);
    } catch (Exception exception) {
      TextException textException = new TextException(
          "The specified table can not be removed");
      textException.initCause(exception);
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns the page number where the table starts, returns -1 if page number
   * could not be determined.
   *
   * @return the page number where the table starts, returns -1 if page number
   *         could not be determined
   *
   * @author Markus Kr�ger
   */
  public short getTableStartPageNumber() {
    String[] cellNames = xTextTable.getCellNames();
    if (cellNames.length < 1)
      return -1;
    try {
      return getCell(cellNames[0]).getPageNumber();
    } catch (TextException exception) {
      return -1;
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Sets the number of header rows to apply header style for. NOTE: Table
   * must already be inserted before calling this method.
   *
   * @param headerRows
   *            number of header rows
   *
   * @throws TextException
   *             if the header rows could not be set
   *
   * @author Markus Kr�ger
   * @date 21.03.2007
   */
  public void setHeaderRows(int headerRows) throws TextException {
    if (headerRows > 0) {
      int rows = getRowCount();
      if (headerRows > rows)
        headerRows = rows;
      String[] cellNames = xTextTable.getCellNames();
      for (int i = 0; i < cellNames.length; i++) {
        int row = TextTableCellNameHelper.getRowIndex(cellNames[i]);
        if (row < headerRows)
          getCell(cellNames[i]).setCellParagraphStyle(
              ITextTableCell.STYLE_TABLE_HEADER);
      }
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Returns the page number where the table ends, returns -1 if page number
   * could not be determined.
   *
   * @return the page number where the table ends, returns -1 if page number
   *         could not be determined
   *
   * @author Markus Kr�ger
   */
  public short getTableEndPageNumber() {
    String[] cellNames = xTextTable.getCellNames();
    if (cellNames.length < 1)
      return -1;
    try {
      return getCell(cellNames[cellNames.length - 1]).getPageNumber();
    } catch (TextException exception) {
      return -1;
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Marks the table.
   *
   * @author Markus Kr�ger
   * @date 06.08.2007
   */
  public void markTable() {
    try {
      String firstCell = "A1";
      String range = firstCell + ":";
      ITextTableRow[] rows = getRows();
      if (rows.length > 0) {
        ITextTableCell[] cells = rows[rows.length - 1].getCells();
        String lastCellName = cells[cells.length - 1].getName()
            .getName();
        range = range
            + TextTableCellNameHelper
                .getColumnCharacter(lastCellName)
            + TextTableCellNameHelper
                .getRowCounterValue(lastCellName);
        ITextTableCellRange cellRange = getCellRange(range);
        ITextDocument textDocument = getTextDocument();
        if (textDocument.isOpen()) {
          XCell cell = getXTextTable().getCellByName(firstCell);
          XPropertySet xPropertySet = (XPropertySet) UnoRuntime
              .queryInterface(XPropertySet.class, cell);
          if (xPropertySet != null) {
            Object value = xPropertySet
                .getPropertyValue("TextSection");
            boolean select = true;
            XTextSection xTextSection = (XTextSection) UnoRuntime
                .queryInterface(XTextSection.class, value);
            if (xTextSection != null) {
              XPropertySet xTextSectionPropertySet = (XPropertySet) UnoRuntime
                  .queryInterface(XPropertySet.class,
                      xTextSection);
              if (xTextSectionPropertySet != null) {
                Boolean visible = (Boolean) xTextSectionPropertySet
                    .getPropertyValue("IsVisible");
                select = visible.booleanValue();
              }
            }
            if (select)
              textDocument
                  .setSelection(new XInterfaceObjectSelection(
                      cellRange.getXCellRange()));
          }
        }
      }
    } catch (Throwable throwable) {
      // no marking possible
    }
  }

  // ----------------------------------------------------------------------------
  /**
   * Analyses the table for cells with formulas and put them into a list.
   *
   * @author Markus Kr�ger
   */
  private void analyseTableFormulas() {
    formulaCells = new ArrayList();
    ITextTableRow[] tableRows = getRows();
    for (int i = 0; i < tableRows.length; i++) {
      ITextTableRow tableRow = tableRows[i];
      if (tableRow != null) {
        ITextTableCell[] cells = tableRow.getCells();
        for (int j = 0; j < cells.length; j++) {
          ITextTableCell cell = cells[j];
          if (cell != null) {
            IFormulaService formulaService = cell
                .getFormulaService();
            if (formulaService != null) {
              IFormula formula = formulaService.getFormula();
              if (formula != null) {
                formulaCells.add(cell);
              }
            }
          }
        }
      }
    }
  }
  // ----------------------------------------------------------------------------

}
TOP

Related Classes of ag.ion.bion.officelayer.internal.text.TextTable

TOP
Copyright © 2018 www.massapi.com. All rights reserved.
All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.