Example #1
0
        public static Record Read(Stream stream)
        {
            Record record = Record.ReadBase(stream);

            switch (record.Type)
            {
            case RecordType.BOF:
                return(new BOF(record));

            case RecordType.ARRAY:
                return(new ARRAY(record));

            case RecordType.BACKUP:
                return(new BACKUP(record));

            case RecordType.BLANK:
                return(new BLANK(record));

            case RecordType.BOOKBOOL:
                return(new BOOKBOOL(record));

            case RecordType.BOTTOMMARGIN:
                return(new BOTTOMMARGIN(record));

            case RecordType.BOUNDSHEET:
                return(new BOUNDSHEET(record));

            case RecordType.CALCCOUNT:
                return(new CALCCOUNT(record));

            case RecordType.CALCMODE:
                return(new CALCMODE(record));

            case RecordType.CODEPAGE:
                return(new CODEPAGE(record));

            case RecordType.DIMENSIONS:
                return(new DIMENSIONS(record));

            case RecordType.MULBLANK:
                return(new MULBLANK(record));

            case RecordType.MULRK:
                return(new MULRK(record));

            case RecordType.ROW:
                return(new ROW(record));

            case RecordType.RSTRING:
                return(new RSTRING(record));

            case RecordType.SST:
                return(new SST(record));

            case RecordType.CONTINUE:
                return(new CONTINUE(record));

            case RecordType.FORMULA:
                return(new FORMULA(record));

            case RecordType.XF:
                return(new XF(record));

            case RecordType.BITMAP:
                return(new BITMAP(record));

            case RecordType.OBJ:
                return(new OBJ(record));

            case RecordType.DATEMODE:
                return(new DATEMODE(record));

            case RecordType.MSODRAWINGGROUP:
                return(new MSODRAWINGGROUP(record));

            case RecordType.MSODRAWING:
                return(new MSODRAWING(record));

            case RecordType.MSODRAWINGSELECTION:
                return(new MSODRAWINGSELECTION(record));

            case RecordType.STRING:
                return(new STRING(record));

            case RecordType.EOF:
                return(new EOF(record));

            case RecordType.BOOLERR:
                return(new BOOLERR(record));

            case RecordType.LABELSST:
                return(new LABELSST(record));

            case RecordType.NUMBER:
                return(new NUMBER(record));

            case RecordType.RK:
                return(new RK(record));

            case RecordType.LABEL:
                return(new LABEL(record));

            case RecordType.DBCELL:
                return(new DBCELL(record));

            case RecordType.EXTSST:
                return(new EXTSST(record));

            case RecordType.WINDOW1:
                return(new WINDOW1(record));

            case RecordType.FORMAT:
                return(new FORMAT(record));

            case RecordType.FONT:
                return(new FONT(record));

            case RecordType.COLINFO:
                return(new COLINFO(record));

            case RecordType.PALETTE:
                return(new PALETTE(record));

            case RecordType.STANDARDWIDTH:
                return(new STANDARDWIDTH(record));

            case RecordType.DEFCOLWIDTH:
                return(new DEFCOLWIDTH(record));

            default:
                return(record);
            }
        }
