{
xlsbiff8.pas

Writes an Excel 8 file

An Excel worksheet stream consists of a number of subsequent records.
To ensure a properly formed file, the following order must be respected:

1st record:        BOF
2nd to Nth record: Any record
Last record:       EOF

Excel 8 files are OLE compound document files, and must be written using the
fpOLE library.

Records Needed to Make a BIFF8 File Microsoft Excel Can Use:

Required Records:

BOF - Set the 6 byte offset to 0x0005 (workbook globals)
Window1
FONT - At least five of these records must be included
XF - At least 15 Style XF records and 1 Cell XF record must be included
STYLE
BOUNDSHEET - Include one BOUNDSHEET record per worksheet
EOF

BOF - Set the 6 byte offset to 0x0010 (worksheet)
INDEX
DIMENSIONS
WINDOW2
EOF

The row and column numbering in BIFF files is zero-based.

Excel file format specification obtained from:

http://sc.openoffice.org/excelfileformat.pdf

AUTHORS:  Felipe Monteiro de Carvalho
          Jose Mejuto
}
unit xlsbiff8;

{$ifdef fpc}
  {$mode delphi}
{$endif}

// The new OLE code is much better, so always use it
{$define USE_NEW_OLE}

interface

uses
  Classes, SysUtils, fpcanvas, DateUtils,
  fpspreadsheet, xlscommon,
  {$ifdef USE_NEW_OLE}
  fpolebasic,
  {$else}
  fpolestorage,
  {$endif}
  fpsutils, lazutf8;

type
  TXFRecordData = class
  public
    FormatIndex: Integer;
  end;

  TFormatRecordData = class
  public
    Index: Integer;
    FormatString: widestring;
  end;

  { TsSpreadBIFF8Reader }

  TsSpreadBIFF8Reader = class(TsSpreadBIFFReader)
  private
    RecordSize: Word;
    PendingRecordSize: SizeInt;
    FWorksheet: TsWorksheet;
    FWorksheetNames: TStringList;
    FCurrentWorksheet: Integer;
    FSharedStringTable: TStringList;
    FXFList: TFPList; // of TXFRecordData
    FFormatList: TFPList; // of TFormatRecordData
    function DecodeRKValue(const ARK: DWORD): Double;
    function ReadWideString(const AStream: TStream;const ALength: WORD): WideString; overload;
    function ReadWideString(const AStream: TStream; const AUse8BitLength: Boolean): WideString; overload;
    procedure ReadWorkbookGlobals(AStream: TStream; AData: TsWorkbook);
    procedure ReadWorksheet(AStream: TStream; AData: TsWorkbook);
    procedure ReadBoundsheet(AStream: TStream);

    procedure ReadRKValue(const AStream: TStream);
    procedure ReadMulRKValues(const AStream: TStream);
    procedure ReadFormulaExcel(AStream: TStream);
    procedure ReadRowColXF(const AStream: TStream; out ARow,ACol,AXF: WORD);
    function ReadString(const AStream: TStream; const ALength: WORD): UTF8String;
    procedure ReadRichString(const AStream: TStream);
    procedure ReadSST(const AStream: TStream);
    procedure ReadLabelSST(const AStream: TStream);
    //
    procedure ReadXF(const AStream: TStream);
    procedure ReadFormat(const AStream: TStream);
    function  FindFormatRecordForCell(const AFXIndex: Integer): TFormatRecordData;
    class function ConvertExcelDateToTDateTime(const AExcelDateNum: Double; ABaseDate: TDateTime): TDateTime;

    // Workbook Globals records
    // procedure ReadCodepage in xlscommon
    procedure ReadFont(const AStream: TStream);
  public
    constructor Create; override;
    destructor Destroy; override;
    { General reading methods }
    procedure ReadFromFile(AFileName: string; AData: TsWorkbook); override;
    procedure ReadFromStream(AStream: TStream; AData: TsWorkbook); override;
    { Record writing methods }
    procedure ReadFormula(AStream: TStream); override;
    procedure ReadLabel(AStream: TStream); override;
    procedure ReadNumber(AStream: TStream); override;
  end;

  { TsSpreadBIFF8Writer }

  TsSpreadBIFF8Writer = class(TsSpreadBIFFWriter)
  private
    procedure WriteXFIndex(AStream: TStream; ACell: PCell);
    procedure WriteXFFieldsForFormattingStyles(AStream: TStream);
  protected
    procedure AddDefaultFormats(); override;
  public
//    constructor Create;
//    destructor Destroy; override;
    { General writing methods }
    procedure WriteToFile(const AFileName: string; AData: TsWorkbook;
      const AOverwriteExisting: Boolean = False); override;
    procedure WriteToStream(AStream: TStream; AData: TsWorkbook); override;
    { Record writing methods }
    procedure WriteBOF(AStream: TStream; ADataType: Word);
    function  WriteBoundsheet(AStream: TStream; ASheetName: string): Int64;
    // procedure WriteCodepage in xlscommon
    procedure WriteDimensions(AStream: TStream; AWorksheet: TsWorksheet);
    procedure WriteEOF(AStream: TStream);
    procedure WriteFont(AStream: TStream; AFont: TFPCustomFont);
    procedure WriteFormula(AStream: TStream; const ARow, ACol: Word; const AFormula: TsFormula); override;
    procedure WriteRPNFormula(AStream: TStream; const ARow, ACol: Word; const AFormula: TsRPNFormula); override;
    procedure WriteIndex(AStream: TStream);
    procedure WriteLabel(AStream: TStream; const ARow, ACol: Word; const AValue: string; ACell: PCell); override;
    procedure WriteNumber(AStream: TStream; const ARow, ACol: Cardinal; const AValue: double; ACell: PCell); override;
    procedure WritePalette(AStream: TStream);
    procedure WriteStyle(AStream: TStream);
    procedure WriteWindow1(AStream: TStream);
    procedure WriteWindow2(AStream: TStream; ASheetSelected: Boolean);
    procedure WriteXF(AStream: TStream; AFontIndex: Word;
      AXF_TYPE_PROT, ATextRotation: Byte; ABorders: TsCellBorders;
      AddBackground: Boolean = False; ABackgroundColor: TsColor = scSilver);
  end;

implementation

