Пример #1
0
        public override void Encode()
        {
            MemoryStream stream = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(stream);

            NumStrings = StringList.Count;
            writer.Write(TotalOccurance);
            writer.Write(NumStrings);
            this.ContinuedRecords.Clear();
            Record currentRecord = this;

            foreach (String stringVar in StringList)
            {
                int stringlength = Record.GetStringDataLength(stringVar);
                if (stream.Length + stringlength > Record.MaxContentLength)
                {
                    currentRecord.Data = stream.ToArray();
                    currentRecord.Size = (UInt16)currentRecord.Data.Length;

                    stream = new MemoryStream();
                    writer = new BinaryWriter(stream);

                    CONTINUE continuedRecord = new CONTINUE();
                    this.ContinuedRecords.Add(continuedRecord);
                    currentRecord = continuedRecord;
                }
                Record.WriteString(writer, stringVar, 16);
            }
            currentRecord.Data = stream.ToArray();
            currentRecord.Size = (UInt16)currentRecord.Data.Length;
        }
Пример #2
0
        public override void Encode()
        {
            MemoryStream stream = new MemoryStream();
            BinaryWriter writer = new BinaryWriter(stream);
            NumStrings = StringList.Count;
            writer.Write(TotalOccurance);
            writer.Write(NumStrings);
            this.ContinuedRecords.Clear();
            Record currentRecord = this;
            foreach (String stringVar in StringList)
            {
                int stringlength = Record.GetStringDataLength(stringVar);
                if (stream.Length + stringlength > Record.MaxContentLength)
                {
                    currentRecord.Data = stream.ToArray();
                    currentRecord.Size = (UInt16)currentRecord.Data.Length;

                    stream = new MemoryStream();
                    writer = new BinaryWriter(stream);

                    CONTINUE continuedRecord = new CONTINUE();
                    this.ContinuedRecords.Add(continuedRecord);
                    currentRecord = continuedRecord;
                }
                Record.WriteString(writer, stringVar, 16);
            }
            currentRecord.Data = stream.ToArray();
            currentRecord.Size = (UInt16)currentRecord.Data.Length;
        }
Пример #3
0
        public override void Encode()
        {
            MemoryStream memoryStream = new MemoryStream();
            BinaryWriter binaryWriter = new BinaryWriter(memoryStream);

            this.NumStrings = this.StringList.Count;
            binaryWriter.Write(this.TotalOccurance);
            binaryWriter.Write(this.NumStrings);
            this.ContinuedRecords.Clear();
            Record record = this;

            checked
            {
                foreach (string text in this.StringList)
                {
                    int stringDataLength = Record.GetStringDataLength(text);
                    if (memoryStream.Length + unchecked ((long)stringDataLength) > 8224L)
                    {
                        record.Data  = memoryStream.ToArray();
                        record.Size  = (ushort)record.Data.Length;
                        memoryStream = new MemoryStream();
                        binaryWriter = new BinaryWriter(memoryStream);
                        CONTINUE cONTINUE = new CONTINUE();
                        this.ContinuedRecords.Add(cONTINUE);
                        record = cONTINUE;
                    }
                    Record.WriteString(binaryWriter, text, 16);
                }
                record.Data = memoryStream.ToArray();
                record.Size = (ushort)record.Data.Length;
            }
        }
Пример #4
0
 public virtual void Encode()
 {
     this.ContinuedRecords.Clear();
     if (Size > 0 && Data.Length > MaxContentLength)
     {
         int index = MaxContentLength;
         while (index < Data.Length)
         {
             CONTINUE continuedRecord = new CONTINUE();
             int size = Math.Min(MaxContentLength, Data.Length - index);
             continuedRecord.Data = Algorithm.ArraySection(Data, index, size);
             continuedRecord.Size = (ushort)size;
             this.ContinuedRecords.Add(continuedRecord);
             index += size;
         }
         this.Size = MaxContentLength;
         this.Data = Algorithm.ArraySection(Data, 0, MaxContentLength);
     }
 }
Пример #5
0
 public virtual void Encode()
 {
     this.ContinuedRecords.Clear();
     if (Size > 0 && Data.Length > MaxContentLength)
     {
         int index = MaxContentLength;
         while (index < Data.Length)
         {
             CONTINUE continuedRecord = new CONTINUE();
             int      size            = Math.Min(MaxContentLength, Data.Length - index);
             continuedRecord.Data = Algorithm.ArraySection(Data, index, size);
             continuedRecord.Size = (ushort)size;
             this.ContinuedRecords.Add(continuedRecord);
             index += size;
         }
         this.Size = MaxContentLength;
         this.Data = Algorithm.ArraySection(Data, 0, MaxContentLength);
     }
 }
Пример #6
0
 public virtual void Encode()
 {
     this.ContinuedRecords.Clear();
     checked
     {
         if (this.Size > 0 && this.Data.Length > 8224)
         {
             int num;
             for (int i = 8224; i < this.Data.Length; i += num)
             {
                 CONTINUE cONTINUE = new CONTINUE();
                 num           = Math.Min(8224, this.Data.Length - i);
                 cONTINUE.Data = Algorithm.ArraySection(this.Data, i, num);
                 cONTINUE.Size = (ushort)num;
                 this.ContinuedRecords.Add(cONTINUE);
             }
             this.Size = 8224;
             this.Data = Algorithm.ArraySection(this.Data, 0, 8224);
         }
     }
 }
Пример #7
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);
        }