Beispiel #1
0
        private void ResizeLabel(LabelRecord lbl)
        {
            SuspendLayout();
            // Get the proportionality of the resize
            float proportionalNewWidth  = (float)lbl.label.Width / lbl.initialWidth;
            float proportionalNewHeight = (float)lbl.label.Height / lbl.initialHeight;

            // Calculate the current font size
            lbl.label.Font = new Font(lbl.label.Font.FontFamily, lbl.initialFontSize *
                                      (proportionalNewWidth > proportionalNewHeight ? proportionalNewHeight : proportionalNewWidth),
                                      lbl.label.Font.Style);

            Image img = lbl.label.Image;

            if (img != null)
            {
                var pic = new Bitmap(img, lbl.label.Width, lbl.label.Height);
                lbl.label.Image = pic;
            }

            ResumeLayout();
        }
Beispiel #2
0
        /// <summary>
        /// Reads type record for the specified type index.
        /// </summary>
        /// <param name="typeIndex">Type record index in <see cref="references"/> list.</param>
        /// <returns></returns>
        private TypeRecord ReadType(int typeIndex)
        {
            IBinaryReader   reader    = typeRecordsSubStreamPerThread.Value;
            RecordReference reference = references[typeIndex];
            TypeRecord      typeRecord;
            long            dataEnd = reference.DataOffset + reference.DataLen;

            reader.Position = reference.DataOffset;
            switch (reference.Kind)
            {
            case TypeLeafKind.LF_MODIFIER:
                typeRecord = ModifierRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_PROCEDURE:
                typeRecord = ProcedureRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_MFUNCTION:
                typeRecord = MemberFunctionRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_LABEL:
                typeRecord = LabelRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_MFUNC_ID:
                typeRecord = MemberFunctionIdRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_ARGLIST:
                typeRecord = ArgumentListRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_SUBSTR_LIST:
                typeRecord = StringListRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_POINTER:
                typeRecord = PointerRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_NESTTYPE:
                typeRecord = NestedTypeRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_FIELDLIST:
                typeRecord = FieldListRecord.Read(reader, reference.Kind, reference.DataLen);
                break;

            case TypeLeafKind.LF_ENUM:
                typeRecord = EnumRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_CLASS:
            case TypeLeafKind.LF_STRUCTURE:
            case TypeLeafKind.LF_INTERFACE:
                typeRecord = ClassRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_ARRAY:
                typeRecord = ArrayRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_BITFIELD:
                typeRecord = BitFieldRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_METHODLIST:
                typeRecord = MethodOverloadListRecord.Read(reader, reference.Kind, reference.DataLen);
                break;

            case TypeLeafKind.LF_UNION:
                typeRecord = UnionRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_VTSHAPE:
                typeRecord = VirtualFunctionTableShapeRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_UDT_MOD_SRC_LINE:
                typeRecord = UdtModuleSourceLineRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_STRING_ID:
                typeRecord = StringIdRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_BUILDINFO:
                typeRecord = BuildInfoRecord.Read(reader, reference.Kind);
                break;

            case TypeLeafKind.LF_FUNC_ID:
                typeRecord = FunctionIdRecord.Read(reader, reference.Kind);
                break;

            default:
#if DEBUG
                throw new NotImplementedException($"Unknown reference kind: {reference.Kind}");
#else
                return(null);
#endif
            }
            if (reader.Position + 4 < dataEnd || reader.Position > dataEnd)
            {
                throw new Exception("Parsing went wrong");
            }
            return(typeRecord);
        }