const
  { Excel record IDs }
  INT_EXCEL_ID_BOF        = $0809;
  INT_EXCEL_ID_BOUNDSHEET = $0085; // Renamed to SHEET in the latest OpenOffice docs
  INT_EXCEL_ID_EOF        = $000A;
  INT_EXCEL_ID_DIMENSIONS = $0200;
  INT_EXCEL_ID_FONT       = $0031;
  INT_EXCEL_ID_FORMULA    = $0006;
  INT_EXCEL_ID_INDEX      = $020B;
  INT_EXCEL_ID_LABEL      = $0204;
  INT_EXCEL_ID_NUMBER     = $0203;
  INT_EXCEL_ID_STYLE      = $0293;
  INT_EXCEL_ID_WINDOW1    = $003D;
  INT_EXCEL_ID_WINDOW2    = $023E;
  INT_EXCEL_ID_XF         = $00E0;
  INT_EXCEL_ID_RSTRING    = $00D6;
  INT_EXCEL_ID_RK         = $027E;
  INT_EXCEL_ID_MULRK      = $00BD;
  INT_EXCEL_ID_SST        = $00FC; //BIFF8 only
  INT_EXCEL_ID_CONTINUE   = $003C;
  INT_EXCEL_ID_LABELSST   = $00FD; //BIFF8 only
  INT_EXCEL_ID_PALETTE    = $0092;
  INT_EXCEL_ID_CODEPAGE   = $0042;
  INT_EXCEL_ID_FORMAT     = $041E;

  { Cell Addresses constants }
  MASK_EXCEL_ROW          = $3FFF;
  MASK_EXCEL_RELATIVE_ROW = $4000;
  MASK_EXCEL_RELATIVE_COL = $8000;

  { BOF record constants }
  INT_BOF_BIFF8_VER       = $0600;
  INT_BOF_WORKBOOK_GLOBALS= $0005;
  INT_BOF_VB_MODULE       = $0006;
  INT_BOF_SHEET           = $0010;
  INT_BOF_CHART           = $0020;
  INT_BOF_MACRO_SHEET     = $0040;
  INT_BOF_WORKSPACE       = $0100;
  INT_BOF_BUILD_ID        = $1FD2;
  INT_BOF_BUILD_YEAR      = $07CD;

  { FONT record constants }
  INT_FONT_WEIGHT_NORMAL  = $0190;
  INT_FONT_WEIGHT_BOLD    = $02BC;

  { FORMULA record constants }
  MASK_FORMULA_RECALCULATE_ALWAYS  = $0001;
  MASK_FORMULA_RECALCULATE_ON_OPEN = $0002;
  MASK_FORMULA_SHARED_FORMULA      = $0008;

  { STYLE record constants }
  MASK_STYLE_BUILT_IN     = $8000;

  { WINDOW1 record constants }
  MASK_WINDOW1_OPTION_WINDOW_HIDDEN             = $0001;
  MASK_WINDOW1_OPTION_WINDOW_MINIMISED          = $0002;
  MASK_WINDOW1_OPTION_HORZ_SCROLL_VISIBLE       = $0008;
  MASK_WINDOW1_OPTION_VERT_SCROLL_VISIBLE       = $0010;
  MASK_WINDOW1_OPTION_WORKSHEET_TAB_VISIBLE     = $0020;

  { WINDOW2 record constants }
  MASK_WINDOW2_OPTION_SHOW_FORMULAS             = $0001;
  MASK_WINDOW2_OPTION_SHOW_GRID_LINES           = $0002;
  MASK_WINDOW2_OPTION_SHOW_SHEET_HEADERS        = $0004;
  MASK_WINDOW2_OPTION_PANES_ARE_FROZEN          = $0008;
  MASK_WINDOW2_OPTION_SHOW_ZERO_VALUES          = $0010;
  MASK_WINDOW2_OPTION_AUTO_GRIDLINE_COLOR       = $0020;
  MASK_WINDOW2_OPTION_COLUMNS_RIGHT_TO_LEFT     = $0040;
  MASK_WINDOW2_OPTION_SHOW_OUTLINE_SYMBOLS      = $0080;
  MASK_WINDOW2_OPTION_REMOVE_SPLITS_ON_UNFREEZE = $0100;
  MASK_WINDOW2_OPTION_SHEET_SELECTED            = $0200;
  MASK_WINDOW2_OPTION_SHEET_ACTIVE              = $0400;

  { XF substructures }

  { XF_TYPE_PROT - XF Type and Cell protection (3 Bits) - BIFF3-BIFF8 }
  MASK_XF_TYPE_PROT_LOCKED            = $1;
  MASK_XF_TYPE_PROT_FORMULA_HIDDEN    = $2;
  MASK_XF_TYPE_PROT_STYLE_XF          = $4; // 0 = CELL XF

  { XF_USED_ATTRIB - Attributes from parent Style XF (6 Bits) - BIFF3-BIFF8
  
    In a CELL XF a cleared bit means that the parent attribute is used,
    while a set bit indicates that the data in this XF is used

    In a STYLE XF a cleared bit means that the data in this XF is used,
    while a set bit indicates that the attribute should be ignored }
  MASK_XF_USED_ATTRIB_NUMBER_FORMAT   = $04;
  MASK_XF_USED_ATTRIB_FONT            = $08;
  MASK_XF_USED_ATTRIB_TEXT            = $10;
  MASK_XF_USED_ATTRIB_BORDER_LINES    = $20;
  MASK_XF_USED_ATTRIB_BACKGROUND      = $40;
  MASK_XF_USED_ATTRIB_CELL_PROTECTION = $80;

  { XF_VERT_ALIGN }
  MASK_XF_VERT_ALIGN_TOP              = $00;
  MASK_XF_VERT_ALIGN_CENTRED          = $10;
  MASK_XF_VERT_ALIGN_BOTTOM           = $20;
  MASK_XF_VERT_ALIGN_JUSTIFIED        = $30;

  { XF_ROTATION }

  XF_ROTATION_HORIZONTAL                 = 0;
  XF_ROTATION_90_DEGREE_COUNTERCLOCKWISE = 90;
  XF_ROTATION_90_DEGREE_CLOCKWISE        = 180;

  { XF record constants }
  MASK_XF_TYPE_PROT                   = $0007;
  MASK_XF_TYPE_PROT_PARENT            = $FFF0;

  MASK_XF_VERT_ALIGN                  = $70;

{
  Exported functions
}

{ TsSpreadBIFF8Writer }

{ Index to XF record, according to formatting }
procedure TsSpreadBIFF8Writer.WriteXFIndex(AStream: TStream; ACell: PCell);
var
  lIndex: Integer;
  lXFIndex: Word;
begin
  // First try the fast methods for default formats
  if ACell^.UsedFormattingFields = [] then
  begin
    AStream.WriteWord(WordToLE(15));
    Exit;
  end;

  if ACell^.UsedFormattingFields = [uffTextRotation] then
  begin
    case ACell^.TextRotation of
      rt90DegreeCounterClockwiseRotation: AStream.WriteWord(WordToLE(16));
      rt90DegreeClockwiseRotation: AStream.WriteWord(WordToLE(17));
    else
      AStream.WriteWord(WordToLE(15));
    end;
    Exit;
  end;

  if ACell^.UsedFormattingFields = [uffBold] then
  begin
    AStream.WriteWord(WordToLE(18));
    Exit;
  end;

  // If not, then we need to search in the list of dynamic formats

  lIndex := FindFormattingInList(ACell);
  // Carefully check the index
  if (lIndex < 0) or (lIndex > Length(FFormattingStyles)) then
    raise Exception.Create('[TsSpreadBIFF8Writer.WriteXFIndex] Invalid Index, this should not happen!');

  lXFIndex := FFormattingStyles[lIndex].Row;

  AStream.WriteWord(WordToLE(lXFIndex));
end;

procedure TsSpreadBIFF8Writer.WriteXFFieldsForFormattingStyles(AStream: TStream);
var
  i: Integer;
  lFontIndex: Word;
  lTextRotation: Byte;
  lBorders: TsCellBorders;
  lAddBackground: Boolean;
  lBackgroundColor: TsColor;
begin
  // The first 4 styles were already added
  for i := 4 to Length(FFormattingStyles) - 1 do
  begin
    // Default styles
    lFontIndex := 0;
    lTextRotation := XF_ROTATION_HORIZONTAL;
    lBorders := [];
    lAddBackground := False;
    lBackgroundColor := FFormattingStyles[i].BackgroundColor;

    // Now apply the modifications
    if uffBorder in FFormattingStyles[i].UsedFormattingFields then
      lBorders := FFormattingStyles[i].Border;

    if uffTextRotation in FFormattingStyles[i].UsedFormattingFields then
    begin
      case FFormattingStyles[i].TextRotation of
      trHorizontal:                       lTextRotation := XF_ROTATION_HORIZONTAL;
      rt90DegreeClockwiseRotation:        lTextRotation := XF_ROTATION_90_DEGREE_CLOCKWISE;
      rt90DegreeCounterClockwiseRotation: lTextRotation := XF_ROTATION_90_DEGREE_COUNTERCLOCKWISE;
      end;
    end;

    if uffBold in FFormattingStyles[i].UsedFormattingFields then
      lFontIndex := 1;

    if uffBackgroundColor in FFormattingStyles[i].UsedFormattingFields then
      lAddBackground := True;

    // And finally write the style
    WriteXF(AStream, lFontIndex, 0, lTextRotation, lBorders, lAddBackground, lBackgroundColor);
  end;
end;

{@@
  These are default formats which are added as XF fields regardless of being used
  in the document or not.
}
procedure TsSpreadBIFF8Writer.AddDefaultFormats();
begin
  NextXFIndex := 19;

  SetLength(FFormattingStyles, 4);

  // XF15 - Default, no formatting
  FFormattingStyles[0].UsedFormattingFields := [];
  FFormattingStyles[0].Row := 15;

  // XF16 - Rotated
  FFormattingStyles[1].UsedFormattingFields := [uffTextRotation];
  FFormattingStyles[1].Row := 16;
  FFormattingStyles[1].TextRotation := rt90DegreeCounterClockwiseRotation;

  // XF17 - Rotated
  FFormattingStyles[2].UsedFormattingFields := [uffTextRotation];
  FFormattingStyles[2].Row := 17;
  FFormattingStyles[2].TextRotation := rt90DegreeClockwiseRotation;

  // XF18 - Bold
  FFormattingStyles[3].UsedFormattingFields := [uffBold];
  FFormattingStyles[3].Row := 18;
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteToFile ()
*
*  DESCRIPTION:    Writes an Excel BIFF8 file to the disc
*
*                  The BIFF 8 writer overrides this method because
*                  BIFF 8 is written as an OLE document, and our
*                  current OLE document writing method involves:
*
*                  1 - Writing the BIFF data to a memory stream
*
*                  2 - Write the memory stream data to disk using
*                      COM functions
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteToFile(const AFileName: string;
  AData: TsWorkbook; const AOverwriteExisting: Boolean);
var
  MemStream: TMemoryStream;
  OutputStorage: TOLEStorage;
  OLEDocument: TOLEDocument;
