Examples with RowRecord org.apache.poi.hssf.record.RowRecord used on opensource projects

Example 6 with RowRecord

use of org.apache.poi.hssf.record.RowRecord in project poi by apache.

the class TestMissingRecordAwareHSSFListener method testMissingRowRecords.

public void testMissingRowRecords() {
    openNormal();
    // We have rows 0, 1, 2, 20 and 21
    int row0 = -1;
    for (int i = 0; i < r.length; i++) {
        if (r[i] instanceof RowRecord) {
            RowRecord rr = (RowRecord) r[i];
            if (rr.getRowNumber() == 0) {
                row0 = i;
            }
        }
    }
    assertTrue(row0 > -1);
    // Following row 0, we should have 1, 2, then dummy, then 20+21+22
    assertTrue(r[row0] instanceof RowRecord);
    assertTrue(r[row0 + 1] instanceof RowRecord);
    assertTrue(r[row0 + 2] instanceof RowRecord);
    assertTrue(r[row0 + 3] instanceof MissingRowDummyRecord);
    assertTrue(r[row0 + 4] instanceof MissingRowDummyRecord);
    assertTrue(r[row0 + 5] instanceof MissingRowDummyRecord);
    assertTrue(r[row0 + 6] instanceof MissingRowDummyRecord);
    // ...
    assertTrue(r[row0 + 18] instanceof MissingRowDummyRecord);
    assertTrue(r[row0 + 19] instanceof MissingRowDummyRecord);
    assertTrue(r[row0 + 20] instanceof RowRecord);
    assertTrue(r[row0 + 21] instanceof RowRecord);
    assertTrue(r[row0 + 22] instanceof RowRecord);
    // Check things had the right row numbers
    RowRecord rr;
    rr = (RowRecord) r[row0 + 2];
    assertEquals(2, rr.getRowNumber());
    rr = (RowRecord) r[row0 + 20];
    assertEquals(20, rr.getRowNumber());
    rr = (RowRecord) r[row0 + 21];
    assertEquals(21, rr.getRowNumber());
    MissingRowDummyRecord mr;
    mr = (MissingRowDummyRecord) r[row0 + 3];
    assertEquals(3, mr.getRowNumber());
    mr = (MissingRowDummyRecord) r[row0 + 4];
    assertEquals(4, mr.getRowNumber());
    mr = (MissingRowDummyRecord) r[row0 + 5];
    assertEquals(5, mr.getRowNumber());
    mr = (MissingRowDummyRecord) r[row0 + 18];
    assertEquals(18, mr.getRowNumber());
    mr = (MissingRowDummyRecord) r[row0 + 19];
    assertEquals(19, mr.getRowNumber());
}

Example 7 with RowRecord

use of org.apache.poi.hssf.record.RowRecord in project poi by apache.

the class TestHSSFRow method testLastAndFirstColumns_bug46654.

@Test
public void testLastAndFirstColumns_bug46654() throws IOException {
    int ROW_IX = 10;
    int COL_IX = 3;
    HSSFWorkbook workbook = new HSSFWorkbook();
    HSSFSheet sheet = workbook.createSheet("Sheet1");
    RowRecord rowRec = new RowRecord(ROW_IX);
    rowRec.setFirstCol((short) 2);
    rowRec.setLastCol((short) 5);
    BlankRecord br = new BlankRecord();
    br.setRow(ROW_IX);
    br.setColumn((short) COL_IX);
    sheet.getSheet().addValueRecord(ROW_IX, br);
    HSSFRow row = new HSSFRow(workbook, sheet, rowRec);
    HSSFCell cell = row.createCellFromRecord(br);
    if (row.getFirstCellNum() == 2 && row.getLastCellNum() == 5) {
        fail("Identified bug 46654a");
    }
    assertEquals(COL_IX, row.getFirstCellNum());
    assertEquals(COL_IX + 1, row.getLastCellNum());
    row.removeCell(cell);
    assertEquals(-1, row.getFirstCellNum());
    assertEquals(-1, row.getLastCellNum());
    workbook.close();
}

Example 8 with RowRecord

use of org.apache.poi.hssf.record.RowRecord in project poi by apache.