Beispiel #3
0
            /// <summary>
            /// Process an HSSF Record. Called when a record occurs in an HSSF file.
            /// </summary>
            /// <param name="record"></param>
            public void ProcessRecord(Record record)
            {
                String thisText = null;
                int    thisRow  = -1;

                switch (record.Sid)
                {
                case BoundSheetRecord.sid:
                    BoundSheetRecord sr = (BoundSheetRecord)record;
                    sheetNames.Add(sr.Sheetname);
                    break;

                case BOFRecord.sid:
                    BOFRecord bof = (BOFRecord)record;
                    if (bof.Type == BOFRecordType.Worksheet)
                    {
                        sheetNum++;
                        rowNum = -1;

                        if (includeSheetNames)
                        {
                            if (text.Length > 0)
                            {
                                text.Append("\n");
                            }
                            text.Append(sheetNames[sheetNum]);
                        }
                    }
                    break;

                case SSTRecord.sid:
                    sstRecord = (SSTRecord)record;
                    break;

                case FormulaRecord.sid:
                    FormulaRecord frec = (FormulaRecord)record;
                    thisRow = frec.Row;

                    if (formulasNotResults)
                    {
                        thisText = HSSFFormulaParser.ToFormulaString((HSSFWorkbook)null, frec.ParsedExpression);
                    }
                    else
                    {
                        if (frec.HasCachedResultString)
                        {
                            // Formula result is a string
                            // This is stored in the next record
                            outputNextStringValue = true;
                            nextRow = frec.Row;
                        }
                        else
                        {
                            thisText = FormatNumberDateCell(frec, frec.Value);
                        }
                    }
                    break;

                case StringRecord.sid:
                    if (outputNextStringValue)
                    {
                        // String for formula
                        StringRecord srec = (StringRecord)record;
                        thisText = srec.String;
                        thisRow  = nextRow;
                        outputNextStringValue = false;
                    }
                    break;

                case LabelRecord.sid:
                    LabelRecord lrec = (LabelRecord)record;
                    thisRow  = lrec.Row;
                    thisText = lrec.Value;
                    break;

                case LabelSSTRecord.sid:
                    LabelSSTRecord lsrec = (LabelSSTRecord)record;
                    thisRow = lsrec.Row;
                    if (sstRecord == null)
                    {
                        throw new Exception("No SST record found");
                    }
                    thisText = sstRecord.GetString(lsrec.SSTIndex).ToString();
                    break;

                case NoteRecord.sid:
                    NoteRecord nrec = (NoteRecord)record;
                    thisRow = nrec.Row;
                    // TODO: Find object to match nrec.GetShapeId()
                    break;

                case NumberRecord.sid:
                    NumberRecord numrec = (NumberRecord)record;
                    thisRow  = numrec.Row;
                    thisText = FormatNumberDateCell(numrec, numrec.Value);
                    break;

                default:
                    break;
                }

                if (thisText != null)
                {
                    if (thisRow != rowNum)
                    {
                        rowNum = thisRow;
                        if (text.Length > 0)
                        {
                            text.Append("\n");
                        }
                    }
                    else
                    {
                        text.Append("\t");
                    }
                    text.Append(thisText);
                }
            }
Beispiel #4
0
        private Biff GetCorrectRecord(GenericBiff record, Stream stream, SstRecord sst)
        {
            Biff ret = record;

            switch (record.Id)
            {
            case (ushort)RecordType.Bof:
                BofRecord bof = new BofRecord(record);
                if (bof.Version < 0x0600)
                {
                    throw new Exception("Versions below Excel 97/2000 are currently not supported.");
                }

                ret = bof;
                break;

            case (ushort)RecordType.Boundsheet:
                ret = new BoundSheetRecord(record);
                break;

            case (ushort)RecordType.Index:
                ret = new IndexRecord(record);
                break;

            case (ushort)RecordType.DbCell:
                ret = new DbCellRecord(record);
                break;

            case (ushort)RecordType.Row:
                ret = new RowRecord(record);
                break;

            case (ushort)RecordType.Continue:
                ret = new ContinueRecord(record);
                break;

            case (ushort)RecordType.Blank:
                ret = new BlankRecord(record);
                break;

            case (ushort)RecordType.BoolErr:
                ret = new BoolErrRecord(record);
                break;

            case (ushort)RecordType.Formula:
                ret = new FormulaRecord(record, stream);
                break;

            case (ushort)RecordType.Label:
                ret = new LabelRecord(record);
                break;

            case (ushort)RecordType.LabelSst:
                ret = new LabelSstRecord(record, sst);
                break;

            case (ushort)RecordType.MulBlank:
                ret = new MulBlankRecord(record);
                break;

            case (ushort)RecordType.MulRk:
                ret = new MulRkRecord(record);
                break;

            case (ushort)RecordType.String:
                ret = new StringValueRecord(record);
                break;

            case (ushort)RecordType.Xf:
                ret = new XfRecord(record);
                break;

            case (ushort)RecordType.Rk:
                ret = new RkRecord(record);
                break;

            case (ushort)RecordType.Number:
                ret = new NumberRecord(record);
                break;

            case (ushort)RecordType.Array:
                ret = new ArrayRecord(record);
                break;

            case (ushort)RecordType.ShrFmla:
                ret = new SharedFormulaRecord(record);
                break;

            case (ushort)RecordType.Table:
                ret = new TableRecord(record);
                break;

            case (ushort)RecordType.Sst:
                ret = new SstRecord(record, stream);
                break;

            case (ushort)RecordType.Eof:
                ret = new EofRecord(record);
                break;

            case (ushort)RecordType.Font:
                ret = new FontRecord(record);
                break;

            case (ushort)RecordType.Format:
                ret = new Net.SourceForge.Koogra.Excel.Records.FormatRecord(record);
                break;

            case (ushort)RecordType.Palette:
                ret = new PaletteRecord(record);
                break;

            case (ushort)RecordType.Hyperlink:
                ret = new HyperLinkRecord(record);
                break;
            }

            return(ret);
        }