begin
  MemStream := TMemoryStream.Create;
  OutputStorage := TOLEStorage.Create;
  try
    WriteToStream(MemStream, AData);

    // Only one stream is necessary for any number of worksheets
    OLEDocument.Stream := MemStream;

    OutputStorage.WriteOLEFile(AFileName, OLEDocument, AOverwriteExisting, 'Workbook');
  finally
    MemStream.Free;
    OutputStorage.Free;
  end;
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteToStream ()
*
*  DESCRIPTION:    Writes an Excel BIFF8 record structure
*
*                  Be careful as this method doesn't write the OLE
*                  part of the document, just the BIFF records
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteToStream(AStream: TStream; AData: TsWorkbook);
var
  FontData: TFPCustomFont;
  MyData: TMemoryStream;
  CurrentPos: Int64;
  Boundsheets: array of Int64;
  i, len: Integer;
begin
  { Write workbook globals }

  WriteBOF(AStream, INT_BOF_WORKBOOK_GLOBALS);

  WriteWindow1(AStream);

  FontData := TFPCustomFont.Create;
  try
    FontData.Name := 'Arial';

    // FONT0 - normal
    WriteFont(AStream, FontData);
    // FONT1 - bold
    FontData.Bold := True;
    WriteFont(AStream, FontData);
    FontData.Bold := False;
    // FONT2
    WriteFont(AStream, FontData);
    // FONT3
    WriteFont(AStream, FontData);
    // FONT5
    WriteFont(AStream, FontData);
  finally
   FontData.Free;
  end;
  
  // PALETTE
  WritePalette(AStream);

  // XF0
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF1
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF2
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF3
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF4
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF5
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF6
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF7
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF8
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF9
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF10
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF11
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF12
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF13
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF14
  WriteXF(AStream, 0, MASK_XF_TYPE_PROT_STYLE_XF, XF_ROTATION_HORIZONTAL, []);
  // XF15 - Default, no formatting
  WriteXF(AStream, 0, 0, XF_ROTATION_HORIZONTAL, []);
  // XF16 - Rotated
  WriteXF(AStream, 0, 0, XF_ROTATION_90_DEGREE_COUNTERCLOCKWISE, []);
  // XF17 - Rotated
  WriteXF(AStream, 0, 0, XF_ROTATION_90_DEGREE_CLOCKWISE, []);
  // XF18 - Bold
  WriteXF(AStream, 1, 0, XF_ROTATION_HORIZONTAL, []);
  // Add further all non-standard formatting styles
  ListAllFormattingStyles(AData);
  WriteXFFieldsForFormattingStyles(AStream);

  WriteStyle(AStream);

  // A BOUNDSHEET for each worksheet
  for i := 0 to AData.GetWorksheetCount - 1 do
  begin
    len := Length(Boundsheets);
    SetLength(Boundsheets, len + 1);
    Boundsheets[len] := WriteBoundsheet(AStream, AData.GetWorksheetByIndex(i).Name);
  end;
  
  WriteEOF(AStream);

  { Write each worksheet }

  for i := 0 to AData.GetWorksheetCount - 1 do
  begin
    { First goes back and writes the position of the BOF of the
      sheet on the respective BOUNDSHEET record }
    CurrentPos := AStream.Position;
    AStream.Position := Boundsheets[i];
    AStream.WriteDWord(DWordToLE(DWORD(CurrentPos)));
    AStream.Position := CurrentPos;

    WriteBOF(AStream, INT_BOF_SHEET);

    WriteIndex(AStream);

    WriteDimensions(AStream, AData.GetWorksheetByIndex(i));

    WriteWindow2(AStream, True);

    WriteCellsToStream(AStream, AData.GetWorksheetByIndex(i).Cells);

    WriteEOF(AStream);
  end;
  
  { Cleanup }
  
  SetLength(Boundsheets, 0);
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteBOF ()
*
*  DESCRIPTION:    Writes an Excel 8 BOF record
*
*                  This must be the first record on an Excel 8 stream
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteBOF(AStream: TStream; ADataType: Word);
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_BOF));
  AStream.WriteWord(WordToLE(16));

  { BIFF version. Should only be used if this BOF is for the workbook globals }
  { OpenOffice rejects to correctly read xls files if this field is
    omitted as docs. says, or even if it is being written to zero value,
    Not tested with Excel, but MSExcel reader opens it as expected }
  AStream.WriteWord(WordToLE(INT_BOF_BIFF8_VER));

  { Data type }
  AStream.WriteWord(WordToLE(ADataType));

  { Build identifier, must not be 0 }
  AStream.WriteWord(WordToLE(INT_BOF_BUILD_ID));

  { Build year, must not be 0 }
  AStream.WriteWord(WordToLE(INT_BOF_BUILD_YEAR));

  { File history flags }
  AStream.WriteDWord(DWordToLE(0));

  { Lowest Excel version that can read all records in this file 5?}
  AStream.WriteDWord(DWordToLE(0)); //?????????
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteBoundsheet ()
*
*  DESCRIPTION:    Writes an Excel 8 BOUNDSHEET record
*
*                  Always located on the workbook globals substream.
*
*                  One BOUNDSHEET is written for each worksheet.
*
*  RETURNS:        The stream position where the absolute stream position
*                  of the BOF of this sheet should be written (4 bytes size).
*
*******************************************************************}
function TsSpreadBIFF8Writer.WriteBoundsheet(AStream: TStream; ASheetName: string): Int64;
var
  Len: Byte;
  WideSheetName: WideString;
begin
  WideSheetName:=UTF8Decode(ASheetName);
  Len := Length(WideSheetName);

  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_BOUNDSHEET));
  AStream.WriteWord(WordToLE(6 + 1 + 1 + Len * Sizeof(WideChar)));

  { Absolute stream position of the BOF record of the sheet represented
    by this record }
  Result := AStream.Position;
  AStream.WriteDWord(DWordToLE(0));

  { Visibility }
  AStream.WriteByte(0);

  { Sheet type }
  AStream.WriteByte(0);

  { Sheet name: Unicode string char count 1 byte }
  AStream.WriteByte(Len);
  {String flags}
  AStream.WriteByte(1);
  AStream.WriteBuffer(WideStringToLE(WideSheetName)[1], Len * Sizeof(WideChar));
end;

{
  Writes an Excel 8 DIMENSIONS record

  nm = (rl - rf - 1) / 32 + 1 (using integer division)

  Excel, OpenOffice and FPSpreadsheet ignore the dimensions written in this record,
  but some other applications really use them, so they need to be correct.

  See bug 18886: excel5 files are truncated when imported
}
procedure TsSpreadBIFF8Writer.WriteDimensions(AStream: TStream; AWorksheet: TsWorksheet);
var
  lLastCol: Word;
  lLastRow: Integer;
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_DIMENSIONS));
  AStream.WriteWord(WordToLE(14));

  { Index to first used row }
  AStream.WriteDWord(DWordToLE(0));

  { Index to last used row, increased by 1 }
  lLastRow := GetLastRowIndex(AWorksheet)+1;
  AStream.WriteDWord(DWordToLE(lLastRow)); // Old dummy value: 33

  { Index to first used column }
  AStream.WriteWord(WordToLE(0));

  { Index to last used column, increased by 1 }
  lLastCol := GetLastColIndex(AWorksheet)+1;
  AStream.WriteWord(WordToLE(lLastCol)); // Old dummy value: 10

  { Not used }
  AStream.WriteWord(WordToLE(0));
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteEOF ()
*
*  DESCRIPTION:    Writes an Excel 8 EOF record
*
*                  This must be the last record on an Excel 8 stream
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteEOF(AStream: TStream);
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_EOF));
  AStream.WriteWord(WordToLE($0000));
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteFont ()
*
*  DESCRIPTION:    Writes an Excel 8 FONT record
*
*                  The font data is passed in an instance of TFPCustomFont
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteFont(AStream: TStream; AFont: TFPCustomFont);
var
  Len: Byte;
  WideFontName: WideString;
