Package org.odftoolkit.odfdom.dom.element.table

Examples of org.odftoolkit.odfdom.dom.element.table.TableCoveredTableCellElement


      int i = 1;
      while (cellElement != null && i <= columnCount) {
        // covered element
        String tableNameSpace = OdfDocumentNamespace.TABLE.getUri();
        if (cellElement instanceof TableCoveredTableCellElement) {
          TableCoveredTableCellElement coveredCellEle = (TableCoveredTableCellElement) cellElement;
          // find cover cell element
          TableTableRowElement aRowEle = (TableTableRowElement) (coveredCellEle.getParentNode()
              .getPreviousSibling());
          while (aRowEle != null) {
            // the cover cell and the first covered cell must have
            // the same column index.
            TableTableCellElementBase coverCellEle = (TableTableCellElementBase) (aRowEle.getFirstChild());
            int j = coverCellEle.getTableNumberColumnsRepeatedAttribute();
            while (j < i) {
              coverCellEle = (TableTableCellElementBase) (coverCellEle.getNextSibling());
              if (coverCellEle instanceof TableTableCellElement) {
                j += (coverCellEle.getTableNumberColumnsRepeatedAttribute() * (((TableTableCellElement) coverCellEle)
                    .getTableNumberColumnsSpannedAttribute()));
              } else {
                j += coverCellEle.getTableNumberColumnsRepeatedAttribute();
              }
            }
            // find the cover cell, now start cell clone.
            if (coverCellEle instanceof TableTableCellElement) {
              TableTableCellElement newCellEle = (TableTableCellElement) (coverCellEle.cloneNode(true));
              cleanCell(newCellEle);
              newCellEle.removeAttributeNS(tableNameSpace, "number-rows-spanned");
              newRow.appendChild(newCellEle);
              // deal with the following covered cell, spread
              // sheet need change these covered cell to cell.
              if (mIsSpreadsheet) {
                // update column repeated number.
                int columnsSpannedNumber = newCellEle.getTableNumberColumnsSpannedAttribute();
                newCellEle.removeAttributeNS(tableNameSpace, "number-columns-spanned");
                int newColumnRepeatedNumber = newCellEle.getTableNumberColumnsRepeatedAttribute()
                    * columnsSpannedNumber;
                if (newColumnRepeatedNumber > 1) {
                  newCellEle.setTableNumberColumnsRepeatedAttribute(newColumnRepeatedNumber);
                } else {
                  newCellEle.removeAttributeNS(tableNameSpace, "number-columns-repeated");
                }
                // ignore the following covered cell of
                // reference row.
                // added by Daisy because of a bug in demo4
                // cellElement is a covered cell. coverCellEle
                // is its cover cell.
                // below codes will count
                // newColumnRepeatedNumber covered cell.
                int tempi = newColumnRepeatedNumber;
                while (tempi > 0) {
                  int iColumnRepeatedNumber = cellElement.getTableNumberColumnsRepeatedAttribute();
                  if (iColumnRepeatedNumber > tempi) {
                    // split covered cell
                    if (cellElement instanceof TableCoveredTableCellElement) {
                      cellElement.setTableNumberColumnsRepeatedAttribute(iColumnRepeatedNumber
                          - tempi);
                      TableTableCellElementBase newCoveredCellEle = (TableTableCellElementBase) cellElement
                          .cloneNode(true);
                      cleanCell(newCoveredCellEle);
                      if (tempi > 1) {
                        newCoveredCellEle.setTableNumberColumnsRepeatedAttribute(tempi);
                      } else {
                        newCoveredCellEle.removeAttributeNS(
                            OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
                      }
                      refRowElement.insertBefore(newCoveredCellEle, cellElement);
                      cellElement = newCoveredCellEle;
                    }
                  }
                  tempi = tempi - cellElement.getTableNumberColumnsRepeatedAttribute();
                  i = i + cellElement.getTableNumberColumnsRepeatedAttribute();
                  if (!(cellElement instanceof TableCoveredTableCellElement) && (tempi > 0)){
                    Logger.getLogger(Table.class.getName()).log(Level.FINE,  "Not covered cell was ignored");
                  }
                  cellElement = (TableTableCellElementBase) (cellElement.getNextSibling());
                  // while ((cellElement != null) &&
                  // (cellElement instanceof
                  // TableCoveredTableCellElement)) {
                  // cellElement = (TableTableCellElementBase)
                  // (cellElement.getNextSibling());
                  // }
                }
                // i += newColumnRepeatedNumber;
              } else {
                // clone the following covered cell of reference
                // row.
                // added by Daisy because of a bug in demo4
                cellElement = (TableTableCellElementBase) cellElement.getNextSibling();
                i += cellElement.getTableNumberColumnsRepeatedAttribute();
                int newColumnSpanNumber = newCellEle.getTableNumberColumnsSpannedAttribute();
                while ((cellElement != null) && (cellElement instanceof TableCoveredTableCellElement)
                    && (newColumnSpanNumber > 1)) {
                  TableCoveredTableCellElement newCoveredCellElement = (TableCoveredTableCellElement) cellElement
                      .cloneNode(true);
                  cleanCell(newCoveredCellElement);
                  newRow.appendChild(newCoveredCellElement);
                  i += cellElement.getTableNumberColumnsRepeatedAttribute();
                  cellElement = (TableTableCellElementBase) cellElement.getNextSibling();
View Full Code Here


          TableTableCellElement newCellEle = (TableTableCellElement) aCellEle.cloneNode(true);
          cleanCell(newCellEle);
          aRow.appendChild(newCellEle);
        } else { // cover more rows
          aCellEle.setTableNumberRowsSpannedAttribute(coveredHeigth + 1);
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) OdfXMLFactory
              .newOdfElement((OdfFileDom) mTableElement.getOwnerDocument(), OdfName.newName(
                  OdfDocumentNamespace.TABLE, "covered-table-cell"));
          if (columnsRepeatedNumber > 1) {
            newCellEle.setTableNumberColumnsRepeatedAttribute(columnsRepeatedNumber);
          } else {
            newCellEle.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
          }
          aRow.appendChild(newCellEle);
        }

        coveredLength = aCellEle.getTableNumberColumnsSpannedAttribute() - columnsRepeatedNumber;
        i = i + columnsRepeatedNumber;
      } else {
        TableCoveredTableCellElement aCellEle = (TableCoveredTableCellElement) refCell.getOdfElement();
        if (coveredLength >= 1) {
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) aCellEle.cloneNode(true);
          aRow.appendChild(newCellEle);
          coveredLength -= newCellEle.getTableNumberColumnsRepeatedAttribute();
        } else {
          TableTableCellElement coveredCell = (TableTableCellElement) refCell.getCoverCell().getOdfElement();
          TableTableCellElement newCellEle = (TableTableCellElement) coveredCell.cloneNode(true);
          cleanCell(newCellEle);
          newCellEle.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-rows-spanned");
          aRow.appendChild(newCellEle);
          coveredLength = coveredCell.getTableNumberColumnsSpannedAttribute() - columnsRepeatedNumber;
        }
        i = i + columnsRepeatedNumber;
      }
View Full Code Here

      int i = 1;
      while (cellElement != null && i <= columnCount) {
        // covered element
        String tableNameSpace = OdfDocumentNamespace.TABLE.getUri();
        if (cellElement instanceof TableCoveredTableCellElement) {
          TableCoveredTableCellElement coveredCellEle = (TableCoveredTableCellElement) cellElement;
          // find cover cell element
          TableTableRowElement aRowEle = (TableTableRowElement) (coveredCellEle.getParentNode()
              .getPreviousSibling());
          while (aRowEle != null) {
            // the cover cell and the first covered cell must have
            // the same column index.
            TableTableCellElementBase coverCellEle = (TableTableCellElementBase) (aRowEle.getFirstChild());
            int j = coverCellEle.getTableNumberColumnsRepeatedAttribute();
            while (j < i) {
              coverCellEle = (TableTableCellElementBase) (coverCellEle.getNextSibling());
              if (coverCellEle instanceof TableTableCellElement) {
                j += (coverCellEle.getTableNumberColumnsRepeatedAttribute() * (((TableTableCellElement) coverCellEle)
                    .getTableNumberColumnsSpannedAttribute()));
              } else {
                j += coverCellEle.getTableNumberColumnsRepeatedAttribute();
              }
            }
            // find the cover cell, now start cell clone.
            if (coverCellEle instanceof TableTableCellElement) {
              TableTableCellElement newCellEle = (TableTableCellElement) (coverCellEle.cloneNode(true));
              cleanCell(newCellEle);
              newCellEle.removeAttributeNS(tableNameSpace, "number-rows-spanned");
              newRow.appendChild(newCellEle);
              // deal with the following covered cell, spread
              // sheet need change these covered cell to cell.
              if (mIsSpreadsheet) {
                // update column repeated number.
                int columnsSpannedNumber = newCellEle.getTableNumberColumnsSpannedAttribute();
                newCellEle.removeAttributeNS(tableNameSpace, "number-columns-spanned");
                int newColumnRepeatedNumber = newCellEle.getTableNumberColumnsRepeatedAttribute()
                    * columnsSpannedNumber;
                if (newColumnRepeatedNumber > 1) {
                  newCellEle.setTableNumberColumnsRepeatedAttribute(newColumnRepeatedNumber);
                } else {
                  newCellEle.removeAttributeNS(tableNameSpace, "number-columns-repeated");
                }
                // ignore the following covered cell of
                // reference row.
                // added by Daisy because of a bug in demo4
                // cellElement is a covered cell. coverCellEle
                // is its cover cell.
                // below codes will count
                // newColumnRepeatedNumber covered cell.
                int tempi = newColumnRepeatedNumber;
                while (tempi > 0) {
                  int iColumnRepeatedNumber = cellElement.getTableNumberColumnsRepeatedAttribute();
                  if (iColumnRepeatedNumber > tempi) {
                    // split covered cell
                    if (cellElement instanceof TableCoveredTableCellElement) {
                      cellElement.setTableNumberColumnsRepeatedAttribute(iColumnRepeatedNumber
                          - tempi);
                      TableTableCellElementBase newCoveredCellEle = (TableTableCellElementBase) cellElement
                          .cloneNode(true);
                      cleanCell(newCoveredCellEle);
                      if (tempi > 1) {
                        newCoveredCellEle.setTableNumberColumnsRepeatedAttribute(tempi);
                      } else {
                        newCoveredCellEle.removeAttributeNS(
                            OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
                      }
                      refRowElement.insertBefore(newCoveredCellEle, cellElement);
                      cellElement = newCoveredCellEle;
                    }
                  }
                  tempi = tempi - cellElement.getTableNumberColumnsRepeatedAttribute();
                  i = i + cellElement.getTableNumberColumnsRepeatedAttribute();
                  if (!(cellElement instanceof TableCoveredTableCellElement) && (tempi > 0)){
                    Logger.getLogger(Table.class.getName()).log(Level.FINE,  "Not covered cell was ignored");
                  }
                  cellElement = (TableTableCellElementBase) (cellElement.getNextSibling());
                  // while ((cellElement != null) &&
                  // (cellElement instanceof
                  // TableCoveredTableCellElement)) {
                  // cellElement = (TableTableCellElementBase)
                  // (cellElement.getNextSibling());
                  // }
                }
                // i += newColumnRepeatedNumber;
              } else {
                // clone the following covered cell of reference
                // row.
                // added by Daisy because of a bug in demo4
                cellElement = (TableTableCellElementBase) cellElement.getNextSibling();
                i += cellElement.getTableNumberColumnsRepeatedAttribute();
                int newColumnSpanNumber = newCellEle.getTableNumberColumnsSpannedAttribute();
                while ((cellElement != null) && (cellElement instanceof TableCoveredTableCellElement)
                    && (newColumnSpanNumber > 1)) {
                  TableCoveredTableCellElement newCoveredCellElement = (TableCoveredTableCellElement) cellElement
                      .cloneNode(true);
                  cleanCell(newCoveredCellElement);
                  newRow.appendChild(newCoveredCellElement);
                  i += cellElement.getTableNumberColumnsRepeatedAttribute();
                  cellElement = (TableTableCellElementBase) cellElement.getNextSibling();
View Full Code Here

          TableTableCellElement newCellEle = (TableTableCellElement) aCellEle.cloneNode(true);
          cleanCell(newCellEle);
          aRow.appendChild(newCellEle);
        } else { // cover more rows
          aCellEle.setTableNumberRowsSpannedAttribute(coveredHeigth + 1);
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) OdfXMLFactory
              .newOdfElement((OdfFileDom) mTableElement.getOwnerDocument(), OdfName.newName(
                  OdfDocumentNamespace.TABLE, "covered-table-cell"));
          if (columnsRepeatedNumber > 1) {
            newCellEle.setTableNumberColumnsRepeatedAttribute(columnsRepeatedNumber);
          } else {
            newCellEle.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
          }
          aRow.appendChild(newCellEle);
        }

        coveredLength = aCellEle.getTableNumberColumnsSpannedAttribute() - columnsRepeatedNumber;
        i = i + columnsRepeatedNumber;
      } else {
        TableCoveredTableCellElement aCellEle = (TableCoveredTableCellElement) refCell.getOdfElement();
        if (coveredLength >= 1) {
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) aCellEle.cloneNode(true);
          aRow.appendChild(newCellEle);
          coveredLength -= newCellEle.getTableNumberColumnsRepeatedAttribute();
        } else {
          TableTableCellElement coveredCell = (TableTableCellElement) refCell.getCoverCell().getOdfElement();
          TableTableCellElement newCellEle = (TableTableCellElement) coveredCell.cloneNode(true);
          cleanCell(newCellEle);
          newCellEle.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-rows-spanned");
          aRow.appendChild(newCellEle);
          coveredLength = coveredCell.getTableNumberColumnsSpannedAttribute() - columnsRepeatedNumber;
        }
        i = i + columnsRepeatedNumber;
      }
View Full Code Here

          || (coverPosCellEle != null && refCell.getOdfElement() == coverPosCellEle)) {
        if (coverRefCellEle == null) {
          coverRefCellEle = (TableTableCellElement) refCell.getOdfElement();
          coverRefCell = refCell;
        }
        TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) OdfXMLFactory.newOdfElement(
            (OdfFileDom) ownerTable.getOdfElement().getOwnerDocument(), OdfName.newName(
                OdfDocumentNamespace.TABLE, "covered-table-cell"));
        insertCellElementBefore(getOdfElement(), positionCell.getOdfElement(), newCellEle, count);
        // the first cover line
        if (refCell.getRowIndex() == coverRefCell.getRowIndex()) {
          coverRefCell.setColumnSpannedNumber(coverRefCell.getColumnSpannedNumber() + count);
        }
      } else if (coverRefCellEle != null) {
        // This is a cover cell

        // the first cover line
        if (refCell.getRowIndex() == coverRefCell.getRowIndex()) {
          TableTableCellElement newCellEle = (TableTableCellElement) coverRefCellEle.cloneNode(true);
          cleanCell(newCellEle);
          insertCellElementBefore(getOdfElement(), positionCell.getOdfElement(), newCellEle, count);
        } else { // the second and other cover line
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) refCell.getOdfElement()
              .cloneNode(true);
          newCellEle.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
          insertCellElementBefore(getOdfElement(), positionCell.getOdfElement(), newCellEle, count);
        }
      } else if ((refCell.getOdfElement() == positionCell.getOdfElement())
          && (refCell.getColumnsRepeatedNumber() > 1)) {
        // repeated number
View Full Code Here

          || (coverPosCellEle != null && refCell.getOdfElement() == coverPosCellEle)) {
        if (coverRefCellEle == null) {
          coverRefCellEle = (TableTableCellElement) refCell.getOdfElement();
          coverRefCell = refCell;
        }
        TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) OdfXMLFactory.newOdfElement(
            (OdfFileDom) ownerTable.getOdfElement().getOwnerDocument(), OdfName.newName(
                OdfDocumentNamespace.TABLE, "covered-table-cell"));
        getOdfElement().insertBefore(newCellEle, positionCell.getOdfElement());
        if (refCell.getRowIndex() == coverRefCell.getRowIndex()) {
          // the first cover line
          coverRefCell.setColumnSpannedNumber(coverRefCell.getColumnSpannedNumber() + 1);
        }
        newCell = ownerTable.getCellInstance(newCellEle, 0, 0);
      } else if (coverRefCellEle != null) {
        // This is cover cell
        if (refCell.getRowIndex() == coverRefCell.getRowIndex()) {
          // the first cover line
          TableTableCellElement newCellEle = (TableTableCellElement) coverRefCellEle.cloneNode(true);
          cleanCell(newCellEle);
          getOdfElement().insertBefore(newCellEle, positionCell.getOdfElement());
          newCell = ownerTable.getCellInstance(newCellEle, 0, 0);
        } else { // the second and other cover line
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) refCell.getOdfElement()
              .cloneNode(true);
          newCellEle.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
          getOdfElement().insertBefore(newCellEle, positionCell.getOdfElement());
          newCell = ownerTable.getCellInstance(newCellEle, 0, 0);
        }
      } else if ((refCell.getOdfElement() == positionCell.getOdfElement())
          && (refCell.getColumnsRepeatedNumber() > 1)) {
View Full Code Here

          TableTableCellElement newCellEle = (TableTableCellElement) aCellEle.cloneNode(true);
          cleanCell(newCellEle);
          aRow.appendChild(newCellEle);
        } else { //cover more rows
          aCellEle.setTableNumberRowsSpannedAttribute(coveredHeigth + 1);
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) OdfXMLFactory.newOdfElement(
              (OdfFileDom) mTableElement.getOwnerDocument(),
              OdfName.newName(OdfDocumentNamespace.TABLE, "covered-table-cell"));
          newCellEle.setTableNumberColumnsRepeatedAttribute(refCell.getColumnsRepeatedNumber());
          aRow.appendChild(newCellEle);
        }

        coveredLength = aCellEle.getTableNumberColumnsSpannedAttribute() - refCell.getColumnsRepeatedNumber();
        i = i + refCell.getColumnsRepeatedNumber();
      } else {
        TableCoveredTableCellElement aCellEle = (TableCoveredTableCellElement) refCell.getOdfElement();
        if (coveredLength >= 1) {
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) aCellEle.cloneNode(true);
          aRow.appendChild(newCellEle);
          coveredLength -= newCellEle.getTableNumberColumnsRepeatedAttribute();
        } else {
          TableTableCellElement coveredCell = (TableTableCellElement) refCell.getCoverCell().getOdfElement();
          TableTableCellElement newCellEle = (TableTableCellElement) coveredCell.cloneNode(true);
          cleanCell(newCellEle);
          newCellEle.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-rows-spanned");
          aRow.appendChild(newCellEle);

          coveredLength = coveredCell.getTableNumberColumnsSpannedAttribute() - refCell.getColumnsRepeatedNumber();
        }
        i = i + refCell.getColumnsRepeatedNumber();
