private void LoadAllFonts(string FontPath, DirectoryInfo di, string FontExtension, Boolean ErrorIfEmpty)
{
// Create an array representing the files in the current directory.
FileInfo[] fi = di.GetFiles(FontExtension);
if (ErrorIfEmpty && fi.Length == 0)
{
FlxMessages.ThrowException(FlxErr.ErrEmptyFolder, FontPath, FontExtension);
}
foreach (FileInfo fontFile in fi)
{
if (FFontFiles.ContainsKey(fontFile.Name))
{
continue;
}
FFontFiles.Add(fontFile.Name, null);
try
{
LoadFont(fontFile.FullName);
}
catch (Exception ex)
{
//Invalid font. nothing to do, just continue reading the other fonts.
// What we will do is just ignore it here, and throw an exception when (and if) the user actually tries to use this font.
if (FlexCelTrace.HasListeners)
{
FlexCelTrace.Write(new TPdfCorruptFontInFontFolderError(ex.Message, fontFile.FullName));
}
}
}
}
private static void AddExtraRelationships(IDataTableFinder TableFinder, VirtualDataTable aData, TRelationshipList Relations, TBand band, TMasterDetailLinkList MasterDetailLinkList)
{
foreach (TRelationship tr in Relations)
{
TDataSourceInfo dParent = TableFinder.TryGetDataTable(tr.ParentTable);
if (dParent == null || dParent.Table == null)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidManualRelationshipDatasetNull, tr.ParentTable);
}
TDataSourceInfo dChild = TableFinder.TryGetDataTable(tr.ChildTable);
if (dChild == null || dChild.Table == null)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidManualRelationshipDatasetNull, tr.ChildTable);
}
if (SameTable(dChild.Table, aData) && SameTable(dParent.Table, band.DataSource.Data))
{
GetColIndexes(dParent.Table, tr.ParentColumns, true); //we do it here so it checks all columns exist in the parent. They might not exist in our table, and that is ok if our table is a distinct for example)
GetColIndexes(dChild.Table, tr.ChildColumns, true);
int[] ChildCols = GetColIndexes(aData, tr.ChildColumns, false);
int[] ParentCols = GetColIndexes(band.DataSource.Data, tr.ParentColumns, false);
if (ChildCols != null && ParentCols != null)
{
MasterDetailLinkList.AddRelation(band.DataSource.DataState,
new TRelation(band.DataSource.Data, aData, ParentCols,
ChildCols));
}
}
}
}
private void CheckConnected()
{
if (CurrentChart == null)
{
FlxMessages.ThrowException(FlxErr.ErrNotConnected);
}
}
private static void PartialSort(TKeyList Items, ExcelFile xls, TXlsCellRange Range, bool ByRows, int FirstRow, int StagingRow)
{
int Slot = FirstRow - Range.Top;
int LastSlot = -1;
int destRow = StagingRow;
int Row = FirstRow;
do
{
if (Row == destRow)
{
FlxMessages.ThrowException(FlxErr.ErrInternal);
}
MoveRows(xls, Range, ByRows, Row, destRow);
if (LastSlot >= 0)
{
Items[LastSlot].Position = destRow;
}
int MovedFrom = Row;
if (Slot == Items.Count)
{
break; //we are moving from the staging area.
}
Row = Items[Slot].Position;
if (Row == FirstRow)
{
Row = StagingRow;
}
LastSlot = Slot;
Slot = Row - Range.Top;
destRow = MovedFrom;
} while (true);
}
internal TRKRecord(int aCol, int aXF, double Value) : base((int)xlr.RK, aCol, aXF)
{
if (!EncodeRK(Value, ref RK))
{
FlxMessages.ThrowException(FlxErr.ErrInvalidCellValue, Value.ToString());
}
}
private static Dictionary <string, TShapeGeom> ReadShapes()
{
Dictionary <string, TShapeGeom> Result = new Dictionary <string, TShapeGeom>();
using (Stream PresetStream = GetPresetStream())
{
using (TOpenXmlReader DataStream = TOpenXmlReader.CreateFromSimpleStream(PresetStream))
{
DataStream.DefaultNamespace = "";
DataStream.NextTag();
Debug.Assert(DataStream.RecordName() == "presetShapeDefinitons", DataStream.RecordName());
string StartElement = DataStream.RecordName();
if (!DataStream.NextTag())
{
FlxMessages.ThrowException(FlxErr.ErrInternal);
}
TXlsxShapeReader ShapeReader = new TXlsxShapeReader(DataStream);
while (!DataStream.AtEndElement(StartElement))
{
Result[DataStream.RecordName()] = ShapeReader.ReadShapeDef(DataStream.RecordName());
}
}
}
return(Result);
}
public override void Flush()
{
if (HelperStream != null)
{
FlxMessages.ThrowException(FlxErr.ErrInternal);
}
VirtualStream.Flush();
}
public TConfigFormat GetValue(string Key)
{
TConfigFormat Result;
if (!TryGetValue(Key, out Result))
{
FlxMessages.ThrowException(FlxErr.ErrInvalidFormat, Key);
}
return(Result);
}
private static void LoadString(ResourceManager rm, string Id, ref string[] Tmp, TagEnum Tag)
{
string s = rm.GetString(Id);
if (s == null || s.Length == 0)
{
FlxMessages.ThrowException(FlxErr.ErrUndefinedId, Id, "TagTokens.resx");
}
Tmp[(int)Tag] = s;
}
private TShapePoint ReadPoint(TShapeGeom ShapeGeom, string TagName)
{
List <TShapePoint> Pts = ReadPts(ShapeGeom, TagName);
if (Pts.Count != 1)
{
FlxMessages.ThrowException(FlxErr.ErrInternal);
}
return(Pts[0]);
}
public int GetColumn(string ColumnName)
{
int dc = Data.GetColumn(ColumnName);
if (dc < 0)
{
FlxMessages.ThrowException(FlxErr.ErrColumNotFound, ColumnName, Name);
}
return(dc);
}
/// <summary>
/// Returns an string token
/// </summary>
private static string GetString(string s, int MaxStringConstantLen)
{
string Result = s.Replace("\"", "\"\"");
if (MaxStringConstantLen > 0 && s.Length > MaxStringConstantLen)
{
FlxMessages.ThrowException(FlxErr.ErrStringConstantInFormulaTooLong, Result, String.Empty);
}
return(Result);
}
public override string GetColumnCaption(int columnIndex)
{
switch (columnIndex)
{
case 0: return("Position");
case 1: return("Name");
}
FlxMessages.ThrowException(FlxErr.ErrInvalidColumn, columnIndex);
return(String.Empty);
}
internal static int TotalSizeWithArray(TParsedTokenList Data, TFormulaType FmlaType)
{
if (Data.TextLenght > FlxConsts.Max_FormulaLen97_2003)
{
FlxMessages.ThrowException(FlxErr.ErrFormulaTooLong, TFormulaConvertInternalToText.AsString(Data, 0, 0, null));
}
int DataLenNoArray;
byte[] bData = TFormulaConvertInternalToBiff8.GetTokenData(null, Data, FmlaType, out DataLenNoArray);
return(bData.Length);
}
internal IDbDataParameter this[string key]
{
get
{
IDbDataParameter Result = null;
if (!FList.TryGetValue(key, out Result))
{
FlxMessages.ThrowException(FlxErr.ErrSqlParameterNotFound, key);
}
return(Result);
}
}
private static ImageCodecInfo GetTiffEncoder()
{
foreach (ImageCodecInfo ImageEncoder in ImageCodecInfo.GetImageEncoders())
{
if (ImageEncoder.MimeType == "image/tiff")
{
return(ImageEncoder);
}
}
FlxMessages.ThrowException(FlxErr.ErrTiffEncoderNotFound);
return(null); //just to compile.
}
private void FillNotLoaded()
{
foreach (TEscherOPTRecord R in NotLoadedOpt)
{
long ShapeId = R.ShapeId();
if (ShapeId == -1)
{
FlxMessages.ThrowException(FlxErr.ErrInternal);
}
OptsByShapeId[ShapeId] = R;
}
NotLoadedOpt.Clear();
}
/// <summary>
/// This method will be called each time that the master datasource moves its position. Use it to filter the data returned
/// if this is used on a master-detail relationship.
/// </summary>
/// <remarks>
/// You do not need to implement this method if you are not using Master-Detail or Split relationships.</remarks>
/// <param name="masterDetailLinks">List of all the master tables that are related to this one.
/// If there are no parents on this VirtualDataTableState, this will be an empty array, not null.
/// Use it on <see cref="GetValue"/> to filter the data and then return only the records that satisfy the master-detail relationships on <see cref="GetValue"/>
/// </param>
/// <param name="splitLink">Parent Split table if this dataset is on a Split relationship, or null if there is none.
/// Use it to know how many records you should retun on <see cref="RowCount"/>. Note that a table might be on Master-Detail relationship
/// *and* split relationship. In this case you need to first filter the records that are on the master detail relationship, and then apply the split to them.
/// </param>
public virtual void MoveMasterRecord(TMasterDetailLink[] masterDetailLinks, TSplitLink splitLink)
{
if (masterDetailLinks == null)
{
return;
}
for (int i = 0; i < masterDetailLinks.Length; i++)
{
if (masterDetailLinks[i].ParentDataSource.RowCount != 0) //Avoid throwing an exception if there is actually only one master record.
{
FlxMessages.ThrowException(FlxErr.ErrTableDoesNotSupportMasterDetail, FTableData.TableName);
}
}
}
private static void Filter(ref VirtualDataTable aTable, string RowFilter, ref bool TableNeedsDispose, string aName)
{
RowFilter = RowFilter.Trim();
if (string.IsNullOrEmpty(RowFilter))
{
if (aTable.TableName != aName)
{
VirtualDataTable nTable = aTable.FilterData(aName, null);
if (aTable != null && TableNeedsDispose)
{
aTable.Dispose();
}
aTable = nTable;
TableNeedsDispose = true;
}
return;
}
int fPos = RowFilter.IndexOf(ReportTag.StrOpenParen);
if (fPos > 2)
{
if (String.Equals(RowFilter.Substring(0, fPos).Trim(), ReportTag.ConfigTag(ConfigTagEnum.Distinct), StringComparison.InvariantCultureIgnoreCase))
{
if (RowFilter[RowFilter.Length - 1] != ReportTag.StrCloseParen)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidFilterParen, RowFilter);
}
VirtualDataTable bTable = aTable.GetDistinct(aName, GetColumnsForDistinct(aTable, RowFilter.Substring(fPos + 1, RowFilter.Length - fPos - 2)));
if (aTable != null && TableNeedsDispose)
{
aTable.Dispose();
}
aTable = bTable;
TableNeedsDispose = true;
return;
}
}
VirtualDataTable cTable = aTable.FilterData(aName, RowFilter);
if (aTable != null && TableNeedsDispose)
{
aTable.Dispose();
}
aTable = cTable;
TableNeedsDispose = true;
}
internal static void SaveToStream(TNameRecordList Names, IDataStream Workbook, TFormulaType FmlaType, TParsedTokenList Data, bool WriteLen)
{
if (Data.TextLenght > FlxConsts.Max_FormulaLen97_2003)
{
FlxMessages.ThrowException(FlxErr.ErrFormulaTooLong, TFormulaConvertInternalToText.AsString(Data, 0, 0, null));
}
int FmlaNoArrayLen;
byte[] bData = TFormulaConvertInternalToBiff8.GetTokenData(Names, Data, FmlaType, out FmlaNoArrayLen);
if (WriteLen)
{
Workbook.Write16((UInt16)FmlaNoArrayLen);
}
Workbook.Write(bData, bData.Length);
}
public object GetValueForRow(int Row, int ColumnIndex)
{
if ((TPseudoColumn)ColumnIndex == TPseudoColumn.RowCount)
{
return(DataState.RowCount); //First so it does not check for eof.
}
if (Row >= RecordCount)
{
FlxMessages.ThrowException(FlxErr.ErrReadAfterEOF);
}
if (Row < 0)
{
FlxMessages.ThrowException(FlxErr.ErrReadBeforeBOF);
}
if (ColumnIndex >= ColumnCount)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidColumn, ColumnIndex);
}
if (ColumnIndex < 0)
{
switch ((TPseudoColumn)ColumnIndex)
{
case TPseudoColumn.RowPos: return(DataState.Position);
default: FlxMessages.ThrowException(FlxErr.ErrInvalidColumn, ColumnIndex); break;
}
}
if (Row == DataState.Position)
{
return(DataState.GetValue(ColumnIndex)); //avoid an exception if movetorecord is not supported and we really don't need to move to record.
}
int SavePosition = DataState.Position;
try
{
DataState.DoMoveToRecord(Row);
return(DataState.GetValue(ColumnIndex));
}
finally
{
DataState.DoMoveToRecord(SavePosition);
}
}
private static int[] GetColumnsForDistinct(VirtualDataTable aTable, string SortString)
{
if (SortString.Trim().Length == 0)
{
FlxMessages.ThrowException(FlxErr.ErrInvalidDistinctParams);
}
int start = 0;
int count = 0;
do
{
start = SortString.IndexOf(ReportTag.ParamDelim, start);
if (start > 0)
{
count++;
start++;
}
}while (start > 0);
start = 0;
int oldStart = 0;
int[] Result = new int[count + 1];
for (int i = 0; i < count; i++)
{
start = SortString.IndexOf(ReportTag.ParamDelim, oldStart);
Result[i] = aTable.GetColumn(SortString.Substring(oldStart, start - oldStart).Trim());
if (Result[i] < 0)
{
FlxMessages.ThrowException(FlxErr.ErrColumNotFound, SortString.Substring(oldStart, start - oldStart).Trim(), aTable.TableName);
}
if (i < count)
{
oldStart = start + 1;
}
}
Result[count] = aTable.GetColumn(SortString.Substring(oldStart).Trim());
if (Result[count] < 0)
{
FlxMessages.ThrowException(FlxErr.ErrColumNotFound, SortString.Substring(oldStart).Trim(), aTable.TableName);
}
return(Result);
}
private static int FindName(TNameRecordList Names, string Name)
{
if (Names == null)
{
return(0); //Calculating length.
}
for (int i = 0; i < Names.Count; i++)
{
if (String.Equals(Name, Names[i].Name, StringComparison.CurrentCultureIgnoreCase) && (Names[i].IsAddin))
{
return(i + 1);
}
}
FlxMessages.ThrowException(FlxErr.ErrCantFindNamedRange, Name);
return(-1);
}
private static void MoveRowRange(TKeyList Items, ExcelFile xls, TXlsCellRange Range, bool ByRows)
{
if (!ByRows)
{
Range = Range.Transpose();
}
//optimization if part (or all) of the range is already sorted.
int FirstRow = Range.Top;
FirstRow = AdvanceToNextUnsorted(Items, Range, FirstRow);
if (FirstRow > Range.Bottom)
{
return;
}
int LastRow = Range.Bottom;
int StagingRow = LastRow + 1;
if (ByRows)
{
xls.InsertAndCopyRange(new TXlsCellRange(StagingRow, Range.Left, StagingRow, Range.Right), StagingRow, Range.Left, 1, TFlxInsertMode.ShiftRangeDown, TRangeCopyMode.None); //add a row at the bottom to swap rows.
}
else
{
xls.InsertAndCopyRange(new TXlsCellRange(Range.Left, StagingRow, Range.Right, StagingRow), Range.Left, StagingRow, 1, TFlxInsertMode.ShiftRangeRight, TRangeCopyMode.None); //add a column at the right to swap columns.
}
do
{
PartialSort(Items, xls, Range, ByRows, FirstRow, StagingRow);
int fr = FirstRow;
FirstRow = AdvanceToNextUnsorted(Items, Range, FirstRow);
if (fr == FirstRow)
{
FlxMessages.ThrowException(FlxErr.ErrInternal);
}
} while (FirstRow < Range.Bottom);
if (ByRows)
{
xls.DeleteRange(new TXlsCellRange(StagingRow, Range.Left, StagingRow, Range.Right), TFlxInsertMode.ShiftRangeDown);
}
else
{
xls.DeleteRange(new TXlsCellRange(Range.Left, StagingRow, Range.Right, StagingRow), TFlxInsertMode.ShiftRangeRight);
}
}
public override int GetColumn(string columnName)
{
#if (COMPACTFRAMEWORK)
switch (columnName.ToLower(CultureInfo.InvariantCulture))
#else
switch (columnName.ToLowerInvariant())
#endif
{
case "position": return(0);
case "name": return(1);
default:
break;
}
FlxMessages.ThrowException(FlxErr.ErrInvalidColumn, columnName);
return(0);
}
public static void WriteStringInStream(TPdfStream DataStream, string Text, real FontSize, TPdfFont aFont, ref string LastFont, string EndNewText, string StartNewText2, string EndNewText2, TTracedFonts TracedFonts)
{
TPdfFont LastFallbackFont = aFont;
int StartText = 0;
int TLen = Text.Length;
for (int i = 0; i <= TLen; i++)
{
TPdfFont FallbackFont = null;
if (i < TLen)
{
FallbackFont = aFont.Fallback(Text[i], 0);
if (FallbackFont == null)
{
FallbackFont = aFont;
}
}
if (FallbackFont != LastFallbackFont)
{
WriteSimpleString(DataStream, Text.Substring(StartText, i - StartText), LastFallbackFont, EndNewText);
StartText = i;
if (FallbackFont != null)
{
TPdfBaseRecord.Write(DataStream, EndNewText2);
FallbackFont.Select(DataStream, FontSize, ref LastFont);
if (FlexCelTrace.HasListeners && FallbackFont != aFont && !TracedFonts.ContainsKey(aFont.FontName + ";" + FallbackFont.FontName))
{
TracedFonts.Add(aFont.FontName + ";" + FallbackFont.FontName, String.Empty);
FlexCelTrace.Write(new TPdfUsedFallbackFontError(FlxMessages.GetString(FlxErr.ErrUsedFallbackFont, aFont.FontName, FallbackFont.FontName), aFont.FontName, FallbackFont.FontName));
}
TPdfBaseRecord.Write(DataStream, StartNewText2);
LastFallbackFont = FallbackFont;
}
}
}
}
public TFlexCelDataSource(string dtName, VirtualDataTable aData, TRelationshipList ExtraRelations, TRelationshipList StaticRelations,
TBand MasterBand, string Sort, IDataTableFinder TableFinder)
{
SplitLink = null;
TBand band = MasterBand;
TMasterDetailLinkList MasterDetailLinkList = new TMasterDetailLinkList();
while (band != null)
{
if (band.DataSource != null)
{
TRelation RelToMaster = band.DataSource.Data.GetRelationWith(aData);
if (RelToMaster != null)
{
MasterDetailLinkList.AddRelation(band.DataSource.DataState, RelToMaster);
}
//Create the splitlink.
TMasterSplitDataTableState SplitMaster = band.DataSource.DataState as TMasterSplitDataTableState;
if (SplitMaster != null && String.Equals(SplitMaster.DetailName, dtName, StringComparison.CurrentCultureIgnoreCase))
{
if (SplitLink != null)
{
FlxMessages.ThrowException(FlxErr.ErrSplitNeedsOnlyOneMaster, dtName, SplitMaster.TableName, SplitLink.ParentDataSource.TableName);
}
SplitLink = new TSplitLink(SplitMaster, SplitMaster.SplitCount);
}
AddExtraRelationships(TableFinder, aData, ExtraRelations, band, MasterDetailLinkList);
AddExtraRelationships(TableFinder, aData, StaticRelations, band, MasterDetailLinkList);
}
band = band.MasterBand;
}
MasterDetailLinks = MasterDetailLinkList.ToArray();
Data = aData;
DataState = aData.CreateState(Sort, MasterDetailLinks, SplitLink);
DataState.FTableName = dtName;
FName = dtName;
}
private void DoPreload(TBand aParentBand, string aRange, string aFileName, TDataSourceInfoList aDsInfoList, int aNestedLevel, ExcelFile Result, MemoryStream MStream, FlexCelReport aParentReport)
{
Result.Open(MStream);
Result.ActiveFileName = aFileName;
TXlsNamedRange XlsRange = Result.GetNamedRange(aRange, -1);
if (XlsRange == null)
{
FlxMessages.ThrowException(FlxErr.ErrCantFindNamedRange, aRange);
}
FRangeName = aRange;
MainBand = CreateStartingBand(XlsRange, aParentBand, aRange);
Report = new FlexCelReport(aNestedLevel, FTagText, aDsInfoList, aParentReport);
if (!StaticInclude)
{
Report.PreLoad(Result, ref MainBand, XlsRange.SheetIndex, ref FData, out KeepRows, out KeepCols);
}
Result.ActiveSheet = XlsRange.SheetIndex;
}
UInt16 ActualRecordSize(ref int Pos)
{
if (Pos > SelectedCells.Length)
{
FlxMessages.ThrowException(FlxErr.ErrInternal);
}
int DeltaPos = ((XlsConsts.MaxRecordDataSize - XlsConsts.SizeOfTRecordHeader - 9) / 6) - 1;
Pos += DeltaPos;
int IncludedCells = DeltaPos;
if (Pos > SelectedCells.Length)
{
IncludedCells = SelectedCells.Length - (Pos - DeltaPos);
Pos = SelectedCells.Length;
}
return((UInt16)(XlsConsts.SizeOfTRecordHeader +
9 + //Fixed part
IncludedCells * 6));
}
public object GetValue(int ColumnIndex)
{
if ((TPseudoColumn)ColumnIndex == TPseudoColumn.RowCount)
{
return(DataState.RowCount); //First so it does not check for eof.
}
if (Eof())
{
FlxMessages.ThrowException(FlxErr.ErrReadAfterEOF);
}
if (ColumnIndex < 0)
{
switch ((TPseudoColumn)ColumnIndex)
{
case TPseudoColumn.RowPos: return(DataState.Position);
default: FlxMessages.ThrowException(FlxErr.ErrInternal); break; //Should never come here.
}
}
return(DataState.GetValue(ColumnIndex));
}