begin
  WideFontName:=AFont.Name;
  Len := Length(WideFontName);

  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_FONT));
  AStream.WriteWord(WordToLE(14 + 1 + 1 + Len * Sizeof(WideChar)));

  { Height of the font in twips = 1/20 of a point }
  AStream.WriteWord(WordToLE(200));

  { Option flags }
  if AFont.Bold then AStream.WriteWord(WordToLE(1))
  else AStream.WriteWord(WordToLE(0));

  { Colour index }
  AStream.WriteWord(WordToLE($7FFF));

  { Font weight }
  if AFont.Bold then AStream.WriteWord(WordToLE(INT_FONT_WEIGHT_BOLD))
  else AStream.WriteWord(WordToLE(INT_FONT_WEIGHT_NORMAL));

  { Escapement type }
  AStream.WriteWord(WordToLE(0));

  { Underline type }
  AStream.WriteByte(0);

  { Font family }
  AStream.WriteByte(0);

  { Character set }
  AStream.WriteByte(0);

  { Not used }
  AStream.WriteByte(0);

  { Font name: Unicodestring, char count in 1 byte }
  AStream.WriteByte(Len);
  { Widestring flags, 1=regular unicode LE string }
  AStream.WriteByte(1);
  AStream.WriteBuffer(WideStringToLE(WideFontName)[1], Len * Sizeof(WideChar));
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteFormula ()
*
*  DESCRIPTION:    Writes an Excel 5 FORMULA record
*
*                  To input a formula to this method, first convert it
*                  to RPN, and then list all it's members in the
*                  AFormula array
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteFormula(AStream: TStream; const ARow,
  ACol: Word; const AFormula: TsFormula);
{var
  FormulaResult: double;
  i: Integer;
  RPNLength: Word;
  TokenArraySizePos, RecordSizePos, FinalPos: Int64;}
begin
(*  RPNLength := 0;
  FormulaResult := 0.0;

  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_FORMULA));
  RecordSizePos := AStream.Position;
  AStream.WriteWord(WordToLE(22 + RPNLength));

  { BIFF Record data }
  AStream.WriteWord(WordToLE(ARow));
  AStream.WriteWord(WordToLE(ACol));

  { Index to XF Record }
  AStream.WriteWord($0000);

  { Result of the formula in IEE 754 floating-point value }
  AStream.WriteBuffer(FormulaResult, 8);

  { Options flags }
  AStream.WriteWord(WordToLE(MASK_FORMULA_RECALCULATE_ALWAYS));

  { Not used }
  AStream.WriteDWord(0);

  { Formula }

  { The size of the token array is written later,
    because it's necessary to calculate if first,
    and this is done at the same time it is written }
  TokenArraySizePos := AStream.Position;
  AStream.WriteWord(RPNLength);

  { Formula data (RPN token array) }
  for i := 0 to Length(AFormula) - 1 do
  begin
    { Token identifier }
    AStream.WriteByte(AFormula[i].TokenID);
    Inc(RPNLength);

    { Additional data }
    case AFormula[i].TokenID of

    { binary operation tokens }

    INT_EXCEL_TOKEN_TADD, INT_EXCEL_TOKEN_TSUB, INT_EXCEL_TOKEN_TMUL,
     INT_EXCEL_TOKEN_TDIV, INT_EXCEL_TOKEN_TPOWER: begin end;

    INT_EXCEL_TOKEN_TNUM:
    begin
      AStream.WriteBuffer(AFormula[i].DoubleValue, 8);
      Inc(RPNLength, 8);
    end;

    INT_EXCEL_TOKEN_TREFR, INT_EXCEL_TOKEN_TREFV, INT_EXCEL_TOKEN_TREFA:
    begin
      AStream.WriteWord(AFormula[i].Row and MASK_EXCEL_ROW);
      AStream.WriteByte(AFormula[i].Col);
      Inc(RPNLength, 3);
    end;

    end;
  end;

  { Write sizes in the end, after we known them }
  FinalPos := AStream.Position;
  AStream.position := TokenArraySizePos;
  AStream.WriteByte(RPNLength);
  AStream.Position := RecordSizePos;
  AStream.WriteWord(WordToLE(22 + RPNLength));
  AStream.position := FinalPos;*)
end;

procedure TsSpreadBIFF8Writer.WriteRPNFormula(AStream: TStream; const ARow,
  ACol: Word; const AFormula: TsRPNFormula);
var
  FormulaResult: double;
  i: Integer;
  RPNLength: Word;
  TokenArraySizePos, RecordSizePos, FinalPos: Int64;
  TokenID: Byte;
begin
  RPNLength := 0;
  FormulaResult := 0.0;

  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_FORMULA));
  RecordSizePos := AStream.Position;
  AStream.WriteWord(WordToLE(22 + RPNLength));

  { BIFF Record data }
  AStream.WriteWord(WordToLE(ARow));
  AStream.WriteWord(WordToLE(ACol));

  { Index to XF Record }
  AStream.WriteWord($0000);

  { Result of the formula in IEE 754 floating-point value }
  AStream.WriteBuffer(FormulaResult, 8);

  { Options flags }
  AStream.WriteWord(WordToLE(MASK_FORMULA_RECALCULATE_ALWAYS));

  { Not used }
  AStream.WriteDWord(0);

  { Formula }

  { The size of the token array is written later,
    because it's necessary to calculate if first,
    and this is done at the same time it is written }
  TokenArraySizePos := AStream.Position;
  AStream.WriteWord(RPNLength);

  { Formula data (RPN token array) }
  for i := 0 to Length(AFormula) - 1 do
  begin
    { Token identifier }
    TokenID := FormulaElementKindToExcelTokenID(AFormula[i].ElementKind);
    AStream.WriteByte(TokenID);
    Inc(RPNLength);

    { Additional data }
    case TokenID of
    { Operand Tokens }
    INT_EXCEL_TOKEN_TREFR, INT_EXCEL_TOKEN_TREFV, INT_EXCEL_TOKEN_TREFA: { fekCell }
    begin
      AStream.WriteWord(AFormula[i].Row and MASK_EXCEL_ROW);
      AStream.WriteByte(AFormula[i].Col);
      Inc(RPNLength, 3);
    end;

    INT_EXCEL_TOKEN_TAREA_R: { fekCellRange }
    begin
      {
      Cell range address, BIFF8:
      Offset Size Contents
      0 2 Index to first row (0…65535) or offset of first row (method [B], -32768…32767)
      2 2 Index to last row (0…65535) or offset of last row (method [B], -32768…32767)
      4 2 Index to first column or offset of first column, with relative flags (see table above)
      6 2 Index to last column or offset of last column, with relative flags (see table above)
      }
      AStream.WriteWord(WordToLE(AFormula[i].Row));
      AStream.WriteWord(WordToLE(AFormula[i].Row2));
      AStream.WriteWord(WordToLE(AFormula[i].Col));
      AStream.WriteWord(WordToLE(AFormula[i].Col2));
      Inc(RPNLength, 8);
    end;

    INT_EXCEL_TOKEN_TNUM: { fekNum }
    begin
      AStream.WriteBuffer(AFormula[i].DoubleValue, 8);
      Inc(RPNLength, 8);
    end;

    { binary operation tokens }
    INT_EXCEL_TOKEN_TADD, INT_EXCEL_TOKEN_TSUB, INT_EXCEL_TOKEN_TMUL,
     INT_EXCEL_TOKEN_TDIV, INT_EXCEL_TOKEN_TPOWER: begin end;

    { Other operations }
    INT_EXCEL_TOKEN_TATTR: { fekOpSUM }
    begin
      // Uniry SUM Operation
      AStream.WriteByte($10);
      AStream.WriteByte(0);
      AStream.WriteByte(0);
      Inc(RPNLength, 3);
    end;

    else
    end;
  end;

  { Write sizes in the end, after we known them }
  FinalPos := AStream.Position;
  AStream.position := TokenArraySizePos;
  AStream.WriteByte(RPNLength);
  AStream.Position := RecordSizePos;
  AStream.WriteWord(WordToLE(22 + RPNLength));
  AStream.position := FinalPos;
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteIndex ()
*
*  DESCRIPTION:    Writes an Excel 8 INDEX record
*
*                  nm = (rl - rf - 1) / 32 + 1 (using integer division)
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteIndex(AStream: TStream);
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_INDEX));
  AStream.WriteWord(WordToLE(16));

  { Not used }
  AStream.WriteDWord(DWordToLE(0));

  { Index to first used row, rf, 0 based }
  AStream.WriteDWord(DWordToLE(0));

  { Index to first row of unused tail of sheet, rl, last used row + 1, 0 based }
  AStream.WriteDWord(DWordToLE(0));

  { Absolute stream position of the DEFCOLWIDTH record of the current sheet.
    If it doesn't exist, the offset points to where it would occur. }
  AStream.WriteDWord(DWordToLE($00));

  { Array of nm absolute stream positions of the DBCELL record of each Row Block }
  
  { OBS: It seams to be no problem just ignoring this part of the record }
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteLabel ()
*
*  DESCRIPTION:    Writes an Excel 8 LABEL record
*
*                  Writes a string to the sheet
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteLabel(AStream: TStream; const ARow,
  ACol: Word; const AValue: string; ACell: PCell);
var
  L, RecLen: Word;
  WideValue: WideString;
begin
  WideValue := UTF8Decode(AValue);
  if WideValue = '' then
  begin
    // Bad formatted UTF8String (maybe ANSI?)
    if Length(AValue)<>0 then begin
      //It was an ANSI string written as UTF8 quite sure, so raise exception.
      Raise Exception.CreateFmt('Expected UTF8 text but probably ANSI text found in cell [%d,%d]',[ARow,ACol]);
    end;
    Exit;
  end;
  L := Length(WideValue);

  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_LABEL));
  RecLen := 8 + 1 + L * Sizeof(WideChar);
  AStream.WriteWord(WordToLE(RecLen));

  { BIFF Record data }
  AStream.WriteWord(WordToLE(ARow));
  AStream.WriteWord(WordToLE(ACol));

  { Index to XF record, according to formatting }
  WriteXFIndex(AStream, ACell);

  { Byte String with 16-bit size }
  AStream.WriteWord(WordToLE(L));

  { Byte flags. 1 means regular Unicode LE encoding}
  AStream.WriteByte(1);
  AStream.WriteBuffer(WideStringToLE(WideValue)[1], L * Sizeof(WideChar));
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteNumber ()
*
*  DESCRIPTION:    Writes an Excel 8 NUMBER record
*
*                  Writes a number (64-bit floating point) to the sheet
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteNumber(AStream: TStream; const ARow,
  ACol: Cardinal; const AValue: double; ACell: PCell);
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_NUMBER));
  AStream.WriteWord(WordToLE(14));

  { BIFF Record data }
  AStream.WriteWord(WordToLE(ARow));
  AStream.WriteWord(WordToLE(ACol));

  { Index to XF record }
  AStream.WriteWord(WordToLE($0));

  { IEE 754 floating-point value (is different in BIGENDIAN???) }
  AStream.WriteBuffer(AValue, 8);
