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));
}
}
