/// <summary>
        /// Process an HSSF Record. Called when a record occurs in an HSSF file.
        /// </summary>
        /// <param name="record"></param>
        public void ProcessRecord(Record record)
        {
            int thisRow;
            int thisColumn;
            CellValueRecordInterface[] expandedRecords = null;

            if (record is CellValueRecordInterface)
            {
                CellValueRecordInterface valueRec = (CellValueRecordInterface)record;
                thisRow = valueRec.Row;
                thisColumn = valueRec.Column;
            }
            else
            {
                thisRow = -1;
                thisColumn = -1;

                switch (record.Sid)
                {
                    // the BOFRecord can represent either the beginning of a sheet or the workbook
                    case BOFRecord.sid:
                        BOFRecord bof = (BOFRecord)record;
                        if (bof.Type == BOFRecord.TYPE_WORKBOOK || bof.Type == BOFRecord.TYPE_WORKSHEET)
                        {
                            // Reset the row and column counts - new workbook / worksheet
                            ResetCounts();
                        }
                        break;
                    case RowRecord.sid:
                        RowRecord rowrec = (RowRecord)record;
                        //Console.WriteLine("Row " + rowrec.RowNumber + " found, first column at "
                        //        + rowrec.GetFirstCol() + " last column at " + rowrec.GetLastCol());

                        // If there's a jump in rows, fire off missing row records
                        if (lastRowRow + 1 < rowrec.RowNumber)
                        {
                            for (int i = (lastRowRow + 1); i < rowrec.RowNumber; i++)
                            {
                                MissingRowDummyRecord dr = new MissingRowDummyRecord(i);
                                childListener.ProcessRecord(dr);
                            }
                        }

                        // Record this as the last row we saw
                        lastRowRow = rowrec.RowNumber;
                        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.Row;
                        thisColumn = nrec.Column;
                        break;
                    default:
                        //Console.WriteLine(record.GetClass());
                        break;
                }
            }

            // First part of expanded record handling
            if (expandedRecords != null && expandedRecords.Length > 0)
            {
                thisRow = expandedRecords[0].Row;
                thisColumn = expandedRecords[0].Column;
            }

            // If we're on cells, and this cell isn't in the same
            //  row as the last one, then fire the 
            //  dummy end-of-row records
            if (thisRow != lastCellRow && lastCellRow > -1)
            {
                for (int i = lastCellRow; i < thisRow; i++)
                {
                    int cols = -1;
                    if (i == lastCellRow)
                    {
                        cols = lastCellColumn;
                    }
                    childListener.ProcessRecord(new LastCellOfRowDummyRecord(i, cols));
                }
            }

            // If we've just finished with the cells, then fire the
            // final dummy end-of-row record
            if (lastCellRow != -1 && lastCellColumn != -1 && thisRow == -1)
            {
                childListener.ProcessRecord(new LastCellOfRowDummyRecord(lastCellRow, lastCellColumn));

                lastCellRow = -1;
                lastCellColumn = -1;
            }

            // If we've moved onto a new row, the ensure we re-set
            //  the column counter
            if (thisRow != lastCellRow)
            {
                lastCellColumn = -1;
            }

            // If there's a gap in the cells, then fire
            //  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].Column;
            }


            // 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)
            {
                foreach (CellValueRecordInterface r in expandedRecords)
                {
                    childListener.ProcessRecord((Record)r);
                }
            }
            else
            {
                childListener.ProcessRecord(record);
            }
        }
        /// <summary>
        /// Process an HSSF Record. Called when a record occurs in an HSSF file.
        /// </summary>
        /// <param name="record"></param>
        public void ProcessRecord(Record record)
        {
            int thisRow = -1;
            int thisColumn = -1;

            switch (record.Sid)
            {
                // the BOFRecord can represent either the beginning of a sheet or the workbook
                case BOFRecord.sid:
                    BOFRecord bof = (BOFRecord)record;
                    if (bof.Type == BOFRecord.TYPE_WORKBOOK)
                    {
                        // ReSet the row and column counts - new workbook
                        lastSeenRow = -1;
                        lastSeenColumn = -1;
                        //Console.WriteLine("Encountered workbook");
                    }
                    else if (bof.Type == BOFRecord.TYPE_WORKSHEET)
                    {
                        // ReSet the row and column counts - new sheet
                        lastSeenRow = -1;
                        lastSeenColumn = -1;
                        //Console.WriteLine("Encountered sheet reference");
                    }
                    break;
                case BoundSheetRecord.sid:
                    BoundSheetRecord bsr = (BoundSheetRecord)record;
                    //Console.WriteLine("New sheet named: " + bsr.GetSheetname());
                    break;
                case RowRecord.sid:
                    RowRecord rowrec = (RowRecord)record;
                    //Console.WriteLine("Row " + rowrec.RowNumber + " found, first column at "
                    //        + rowrec.GetFirstCol() + " last column at " + rowrec.GetLastCol());

                    // If there's a jump in rows, fire off missing row records
                    if (lastSeenRow + 1 < rowrec.RowNumber)
                    {
                        for (int i = (lastSeenRow + 1); i < rowrec.RowNumber; i++)
                        {
                            MissingRowDummyRecord dr = new MissingRowDummyRecord(i);
                            childListener.ProcessRecord(dr);
                        }
                    }

                    // Record this as the last row we saw
                    lastSeenRow = rowrec.RowNumber;
                    break;


                // These are all the "cell" records

                case BlankRecord.sid:
                    BlankRecord brec = (BlankRecord)record;
                    thisRow = brec.Row;
                    thisColumn = brec.Column;
                    break;
                case BoolErrRecord.sid:
                    BoolErrRecord berec = (BoolErrRecord)record;
                    thisRow = berec.Row;
                    thisColumn = berec.Column;
                    break;
                case FormulaRecord.sid:
                    FormulaRecord frec = (FormulaRecord)record;
                    thisRow = frec.Row;
                    thisColumn = frec.Column;
                    break;
                case LabelRecord.sid:
                    LabelRecord lrec = (LabelRecord)record;
                    thisRow = lrec.Row;
                    thisColumn = lrec.Column;
                    //Console.WriteLine("Cell found containing String "
                    //        + " at row " + lrec.Row + " and column " + lrec.Column);
                    break;
                case LabelSSTRecord.sid:
                    LabelSSTRecord lsrec = (LabelSSTRecord)record;
                    thisRow = lsrec.Row;
                    thisColumn = lsrec.Column;
                    //Console.WriteLine("Cell found containing String "
                    //        + " at row " + lsrec.Row + " and column " + lsrec.Column);
                    break;
                case NoteRecord.sid:
                    NoteRecord nrec = (NoteRecord)record;
                    thisRow = nrec.Row;
                    thisColumn = nrec.Column;
                    break;
                case NumberRecord.sid:
                    NumberRecord numrec = (NumberRecord)record;
                    thisRow = numrec.Row;
                    thisColumn = numrec.Column;
                    //Console.WriteLine("Cell found with value " + numrec.GetValue()
                    //        + " at row " + numrec.Row + " and column " + numrec.Column);
                    break;
                case RKRecord.sid:
                    RKRecord rkrec = (RKRecord)record;
                    thisRow = rkrec.Row;
                    thisColumn = rkrec.Column;
                    break;
                default:
                    //Console.WriteLine(record.GetClass());
                    break;
            }

            // Do we need to fire dummy end-of-row records?
            if (thisRow != lastSeenRow && lastSeenRow > -1)
            {
                for (int i = lastSeenRow; i < thisRow; i++)
                {
                    int cols = -1;
                    if (i == lastSeenRow)
                    {
                        cols = lastSeenColumn;
                    }
                    LastCellOfRowDummyRecord r = new LastCellOfRowDummyRecord(i, cols);
                    childListener.ProcessRecord(r);
                }
            }
            // If we've finished with the columns, then fire the final
            //  dummy end-of-row record
            if (lastSeenRow != -1 && lastSeenColumn != -1 && thisRow == -1)
            {
                LastCellOfRowDummyRecord r = new LastCellOfRowDummyRecord(lastSeenRow, lastSeenColumn);
                childListener.ProcessRecord(r);

                lastSeenRow = -1;
                lastSeenColumn = -1;
            }

            // If we've moved onto a new row, the ensure we re-Set
            //  the column counter
            if (thisRow != lastSeenRow)
            {
                lastSeenColumn = -1;
            }

            // Do we need to fire dummy cell records?
            if (lastSeenColumn != (thisColumn - 1))
            {
                for (int i = lastSeenColumn + 1; i < thisColumn; i++)
                {
                    MissingCellDummyRecord r = new MissingCellDummyRecord(thisRow, i);
                    childListener.ProcessRecord(r);
                }
            }

            // Update cell and row counts if doing cells
            if (thisColumn != -1)
            {
                lastSeenRow = thisRow;
                lastSeenColumn = thisColumn;
            }

            childListener.ProcessRecord(record);
        }