Example #2
0
        public static Record Read(Stream stream)
        {
            Record record = Record.ReadBase(stream);
            ushort type   = record.Type;
            Record result;

            if (type <= 146)
            {
                if (type <= 49)
                {
                    if (type <= 13)
                    {
                        if (type == 6)
                        {
                            result = new FORMULA(record);
                            return(result);
                        }
                        switch (type)
                        {
                        case 10:
                            result = new EOF(record);
                            return(result);

                        case 12:
                            result = new CALCCOUNT(record);
                            return(result);

                        case 13:
                            result = new CALCMODE(record);
                            return(result);
                        }
                    }
                    else
                    {
                        if (type == 34)
                        {
                            result = new DATEMODE(record);
                            return(result);
                        }
                        if (type == 41)
                        {
                            result = new BOTTOMMARGIN(record);
                            return(result);
                        }
                        if (type == 49)
                        {
                            result = new FONT(record);
                            return(result);
                        }
                    }
                }
                else
                {
                    if (type <= 93)
                    {
                        switch (type)
                        {
                        case 60:
                            result = new CONTINUE(record);
                            return(result);

                        case 61:
                            result = new WINDOW1(record);
                            return(result);

                        case 62:
                        case 63:
                        case 65:
                            break;

                        case 64:
                            result = new BACKUP(record);
                            return(result);

                        case 66:
                            result = new CODEPAGE(record);
                            return(result);

                        default:
                            if (type == 85)
                            {
                                result = new DEFCOLWIDTH(record);
                                return(result);
                            }
                            if (type == 93)
                            {
                                result = new OBJ(record);
                                return(result);
                            }
                            break;
                        }
                    }
                    else
                    {
                        if (type == 125)
                        {
                            result = new COLINFO(record);
                            return(result);
                        }
                        if (type == 133)
                        {
                            result = new BOUNDSHEET(record);
                            return(result);
                        }
                        if (type == 146)
                        {
                            result = new PALETTE(record);
                            return(result);
                        }
                    }
                }
            }
            else
            {
                if (type <= 237)
                {
                    if (type <= 190)
                    {
                        if (type == 153)
                        {
                            result = new STANDARDWIDTH(record);
                            return(result);
                        }
                        switch (type)
                        {
                        case 189:
                            result = new MULRK(record);
                            return(result);

                        case 190:
                            result = new MULBLANK(record);
                            return(result);
                        }
                    }
                    else
                    {
                        switch (type)
                        {
                        case 214:
                            result = new RSTRING(record);
                            return(result);

                        case 215:
                            result = new DBCELL(record);
                            return(result);

                        case 216:
                        case 217:
                            break;

                        case 218:
                            result = new BOOKBOOL(record);
                            return(result);

                        default:
                            if (type == 224)
                            {
                                result = new XF(record);
                                return(result);
                            }
                            switch (type)
                            {
                            case 233:
                                result = new BITMAP(record);
                                return(result);

                            case 235:
                                result = new MSODRAWINGGROUP(record);
                                return(result);

                            case 236:
                                result = new MSODRAWING(record);
                                return(result);

                            case 237:
                                result = new MSODRAWINGSELECTION(record);
                                return(result);
                            }
                            break;
                        }
                    }
                }
                else
                {
                    if (type <= 545)
                    {
                        switch (type)
                        {
                        case 252:
                            result = new SST(record);
                            return(result);

                        case 253:
                            result = new LABELSST(record);
                            return(result);

                        case 254:
                            break;

                        case 255:
                            result = new EXTSST(record);
                            return(result);

                        default:
                            switch (type)
                            {
                            case 512:
                                result = new DIMENSIONS(record);
                                return(result);

                            case 513:
                                result = new BLANK(record);
                                return(result);

                            case 514:
                            case 516:
                            case 518:
                                break;

                            case 515:
                                result = new NUMBER(record);
                                return(result);

                            case 517:
                                result = new BOOLERR(record);
                                return(result);

                            case 519:
                                result = new STRING(record);
                                return(result);

                            case 520:
                                result = new ROW(record);
                                return(result);

                            default:
                                if (type == 545)
                                {
                                    result = new ARRAY(record);
                                    return(result);
                                }
                                break;
                            }
                            break;
                        }
                    }
                    else
                    {
                        if (type == 638)
                        {
                            result = new RK(record);
                            return(result);
                        }
                        if (type == 1054)
                        {
                            result = new FORMAT(record);
                            return(result);
                        }
                        if (type == 2057)
                        {
                            result = new BOF(record);
                            return(result);
                        }
                    }
                }
            }
            result = record;
            return(result);
        }