internal override void SaveToPxl(TPxlStream PxlStream, TPxlSaveData SaveData) { if ((sBOF == null) || (sEOF == null)) { XlsMessages.ThrowException(XlsErr.ErrSectionNotLoaded); } sBOF.SaveToPxl(PxlStream, 0, SaveData); foreach (TWindow1Record w1 in Window1) { if (w1 != null) { w1.SaveToPxl(PxlStream, 0, SaveData); } } Fonts.SaveToPxl(PxlStream, 0, SaveData); Formats.SaveToPxl(PxlStream, 0, SaveData); CellXF.SaveToPxl(PxlStream, 0, SaveData); FBoundSheets.SaveToPxl(PxlStream, SaveData); FNames.SaveToPxl(PxlStream, 0, SaveData); //Should be after FBoundSheets.SaveToStream sEOF.SaveToPxl(PxlStream, 0, SaveData); }
private void FixSheetVisible() { int NewFirstSheetVisible = -1; //Verify we have not selected a hidden sheet. This will cause excel to crash. for (int i = FSheets.Count - 1; i >= 0; i--) { if (FGlobals.GetSheetVisible(i) == TXlsSheetVisible.Visible) { NewFirstSheetVisible = i; } else if (FSheets[i].Selected) { XlsMessages.ThrowException(XlsErr.ErrHiddenSheetSelected); } } if (NewFirstSheetVisible == -1) { XlsMessages.ThrowException(XlsErr.ErrNoSheetVisible); } int sv = FGlobals.GetFirstSheetVisible(); if (sv < 0 || sv >= FSheets.Count || FGlobals.GetSheetVisible(sv) != TXlsSheetVisible.Visible) { FGlobals.SetFirstSheetVisible(NewFirstSheetVisible); } }
/// <summary> /// CreateFromData /// </summary> internal TNoteRecord(int aRow, int aCol, TRichString aTxt, string aAuthor, TDrawing Drawing, TImageProperties Properties, ExcelFile xls, TSheet sSheet, bool ReadFromXlsx) : base((int)xlr.NOTE, aCol) { if ((aCol < 0) || (aCol > FlxConsts.Max_Columns)) { XlsMessages.ThrowException(XlsErr.ErrXlsIndexOutBounds, aCol, "Column", 0, FlxConsts.Max_Columns); } Dwg = Drawing.AddNewComment(xls, Properties, sSheet, ReadFromXlsx); TEscherImageAnchorRecord Anchor = GetImageRecord(); if (Anchor != null) { NoteTextBox = Anchor.SaveCommentCoords(sSheet, aRow, aCol); } Col = aCol; OptionFlags = 0; //option flags unchecked { ObjId = (UInt16)Dwg.ObjId; //object id } Author = aAuthor; SetText(aTxt); }
private static void WriteAgileCipherParams(XmlWriter xml, TEncryptionParameters EncParams, TAgileEncryptionKey Key) { xml.WriteAttributeString("saltSize", Convert.ToString(Key.Salt.Length, CultureInfo.InvariantCulture)); xml.WriteAttributeString("blockSize", Convert.ToString(Key.BlockSize, CultureInfo.InvariantCulture)); xml.WriteAttributeString("keyBits", Convert.ToString(Key.KeySizeInBytes * 8, CultureInfo.InvariantCulture)); xml.WriteAttributeString("hashSize", Convert.ToString(Key.HashSizeBytes(), CultureInfo.InvariantCulture)); //sha1 hash size xml.WriteAttributeString("cipherAlgorithm", "AES"); switch (EncParams.ChainingMode) { case CipherMode.CBC: xml.WriteAttributeString("cipherChaining", "ChainingModeCBC"); break; case CipherMode.CFB: xml.WriteAttributeString("cipherChaining", "ChainingModeCFB"); break; case CipherMode.CTS: case CipherMode.ECB: case CipherMode.OFB: default: XlsMessages.ThrowException(XlsErr.ErrNotSupportedEncryption); break; } xml.WriteAttributeString("hashAlgorithm", "SHA1"); xml.WriteAttributeString("saltValue", Convert.ToBase64String(Key.Salt)); }
internal TBOFRecord(int aId, byte[] aData) : base(aId, aData) { if (GetWord(0) != (int)xlr.BofVersion) { XlsMessages.ThrowException(XlsErr.ErrInvalidVersion); } }
internal void CopyFrom(TColInfoList aColInfoList) { DefColWidthChars = aColInfoList.DefColWidthChars; DefColWidthChars256 = aColInfoList.DefColWidthChars256; if (aColInfoList.FColumns == FColumns) { XlsMessages.ThrowException(XlsErr.ErrInternal); //Should be different objects } if (aColInfoList.DefaultColumn != null) { DefaultColumn = new TColInfo(aColInfoList.DefaultColumn.Width, aColInfoList.DefaultColumn.XF, aColInfoList.DefaultColumn.Options, true); } for (int i = FColumns.Length - 1; i >= 0; i--) { TColInfo[] a = aColInfoList.FColumns[i]; if (a != null) { FColumns[i] = new TColInfo[a.Length]; for (int k = a.Length - 1; k >= 0; k--) { if (a[k] != null) { FColumns[i][k] = new TColInfo(a[k].Width, a[k].XF, a[k].Options, true); } } } } }
internal void ArrangeInsertCols(TXlsCellRange CellRange, int aColCount, TSheetInfo SheetInfo) { if (SheetInfo.SourceFormulaSheet != SheetInfo.InsSheet) { return; } int ColOffset = CellRange.ColCount * aColCount; if (aColCount < 0) //Deleting columns. ColOffset is < 0. { DeleteColumns(CellRange.Left, -ColOffset); } else { //the check below might throw unwanted exceptions when all columns are formatted (even with fake formatting) //and disallow to insert columns on some sheets. (for example all pxl files have the full 255 columns formatted) //so we will allow to "lose" formatted columns if there is no data on them. //if (LastColumn+ColOffset>FlxConsts.Max_Columns) XlsMessages.ThrowException(XlsErr.ErrTooManyColumns, LastColumn + ColOffset + 1, FlxConsts.Max_Columns+1); if (CellRange.Left + ColOffset > FlxConsts.Max_Columns) { XlsMessages.ThrowException(XlsErr.ErrTooManyColumns, CellRange.Left + ColOffset + 1, FlxConsts.Max_Columns + 1); } InsertColumns(CellRange.Left, ColOffset); } }
internal static Stream Decrypt(Stream aStream, TEncryptionData Encryption) { using (TOle2File DataStream = new TOle2File(aStream, false)) { DataStream.SelectStream(XlsxConsts.EncryptionInfoString); byte[] RecordHeader = new byte[4 * 2]; DataStream.Read(RecordHeader, RecordHeader.Length); int vMajor = BitOps.GetWord(RecordHeader, 0); int vMinor = BitOps.GetWord(RecordHeader, 2); if ((vMajor == 0x03 || vMajor == 0x04) && vMinor == 0x02) { long Flags = BitOps.GetCardinal(RecordHeader, 4); if (Flags == 0x10) { XlsMessages.ThrowException(XlsErr.ErrNotSupportedEncryption); //external encryption } return(ReadStandardEncryptionInfo(DataStream, Encryption)); } else if (vMajor == 4 && vMinor == 4 && BitOps.GetCardinal(RecordHeader, 4) == 0x040) { return(ReadAgileEncryptionInfo(DataStream, Encryption)); } XlsMessages.ThrowException(XlsErr.ErrNotSupportedEncryption); return(null); } }
internal void MoveRange(int SheetNo, TXlsCellRange CellRange, int NewRow, int NewCol) { //Some error handling if ( (CellRange.Top > CellRange.Bottom) || (CellRange.Top < 0) || (NewRow + CellRange.RowCount - 1 > FlxConsts.Max_Rows) ) { XlsMessages.ThrowException(XlsErr.ErrBadMoveCall); } if ( (CellRange.Left > CellRange.Right) || (CellRange.Left < 0) || (NewCol + CellRange.ColCount - 1 > FlxConsts.Max_Columns) ) { XlsMessages.ThrowException(XlsErr.ErrBadMoveCall); } if ((SheetNo >= Sheets.Count) || (SheetNo < 0)) { XlsMessages.ThrowException(XlsErr.ErrInvalidSheetNo, SheetNo, 0, Sheets.Count - 1); } TSheetInfo SheetInfo = new TSheetInfo(SheetNo, SheetNo, SheetNo, Globals, Globals, Sheets, Sheets, false); FSheets.MoveRange(CellRange, NewRow, NewCol, SheetInfo); Globals.MoveRange(CellRange, NewRow, NewCol, SheetInfo); }
internal void SaveRangeToStream(IDataStream DataStream, TSaveData SaveData, TXlsCellRange CellRange) { int FirstRecord = 0; int RecordCount = 0; CalcIncludedRangeRecords(CellRange, ref FirstRecord, ref RecordCount); if (RecordCount > MaxPageBreaks) { if (SaveData.ThrowExceptionOnTooManyPageBreaks) { XlsMessages.ThrowException(XlsErr.ErrTooManyPageBreaks); } else { RecordCount = MaxPageBreaks; } if (FlexCelTrace.Enabled) { FlexCelTrace.Write(new TXlsTooManyPageBreaksError(XlsMessages.GetString(XlsErr.ErrTooManyPageBreaks), DataStream.FileName)); } } SaveToStreamExt(DataStream, SaveData, FirstRecord, RecordCount); }
internal TExcelString(TStrLenLength aStrLenLength, string s, TRTFRun[] RTFRuns, bool ForceWide) { StrLenLength = aStrLenLength; if (StrLenLength == TStrLenLength.is8bits) { if (s.Length > 0xFF) { XlsMessages.ThrowException(XlsErr.ErrInvalidStringRecord); } } OptionFlags = 0; if (ForceWide || StrOps.IsWide(s)) { OptionFlags = 1; } if ((RTFRuns != null) && (RTFRuns.Length > 0)) { OptionFlags = (byte)(OptionFlags | 8); RichTextFormats = TRTFRun.ToByteArray(RTFRuns); } else { RichTextFormats = null; } FarEastData = null; Data = s; //We have to include all data on the hash. Hash = GetHashString().GetHashCode(); }
private static void ReadAgileCipherParams(XmlReader xml, TEncryptionParameters EncParams, TEncryptionKey Key) { int SaltSize = Convert.ToInt32(xml.GetAttribute("saltSize"), CultureInfo.InvariantCulture); int BlockSize = Convert.ToInt32(xml.GetAttribute("blockSize"), CultureInfo.InvariantCulture); Key.BlockSize = BlockSize; if (BlockSize != 0x10) { XlsMessages.ThrowException(XlsErr.ErrNotSupportedEncryption); } int KeyBits = Convert.ToInt32(xml.GetAttribute("keyBits"), CultureInfo.InvariantCulture); Key.KeySizeInBytes = KeyBits / 8; switch (KeyBits) { case 128: EncParams.Algorithm = TEncryptionAlgorithm.AES_128; break; case 192: EncParams.Algorithm = TEncryptionAlgorithm.AES_192; break; case 256: EncParams.Algorithm = TEncryptionAlgorithm.AES_256; break; default: XlsMessages.ThrowException(XlsErr.ErrNotSupportedEncryption); break; } string CipherAlgo = xml.GetAttribute("cipherAlgorithm"); if (!string.Equals(CipherAlgo, "AES", StringComparison.InvariantCulture)) { XlsMessages.ThrowException(XlsErr.ErrNotSupportedEncryption); } string CipherChaining = xml.GetAttribute("cipherChaining"); switch (CipherChaining) { case "ChainingModeCBC": EncParams.ChainingMode = CipherMode.CBC; break; case "ChainingModeCFB": EncParams.ChainingMode = CipherMode.CFB; break; default: XlsMessages.ThrowException(XlsErr.ErrNotSupportedEncryption); break; } string HashAlgorithm = xml.GetAttribute("hashAlgorithm"); if (HashAlgorithm != "SHA1" && HashAlgorithm != "SHA-1") { XlsMessages.ThrowException(XlsErr.ErrNotSupportedEncryption); } Key.Salt = Convert.FromBase64String(xml.GetAttribute("saltValue")); if (Key.Salt == null || SaltSize != Key.Salt.Length) { XlsMessages.ThrowException(XlsErr.ErrNotSupportedEncryption); } }
private static void MoveOne(ref int r, int Delta, int MaxAll, XlsErr ErrorWhenTooMany) { r += Delta; if (r > MaxAll) { XlsMessages.ThrowException(ErrorWhenTooMany, r + 1, MaxAll + 1); } }
internal long AcumSize() { if ((CurrentPos >= Count) || (CurrentPos < 0)) { XlsMessages.ThrowException(XlsErr.ErrInternal); } return(this[CurrentPos].AcumSize + ZeroPos + XlsConsts.SizeOfTRecordHeader * (CurrentPos)); }
private long GetColor(int Index) { if ((Index >= Count) || (Index < 0)) { XlsMessages.ThrowException(XlsErr.ErrXlsIndexOutBounds, Index, "Palette Color Index", 0, Count - 1); } return(GetCardinal(2 + Index * 4)); }
public TLabColor GetLabColor(int Index) { if ((Index >= Count) || (Index < 0)) { XlsMessages.ThrowException(XlsErr.ErrXlsIndexOutBounds, Index, "Palette Color Index", 0, Count - 1); } return(LabColorCache[Index]); }
internal void SaveRangeToStream(IDataStream DataStream, TSaveData SaveData, int SheetIndex) { if ((SheetIndex >= FBoundSheets.Count) || (SheetIndex < 0)) { XlsMessages.ThrowException(XlsErr.ErrInvalidSheetNo, SheetIndex, 0, FBoundSheets.Count - 1); } FBoundSheets[SheetIndex].SaveToStream(DataStream, SaveData, 0); }
internal long TotalRangeSize(int SheetIndex) { if ((SheetIndex >= FBoundSheets.Count) || (SheetIndex < 0)) { XlsMessages.ThrowException(XlsErr.ErrInvalidSheetNo, SheetIndex, 0, FBoundSheets.Count - 1); } return(FBoundSheets[SheetIndex].TotalSize()); }
internal virtual long TotalRangeSize(int SheetIndex, TXlsCellRange CellRange, TEncryptionData Encryption, bool Repeatable) { if ((sEOF == null) || (sBOF == null)) { XlsMessages.ThrowException(XlsErr.ErrSectionNotLoaded); } return(sEOF.TotalSize() + sBOF.TotalSize()); }
private void LoadBinWorkbook(TBinRecordLoader RecordLoader) { RecordLoader.ReadHeader(); int RecordId = RecordLoader.RecordHeader.Id; while (!RecordLoader.Eof && (RecordLoader.RecordHeader.Id != 0)) { RecordId = RecordLoader.RecordHeader.Id; TBOFRecord RBOF = RecordLoader.LoadRecord(false) as TBOFRecord; if (RecordId == (int)xlr.BOF) { RecordLoader.SwitchSheet(); switch (RBOF.BOFType) { case (int)xlb.Globals: Globals.LoadFromStream(RecordLoader, RBOF); if (RecordLoader.VirtualReader != null) { RecordLoader.VirtualReader.StartReading(); } break; case (int)xlb.Worksheet: FSheets[FSheets.Add(new TWorkSheet(Globals))].LoadFromStream(RecordLoader, RBOF); break; case (int)xlb.Chart: FSheets[FSheets.Add(new TFlxChart(Globals, false))].LoadFromStream(RecordLoader, RBOF); break; case (int)xlb.Macro: FSheets[FSheets.Add(new TMacroSheet(Globals))].LoadFromStream(RecordLoader, RBOF); break; default: FSheets[FSheets.Add(new TFlxUnsupportedSheet(Globals))].LoadFromStream(RecordLoader, RBOF); break; } //case if (RecordLoader.VirtualReader != null) { RecordLoader.VirtualReader.Flush(); } } else if (RecordId != (int)xlr.EOF) //There can be 2 eof at the end of the file { XlsMessages.ThrowException(XlsErr.ErrExcelInvalid); } if (Globals.SheetCount > 0 && Globals.SheetCount <= FSheets.Count) { break; //There shouldn't be any garbage here, but some weird non-created-by-excel files might have it, and Excel will load them fine. } } //while }
internal void DeleteSheets(int SheetPos, int SheetCount) { if (SheetPos > Sheets.Count) { XlsMessages.ThrowException(XlsErr.ErrInvalidSheetNo, SheetPos, 0, Sheets.Count); } Globals.DeleteSheets(SheetPos, SheetCount, this); Sheets.DeleteSheets(SheetPos, SheetCount); }
internal void LoadBiff7(byte[] Data, int Pos, TExternSheetList ExternSheetList, TPxlVersion PxlVersion) { TFormulaErrorValue Err = Load(Data, Pos, TFmlaConvert.Biff7To8, PxlVersion, ExternSheetList, null); //No references to load Biff7 if (Err != null) { XlsMessages.ThrowException(XlsErr.ErrBadToken, Err.Token); } }
private static byte[] ConvertToBiff8(TExternSheetList ExternSheetList, byte Token, byte[] Data, ref int tPos) { byte[] Result; int rPos = 0; switch (TBaseParsedToken.CalcBaseToken((ptg)Token)) { case ptg.Name: Result = new byte[4]; //Wrong on Excel docs! BitOps.SetWord(Result, 0, BitOps.GetWord(Data, tPos)); tPos += 14; return(Result); case ptg.NameX: Result = new byte[6]; //This is actually 6 BitOps.SetWord(Result, 2, BitOps.GetWord(Data, tPos + 10)); tPos += 24; return(Result); case ptg.Ref: case ptg.RefN: Result = new byte[4]; ConvertRowsAndColumns7To8(Data, Result, ref tPos, ref rPos, false); return(Result); case ptg.Area: case ptg.AreaN: Result = new byte[8]; ConvertRowsAndColumns7To8(Data, Result, ref tPos, ref rPos, true); return(Result); case ptg.RefErr: tPos += 3; return(new byte[4]); case ptg.AreaErr: tPos += 6; return(new byte[8]); case ptg.Ref3d: case ptg.Ref3dErr: Result = new byte[6]; Convert3D7To8(ExternSheetList, Token, Data, Result, ref tPos, ref rPos); ConvertRowsAndColumns7To8(Data, Result, ref tPos, ref rPos, false); return(Result); case ptg.Area3d: case ptg.Area3dErr: Result = new byte[10]; Convert3D7To8(ExternSheetList, Token, Data, Result, ref tPos, ref rPos); ConvertRowsAndColumns7To8(Data, Result, ref tPos, ref rPos, true); return(Result); } XlsMessages.ThrowException(XlsErr.ErrBadToken, Token); return(null); //just to compile. }
/// <summary> /// Throws an exception if not found. /// </summary> internal int this[int index] { get { int r; if (!FList.TryGetValue(index, out r)) { XlsMessages.ThrowException(XlsErr.ErrExcelInvalid); } return(r); } set { FList[index] = value; } }
internal static xlr GetId(pxl Record) { switch (Record) { case pxl.BLANK: return(xlr.BLANK); case pxl.BOF: return(xlr.BOF); case pxl.BOOLERR: return(xlr.BOOLERR); case pxl.BOUNDSHEET: return(xlr.BOUNDSHEET); case pxl.COLINFO: return(xlr.COLINFO); case pxl.DEFAULTROWHEIGHT: return(xlr.DEFAULTROWHEIGHT); case pxl.DEFCOLWIDTH: return(xlr.DEFCOLWIDTH); case pxl.EOF: return(xlr.EOF); case pxl.FILEPASS: return(xlr.FILEPASS); case pxl.FONT: return(xlr.FONT); case pxl.xFORMAT: return(xlr.xFORMAT); case pxl.FORMULA: return(xlr.FORMULA); case pxl.LABEL: return(xlr.LABEL); case pxl.NAME: return(xlr.NAME); case pxl.NUMBER: return(xlr.NUMBER); case pxl.PANE: return(xlr.PANE); case pxl.ROW: return(xlr.ROW); case pxl.SELECTION: return(xlr.SELECTION); case pxl.STRING: return(xlr.STRING); case pxl.WINDOW1: return(xlr.WINDOW1); case pxl.WINDOW2: return(xlr.WINDOW2); case pxl.XF: return(xlr.XF); case pxl.CODEPAGE: return(xlr.CODEPAGE); case pxl.COUNTRY: return(xlr.COUNTRY); default: XlsMessages.ThrowException(XlsErr.ErrPxlIsInvalidToken, (int)Record); return(xlr.EOF); //just to keep compiler happy. } }
internal void Add(TBoundSheetRecordList BoundSheets, int SheetToInsert, string aName, int SheetPos) //Error if duplicated entry { if (FList.ContainsKey(aName)) { XlsMessages.ThrowException(XlsErr.ErrDuplicatedSheetName, aName); } FixSheetPos(BoundSheets, SheetToInsert, 1); FList.Add(aName, SheetPos); }
internal void InsertSheets(int CopyFrom, int InsertBefore, int SheetCount, TWorkbook SourceWorkbook) { if (SourceWorkbook == null) { SourceWorkbook = this; } if (CopyFrom >= SourceWorkbook.Sheets.Count) { XlsMessages.ThrowException(XlsErr.ErrInvalidSheetNo, CopyFrom, -1, SourceWorkbook.Sheets.Count - 1); } if (InsertBefore > Sheets.Count) { XlsMessages.ThrowException(XlsErr.ErrInvalidSheetNo, InsertBefore, 0, Sheets.Count); } TSheet aSheet = null; int OptionFlags = 0; if (CopyFrom >= 0) { aSheet = SourceWorkbook.Sheets[CopyFrom]; OptionFlags = SourceWorkbook.Globals.SheetOptionFlags(CopyFrom); } int NewCopyFrom = CopyFrom; if (SourceWorkbook == this && CopyFrom >= InsertBefore) { NewCopyFrom += SheetCount; } Globals.InsertSheets(CopyFrom, InsertBefore, OptionFlags, XlsMessages.GetString(XlsErr.BaseSheetName), SheetCount, SourceWorkbook.Sheets); TSheetInfo SheetInfo = new TSheetInfo(-1, -1, -1, SourceWorkbook.Globals, Globals, aSheet, null, false); for (int i = 0; i < SheetCount; i++) { SheetInfo.InsSheet = InsertBefore + i; SheetInfo.SourceFormulaSheet = NewCopyFrom; SheetInfo.DestFormulaSheet = InsertBefore; SheetInfo.DestSheet = null; //keep it null, since the reference does not exist yet. if (aSheet == null) { Sheets.Insert(InsertBefore, TWorkSheet.CreateFromData(Globals, Globals.Workbook.XlsBiffVersion, Globals.Workbook.ExcelFileFormat)); } else { SheetInfo.DestFormulaSheet = InsertBefore + i; Globals.Names.InsertSheets(NewCopyFrom, InsertBefore + i, 1, SheetInfo, SourceWorkbook == this); //names must be inserted before the sheet is cloned, so formulas can refer to them. Sheets.Insert(InsertBefore + i, TSheet.Clone(aSheet, SheetInfo)); SheetInfo.DestSheet = Sheets[InsertBefore + i]; Sheets[InsertBefore + i].ArrangeCopySheet(SheetInfo); } } }
private static void InsertFirst(ref int First, int MaxRange, int MaxAll, int RangeCount, int aRowCount, XlsErr ErrorWhenTooMany) { if (First >= MaxRange) { First += RangeCount * aRowCount; if (First > MaxAll) { XlsMessages.ThrowException(ErrorWhenTooMany, First + 1, MaxAll + 1); } } }
/// <summary> /// Should be called before we release SST.IndexData /// </summary> /// <param name="aSST"></param> /// <param name="index"></param> /// <param name="aFontList"></param> private void AttachToSST(long index, TSST aSST, IFlexCelFontList aFontList) { if (aSST == null || aFontList == null || index >= aSST.IndexData.Count) { XlsMessages.ThrowException(XlsErr.ErrExcelInvalid); } SST = aSST; pSSTEntry = SST.IndexData[(int)index]; pSSTEntry.AddRef(); FontList = aFontList; }
internal void CopyFrom(THLinkList aHLinkList, TSheetInfo SheetInfo) { if (aHLinkList.FList == FList) { XlsMessages.ThrowException(XlsErr.ErrInternal); //Should be different objects } for (int i = 0; i < aHLinkList.Count; i++) { Add((THLinkRecord)THLinkRecord.Clone(aHLinkList[i], SheetInfo)); } }