View Full Code Here

      {
        if (coverRefCellEle == null) {
          coverRefCellEle = (TableTableCellElement) refCell.getOdfElement();
          coverRefCell = refCell;
        }
        TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) OdfXMLFactory.newOdfElement(
            (OdfFileDom) ownerTable.getOdfElement().getOwnerDocument(),
            OdfName.newName(OdfDocumentNamespace.TABLE, "covered-table-cell"));
        insertCellElementBefore(getOdfElement(), positionCell.getOdfElement(), newCellEle, count);
        if (refCell.getRowIndex() == coverRefCell.getRowIndex()) //the first cover line
        {
          coverRefCell.setColumnSpannedNumber(coverRefCell.getColumnSpannedNumber() + count);
        }
      } else if (coverRefCellEle != null) //is cover cell
      {
        if (refCell.getRowIndex() == coverRefCell.getRowIndex()) { //the first cover line
          TableTableCellElement newCellEle = (TableTableCellElement) coverRefCellEle.cloneNode(true);
          cleanCell(newCellEle);
          insertCellElementBefore(getOdfElement(), positionCell.getOdfElement(), newCellEle, count);
        } else { //the second and other cover line
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) refCell.getOdfElement().cloneNode(true);
          newCellEle.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
          insertCellElementBefore(getOdfElement(), positionCell.getOdfElement(), newCellEle, count);
        }
      } else if ((refCell.getOdfElement() == positionCell.getOdfElement())
          && (refCell.getColumnsRepeatedNumber() > 1)) //repeated number
      {
View Full Code Here

      {
        if (coverRefCellEle == null) {
          coverRefCellEle = (TableTableCellElement) refCell.getOdfElement();
          coverRefCell = refCell;
        }
        TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) OdfXMLFactory.newOdfElement(
            (OdfFileDom) ownerTable.getOdfElement().getOwnerDocument(),
            OdfName.newName(OdfDocumentNamespace.TABLE, "covered-table-cell"));
        getOdfElement().insertBefore(newCellEle, positionCell.getOdfElement());
        if (refCell.getRowIndex() == coverRefCell.getRowIndex()) //the first cover line
        {
          coverRefCell.setColumnSpannedNumber(coverRefCell.getColumnSpannedNumber() + 1);
        }
        newCell = ownerTable.getCellInstance(newCellEle, 0, 0);
      } else if (coverRefCellEle != null) //is cover cell
      {
        if (refCell.getRowIndex() == coverRefCell.getRowIndex()) { //the first cover line
          TableTableCellElement newCellEle = (TableTableCellElement) coverRefCellEle.cloneNode(true);
          cleanCell(newCellEle);
          getOdfElement().insertBefore(newCellEle, positionCell.getOdfElement());
          newCell = ownerTable.getCellInstance(newCellEle, 0, 0);
        } else { //the second and other cover line
          TableCoveredTableCellElement newCellEle = (TableCoveredTableCellElement) refCell.getOdfElement().cloneNode(true);
          newCellEle.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-repeated");
          getOdfElement().insertBefore(newCellEle, positionCell.getOdfElement());
          newCell = ownerTable.getCellInstance(newCellEle, 0, 0);
        }
      } else if ((refCell.getOdfElement() == positionCell.getOdfElement())
          && (refCell.getColumnsRepeatedNumber() > 1)) //repeated number