end;

procedure TsSpreadBIFF8Writer.WritePalette(AStream: TStream);
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_PALETTE));
  AStream.WriteWord(WordToLE(2+4*56));

  { Number of colors }
  AStream.WriteWord(WordToLE(56));

  { Now the colors, first the standard 16 from Excel }
  AStream.WriteDWord(DWordToLE($000000)); // $08
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FF0000));
  AStream.WriteDWord(DWordToLE($00FF00));
  AStream.WriteDWord(DWordToLE($0000FF));
  AStream.WriteDWord(DWordToLE($FFFF00));
  AStream.WriteDWord(DWordToLE($FF00FF));
  AStream.WriteDWord(DWordToLE($00FFFF));
  AStream.WriteDWord(DWordToLE($800000));
  AStream.WriteDWord(DWordToLE($008000));
  AStream.WriteDWord(DWordToLE($000080));
  AStream.WriteDWord(DWordToLE($808000));
  AStream.WriteDWord(DWordToLE($800080));
  AStream.WriteDWord(DWordToLE($008080));
  AStream.WriteDWord(DWordToLE($C0C0C0));
  AStream.WriteDWord(DWordToLE($808080)); //$17

  { Now some colors which we define ourselves }

  AStream.WriteDWord(DWordToLE($E6E6E6)); //$18
  AStream.WriteDWord(DWordToLE($CCCCCC)); //$19

  { And padding }
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));

  AStream.WriteDWord(DWordToLE($FFFFFF)); //$20
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));

  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));

  AStream.WriteDWord(DWordToLE($FFFFFF)); //$30
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));

  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
  AStream.WriteDWord(DWordToLE($FFFFFF));
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteStyle ()
*
*  DESCRIPTION:    Writes an Excel 8 STYLE record
*
*                  Registers the name of a user-defined style or
*                  specific options for a built-in cell style.
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteStyle(AStream: TStream);
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_STYLE));
  AStream.WriteWord(WordToLE(4));

  { Index to style XF and defines if it's a built-in or used defined style }
  AStream.WriteWord(WordToLE(MASK_STYLE_BUILT_IN));

  { Built-in cell style identifier }
  AStream.WriteByte($00);

  { Level if the identifier for a built-in style is RowLevel or ColLevel, $FF otherwise }
  AStream.WriteByte($FF);
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteWindow1 ()
*
*  DESCRIPTION:    Writes an Excel 8 WINDOW1 record
*
*                  This record contains general settings for the
*                  document window and global workbook settings.
*
*                  The values written here are reasonable defaults,
*                  which should work for most sheets.
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteWindow1(AStream: TStream);
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_WINDOW1));
  AStream.WriteWord(WordToLE(18));

  { Horizontal position of the document window, in twips = 1 / 20 of a point }
  AStream.WriteWord(WordToLE(0));

  { Vertical position of the document window, in twips = 1 / 20 of a point }
  AStream.WriteWord(WordToLE($0069));

  { Width of the document window, in twips = 1 / 20 of a point }
  AStream.WriteWord(WordToLE($339F));

  { Height of the document window, in twips = 1 / 20 of a point }
  AStream.WriteWord(WordToLE($1B5D));

  { Option flags }
  AStream.WriteWord(WordToLE(
   MASK_WINDOW1_OPTION_HORZ_SCROLL_VISIBLE or
   MASK_WINDOW1_OPTION_VERT_SCROLL_VISIBLE or
   MASK_WINDOW1_OPTION_WORKSHEET_TAB_VISIBLE));

  { Index to active (displayed) worksheet }
  AStream.WriteWord(WordToLE($00));

  { Index of first visible tab in the worksheet tab bar }
  AStream.WriteWord(WordToLE($00));

  { Number of selected worksheets }
  AStream.WriteWord(WordToLE(1));

  { Width of worksheet tab bar (in 1/1000 of window width).
    The remaining space is used by the horizontal scroll bar }
  AStream.WriteWord(WordToLE(600));
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteWindow2 ()
*
*  DESCRIPTION:    Writes an Excel 8 WINDOW2 record
*
*                  This record contains aditional settings for the
*                  document window (BIFF2-BIFF4) or for a specific
*                  worksheet (BIFF5-BIFF8).
*
*                  The values written here are reasonable defaults,
*                  which should work for most sheets.
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteWindow2(AStream: TStream;
 ASheetSelected: Boolean);
var
  Options: Word;
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_WINDOW2));
  AStream.WriteWord(WordToLE(18));

  { Options flags }
  Options := MASK_WINDOW2_OPTION_SHOW_GRID_LINES or
   MASK_WINDOW2_OPTION_SHOW_SHEET_HEADERS or
   MASK_WINDOW2_OPTION_SHOW_ZERO_VALUES or
   MASK_WINDOW2_OPTION_AUTO_GRIDLINE_COLOR or
   MASK_WINDOW2_OPTION_SHOW_OUTLINE_SYMBOLS or
   MASK_WINDOW2_OPTION_SHEET_ACTIVE;

  if ASheetSelected then Options := Options or MASK_WINDOW2_OPTION_SHEET_SELECTED;

  AStream.WriteWord(WordToLE(Options));

  { Index to first visible row }
  AStream.WriteWord(WordToLE(0));

  { Index to first visible column }
  AStream.WriteWord(WordToLE(0));

  { Grid line index colour }
  AStream.WriteWord(WordToLE(0));

  { Not used }
  AStream.WriteWord(WordToLE(0));

  { Cached magnification factor in page break preview (in percent); 0 = Default (60%) }
  AStream.WriteWord(WordToLE(0));

  { Cached magnification factor in normal view (in percent); 0 = Default (100%) }
  AStream.WriteWord(WordToLE(0));

  { Not used }
  AStream.WriteDWord(DWordToLE(0));
end;

{*******************************************************************
*  TsSpreadBIFF8Writer.WriteXF ()
*
*  DESCRIPTION:    Writes an Excel 8 XF record
*
*
*
*******************************************************************}
procedure TsSpreadBIFF8Writer.WriteXF(AStream: TStream; AFontIndex: Word;
 AXF_TYPE_PROT, ATextRotation: Byte; ABorders: TsCellBorders;
 AddBackground: Boolean = False; ABackgroundColor: TsColor = scSilver);
var
  XFOptions: Word;
  XFAlignment, XFOrientationAttrib: Byte;
  XFBorderDWord1, XFBorderDWord2: DWord;
