private void pushCellValue(XlsBiffBlankCell cell)
        {
            double _dValue;

            LogManager.Log(this).Debug("pushCellValue {0}", cell.ID);
            switch (cell.ID)
            {
            case BIFFRECORDTYPE.BOOLERR:
                if (cell.ReadByte(7) == 0)
                {
                    m_cellsValues[cell.ColumnIndex] = cell.ReadByte(6) != 0;
                }
                break;

            case BIFFRECORDTYPE.BOOLERR_OLD:
                if (cell.ReadByte(8) == 0)
                {
                    m_cellsValues[cell.ColumnIndex] = cell.ReadByte(7) != 0;
                }
                break;

            case BIFFRECORDTYPE.INTEGER:
            case BIFFRECORDTYPE.INTEGER_OLD:
                m_cellsValues[cell.ColumnIndex] = ((XlsBiffIntegerCell)cell).Value;
                break;

            case BIFFRECORDTYPE.NUMBER:
            case BIFFRECORDTYPE.NUMBER_OLD:

                _dValue = ((XlsBiffNumberCell)cell).Value;

                m_cellsValues[cell.ColumnIndex] = !ConvertOaDate ?
                                                  _dValue : tryConvertOADateTime(_dValue, cell.XFormat);

                LogManager.Log(this).Debug("VALUE: {0}", _dValue);
                break;

            case BIFFRECORDTYPE.LABEL:
            case BIFFRECORDTYPE.LABEL_OLD:
            case BIFFRECORDTYPE.RSTRING:

                m_cellsValues[cell.ColumnIndex] = ((XlsBiffLabelCell)cell).Value;

                LogManager.Log(this).Debug("VALUE: {0}", m_cellsValues[cell.ColumnIndex]);
                break;

            case BIFFRECORDTYPE.LABELSST:
                string tmp = m_globals.SST.GetString(((XlsBiffLabelSSTCell)cell).SSTIndex);
                LogManager.Log(this).Debug("VALUE: {0}", tmp);
                m_cellsValues[cell.ColumnIndex] = tmp;
                break;

            case BIFFRECORDTYPE.RK:

                _dValue = ((XlsBiffRKCell)cell).Value;

                m_cellsValues[cell.ColumnIndex] = !ConvertOaDate ?
                                                  _dValue : tryConvertOADateTime(_dValue, cell.XFormat);

                LogManager.Log(this).Debug("VALUE: {0}", _dValue);
                break;

            case BIFFRECORDTYPE.MULRK:

                XlsBiffMulRKCell _rkCell = (XlsBiffMulRKCell)cell;
                for (ushort j = cell.ColumnIndex; j <= _rkCell.LastColumnIndex; j++)
                {
                    _dValue = _rkCell.GetValue(j);
                    LogManager.Log(this).Debug("VALUE[{1}]: {0}", _dValue, j);
                    m_cellsValues[j] = !ConvertOaDate ? _dValue : tryConvertOADateTime(_dValue, _rkCell.GetXF(j));
                }

                break;

            case BIFFRECORDTYPE.BLANK:
            case BIFFRECORDTYPE.BLANK_OLD:
            case BIFFRECORDTYPE.MULBLANK:
                // Skip blank cells

                break;

            case BIFFRECORDTYPE.FORMULA:
            case BIFFRECORDTYPE.FORMULA_OLD:

                object _oValue = ((XlsBiffFormulaCell)cell).Value;

                if (null != _oValue && _oValue is FORMULAERROR)
                {
                    _oValue = null;
                }
                else
                {
                    m_cellsValues[cell.ColumnIndex] = !ConvertOaDate ?
                                                      _oValue : tryConvertOADateTime(_oValue, (ushort)(cell.XFormat));  //date time offset
                }

                break;

            default:
                break;
            }
        }
