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

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

257
258
259
260
261
262
263
264
265
266
267
268
        // column count
        int legendcount = headerCells.getLength() - 1;
        legends = new String[legendcount];
        for (int i = 1; i < legendcount + 1; i++) {
          TableTableCellElement headerCell = (TableTableCellElement) headerCells.item(i);
          legends[i - 1] = ((OdfTextParagraph) headerCell.getElementsByTagName(
              TextPElement.ELEMENT_NAME.getQName()).item(0)).getTextContent();
        }

        rows = (TableTableRowsElement) table
            .getElementsByTagName(TableTableRowsElement.ELEMENT_NAME.getQName()).item(0);
View Full Code Here
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
    column.setTableNumberColumnsRepeatedAttribute(new Integer(numColumns));
    headerRow.newTableTableCellElement(0.0, "string");
    Object[] labelCellRange = getLabelCellRange();
    Object[] valueCellRange = getValueCellRange();
    for (int i = 0; i < numColumns; i++) {
      TableTableCellElement cell = headerRow.newTableTableCellElement(0.0, "string");
      cell.setOfficeValueTypeAttribute(OfficeValueTypeAttribute.Value.STRING.toString());
      String[] cellContents = dataset.getLocalTableFirstRow();
      OdfTextParagraph paragraph = (OdfTextParagraph) cell.newTextPElement();

      if (isFirstRowAsLabel && !isRowAsSeries) {
        if ((String) labelCellRange[i] != null) {
          paragraph.setTextIdAttribute((String) labelCellRange[i]);
        }
      }
      if (isFirstRowAsLabel && isRowAsSeries && i == 0) {
        if ((String) getTableCellRange() != null) {
          paragraph.setTextIdAttribute(getTableCellRange());
        }
      }
      if (cellContents[i] != null) {
        paragraph.setTextContent(cellContents[i]);
      } else {
        paragraph.setTextContent("");
      }
    }

    // create table rows
    Double[][] cellValues = dataset.getLocalTableData();
    for (int i = 0; i < numRows; i++) {
      TableTableRowElement row = rows.newTableTableRowElement();
      TableTableCellElement nameCell = row.newTableTableCellElement(0.0, "string");
      nameCell.setOfficeValueTypeAttribute(OfficeValueTypeAttribute.Value.STRING.toString());
      OdfTextParagraph paragraph = (OdfTextParagraph) nameCell.newTextPElement();
      String[] cellContents = dataset.getLocalTableFirstColumn();
      if (cellContents[i] != null) {
        if (isFirstColumnAsLabel) {
          if (isRowAsSeries) {
            paragraph.setTextIdAttribute((String) labelCellRange[i]);
          }
          if (!isRowAsSeries && i == 0) {
            paragraph.setTextIdAttribute(getTableCellRange());
          }
        }
        paragraph.setTextContent(cellContents[i]);
      } else {
        paragraph.setTextContent("");
      }
      for (int j = 0; j < numColumns; j++) {
        TableTableCellElement cell = row.newTableTableCellElement(0.0, "string");
        cell.setOfficeValueTypeAttribute(OfficeValueTypeAttribute.Value.FLOAT.toString());
        if (cellValues[i][j] != null) {
          cell.setOfficeValueAttribute(cellValues[i][j]);
          OdfTextParagraph paragraph1 = (OdfTextParagraph) cell.newTextPElement();
          paragraph1.setTextContent(cellValues[i][j].toString());
          if (isRowAsSeries && j == 0) {
            paragraph1.setTextIdAttribute((String) valueCellRange[i]);
          }
          if (!isRowAsSeries && i == 0) {
            paragraph1.setTextIdAttribute((String) valueCellRange[j]);
          }
        } else {
          cell.setOfficeValueAttribute(new Double(Double.NaN));
          OdfTextParagraph paragraph1 = (OdfTextParagraph) cell.newTextPElement();
          paragraph1.setTextContent("1.#NAN");
          if (isRowAsSeries && j == 0) {
            paragraph1.setTextIdAttribute((String) valueCellRange[i]);
          }
          if (!isRowAsSeries && i == 0) {
View Full Code Here
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
  private void updateTableCells(Document odfdoc, String tablename,
      double[] values, String[] labels) {
    int i = 0, j = 0;
    TableTableRowElement td;
    TableTableCellElement cell;
    OdfFileDom dom;
    NodeList tableList;
    TableTableElement myTable;
    NodeList lst;
    OdfTextParagraph p;
    OfficeSpreadsheetElement spreadsheet = null;

    try {
      dom = odfdoc.getContentDom();
      tableList = dom.getElementsByTagNameNS(
          OdfDocumentNamespace.TABLE.getUri(), "table");
      spreadsheet = (OfficeSpreadsheetElement) dom.getElementsByTagNameNS(
          OdfDocumentNamespace.OFFICE.getUri(), "spreadsheet").item(0);

      i = 0;
      if (tableList.getLength() > 0) {
        for (; i < tableList.getLength(); i++) {
          String currentname = ((TableTableElement) tableList.item(i)).getTableNameAttribute();
          if (currentname == null) {
            currentname = "";
          }
          if (currentname.equalsIgnoreCase(tablename)) {
            break;
          }
        }
      }
      if (i < tableList.getLength()) //table with the specific table name is found
      {
        myTable = (TableTableElement) tableList.item(i);
      } else { //table with the specific table name is not found. Create table
        myTable = dom.newOdfElement(TableTableElement.class);
        myTable.setTableNameAttribute(tablename);
        spreadsheet.appendChild(myTable);
      }

      lst = myTable.getElementsByTagNameNS(OdfDocumentNamespace.TABLE.getUri(), "table-row");
      if (lst.getLength() == 0) { //the first table row is not existed. Create table row
        td = dom.newOdfElement(TableTableRowElement.class);
        cell = dom.newOdfElement(TableTableCellElement.class);
        p = dom.newOdfElement(OdfTextParagraph.class);
        if (tablename.startsWith("Memory")) {
          p.setTextContent("memory(b)");
        } else {
          p.setTextContent("time(ms)");
        }
        td.appendChild(cell);
        cell.appendChild(p);
        myTable.appendChild(td);
      } else {
        td = (TableTableRowElement) lst.item(0); //the first table row is existed.
      }
      cell = dom.newOdfElement(TableTableCellElement.class);
      td.appendChild(cell);
      p = dom.newOdfElement(OdfTextParagraph.class);
      p.setTextContent(testTag);
      cell.appendChild(p);


      for (i = 1; i < values.length + 1; i++) {
        if (i < lst.getLength()) { //table row is existed
          td = (TableTableRowElement) lst.item(i);
        } else { //table row is not existed.
          td = dom.newOdfElement(TableTableRowElement.class);
          myTable.appendChild(td);
          //append first cell with labels
          cell = dom.newOdfElement(TableTableCellElement.class);
          td.appendChild(cell);
          p = dom.newOdfElement(OdfTextParagraph.class);
          p.setTextContent(labels[j]);
          cell.appendChild(p);
        }
        cell = dom.newOdfElement(TableTableCellElement.class);
        cell.setOfficeValueTypeAttribute("float");
        cell.setOfficeValueAttribute(new Double(values[j]));
        p = dom.newOdfElement(OdfTextParagraph.class);
        p.setTextContent(values[j] + "");
        cell.appendChild(p);
        td.appendChild(cell);
        j++;
      }
    } catch (Exception e) {
      LOG.log(Level.SEVERE, null, e);
View Full Code Here
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
    try {
      int i = 0, rowindex, columnindex;
      char ch;
      TableTableRowElement td;
      TableTableCellElement cell;
      OdfFileDom sheetContent;
      NodeList tableList, rowList, cellList;
      TableTableElement table;
      Vector<Double> series;
      double value;

      // get table
      sheetContent = spreadsheet.getContentDom();
      tableList = sheetContent.getElementsByTagNameNS(OdfNamespace.newNamespace(OdfDocumentNamespace.TABLE)
          .toString(), "table");
      while (!sheettable.equals(((TableTableElement) tableList.item(i)).getTableNameAttribute()))
        i++;
      table = (TableTableElement) tableList.item(i);
      rowList = table.getElementsByTagNameNS(OdfNamespace.newNamespace(OdfDocumentNamespace.TABLE).toString(),
          "table-row");

      // get data, begin for(beginRow,endRow)
      for (i = beginRow; i <= endRow; i++) {
        rowindex = bFirstRowAsLabel ? (i - beginRow - 1) : (i - beginRow);
        td = (TableTableRowElement) rowList.item(i - 1);
        cellList = td.getElementsByTagNameNS(OdfNamespace.newNamespace(OdfDocumentNamespace.TABLE).toString(),
            "table-cell");
        Map<Integer, TableTableCellElement> cellIndexMap = new HashMap<Integer, TableTableCellElement>();
        for (int index = 0, cellNum = 0; (cellNum < cellList.getLength()) && (index <= (endColumn - 'A')); cellNum++) {
          TableTableCellElement item = (TableTableCellElement) cellList.item(cellNum);
          int repeatedCount = item.getTableNumberColumnsRepeatedAttribute()
              * item.getTableNumberColumnsSpannedAttribute();
          int tmpIndex = index + repeatedCount;
          if (tmpIndex >= (beginColumn - 'A')) {
            if ((beginColumn - 'A') > index) {
              index = beginColumn - 'A';
            }
View Full Code Here
1901
1902
1903
1904
1905
1906
1907
1908
1909
1910
1911
1912
1913
        if (i == startRowi && j == startColumni) {
          continue;
        }
        Cell cell = aRow.getCellByIndex(j);
        if (cell.getOdfElement() instanceof TableTableCellElement) {
          TableTableCellElement cellEle = (TableTableCellElement) cell.getOdfElement();
          if ((cellEle.getTableNumberColumnsSpannedAttribute() + j > startColumni)
              && (cellEle.getTableNumberRowsSpannedAttribute() + i > startRowi)) {
            return mOwnerTable.getCellInstance(cellEle, 0, 0);
          }
        }
      }
    }
View Full Code Here
213
214
215
216
217
218
219
220
221
222
      OdfStyle cellStyleWithoutBorder = styles.newStyle(OdfStyleFamily.TableCell);
      cellStyleWithoutBorder.setProperty(StyleTableCellPropertiesElement.Border, "none");
      cellStyleWithoutBorder.removeProperty(StyleTableCellPropertiesElement.Padding);
      String cellStyleName = cellStyleWithoutBorder.getStyleNameAttribute();
      for (int i = 0; i < cells.getLength(); i++) {
        TableTableCellElement cell = (TableTableCellElement) cells.item(i);
        cell.setStyleName(cellStyleName);
      }
    }
  }
View Full Code Here
214
215
216
217
218
219
220
221
222
223
      OdfStyle cellStyleWithoutBorder = styles.newStyle(OdfStyleFamily.TableCell);
      cellStyleWithoutBorder.setProperty(StyleTableCellPropertiesElement.Border, "none");
      cellStyleWithoutBorder.removeProperty(StyleTableCellPropertiesElement.Padding);
      String cellStyleName = cellStyleWithoutBorder.getStyleNameAttribute();
      for (int i = 0; i < cells.getLength(); i++) {
        TableTableCellElement cell = (TableTableCellElement) cells.item(i);
        cell.setStyleName(cellStyleName);
      }
    }
  }
View Full Code Here
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
    //rather than merge to a big cell.
    if (rowCount == (mnEndRow - mnStartRow + 1)
        && colCount == (mnEndColumn - mnStartColumn + 1)
        && !mbSpreadsheet) {
      if (firstCell.getOdfElement() instanceof TableTableCellElement) {
        TableTableCellElement firstCellElement = (TableTableCellElement) (firstCell.getOdfElement());
        firstCellElement.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-spanned");
        firstCellElement.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-rows-spanned");
        firstCellElement.setOfficeValueTypeAttribute(OfficeValueTypeAttribute.Value.STRING.toString());
      }
      //just copy the text of the other cells to this first cell
      for (int i = mnStartRow; i < mnEndRow + 1; i++) {
        for (int j = mnStartColumn; j < mnEndColumn + 1; j++) {
          Cell cellBase = maOwnerTable.getCellByPosition(j, i);
          if (j != mnStartColumn || i != mnStartRow) {
            //copy the content of this cell to the first cell
            firstCell.appendContentFrom(cellBase);
          }
        }
      }
      maOwnerTable.removeRowsByIndex(1, maOwnerTable.getRowCount() - 1);
      maOwnerTable.removeColumnsByIndex(1, maOwnerTable.getColumnCount() - 1);
      Column firstColumn = maOwnerTable.getColumnByIndex(0);
      firstColumn.setWidth(maOwnerTable.getWidth());
      mnEndRow = mnStartRow;
      mnEndColumn = mnStartColumn;
      return;
    } //if the cell range covered all the table row, and the merged column > 1
    //the merged column can be removed
    else if (rowCount == (mnEndRow - mnStartRow + 1)
        && colCount > (mnEndColumn - mnStartColumn + 1)
        && (mnEndColumn - mnStartColumn) > 0) {
      //the first cell, set the span attribute
      if (firstCell.getOdfElement() instanceof TableTableCellElement) {
        TableTableCellElement firstCellElement = (TableTableCellElement) (firstCell.getOdfElement());
        firstCellElement.removeAttributeNS(OdfDocumentNamespace.TABLE.getUri(), "number-columns-spanned");
        firstCellElement.setTableNumberRowsSpannedAttribute(Integer.valueOf(mnEndRow - mnStartRow + 1));
        firstCellElement.setOfficeValueTypeAttribute(OfficeValueTypeAttribute.Value.STRING.toString());
      }
      //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 = mnStartRow; i < mnEndRow + 1; i++) {
        for (int j = mnStartColumn; j < mnEndColumn + 1; j++) {
          Cell cellBase = maOwnerTable.getCellByPosition(j, i);
          if (j != mnStartColumn || i != mnStartRow) {
            //append content to first cell
            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"));
              Row parentRow = cellBase.getTableRow();
              parentRow.getOdfElement().insertBefore(coveredCell, firstColumnCell);
              parentRow.getOdfElement().removeChild(firstColumnCell);
            }
          }
        }
      }
      List<Double> widthList = getCellRangeWidthList();
      double nCellRangeWidth = widthList.get(widthList.size() - 1) - widthList.get(0);
      maOwnerTable.removeColumnsByIndex(mnStartColumn + 1, mnEndColumn - mnStartColumn);
      Column 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++) {
          Cell 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"));
              Row 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) {
        //first cell number columns repeated attribute may > 1.
        firstCell.splitRepeatedCells();
        TableTableCellElement firstCellElement = (TableTableCellElement) (firstCell.getOdfElement());
        firstCellElement.setTableNumberColumnsSpannedAttribute(mnEndColumn - mnStartColumn + 1);
        firstCellElement.setTableNumberRowsSpannedAttribute(mnEndRow - mnStartRow + 1);
      }
      //the other cell, set to the covered cell
      for (int i = mnStartRow; i < mnEndRow + 1; i++) {
        for (int j = mnStartColumn; j < mnEndColumn + 1; j++) {
          Cell 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"));

              TableTableRowElement parentRowEle = cellBase.getTableRow().getOdfElement();
              parentRowEle.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();
              int num = (mnEndColumn - j + 1) - repeatedNum;
              if (num >= 0) {
                if(repeatedNum > 1){
                  coveredCell.setTableNumberColumnsRepeatedAttribute(repeatedNum);
                }
                parentRowEle.removeChild(cell);
              } else {
                int tableNumberColumnsRepeatedValue = mnEndColumn - j + 1;
                if(tableNumberColumnsRepeatedValue > 1){
                  coveredCell.setTableNumberColumnsRepeatedAttribute(tableNumberColumnsRepeatedValue);
                }
                cell.setTableNumberColumnsRepeatedAttribute(-num);
              }
            } else if (cellBase.getOdfElement() instanceof TableCoveredTableCellElement) {
              try {
                //copy the content of this cell to the first cell
                firstCell.appendContentFrom(cellBase);
View Full Code Here
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
          OdfName.newName(OdfDocumentNamespace.TABLE, "table-header-rows"));
      for (int i = 0; i < headerRowNumber; i++) {
        TableTableRowElement aRow = (TableTableRowElement) OdfXMLFactory.newOdfElement(dom, OdfName.newName(
            OdfDocumentNamespace.TABLE, "table-row"));
        for (int j = 0; j < numCols; j++) {
          TableTableCellElement aCell = (TableTableCellElement) OdfXMLFactory.newOdfElement(dom, OdfName
              .newName(OdfDocumentNamespace.TABLE, "table-cell"));
          if (isTextDocument) {
            if ((j + 1 == numCols) && (i == 0)) {
              aCell.setStyleName(righttopStyle.getStyleNameAttribute());
            } else if (i == 0) {
              aCell.setStyleName(lefttopStyle.getStyleNameAttribute());
            } else if ((j + 1 == numCols) && (i > 0)) {
              aCell.setStyleName(rightbottomStyle.getStyleNameAttribute());
            } else {
              aCell.setStyleName(leftbottomStyle.getStyleNameAttribute());
            }
          }
          aRow.appendChild(aCell);
        }
        headerrows.appendChild(aRow);
      }
      newTEle.appendChild(headerrows);
    }

    // 3.2 create common row elements
    for (int i = headerRowNumber; i < numRows; i++) {
      TableTableRowElement aRow = (TableTableRowElement) OdfXMLFactory.newOdfElement(dom, OdfName.newName(
          OdfDocumentNamespace.TABLE, "table-row"));
      for (int j = 0; j < numCols; j++) {
        TableTableCellElement aCell = (TableTableCellElement) OdfXMLFactory.newOdfElement(dom, OdfName.newName(
            OdfDocumentNamespace.TABLE, "table-cell"));
        if (isTextDocument) {
          if ((j + 1 == numCols) && (i == 0)) {
            aCell.setStyleName(righttopStyle.getStyleNameAttribute());
          } else if (i == 0) {
            aCell.setStyleName(lefttopStyle.getStyleNameAttribute());
          } else if ((j + 1 == numCols) && (i > 0)) {
            aCell.setStyleName(rightbottomStyle.getStyleNameAttribute());
          } else {
            aCell.setStyleName(leftbottomStyle.getStyleNameAttribute());
          }
        }
        aRow.appendChild(aCell);
      }
      newTEle.appendChild(aRow);
View Full Code Here
645
646
647
648
649
650
651
652
653
654
655
656
    }

    protected DrawFrameElement getChartFrame() throws Exception {
      OdfContentDom contentDom2 = sdoc.getContentDom();
      DrawFrameElement drawFrame = contentDom2.newOdfElement(DrawFrameElement.class);
      TableTableCellElement lastCell = (TableTableCellElement) contentDom2.getXPath().evaluate(
          "//table:table-cell[last()]", contentDom2, XPathConstants.NODE);
      lastCell.appendChild(drawFrame);
      drawFrame.removeAttribute("text:anchor-type");
      this.drawFrame = drawFrame;
      return drawFrame;
    }
View Full Code Here
TOP

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

  • org.bazu.jotex.OdtEPUBlisher
  • org.odftoolkit.odfdom.doc.CreateChildrenElementsTest
  • org.odftoolkit.odfdom.doc.CreateTableTest
  • org.odftoolkit.odfdom.doc.OdfDocument
  • org.odftoolkit.odfdom.doc.table.OdfTable
  • org.odftoolkit.odfdom.doc.table.OdfTableCell
  • org.odftoolkit.odfdom.doc.table.OdfTableCellRange
  • org.odftoolkit.odfdom.doc.table.OdfTableRow
  • org.odftoolkit.odfdom.doc.TableTest
  • org.odftoolkit.odfdom.dom.attribute.office.OfficeValueTypeAttribute
    • 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.