begin
  { BIFF Record header }
  AStream.WriteWord(WordToLE(INT_EXCEL_ID_XF));
  AStream.WriteWord(WordToLE(20));

  { Index to FONT record }
  AStream.WriteWord(WordToLE(AFontIndex));

  { Index to FORMAT record }
  AStream.WriteWord(WordToLE($00));

  { XF type, cell protection and parent style XF }
  XFOptions := AXF_TYPE_PROT and MASK_XF_TYPE_PROT;

  if AXF_TYPE_PROT and MASK_XF_TYPE_PROT_STYLE_XF <> 0 then
   XFOptions := XFOptions or MASK_XF_TYPE_PROT_PARENT;
   
  AStream.WriteWord(WordToLE(XFOptions));

  { Alignment and text break }
  XFAlignment := MASK_XF_VERT_ALIGN_BOTTOM;

  AStream.WriteByte(XFAlignment);

  { Text rotation }
  AStream.WriteByte(ATextRotation); // 0 is horizontal / normal

  { Indentation, shrink and text direction }
  AStream.WriteByte(0);

  { Used attributes }
  XFOrientationAttrib :=
   MASK_XF_USED_ATTRIB_NUMBER_FORMAT or
   MASK_XF_USED_ATTRIB_FONT or
   MASK_XF_USED_ATTRIB_TEXT or
   MASK_XF_USED_ATTRIB_BORDER_LINES or
   MASK_XF_USED_ATTRIB_BACKGROUND or
   MASK_XF_USED_ATTRIB_CELL_PROTECTION;

  AStream.WriteByte(XFOrientationAttrib);

  { Cell border lines and background area }

  // Left and Right line colors, use black
  XFBorderDWord1 := 8 * $10000 {left line - black} + 8 * $800000 {right line - black};

  if cbNorth in ABorders then XFBorderDWord1 := XFBorderDWord1 or $100;
  if cbWest in ABorders  then XFBorderDWord1 := XFBorderDWord1 or $1;
  if cbEast in ABorders  then XFBorderDWord1 := XFBorderDWord1 or $10;
  if cbSouth in ABorders then XFBorderDWord1 := XFBorderDWord1 or $1000;

  AStream.WriteDWord(DWordToLE(XFBorderDWord1));

  // Top and Bottom line colors, use black
  XFBorderDWord2 := 8 {top line - black} + 8 * $80 {bottom line - black};
  // Add a background, if desired
  if AddBackground then XFBorderDWord2 := XFBorderDWord2 or $4000000;
  AStream.WriteDWord(DWordToLE(XFBorderDWord2));
  // Background Pattern Color, always zeroed
  if AddBackground then AStream.WriteWord(WordToLE(FPSColorToEXCELPallete(ABackgroundColor)))
  else AStream.WriteWord(0);
end;

{ TsSpreadBIFF8Reader }

function TsSpreadBIFF8Reader.DecodeRKValue(const ARK: DWORD): Double;
var
  Number: Double;
  Tmp: LongInt;
begin
  if ARK and 2 = 2 then begin
    // Signed integer value
    if LongInt(ARK)<0 then begin
      //Simulates a sar
      Tmp:=LongInt(ARK)*-1;
      Tmp:=Tmp shr 2;
      Tmp:=Tmp*-1;
      Number:=Tmp-1;
    end else begin
      Number:=ARK shr 2;
    end;
  end else begin
    // Floating point value
    // NOTE: This is endian dependent and IEEE dependent (Not checked) (working win-i386)
    (PDWORD(@Number))^:= $00000000;
    (PDWORD(@Number)+1)^:=(ARK and $FFFFFFFC);
  end;
  if ARK and 1 = 1 then begin
    // Encoded value is multiplied by 100
    Number:=Number / 100;
  end;
  Result:=Number;
end;

function TsSpreadBIFF8Reader.ReadWideString(const AStream: TStream;
  const ALength: WORD): WideString;
var
  StringFlags: BYTE;
  DecomprStrValue: WideString;
  AnsiStrValue: ansistring;
  RunsCounter: WORD;
  AsianPhoneticBytes: DWORD;
  i: Integer;
  j: SizeUInt;
  lLen: SizeInt;
begin
  StringFlags:=AStream.ReadByte;
  Dec(PendingRecordSize);
  if StringFlags and 4 = 4 then begin
    //Asian phonetics
    //Read Asian phonetics Length (not used)
    AsianPhoneticBytes:=DWordLEtoN(AStream.ReadDWord);
  end;
  if StringFlags and 8 = 8 then begin
    //Rich string
    RunsCounter:=WordLEtoN(AStream.ReadWord);
    dec(PendingRecordSize,2);
  end;
  if StringFlags and 1 = 1 Then begin
    //String is WideStringLE
    if (ALength*SizeOf(WideChar)) > PendingRecordSize then begin
      SetLength(Result,PendingRecordSize);
      AStream.ReadBuffer(Result[1],PendingRecordSize * SizeOf(WideChar));
      Dec(PendingRecordSize,PendingRecordSize * SizeOf(WideChar));
    end else begin
      SetLength(Result,ALength);
      AStream.ReadBuffer(Result[1],ALength * SizeOf(WideChar));
      Dec(PendingRecordSize,ALength * SizeOf(WideChar));
    end;
    Result:=WideStringLEToN(Result);
  end else begin
    //String is 1 byte per char, this is UTF-16 with the high byte ommited because it is zero
    // so decompress and then convert
    if ALength > PendingRecordSize then lLen := PendingRecordSize
    else lLen := ALength;

    SetLength(DecomprStrValue, lLen);
    for i := 1 to lLen do
    begin
      DecomprStrValue[i] := WideChar(AStream.ReadByte());
    end;
    Dec(PendingRecordSize, lLen);

    Result := DecomprStrValue;
  end;
  if StringFlags and 8 = 8 then begin
    //Rich string (This only happend in BIFF8)
    for j := 1 to RunsCounter do begin
      AStream.ReadWord;
      AStream.ReadWord;
      dec(PendingRecordSize,2*2);
    end;
  end;
  if StringFlags and 4 = 4 then begin
    //Asian phonetics
    //Read Asian phonetics, discarded as not used.
    SetLength(AnsiStrValue,AsianPhoneticBytes);
    AStream.ReadBuffer(AnsiStrValue[1],AsianPhoneticBytes);
  end;
end;

function TsSpreadBIFF8Reader.ReadWideString(const AStream: TStream;
  const AUse8BitLength: Boolean): WideString;
var
  Len: Word;
  WideName: WideString;
begin
  if AUse8BitLength then
    Len := AStream.ReadByte()
  else
    Len := WordLEtoN(AStream.ReadWord());

  Result := ReadWideString(AStream, Len);
end;

procedure TsSpreadBIFF8Reader.ReadWorkbookGlobals(AStream: TStream;
  AData: TsWorkbook);
var
  SectionEOF: Boolean = False;
  RecordType: Word;
  CurStreamPos: Int64;
begin
  if Assigned(FSharedStringTable) then FreeAndNIL(FSharedStringTable);
  while (not SectionEOF) do
  begin
    { Read the record header }
    RecordType := WordLEToN(AStream.ReadWord);
    RecordSize := WordLEToN(AStream.ReadWord);
    PendingRecordSize:=RecordSize;

    CurStreamPos := AStream.Position;

    if RecordType<>INT_EXCEL_ID_CONTINUE then begin
      case RecordType of
       INT_EXCEL_ID_BOF:        ;
       INT_EXCEL_ID_BOUNDSHEET: ReadBoundSheet(AStream);
       INT_EXCEL_ID_EOF:        SectionEOF := True;
       INT_EXCEL_ID_SST:        ReadSST(AStream);
       INT_EXCEL_ID_CODEPAGE:   ReadCodepage(AStream);
       INT_EXCEL_ID_FONT:       ReadFont(AStream);
       INT_EXCEL_ID_XF:         ReadXF(AStream);
       INT_EXCEL_ID_FORMAT:     ReadFormat(AStream);
       INT_EXCEL_ID_DATEMODE:   ReadDateMode(AStream);
      else
        // nothing
      end;
    end;

    // Make sure we are in the right position for the next record
    AStream.Seek(CurStreamPos + RecordSize, soFromBeginning);

    // Check for the end of the file
    if AStream.Position >= AStream.Size then SectionEOF := True;
  end;
end;

procedure TsSpreadBIFF8Reader.ReadWorksheet(AStream: TStream; AData: TsWorkbook);
var
  SectionEOF: Boolean = False;
  RecordType: Word;
  CurStreamPos: Int64;
begin
  FWorksheet := AData.AddWorksheet(FWorksheetNames.Strings[FCurrentWorksheet]);

  while (not SectionEOF) do
  begin
    { Read the record header }
    RecordType := WordLEToN(AStream.ReadWord);
    RecordSize := WordLEToN(AStream.ReadWord);
    PendingRecordSize:=RecordSize;

    CurStreamPos := AStream.Position;

    case RecordType of

    INT_EXCEL_ID_NUMBER:  ReadNumber(AStream);
    INT_EXCEL_ID_LABEL:   ReadLabel(AStream);