Beispiel #2
0
        private void pushCellValue(XlsBiffBlankCell cell)
        {
            double num;

            switch (cell.ID)
            {
            case BIFFRECORDTYPE.RK:
                num = ((XlsBiffRKCell)cell).Value;
                this.m_cellsValues[cell.ColumnIndex] = !this.m_ConvertOADate ? num : this.tryConvertOADateTime(num, cell.XFormat);
                return;

            case BIFFRECORDTYPE.FORMULA:
            case BIFFRECORDTYPE.FORMULA_OLD:
            {
                object obj2 = ((XlsBiffFormulaCell)cell).Value;
                if ((obj2 != null) && (obj2 is FORMULAERROR))
                {
                    obj2 = null;
                    return;
                }
                this.m_cellsValues[cell.ColumnIndex] = !this.m_ConvertOADate ? obj2 : this.tryConvertOADateTime(obj2, cell.XFormat);
                break;
            }

            case BIFFRECORDTYPE.BLANK:
            case BIFFRECORDTYPE.BLANK_OLD:
            case BIFFRECORDTYPE.MULBLANK:
                break;

            case BIFFRECORDTYPE.INTEGER:
            case BIFFRECORDTYPE.INTEGER_OLD:
                this.m_cellsValues[cell.ColumnIndex] = ((XlsBiffIntegerCell)cell).Value;
                return;

            case BIFFRECORDTYPE.NUMBER:
            case BIFFRECORDTYPE.NUMBER_OLD:
                num = ((XlsBiffNumberCell)cell).Value;
                this.m_cellsValues[cell.ColumnIndex] = !this.m_ConvertOADate ? num : this.tryConvertOADateTime(num, cell.XFormat);
                return;

            case BIFFRECORDTYPE.LABEL:
            case BIFFRECORDTYPE.LABEL_OLD:
            case BIFFRECORDTYPE.RSTRING:
                this.m_cellsValues[cell.ColumnIndex] = ((XlsBiffLabelCell)cell).Value;
                return;

            case BIFFRECORDTYPE.BOOLERR:
                if (cell.ReadByte(7) != 0)
                {
                    break;
                }
                this.m_cellsValues[cell.ColumnIndex] = cell.ReadByte(6) != 0;
                return;

            case BIFFRECORDTYPE.LABELSST:
            {
                string str = this.m_globals.SST.GetString(((XlsBiffLabelSSTCell)cell).SSTIndex);
                this.m_cellsValues[cell.ColumnIndex] = str;
                return;
            }

            case BIFFRECORDTYPE.BOOLERR_OLD:
                if (cell.ReadByte(8) != 0)
                {
                    break;
                }
                this.m_cellsValues[cell.ColumnIndex] = cell.ReadByte(7) != 0;
                return;

            case BIFFRECORDTYPE.MULRK:
            {
                XlsBiffMulRKCell cell2 = (XlsBiffMulRKCell)cell;
                for (ushort i = cell.ColumnIndex; i <= cell2.LastColumnIndex; i = (ushort)(i + 1))
                {
                    num = cell2.GetValue(i);
                    this.m_cellsValues[i] = !this.m_ConvertOADate ? num : this.tryConvertOADateTime(num, cell2.GetXF(i));
                }
                return;
            }

            default:
                return;
            }
        }
        private bool ReadWorksheet(XlsWorksheet sheet)
        {
            m_stream.Seek((int)sheet.DataOffset, SeekOrigin.Begin);

            XlsBiffBOF bof = m_stream.Read() as XlsBiffBOF;

            if (bof == null || bof.Type != BIFFTYPE.Worksheet)
            {
                return(false);
            }

            XlsBiffIndex idx = m_stream.Read() as XlsBiffIndex;

            if (null == idx)
            {
                return(false);
            }

            idx.IsV8 = IsV8();

            DataTable dt = new DataTable(sheet.Name);

            XlsBiffRecord     trec;
            XlsBiffDimensions dims = null;

            do
            {
                trec = m_stream.Read();
                if (trec.ID == BIFFRECORDTYPE.DIMENSIONS)
                {
                    dims = (XlsBiffDimensions)trec;
                    break;
                }
            } while (trec != null && trec.ID != BIFFRECORDTYPE.ROW);

            int maxCol = 256;

            if (dims != null)
            {
                dims.IsV8        = IsV8();
                maxCol           = dims.LastColumn - 1;
                sheet.Dimensions = dims;
            }

            InitializeColumns(ref dt, maxCol);

            sheet.Data = dt;

            uint maxRow = idx.LastExistingRow;

            if (idx.LastExistingRow <= idx.FirstExistingRow)
            {
                return(true);
            }

            dt.BeginLoadData();

            for (int i = 0; i < maxRow; i++)
            {
                dt.Rows.Add(dt.NewRow());
            }

            uint[] dbCellAddrs = idx.DbCellAddresses;

            for (int i = 0; i < dbCellAddrs.Length; i++)
            {
                XlsBiffDbCell dbCell = (XlsBiffDbCell)m_stream.ReadAt((int)dbCellAddrs[i]);
                XlsBiffRow    row    = null;
                int           offs   = dbCell.RowAddress;

                do
                {
                    row = m_stream.ReadAt(offs) as XlsBiffRow;
                    if (row == null)
                    {
                        break;
                    }

                    offs += row.Size;
                } while (null != row);

                while (true)
                {
                    XlsBiffRecord rec = m_stream.ReadAt(offs);
                    offs += rec.Size;
                    if (rec is XlsBiffDbCell)
                    {
                        break;
                    }
                    if (rec is XlsBiffEOF)
                    {
                        break;
                    }
                    XlsBiffBlankCell cell = rec as XlsBiffBlankCell;

                    if (cell == null)
                    {
                        continue;
                    }
                    if (cell.ColumnIndex >= maxCol)
                    {
                        continue;
                    }
                    if (cell.RowIndex > maxRow)
                    {
                        continue;
                    }

                    string _sValue;
                    double _dValue;

                    switch (cell.ID)
                    {
                    case BIFFRECORDTYPE.INTEGER:
                    case BIFFRECORDTYPE.INTEGER_OLD:
                        dt.Rows[cell.RowIndex][cell.ColumnIndex] = ((XlsBiffIntegerCell)cell).Value.ToString();
                        break;

                    case BIFFRECORDTYPE.NUMBER:
                    case BIFFRECORDTYPE.NUMBER_OLD:

                        _dValue = ((XlsBiffNumberCell)cell).Value;

                        if ((_sValue = TryConvertOADate(_dValue, cell.XFormat)) != null)
                        {
                            dt.Rows[cell.RowIndex][cell.ColumnIndex] = _sValue;
                        }
                        else
                        {
                            dt.Rows[cell.RowIndex][cell.ColumnIndex] = _dValue;
                        }

                        break;

                    case BIFFRECORDTYPE.LABEL:
                    case BIFFRECORDTYPE.LABEL_OLD:
                    case BIFFRECORDTYPE.RSTRING:
                        dt.Rows[cell.RowIndex][cell.ColumnIndex] = ((XlsBiffLabelCell)cell).Value;
                        break;

                    case BIFFRECORDTYPE.LABELSST:
                        string tmp = m_globals.SST.GetString(((XlsBiffLabelSSTCell)cell).SSTIndex);
                        dt.Rows[cell.RowIndex][cell.ColumnIndex] = tmp;
                        break;

                    case BIFFRECORDTYPE.RK:

                        _dValue = ((XlsBiffRKCell)cell).Value;

                        if ((_sValue = TryConvertOADate(_dValue, cell.XFormat)) != null)
                        {
                            dt.Rows[cell.RowIndex][cell.ColumnIndex] = _sValue;
                        }
                        else
                        {
                            dt.Rows[cell.RowIndex][cell.ColumnIndex] = _dValue;
                        }

                        break;

                    case BIFFRECORDTYPE.MULRK:

                        XlsBiffMulRKCell _rkCell = (XlsBiffMulRKCell)cell;
                        for (ushort j = cell.ColumnIndex; j <= _rkCell.LastColumnIndex; j++)
                        {
                            dt.Rows[cell.RowIndex][j] = _rkCell.GetValue(j);
                        }

                        break;

                    case BIFFRECORDTYPE.BLANK:
                    case BIFFRECORDTYPE.BLANK_OLD:
                    case BIFFRECORDTYPE.MULBLANK:
                        // Skip blank cells

                        break;

                    case BIFFRECORDTYPE.FORMULA:
                    case BIFFRECORDTYPE.FORMULA_OLD:

                        object _oValue = ((XlsBiffFormulaCell)cell).Value;

                        if (null != _oValue && _oValue is FORMULAERROR)
                        {
                            _oValue = null;
                        }

                        if (null != _oValue &&
                            (_sValue = TryConvertOADate(_oValue, cell.XFormat)) != null)
                        {
                            dt.Rows[cell.RowIndex][cell.ColumnIndex] = _sValue;
                        }
                        else
                        {
                            dt.Rows[cell.RowIndex][cell.ColumnIndex] = _oValue;
                        }

                        break;

                    default:
                        break;
                    }
                }
            }

            dt.EndLoadData();

            if (m_PromoteToColumns)
            {
                RemapColumnsNames(ref dt, dt.Rows[0].ItemArray);
                dt.Rows.RemoveAt(0);
                dt.AcceptChanges();
            }

            return(true);
        }
        private void pushCellValue(XlsBiffBlankCell cell)
        {
            double _dValue;

            switch (cell.ID)
            {
            case BIFFRECORDTYPE.INTEGER:
            case BIFFRECORDTYPE.INTEGER_OLD:
                m_cellsValues[cell.ColumnIndex] = ((XlsBiffIntegerCell)cell).Value;
                break;

            case BIFFRECORDTYPE.NUMBER:
            case BIFFRECORDTYPE.NUMBER_OLD:

                _dValue = ((XlsBiffNumberCell)cell).Value;

                m_cellsValues[cell.ColumnIndex] = !m_ConvertOADate ?
                                                  _dValue : tryConvertOADateTime(_dValue, cell.XFormat);

                break;

            case BIFFRECORDTYPE.LABEL:
            case BIFFRECORDTYPE.LABEL_OLD:
            case BIFFRECORDTYPE.RSTRING:
                m_cellsValues[cell.ColumnIndex] = ((XlsBiffLabelCell)cell).Value;
                break;

            case BIFFRECORDTYPE.LABELSST:
                string tmp = m_globals.SST.GetString(((XlsBiffLabelSSTCell)cell).SSTIndex);
                m_cellsValues[cell.ColumnIndex] = tmp;
                break;

            case BIFFRECORDTYPE.RK:

                _dValue = ((XlsBiffRKCell)cell).Value;

                m_cellsValues[cell.ColumnIndex] = !m_ConvertOADate ?
                                                  _dValue : tryConvertOADateTime(_dValue, cell.XFormat);

                break;

            case BIFFRECORDTYPE.MULRK:

                XlsBiffMulRKCell _rkCell = (XlsBiffMulRKCell)cell;
                for (ushort j = cell.ColumnIndex; j <= _rkCell.LastColumnIndex; j++)
                {
                    m_cellsValues[j] = _rkCell.GetValue(j);
                }

                break;

            case BIFFRECORDTYPE.BLANK:
            case BIFFRECORDTYPE.BLANK_OLD:
            case BIFFRECORDTYPE.MULBLANK:
                // Skip blank cells

                break;

            case BIFFRECORDTYPE.FORMULA:
            case BIFFRECORDTYPE.FORMULA_OLD:

                object _oValue = ((XlsBiffFormulaCell)cell).Value;

                if (null != _oValue && _oValue is FORMULAERROR)
                {
                    _oValue = null;
                }
                else
                {
                    m_cellsValues[cell.ColumnIndex] = !m_ConvertOADate ?
                                                      _oValue : tryConvertOADateTime(_oValue, (ushort)(cell.XFormat + 75));  //date time offset
                }

                break;

            default:
                break;
            }
        }