View Full Code Here

            firstCell.appendContentFrom(cellBase);
            //change the cell in the first column of cell range to covered cell
            if ((j == mnStartColumn) && (cellBase.getOdfElement() instanceof TableTableCellElement)) {
              //change the normal cell to be the covered cell
              TableTableCellElement firstColumnCell = (TableTableCellElement) cellBase.getOdfElement();
              TableCoveredTableCellElement coveredCell = (TableCoveredTableCellElement) OdfXMLFactory.newOdfElement(
                  (OdfFileDom) firstColumnCell.getOwnerDocument(),
                  OdfName.newName(OdfDocumentNamespace.TABLE, "covered-table-cell"));
              OdfTableRow parentRow = cellBase.getTableRow();
              parentRow.getOdfElement().insertBefore(coveredCell, firstColumnCell);
              parentRow.getOdfElement().removeChild(firstColumnCell);
            }
          }
        }
      }
      List<Long> widthList = getCellRangeWidthList();
      long nCellRangeWidth = widthList.get(widthList.size() - 1).longValue() - widthList.get(0).longValue();
      maOwnerTable.removeColumnsByIndex(mnStartColumn + 1, mnEndColumn - mnStartColumn);
      OdfTableColumn firstColumn = maOwnerTable.getColumnByIndex(mnStartColumn);
      firstColumn.setWidth(nCellRangeWidth);
      mnEndColumn = mnStartColumn;
      return;
    } //if the cell range covered all the table column, the merged row can be removed
    else if (rowCount > (mnEndRow - mnStartRow + 1)
        && colCount == (mnEndColumn - mnStartColumn + 1)
        && (mnEndRow - mnStartRow) > 0) {
      //the first cell, set the span attribute
      if (firstCell.getOdfElement() instanceof TableTableCellElement) {
        TableTableCellElement firstCellElement = (TableTableCellElement) (firstCell.getOdfElement());
        firstCellElement.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-rows-spanned");
        firstCellElement.setTableNumberColumnsSpannedAttribute(Integer.valueOf(mnEndColumn - mnStartColumn + 1));
        firstCellElement.setOfficeValueTypeAttribute(OfficeValueTypeAttribute.Value.STRING.toString());
      }
      //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 = mnStartRow; i < mnEndRow + 1; i++) {
        for (int j = mnStartColumn; j < mnEndColumn + 1; j++) {
          OdfTableCell cellBase = maOwnerTable.getCellByPosition(j, i);
          if (j != mnStartColumn || i != mnStartRow) {
            //append content to first cell
            firstCell.appendContentFrom(cellBase);
            //change the cell in the first row of cell range to covered cell
            if ((i == mnStartRow) && (cellBase.getOdfElement() instanceof TableTableCellElement)) {
              //change the normal cell to be the covered cell
              TableTableCellElement firstRowCell = (TableTableCellElement) cellBase.getOdfElement();
              TableCoveredTableCellElement coveredCell = (TableCoveredTableCellElement) OdfXMLFactory.newOdfElement(
                  (OdfFileDom) firstRowCell.getOwnerDocument(),
                  OdfName.newName(OdfDocumentNamespace.TABLE, "covered-table-cell"));
              OdfTableRow parentRow = cellBase.getTableRow();
              parentRow.getOdfElement().insertBefore(coveredCell, firstRowCell);
              parentRow.getOdfElement().removeChild(firstRowCell);
            }
          }
        }
      }
      maOwnerTable.removeRowsByIndex(mnStartRow + 1, mnEndRow - mnStartRow);
      mnEndRow = mnStartRow;
      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) {
        TableTableCellElement firstCellElement = (TableTableCellElement) (firstCell.getOdfElement());
        firstCellElement.setTableNumberColumnsSpannedAttribute(Integer.valueOf(mnEndColumn - mnStartColumn + 1));
        firstCellElement.setTableNumberRowsSpannedAttribute(Integer.valueOf(mnEndRow - mnStartRow + 1));
        firstCellElement.setOfficeValueTypeAttribute(OfficeValueTypeAttribute.Value.STRING.toString());
      }
      //the other cell, set to the covered cell
      for (int i = mnStartRow; i < mnEndRow + 1; i++) {
        for (int j = mnStartColumn; j < mnEndColumn + 1; j++) {
          OdfTableCell cellBase = maOwnerTable.getCellByPosition(j, i);
          if (j != mnStartColumn || i != mnStartRow) {
            if (cellBase.getOdfElement() instanceof TableTableCellElement) {
              //change the normal cell to be the covered cell
              TableTableCellElement cell = (TableTableCellElement) cellBase.getOdfElement();
              TableCoveredTableCellElement coveredCell = (TableCoveredTableCellElement) OdfXMLFactory.newOdfElement(
                  (OdfFileDom) cell.getOwnerDocument(),
                  OdfName.newName(OdfDocumentNamespace.TABLE, "covered-table-cell"));

              OdfTableRow parentRow = cellBase.getTableRow();
              parentRow.getOdfElement().insertBefore(coveredCell, cell);
              //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().intValue();
              int num = (mnEndColumn - j + 1) - repeatedNum;
              if (num >= 0) {
                coveredCell.setTableNumberColumnsRepeatedAttribute(Integer.valueOf(repeatedNum));
                parentRow.getOdfElement().removeChild(cell);
              } else {
                coveredCell.setTableNumberColumnsRepeatedAttribute(new Integer(mnEndColumn - j + 1));
                cell.setTableNumberColumnsRepeatedAttribute(Integer.valueOf(-num));
              }

            } else if (cellBase.getOdfElement() instanceof TableCoveredTableCellElement) {
              try {
View Full Code Here

TOP

Related Classes of org.odftoolkit.odfdom.dom.element.table.TableCoveredTableCellElement

Copyright © 2018 www.massapicom. 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.