//    INT_EXCEL_ID_FORMULA: ReadFormula(AStream);
    INT_EXCEL_ID_RSTRING: ReadRichString(AStream); //(RSTRING) This record stores a formatted text cell (Rich-Text). In BIFF8 it is usually replaced by the LABELSST record. Excel still uses this record, if it copies formatted text cells to the clipboard.
    INT_EXCEL_ID_RK:      ReadRKValue(AStream); //(RK) This record represents a cell that contains an RK value (encoded integer or floating-point value). If a floating-point value cannot be encoded to an RK value, a NUMBER record will be written. This record replaces the record INTEGER written in BIFF2.
    INT_EXCEL_ID_MULRK:   ReadMulRKValues(AStream);
    INT_EXCEL_ID_LABELSST:ReadLabelSST(AStream); //BIFF8 only
    INT_EXCEL_ID_FORMULA: ReadFormulaExcel(AStream);
    INT_EXCEL_ID_BOF:     ;
    INT_EXCEL_ID_EOF:     SectionEOF := True;
    else
      // nothing
    end;

    // Make sure we are in the right position for the next record
    AStream.Seek(CurStreamPos + RecordSize, soFromBeginning);

    // Check for the end of the file
    if AStream.Position >= AStream.Size then SectionEOF := True;
  end;
end;

procedure TsSpreadBIFF8Reader.ReadBoundsheet(AStream: TStream);
var
  Len: Byte;
  WideName: WideString;
begin
  { Absolute stream position of the BOF record of the sheet represented
    by this record }
  // Just assume that they are in order
  AStream.ReadDWord();

  { Visibility }
  AStream.ReadByte();

  { Sheet type }
  AStream.ReadByte();

  { Sheet name: 8-bit length }
  Len := AStream.ReadByte();

  { Read string with flags }
  WideName:=ReadWideString(AStream,Len);

  FWorksheetNames.Add(UTF8Encode(WideName));
end;

procedure TsSpreadBIFF8Reader.ReadRKValue(const AStream: TStream);
var
  RK: DWORD;
  ARow, ACol, XF: WORD;
  Number: Double;
  lFormatData: TFormatRecordData;
  lDateTime: TDateTime;
begin
  ReadRowColXF(AStream,ARow,ACol,XF);

  {Encoded RK value}
  RK:=DWordLEtoN(AStream.ReadDWord);

  {Check RK codes}
  Number:=DecodeRKValue(RK);

  // Now try to figure out if the number is really a number of a date or time value
  // See: http://www.gaia-gis.it/FreeXL/freexl-1.0.0a-doxy-doc/Format.html
  // Unfornately Excel doesnt give us a direct way to find this,
  // we need to guess by the FORMAT field
  lFormatData := FindFormatRecordForCell(XF);
  if lFormatData <> nil then
  begin
    // Dates have /
    if Pos('/', lFormatData.FormatString) > 0 then
    begin
      lDateTime := ConvertExcelDateToTDateTime(Number, FBaseDate);
      FWorksheet.WriteDateTime(ARow,ACol,lDateTime);
      Exit;
    end;
  end;

  FWorksheet.WriteNumber(ARow,ACol,Number);
end;

procedure TsSpreadBIFF8Reader.ReadMulRKValues(const AStream: TStream);
var
  ARow, fc,lc,XF: Word;
  Pending: integer;
  RK: DWORD;
  Number: Double;
begin
  ARow:=WordLEtoN(AStream.ReadWord);
  fc:=WordLEtoN(AStream.ReadWord);
  Pending:=RecordSize-sizeof(fc)-Sizeof(ARow);
  while Pending > (sizeof(XF)+sizeof(RK)) do begin
    XF:=AStream.ReadWord; //XF record (not used)
    RK:=DWordLEtoN(AStream.ReadDWord);
    Number:=DecodeRKValue(RK);
    FWorksheet.WriteNumber(ARow,fc,Number);
    inc(fc);
    dec(Pending,(sizeof(XF)+sizeof(RK)));
  end;
  if Pending=2 then begin
    //Just for completeness
    lc:=WordLEtoN(AStream.ReadWord);
    if lc+1<>fc then begin
      //Stream error... bypass by now
    end;
  end;
end;

procedure TsSpreadBIFF8Reader.ReadFormulaExcel(AStream: TStream);
var
  ARow, ACol, XF: WORD;
  ResultFormula: Double;
  Data: array [0..7] of BYTE;
  Flags: WORD;
  FormulaSize: BYTE;
  i: Integer;
begin
  { BIFF Record header }
  { BIFF Record data }
  { Index to XF Record }
  ReadRowColXF(AStream,ARow,ACol,XF);

  { Result of the formula in IEE 754 floating-point value }
  AStream.ReadBuffer(Data,Sizeof(Data));

  { Options flags }
  Flags:=WordLEtoN(AStream.ReadWord);

  { Not used }
  AStream.ReadDWord;

  { Formula size }
  FormulaSize := WordLEtoN(AStream.ReadWord);

  { Formula data, outputed as debug info }
{  Write('Formula Element: ');
  for i := 1 to FormulaSize do
    Write(IntToHex(AStream.ReadByte, 2) + ' ');
  WriteLn('');}

  //RPN data not used by now
  AStream.Position:=AStream.Position+FormulaSize;

  if SizeOf(Double)<>8 then Raise Exception.Create('Double is not 8 bytes');
  Move(Data[0],ResultFormula,sizeof(Data));
  FWorksheet.WriteNumber(ARow,ACol,ResultFormula);
end;

procedure TsSpreadBIFF8Reader.ReadRowColXF(const AStream: TStream; out ARow,
  ACol, AXF: WORD);
begin
  { BIFF Record data }
  ARow := WordLEToN(AStream.ReadWord);
  ACol := WordLEToN(AStream.ReadWord);

  { Index to XF record }
  AXF:=WordLEtoN(AStream.ReadWord);
end;

function TsSpreadBIFF8Reader.ReadString(const AStream: TStream;
  const ALength: WORD): UTF8String;
begin
  Result:=UTF16ToUTF8(ReadWideString(AStream, ALength));
end;

constructor TsSpreadBIFF8Reader.Create;
begin
  inherited Create;
  FXFList := TFPList.Create;
  FFormatList := TFPList.Create;
end;

destructor TsSpreadBIFF8Reader.Destroy;
var
  j: integer;
begin
  for j := FXFList.Count-1 downto 0 do TObject(FXFList[j]).Free;
  for j := FFormatList.Count-1 downto 0 do TObject(FFormatList[j]).Free;
  FXFList.Free;
  FFormatList.Free;
  if Assigned(FSharedStringTable) then FSharedStringTable.Free;
end;

procedure TsSpreadBIFF8Reader.ReadFromFile(AFileName: string; AData: TsWorkbook);
var
  MemStream: TMemoryStream;
  OLEStorage: TOLEStorage;
  OLEDocument: TOLEDocument;
begin
  MemStream := TMemoryStream.Create;
  OLEStorage := TOLEStorage.Create;
  try
    // Only one stream is necessary for any number of worksheets
    OLEDocument.Stream := MemStream;
    OLEStorage.ReadOLEFile(AFileName, OLEDocument,'Workbook');

    // Check if the operation succeded
    if MemStream.Size = 0 then raise Exception.Create('FPSpreadsheet: Reading the OLE document failed');

    // Rewind the stream and read from it
    MemStream.Position := 0;
    ReadFromStream(MemStream, AData);

//    Uncomment to verify if the data was correctly optained from the OLE file
//    MemStream.SaveToFile(SysUtils.ChangeFileExt(AFileName, 'bin.xls'));
  finally
    MemStream.Free;
    OLEStorage.Free;
  end;
end;

procedure TsSpreadBIFF8Reader.ReadFromStream(AStream: TStream; AData: TsWorkbook);
var
  BIFF8EOF: Boolean;
begin
  { Initializations }

  FWorksheetNames := TStringList.Create;
  FWorksheetNames.Clear;
  FCurrentWorksheet := 0;
  BIFF8EOF := False;

  { Read workbook globals }

  ReadWorkbookGlobals(AStream, AData);

  // Check for the end of the file
  if AStream.Position >= AStream.Size then BIFF8EOF := True;

  { Now read all worksheets }

  while (not BIFF8EOF) do
  begin
    //Safe to not read beyond assigned worksheet names.
    if FCurrentWorksheet>FWorksheetNames.Count-1 then break;

    ReadWorksheet(AStream, AData);

    // Check for the end of the file
    if AStream.Position >= AStream.Size then BIFF8EOF := True;

    // Final preparations
    Inc(FCurrentWorksheet);
  end;

  { Finalizations }

  FWorksheetNames.Free;
end;

procedure TsSpreadBIFF8Reader.ReadFormula(AStream: TStream);
begin

end;

procedure TsSpreadBIFF8Reader.ReadLabel(AStream: TStream);
var
  L: Word;
  StringFlags: BYTE;
  ARow, ACol: Word;
  WideStrValue: WideString;
  AnsiStrValue: AnsiString;