the class InternalSheet method addRow.

/**
     * Adds a row record to the sheet
     *
     * <P>
     * This method is "loc" sensitive.  Meaning you need to set LOC to where you
     * want it to start searching.  If you don't know do this: setLoc(getDimsLoc).
     * When adding several rows you can just start at the last one by leaving loc
     * at what this sets it to.
     *
     * @param row the row record to be added
     */
public void addRow(RowRecord row) {
    if (log.check(POILogger.DEBUG))
        log.log(POILogger.DEBUG, "addRow ");
    DimensionsRecord d = _dimensions;
    if (row.getRowNumber() >= d.getLastRow()) {
        d.setLastRow(row.getRowNumber() + 1);
    }
    if (row.getRowNumber() < d.getFirstRow()) {
        d.setFirstRow(row.getRowNumber());
    }
    //If the row exists remove it, so that any cells attached to the row are removed
    RowRecord existingRow = _rowsAggregate.getRow(row.getRowNumber());
    if (existingRow != null) {
        _rowsAggregate.removeRow(existingRow);
    }
    _rowsAggregate.insertRow(row);
    if (log.check(POILogger.DEBUG))
        log.log(POILogger.DEBUG, "exit addRow");
}

Example 9 with RowRecord

use of org.apache.poi.hssf.record.RowRecord in project poi by apache.

the class MissingRecordAwareHSSFListener method processRecord.

public void processRecord(Record record) {
    int thisRow;
    int thisColumn;
    CellValueRecordInterface[] expandedRecords = null;
    if (record instanceof CellValueRecordInterface) {
        CellValueRecordInterface valueRec = (CellValueRecordInterface) record;
        thisRow = valueRec.getRow();
        thisColumn = valueRec.getColumn();
    } else {
        if (record instanceof StringRecord) {
            //it contains only cashed result of the previous FormulaRecord evaluation
            childListener.processRecord(record);
            return;
        }
        thisRow = -1;
        thisColumn = -1;
        switch(record.getSid()) {
            // the workbook
            case BOFRecord.sid:
                BOFRecord bof = (BOFRecord) record;
                if (bof.getType() == BOFRecord.TYPE_WORKBOOK || bof.getType() == BOFRecord.TYPE_WORKSHEET) {
                    // Reset the row and column counts - new workbook / worksheet
                    resetCounts();
                }
                break;
            case RowRecord.sid:
                RowRecord rowrec = (RowRecord) record;
                // If there's a jump in rows, fire off missing row records
                if (lastRowRow + 1 < rowrec.getRowNumber()) {
                    for (int i = (lastRowRow + 1); i < rowrec.getRowNumber(); i++) {
                        MissingRowDummyRecord dr = new MissingRowDummyRecord(i);
                        childListener.processRecord(dr);
                    }
                }
                // Record this as the last row we saw
                lastRowRow = rowrec.getRowNumber();
                lastCellColumn = -1;
                break;
            case SharedFormulaRecord.sid:
                // SharedFormulaRecord occurs after the first FormulaRecord of the cell range.
                // There are probably (but not always) more cell records after this
                // - so don't fire off the LastCellOfRowDummyRecord yet
                childListener.processRecord(record);
                return;
            case MulBlankRecord.sid:
                // These appear in the middle of the cell records, to
                //  specify that the next bunch are empty but styled
                // Expand this out into multiple blank cells
                MulBlankRecord mbr = (MulBlankRecord) record;
                expandedRecords = RecordFactory.convertBlankRecords(mbr);
                break;
            case MulRKRecord.sid:
                // This is multiple consecutive number cells in one record
                // Exand this out into multiple regular number cells
                MulRKRecord mrk = (MulRKRecord) record;
                expandedRecords = RecordFactory.convertRKRecords(mrk);
                break;
            case NoteRecord.sid:
                NoteRecord nrec = (NoteRecord) record;
                thisRow = nrec.getRow();
                thisColumn = nrec.getColumn();
                break;
            default:
                break;
        }
    }
    // First part of expanded record handling
    if (expandedRecords != null && expandedRecords.length > 0) {
        thisRow = expandedRecords[0].getRow();
        thisColumn = expandedRecords[0].getColumn();
    }
    //  dummy end-of-row records
    if (thisRow != lastCellRow && thisRow > 0) {
        if (lastCellRow == -1)
            lastCellRow = 0;
        for (int i = lastCellRow; i < thisRow; i++) {
            int cols = -1;
            if (i == lastCellRow) {
                cols = lastCellColumn;
            }
            childListener.processRecord(new LastCellOfRowDummyRecord(i, cols));
        }
    }
    // final dummy end-of-row record
    if (lastCellRow != -1 && lastCellColumn != -1 && thisRow == -1) {
        childListener.processRecord(new LastCellOfRowDummyRecord(lastCellRow, lastCellColumn));
        lastCellRow = -1;
        lastCellColumn = -1;
    }
    //  the column counter
    if (thisRow != lastCellRow) {
        lastCellColumn = -1;
    }
    //  the dummy cell records
    if (lastCellColumn != thisColumn - 1) {
        for (int i = lastCellColumn + 1; i < thisColumn; i++) {
            childListener.processRecord(new MissingCellDummyRecord(thisRow, i));
        }
    }
    // Next part of expanded record handling
    if (expandedRecords != null && expandedRecords.length > 0) {
        thisColumn = expandedRecords[expandedRecords.length - 1].getColumn();
    }
    // Update cell and row counts as needed
    if (thisColumn != -1) {
        lastCellColumn = thisColumn;
        lastCellRow = thisRow;
    }
    // Pass along the record(s)
    if (expandedRecords != null && expandedRecords.length > 0) {
        for (CellValueRecordInterface r : expandedRecords) {
            childListener.processRecord((Record) r);
        }
    } else {
        childListener.processRecord(record);
    }
}