begin
  { BIFF Record data }
  ARow := WordLEToN(AStream.ReadWord);
  ACol := WordLEToN(AStream.ReadWord);

  { Index to XF record, not used }
  AStream.ReadWord();

  { Byte String with 16-bit size }
  L := WordLEtoN(AStream.ReadWord());

  { Read string with flags }
  WideStrValue:=ReadWideString(AStream,L);

  { Save the data }
  FWorksheet.WriteUTF8Text(ARow, ACol, UTF16ToUTF8(WideStrValue));
end;

procedure TsSpreadBIFF8Reader.ReadNumber(AStream: TStream);
var
  ARow, ACol: Word;
  AValue: Double;
begin
  { BIFF Record data }
  ARow := WordLEToN(AStream.ReadWord);
  ACol := WordLEToN(AStream.ReadWord);

  { Index to XF record, not used }
  AStream.ReadWord();

  { IEE 754 floating-point value }
  AStream.ReadBuffer(AValue, 8);

  { Save the data }
  FWorksheet.WriteNumber(ARow, ACol, AValue);
end;

procedure TsSpreadBIFF8Reader.ReadRichString(const AStream: TStream);
var
  L: Word;
  B: WORD;
  ARow, ACol, XF: Word;
  AStrValue: ansistring;
begin
  ReadRowColXF(AStream,ARow,ACol,XF);

  { Byte String with 16-bit size }
  L := WordLEtoN(AStream.ReadWord());
  AStrValue:=ReadString(AStream,L);

  { Save the data }
  FWorksheet.WriteUTF8Text(ARow, ACol, AStrValue);
  //Read formatting runs (not supported)
  B:=WordLEtoN(AStream.ReadWord);
  for L := 0 to B-1 do begin
    AStream.ReadWord; // First formatted character
    AStream.ReadWord; // Index to FONT record
  end;
end;

procedure TsSpreadBIFF8Reader.ReadSST(const AStream: TStream);
var
  Items: DWORD;
  StringLength: WORD;
  LString: String;
  ContinueIndicator: WORD;
begin
  //Reads the shared string table, only compatible with BIFF8
  if not Assigned(FSharedStringTable) then begin
    //First time SST creation
    FSharedStringTable:=TStringList.Create;

    DWordLEtoN(AStream.ReadDWord); //Apparences not used
    Items:=DWordLEtoN(AStream.ReadDWord);
    Dec(PendingRecordSize,8);
  end else begin
    //A second record must not happend. Garbage so skip.
    Exit;
  end;
  while Items>0 do begin
    StringLength:=0;
    StringLength:=WordLEtoN(AStream.ReadWord);
    Dec(PendingRecordSize,2);
    LString:='';
    while PendingRecordSize>0 do begin
      if StringLength>0 then begin
        //Read a stream of zero length reads all the stream.
        LString:=LString+ReadString(AStream,StringLength);
      end else begin
        //String of 0 chars in length, so just read it empty, reading only the mandatory flags
        AStream.ReadByte; //And discard it.
        Dec(PendingRecordSize);
        //LString:=LString+'';
      end;
      if (PendingRecordSize=0) and (Items>1) then begin
        //A Continue will happend, read the
        //tag and continue linking...
        ContinueIndicator:=WordLEtoN(AStream.ReadWord);
        if ContinueIndicator<>INT_EXCEL_ID_CONTINUE then begin
          Raise Exception.Create('Expected CONTINUE not found.');
        end;
        PendingRecordSize:=WordLEtoN(AStream.ReadWord);
        Dec(StringLength,Length(UTF8ToUTF16(LString))); //Dec the used chars
        if StringLength=0 then break;
      end else begin
        break;
      end;
    end;
    FSharedStringTable.Add(LString);
    {$ifdef XLSDEBUG}
    WriteLn('Adding shared string: ' + LString);
    {$endif}
    dec(Items);
  end;
end;

procedure TsSpreadBIFF8Reader.ReadLabelSST(const AStream: TStream);
var
  ACol,ARow,XF: WORD;
  SSTIndex: DWORD;
begin
  ReadRowColXF(AStream,ARow,ACol,XF);
  SSTIndex:=DWordLEtoN(AStream.ReadDWord);
  if SizeInt(SSTIndex)>=FSharedStringTable.Count then begin
    Raise Exception.CreateFmt('Index %d in SST out of range (0-%d)',[Integer(SSTIndex),FSharedStringTable.Count-1]);
  end;
  FWorksheet.WriteUTF8Text(ARow, ACol, FSharedStringTable[SSTIndex]);
end;

procedure TsSpreadBIFF8Reader.ReadXF(const AStream: TStream);
var
  lData: TXFRecordData;
begin
  lData := TXFRecordData.Create;

  // Record XF, BIFF8:
  // Offset Size Contents
  // 0 2 Index to FONT record (➜5.45)
  WordLEtoN(AStream.ReadWord);

  // 2 2 Index to FORMAT record (➜5.49)
  lData.FormatIndex := WordLEtoN(AStream.ReadWord);

  {4 2 XF type, cell protection, and parent style XF:
  Bit Mask Contents
  2-0 0007H XF_TYPE_PROT – XF type, cell protection (see above)
  15-4 FFF0H Index to parent style XF (always FFFH in style XFs)
  6 1 Alignment and text break:
  Bit Mask Contents
  2-0 07H XF_HOR_ALIGN – Horizontal alignment (see above)
  3 08H 1 = Text is wrapped at right border
  6-4 70H XF_VERT_ALIGN – Vertical alignment (see above)
  7 80H 1 = Justify last line in justified or distibuted text
  7 1 XF_ROTATION: Text rotation angle (see above)
  8 1 Indentation, shrink to cell size, and text direction:
  Bit Mask Contents
  3-0 0FH Indent level
  4 10H 1 = Shrink content to fit into cell
  7-6 C0H Text direction:
  0 = According to context
  35
  ; 1 = Left-to-right; 2 = Right-to-left
  9 1 Flags for used attribute groups:
  ....}

  // Add the XF to the list
  FXFList.Add(lData);
end;

procedure TsSpreadBIFF8Reader.ReadFormat(const AStream: TStream);
var
  lData: TFormatRecordData;
begin
  lData := TFormatRecordData.Create;

  // Record FORMAT, BIFF8:
  // Offset Size Contents
  // 0 2 Format index used in other records
  lData.Index := WordLEtoN(AStream.ReadWord);

  // 2 var. Number format string (Unicode string, 16-bit string length, ➜2.5.3)
  lData.FormatString := ReadWideString(AStream, False);

  // Add to the list
  FFormatList.Add(lData);
end;

function TsSpreadBIFF8Reader.FindFormatRecordForCell(const AFXIndex: Integer
  ): TFormatRecordData;
var
  lXFData: TXFRecordData;
  lFormatData: TFormatRecordData;
  i: Integer;
begin
  Result := nil;
  lXFData := TXFRecordData(FXFList.Items[AFXIndex]);
  for i := 0 to FFormatList.Count-1 do
  begin
    lFormatData := TFormatRecordData(FFormatList.Items[i]);
    if lFormatData.Index = lXFData.FormatIndex then Exit(lFormatData);
  end;
end;

class function TsSpreadBIFF8Reader.ConvertExcelDateToTDateTime(
  const AExcelDateNum: Double; ABaseDate: TDateTime): TDateTime;
begin
  Result := IncDay(ABaseDate, Round(AExcelDateNum));
end;

procedure TsSpreadBIFF8Reader.ReadFont(const AStream: TStream);
var
  lCodePage: Word;
  lHeight: Word;
  lOptions: Word;
  Len: Byte;
  lFontName: UTF8String;
begin
  { Height of the font in twips = 1/20 of a point }
  lHeight := AStream.ReadWord(); // WordToLE(200)

  { Option flags }
  lOptions := AStream.ReadWord();

  { Colour index }
  AStream.ReadWord();

  { Font weight }
  AStream.ReadWord();

  { Escapement type }
  AStream.ReadWord();

  { Underline type }
  AStream.ReadByte();

  { Font family }
  AStream.ReadByte();

  { Character set }
  lCodepage := AStream.ReadByte();
  {$ifdef XLSDEBUG}
  WriteLn('Reading Font Codepage='+IntToStr(lCodepage));
  {$endif}

  { Not used }
  AStream.ReadByte();

  { Font name: Unicodestring, char count in 1 byte }
  Len := AStream.ReadByte();
  lFontName := ReadString(AStream, Len);
end;

{*******************************************************************
*  Initialization section
*
*  Registers this reader / writer on fpSpreadsheet
*
*******************************************************************}

initialization

  RegisterSpreadFormat(TsSpreadBIFF8Reader, TsSpreadBIFF8Writer, sfExcel8);

end.