Example 10 with RowRecord

use of org.apache.poi.hssf.record.RowRecord in project poi by apache.

the class HSSFSheet method setPropertiesFromSheet.

/**
     * used internally to set the properties given a Sheet object
     */
private void setPropertiesFromSheet(InternalSheet sheet) {
    RowRecord row = sheet.getNextRow();
    while (row != null) {
        createRowFromRecord(row);
        row = sheet.getNextRow();
    }
    Iterator<CellValueRecordInterface> iter = sheet.getCellValueIterator();
    long timestart = System.currentTimeMillis();
    if (log.check(POILogger.DEBUG)) {
        log.log(DEBUG, "Time at start of cell creating in HSSF sheet = ", Long.valueOf(timestart));
    }
    HSSFRow lastrow = null;
    // Add every cell to its row
    while (iter.hasNext()) {
        CellValueRecordInterface cval = iter.next();
        long cellstart = System.currentTimeMillis();
        HSSFRow hrow = lastrow;
        if (hrow == null || hrow.getRowNum() != cval.getRow()) {
            hrow = getRow(cval.getRow());
            lastrow = hrow;
            if (hrow == null) {
                /* we removed this check, see bug 47245 for the discussion around this
                    // Some tools (like Perl module Spreadsheet::WriteExcel - bug 41187) skip the RowRecords
                    // Excel, OpenOffice.org and GoogleDocs are all OK with this, so POI should be too.
                    if (rowRecordsAlreadyPresent) {
                        // if at least one row record is present, all should be present.
                        throw new RuntimeException("Unexpected missing row when some rows already present");
                    }*/
                // create the row record on the fly now.
                RowRecord rowRec = new RowRecord(cval.getRow());
                sheet.addRow(rowRec);
                hrow = createRowFromRecord(rowRec);
            }
        }
        if (log.check(POILogger.DEBUG)) {
            if (cval instanceof Record) {
                log.log(DEBUG, "record id = " + Integer.toHexString(((Record) cval).getSid()));
            } else {
                log.log(DEBUG, "record = " + cval);
            }
        }
        hrow.createCellFromRecord(cval);
        if (log.check(POILogger.DEBUG)) {
            log.log(DEBUG, "record took ", Long.valueOf(System.currentTimeMillis() - cellstart));
        }
    }
    if (log.check(POILogger.DEBUG)) {
        log.log(DEBUG, "total sheet cell creation took ", Long.valueOf(System.currentTimeMillis() - timestart));
    }
}