lazarus-ccr/components/fpspreadsheet/reference/BIFFExplorer/bebiffgrid.pas

unit beBIFFGrid;

{$mode objfpc}{$H+}

interface

uses
  Classes, SysUtils, Controls, Grids, fpstypes, fpspreadsheet, beTypes;

type
  TBIFFBuffer = array of byte;

  TBIFFDetailsEvent = procedure(Sender: TObject; ADetails: TStrings) of object;

  TRichTextFormattingRun = packed record
    FirstIndex, fontIndex: Word;
  end;
  TRichTextFormattingRuns = array of TRichTextFormattingRun;

  TBIFFGrid = class(TStringGrid)
  private
    FRecType: Word;
    FBuffer: TBIFFBuffer;
    FBufferIndex: LongWord;
    FFormat: TsSpreadsheetFormat;
    FInfo: Integer;
    FTotalSST: Integer;
    FCounterSST: Integer;
    FPendingCharCount: Integer;
    FCurrRow: Integer;
    FDetails: TStrings;
    FOnDetails: TBIFFDetailsEvent;
    function  GetStringType: String;

    procedure ShowBackup;
    procedure ShowBlankCell;
    procedure ShowBOF;
    procedure ShowBookBool;
    procedure ShowBoolCell;
    procedure ShowBottomMargin;
    procedure ShowCalcCount;
    procedure ShowCalcMode;
    procedure ShowCellAddress;
    procedure ShowCellAddressRange(AFormat: TsSpreadsheetFormat);
    procedure ShowClrtClient;
    procedure ShowCodePage;
    procedure ShowColInfo;
    procedure ShowColWidth;
    procedure ShowContinue;
    procedure ShowCountry;
    procedure ShowDateMode;
    procedure ShowDBCell;
    procedure ShowDefColWidth;
    procedure ShowDefinedName;
    procedure ShowDefRowHeight;
    procedure ShowDelta;
    procedure ShowDimensions;
    procedure ShowDSF;
    procedure ShowEOF;
    procedure ShowExcel9File;
    procedure ShowExternBook;
    procedure ShowExternCount;
    procedure ShowExternSheet;
    procedure ShowFileSharing;
    procedure ShowFnGroupCount;
    procedure ShowFont;
    procedure ShowFontColor;
    procedure ShowFooter;
    procedure ShowFormat;
    procedure ShowFormatCount;
    procedure ShowFormula;
    procedure ShowFormulaTokens(ATokenBytes: Integer);
    procedure ShowGCW;
    procedure ShowHeader;
    procedure ShowHideObj;
    procedure ShowHyperLink;
    procedure ShowHyperLinkTooltip;
    procedure ShowInteger;
    procedure ShowInterfaceEnd;
    procedure ShowInterfaceHdr;
    procedure ShowIteration;
    procedure ShowIXFE;
    procedure ShowLabelCell;
    procedure ShowLabelSSTCell;
    procedure ShowLeftMargin;
    procedure ShowMergedCells;
    procedure ShowMMS;
    procedure ShowMSODrawing;
    procedure ShowMulBlank;
    procedure ShowMulRK;
    procedure ShowNote;
    procedure ShowNumberCell;
    procedure ShowObj;
    procedure ShowPageSetup;
    procedure ShowPalette;
    procedure ShowPane;
    procedure ShowPassword;
    procedure ShowPrecision;
    procedure ShowPrintGridLines;
    procedure ShowPrintHeaders;
    procedure ShowProt4Rev;
    procedure ShowProt4RevPass;
    procedure ShowProtect;
    procedure ShowRecalc;
    procedure ShowRefMode;
    procedure ShowRefreshAll;
    procedure ShowRightMargin;
    procedure ShowRK;
    procedure ShowRString;
    procedure ShowRow;
    procedure ShowSelection;
    procedure ShowSharedFormula;
    procedure ShowSheet;
    procedure ShowSheetPR;
    procedure ShowSST;
    procedure ShowStandardWidth;
    procedure ShowString;
    procedure ShowStyle;
    procedure ShowStyleExt;
    procedure ShowTabID;
    procedure ShowTopMargin;
    procedure ShowTXO;
    procedure ShowWindow1;
    procedure ShowWindow2;
    procedure ShowWindowProtect;
    procedure ShowWriteAccess;
    procedure ShowWriteProt;
    procedure ShowXF;
    procedure ShowXFCRC;
    procedure ShowXFEXT;

  protected
    procedure Click; override;
    procedure DoExtractDetails;
    function DoMouseWheelDown(Shift: TShiftState; MousePos: TPoint): Boolean; override;
    function DoMouseWheelUp(Shift: TShiftState; MousePos: TPoint): Boolean; override;
    procedure ExtractString(ABufIndex: Integer; AUnicode: Boolean;
      ACharCount: Integer; out AString: String; out ANumbytes: Integer); overload;
    procedure ExtractString(ABufIndex: Integer; ALenBytes: Byte; AUnicode: Boolean;
      out AString: String; out ANumBytes: Integer;
      out ARichTextRuns: TRichTextFormattingRuns;
      out ABufIndexOfFirstRichTextRun: LongWord;
      IgnoreCompressedFlag: Boolean = false); overload;
    procedure ExtractString(ABufIndex: Integer; ALenbytes: Byte; AUnicode: Boolean;
      out AString: String; out ANumBytes: Integer;
      IgnoreCompressedFlag: Boolean=False); overload;
    procedure PopulateGrid;
    procedure ShowInRow(var ARow: Integer; var AOffs: LongWord; ASize: Word;
      AValue,ADescr: String; ADescrOnly: Boolean = false);
    procedure ShowRowColData(var ABufIndex: LongWord);

  public
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;
    procedure SetBIFFNodeData(AData: TBIFFNodeData; ABuffer: TBIFFBuffer; AFormat: TsSpreadsheetFormat);
//    procedure SetRecordType(ARecType: Word; ABuffer: TBIFFBuffer; AFormat: TsSpreadsheetFormat);

  published
    property OnDetails: TBIFFDetailsEvent read FOnDetails write FOnDetails;
  end;

implementation

uses
  StrUtils, Math, lazutf8,
  fpsutils,
  beBIFFUtils;

const
  ABS_REL: array[boolean] of string = ('abs', 'rel');

constructor TBIFFGrid.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  ColCount := 4;
  FixedCols := 0;
  RowCount := 2;
  Cells[0, 0] := 'Offset';
  Cells[1, 0] := 'Size';
  Cells[2, 0] := 'Value';
  Cells[3, 0] := 'Description';
  ColWidths[0] := 60;
  ColWidths[1] := 60;
  ColWidths[2] := 120;
  ColWidths[3] := 350;
  Options := Options
    + [goThumbTracking, goColSizing, goTruncCellHints, goCellHints]
    - [goVertLine, goSmoothScroll];
  MouseWheelOption := mwGrid;
  FDetails := TStringList.Create;
  FPendingCharCount := -1;
end;


destructor TBIFFGrid.Destroy;
begin
  FDetails.Free;
  inherited;
end;


procedure TBIFFGrid.Click;
begin
  inherited;
  if (FBuffer <> nil) then
    DoExtractDetails;
end;


procedure TBIFFGrid.DoExtractDetails;
begin
  if Assigned(FOnDetails) then begin
    PopulateGrid;
    FOnDetails(self, FDetails);
  end;
end;

function TBIFFGrid.DoMouseWheelDown(Shift: TShiftState; MousePos: TPoint
  ): Boolean;
begin
  Result := inherited;
  Click;
end;

function TBIFFGrid.DoMouseWheelUp(Shift: TShiftState; MousePos: TPoint
  ): Boolean;
begin
  Result := inherited;
  Click;
end;

{ Reads a string character array starting at ABufIndex. The string is supposed
  to have ACharCount character, but less characters are read if the string
  extends across the max size of a record and is continued in the next CONTINUE
  record.
  The string is assumed to be a UTF16 string if AUnicode=true, otherwise it is
  an ansi string. }
procedure TBIFFGrid.ExtractString(ABufIndex: Integer; AUnicode: Boolean;
  ACharCount: Integer; out AString: String; out ANumbytes: Integer);
var
  sa: AnsiString;
  sw: WideString;
  n: Integer;
begin
  if AUnicode then   // uncompressed unicode --> 2 bytes per char
  begin
    if ABufIndex + ACharCount * SizeOf(WideChar) >= Length(FBuffer) then
    begin
      n := (Length(FBuffer) - ABufIndex) div SizeOf(WideChar);
      FPendingCharCount := ACharCount - n;  // number of chars to be read from subsequent CONTINUE record
    end else
    begin
      n := ACharCount;
      FPendingCharCount := 0;
    end;
    SetLength(sw, n);
    ANumBytes := n * SizeOf(WideChar);
    Move(FBuffer[ABufIndex], sw[1], ANumBytes);
    AString := UTF8Encode(WideStringLEToN(sw));
  end else
  begin   // ansi or compressed unicode
    if ABufIndex + ACharCount >= Length(FBuffer) then
    begin
      n := Length(FBuffer) - ABufIndex;
      FPendingCharCount := ACharCount - n;  // number of chars in subsequent CONTINUE record
    end else
    begin
      n := ACharCount;
      FPendingCharCount := 0;
    end;
    SetLength(sa, n);
    ANumBytes := n;
    Move(FBuffer[ABufIndex], sa[1], ANumBytes);
    AString := AnsiToUTF8(sa);  // to do: use code page of file
  end;
end;

procedure TBIFFGrid.ExtractString(ABufIndex: Integer; ALenBytes: Byte; AUnicode: Boolean;
  out AString: String; out ANumBytes: Integer;
  IgnoreCompressedFlag: Boolean = false);
var
  rtfRuns: TRichTextFormattingRuns;
  rtfIndex: LongWord;
begin
  ExtractString(ABufIndex, ALenbytes, AUnicode, AString, ANumBytes,
    rtfRuns, rtfIndex, IgnoreCompressedFlag);
end;

procedure TBIFFGrid.ExtractString(ABufIndex: Integer; ALenBytes: Byte; AUnicode: Boolean;
  out AString: String; out ANumBytes: Integer;
  out ARichTextRuns: TRichTextFormattingRuns;
  out ABufIndexOfFirstRichTextRun: LongWord;
  IgnoreCompressedFlag: Boolean = false);
var
  ls: Integer;    // Character count of string
  w: Word;
  dw: DWord;
  optn: Byte;
  n: Integer;     // Byte count in string character array
  asianPhoneticBytes: DWord;
  numRichRuns: Word;
  offs: Integer;
  rtfBufIndex: Int64;
  rtfIndex: Integer;
begin
  ABufIndexOfFirstRichTextRun := LongWord(-1);
  SetLength(ARichTextRuns, 0);

  if Length(FBuffer) = 0 then begin
    AString := '';
    ANumBytes := 0;
    exit;
  end;
  if ALenBytes = 1 then
    ls := FBuffer[ABufIndex]
  else begin
    Move(FBuffer[ABufIndex], w, 2);
    ls := WordLEToN(w);
  end;
  if AUnicode then begin
    offs := ALenBytes;
    optn := FBuffer[ABufIndex + ALenBytes];
    inc(offs, 1);

    if optn and $08 <> 0 then  // rich text
    begin
      Move(FBuffer[ABufIndex + offs], w, 2);
      numRichRuns := WordLEToN(w);
      inc(offs, 2);
    end else
      numRichRuns := 0;
    SetLength(ARichTextRuns, numRichRuns);

    if optn and $04 <> 0 then  // Asian phonetic
    begin
      Move(FBuffer[ABufIndex + offs], dw, 4);
      AsianPhoneticBytes := DWordLEToN(dw);
      inc(offs, 4);
    end else
      asianPhoneticBytes := 0;

    if (optn  and $01 = 0) and (not IgnoreCompressedFlag) then
      // compressed --> 1 byte per character
      ExtractString(ABufIndex + offs, false, ls, AString, n)
    else
      // non-compressed unicode
      ExtractString(ABufIndex + offs, true, ls, AString, n);

    ANumBytes := offs + n + numRichRuns * 4 + asianPhoneticBytes;

    rtfIndex := 0;
    rtfBufIndex := ABufIndex + offs + n;
    ABufIndexOfFirstRichTextRun := rtfBufIndex;
    while rtfIndex < numRichRuns do begin
      Move(FBuffer[rtfBufIndex], w, 2);
      ARichTextRuns[rtfIndex].FirstIndex := WordLEToN(w);
      Move(FBuffer[rtfBufIndex+2], w, 2);
      ARichTextRuns[rtfIndex].FontIndex := WordLEToN(w);
      inc(rtfIndex);
      inc(rtfBufIndex, 4);
    end;
  end else
  begin
    // ansi string
    SetLength(ARichTextRuns, 0);  // no rich text formatting for ansi strings
    ExtractString(ABufIndex + ALenBytes, false, ls, AString, n);
    ANumbytes := ALenBytes + n;
  end;
end;


function TBIFFGrid.GetStringType: String;
begin
  case FFormat of
    sfExcel2: Result := 'Byte';
    sfExcel5: Result := 'Byte';
    sfExcel8: Result := 'Unicode';
  end;
end;


procedure TBIFFGrid.PopulateGrid;
begin
  FBufferIndex := 0;
  FCurrRow := FixedRows;
  FDetails.Clear;
  case FRecType of
    $0000, $0200:
      ShowDimensions;
    $0001, $0201:
      ShowBlankCell;
    $0002:
      ShowInteger;
    $0003, $0203:
      ShowNumberCell;
    $0004, $0204:
      ShowLabelCell;
    $0005, $0205:
      ShowBoolCell;
    $0006:
      ShowFormula;
    $0007, $0207:
      ShowString;
    $0008, $0208:
      ShowRow;
    $0009, $0209, $0409, $0809:
      ShowBOF;
    $000A:
      ShowEOF;
    $000C:
      ShowCalcCount;
    $000D:
      ShowCalcMode;
    $000E:
      ShowPrecision;
    $000F:
      ShowRefMode;
    $0010:
      ShowDelta;
    $0011:
      ShowIteration;
    $0012:
      ShowProtect;
    $0013:
      ShowPassword;
    $0014:
      ShowHeader;
    $0015:
      ShowFooter;
    $0016:
      ShowExternCount;
    $0017:
      ShowExternSheet;
    $0018, $0218:
      ShowDefinedName;
    $0019:
      ShowWindowProtect;
    $001C:
      ShowNote;
    $001D:
      ShowSelection;
    $001E, $041E:
      ShowFormat;
    $001F:
      ShowFormatCount;
    $0022:
      ShowDateMode;
    $0024:
      ShowColWidth;
    $0025, $0225:
      ShowDefRowHeight;
    $0026:
      ShowLeftMargin;
    $0027:
      ShowRightMargin;
    $0028:
      ShowTopMargin;
    $0029:
      ShowBottomMargin;
    $002A:
      ShowPrintHeaders;
    $002B:
      ShowPrintGridLines;
    $0031:
      ShowFont;
    $003C:
      ShowContinue;
    $003D:
      ShowWindow1;
    $003E, $023E:
      ShowWindow2;
    $0040:
      ShowBackup;
    $0041:
      ShowPane;
    $0042:
      ShowCodePage;
    $0043:
      ShowXF;
    $0044:
      ShowIXFE;
    $0045:
      ShowFontColor;
    $0055:
      ShowDefColWidth;
    $005B:
      ShowFileSharing;
    $005C:
      ShowWriteAccess;
    $005D:
      ShowObj;
    $005F:
      ShowRecalc;
    $007D:
      ShowColInfo;
    $0081:
      ShowSheetPR;
    $0085:
      ShowSheet;
    $0086:
      ShowWriteProt;
    $008C:
      ShowCountry;
    $008D:
      ShowHideObj;
    $0092:
      ShowPalette;
    $099:
      ShowStandardWidth;
    $00A1:
      ShowPageSetup;
    $00AB:
      ShowGCW;
    $00C1:
      ShowMMS;
    $009C:
      ShowFnGroupCount;
    $00BE:
      ShowMulBlank;
    $00BD:
      ShowMulRK;
    $00D6:
      ShowRString;
    $00D7:
      ShowDBCell;
    $00DA:
      ShowBookBool;
    $00E0:
      ShowXF;
    $00E1:
      ShowInterfaceHdr;
    $00E2:
      ShowInterfaceEnd;
    $00E5:
      ShowMergedCells;
    $00EC:
      ShowMSODrawing;
    $00FC:
      ShowSST;
    $00FD:
      ShowLabelSSTCell;
    $013D:
      ShowTabID;
    $0161:
      ShowDSF;
    $01AE:
      ShowExternBook;
    $01AF:
      ShowProt4Rev;
    $01B6:
      ShowTXO;
    $01B7:
      ShowRefreshAll;
    $01B8:
      ShowHyperlink;
    $01BC:
      ShowProt4RevPass;
    $01C0:
      ShowExcel9File;
    $027E:
      ShowRK;
    $0293:
      ShowStyle;
    $04BC:
      ShowSharedFormula;
    $0800:
      ShowHyperlinkTooltip;
    $087C:
      ShowXFCRC;
    $087D:
      ShowXFEXT;
    $0892:
      ShowStyleExt;
    $105C:
      ShowClrtClient;
    else
      RowCount := 2;
      Rows[1].Clear;
  end;
end;


procedure TBIFFGrid.SetBIFFNodeData(AData: TBIFFNodeData;
  ABuffer: TBIFFBuffer; AFormat: TsSpreadsheetFormat);
begin
  if AData = nil then
    exit;
  FFormat := AFormat;
  FRecType := AData.RecordID;
  FInfo := AData.Tag;
  SetLength(FBuffer, Length(ABuffer));
  if Length(FBuffer) > 0 then
    Move(ABuffer[0], FBuffer[0], Length(FBuffer));
  PopulateGrid;
  if Assigned(FOnDetails) then FOnDetails(self, FDetails);
end;


procedure TBIFFGrid.ShowBackup;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Save backup copy of workbook:'#13);
    if w = 0
      then FDetails.Add('0 = no backup')
      else FDetails.Add('1 = backup copy is saved when workbook is saved');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [w]),
    'Save backup copy of workbook');
end;


procedure TBIFFGrid.ShowBlankCell;
var
  numBytes: Integer;
  b: Byte = 0;
  w: Word = 0;
  dbl: Double;
begin
  RowCount := IfThen(FFormat = sfExcel2, FixedRows + 5, FixedRows + 3);
  // Offset 0: Row & Offset 2: Column
  ShowRowColData(FBufferIndex);

  // Offset 4: Cell attributes (BIFF2) or XF record index (> BIFF2)
  if FFormat = sfExcel2 then begin
    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Cell protection and XF index:'#13);
      FDetails.Add(Format('Bits 5-0 = %d: XF Index', [b and $3F]));
      case b and $40 of
        0: FDetails.Add('Bit 6 = 0: Cell is NOT locked.');
        1: FDetails.Add('Bit 6 = 1: Cell is locked.');
      end;
      case b and $80 of
        0: FDetails.Add('Bit 7 = 0: Formula is NOT hidden.');
        1: FDetails.Add('Bit 7 = 1: Formula is hidden.');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b, b]),
      'Cell protection and XF index');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Indexes to format and font records:'#13);
      FDetails.Add(Format('Bits 5-0 = %d: Index to FORMAT record', [b and $3f]));
      FDetails.Add(Format('Bits 7-6 = %d: Index to FONT record', [(b and $C0) shr 6]));
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b, b]),
      'Indexes of format and font records');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Cell style:'#13);
      case b and $07 of
        0: FDetails.Add('Bits 2-0 = 0: Horizontal alignment is GENERAL');
        1: FDetails.Add('Bits 2-0 = 1: Horizontal alignment is LEFT');
        2: FDetails.Add('Bits 2-0 = 2: Horizontal alignment is CENTERED');
        3: FDetails.Add('Bits 2-0 = 3: Horizontal alignment is RIGHT');
        4: FDetails.Add('Bits 2-0 = 4: Horizontal alignment is FILLED');
      end;
      if b and $08 = 0
        then FDetails.Add('Bit 3 = 0: Cell has NO left border')
        else FDetails.Add('Bit 3 = 1: Cell has left black border');
      if b and $10 = 0
        then FDetails.Add('Bit 4 = 0: Cell has NO right border')
        else FDetails.Add('Bit 4 = 1: Cell has right black border');
      if b and $20 = 0
        then FDetails.Add('Bit 5 = 0: Cell has NO top border')
        else FDetails.Add('Bit 5 = 1: Cell has top black border');
      if b and $40 = 0
        then FDetails.Add('Bit 6 = 0: Cell has NO bottom border')
        else FDetails.Add('Bit 6 = 1: Cell has bottom black border');
      if b and $80 = 0
        then FDetails.Add('Bit 7 = 0: Cell has NO shaded background')
        else FDetails.Add('Bit 7 = 1: Cell has shaded background');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.2x)', [b,b]),
      'Cell style');
  end else
  begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrROw, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
      'Index of XF record');
  end;
end;


procedure TBIFFGrid.ShowBOF;
var
  numBytes: Integer;
  w: Word;
  s: String;
begin
  case FFormat of
    sfExcel2: RowCount := FixedRows + 2;
    { //Excel3 & 4 not supported by fpspreadsheet
    sfExcel3, sfExcel4: RowCount := FixedRows + 3;
    }
    sfExcel5: RowCount := FixedRows + 4;
    sfExcel8: RowCount := FixedRows + 6;
  end;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('BIFF version:'#13);
    case FRecType of
      $0009,
      $0209,
      $0409: FDetails.Add('not used');
      $0809: case FFormat of
               sfExcel5: FDetails.Add('$0500 = BIFF5');
               sfExcel8: FDetails.Add('$0600 = BIFF8');
             end;
      else   case w of
               $0000: FDetails.Add('$0000 = BIFF5');
               $0200: FDetails.Add('$0200 = BIFF2');
               $0300: FDetails.Add('$0300 = BIFF3');
               $0400: FDetails.Add('$0400 = BIFF4');
               $0500: FDetails.Add('$0500 = BIFF5');
               $0600: FDetails.Add('$0600 = BIFF8');
             end;
    end;
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [w]),
    'BIFF version');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  s := '$0010=Sheet, $0020=Chart, $0040=Macro sheet';
  if FFormat > sfExcel2 then
    s := '$0005=WB globals, $0006=VB module, ' + s + ', $0100=Workspace';
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Type of data:'#13);
    FDetails.Add(Format('$%.4x = %s', [w, BofName(w)]));
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [w]),
    Format('Type of data (%s)', [s]));

  if FFormat > sfExcel2 then begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    { Excel3/4 not supported in fpSpreadsheet
    if FFormat in [sfExcel3, sfExcel4] then
      ShowInRow(FCurrRow, FBUfferIndex, numBytes, IntToStr(WordLEToN(w)),
        'not used')
    else}
    begin
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
        'Build identifier (must not be zero)');

      numBytes := 2;
      Move(FBuffer[FBufferIndex], w, numBytes);
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
        'Build year (must not be zero)');
    end;
  end;

  if FFormat = sfExcel8 then begin
    numBytes := 4;
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
      'File history flags');

    numBytes :=4;
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
      'Lowest Excel version that can read all records of this file');
  end;
end;


procedure TBIFFGrid.ShowBookBool;
var
  numbytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Some properties assosciated with notebook:'#13);
    if w and $0001 = 0
      then FDetails.Add('Bit 0 = 0: External link values are saved.')
      else FDetails.Add('Bit 0 = 1: External link values are NOT saved.');
    FDetails.Add('Bit 1: to be ignored');
    if w and $0004 = 0
      then FDetails.Add('Bit 2 = 0: Workbook does not have a mail envelope')
      else FDetails.Add('Bit 2 = 1: Workbook has a mail envelope');
    if w and $0008 = 0
      then FDetails.Add('Bit 3 = 0: Mail envelope is NOT visible.')
      else FDetails.Add('Bit 3 = 1: Mail envelope is visible.');
    if w and $0010 = 0
      then FDetails.Add('Bit 4 = 0: Mail envelope has NOT been initialized.')
      else FDetails.Add('Bit 4 = 1: Mail envelope has been initialized.');
    case (w and $0060) shr 5 of
      0: FDetails.Add('Bits 5-6 (Update external links) = 0: Prompt user to update');
      1: FDetails.Add('Bits 5-6 (Update external linls) = 1: Do not update, and do not prompt user.');
      2: FDetails.Add('Bits 5-6 (Update external links) = 2: Silently update external links.');
    end;
    FDetails.Add('Bit 7: undefined, must be ignored');
    if w and $0100 = 0
      then FDetails.Add('Bit 8 = 0: Do not hide borders of tables that do not contain the active cell')
      else FDetails.Add('Bit 8 = 1: Hide borders of tables that do not contain the active cell');
    FDetails.Add('Bits 9-15: MUST BE zero, MUST be ignored');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]),
    'Specifies some properties assosciated with a workbook');
end;

procedure TBIFFGrid.ShowBoolCell;
var
  numBytes: Integer;
  w: Word;
  b: Byte;
begin
  if FFormat = sfExcel2 then
    RowCount := FixedRows + 7
  else
    RowCount := FixedRows + 5;

  ShowRowColData(FBufferIndex);

  if FFormat = sfExcel2 then begin
    numBytes := 1;
    b := FBuffer[FBufferIndex];
    if Row = FCurrRow then begin
      FDetails.Add('Cell protection and XF index:'#13);
      FDetails.Add(Format('Bits 5-0 = %d: XF Index', [b and $3F]));
      case b and $40 of
        0: FDetails.Add('Bit 6 = 0: Cell is NOT locked.');
        1: FDetails.Add('Bit 6 = 1: Cell is locked.');
      end;
      case b and $80 of
        0: FDetails.Add('Bit 7 = 0: Formula is NOT hidden.');
        1: FDetails.Add('Bit 7 = 1: Formula is hidden.');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
      'Cell protection and XF index');

    b := FBuffer[FBufferIndex];
    if Row = FCurrRow then begin
      FDetails.Add('Indexes to format and font records:'#13);
      FDetails.Add(Format('Bits 5-0 = %d: Index to FORMAT record', [b and $3f]));
      FDetails.Add(Format('Bits 7-6 = %d: Index to FONT record', [(b and $C0) shr 6]));
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
      'Indexes of format and font records');

    b := FBuffer[FBufferIndex];
    if Row = FCurrRow then begin
      FDetails.Add('Cell style:'#13);
      case b and $07 of
        0: FDetails.Add('Bits 2-0 = 0: Horizontal alignment is GENERAL');
        1: FDetails.Add('Bits 2-0 = 1: Horizontal alignment is LEFT');
        2: FDetails.Add('Bits 2-0 = 2: Horizontal alignment is CENTERED');
        3: FDetails.Add('Bits 2-0 = 3: Horizontal alignment is RIGHT');
        4: FDetails.Add('Bits 2-0 = 4: Horizontal alignment is FILLED');
      end;
      if b and $08 = 0
        then FDetails.Add('Bit 3 = 0: Cell has NO left border')
        else FDetails.Add('Bit 3 = 1: Cell has left black border');
      if b and $10 = 0
        then FDetails.Add('Bit 4 = 0: Cell has NO right border')
        else FDetails.Add('Bit 4 = 1: Cell has right black border');
      if b and $20 = 0
        then FDetails.Add('Bit 5 = 0: Cell has NO top border')
        else FDetails.Add('Bit 5 = 1: Cell has top black border');
      if b and $40 = 0
        then FDetails.Add('Bit 6 = 0: Cell has NO bottom border')
        else FDetails.Add('Bit 6 = 1: Cell has bottom black border');
      if b and $80 = 0
        then FDetails.Add('Bit 7 = 0: Cell has NO shaded background')
        else FDetails.Add('Bit 7 = 1: Cell has shaded background');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.2x)', [b,b]),
      'Cell style');
  end else
  begin  // BIFF3 - BIFF 8
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrROw, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
      'Index of XF record');
  end;

  // boolean value
  numBytes := 1;
  b := FBuffer[FBufferIndex];
  ShowInRow(FCurrRow, FBufferIndex, numbytes,
    Format('%d (%s)', [b, Uppercase(BoolToStr(Boolean(b), true))]),
    'Boolean value (0=FALSE, 1=TRUE)'
  );

  // bool/error flag
  numBytes := 1;
  b := FBuffer[FBufferIndex];
  if b = 0 then
    ShowInRow(FCurrRow, FBufferIndex, numbytes, '0 (boolean value)',
      'Boolean/Error value flag (0=boolean, 1=error value)')
  else
    ShowInRow(FCurrRow, FBufferIndex, numbytes, '1 (error value)',
      'Boolean/Error value flag (0=boolean, 1=error value)');
end;

procedure TBIFFGrid.ShowBottomMargin;
var
  numBytes: Integer;
  dbl: Double;
begin
  RowCount := FixedRows + 1;
  numBytes := 8;
  Move(FBuffer[FBufferIndex], dbl, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, FloatToStr(dbl),
    'Bottom page margin in inches (IEEE 754 floating-point value, 64-bit double precision)');
end;


procedure TBIFFGrid.ShowCalcCount;
var
  numBytes: Word;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Maximum number of iterations allowed in circular references');
end;


procedure TBIFFGrid.ShowCalcMode;
var
  numBytes: Word;
  w: word;
  s: String;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if w = $FFFF then
    s := '–1 = automatically except for multiple table operations'
  else if w = 0 then
    s := '0 = manually'
  else if w = 1 then
    s := '1 = automatically (default)';
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]), s);
end;


procedure TBIFFGrid.ShowCellAddress;
{ Note: The bitmask assignment to relative column/row is reversed in relation
  to OpenOffice documentation in order to match with Excel files. }
var
  numBytes: Word;
  b: Byte;
  w: Word;
  r,c: Integer;
  s: String;
begin
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);   // row --> w
  r := WordLEToN(w);
  if FFormat = sfExcel8 then begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex+2], w, numBytes);  // column --w1
    c := WordLEToN(w);
    if FCurrRow = Row then begin
      FDetails.Add('RowIndex information:'#13);
      FDetails.Add(Format('RowIndex = %d (%s)', [r, ABS_REL[c and $4000 <> 0]]));
    end;
    s := Format('%d ($%.4x)', [r, r]);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, s, 'Row index');
    if FCurrRow = Row then begin
      FDetails.Add('ColIndex information:'#13);
      FDetails.Add(Format('Bits 0-13: ColIndex = %d (%s)', [c and $3FFF, ABS_REL[c and $8000 <> 0]]));
      if c and $4000 = 0
        then FDetails.Add('Bit 14=0: absolute column index')
        else FDetails.Add('Bit 14=1: relative column index');
      if c and $8000 = 0
        then FDetails.Add('Bit 15=0: absolute row index')
        else FDetails.Add('Bit 15=1: relative row index');
    end;
    s := Format('%d ($%.4x)', [c, c]);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Column index');
  end else
  begin
    numbytes := 1;
    Move(FBuffer[FBufferIndex+2], b, numBytes);
    c := b;
    if FCurrRow = Row then begin
      FDetails.Add('RowIndex information:'#13);
      FDetails.Add(Format('Bits 0-13: RowIndex = %d (%s)', [r and $3FFF, ABS_REL[r and $4000 <> 0]]));
      if r and $4000 = 0
        then FDetails.Add('Bit 14=0: absolute column index')
        else FDetails.Add('Bit 14=1: relative column index');
      if r and $8000 = 0
        then FDetails.Add('Bit 15=0: absolute row index')
        else FDetails.Add('Bit 15=1: relative row index');
    end;
    //s := Format('$%.4x (%d, %s)', [r, r and $3FFF, ABS_REL[r and $4000 <> 0]]);
    s := Format('%d ($%.4x)', [r, r]);
    ShowInRow(FCurrRow, FBufferIndex, 2, s, 'Row index');
    if FCurrRow = Row then begin
      FDetails.Add('ColIndex information:'#13);
      FDetails.Add(Format('ColIndex = %d (%s)', [c, ABS_REL[r and $8000 <> 0]]));
    end;
    //s := Format('$%.2x (%d, %s)', [c, c, ABS_REL[r and $8000 <> 0]]);
    s := Format('%d ($%.4x)', [c, c]);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Column index');
  end;
end;


procedure TBIFFGrid.ShowCellAddressRange(AFormat: TsSpreadsheetFormat);
{ Note: The bitmask assignment to relative column/row is reversed in relation
  to OpenOffice documentation in order to match with Excel files.

  The spreadsheet format is passed as a parameter because some BIFF8 records
  used these fields in BIFF5 format. }
var
  numbytes: Word;
  b: Byte;
  w: Word;
  r, c, r2, c2: Integer;
  s: String;
begin
  if AFormat = sfExcel8 then begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    r := WordLEToN(w);
    if FCurrRow = Row then begin
      FDetails.Add('RowIndex information:'#13);
      FDetails.Add(Format('RowIndex = %d (%s)', [r, ABS_REL[c and $4000 <> 0]]));
    end;
    s := Format('%d ($%.4x)', [r, r]);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, s, 'First row index');

    Move(FBuffer[FBufferIndex], w, numBytes);
    r2 := WordLEToN(w);
    if FCurrRow = Row then begin
      FDetails.Add('RowIndex information:'#13);
      FDetails.Add(Format('RowIndex = %d (%s)', [r2, ABS_REL[c and $4000 <> 0]]));
    end;
    s := Format('%d ($%.4x)', [r2, r2]);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, s, 'Last row index');

    Move(FBuffer[FBufferIndex], w, numBytes);  // column
    c := WordLEToN(w);
    Move(FBuffer[FBufferIndex+2], w, numBytes);
    c2 := WordLEToN(w);

    if FCurrRow = Row then begin
      FDetails.Add('ColIndex information:'#13);
      FDetails.Add(Format('Bits 0-13: ColIndex = %d (%s)', [c and $3FFF, ABS_REL[c and $8000 <> 0]]));
      if c and $4000 = 0
        then FDetails.Add('Bit 14=0: absolute column index')
        else FDetails.Add('Bit 14=1: relative column index');
      if c and $8000 = 0
        then FDetails.Add('Bit 15=0: absolute row index')
        else FDetails.Add('Bit 15=1: relative row index');
    end;
    s := Format('%d ($%.4x)', [c, c]);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'First column index');

    if FCurrRow = Row then
    begin
      FDetails.Add('ColIndex information:'#13);
      FDetails.Add(Format('Bits 0-13: ColIndex = %d (%s)', [c2 and $3FFF, ABS_REL[c2 and $8000 <> 0]]));
      if c2 and $4000 = 0
        then FDetails.Add('Bit 14=0: absolute column index')
        else FDetails.Add('Bit 14=1: relative column index');
      if c2 and $8000 = 0
        then FDetails.Add('Bit 15=0: absolute row index')
        else FDetails.Add('Bit 15=1: relative row index');
    end;
    s := Format('%d ($%.4x)', [c2, c2]);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Last column index');
  end
  else
  begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    r := WordLEToN(w);
    Move(FBuffer[FBufferIndex+2], w, numBytes);
    r2 := WordLEToN(w);

    numbytes := 1;
    c := FBuffer[FBufferIndex+4];
    c2 := FBuffer[FBufferIndex+5];

    if FCurrRow = Row then
    begin
      FDetails.Add('RowIndex information:'#13);
      FDetails.Add(Format('Bits 0-13: RowIndex = %d (%s)', [r and $3FFF, ABS_REL[r and $4000 <> 0]]));
      if r and $4000 = 0
        then FDetails.Add('Bit 14=0: absolute column index')
        else FDetails.Add('Bit 14=1: relative column index');
      if r and $8000 = 0
        then FDetails.Add('Bit 15=0: absolute row index')
        else FDetails.Add('Bit 15=1: relative row index');
    end;
    s := Format('%d ($%.4x)', [r, r]);
    ShowInRow(FCurrRow, FBufferIndex, 2, s, 'First row index');

    if FCurrRow = Row then
    begin
      FDetails.Add('RowIndex information:'#13);
      FDetails.Add(Format('Bits 0-13: RowIndex = %d (%s)', [r2 and $3FFF, ABS_REL[r2 and $4000 <> 0]]));
      if r2 and $4000 = 0
        then FDetails.Add('Bit 14=0: absolute column index')
        else FDetails.Add('Bit 14=1: relative column index');
      if r2 and $8000 = 0
        then FDetails.Add('Bit 15=0: absolute row index')
        else FDetails.Add('Bit 15=1: relative row index');
    end;
    s := Format('%d ($%.4x)', [r2, r2]);
    ShowInRow(FCurrRow, FBufferIndex, 2, s, 'Last row index');

    if FCurrRow = Row then
    begin
      FDetails.Add('ColIndex information:'#13);
      FDetails.Add(Format('ColIndex = %d (%s)', [c, ABS_REL[r and $8000 <> 0]]));
    end;
    s := Format('%d ($%.4x)', [c, c]);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'First column index');

    if FCurrRow = Row then
    begin
      FDetails.Add('ColIndex information:'#13);
      FDetails.Add(Format('ColIndex = %d (%s)', [c2, ABS_REL[r2 and $8000 <> 0]]));
    end;
    s := Format('%d ($%.4x)', [c2, c2]);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Last column index');
  end;
end;


procedure TBIFFGrid.ShowClrtClient;
var
  w: Word;
  dw: DWord;
  numbytes: Word;
begin
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);

  RowCount := FixedRows + w + 1;

  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Number of colors (must be 3)');

  numBytes := 4;
  Move(FBuffer[FBufferIndex], dw, numbytes);
  dw := DWordLEToN(dw);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x', [dw]),
    'Foreground color (system window text color)');
  Move(FBuffer[FBufferIndex], dw, numbytes);
  dw := DWordLEToN(dw);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x', [dw]),
    'Background color (system window color)');
  Move(FBuffer[FBufferIndex], dw, numbytes);
  dw := DWordLEToN(dw);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x', [dw]), '???');
end;


procedure TBIFFGrid.ShowCodePage;
var
  numBytes: Word;
  w: Word;
  s: String;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  s := CodePageName(w);
  if Row = FCurrRow then begin
    FDetails.Add('Code page:'#13);
    FDetails.Add(Format('$%.04x = %s', [w, s]));
  end;
  if s <> '' then s := 'Code page identifier (' + s + ')' else s := 'Code page identifier';
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]), s);
end;


procedure TBIFFGrid.ShowColInfo;
var
  numBytes: Integer;
  w: Word;
begin
  if FFormat = sfExcel2 then
    exit;

  RowCount := FixedRows + 5;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index of first column in range');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index of last column in range');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d (%f characters)', [w, w/256]),
    'Width of the columns in 1/256 of the width of the zero character, using default font (first FONT record in the file)');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Index to XF record for default column formatting');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Column options:'#13);
    if w and $0001 = 0
      then FDetails.Add('Bit  $0001 = 0: Columns are NOT hidden')
      else FDetails.Add('Bit  $0001 = 1: Columns are hidden');
    FDetails.Add(Format('Bits $0700 = %d: Outline level of the columns (0 = no outline)', [(w and $0700) shr 8]));
    if w and $1000 = 0
      then FDetails.Add('Bit  $1000 = 0: Columns are NOT collapsed')
      else FDetails.Add('Bit  $1000 = 1: Columns are collapsed');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w), 'Option flags');
end;


procedure TBIFFGrid.ShowColWidth;
var
  numBytes: Integer;
  w: Word;
  b: Byte;
begin
  if FFormat <> sfExcel2 then
    exit;

  RowCount := FixedRows + 3;

  numBytes := 1;
  b := FBuffer[FBufferIndex];
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
    'Index of first column');

  numBytes := 1;
  b := FBuffer[FBufferIndex];
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
    'Index of last column');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Width of the columns in 1/256 of the width of the zero character, using default font (first FONT record in the file)');
end;


procedure TBIFFGrid.ShowContinue;
var
  numbytes: Integer;
  s: String;
  sa: ansistring;
  sw: widestring;
  ls: Integer;
  i, j: Integer;
  w: Word;
  n: Integer;
  run: Integer;
  total2: Integer;
  optn: Byte;
  rtfRuns: TRichTextFormattingRuns;
  rtfBufferIndex: LongWord;
begin
  case FInfo of
    BIFFNODE_TXO_CONTINUE1:
      begin
        RowCount := FixedRows + 1;
        numbytes := Length(FBuffer);
        if FBuffer[FBufferIndex] = 0 then begin
          ls := Length(FBuffer)-1;
          SetLength(sa, ls);
          Move(FBuffer[FBufferIndex+1], sa[1], ls);
          s := AnsiToUTF8(sa);
        end else
        if FBuffer[FBufferIndex] = 1 then begin
          ls := (Length(FBuffer) - 1) div SizeOf(WideChar);
          SetLength(sw, ls);
          Move(FBuffer[FBufferIndex+1], sw[1], ls*SizeOf(WideChar));
          s := UTF8Encode(sw);
        end else
          s := 'ERROR!!!';
        s := UTF8StringReplace(s, #$0A, '[/n]', [rfReplaceAll]);
        ShowInRow(FCurrRow, FBufferIndex, numbytes, s, 'Comment text');
      end;

    BIFFNODE_TXO_CONTINUE2:
      begin
        RowCount := FixedRows + 1000;
        n := 0;
        numBytes := 2;
        run := 1;
        while FBufferIndex < Length(FBuffer) - 4*SizeOf(Word) do begin
          Move(FBuffer[FBufferIndex], w, numBytes);
          ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)), Format(
            'Run %d: Index of first character using this font (0-based)', [run]));
          inc(n);

          Move(FBuffer[FBufferIndex], w, numbytes);
          ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToSTr(WordLEToN(w)),
            Format('Run %d: Index to FONT record', [run]));
          inc(n);

          Move(FBuffer[FBufferIndex], w, numbytes);
          ShowInrow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
            'Not used');
          inc(n);

          Move(FBuffer[FBufferIndex], w, numbytes);
          ShowInrow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
            'Not used');
          inc(n);

          inc(run);
        end;

        // lastRun
        Move(FBuffer[FBufferIndex], w, numbytes);
        ShowInrow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
          'Number of characters');
        inc(n);

        Move(FBuffer[FBufferIndex], w, numbytes);
        ShowInrow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
          'Not used');
        inc(n);

        Move(FBuffer[FBufferIndex], w, numbytes);
        ShowInrow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
          'Not used');
        inc(n);

        Move(FBuffer[FBufferIndex], w, numbytes);
        ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
          'Not used');
        inc(n);

        RowCount := FixedRows + n;
      end;

    BIFFNODE_SST_CONTINUE:
      begin  // Continues an SST record
        if FPendingCharCount = -1 then
        begin
          RowCount := FixedRows + 1;
          ShowInRow(FCurrRow, FBufferIndex, 0, '', 'Please select preceding SST record first.');
          exit;
        end;

        RowCount := FixedRows + FTotalSST;
        n := 0;

        optn := FBuffer[FBufferIndex];
        if optn and $01 = $01 then  // wide characters
          ExtractString(FBufferIndex+1, true, FPendingCharCount, s, numBytes)
        else
          ExtractString(FBufferIndex+1, false, FPendingCharCount, s, numbytes);
        FPendingCharCount := -1;
        inc(numbytes, 1);
        ShowInRow(FCurrRow, FBufferIndex, numbytes, s, Format('Shared String #%d (rest)', [FCounterSST]));
        inc(n);

        FPendingCharCount := -1;

        for i:=FCounterSST+1 to FTotalSST do
        begin
          FCounterSST := i;
          ExtractString(FBufferIndex, 2, true, s, numBytes, rtfRuns, rtfBufferIndex);
          ShowInRow(FCurrRow, FBufferIndex, numBytes, s, Format('Shared string #%d', [i]));
          inc(n);
          if Length(rtfRuns) > 0 then begin
            numBytes := 2;
            for j:=0 to High(rtfRuns) do
            begin
              ShowInRow(FCurrRow, rtfBufferIndex, 2, IntToStr(rtfRuns[j].FirstIndex),
                Format('Rich-Text formatting run #%d, index of first character', [j]));
              ShowInRow(FCurrRow, rtfBufferIndex, 2, IntToStr(rtfRuns[j].FontIndex),
                Format('Rich-Text formatting run #%d, font index', [j]));
              inc(n, 2);
            end;
          end;
          if FPendingCharCount > 0 then
          begin
            FInfo := BIFFNODE_SST_CONTINUE;
            break;
          end;
        end;
        RowCount := FixedRows + n;
        if FPendingCharCount = 0 then
          FPendingCharCount := -1;
      end;
  end;
end;


procedure TBIFFGrid.ShowCountry;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 2;
  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Windows country identifier for UI language of Excel');

  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Windows country identifier of system regional settings');
end;


procedure TBIFFGrid.ShowDateMode;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    '0 = Base date is 1899-Dec-31, 1 = Base date is 1904-Jan-01');
end;

procedure TBIFFGrid.ShowDBCell;
var
  i, n: Integer;
  dw: DWord;
  w: Word;
  numBytes: Integer;
begin
  if FFormat < sfExcel5 then exit;

  n := (Length(FBuffer) - 4) div 2;
  RowCount := FixedRows + 1 + n;

  numBytes := 4;
  Move(FBuffer[FBufferIndex], dw, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)),
    'Relative offset to first ROW record in the Row Block');

  numBytes := 2;
  for i:=1 to n do begin
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Relative offsets to calculate stream position of the first cell record in row');
  end;
end;

procedure TBIFFGrid.ShowDefColWidth;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Column width in characters, using the width of the zero character from default '+
    'font (first FONT record in the file) + some extra space.');
end;


procedure TBIFFGrid.ShowDefinedName;
var
  numBytes: Integer;
  b: Byte;
  w: Word;
  isFuncMacro: Boolean;
  lenName: Word;
  ansistr: AnsiString;
  widestr: WideString;
  s: String;
  macro: Boolean;
  formulaSize: Word;
  firstTokenBufIdx: Integer;
  token: Byte;
  r,c, r2,c2: Integer;
  builtinName: Boolean;
begin
  BeginUpdate;
  RowCount := FixedRows + 1000;
  // Brute force simplification because of unknown row count at this point
  // Will be reduced at the end.

  builtinName := false;
  if FFormat = sfExcel2 then
  begin
    numBytes := 1;
    b := FBuffer[FBufferIndex];
    isFuncMacro := b and $02 <> 0;
    if Row = FCurrRow then begin
      FDetails.Add('Option flags:'#13);
      if b and $02 = 0 then
        FDetails.Add('  Bit $02 = 0: NO function macro or command macro')
      else
        FDetails.Add('* Bit $02 = 1: Function macro or command macro');
      if b and $04 = 0 then
        FDetails.Add('  Bit $04 = 0: NO Complex function (array formula or user defined)')
      else
        FDetails.Add('* Bit $04 = 1: Complex function (array formula or user defined)');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]),
      'Option flags');

    numBytes := 1;
    b := FBuffer[FBufferIndex];
    if isFuncMacro then
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
        '$01 = Function macro, $02 = Command macro')
    else
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
        'unknown');

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
      'Keyboard shortcut (only for command macro names)');

    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
      'Length of the name (character count)');
    lenName := b;

    numbytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBUfferIndex, numBytes, IntToStr(b),
      'Size of the formula data');
    formulaSize := b;
  end
  else
  begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      macro := (w and $0008 <> 0);
      builtinName := (w and $0020 <> 0);
      FDetails.Add('Option flags:'#13);
      if w and $0001 = 0
        then FDetails.Add('  Bit $0001 (flag name "hidden") = 0: Visible')
        else FDetails.Add('* Bit $0001 (flag name "hidden")= 1: Hidden');
      if w and $0002 = 0
        then FDetails.Add('  Bit §0002 (flag name "func") = 0: Command macro')
        else FDetails.Add('* Bit $0002 (flag name "func") = 1: Function macro');
      if w and $0004 = 0
        then FDetails.Add('  Bit $0004 (flag name "vbasic") = 0: Sheet macro')
        else FDetails.Add('* Bit $0004 (flag name "vbasic") = 1: Visual basic macro');
      if w and $0008 = 0
        then FDetails.Add('  Bit $0008 (flag name "macro") = 0: Standard name')
        else FDetails.Add('* Bit $0008 (flag name "macro") = 1: Macro name');
      if w and $0010 = 0
        then FDetails.Add('  Bit $0010 (flag name "complex") = 0: Simple formula')
        else FDetails.Add('* Bit $0010 (flag name "complex") = 1: Complex formula (array formula or user defined)');
      if w and $0020 = 0
        then FDetails.Add('  Bit $0020 (flag name "builtin") = 0: User-defined name')
        else FDetails.Add('* Bit $0020 (flag name "builtin") = 1: Built-in name');
      case (w and $0FC0) shr 6 of
        0: if macro then
             FDetails.Add('  Bit $0FC0 = 0: --- forbidden value, must be > 0 ---')
           else
             FDetails.Add('  Bit $0FC0 (flag name "funcgroup") = 0: not used (requires "macro" = 1)');
        1: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 1: financial');
        2: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 2: date & time');
        3: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 3: math & trig');
        4: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 4: statistical');
        5: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 5: lookup & reference');
        6: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 6: database');
        7: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 7: text');
        8: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 8: logical');
        9: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 9: information');
       10: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 10: commands');
       11: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 11: customizing');
       12: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 12: macro control');
       13: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 13: dde/external');
       14: FDetails.Add('* Bit $0FC0 (flag name "funcgroup") = 14: user defined');
      end;
      if w and $1000 = 0
        then FDetails.Add('  Bit $1000 (flag name "binary") = 0: formula definition')
        else FDetails.add('* Bit $1000 (flag name "binary") = 1: binary data (BIFF5-BIFF8)');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
      'Option flags');

    numbytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInrow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b, b]),
      'Keyboard shortcurt (only for command macro names)');

    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
      'Length of the name (character count)');
    lenName := b;

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
      'Size of the formula data');
    formulaSize := w;

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    if FFormat = sfExcel5 then
      ShowInRow(FCurrRow, FBufferIndex, NumBytes, IntToStr(w),
        '0 = Global name, otherwise index to EXTERNSHEET record (one-based)')
    else
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
        'not used');

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, NumBytes, IntToStr(w),
      '0 = Global name, otherwise index to sheet (one-based)');

    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, nuMbytes, IntToStr(b),
      'Length of the menu text (character count)');

    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, nuMbytes, IntToStr(b),
      'Length of the description text (character count)');

    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, nuMbytes, IntToStr(b),
      'Length of the help topic text (character count)');

    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, nuMbytes, IntToStr(b),
      'Length of the status bar text (character count)');

    if FFormat = sfExcel5 then begin
      numBytes := lenName * sizeOf(ansiChar);
      SetLength(ansiStr, lenName);
      Move(FBuffer[FBufferIndex], ansiStr[1], numbytes);
      ShowInRow(FCurrRow, FBufferIndex, numBytes, ansiStr,
        'Character array of the name');
    end else
    begin
      if (FBuffer[FBufferIndex] and $01 = 0) //and (not IgnoreCompressedFlag)
      then begin   // compressed --> 1 byte per character
        SetLength(ansiStr, lenName);
        numbytes := lenName*SizeOf(ansiChar) + 1;
        Move(FBuffer[FBufferIndex + 1], ansiStr[1], lenName*SizeOf(AnsiChar));
        s := AnsiToUTF8(ansiStr);
      end else begin
        SetLength(wideStr, lenName);
        numBytes := lenName*SizeOf(WideChar) + 1;
        Move(FBuffer[FBufferIndex + 1], wideStr[1], lenName*SizeOf(WideChar));
        s := UTF8Encode(WideStringLEToN(wideStr));
      end;
      if builtinName and (Length(s) = 1) then begin
        s := Format('%s ($%x --> ', [s, ord(s[1])]);
        case ord(s[1]) of
          0: s := s + 'Consolidate_Area)';
          1: s := s + 'Auto_Open)';
          2: s := s + 'Auto_Close)';
          3: s := s + 'Extract)';
          4: s := s + 'Database)';
          5: s := s + 'Citeria)';
          6: s := s + 'Print_Area)';
          7: s := s + 'Print_Titles)';
          8: s := s + 'Recorder)';
          9: s := s + 'Data_Form)';
         10: s := s + 'Auto_Activate)';
         11: s := s + 'Auto_Deactivate)';
         12: s := s + 'Sheet_Title)';
         13: s := s + '_FilterDatabase)';
         else s := s + 'unknown meaning)';
        end;
      end;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
        'Name (Unicode string without length field)');
    end;
  end;

  firstTokenBufIdx := FBufferIndex;
  while FBufferIndex < firstTokenBufIdx + formulaSize do begin
    token := FBuffer[FBufferIndex];
    numBytes := 1;
    case token of
      $3A, $3B, $5A, $5B, $7A, $7B:
        begin
          case token of
            $3A: s := 'Token tRef3dR for "3D or external reference to a cell" (R = Reference)';
            $5A: s := 'Token tRef3dV for "3D or external reference to a cell" (V = Value)';
            $7A: s := 'Token tRef3dA for "3D or external reference to a cell" (A = Area)';
            $3B: s := 'Token tArea3dR for "3D or external reference to a cell range" (R = Reference)';
            $5B: s := 'Token tArea3dV for "3D or external reference to a cell range" (V = Value)';
            $7B: s := 'Token tArea3dA for "3D or external reference to a cell range" (A = Area)';
          end;
          ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.2x', [token]), s);

          numbytes := 2;
          Move(FBuffer[FBufferIndex], w, numBytes);
          w := WordLEToN(w);
          if FFormat = sfExcel5 then begin
            if w and $8000 <> 0 then begin  // negative value --> 3D reference
              ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(SmallInt(w)),
                '3D reference, 1-based index to EXTERNSHEET record');
              numBytes := 8;
              ShowInRow(FCurrRow, FBufferIndex, numBytes, '', 'Not used');
              numBytes := 2;
              Move(FBuffer[FBufferIndex], w, numBytes);
              ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
                'Index to first referenced sheet ($FFFF = deleted sheet)');
              Move(FBuffer[FBufferIndex], w, numBytes);
              ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
                'Index to last referenced sheet ($FFFF = deleted sheet)');
            end else
            begin
              ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
                'External reference, 1-based index to EXTERNSHEET record');
              numBytes := 12;
              ShowInRow(FCurrRow, FBufferIndex, numBytes, '', 'Not used');
            end;
          end else
            ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
              'Index to REF entry in EXTERNSHEET record');

          if token in [$3A, $5A, $7A] then
            ShowCellAddress        // Cell address
          else
            ShowCellAddressRange(FFormat);  // Cell range
        end;

      else
        numBytes := 1;
        ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
          '(unknown token)');
    end;  // case
  end;  // while

  RowCount := FCurrRow;
  EndUpdate(true);
end;

procedure TBIFFGrid.ShowDefRowHeight;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + IfThen(FFormat = sfExcel2, 1, 2);

  if FFormat = sfExcel2 then begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      FDetails.Add('Default height for unused rows:'#13);
      FDetails.Add(Format(
        'Bits $7FFF = %d: Default height for unused rows, in twips = 1/20 of a point',
        [w and $7FFF]));
      if w and $8000 = 0 then
        FDetails.Add('Bit $8000 = 0: Row height changed manually')
      else
        FDetails.Add('Bit $8000 = 1: Row height not changed manually');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
      'Default height for unused rows, in twips = 1/20 of a point');
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      FDetails.Add('Option flags:'#13);
      if w and $0001 = 0
        then FDetails.Add('Bit $0001 = 0: Row height and default font height do match')
        else FDetails.Add('Bit $0001 = 1: Row height and default font height do not match');
      if w and $0002 = 0
        then FDetails.Add('Bit $0002 = 0: Row is visible')
        else FDetails.Add('Bit $0002 = 1: Row is hidden');
      if w and $0004 = 0
        then FDetails.Add('Bit $0004 = 0: No additional space above the row')
        else FDetails.Add('Bit $0004 = 1: Additional space above the row');
      if w and $0008 = 0
        then FDetails.Add('Bit $0008 = 0: No additional space below the row')
        else FDetails.Add('Bit $0008 = 1: Additional space below the row');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [WordLEToN(w)]),
      'Option flags');

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
      'Default height for unused rows, in twips = 1/20 of a point');
  end;
end;


procedure TBIFFGrid.ShowDelta;
var
  numBytes: Integer;
  dbl: Double;
begin
  RowCount := FixedRows + 1;
  numBytes := 8;
  Move(FBuffer[FBufferIndex], dbl, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, FloatToStr(dbl),
    'Maximum change in iteration (IEEE 754 floating-point value, 64-bit double precision)');
end;


procedure TBIFFGrid.ShowDimensions;
var
  numBytes: Integer;
  dw: DWord;
  w: Word;
begin
  RowCount := FixedRows + IfThen(FFormat = sfExcel2, 4, 5);

  if FFormat = sfExcel8 then begin
    numBytes := 4;
    Move(FBuffer[FBufferIndex], dw, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(DWordLEToN(dw)),
      'Index to first used row');

    Move(FBuffer[FBufferIndex], dw, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(DWordLEToN(dw)),
      'Index to last used row, increased by 1');
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
      'Index to first used row');

    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
      'Index to last used row, increased by 1');
  end;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to first used column');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to last used column, increased by 1');

  if FFormat <> sfExcel2 then begin
    numBytes := 2;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, '',
      '(not used)');
  end;
end;


procedure TBIFFGrid.ShowDSF;
var
  w: Word;
  numbytes: Integer;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w), 'Reserved, MUST be ignored');
end;


procedure TBIFFGrid.ShowEOF;
begin
  RowCount := FixedRows + 1;
  ShowInRow(FCurrRow, FBufferIndex, 0, '', '(no content)');
end;


procedure TBIFFGrid.ShowExcel9File;
begin
  RowCount := FixedRows + 1;
  ShowInRow(FCurrRow, FBufferIndex, 0, '', 'Optional and unused');
end;


procedure TBIFFGrid.ShowExternBook;
var
  numBytes: Integer;
  w: Word;
  wideStr: WideString;
  ansiStr: AnsiString;
  s: String;
  i, n: Integer;
  b: Byte;
  rtfRuns: TRichTextFormattingRuns;
begin
  BeginUpdate;
  RowCount := FixedRows + 1000;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  n := WordLEToN(w);

  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(n),
    'Number of sheet names / number of sheets');

  if Length(FBuffer) - FBufferIndex = 2 then begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    SetLength(ansiStr, 1);
    ansiStr[1] := char((w and $FF00) shr 8);
    s := Format('%s (string bytes <#%.2x> <#%.2x>)', [ansistr, w and $00FF, (w and $FF00) shr 8]);

    ShowInRow(FCurrRow, FBufferIndex, numBytes, s,
      '(relict of BIFF5)');
  end else begin
    ExtractString(FBufferIndex, 2, true, s, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Encoded URL without sheet name:'#13);
      case s[1] of
        #0: FDetails.Add('First character = #00: Reference relative to current sheet');
        #1: FDetails.Add('First character = #01: Encoded URL follows');
        #2: if FFormat = sfExcel8 then
              FDetails.Add('First character = #02: Reference to a sheet in own document; sheet name follows')
            else
              FDetails.Add('First character = #02: Reference to the corrent sheet (nothing will follow)');
        #3: if FFormat = sfExcel5 then
              FDetails.Add('First character = #03: Reference to a sheet in own document; sheet name follows')
            else
              FDetails.Add('First character = #03: not used');
        #4: if FFormat = sfExcel5 then
              FDetails.ADd('First character = #03: Reference to the own workbook, sheet is unspecified (nothing will follow)')
            else
              FDetails.Add('First character = #03: not used');
      end;
    end;
    if s[1] in [#0, #1, #2, #3, #4] then Delete(s, 1, 1);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s,
      'Encoded URL without sheet name (Unicode string, 16-bit string length)');

    for i:=0 to n-1 do begin
      ExtractString(FBufferIndex, 2, true, s, numBytes);
      ShowInRow(FCurrRow, FBufferIndex, numBytes, s,
        'Sheet name (Unicode string with 16-bit string length)');
    end;
  end;

  RowCount := FCurrRow;
  EndUpdate(true);
end;


procedure TBIFFGrid.ShowExternCount;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Number of following EXTERNSHEET records');
end;


procedure TBIFFGrid.ShowExternSheet;
var
  numBytes: Integer;
  w: Word;
  s: String;
  nREF: Integer;
  i: Integer;
  len: Byte;
  ansiStr: AnsiString;
begin
  if FFormat <= sfExcel5 then begin
    RowCount := FixedRows + 1;
    len := FBuffer[0];
    if FBuffer[1] = $03 then inc(len);
    numBytes := len*SizeOf(AnsiChar) + 1;
    SetLength(ansiStr, len);
    Move(FBuffer[1], ansiStr[1], len*SizeOf(AnsiChar));
    s := AnsiToUTF8(ansiStr);
    if FCurrRow = Row then begin
      FDetails.Add('Encoded document and sheet name:'#13);
      if s[1] = #03 then begin
        FDetails.Add('First character = $03: EXTERNSHEET stores a reference to one of the own sheets');
        FDetails.Add('Document name: ' + Copy(s, 2, Length(s)));
      end else
      if (s[1] = ':') and (Length(s) = 1) then begin
        FDetails.Add('Special EXTERNSHEET record for an add-in function. EXTERNName record with the name of the function follows.');
      end else
        FDetails.Add('Document name: ' + s);
    end;
    if s[1] = #03 then
      Delete(s, 1, 1);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s,
      'Encoded document and sheet name (Byte string, 8-bit string length)');
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    nREF := WordLEToN(w);

    RowCount := FixedRows + 1 + nREF*3;

    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(nREF),
      'Number of following REF structures');

    for i:=1 to nREF do begin
      Move(FBuffer[FBufferIndex], w, numBytes);
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
        Format('REF #%d: Index to EXTERNBOOK record', [i]));

      Move(FBuffer[FBufferIndex], w, numBytes);
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
        Format('REF #%d: Index to first sheet in EXTERNBOOK sheet list', [i]));

      Move(FBuffer[FBufferIndex], w, numBytes);
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
        Format('REF #%d: Index to last sheet in EXTERNBOOK sheet list', [i]));
    end;
  end;
end;


procedure TBIFFGrid.ShowFileSharing;
var
  numbytes: Integer;
  w: Word;
  s: String;
begin
  RowCount := FixedRows + 3;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Recommend read-only state when loading the file:'#13);
    if w = 0 then FDetails.Add('0 = no') else FDetails.Add('1 = yes');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Recommend read-only state when loading the file');

  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [w]),
    'Hash value calculated from the read-only password');

  ExtractString(FBufferIndex, IfThen(FFormat=sfExcel8, 2, 1), FFormat=sfExcel8,
    s, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
    'User name of the file creator' + IfThen(FFormat = sfExcel8,
    ' (Unicode string, 16-bit string length)',
    ' (byte string, 8-bit string length)'
  ));
end;


procedure TBIFFGrid.ShowFnGroupCount;
var
  numbytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Number of built-in function categories:'#13);
    case w of
      $000E:
        FDetails.Add(
          'There are 14 built-in function categories in the workbook.'#13+
          'This implies that the file was last saved by a specific version of the application.'#13+
          'The following 9 built-in function categories are visible to the end-user:'#13+
          '  Financial'#13+
          '  Date & Time'#13+
          '  Math & Trig'#13+
          '  Statistical'#13+
          '  Lookup & Reference'#13+
          '  Database'#13+
          '  Text'#13+
          '  Logical'#13+
          '  Information'#13+
          'The following 5 built-in function categories are not visible to the end-user:'#13+
          '  UserDefined'#13+
          '  Commands'#13+
          '  Customize'#13+
          '  MacroControl'#13+
          '  DDEExternal'
        );
      $0010:
        FDetails.Add(
          'There are 16 built-in function categories in the workbook.'#13+
          'This implies that the file was last saved by a specific version of the application'#13+
          'The following 11 built-in function categories are visible to the end-user:'#13+
          '  Financial'#13+
          '  Date & time'#13+
          '  Math & Trig'#13+
          '  Statistical'#13+
          '  Lookup & Reference'+
          '  Database'#13+
          '  Text'#13+
          '  Logical'#13+
          '  Information'#13+
          '  Engineering'#13+
          '  Cube'#13+
          'The following 5 built-in function categories are not visible to the end-user:'#13+
          '  UserDefined'#13+
          '  Commands'#13+
          '  Customize'#13+
          '  MacroControl'#13+
          '  DDEExternal'
        );
    end;
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Number of built-in function categories');
end;


procedure TBIFFGrid.ShowFont;
var
  numbytes: Integer;
  w: Word;
  b: Byte;
  s: String;
begin
  RowCount := IfThen(FFormat = sfExcel2, 3, 10) + FixedRows;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d (= %.1gpt)', [w, w/20]),
    'Font height in twips (=1/20 point)');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Option flags:'#13);
    if w and $0001 = 0
      then FDetails.Add('  Bit $0001 = 0: not bold')
      else FDetails.Add('x Bit $0001 = 1: bold (redundant in BIFF5-BIFF8)');
    if w and $0002 = 0
      then FDetails.Add('  Bit $0002 = 0: not italic')
      else FDetails.Add('x Bit $0002 = 1: italic');
    if w and $0004 = 0
      then FDetails.Add('  Bit $0004 = 0: not underlined')
      else FDetails.Add('x Bit $0004 = 1: underlined (redundant in BIFF5-BIFF8)');
    if w and $0008 = 0
      then FDetails.Add('  Bit $0008 = 0: not struck out')
      else FDetails.Add('x Bit $0008 = 1: struck out');
    if w and $0010 = 0
      then FDetails.Add('  Bit $0010 = 0: not outlined')
      else FDetails.Add('x Bit $0010 = 1: outlined');
    if w and $0020 = 0
      then FDetails.Add('  Bit $0020 = 0: not shadowed')
      else FDetails.Add('x Bit $0020 = 1: shadowed');
    if w and $0040 = 0
      then FDetails.Add('  Bit $0040 = 0: not condensed')
      else FDetails.Add('x Bit $0040 = 1: condensed');
    if w and $0080 = 0
      then FDetails.Add('  Bit $0080 = 0: not extended')
      else FDetails.Add('x Bit $0080 = 1: extended');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
    'Option flags');

  if FFormat <> sfExcel2 then begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Color index');

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w,w]),
      'Font weight (400=normal, 700=bold)');

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      FDetails.Add('Escapement:'#13);
      case w of
        0: FDetails.Add('0 = none');
        1: FDetails.Add('1 = superscript');
        2: FDetails.Add('2 = subscript');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [w]),
      'Escapement ($00=none, $01=superscript, $02=subscript)');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Underline type:'#13);
      case b of
        $00: FDetails.Add('$00 = no underline');
        $01: FDetails.Add('$01 = single underline');
        $02: FDetails.Add('$02 = double underline');
        $21: FDetails.Add('$21 = single accounting');
        $22: FDetails.Add('$22 = double accounting');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]),
      'Underline type ($00=none, $01=single, $02=double, ...)');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Font family:'#13);
      case b of
        $00: FDetails.Add('$00 = None (unknown or don''t care)');
        $01: FDetails.Add('$01 = Roman (variable width, serifed)');
        $02: FDetails.Add('$02 = Swiss (variable width, sans-serifed)');
        $03: FDetails.Add('$03 = Modern (fixed width, serifed or sans-serifed)');
        $04: FDetails.Add('$04 = Script (cursive)');
        $05: FDetails.Add('$05 = Decorative (specialised, for example Old English, Fraktur)');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%.2x', [b]),
      'Font family');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    case b of
      $00: s := 'ANSI Latin';
      $01: s := 'System default';
      $02: s := 'Symbol';
      $4D: s := 'Apple Roman';
      $80: s := 'ANSI Japanese Shift-JIS';
      $81: s := 'ANSI Korean (Hangul)';
      $82: s := 'ANSI Korean (Johab)';
      $86: s := 'ANSI Chinese Simplified GBK';
      $88: s := 'ANSI Chinese Traditional BIG5';
      $A1: s := 'ANSI Greek';
      $A2: s := 'ANSI Turkish';
      $A3: s := 'ANSI Vietnamese';
      $B1: s := 'ANSI Hebrew';
      $B2: s := 'ANSI Arabic';
      $BA: s := 'ANSI Baltic';
      $CC: s := 'ANSI Cyrillic';
      $DE: s := 'ANSI Thai';
      $EE: s := 'ANSI Latin II (Central European)';      // East Europe in MS docs!
      $FF: s := 'OEM Latin I';
      else s := '';
    end;
    if s <> '' then s := Format('$%.2x: %s', [b, s]) else s := Format('$%.2x', [b]);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s,
      'Character set');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]), 'Not used');
  end;

  ExtractString(FBufferIndex, 1, FFormat=sfExcel8, s, numbytes);
  if FFormat = sfExcel8 then
    ShowInRow(FCurrRow, FBufferIndex, numbytes, s, 'Font name (unicode string, 8-bit string length)')
  else
    ShowInRow(FCurrRow, FBufferIndex, numbytes, s, 'Font name (byte string, 8-bit string length)');
end;


procedure TBIFFGrid.ShowFontColor;
var
  numBytes: Integer;
  w: Word;
  s: String;
begin
  RowCount := FixedRows + 1;
  NumBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  case w of
    $0000: s := 'EGA Black (rgb = $000000)';
    $0001: s := 'EGA White (rgb = $FFFFFF)';
    $0002: s := 'EGA Red (rgb = $0000FF)';
    $0003: s := 'EGA Green (rgb = $00FF00)';
    $0004: s := 'EGA Blue (rgb = $FF0000)';
    $0005: s := 'EGA Yellow (rgb = $00FFFF)';
    $0006: s := 'EGA Magenta (rgb = $FF00FF)';
    $0007: s := 'EGA Cyan (rgb = $FFFF00)';
    $7FFF: s := 'Automatic (system window text colour)';
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.04x)', [w, w]),
    Format('Font color index into preceding FONT record (%s)', [s]));
end;

procedure TBIFFGrid.ShowFooter;
var
  numbytes: Integer;
  s: String;
begin
  RowCount := FixedRows + 1;
  ExtractString(FBufferIndex, IfThen(FFormat=sfExcel8, 2, 1), FFormat=sfExcel8,
    s, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
    'Page footer string' + IfThen(FFormat = sfExcel8,
    ' (Unicode string, 16-bit string length)',
    ' (byte string, 8-bit string length)'
  ));
end;


procedure TBIFFGrid.ShowFormat;
var
  numBytes: Integer;
  w: word;
  b: Byte;
  s: String;
begin
  RowCount := IfThen(FFormat = sfExcel2, FixedRows + 1, FixedRows + 2);
  if FFormat <> sfExcel2 then begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
      'FormatIndex used in other records');
  end;
  b := IfThen(FFormat=sfExcel8, 2, 1);
  ExtractString(FBufferIndex, b, (FFormat=sfExcel8), s, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, s,
    Format('Number format string (%s string, %d-bit string length)', [GetStringType, b*8]));
end;


procedure TBIFFGrid.ShowFormatCount;
var
  numBytes: Integer;
  w: Word;
begin
  if FFormat = sfExcel2 then begin
    RowCount := 1 + FixedRows;
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Number of FORMAT records');
  end;
end;


procedure TBIFFGrid.ShowFormula;
var
  numBytes: Integer;
  b: Byte;
  w: Word;
  q: QWord;
  dbl: double absolute q;
  bytearr: array[0..7] of byte absolute q;
  wordarr: array[0..3] of word absolute q;
//  s: String;
  tokenBytes: Integer;
//  firstTokenBufIdx: Integer;
//  token: Byte;
  r,c, r2,c2: Integer;
begin
  BeginUpdate;
  RowCount := FixedRows + 1000;
  // Brute force simplification because of unknown row count at this point
  // Will be reduced at the end.

  // Offset 0 = Row, Offset 2 = Column
  ShowRowColData(FBufferIndex);
  // Offset 4 = Cell attributes (BIFF2) or XF ecord index (> BIFF2)
  if FFormat = sfExcel2 then begin
    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Cell protection and XF index:'#13);
      FDetails.Add(Format('x Bits 5-0 = %d: XF Index', [b and $3F]));
      case b and $40 of
        0: FDetails.Add('  Bit 6 = 0: Cell is NOT locked.');
        1: FDetails.Add('x Bit 6 = 1: Cell is locked.');
      end;
      case b and $80 of
        0: FDetails.Add('  Bit 7 = 0: Formula is NOT hidden.');
        1: FDetails.Add('x Bit 7 = 1: Formula is hidden.');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
      'Cell protection and XF index');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Indexes to format and font records:'#13);
      FDetails.Add(Format('Bits 5-0 = %d: Index to FORMAT record', [b and $3f]));
      FDetails.Add(Format('Bits 7-6 = %d: Index to FONT record', [(b and $C0) shr 6]));
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
      'Indexes of format and font records');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Cell style:'#13);
      case b and $07 of
        0: FDetails.Add('Bits 2-0 = 0: Horizontal alignment is GENERAL');
        1: FDetails.Add('Bits 2-0 = 1: Horizontal alignment is LEFT');
        2: FDetails.Add('Bits 2-0 = 2: Horizontal alignment is CENTERED');
        3: FDetails.Add('Bits 2-0 = 3: Horizontal alignment is RIGHT');
        4: FDetails.Add('Bits 2-0 = 4: Horizontal alignment is FILLED');
      end;
      if b and $08 = 0
        then FDetails.Add('Bit 3 = 0: Cell has NO left border')
        else FDetails.Add('Bit 3 = 1: Cell has left black border');
      if b and $10 = 0
        then FDetails.Add('Bit 4 = 0: Cell has NO right border')
        else FDetails.Add('Bit 4 = 1: Cell has right black border');
      if b and $20 = 0
        then FDetails.Add('Bit 5 = 0: Cell has NO top border')
        else FDetails.Add('Bit 5 = 1: Cell has top black border');
      if b and $40 = 0
        then FDetails.Add('Bit 6 = 0: Cell has NO bottom border')
        else FDetails.Add('Bit 6 = 1: Cell has bottom black border');
      if b and $80 = 0
        then FDetails.Add('Bit 7 = 0: Cell has NO shaded background')
        else FDetails.Add('Bit 7 = 1: Cell has shaded background');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.2x)', [b,b]),
      'Cell style');
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrROw, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
      'Index of XF record');
  end;

  // Offset 6: Result of formula
  numBytes := 8;
  Move(FBuffer[FBufferIndex], q, numBytes);
  if wordarr[3] <> $FFFF then begin
    if FCurrRow = Row then begin
      FDetails.Add('Formula result:'#13);
      FDetails.Add(Format('Bytes 0-7: $%.15x --> IEEE 764 floating-point value, 64-bit double precision'#13+
                          '           = %g', [q, dbl]));
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, FloatToStr(dbl),
      'Result of formula (IEEE 764 floating-point value, 64-bit double precision)');
  end else begin
    case bytearr[0] of
      0: begin     // String result
           if FCurrRow = Row then begin
             FDetails.Add('Formula result:'#13);
             FDetails.Add('Byte 0 = 0  --> Result is string, follows in STRING record');
             FDetails.Add('Byte 1-5: Not used');
             FDetails.Add('Byte 6&7: $FFFF --> no floating point number');
           end;
           ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.16x', [q]),
             'Result is a string, follows in STRING record');
         end;
      1: begin     // BOOL result
           if FCurrRow = Row then begin
             FDetails.Add('Formula result:'#13);
             FDetails.Add('Byte 0 = 1 --> Result is BOOLEAN');
             FDetails.Add('Byte 1: Not used');
             if bytearr[2] = 0
               then FDetails.Add('Byte 2 = 0 --> FALSE')
               else FDetails.Add('Byte 2 = 1 --> TRUE');
             FDetails.Add('Bytes 3-5: Not used');
             FDetails.Add('Bytes 6&7: $FFFF --> no floating point number');
           end;
           ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.16x', [q]),
             'Result is BOOLEAN');
         end;
      2: begin        // ERROR result
           if FCurrRow = Row then begin
             FDetails.Add('Formula result:'#13);
             FDetails.Add('Byte 0 = 2 --> Result is an ERROR value');
             FDetails.Add('Byte 1: Not used');
             case bytearr[2] of
               $00: FDetails.Add('Byte 2 = $00 --> #NULL! Intersection of two cell ranges is empty');
               $07: FDetails.Add('Byte 2 = $07 --> #DIV/0! Division by zero');
               $0F: FDetails.Add('Byte 2 = $0F --> #VALUE! Wrong type of operand');
               $17: FDetails.Add('Byte 2 = $17 --> #REF! Illegal or deleted cell reference');
               $1D: FDetails.Add('Byte 2 = $1D --> #NAME? Wrong function or range name');
               $24: FDetails.Add('Byte 2 = $24 --> #NUM! Value range overflow');
               $2A: FDetails.Add('Byte 2 = $2A --> #N/A Argument or function not available');
             end;
             FDetails.Add('Bytes 6&7: $FFFF --> no floating point number');
           end;
           ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.16x', [q]),
             'Result is an ERROR value');
         end;
      3: begin       // EMPTY cell
           if FCurrRow = Row then begin
             FDetails.Add('Formula result:'#13);
             FDetails.Add('Byte 0 = 3 --> Result is an empty cell, for example an empty string');
             FDetails.Add('Byte 1-5: Not used');
             FDetails.Add('Bytes 6&7: $FFFF --> no floating point number');
           end;
           ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.16x', [q]),
             'Result is an EMPTY cell (empty string)');
         end;
    end;
  end;

  // Option flags
  if FFormat = sfExcel2 then begin
    numBytes := 1;
    b := FBuffer[FBufferIndex];
    if Row = FCurrRow then begin
      FDetails.Add('Option flags:'#13);
      case b of
        0: FDetails.Add('0 = Do not recalculate');
        1: FDetails.Add('1 = Recalculate always');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b), 'Option flags');
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      FDetails.Add('Option flags:'#13);
      if w and $0001 = 0
        then FDetails.Add('Bit $0001 = 0: Do not recalculate')
        else FDetails.Add('Bit $0001 = 1: Recalculate always');
      FDetails.Add('Bit $0002: Reserved - MUST be zero, MUST be ignored');
      if w and $0004 = 0
        then FDetails.Add('Bit $0004 = 0: Cell does NOT have a fill alignment or a center-across-selection alignment.')
        else FDetails.Add('Bit $0004 = 1: Cell has either a fill alignment or a center-across-selection alignment.');
      if w and $0008 = 0
        then FDetails.Add('Bit $0008 = 0: Formula is NOT part of a shared formula')
        else FDetails.Add('Bit $0008 = 1: Formula is part of a shared formula');
      FDetails.Add('Bit $0010: Reserved - MUST be zero, MUST be ignored');
      if w and $0020 = 0
        then FDetails.Add('Bit $0020 = 0: Formula is NOT excluded from formula error checking')
        else FDetails.Add('Bit $0020 = 1: Formula is excluded from formula error checking');
      FDetails.Add('Bits $FC00: Reserved - MUST be zero, MUST be ignored');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]),
      'Option flags');
  end;

  // Not used
  if (FFormat >= sfExcel5) then begin
    numBytes := 4;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, '', '(not used');
  end;

  // Size of Token array (in Bytes)
  if FFormat = sfExcel2 then begin
    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    tokenBytes := b;
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    tokenBytes := WordLEToN(w);
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(tokenBytes),
    'Size of formula data (in Bytes)');

  ShowFormulaTokens(tokenBytes);

  RowCount := FCurrRow;
  EndUpdate(true);
end;


procedure TBIFFGrid.ShowFormulaTokens(ATokenBytes: Integer);
var
  numBytes: Integer;
  b: Byte;
  w: Word;
  s: String;
  dbl: Double;
  firstTokenBufIndex: Integer;
  token: Byte;
  r, c: Word;
begin
  // Tokens and parameters
  firstTokenBufIndex := FBufferIndex;
  while FBufferIndex < firstTokenBufIndex + ATokenBytes do begin
    token := FBuffer[FBufferIndex];
    numBytes := 1;
    case token of
      $01: begin
             ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.2x', [token]),
               'Token for "Cell is part of shared formula"');
             numbytes := 2;
             Move(FBuffer[FBufferIndex], w, numBytes);
             ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
               'Index to row of first FORMULA record in the formula range');
             if FFormat = sfExcel2 then begin
               numbytes := 1;
               b := FBuffer[FBufferIndex];
               ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
                 'Index to column of first FORMULA record in the formula range');
             end else begin
               numbytes := 2;
               Move(FBuffer[FBufferIndex], w, numbytes);
               ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
                 'Index to column of first FORMULA record in the formula range');
             end;
           end;
      $02: begin
             ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.2x', [token]),
               'Token for "Cell is part of a multiple operations table"');
             numbytes := 2;
             Move(FBuffer[FBufferIndex], w, numBytes);
             ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
               'Index to first row of the table range');
             if FFormat = sfExcel2 then begin
               numbytes := 1;
               b := FBuffer[FBufferIndex];
               ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
                 'Index to first column of the table range');
             end else begin
               numbytes := 2;
               Move(FBuffer[FBufferIndex], w, numbytes);
               ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
                 'Index to first column of the table range');
             end;
           end;
      $03: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "+" (add)');
      $04: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "-" (subtract)');
      $05: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "*" (multiply)');
      $06: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "/" (divide)');
      $07: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "^" (power)');
      $08: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "&" (concat)');
      $09: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "<" (less than)');
      $0A: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "<=" (less equal)');
      $0B: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "=" (equal)');
      $0C: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token ">=" (greater equal)');
      $0D: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token ">" (greater than)');
      $0E: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "<>" (not equal)');
      $0F: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token " " (intersect)');
      $10: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "list character"');
      $11: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token ":" (range)');
      $12: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "+" (unary plus)');
      $13: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "-" (unary minus)');
      $14: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "%" (percent)');
      $15: ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.2x', [token]),
             'Token "()" (operator in parenthesis)');
      $16: ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
             'Token "missing argument"');
      $17: begin
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               'Token tSTR (Label)');
             ExtractString(FBufferIndex, 1, (FFormat = sfExcel8), s, numBytes);
             ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'String value');
           end;
      $1C: begin
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               'Token tERR (Error)');
             numBytes := 1;
             b := FBuffer[FBufferIndex];
             if FCurrRow = Row then begin
               FDetails.Add('Error code:'#13);
               FDetails.Add(Format('Code $%.2x --> "%s"', [b, GetErrorValueStr(TsErrorValue(b))]));
             end;
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]), 'Error code');
           end;
      $1D: begin
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               'Token tBOOL');
             numBytes := 1;
             b := FBuffer[FBufferIndex];
             ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
               '0=FALSE, 1=TRUE');
           end;
      $1E: begin
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               'Token tINT (Integer)');
             numBytes := 2;
             Move(FBuffer[FBufferIndex], w, numBytes);
             ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
               'Integer value');
           end;
      $1F: begin
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               'Token tNUM (Number)');
             numBytes := 8;
             Move(FBuffer[FBufferIndex], dbl, numBytes);
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%g', [dbl]), //FloatToStr(dbl),
               'IEEE 754 floating-point value');
           end;
      $20, $40, $60:
           begin
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               'Token tARRAY');
             if FFormat = sfExcel2 then numBytes := 6 else numBytes := 7;
             ShowInRow(FCurrRow, FBufferIndex, numbytes, '', '(not used)');
           end;
      $21, $41, $61:
           begin
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               'Token tFUNC (Function with fixed argument count)');
             if FFormat = sfExcel2 then begin
               numBytes := 1;
               b := FBuffer[FBufferIndex];
               s := Format('Index of function (%s)', [SheetFuncName(b)]);
               ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b), s);
             end else begin
               numBytes := 2;
               Move(FBuffer[FBufferIndex], w, numBytes);
               w := WordLEToN(w);
               s := Format('Index of function (%s)', [SheetFuncName(w)]);
               ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), s);
             end;
           end;
      $22, $42, $62:
           begin
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               'Token tFUNCVAR (Function with variable argument count)');
             numBytes := 1;
             b := FBuffer[FBufferIndex];
             ShowInRow(FCurrRow, FBufferIndex, numBytes,  IntToStr(b),
               'Number of arguments');
             if FFormat = sfExcel2 then begin
               numBytes := 1;
               s := Format('Index of built-in function (%s)', [SheetFuncName(b)]);
               ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b), s);
             end else begin
               numBytes := 2;
               Move(FBuffer[FBufferIndex], w, numbytes);
               w := WordLEToN(w);
               s := Format('Index of built-in function (%s)', [SheetFuncName(w)]);
               ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), s);
             end;
           end;
      $23, $43, $63:
           begin
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               'Token tNAME');
             numBytes := 2;
             Move(FBuffer[FBufferIndex], w, numBytes);
             case FFormat of
               sfExcel2: s := 'DEFINEDNAME or EXTERNALNAME record';
               sfExcel5: s := 'DEFINEDNAME record in Global Link Table';
               sfExcel8: s := 'DEFINEDNAME record in Link Table';
             end;
             ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
               '1-based index to '+s);
             case FFormat of
               sfExcel2: numBytes := 5;
               sfExcel5: numBytes := 12;
               sfExcel8: numBytes := 2;
             end;
             ShowInRow(FCurrRow, FBufferIndex, numBytes, '', '(not used)');
           end;
      $24, $44, $64:
           begin
             case token of
               $24: s := 'reference';
               $44: s := 'value';
               $64: s := 'array';
             end;
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               Format('Token tREF (Cell %s)', [s]));
             ShowCellAddress;
           end;
      $25, $45, $65:
           begin
             case token of
               $25: s := 'reference';
               $45: s := 'value';
               $65: s := 'array';
             end;
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
               Format('Token tAREA (Cell range %s)', [s]));
             ShowCellAddressRange(FFormat);
           end;
      $2C, $4C, $6C:
          begin
            case token of
              $2C: s := 'reference';
              $4C: s := 'value';
              $6C: s := 'array';
            end;
            ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
              Format('Token tREFN (Relative reference to cell %s in same sheet)', [s]));

            // Encoded relative cell address
            if FFormat = sfExcel8 then
            begin
              numBytes := 2;
              Move(FBuffer[FBufferIndex], w, numBytes);    // row
              r := WordLEToN(w);
              Move(FBuffer[FBufferIndex+2], w, numBytes);  // column with flags
              c := WordLEToN(w);

              { Note: The bitmask assignment to relative column/row is reversed in relation
                to OpenOffice documentation in order to match with Excel files. }
              if Row = FCurrRow then begin
                FDetails.Add('Encoded cell address (row):'#13);
                if c and $8000 = 0 then
                begin
                  FDetails.Add('Row index is ABSOLUTE (see Encoded column index)');
                  FDetails.Add('Absolute row index: ' + IntToStr(r));
                end else
                begin
                  FDetails.Add('Row index is RELATIVE (see Encoded column index)');
                  FDetails.Add('Relative row index: ' + IntToStr(Smallint(r)));
                end;
              end;
              ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [r, r]),
                'Encoded row index');

              // Bit mask $4000 --> column
              // Bit mask $8000 --> row
              if Row = FCurrRow then
              begin
                FDetails.Add('Encoded cell address (column):'#13);
                if c and $4000 = 0
                  then FDetails.Add('Bit 14=0: Column index is ABSOLUTE')
                  else FDetails.Add('Bit 14=1: Column index is RELATIVE');
                if c and $8000 = 0
                  then FDetails.Add('Bit 15=0: Row index is ABSOLUTE')
                  else FDetails.Add('Bit 15=1: Row index is RELATIVE');
                FDetails.Add('');
                if c and $4000 = 0
                  then FDetails.Add('Absolute column index: ' + IntToStr(Lo(c)))
                  else FDetails.Add('Relative column index: ' + IntToStr(ShortInt(Lo(c))));
              end;

              ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [c, c]),
                'Encoded column index');
            end
            else
            // Excel5 (Excel2 does not support shared formulas)
            begin
              numBytes := 2;
              Move(FBuffer[FBufferIndex], w, numBytes);
              w := WordLEToN(w);
              r := w and $3FFF;
              b := FBuffer[FBufferIndex+2];
              c := b;

              // Bit mask $4000 --> column
              // Bit mask $8000 --> row
              if Row = FCurrRow then begin
                FDetails.Add('Encoded cell address (row):'#13);
                if w and $4000 = 0
                  then FDetails.Add('Bit 14=0: Column index is ABSOLUTE')
                  else FDetails.Add('Bit 14=0: Column index is RELATIVE');
                if w and $8000 = 0
                  then FDetails.Add('Bit 15=0: Row index is ABSOLUTE')
                  else FDetails.Add('Bit 15=1: Row index is RELATIVE');
                FDetails.Add('');
                if w and $8000 = 0
                  then FDetails.Add('Absolute row index: ' + IntToStr(r))
                  else FDetails.Add('Relative row index: ' + IntToStr(Smallint(r)));
              end;
              ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
                'Encoded row index');

              if Row = FCurrRow then
              begin
                FDetails.Add('Encoded cell address (column):'#13);
                if w and $4000 = 0 then begin
                  FDetails.Add('Column index is ABSOLUTE (see Encoded row index)');
                  FDetails.Add('Absolute column index: ' + IntToStr(c));
                end else begin
                  FDetails.Add('Column index is RELATIVE (see Encoded row index)');
                  FDetails.Add('Relative column index: ' + IntToStr(ShortInt(c)));
                end;
              end;
              numBytes := 1;
              ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b, b]),
                'Encoded column index');
            end;
          end;

    else
          ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [token]),
            '(unknown token)');

    end;  // case
  end;  // while

end;

procedure TBIFFGrid.ShowGCW;
var
  numBytes: Integer;
  b: Byte;
  w: Word;
  i,j: Integer;
  bit: Byte;
begin
  RowCount := FixedRows + 33;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Size of Global Column Width bit field (1 bit per column), must be 32');

  numBytes := 1;
  for i:= 0 to w-1 do begin
    b := FBuffer[FBufferIndex];
    if FCurrRow = Row then begin
      FDetails.Add(Format('GCW (Global column width) record, byte #%d:'#13, [i]));
      bit := 1;
      for j:=0 to 7 do begin
        if b and bit = 0
          then FDetails.Add(Format('Bit $%.2x=0: Column %d uses width of COLWIDTH record.', [bit, j+i*8]))
          else FDetails.Add(Format('Bit $%.2x=1: Column %d uses width of STANDARDWIDTH record '+
                                   '(or, if not available, DEFCOLWIDTH record)', [bit, j+i*8]));
        bit := bit * 2;
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]),
      Format('Widths of columns %d-%d', [i*8, i*8+7]));
  end;
end;


procedure TBIFFGrid.ShowHeader;
var
  numbytes: Integer;
  s: String;
begin
  RowCount := FixedRows + 1;
  ExtractString(FBufferIndex, IfThen(FFormat=sfExcel8, 2, 1), FFormat=sfExcel8,
    s, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
    'Page header string' + IfThen(FFormat = sfExcel8,
    ' (Unicode string, 16-bit string length)',
    ' (byte string, 8-bit string length)'
  ));
end;


procedure TBIFFGrid.ShowHideObj;
var
  numBytes: word;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Viewing mode for objects:'#13);
    case w of
      0: FDetails.Add('0 = Show all objects');
      1: FDetails.Add('1 = Show placeholders');
      2: FDetails.Add('2 = Do not show objects');
    end;
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Viewing mode for objects');
end;


procedure TBIFFGrid.ShowHyperlink;
var
  numbytes: Word;
  w: Word;
  dw: DWord;
  n: Integer;
  guid: TGUID;
  flags: DWord;
  nchar, size: DWord;
  widestr: WideString;
  ansistr: ansistring;
  s: String;
begin
  n := 0;
  RowCount := FixedRows + 1000;

  ShowCellAddressRange(FFormat);
  inc(n, 4);

  numbytes := 16;
  Move(FBuffer[FBufferIndex], guid, numbytes);
  s := GuidToString(guid);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, GuidToString(guid), 'GUID of standard link');
  inc(n);

  numbytes := 4;
  Move(FBuffer[FBufferIndex], dw, numbytes);
  dw := DWordToLE(dw);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x (%d)', [dw, dw]), 'Unknown');
  inc(n);

  numbytes := 4;
  Move(FBuffer[FBufferIndex], dw, numbytes);
  flags := DWordToLE(dw);
  if FCurrRow = row then begin
    FDetails.Add('Option flags:'#13);
    if flags and $0001 = 0
      then FDetails.Add('  Bit  $0001=0: No link')
      else FDetails.ADd('* Bit  $0001=1: File link or URL');
    if flags and $0002 = 0
      then FDetails.Add('  Bit  $0002=0: Relative path')
      else FDetails.Add('* Bit  $0002=1: Absolute path');
    if flags and $0014 = 0
      then FDetails.Add('  Bits $0014=0: No desriptions')
      else FDetails.Add('* Bits $0014=1: Description (both bits)');
    if flags and $0008 = 0
      then FDetails.Add('  Bit  $0008=0: No text mark')
      else FDetails.Add('* Bit  $0008=1: Text mark');
    if flags and $0080 = 0
      then FDetails.Add('  Bit  $0080=0: No target frame')
      else FDetails.Add('* Bit  $0080=1: Target frame');
    if flags and $0100 = 0
      then FDetails.Add('  Bit  $0100=0: File link or URL')
      else FDetails.Add('* Bit  $0100=1: UNC path (incl server name)');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x (%d)', [flags, flags]),
    'Option flags');
  inc(n);

  if flags and $0014 = $0014 then  // hyperlink has description
  begin
    numBytes := 4;
    Move(FBuffer[FBufferIndex], dw, numbytes);
    nchar := DWordToLE(dw);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(nchar),
      'Character count of description text, incl trailing zero word');
    inc(n);

    numbytes := 2*nchar;
    SetLength(widestr, nchar);
    Move(FBuffer[FBufferIndex], widestr[1], 2*nchar);
    s := UTF16ToUTF8(widestr);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
      'Character array of description text (no unicode string header, always 16-bit characters, zero-terminated)');
    inc(n);
  end;

  if flags and $0080 <> 0 then  // Hyperlink has target frame
  begin
    numBytes := 4;
    Move(FBuffer[FBufferIndex], dw, numbytes);
    nchar := DWordToLE(dw);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(nchar),
      'Character count of target frame, incl trailing zero word');
    inc(n);

    numbytes := 2*nchar;
    SetLength(widestr, nchar);
    Move(FBuffer[FBufferIndex], widestr[1], 2*nchar);
    s := UTF16ToUTF8(widestr);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
      'Character array of target frame (no unicode string header, always 16-bit characters, zero-terminated)');
    inc(n);
  end;

  if flags and $0011 <> 0 then // hyperlink contains URL ***OR*** a local file
  begin
    numbytes := 16;
    Move(FBuffer[FBufferIndex], guid, numbytes);
    s := GuidToString(guid);
    if s = '{79EAC9E0-BAF9-11CE-8C82-00AA004BA90B}' then    // case: URL
    begin
      ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
        'GUID of URL Moniker');
      inc(n);

      numBytes := 4;
      Move(FBuffer[FBufferIndex], dw, numbytes);
      size := DWordToLE(dw);
      nchar := size div 2 - 1;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(size),
        'Size of URL character array, incl. trailing zero word');
      inc(n);

      numbytes := 2*nchar;
      SetLength(widestr, nchar);
      Move(FBuffer[FBufferIndex], widestr[1], 2*nchar);
      s := UTF16ToUTF8(widestr);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
        'Character array of the URL (no unicode string header, always 16-bit characters, zero-terminated');
      inc(n);
    end else
    if s = '{00000303-0000-0000-C000-000000000046}' then   // case: local file
    begin
      ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
        'GUID of File Moniker');
      inc(n);

      numbytes := 2;
      Move(FBuffer[FBufferIndex], w, numbytes);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
        'Directory up-level count. Each leading "..\" in the file link is deleted and increases this counter.');
      inc(n);

      numBytes := 4;
      Move(FBuffer[FBufferIndex], dw, numbytes);
      nchar := DWordToLE(dw);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(nchar),
        'Character count of the shortened file path and name, incl trailing zero byte.');
      inc(n);

      numbytes := nchar;
      SetLength(ansistr, nchar);
      Move(FBuffer[FBufferIndex], ansistr[1], nchar);
      s := AnsiToUTF8(ansistr);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
        'Character array of the shortened file path and name (no unicode string header, always 8-bit characters, zero-terminated)');
      inc(n);

      for w := 1 to 6 do begin
        numbytes := 4;
        Move(FBuffer[FBufferIndex], dw, numbytes);
        ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x', [DWordToLE(dw)]),
          'Unknown');
        inc(n);
      end;

      numBytes := 4;
      Move(FBuffer[FBufferIndex], dw, numbytes);
      size := DWordToLE(dw);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(size),
        'Size of following file link field incl string length field and additional data field');
      inc(n);

      if size > 0 then begin
        numBytes := 4;
        Move(FBuffer[FBufferIndex], dw, numbytes);
        size := DWordToLE(dw);
        nchar := size div 2;
        ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(size),
          'Size of extended file path and name character array');
        inc(n);

        numBytes := 2;
        Move(FBuffer[FBufferIndex], w, numbytes);
        ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordToLE(w)),
          'Unknown');
        inc(n);

        numBytes := size;
        SetLength(widestr, nchar);
        Move(FBuffer[FBufferIndex], widestr[1], numbytes);
        s := UTF16ToUTF8(widestr);
        ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
          'Character array of extended file path and array (No unicode string header, always 16-bit characters, NOT zero-terminated)');
        inc(n);
      end;
    end;
  end  // if flags and $0011 <> 0
  else begin
    // case: Hyperlink to current workbook
  end;

  if flags and $0008 <> 0 then   // hyperlink contains text mark field
  begin
    numBytes := 4;

    Move(FBuffer[FBufferIndex], dw, numbytes);
    nchar := DWordToLE(dw);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(nchar),
      'Character count of the text mark, incl trailing zero word');
    inc(n);

    numbytes := 2*nchar;
    SetLength(widestr, nchar);
    Move(FBuffer[FBufferIndex], widestr[1], 2*nchar);
    s := UTF16ToUTF8(widestr);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
      'Character array of the text mark, without "#" sign, no unicode string header, always 16-bit characters, zero-terminated)');
    inc(n);
  end;

  RowCount := FixedRows + n;
end;


procedure TBIFFGrid.ShowHyperlinkTooltip;
var
  numbytes: Word;
  w: Word;
  widestr: widestring;
  s: string;
begin
  RowCount := FixedRows + 6;

  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordToLE(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x (%d)', [w, w]),
    'Repeated record ID');

  ShowCellAddressRange(sfExcel8);

  numbytes := Length(FBuffer) - FBufferIndex;
  SetLength(widestr, numbytes div 2);
  Move(FBuffer[FBufferIndex], widestr[1], numbytes);
  s := UTF16toUTF8(widestr);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
    'Character array of the tool tip, no Unicode string header, always 16-bit characters, zero-terminated');
end;


procedure TBIFFGrid.ShowInRow(var ARow: Integer; var AOffs: LongWord;
  ASize: Word; AValue,ADescr: String; ADescrOnly: Boolean = false);
begin
  if ADescrOnly then
  begin
    Cells[0, ARow] := '';
    Cells[1, ARow] := '';
    Cells[2, ARow] := '';
  end else
  begin
    Cells[0, ARow] := IntToStr(AOffs);
    Cells[1, ARow] := IntToStr(ASize);
    Cells[2, ARow] := AValue;
  end;
  Cells[3, ARow] := ADescr;
  inc(ARow);
  inc(AOffs, ASize);
end;


procedure TBIFFGrid.ShowInteger;
var
  numBytes: Integer;
  w: Word;
  b: Byte;
begin
  // BIFF2 only
  if (FFormat <> sfExcel2) then
    exit;

  RowCount := FixedRows + 5;
  ShowRowColData(FBufferIndex);

  numBytes := 1;
  b := FBuffer[FBufferIndex];
  if Row = FCurrRow then begin
    FDetails.Add('Cell protection and XF index:'#13);
    FDetails.Add(Format('x Bits 5-0 = %d: XF Index', [b and $3F]));
    case b and $40 of
      0: FDetails.Add('  Bit 6 = 0: Cell is NOT locked.');
      1: FDetails.Add('x Bit 6 = 1: Cell is locked.');
    end;
    case b and $80 of
      0: FDetails.Add('  Bit 7 = 0: Formula is NOT hidden.');
      1: FDetails.Add('x Bit 7 = 1: Formula is hidden.');
    end;
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
    'Cell protection and XF index');

  b := FBuffer[FBufferIndex];
  if Row = FCurrRow then begin
    FDetails.Add('Indexes to format and font records:'#13);
    FDetails.Add(Format('Bits 5-0 = %d: Index to FORMAT record', [b and $3f]));
    FDetails.Add(Format('Bits 7-6 = %d: Index to FONT record', [(b and $C0) shr 6]));
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
    'Indexes of format and font records');

  b := FBuffer[FBufferIndex];
  if Row = FCurrRow then begin
    FDetails.Add('Cell style:'#13);
    case b and $07 of
      0: FDetails.Add('x Bits 2-0 = 0: Horizontal alignment is GENERAL');
      1: FDetails.Add('x Bits 2-0 = 1: Horizontal alignment is LEFT');
      2: FDetails.Add('x Bits 2-0 = 2: Horizontal alignment is CENTERED');
      3: FDetails.Add('x Bits 2-0 = 3: Horizontal alignment is RIGHT');
      4: FDetails.Add('x Bits 2-0 = 4: Horizontal alignment is FILLED');
    end;
    if b and $08 = 0
      then FDetails.Add('  Bit 3 = 0: Cell has NO left border')
      else FDetails.Add('x Bit 3 = 1: Cell has left black border');
    if b and $10 = 0
      then FDetails.Add('  Bit 4 = 0: Cell has NO right border')
      else FDetails.Add('x Bit 4 = 1: Cell has right black border');
    if b and $20 = 0
      then FDetails.Add('  Bit 5 = 0: Cell has NO top border')
      else FDetails.Add('x Bit 5 = 1: Cell has top black border');
    if b and $40 = 0
      then FDetails.Add('  Bit 6 = 0: Cell has NO bottom border')
      else FDetails.Add('x Bit 6 = 1: Cell has bottom black border');
    if b and $80 = 0
      then FDetails.Add('  Bit 7 = 0: Cell has NO shaded background')
      else FDetails.Add('x Bit 7 = 1: Cell has shaded background');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.2x)', [b,b]),
    'Cell style');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Unsigned 16-bit integer cell value');
end;


procedure TBIFFGrid.ShowInterfaceEnd;
begin
  RowCount := FixedRows + 1;
  ShowInRow(FCurrRow, FBufferIndex, 0, '', 'End of Globals Substream');
end;


procedure TBIFFGrid.ShowInterfaceHdr;
var
  numbytes: Integer;
  w: Word;
begin
  if FFormat < sfExcel8 then begin
    RowCount := FixedRows;
    exit;
  end;

  RowCount := FixedRows + 1;
  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Code page of user interface:'#13);
    FDetails.Add(Format('$%.4x = %s', [w, CodePageName(w)]));
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.4x)', [w, w]),
    'Begin of Globals Substream, code page of user interface');
end;


procedure TBIFFGrid.ShowIteration;
var
  numBytes: Integer;
  w: word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Iterations:'#13);
    case w of
      0: FDetails.Add('0 = Iterations off');
      1: FDetails.Add('1 = Iterations on');
    end;
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Iterations on/off');
end;


procedure TBIFFGrid.ShowIXFE;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to XF record');
end;

// Called for LABEL
procedure TBIFFGrid.ShowLabelCell;
var
  numBytes: Integer;
  b: Byte;
  w: Word;
  s: String;
begin
  RowCount := IfThen(FFormat = sfExcel2, FixedRows + 6, FixedRows + 4);
  ShowRowColData(FBufferIndex);
  if (FFormat = sfExcel2) then begin
    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Cell protection and XF index:'#13);
      FDetails.Add(Format('x Bits 5-0 = %d: XF Index', [b and $3F]));
      case b and $40 of
        0: FDetails.Add('  Bit 6 = 0: Cell is NOT locked.');
        1: FDetails.Add('x Bit 6 = 1: Cell is locked.');
      end;
      case b and $80 of
        0: FDetails.Add('  Bit 7 = 0: Formula is NOT hidden.');
        1: FDetails.Add('x Bit 7 = 1: Formula is hidden.');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
      'Cell protection and XF index');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Indexes to format and font records:'#13);
      FDetails.Add(Format('Bits 5-0 = %d: Index to FORMAT record', [b and $3f]));
      FDetails.Add(Format('Bits 7-6 = %d: Index to FONT record', [(b and $C0) shr 6]));
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
      'Indexes of format and font records');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Cell style:'#13);
      case b and $07 of
        0: FDetails.Add('Bits 2-0 = 0: Horizontal alignment is GENERAL');
        1: FDetails.Add('Bits 2-0 = 1: Horizontal alignment is LEFT');
        2: FDetails.Add('Bits 2-0 = 2: Horizontal alignment is CENTERED');
        3: FDetails.Add('Bits 2-0 = 3: Horizontal alignment is RIGHT');
        4: FDetails.Add('Bits 2-0 = 4: Horizontal alignment is FILLED');
      end;
      if b and $08 = 0
        then FDetails.Add('Bit 3 = 0: Cell has NO left border')
        else FDetails.Add('Bit 3 = 1: Cell has left black border');
      if b and $10 = 0
        then FDetails.Add('Bit 4 = 0: Cell has NO right border')
        else FDetails.Add('Bit 4 = 1: Cell has right black border');
      if b and $20 = 0
        then FDetails.Add('Bit 5 = 0: Cell has NO top border')
        else FDetails.Add('Bit 5 = 1: Cell has top black border');
      if b and $40 = 0
        then FDetails.Add('Bit 6 = 0: Cell has NO bottom border')
        else FDetails.Add('Bit 6 = 1: Cell has bottom black border');
      if b and $80 = 0
        then FDetails.Add('Bit 7 = 0: Cell has NO shaded background')
        else FDetails.Add('Bit 7 = 1: Cell has shaded background');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.2x)', [b,b]),
      'Cell style');
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
      'Index of XF record');
  end;

  b := IfThen(FFormat=sfExcel2, 1, 2);
  ExtractString(FBufferIndex, b, (FFormat = sfExcel8), s, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, s,
    Format('%s string, %d-bit string length', [GetStringType, b*8]));
end;


procedure TBIFFGrid.ShowLabelSSTCell;
var
  numBytes: Integer;
  w: Word;
  dw: DWord;
begin
  RowCount := FixedRows + 4;
  ShowRowColData(FBufferIndex);

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
    'Index of XF record');

  numBytes := 4;
  Move(FBuffer[FBufferIndex], dw, numBytes);
  dw := DWordLEToN(dw);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(dw),
    'Index into SST record (shared string table)');
end;


procedure TBIFFGrid.ShowLeftMargin;
var
  numBytes: Integer;
  dbl: Double;
begin
  RowCount := FixedRows + 1;
  numBytes := 8;
  Move(FBuffer[FBufferIndex], dbl, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, FloatToStr(dbl),
    'Left page margin in inches (IEEE 754 floating-point value, 64-bit double precision)');
end;


procedure TBIFFGrid.ShowMergedCells;
var
  w: Word;
  numBytes: Integer;
  i, n: Integer;
begin
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  n := WordLEToN(w);  // count of merged ranges in this record

  RowCount := FixedRows + 1 + n*4;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(n),
    'Count of merged ranges in this record');

  for i:=1 to n do begin
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
      Format('Merged range #%d: First row = %d', [i, w]));
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
      Format('Merged range #%d: Last row = %d', [i, w]));
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
      Format('Merged range #%d: First column = %d', [i, w]));
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
      Format('Merged range #%d: Last column = %d', [i, w]));
  end;
end;


procedure TBIFFGrid.ShowMMS;
var
  w: Word;
  numbytes: Integer;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w), 'Reserved, MUST be ignored');
end;

{ Only those records needed for comments are deciphered. }
procedure TBIFFGrid.ShowMSODrawing;
var
  n: Integer;
  numBytes: Integer;
  w: Word;
  dw: DWord;
  recType: Word;
  recLen: DWord;
  isContainer: Boolean;
  indent: String;
  level: Integer;

  function PrepareIndent(ALevel: Integer): String;
  var
    i: Integer;
  begin
    Result := '';
    for i := 1 to ALevel do Result := Result + '        ';
  end;

  procedure DoShowHeader(out ARecType: Word; out ARecLen: DWord;
    out IsContainer: Boolean);
  var
    s: String;
    instance: Word;
    version: Word;
  begin
    numbytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    w := WordLEToN(w);
    IsContainer := (w and $000F = $000F);

    if IsContainer and (FBufferIndex > 0) then
      indent := PrepareIndent(level+1);

    s := IfThen(IsContainer, '***** CONTAINER *****', '--- ATOM ---');
    ShowInRow(FCurrRow, FBufferIndex, 0, '', indent + s, TRUE);
    inc(n);

    version := w and $000F;
    instance := (w and $FFF0) shr 4;
    if Row = FCurrRow then begin
      FDetails.Add('OfficeArtDrawing Header:'#13);
      FDetails.Add(Format('Bits 3-0 = $%.1x: Version', [version]));
      FDetails.Add(Format('Bits 15-4 = $%.3x: Instance', [instance]));
    end;
    s := Format('OfficeArtDrawing Header: Version %d, instance %d', [version, instance]);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.04x', [w]), indent + s);
    inc(n);

    Move(FBuffer[FBufferIndex], w, numbytes);
    w := WordLEToN(w);
    ARecType := w;
    case ARecType of
      $F00A: //, $F00B:
         case instance of
           $01: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Rectangle)';
           $02: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Rounded rectangle)';
           $03: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Ellipse)';
           $04: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Diamond)';
           $05: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Triangle)';
           $06: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Right triangle)';
           $07: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Parallelogram)';
           $08: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Trapezoid)';
           $09: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Hexagon)';
           $0A: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Pentagon)';
           $0B: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Plus)';
           $0C: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Star)';
           $0D: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Arrow)';
           $0E: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Thick arrow)';
           $0F: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Irregular pentagon)';
           $10: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Cube)';
           $11: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Speech balloon)';
           $12: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Seal)';
           $13: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Curved arc)';
           $14: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Line)';
           $15: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Plaque)';
           $16: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Cylinder)';
           $17: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Donut)';
           $CA: Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + ' (Text box)';
         end;
      $F00B:
        Cells[3, FCurrRow-1] := Cells[3, FCurrRow-1] + Format(' (i.e., %d properties)', [instance]);
    end;

    case ARecType of
      $F000: s := 'OfficeArtDggContainer (all the OfficeArt file records containing document-wide data)';
      $F001: s := 'OfficeArtBStoreContainer (all the BLIPs used in all the drawings associated with parent OfficeArtDggContainer record)';
      $F002: s := 'OfficeArtDgContainer (all file records for the objects in a drawing)';
      $F003: s := 'OfficeArtSpgrContainer (groups of shapes)';
      $F004: s := 'OfficeArtSpContainer (shape)';
      $F005: s := 'OfficeArtSolverContainer (rules applicable to the shapes contained in an OfficeArtDgContainer record)';
      $F006: s := 'OfficeArtFDGGBlock record (document-wide information about all drawings saved in the file)';
      $F007: s := 'OfficeArtFBSE record (File BLIP Store Entry (FBSE) containing information about the BLIP)';
      $F008: s := 'OfficeArtFDG record (number of shapes, drawing identifier, and shape identifier of the last shape in a drawing)';
      $F009: s := 'OfficeArtFSPGR record (coordinate system of the group shape that the anchors of the child shape are expressed in)';
      $F00A: s := 'OfficeArtFSP record (instance of a shape)';
      $F00B: s := 'OfficeArtFOPT record (table of OfficeArtRGFOPTE records)';
      $F00D: s := 'OfficeArtClientTextBox (text related data for a shape)';
      $F00F: s := 'OfficeArtChildAnchor record (anchors for the shape containing this record)';
      $F010: s := 'OfficeArtClientAnchor record (location of a shape)';
      $F011: s := 'OfficeArtClientData record (information about a shape)';
      $F012: s := 'OfficeArtFConnectorRule record (connection between two shapes by a connector shape)';
      $F014: s := 'OfficeArtFArcRule record (Specifies an arc rule. Each arc shape MUST correspond to a unique arc rule)';
      $F017: s := 'OfficeArtFCalloutRule record (Callout rule: One callout rule MUST exist per callout shape)';
      $F01A: s := 'OfficeArtBlipEMF record (BLIP file data for the enhanced metafile format (EMF))';
      $F01B: s := 'OfficeArtBlipWMF record (BLIP file data for the Windows Metafile Format (WMF))';
      $F01C: s := 'OfficeArtBlipPICT record (BLIP file data for the Macintosh PICT format)';
      $F01D: s := 'OfficeArtBlipJPEG record (BLIP file data for the Joint Photographic Experts Group (JPEG) format)';
      $F01E: s := 'OfficeArtBlipPNG record (BLIP file data for the Portable Network Graphics (PNG) format)';
      $F01F: s := 'OfficeArtBlipDIB record (BLIP file data for the device-independent bitmap (DIB) format)';
      $F029: s := 'OfficeArtBlipTIFF record (BLIP file data for the TIFF format)';
      $F118: s := 'OfficeArtFRITContainer record (container for the table of group identifiers that are used for regrouping ungrouped shapes)';
      $F119: s := 'OfficeArtFDGSL record (specifies both the selected shapes and the shape that is in focus in the drawing)';
      $F11A: s := 'OfficeArtColorMRUContainer record (most recently used custom colors)';
      $F11D: s := 'OfficeArtFPSPL record (former hierarchical position of the containing object that is either a shape or a group of shapes)';
      $F11E: s := 'OfficeArtSplitMenuColorContainer record (container for the colors that were most recently used to format shapes)';
      $F121: s := 'OfficeArtSecondaryFOPT record (table of OfficeArtRGFOPTE records)';
      $F122: s := 'OfficeArtTertiaryFOPT record (table of OfficeArtRGFOPTE records)';
      else   s := 'Not known to BIFFExplorer';
    end;
    if Row = FCurrRow then begin
      FDetails.Add('OfficeArtDrawing Record Type:'#13);
      FDetails.Add(Format('$%.4x: %s', [ARecType, s]));
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]),
      indent + 'Record type: ' + s);
    inc(n);

    numbytes := 4;
    Move(FBuffer[FbufferIndex], ARecLen, Numbytes);
    ARecLen := DWordLEToN(ARecLen);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d', [ARecLen]),
      indent + 'Record length');
    inc(n);
  end;

  procedure DoShowOfficeArtFDG;   // $F008
  // The OfficeArtFDG record specifies the number of shapes, the drawing
  // identifier, and the shape identifier of the last shape in a drawing.
  begin
    numbytes := 4;
    Move(FBuffer[FBufferIndex], dw, numbytes);
    dw := DWordLEToN(dw);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(dw),
      indent + 'Number of shapes in this drawing');
    inc(n);

    Move(FBuffer[FBufferIndex], dw, numbytes);
    dw := DWordLEToN(dw);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(dw),
      indent + 'Shape identifier of the last shape in this drawing');
    inc(n);
  end;

  procedure DoShowOfficeArtFSPGR;  // $F009
  // The OfficeArtFSPGR record specifies the coordinate system of the group
  // shape that the anchors of the child shape are expressed in. This record
  // is present only for group shapes.
  var
    rt: Word;
  begin
    numbytes := 4;
    Move(FBuffer[FBufferIndex], dw, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(LongInt(DWordLEToN(dw))),
      indent + 'xLeft');
    inc(n);

    Move(FBuffer[FBufferIndex], dw, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(LongInt(DWordLEToN(dw))),
      indent + 'yTop');
    inc(n);

    Move(FBuffer[FBufferIndex], dw, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(LongInt(DWordLEToN(dw))),
      indent + 'xRight');
    inc(n);

    Move(FBuffer[FBufferIndex], dw, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(LongInt(DWordLEToN(dw))),
      indent + 'yBottom');
    inc(n);
  end;

  procedure DoShowOfficeArtFSP;   // §F00A
  // The OfficeArtFSP record specifies an instance of a shape.
  // The record header contains the shape type, and the record itself
  // contains the shape identifier and a set of bits that further define the shape.
  var
    rt: word;
    s: String;
  begin
    numbytes := 4;
    Move(FBuffer[FBufferIndex], dw, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)),
      indent + 'Shape identifier');
    inc(n);

    numbytes := 4;
    Move(FBuffer[FBufferIndex], dw, numbytes);
    dw := DWordLEToN(dw);
    s := '';
    if Row = FCurrRow then begin
      FDetails.Add('Shape options:'#13);
      if dw and $0001 = 0
        then FDetails.Add('  Bit 1=0: Shape is NOT a group shape')
        else FDetails.Add('x Bit 1=1: Shape is a group shape');
      if dw and $0002 = 0
        then FDetails.Add('  Bit 2=0: Shape is NOT a child shape')
        else FDetails.Add('x Bit 2=1: Shape is a child shape');
      if dw and $0004 = 0
        then FDetails.Add('  Bit 3=0: Shape is NOT the top-most group shape (patriarch)')
        else FDetails.Add('x Bit 3=1: Shaoe is the top-most group shape (patriarch)');
      if dw and $0008 = 0
        then FDetails.Add('  Bit 4=0: Shape has NOT been deleted')
        else FDetails.Add('x Bit 4=1: Shape has been deleted');
      if dw and $0010 = 0
        then FDetails.Add('  Bit 5=0: Shape is NOT an OLE object')
        else FDetails.Add('x Bit 5=1: Shape is an OLE object');
      if dw and $0020 = 0
        then FDetails.Add('  Bit 6=0: Shape does NOT have a valid master in the hspMaster property')
        else FDetails.Add('x Bit 6=1: Shape has a valid master in the hspMaster property');
      if dw and $0040 = 0
        then FDetails.Add('  Bit 7=0: Shape is NOT horizontally flipped')
        else FDetails.Add('x Bit 7=1: Shape is horizontally flipped');
      if dw and $0080 = 0
        then FDetails.Add('  Bit 8=0: Shape is NOT vertically flipped')
        else FDetails.Add('x Bit 8=1: Shape is vertically flipped');
      if dw and $0100 = 0
        then FDetails.Add('  Bit 9=0: Shape is NOT a connector shape')
        else FDetails.Add('x Bit 9=1: Shape is a connector shape');
      if dw and $0200 = 0
        then FDetails.Add('  Bit 10=0: Shape doe NOT have an anchor')
        else FDetails.Add('x Bit 10=1: Shape has an anchor');
      if dw and $0400 = 0
        then FDetails.Add('  Bit 11=0: Shape is NOT a background shape')
        else FDetails.Add('x Bit 11=1: Shape is a background shape');
      if dw and $0800 = 0
        then FDetails.Add('  Bit 12=0: Shape does NOT have a shape type property')
        else FDetails.Add('x Bit 12=1: Shape has a shape type property');
      FDetails.Add('  Bits 13-32: unused');
    end;
    s := '';
    if dw and $0001 <> 0 then s := s + 'group shape, ';
    if dw and $0002 <> 0 then s := s + 'child shape, ';
    if dw and $0004 <> 0 then s := s + 'patriarch, ';
    if dw and $0008 <> 0 then s := s + 'deleted, ';
    if dw and $0010 <> 0 then s := s + 'OLE object, ';
    if dw and $0020 <> 0 then s := s + 'master, ';
    if dw and $0040 <> 0 then s := s + 'flipped hor, ';
    if dw and $0080 <> 0 then s := s + 'flipped vert, ';
    if dw and $0100 <> 0 then s := s + 'connector shape, ';
    if dw and $0200 <> 0 then s := s + 'anchor, ';
    if dw and $0400 <> 0 then s := s + 'background, ';
    if dw and $0800 <> 0 then s := s + 'shape type, ';
    if s <> '' then begin
      Delete(s, Length(s)-1, 2);
      s := 'Shape options: ' + s;
    end else
      s := 'Shape options';
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x (%d)', [dw, dw]), indent + s);
    inc(n);
  end;

  procedure DoShowOfficeArtFOPT(ARecLen: DWord);  // $F00B
  // The OfficeArtFOPT record specifies a table of OfficeArtRGFOPTE records.
  var
    startIndex: Int64;
    opid: Word;
    op: DWord;
    s: String;
  begin
    startIndex := FBufferIndex;
    while FBufferIndex < startIndex + ARecLen do
    begin
      numbytes := 2;
      Move(FBuffer[FBufferIndex], opid, numbytes);
      opid := WordLEToN(opid);
      case opid of
        $007F: s := 'OfficeArtFOPTEOPID: Protection boolean properties';
        $0080: s := 'OfficeArtFOPTEOPID: TextID';
        $0081: s := 'OfficeArtFOPTEOPID: dxTextLeft';
        $0082: s := 'OfficeArtFOPTEOPID: dyTextTop';
        $0083: s := 'OfficeArtFOPTEOPID: dxTextRight';
        $0084: s := 'OfficeArtFOPTEOPID: dyTextBottom';
        $0085: s := 'OfficeArtFOPTEOPID: Wrap text';
        $0086: s := 'OfficeArtFOPTEOPID: Unused';
        $0087: s := 'OfficeArtFOPTEOPID: Text anchor';
        $0088: s := 'OfficeArtFOPTEOPID: Text flow';
        $0089: s := 'OfficeArtFOPTEOPID: Font rotation';
        $008A: s := 'OfficeArtFOPTEOPID: Next shape in sequence of linked shapes';
        $008B: s := 'OfficeArtFOPTEOPID: Text direction';
        $008C: s := 'OfficeArtFOPTEOPID: Unused';
        $008D: s := 'OfficeArtFOPTEOPID: Unused';
        $00BF: s := 'OfficeArtFOPTEOPID: Boolean properties for the text in a shape';
        $00C0: s := 'OfficeArtFOPTEOPID: Text for this shape’s geometry text';
        $00C2: s := 'OfficeArtFOPTEOPID: Alignment of text in the shape';
        $00C3: s := 'OfficeArtFOPTEOPID: Font size, in points, of the geometry text for this shape';
        $00C4: s := 'OfficeArtFOPTEOPID: Amount of spacing between characters in the text';
        $00C5: s := 'OfficeArtFOPTEOPID: Font to use for the text';
        $0158: s := 'OfficeArtFOPTEOPID: Type of connection point';
        $0181: s := 'OfficeArtFOPTEOPID: Fill color';
        $0183: s := 'OfficeArtFOPTEOPID: Background color of the fill';
        $0185: s := 'OfficeArtFOPTEOPID: Foreground color of the fill';
        $01BF: s := 'OfficeArtFOPTEOPID: Fill style boolean properties';
        $01C0: s := 'OfficeArtFOPTEOPID: Line color';
        $01C3: s := 'OfficeArtFOPTEOPID: Line foreground color for black & white display mode';
        $01FF: s := 'OfficeArtFOPTEOPID: Line style boolean properties';
        $0201: s := 'OfficeArtFOPTEOPID: Shadow color';
        $0203: s := 'OfficeArtFOPTEOPID: Shadow primary color modifier if in black & white mode';
        $023F: s := 'OfficeArtFOPTEOPID: Shadow style boolean properties';
        $03BF: s := 'OfficeArtFOPTEOPID: Group shape boolean properties';
        else   s := 'OfficeArtFOPTEOPID that specifies the header information for this property';
      end;
      s := indent + s;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x (%d)', [opid, opid]), s);
      inc(n);

      numbytes := 4;
      Move(FBuffer[FBufferIndex], op, numbytes);
      op := DWordLEToN(op);
      s := '';
      case opid of
        $0087: case op of
                 0: s := s + ': text at top';
                 1: s := s + ': text vertically centered';
                 2: s := s + ': text at bottom';
                 3: s := s + ': text at top and centered horizontally';
                 4: s := s + ': text at center of box';
                 5: s := s + ': text at bottom and centered horizontally';
               end;
        $0089: case op of
                 0: s := s + ': horizontal';
                 1: s := s + ': 90° clockwise, vertical down';
                 2: s := s + ': horizontal, 180° rotated';
                 3: s := s + ': 90° counter-clickwise, vertical up';
               end;
        $008B: case op of
                 0: s := s + ': left-to-right';
                 1: s := s + ': right-to-left';
                 2: s := s + ': determined from text string';
               end;
        $00C2: case op of
                 0: s := s + ': stretched';
                 1: s := s + ': centered';
                 2: s := s + ': left-aligned';
                 3: s := s + ': right-aligned';
                 4: s := s + ': justified';
                 5: s := s + ': word-justified';
               end;
        $0158: case op of
                 0: s := s + ': no connection point';
                 1: s := s + ': Edit points of shape are used as connection points';
                 2: s := s + ': Custom array of connection points';
                 3: s := s + ': standard 4 connection points at the top, bottom, left, and right side centers';
               end;
      end;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x (%d)', [op, op]),
        indent + 'Value of this property' + s);
      inc(n);
    end;
  end;

  procedure DoShowOfficeArtClientTextbox(ARecLen: Word);  // $F00D
  begin
    numBytes := ARecLen;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, '...', indent + 'Text data follow in TXO record', true);
    inc(n);
  end;

  procedure DoShowOfficeArtClientAnchorData(StructureKind: Integer); // $F010
  begin
    case StructureKind of
      0: begin   // OfficeArtClientAnchorSheet
           numBytes := 2;
           Move(FBuffer[FBufferIndex], w, numbytes);
           w := WordLEToN(w);
           if Row = FCurrRow then begin
             FDetails.Add('Move/resize flags:'#13);
             if w and $0001 = 0
               then FDetails.Add('  Bit 0=0: Shape will NOT be kept intact when the cells are moved')
               else FDetails.Add('x Bit 0=1: Shape will be kept intact when the cells are moved');
             if w and $0002 = 0
               then FDetails.Add('  Bit 1=0: Shape will NOT be kept intact when the cells are resized')
               else FDetails.Add('x Bit 1=1: Shape will be kept intact when the cells are resized');
             FDetails.Add(       '  Bit 2=0: reserved (must be 0)');
             FDetails.Add(       '  Bit 3=0: reserved (must be 0)');
             FDetails.Add(       '  Bit 4=0: reserved (must be 0)');
             FDetails.Add(       '  Bits 15-5: unused');
           end;
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w), indent + 'Move/resize flags');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'Column of the cell under the top left corner of the bounding rectangle of the shape');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'x coordinate of the top left corner of the bounding rectangle relative to the corner of the underlying cell (as 1/1024 of that cell’s width)');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'Row of the cell under the top left corner of the bounding rectangle of the shape');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'y coordinate of the top left corner of the bounding rectangle relative to the corner of the underlying cell (as 1/256 of that cell’s height');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'Column of the cell under the bottom right corner of the bounding rectangle of the shape');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'x coordinate of the bottom right corner of the bounding rectangle relative to the corner of the underlying cell (as 1/1024 of that cell’s width)');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'Row of the cell under the bottom right corner of the bounding rectangle of the shape');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'y coordinate of the bottom right corner of the bounding rectangle relative to the corner of the underlying cell (as 1/256 of that cell’s height');
           inc(n);
         end;
      1: begin  // "Small" rectangle structure
           numBytes := 2;
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'top');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'left');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'right');
           inc(n);
           Move(FBuffer[FBufferIndex], w, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
             indent + 'bottom');
           inc(n);
         end;
      2: begin   // standard rectangle structure
           numbytes := 4;
           Move(FBuffer[FBufferIndex], dw, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)),
             indent + 'top');
           inc(n);
           Move(FBuffer[FBufferIndex], dw, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)),
             indent + 'left');
           inc(n);
           Move(FBuffer[FBufferIndex], dw, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)),
             indent + 'right');
           inc(n);
           Move(FBuffer[FBufferIndex], dw, numbytes);
           ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)),
             indent + 'bottom');
           inc(n);
         end;
    end;
  end;

  procedure DoShowOfficeArtRecord(out ARecType:Word; out ARecLen: DWord;
    out AIsContainer: Boolean);
  var
    startIndex, endindex: Int64;
    totalbytes: Int64;
  begin
    totalbytes := 0;
    startIndex := FBufferIndex + 8;
    repeat
      DoShowHeader(ARecType, ARecLen, AIsContainer);
      if totalbytes = 0 then endindex := startindex + ARecLen;
      totalbytes := totalbytes + ARecLen;
      if AIsContainer then begin
        inc(level);
        indent := PrepareIndent(level);
        DoShowOfficeArtRecord(ARecType, ARecLen, AIsContainer);
      end else
        case ARecType of
          $F008: DoShowOfficeArtFDG;
          $F009: DoShowOfficeArtFSPGR;  // shape group
          $F00A: DoShowOfficeArtFSP;    // instance of a shape
          $F00B: DoShowOfficeArtFOPT(ARecLen); // table of OfficeArtRGFOPTE records
          $F00D: DoShowOfficeArtClientTextbox(ARecLen);
          $F010: DoShowOfficeArtClientAnchorData(0);  // 0 - use OfficeArtClientAnchorSheet because contained in a sheet stream
//           $F122: DoShowOfficeArtRGFOPTE(AIndent);  // (tertiary) table of OfficeArtRGFOPTE records
          else if ARecLen <> 0 then begin
                 ShowInRow(FCurrRow, FBufferIndex, ARecLen, '', indent + 'Skipping this unknown record...');
                 inc(n);
               end;
        end;
    until (FBufferIndex >= endindex) or (FBufferIndex >= Length(FBuffer));
    dec(level);
    FBufferIndex := endindex;
  end;

begin
  RowCount := FixedRows + 1000;
  n := 0;
  level := -1;
  DoShowOfficeArtRecord(recType, recLen, isContainer);
  RowCount := FixedRows + n;
end;

procedure TBIFFGrid.ShowMulBlank;
var
  w: Word;
  numbytes: Integer;
  i, nc: Integer;
begin
  nc := (Length(FBuffer) - 6) div 2;
  RowCount := FixedRows + 3 + nc;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Index to row');

  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Index to first column');

  for i:=0 to nc-1 do begin
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      Format('Index to XF record #%d', [i]));
  end;

  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Index to last column');
end;


procedure TBIFFGrid.ShowMulRK;
var
  w: Word;
  numBytes: Integer;
  i, nc: Integer;
  dw: DWord;
  encint: DWord;
  encdbl: QWord;
  dbl: Double absolute encdbl;
  s: String;
begin
  nc := (Length(FBuffer) - 6) div 6;
  RowCount := FixedRows + 3 + nc*2;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Index to row');

  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Index to first column');

  for i:=0 to nc-1 do begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      Format('Index to XF record #%d', [i]));

    numBytes := 4;
    Move(FBuffer[FBufferIndex], dw, numbytes);
    dw := DWordLEToN(dw);

    if Row = FCurrRow then begin
      FDetails.Add('RK Value:'#13);
      if dw and $00000001 = 0
        then FDetails.Add('Bit 0 = 0: Value not changed')
        else FDetails.Add('Bit 0 = 1: Encoded value is multiplied by 100.');
      if dw and $00000002 = 0
        then FDetails.Add('Bit 1 = 0: Floating point value')
        else FDetails.Add('Bit 1 = 1: Signed integer value');
      if dw and $00000002 = 0 then begin
        encdbl := (QWord(dw) and QWord($FFFFFFFFFFFFFFFC)) shl 32;
        if dw and $00000001 = 1 then
          s := Format('%.2f', [dbl*0.01])
        else
          s := Format('%.0f', [dbl]);
      end
      else begin
        s := Format('$%.16x', [-59000000]);
        encint := ((dw and DWord($FFFFFFFC)) shr 2) or (dw and DWord($C0000000));
          // "arithmetic shift" = replace left-most bits by original bits
        if dw and $00000001 = 1 then
          s := FloatToStr(encint*0.01)
        else
          s := IntToStr(encint);
      end;
      FDetails.Add('Bits 31-2: Encoded value ' + s);
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes,
      Format('$%.8x', [dw]),
      Format('RK value #%d', [i])
    );
  end;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Index to last column');
end;

procedure TBIFFGrid.ShowNote;
var
  numBytes: Integer;
  w: Word = 0;
  s: String;
begin
  RowCount := IfThen(FFormat = sfExcel8, 6, 5);

  // Offset 0: Row and Col index
  ShowRowColData(FBufferIndex);

  if FFormat = sfExcel8 then begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      FDetails.Add('Comment flags:'#13);
      if (w and $0002 <> 0)
        then FDetails.Add('x Bit 1=1: Comment is shown at all times')
        else FDetails.Add('  Bit 1=0: Comment is not shown at all tiems');
      if (w and $0080 <> 0)
        then FDetails.Add('x Bit 7=1: Row with comment is hidden')
        else FDetails.Add('  Bit 7=0: Row with comment is visible');
      if (w and $0100 <> 0)
        then FDetails.Add('x Bit 8=1: Column with comment is hidden')
        else FDetails.Add('  Bit 8=0: Column with comment is visible');
      FDetails.Add('All other bits are reserved and must be ignored.');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
      'Flags');

    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Object ID');

    ExtractString(FBufferIndex, IfThen(FFormat=sfExcel8, 2, 1), FFormat=sfExcel8,
      s, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Author');
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
      'Total length of comment');

    numBytes := Min(Length(FBuffer) - FBufferIndex, 2048);
    SetLength(s, numBytes);
    Move(FBuffer[FBufferIndex], s[1], numBytes);
    SetLength(s, Length(s));
    s := UTF8StringReplace(s, #10, '[\n]', [rfReplaceAll]);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Comment text');
  end;
end;


procedure TBIFFGrid.ShowNumberCell;
var
  numBytes: Integer;
  b: Byte = 0;
  w: Word = 0;
  dbl: Double;
begin
  RowCount := IfThen(FFormat = sfExcel2, FixedRows + 6, FixedRows + 4);
  // Offset 0: Row & Offsset 2: Column
  ShowRowColData(FBufferIndex);
  // Offset 4: Cell attributes (BIFF2) or XF ecord index (> BIFF2)
  if FFormat = sfExcel2 then begin
    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Cell protection and XF index:'#13);
      FDetails.Add(Format('x Bits 5-0 = %d: XF Index', [b and $3F]));
      case b and $40 of
        0: FDetails.Add('  Bit 6 = 0: Cell is NOT locked.');
        1: FDetails.Add('x Bit 6 = 1: Cell is locked.');
      end;
      case b and $80 of
        0: FDetails.Add('  Bit 7 = 0: Formula is NOT hidden.');
        1: FDetails.Add('x Bit 7 = 1: Formula is hidden.');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
      'Cell protection and XF index');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Indexes to format and font records:'#13);
      FDetails.Add(Format('Bits 5-0 = %d: Index to FORMAT record', [b and $3f]));
      FDetails.Add(Format('Bits 7-6 = %d: Index to FONT record', [(b and $C0) shr 6]));
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b,b]),
      'Indexes of format and font records');

    numBytes := 1;
    Move(FBuffer[FBufferIndex], b, numBytes);
    if Row = FCurrRow then begin
      FDetails.Add('Cell style:'#13);
      case b and $07 of
        0: FDetails.Add('x Bits 2-0 = 0: Horizontal alignment is GENERAL');
        1: FDetails.Add('x Bits 2-0 = 1: Horizontal alignment is LEFT');
        2: FDetails.Add('x Bits 2-0 = 2: Horizontal alignment is CENTERED');
        3: FDetails.Add('x Bits 2-0 = 3: Horizontal alignment is RIGHT');
        4: FDetails.Add('x Bits 2-0 = 4: Horizontal alignment is FILLED');
      end;
      if b and $08 = 0
        then FDetails.Add('  Bit 3 = 0: Cell has NO left border')
        else FDetails.Add('x Bit 3 = 1: Cell has left black border');
      if b and $10 = 0
        then FDetails.Add('  Bit 4 = 0: Cell has NO right border')
        else FDetails.Add('x Bit 4 = 1: Cell has right black border');
      if b and $20 = 0
        then FDetails.Add('  Bit 5 = 0: Cell has NO top border')
        else FDetails.Add('x Bit 5 = 1: Cell has top black border');
      if b and $40 = 0
        then FDetails.Add('  Bit 6 = 0: Cell has NO bottom border')
        else FDetails.Add('x Bit 6 = 1: Cell has bottom black border');
      if b and $80 = 0
        then FDetails.Add('  Bit 7 = 0: Cell has NO shaded background')
        else FDetails.Add('x Bit 7 = 1: Cell has shaded background');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.2x)', [b,b]),
      'Cell style');
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrROw, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
      'Index of XF record');
  end;
  // Offset  6: Double value
  numBytes := 8;
  Move(FBuffer[FBufferIndex], dbl, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%g', [dbl]), //FloatToStr(dbl),
    'IEEE 764 floating-point value');
end;


procedure TBIFFGrid.ShowObj;
var
  numBytes: Integer;
  w: Word;
  dw: DWord;
  savedBufferIndex: Integer;
  fieldType: Word;
  fieldSize: Word;
  s: String;
  i, n: Integer;
  guid: TGUID;
begin
  if FFormat = sfExcel8 then begin
    n := 0;
    RowCount := FixedRows + 1000;
    while FBufferIndex < Length(FBuffer) do begin
      savedBufferIndex := FBufferIndex;
      numBytes := 2;
      Move(FBuffer[FBufferIndex], w, numBytes);
      fieldType := WordLEToN(w);
      case fieldType of
        $00: s := 'ftEnd (End of OBJ record)';
        $01: s := '(Reserved)';
        $02: s := '(Reserved)';
        $03: s := '(Reserved)';
        $04: s := 'ftMacro (fmla-style macro)';
        $05: s := 'ftButton (Command button)';
        $06: s := 'ftGmo (Group marker)';
        $07: s := 'ftCf (Clipboard format)';
        $08: s := 'ftPioGrbit (Picture option flags)';
        $09: s := 'ftPictFmla (Picture fmla-style macro)';
        $0A: s := 'ftCbls (Checkbox link)';
        $0B: s := 'ftRbo (Radio button)';
        $0C: s := 'ftSbs (Scrollbar)';
        $0D: s := 'ftNts (Note structure)';
        $0E: s := 'ftSbsFmla (Scroll bar fmla-style macro)';
        $0F: s := 'ftGboData (Group box data)';
        $10: s := 'ftEdoData (Edit control data)';
        $11: s := 'ftRboData (Radio button data)';
        $12: s := 'ftCblsData (Check box data)';
        $13: s := 'ftLbsData (List box data)';
        $14: s := 'ftCblsFmla (Check box link fmla-style macro)';
        $15: s := 'ftCmo (Common object data)';
        else s := '(unknown)';
      end;
      ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.04x', [fieldType]),
        Format('Subrecord type: %s', [s]));
      inc(n);

      Move(FBuffer[FBufferIndex], w, numBytes);
      fieldSize := WordLEToN(w);
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(fieldSize), 'Size of subrecord');
      inc(n);

      case fieldType of
        $000D:
          begin  // ftNts, from https://msdn.microsoft.com/en-us/library/office/dd951373%28v=office.12%29.aspx
            numBytes := 16;
            Move(FBuffer[FBufferIndex], guid, numBytes);
            s := GuidToString(guid);
            ShowInRow(FCurrRow, FBufferIndex, numbytes, s, 'GUID of comment');
            inc(n);

            numbytes := 2;
            Move(FBuffer[FBufferIndex], w, numBytes);
            ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
              'Shared Note (0 = false, 1 = true)');
            inc(n);

            numBytes := 4;
            Move(FBuffer[FBufferIndex], dw, numBytes);
            ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)),
              'Unused (undefined, must be ignored)');
            inc(n);
          end;

        $0015:
          begin  // common object data
             Move(FBuffer[FBufferIndex], w, numBytes);
             w := WordLEToN(w);
             case w of
               $00: s := 'Group';
               $01: s := 'Line';
               $02: s := 'Rectangle';
               $03: s := 'Oval';
               $04: s := 'Arc';
               $05: s := 'Chart';
               $06: s := 'Text';
               $07: s := 'Button';
               $08: s := 'Picture';
               $09: s := 'Polybon';
               $0A: s := '(Reserved)';
               $0B: s := 'Checkbox';
               $0C: s := 'Option button';
               $0D: s := 'Edit box';
               $0E: s := 'Label';
               $0F: s := 'Dialog box';
               $10: s := 'Spinner';
               $11: s := 'Scrollbar';
               $12: s := 'List box';
               $13: s := 'Group box';
               $14: s := 'Combobox';
               $15: s := '(Reserved)';
               $16: s := '(Reserved)';
               $17: s := '(Reserved)';
               $18: s := '(Reserved)';
               $19: s := 'Comment';
               $1A: s := '(Reserved)';
               $1B: s := '(Reserved)';
               $1C: s := '(Reserved)';
               $1D: s := '(Reserved)';
               $1E: s := 'Microsoft Office drawing';
               else s := '(Unknown)';
             end;
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.04x', [w]),
               'Object type: '+s);
             inc(n);

             Move(FBuffer[FBufferIndex], w, numbytes);
             w := WordLEToN(w);
             ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.04x', [w]),
               'Object ID number');
             inc(n);

             Move(FBuffer[FBufferIndex], w, numbytes);
             w := WordLEToN(w);
             if Row = FCurrRow then begin
               FDetails.Add('Option flags:'#13);
               if w and $0001 <> 0
                 then FDetails.Add('x Bit $0001 = 1: Object is locked when sheet is protected.')
                 else FDetails.Add('  Bit $0001 = 0: Object is NOT locked when sheet is protected.');
               if w and $000E <> 0
                 then FDetails.Add('! Bit $0002 <> 0: Reserved - must be zero - THIS SEEMS TO BE AN ERROR!')
                 else FDetails.Add('  Bit $0002 = 0: Reserved - must be zero');
               if w and $0010 <> 0
                 then FDetails.Add('x Bit $0010 = 1: Image of this object is intended to be included when printing')
                 else FDetails.Add('  Bit $0010 = 0: Image of this object is NOT intended to be included when printing');
               if w and $1FE0 <> 0
                 then FDetails.Add('! Bits 12-5 <> 0: Reserved - must be zero - THIS SEEMS TO BE AN ERROR!')
                 else FDetails.Add('  Bits 12-5 = 0: Reserved - must be zero');
               if w and $2000 <> 0
                 then FDetails.Add('x Bit $2000 = 1: Object uses automatic fill style.')
                 else FDetails.Add('  Bit $2000 = 0: Object does NOT use automatic fill style.');
               if w and $4000 <> 0
                 then FDetails.Add('x Bit $4000 = 1: Object uses automatic line style.')
                 else FDetails.Add('  Bit $4000 = 0: Object does NOT use automatic line style.');
               if w and $8000 <> 0
                 then FDetails.Add('! Bit $8000 = 1: Reserved - must be zero - THIS SEEMS TO BE AN ERROR!')
                 else FDetails.Add('  Bit $8000 = 0: Reserved - must be zero.');
             end;
             s := '';
             if w and $0001 <> 0 then s := s + 'locked, ';
             if w and $0010 <> 0 then s := s + 'print, ';
             if w and $2000 <> 0 then s := s + 'automatic fill style, ';
             if w and $4000 <> 0 then s := s + 'automatic line style, ';
             if s <> '' then begin
               Delete(s, Length(s)-1, 2);
               s := 'Option flags:' + s;
             end else
               s := 'Option flags';
             ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.04x', [w]), s);
             inc(n);
           end;
      end;
      FBufferIndex := savedBufferIndex + 4 + fieldSize;
    end;
    RowCount := FixedRows + n;
  end else
  if FFormat = sfExcel5 then begin
      // to do
  end;
end;


procedure TBIFFGrid.ShowPageSetup;
var
  numBytes: Integer;
  w: Word;
  s: String;
  dbl: Double;
begin
  if FFormat in [sfExcel5, sfExcel8] then RowCount := FixedRows + 11
    else RowCount := FixedRows + 6;

  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Paper size:'#13);
    FDetails.Add(Format('%d - %s', [w, PaperSizeName(w)]));
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Paper size');

  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Scaling factor in percent');

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLETON(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Start page number');

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLETON(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Fit worksheet width to this number of pages (0 = use as many as needed)');

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLETON(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Fit worksheet height to this number of pages (0 = use as many as needed)');

  { Excel4 not supported in fpspreadsheet }
  {
  if FFormat = sfExcel4 then begin
    Move(FBuffer[FBufferIndex], w, numbytes);
    w := WordLETON(w);
    if Row = FCurrRow then begin
      FDetails.Add('Option flags:'#13);
      if w and $0001 = 0
        then FDetails.Add('Bit $0001 = 0: Print pages in columns')
        else FDetails.Add('Bit $0001 = 1: Print pages in rows');
      if w and $0002 = 0
        then FDetails.add('Bit $0002 = 0: Landscape')
        else FDetails.Add('Bit $0002 = 1: Portrait');
      if w and $0004 = 0
        then FDetails.Add('Bit $0004 = 0: Paper size, scaling factor, and paper orientation ' +
                                          '(portrait/landscape) ARE initialised')
        else FDetails.Add('Bit $0004 = 1: Paper size, scaling factor, and paper orientation ' +
                                          '(portrait/landscape) are NOT initialised');
      if w and $0008 = 0
        then FDetails.Add('Bit $0008 = 0: Print colored')
        else FDetails.add('Bit $0008 = 1: Print black and white');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x (%d)', [w, w]),
      'Option flags');
  end else }
  if (FFormat in [sfExcel5, sfExcel8]) then begin
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      FDetails.Add('Option flags:'#13);
      if w and $0001 = 0
        then FDetails.Add('Bit $0001 = 0: Print pages in columns')
        else FDetails.Add('Bit $0001 = 1: Print pages in rows');
      if w and $0002 = 0
        then FDetails.add('Bit $0002 = 0: Landscape')
        else FDetails.Add('Bit $0002 = 1: Portrait');
      if w and $0004 = 0
        then FDetails.Add('Bit $0004 = 0: Paper size, scaling factor, and paper orientation ' +
                                          '(portrait/landscape) ARE initialised')
        else FDetails.Add('Bit $0004 = 1: Paper size, scaling factor, and paper orientation ' +
                                          '(portrait/landscape) are NOT initialised');
      if w and $0008 = 0
        then FDetails.Add('Bit $0008 = 0: Print colored')
        else FDetails.add('Bit $0008 = 1: Print black and white');
      if w and $0010 = 0
        then FDetails.Add('Bit $0010 = 0: Default print quality')
        else FDetails.Add('Bit $0010 = 1: Draft quality');
      if w and $0020 = 0
        then FDetails.Add('Bit $0020 = 0: Do NOT print cell notes')
        else FDetails.Add('Bit $0020 = 0: Print cell notes');
      if w and $0040 = 0
        then FDetails.Add('Bit $0040 = 0: Use paper orientation (portrait/landscape) flag abov')
        else FDetails.Add('Bit $0040 = 1: Use default paper orientation (landscape for chart sheets, portrait otherwise)');
      if w and $0080 = 0
        then FDetails.Add('Bit $0080 = 0: Automatic page numbers')
        else FDetails.Add('Bit $0080 = 1: Use start page number above');
      if w and $0200 = 0
        then FDetails.Add('Bit $0200 = 0: Print notes as displayed')
        else FDetails.Add('Bit $0200 = 1: Print notes at end of sheet');
      case (w and $0C00) shr 10 of
        0: FDetails.Add('Bit $0C00 = 0: Print errors as displayed');
        1: FDetails.add('Bit $0C00 = 1: Do not print errors');
        2: FDetails.Add('Bit $0C00 = 2: Print errors as "--"');
        3: FDetails.Add('Bit $0C00 = 4: Print errors as "#N/A"');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x (%d)', [w, w]),
      'Option flags');

    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Print resolution in dpi');

    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Vertical print resolution in dpi');

    numBytes := 8;
    Move(FBuffer[FBufferIndex], dbl, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, FloatToStr(dbl), 'Header margin');

    Move(FBuffer[FBufferIndex], dbl, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, FloatToStr(dbl), 'Footer margin');

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Number of copies to print');
  end;

end;

procedure TBIFFGrid.ShowPalette;
var
  numBytes: Integer;
  w: Word;
  dw: DWord;
  npal: Integer;
  i: Integer;
  s: String;
begin
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  npal := WordLEToN(w);

  RowCount := FixedRows + 1 + npal;

  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(npal),
    'Number of palette colors');

  for i := 0 to npal-1 do begin
    numbytes := 4;
    Move(FBuffer[FBufferIndex], dw, numBytes);
    dw := DWordLEToN(dw);
    s := Format('Palette color, index #%d ($%.2x)',[i, i]);
    case i of
      $00..$07: ;
      $08..$3F: s := s + ', user-defined palette';
      $40     : s := s + ', system window text color for border lines';
      $41     : s := s + ', system window background color for pattern background';
      $43     : s := s + ', system face color (dialogue background color)';
      $4D     : s := s + ', system window text colour for chart border lines';
      $4E     : s := s + ', system window background color for chart areas';
      $4F     : s := s + ', automatic color for chart border lines (seems to be always Black)';
      $50     : s := s + ', system tool tip background color (used in note objects)';
      $51     : s := s + ', system tool tip text color (used in note objects)';
      $7FFF   : s := s + ', system window text color for fonts';
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.8x', [dw]), s);
  end;
end;


procedure TBIFFGrid.ShowPane;
var
  numBytes: Integer;
  w: Word;
  b: Byte;
begin
  RowCount := FixedRows + IfThen(FFormat < sfExcel5, 5, 6);

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Position of vertical split (twips or columns (if frozen))');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBUfferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Position of horizontal split (twips or rows (if frozen))');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBUfferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to first visible row in bottom pane(s)');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBUfferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to first visible column in right pane(s)');

  numBytes := 1;
  b := FBuffer[FBufferIndex];
  ShowInRow(FCurrRow, FBUfferIndex, numBytes, IntToStr(b),
    'Identifier of pane with active cell cursor');

  if FFormat >= sfExcel5 then begin
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBUfferIndex, numBytes, IntToStr(b), 'not used');
  end;
end;

procedure TBIFFGrid.ShowPassword;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Password verifier for sheet or workbook:'#13);
    if w = 0
      then FDetails.Add('0 = No password')
      else FDetails.Add(Format('$%.4x = Password verifier', [w]));
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Password verifier for sheet or workbook');
end;


procedure TBIFFGrid.ShowPrecision;
var
  numbytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Precision-as-displayed mode:'#13);
    if w = 0
      then FDetails.Add('0 = Precision-as-displayed mode selected')
      else FDetails.Add('1 = Precision-as-displayed mode NOT selected');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Precision-as-displayed mode');
end;


procedure TBIFFGrid.ShowPrintGridLines;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Print sheet grid lines:'#13);
    if w = 0
      then FDetails.Add('0 = Do not print sheet grid lines')
      else FDetails.Add('1 = Print sheet grid lines');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Print sheet grid lines');
end;


procedure TBIFFGrid.ShowPrintHeaders;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Print row/column headers');
    FDetails.Add('(the area with row numbers and column letters):'#13);
    if w = 0
      then FDetails.Add('0 = Do not print row/column headers')
      else FDetails.Add('1 = Print row/column headers');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Print row/column headers');
end;


procedure TBIFFGrid.ShowProt4Rev;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Removal of the shared workbook''s revision logs:'#13);
    if w = 0
      then FDetails.Add('0 = Removal of the shared workbook''s revision logs is allowed.')
      else FDetails.Add('1 = Removal of the shared workbook''s revision logs is NOT allowed.');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Removal of the shared workbook''s revision logs');
end;


procedure TBIFFGrid.ShowProt4RevPass;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Password verifier needed to change the PROT4REV record:'#13);
    if w = 0
      then FDetails.Add('0 = No password.')
      else FDetails.Add(Format('$%.04x = Password verifier.', [w]));
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w,w]),
    'Password verifier needed to change the PROT4REV record');
end;


procedure TBIFFGrid.ShowProtect;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Protection state of the workbook:'#13);
    if w = 0
      then FDetails.Add('  0 = Workbook is NOT protected.')
      else FDetails.Add('x 1 = Workbook is protected.');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [w]),
    'Protection state of the workbook');
end;


procedure TBIFFGrid.ShowRecalc;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('"Recalculate before save" option:'#13);
    if w = 0
      then FDetails.Add('  0 = Do not recalculate')
      else FDetails.Add('x 1 = Recalculate before saving the document');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Recalculate before saving');
end;


procedure TBIFFGrid.ShowRefMode;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FbufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Cell reference mode:'#13);
    if w = 0
      then FDetails.Add('0 = RC mode (i.e. cell address shown as "R(1)C(-1)"')
      else FDetails.Add('1 = A1 mode (i.e. cell address shown as "B1")');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Cell reference mode');
end;


procedure TBIFFGrid.ShowRefreshAll;
var
  numbytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('RefreshAll record:'#13);
    if w = 0
      then FDetails.Add('  0 = Do not force refresh of external data ranges, PivotTables and XML maps on workbook load.')
      else FDetails.Add('x 1 = Force refresh of external data ranges, PivotTables and XML maps on workbook load.');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.4x)', [w, w]),
    'Force refresh of external data ranges, Pivot tables and XML maps on workbook load');
end;


procedure TBIFFGrid.ShowRightMargin;
var
  numBytes: Integer;
  dbl: Double;
begin
  RowCount := FixedRows + 1;
  numBytes := 8;
  Move(FBuffer[FBufferIndex], dbl, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, FloatToStr(dbl),
    'Right page margin in inches (IEEE 754 floating-point value, 64-bit double precision)');
end;


procedure TBIFFGrid.ShowRK;
var
  numBytes: Integer;
  w: Word;
  dw: DWord;
  encint: DWord;
  encdbl: QWord;
  dbl: Double absolute encdbl;
  s: String;
begin
  RowCount := FixedRows + 4;

  ShowRowColData(FBufferIndex);

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to XF record');

  numBytes := 4;
  Move(FBuffer[FBufferIndex], dw, numBytes);
  dw := DWordLEToN(dw);

  if dw and $00000002 = 0 then begin
    encdbl := (QWord(dw) and QWord($FFFFFFFFFFFFFFFC)) shl 32;
    if dw and $00000001 = 1 then
      s := Format('%.2f', [dbl*0.01])
    else
      s := Format('%.0f', [dbl]);
  end
  else begin
    s := Format('$%.16x', [-59000000]);
    encint := ((dw and DWord($FFFFFFFC)) shr 2) or (dw and DWord($C0000000));
      // "arithmetic shift" = replace left-most bits by original bits
    if dw and $00000001 = 1 then
      s := FloatToStr(encint*0.01)
    else
      s := IntToStr(encint);
  end;

  if Row = FCurrRow then begin
    FDetails.Add('RK Value:'#13);
    if dw and $00000001 = 0
      then FDetails.Add('Bit 0 = 0: Value not changed')
      else FDetails.Add('Bit 0 = 1: Encoded value is multiplied by 100.');
    if dw and $00000002 = 0
      then FDetails.Add('Bit 1 = 0: Floating point value')
      else FDetails.Add('Bit 1 = 1: Signed integer value');
    FDetails.Add('Bits 31-2: Encoded value ' + s);
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes,
    Format('$%.8x', [QWord(dw)]), 'RK value ['+s+']');
end;


procedure TBIFFGrid.ShowRow;
var
  numBytes: Integer;
  dw: DWord;
  w: Word;
  b: Byte;
begin
  RowCount := FixedRows + IfThen(FFormat = sfExcel2, 10, 7);

  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index of this row');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to column of the first cell which is described by a cell record');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to column of the last cell which is described by a cell record, increased by 1');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Row height:'#13);
    FDetails.Add(Format('Bits 14-0 = %d: Row height in twips (1/20 pt) --> %.1f-pt',
      [w and $7FFF, (w and $7FFF)/20.0])
    );
    if w and $8000 = 0
      then FDetails.Add('Bit 15 = 0: Row has custom height')
      else FDetails.Add('Bit 15 = 1: Row has default height');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [w]),
    'Bits 14-0: Height of row in twips (1/20 pt), Bit 15: Row has default height');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, '', '(not used)');

  if FFormat = sfExcel2 then begin
    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
      '0=No defaults written, 1=Default row attribute field and XF index occur below');

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
      'Relative offset to calculate stream position of the first cell record for this row');

    if b = 1 then begin
      numBytes := 1;
      b := FBuffer[FBufferIndex];
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
        'Cell protection and XF index');

      numBytes := 1;
      b := FBuffer[FBufferIndex];
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
        'Indexes to FORMAT and FONT records');

      numBytes := 1;
      b := FBuffer[FBufferIndex];
      ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
        'Cell style');
    end;
  end
  else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, '',
      'In BIFF5-BIFF8 this field is not used anymore, but the DBCELL record instead.');

    numBytes := 4;
    Move(FBuffer[FBufferIndex], dw, numbytes);
    dw := DWordLEToN(dw);
    if Row = FCurrRow then begin
      FDetails.Add('Option flags and default row formatting:'#13);
      FDetails.Add(Format('Bits 0-2 = %d: Outline level of the row', [dw and $00000007]));
      if dw and $00000010 = 0
        then FDetails.Add('Bit 4 = 0: Outline group does not start or end here and is not collapsed')
        else FDetails.Add('Bit 4 = 1: Outline group starts or ends here and is collapsed');
      if dw and $00000020 = 0
        then FDetails.Add('Bit 5 = 0: Row is NOT hidden')
        else FDetails.Add('Bit 5 = 1: Row is hidden');
      if dw and $00000040 = 0
        then FDetails.Add('Bit 6 = 0: Row height and default font height do match.')
        else FDetails.Add('Bit 6 = 1: Row height and default font height do NOT match.');
      if dw and $00000080 = 0
        then FDetails.Add('Bit 7 = 0: Row does NOT have explicit default format.')
        else FDetails.Add('Bit 7 = 1: Row has explicit default format.');
      FDetails.Add('Bit 8 = 1: Is always 1');
      FDetails.Add(Format('Bits 16-27 = %d: Index to default XF record', [(dw and $0FFF0000) shr 16]));
      if dw and $10000000 = 0
        then FDetails.Add('Bit 28 = 0: No additional space above the row.')
        else FDetails.Add('Bit 28 = 1: Additional space above the row.');
      if dw and $20000000 = 0
        then FDetails.Add('Bit 29 = 0: No additional space below the row.')
        else FDetails.Add('Bit 29 = 1: Additional space below the row.');
      if dw and $40000000 = 0
        then FDetails.Add('Bit 30 = 0: D0 NOT show phonetic text for all cells in the row.')
        else FDetails.Add('Bit 30 = 1: Show phonetic text for all cells in the row.');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.8x', [dw]),
      'Option flags and default row formatting');
  end;
end;

procedure TBIFFGrid.ShowRowColData(var ABufIndex: LongWord);
var
  w: Word;
  numBytes: Integer;
begin
  // Row
  numBytes := 2;
  Move(FBuffer[ABufIndex], w, numBytes);
  ShowInRow(FCurrRow, ABufIndex, numBytes, IntToStr(WordLEToN(w)), 'Index to row');
  // Column
  numBytes := 2;
  Move(FBuffer[ABufIndex], w, numBytes);
  ShowInRow(FCurrRow, ABufIndex, numBytes, IntToStr(WordLEToN(w)), 'Index to column');
end;


procedure TBIFFGrid.ShowRString;
var
  numBytes: Integer;
  b: Byte;
  w: Word;
  s: String;
  len: Integer;
  j: Integer;
  wideStr: wideString;
  ansiStr: ansiString;
begin
  if FFormat < sfExcel5 then
    exit;

  RowCount := FixedRows + 5;

  ShowRowColData(FBufferIndex);

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.4x)', [w, w]),
    'Index of XF record');

  // String length
  Move(FBuffer[FBufferIndex], w, 2);
  len := WordLEToN(w);

  if FFormat = sfExcel8 then
  begin
    SetLength(widestr, len);
    Move(FBuffer[FBufferIndex+3], widestr[1], len*2);
    s := UTF8Encode(WideStringLEToN(widestr));
    numbytes := 3 + len*2;
  end else
  begin
    SetLength(ansistr, len);
    Move(FBuffer[FBufferIndex+2], ansistr[1], len);
    s := AnsiToUTF8(ansistr);
    numbytes := 2 + len;
  end;

  ShowInRow(FCurrRow, FBufferIndex, numbytes, s,
    Format('%s string, 16-bit string length', [GetStringType]));

  // Number of rich-text formatting runs
  numbytes := IfThen(FFormat = sfExcel8, 2, 1);
  Move(FBuffer[FBufferIndex], w, numbytes);
  len := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(len),
    'Count of rich-text formatting runs');

  // Formatting run data
  RowCount := RowCount + 2*len;
  for j:=0 to len-1 do
  begin
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      Format('Rich-Text formatting run #%d, index of first character', [j]));
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      Format('Rich-Text formatting run #%d, font index', [j]));
  end;
end;


procedure TBIFFGrid.ShowSelection;
var
  numBytes: Integer;
  w: word;
  b: Byte;
  i, n: Integer;
begin
  Move(FBuffer[FBufferIndex+7], w, 2);
  n := WordLEToN(w);

  RowCount := FixedRows + 5 + n*4;

  numBytes := 1;
  b := FBuffer[FBufferIndex];
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b), 'Pane identifier (see PANE record)');

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to row of the active cell');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index to column of the active cell');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
    'Index into the following cell range list to the entry that contains the active cell');

  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(n),
    'Number of following cell range addresses');

  numbytes := 2;
  for i:=1 to n do begin
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)), 'Index to first row');
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)), 'Index to last row');
    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b), 'Index to first column');
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b), 'Index to last column');
  end;
end;


procedure TBIFFGrid.ShowSharedFormula;
var
  numBytes: Integer;
  b: Byte;
  w: Word;
  tokenBytes: Integer;
begin
  BeginUpdate;
  RowCount := FixedRows + 1000;
  // Brute force simplification because of unknown row count at this point
  // Will be reduced at the end.

  // Index to first row
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)), 'Index to first row');

  // Index to last row
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)), 'Index to last row');

  // Index to first column
  numBytes := 1;  // 8-bit also for BIFF8!
  Move(FBuffer[FBufferIndex], b, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b), 'Index to first column');

  // Index to last column
  numBytes := 1;  // 8-bit also for BIFF8!
  Move(FBuffer[FBufferIndex], b, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b), 'Index to last column');

  // Not used
  numBytes := 1;
  Move(FBuffer[FBufferIndex], b, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b), 'Not used');

  // Number of existing FORMULA records for this shared formula
  numBytes := 1;
  Move(FBuffer[FBufferIndex], b, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b), 'Number of FORMULA records in shared formula');

  // Size of Token array (in Bytes)
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  tokenBytes := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(tokenBytes),
    'Size of formula data (in Bytes)');

  // Formula tokens
  ShowFormulaTokens(tokenBytes);

  RowCount := FCurrRow;
  EndUpdate(true);
end;


procedure TBIFFGrid.ShowSheet;
var
  numBytes: Integer;
  dw: DWord;
  b: Byte;
  s: String;
begin
  RowCount := FixedRows + 4;

  numBytes := 4;
  Move(FBuffer[FBufferIndex], dw, numBytes);
  dw := DWordLEToN(dw);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.8x)', [dw, dw]),
    'Absolute stream position of BOF record of sheet represented by this record.');

  numBytes := 1;
  b := FBuffer[FBufferIndex];
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
    'Sheet state (0=visible, 1=hidden, 2="very" hidden)');

  numBytes := 1;
  b := FBuffer[FBufferIndex];
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]),
    'Sheet type ($00=worksheet, $02=Chart, $06=VB module)');

  ExtractString(FBufferIndex, 1, (FFormat = sfExcel8), s, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, s, IfThen(FFormat=sfExcel8,
    'Sheet name (unicode string, 8-bit string length)',
    'Sheet name (byte string, 8-bit string length)')
  );
end;


procedure TBIFFGrid.ShowSheetPR;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Option flags:'#13);
    if w and $0001 = 0
      then FDetails.Add('  Bit $0001 = 0: Do not show automatic page breaks')
      else FDetails.Add('x Bit $0001 = 1: Show automatic page breaks');
    if w and $0010 = 0
      then FDetails.Add('  Bit $0010 = 0: Standard sheet')
      else FDetails.Add('x Bit $0010 = 1: Dialog sheet (BIFF5-BIFF8)');
    if w and $0020 = 0
      then FDetails.Add('  Bit $0020 = 0: No automatic styles in outlines')
      else FDetails.Add('x Bit $0020 = 1: Apply automatic styles to outlines');
    if w and $0040 = 0
      then FDetails.Add('  Bit $0040 = 0: Outline buttons above outline group')
      else FDetails.Add('x Bit $0040 = 1: Outline buttons below outline group');
    if w and $0080 = 0
      then FDetails.Add('  Bit $0080 = 0: Outline buttons left of outline group')
      else FDetails.Add('x Bit $0080 = 1: Outline buttons right of outline group');
    if w and $0100 = 0
      then FDetails.Add('  Bit $0100 = 0: Scale printout in percent')
      else FDetails.Add('x Bit $0100 = 1: Fit printout to number of pages');
    if w and $0200 = 0
      then FDetails.Add('  Bit $0200 = 0: Save external linked values (BIFF3-BIFF4 only)')
      else FDetails.Add('x Bit $0200 = 1: Do NOT save external linked values (BIFF3-BIFF4 only)');
    if w and $0400 = 0
      then FDetails.Add('  Bit $0400 = 0: Do not show row outline symbols')
      else FDetails.Add('x Bit $0400 = 1: Show row outline symbols');
    if w and $0800 = 0
      then FDetails.Add('  Bit $0800 = 0: Do not show column outline symbols')
      else FDetails.Add('x Bit $0800 = 1: Show column outline symbols');
    case (w and $3000) shr 12 of
      0: FDetails.Add('x Bits $3000 = $0000: Arrange windows tiled');
      1: FDetails.Add('x Bits $3000 = $1000: Arrange windows horizontal');
      2: FDetails.Add('x Bits $3000 = $2000: Arrange windows vertical');
      3: FDetails.Add('x Bits $3000 = $3000: Arrange windows cascaded');
    end;
    if w and $4000 = 0
      then FDetails.Add('x Bits $4000 = 0: Excel like expression evaluation (BIFF4-BIFF8 only)')
      else FDetails.Add('x Bits $4000 = 1: Lotus like expression evaluation (BIFF4-BIFF8 only)');
    if w and $8000 = 0
      then FDetails.Add('x Bits $8000 = 0: Excel like formula editing (BIFF4-BIFF8 only)')
      else FDetails.Add('x Bits $8000 = 1: Lotus like formula editing (BIFF4-BIFF8 only)');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x (%d)', [w, w]),
    'Option flags');
end;

procedure TBIFFGrid.ShowSST;
var
  numBytes: Integer;
  s: String;
  total1, total2: DWord;
  i, j, n: Integer;
  rtfRuns: TRichTextFormattingRuns;
  rtfIndex: LongWord;
  w: Word;
begin
  numBytes := 4;
  Move(FBuffer[FBufferIndex], total1, numBytes);
  Move(FBuffer[FBufferIndex+4], total2, numBytes);
  total1 := DWordLEToN(total1);
  total2 := DWordLEToN(total2);
  FTotalSST := total2;

  RowCount := FixedRows + 1000;

  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(total1),
    'Total number of shared strings in the workbook');
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(total2),
    'Number of following strings');

  FPendingCharCount := -1;
  n := 0;
  for i:=1 to FTotalSST do begin
    FCounterSST := i;
    ExtractString(FBufferIndex, 2, true, s, numBytes, rtfRuns, rtfIndex);  // BIFF8 only --> 2 length bytes
    inc(n);
    if FPendingCharCount = 0 then begin
      ShowInRow(FCurrRow, FBufferIndex, numbytes, s, IfThen(Length(rtfRuns) > 0,
        Format('Shared string #%d (Count of Rich-Text formatting runs: %d)', [i, Length(rtfRuns)]),
        Format('Shared string #%d', [i])));
//       ShowInRow(FCurrRow, FBufferIndex, numBytes, s, Format('Shared string #%d', [i]));
      for j:=0 to High(rtfRuns) do
      begin
        ShowInRow(FCurrRow, rtfIndex, 2, IntToStr(rtfRuns[j].FirstIndex),
          Format('  Rich-Text formatting run #%d, index of first character', [j]));
        ShowInRow(FCurrRow, rtfIndex, 2, IntToStr(rtfRuns[j].FontIndex),
          Format('  Rich-Text formatting run #%d, font index', [j]));
        inc(n, 2);
      end;
    end
    else
    begin
      ShowInRow(FCurrRow, FBufferIndex, numbytes, s, Format('Shared string #%d - partial (--> CONTINUE)', [i]));
      FInfo := BIFFNODE_SST_CONTINUE;
      break;
    end;
  end;
  RowCount := FixedRows + 2 + n;
end;


procedure TBIFFGrid.ShowStandardWidth;
var
  w: Word;
  numBytes: Integer;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d (%f characters)', [w, w/256]),
    'Default column width (overrides DFCOLWIDTH, in 1/256 of "0" width)');
end;


procedure TBIFFGrid.ShowString;
var
  numBytes: Integer;
  s: String;
begin
  RowCount := FixedRows + 1;
  case FFormat of
    sfExcel2:
      begin
        ExtractString(FBufferIndex, 1, false, s, numBytes);
        ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Byte string, 8-bit string length');
      end;
    sfExcel5:
      begin
        ExtractString(FBufferIndex, 2, false, s, numBytes);
        ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Byte string, 16-bit string length');
      end;
    sfExcel8:
      begin
        ExtractString(FBufferIndex, 2, true, s, numBytes);
        ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Unicode string, 16-bit string length');
      end;
  end;
end;


procedure TBIFFGrid.ShowStyle;
var
  numBytes: Integer;
  b: Byte;
  w: Word;
  s: String;
  isRowLevel: Boolean;
  isColLevel: Boolean;
begin
  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if w and $8000 = 0 then
    RowCount := FixedRows + 2
  else
    RowCount := FixedRows + 3;
  if Row = FCurrRow then begin
    FDetails.Add('Style:'#13);
    FDetails.Add(Format('Bits 0-11 = %d: Index to style XF record', [w and $0FFFF]));
    if w and $8000 = 0
      then FDetails.Add('Bit 15 = 0: user-defined style')
      else FDetails.Add('Bit 15 = 1: built-in style');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]), 'Style index and type');

  if w and $8000 = 0 then begin
    if FFormat = sfExcel8 then begin
      ExtractString(FBufferIndex, 2, true, s, numBytes);
      ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Style name (Unicode string, 16-bit string length)');
    end else begin
      ExtractString(FBufferIndex, 1, false, s, numBytes);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, s, 'Style name (Byte string, 8-bit string length)');
    end;
  end else begin
    numbytes := 1;
    b := FBuffer[FBufferIndex];
    isRowLevel := (b = 1);
    isColLevel := (b = 2);
    if FCurrRow = Row then begin
      FDetails.Add('Identifier for built-in cell style:'#13);
      case b of
        0: FDetails.Add('0 = normal');
        1: FDetails.Add('1 = RowLevel (see next field)');
        2: FDetails.Add('2 = ColLevel (see next field)');
        3: FDetails.Add('3 = Comma');
        4: FDetails.Add('4 = Currency');
        5: FDetails.Add('5 = Percent');
        6: FDetails.Add('6 = Comma [0]');
        7: FDetails.Add('7 = Currency [0]');
        8: FDetails.Add('8 = Hyperlink');
        9: FDetails.Add('9 = Followed hyperlink');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
      'Identifier for built-in cell style');

    b := FBuffer[FBufferIndex];
    if FCurrRow = Row then begin
      FDetails.Add('Level for RowLevel or ColLevel style (zero-based):'#13);
      if b = $FF then
        FDetails.Add('$FF = no RowLevel or ColLevel style')
      else
      if isRowLevel then
        FDetails.Add('RowLevel = ' + IntToStr(b))
      else if isColLevel then
        FDetails.Add('ColLevel = ' + IntToStr(b));
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
      'Level for RowLevel or ColLevel style (if available)');
  end;
end;


procedure TBIFFGrid.ShowStyleExt;
var
  numBytes: Integer;
  w: Word;
  b: Byte;
  bs: Byte;
  s: String;
begin
  RowCount := FixedRows + 11;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [wordLEToN(w)]),
    'Future record type');
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Attributes:'#13);
    if w and $0001 = 0
      then FDetails.Add('  Bit 0 = 0: The containing record does not specify a range of cells.')
      else FDetails.Add('x Bit 0 = 1: The containing record specifies a range of cells.');
    FDetails.Add('Bit 1: specifies wether to alert the user of possible problems '+
      'when saving the file whithout having reckognized this record.');
    FDetails.Add('Bits 2-15: reserved (MUST be zero, MUST be ignored)');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]),
    'Attributes');
  numbytes := 8;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, '', 'Reserved');

  numbytes := 1;
  b := FBuffer[FBufferIndex];
  if Row = FCurrRow then begin
    FDetails.Add('Flags:'#13);
    if b and $01 = 0
      then FDetails.Add('  Bit 0 = 0: no built-in style')
      else FDetails.Add('x Bit 0 = 1: built-in style');
    if b and $02 = 0
      then FDetails.Add('  Bit 1 = 0: NOT hidden')
      else FDetails.Add('x Bit 1 = 1: hidden (i.e. is displayed in user interface)');
    FDetails.Add('Bit 2: specifies whether the built-in cell style was modified '+
      'by the user and thus has a custom definition.');
    FDetails.Add('Bit 3-7: Reserved');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]), 'Flags');

  numbytes := 1;
  b := FBuffer[FBufferIndex];
  if Row = FCurrRow then begin
    FDetails.Add('Category:'#13);
    case b of
      0: FDetails.Add('Bits 0-7 = 0: Custom style');
      1: FDetails.Add('Bits 0-7 = 1: Good, bad, neutral style');
      2: FDetails.Add('Bits 0-7 = 2: Data model style');
      3: FDetails.Add('Bits 0-7 = 3: Title and heading style');
      4: FDetails.Add('Bits 0-7 = 4: Themed cell style');
      5: FDetails.Add('Bits 0-7 = 5: Number format style');
    end;
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]), 'Category');

  numbytes := 1;
  b := FBuffer[FBufferIndex];
  if Row = FCurrRow then begin
    FDetails.Add('Built-in style:'#13);
    FDetails.Add('An unsigned integer that specifies the type of the built-in cell style.');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]), 'Built-in style');
  bs := b;

  numbytes := 1;
  b := FBuffer[FBufferindex];
  if Row = FCurrRow then begin
    FDetails.Add('Outline depth level:'#13);
    FDetails.Add('An unsigned integer that specifies the depth level of row/column automatic outlining.');
    if (bs in [1, 2]) then
      FDetails.Add(Format('Bits 0-7 = %d: Outline level is %d', [b, b+1]))
    else
      FDetails.Add(Format('Bits 0-7 = $%.2x: MUST be $FF, MUST be ignoried', [b]));
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.2x', [b]), 'Outline depth level');

  ExtractString(FBufferIndex, 1, true, s, numBytes, true);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, s, 'Name of the style name to extend (Unicode string, 8-bit string length)');

  numbytes := 2;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, '', 'XFProps (reserved)');

  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w), 'Count of XFProp structures to follow in array');


end;


procedure TBiffGrid.ShowTabID;
var
  numbytes: Integer;
  w: word;
  i, n: Integer;
begin
  numbytes := 2;
  n := Length(FBuffer) div numbytes;
  RowCount := FixedRows + n;
  for i := 1 to n do begin
    Move(FBuffer[FBufferIndex], w, numbytes);
    w := WordLEToN(w);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.4x)', [w, w]),
      'Unique sheet identifier');
  end;
end;


procedure TBIFFGrid.ShowTopMargin;
var
  numBytes: Integer;
  dbl: Double;
begin
  RowCount := FixedRows + 1;
  numBytes := 8;
  Move(FBuffer[FBufferIndex], dbl, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numBytes, FloatToStr(dbl),
    'Top page margin in inches (IEEE 754 floating-point value, 64-bit double precision)');
end;


procedure TBIFFGrid.ShowTXO;
var
  numbytes: Word;
  w: Word;
  s, sh, sv, sl: String;
begin
  RowCount := FixedRows + 9;
  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  sh := '';
  case (w and $000E) shr 1 of
    1: sh := sh + 'left-aligned, ';
    2: sh := sh + 'centered, ';
    3: sh := sh + 'right-aligned, ';
    4: sh := sh + 'justified, ';
  end;
  sv := '';
  case (w and $0070) shr 4 of
    1: sv := sv + 'top, ';
    2: sv := sv + 'middle, ';
    3: sv := sv + 'bottom, ';
    4: sv := sv + 'justify, ';
  end;
  s := sh + sv;
  if (w and $0200) shr 9 <> 0 then s := s + 'lock text, ';
  if Row = FCurrRow then begin
    FDetails.Add(     'Option flags:'#13);
    FDetails.Add(     'Bit 0: Reserved');
    if sh = '' then sh := 'none';
    FDetails.Add(     'Bits 1-3: 0 = Horizontal text alignment: ' + sh);
    if sv = '' then sv := 'none';
    FDetails.Add(     'Bits 4-6: 0 = Vertical text alignment: ' + sv);
    FDetails.Add(     'Bits 7-8: Reserved');
    case (w and $0200) shr 9 of
      0: FDetails.Add('Bit 9: Lock Text Option is off.');
      1: FDetails.Add('Bit 9: Lock Text Option is on');
    end;
    FDetails.Add(     'Bits 10-15: Reserved');
  end;
  if s <> '' then begin
    Delete(s, Length(s)-1, 2);
    s := 'Option flags: ' + s;
  end else
    s := 'Option flags';
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]), s);

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  case w of
    0: s := 'No rotation (text appears left to right';
    1: s := 'Text appears top to bottom; letters are upright';
    2: s := 'Text is rotated 90 degrees counterclockwise';
    3: s := 'Text is rotated 90 degrees clockwise';
  end;
  if Row = FCurrRow then begin
    FDetails.Add('Orientation of text with the object boundary:'#13);
    FDetails.Add(Format('%d = %s', [w, s]));
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(w),
    'Orientation of text within the object boundary: ' + s);

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Reserved (must be 0)');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Reserved (must be 0)');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Reserved (must be 0)');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Length (in characters) of text (in first following CONTINUE record)');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Length of formatting runs (in second following CONTINUE record)');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Reserved (must be 0)');

  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Reserved (must be 0)');
end;

procedure TBIFFGrid.ShowWindow1;
var
  numBytes: Word;
  b: Byte;
  w: word;
begin
  RowCount := FixedRows + IfThen(FFormat < sfExcel5, 5, 9);
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Horizontal position of the document window (in twips = 1/20 pt)');

  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Vertical position of the document window (in twips = 1/20 pt)');

  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Width of the document window (in twips = 1/20 pt)');

  Move(FBuffer[FBufferIndex], w, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
    'Height of the document window (in twips = 1/20 pt)');

  if FFormat < sfExcel5 then begin
    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(b)),
      '0 = Window is visible; 1 = window is hidden');
  end else begin
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      FDetails.Add('Option flags:');
      if w and $0001 = 0
        then FDetails.Add('  Bit $0001 = 0: Window is visible')
        else FDetails.Add('x Bit $0001 = 1: Window is hidden');
      if w and $0002 = 0
        then FDetails.Add('  Bit $0002 = 0: Window is open')
        else FDetails.Add('x Bit $0002 = 1: Window is minimized');
      if w and $0008 = 0
        then FDetails.Add('  Bit $0008 = 0: Horizontal scrollbar hidden')
        else FDetails.Add('x Bit $0008 = 1: Horizontal scrollbar visible');
      if w and $0010 = 0
        then FDetails.Add('  Bit $0010 = 0: Vertical scrollbar hidden')
        else FDetails.Add('x Bit $0010 = 1: Vertical scrollbar visible');
      if w and $0020 = 0
        then FDetails.Add('  Bit $0020 = 0: Worksheet tab bar hidden')
        else FDetails.Add('x Bit $0020 = 1: Worksheet tab bar visible');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.4x)', [w, w]),
      'Option flags');

    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Index to active (displayed) worksheet');

    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Index of first visible tab in the worksheet tab bar');

    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Number of selected worksheets (highlighted in the worksheet tab bar)');

    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Width of worksheet tab bar (in 1/1000 of window width). '+
      'The remaining space is used by the horizontal scrollbar.');
  end;
end;


procedure TBIFFGrid.ShowWindow2;
var
  numBytes: Word;
  b: Byte;
  w: word;
  dw : DWord;
begin
  if FFormat = sfExcel2 then begin
    RowCount := FixedRows + 9;
    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
      '0 = Show formula results; 1 = Show formulas');
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
      '0 = Do not show grid lines; 1 = Show grid lines');
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
      '0 = Do not show sheet headers; 1 = Show sheet headers');
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
      '0 = Panes are not frozen; 1 = Panes are frozen');
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
      '0 = Show zero values as empty cells; 1 = Show zero values');
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Index to first visible row');
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Index to first visible column');
    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b),
      '0 = Use manual grid line colour (below); 1 = Use automatic grid line colour');
    numbytes := 4;
    Move(FBuffer[FBufferIndex], dw, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x', [DWordLEToN(dw)]),
      'Grid line RGB color');
  end else begin
    RowCount := FixedRows + IfThen(FFormat = sfExcel5, 4, 8);
    numbytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      FDetails.Add('Option flags:');
      if w and $0001 = 0
        then FDetails.Add('  Bit $0001 = 0: Show formula results')
        else FDetails.Add('x Bit $0001 = 1: Show formulas');
      if w and $0002 = 0
        then FDetails.Add('  Bit $0002 = 0: Do not show grid lines')
        else FDetails.Add('x Bit $0002 = 1: Show grid lines');
      if w and $0004 = 0
        then FDetails.Add('  Bit $0004 = 0: Do not show sheet headers')
        else FDetails.Add('x Bit $0004 = 1: Show sheet headers');
      if w and $0008 = 0
        then FDetails.Add('  Bit $0008 = 0: Panes are not frozen')
        else FDetails.Add('x Bit $0008 = 1: Panes are frozen');
      if w and $0010 = 0
        then FDetails.Add('  Bit $0010 = 0: Show zero values as empty cells')
        else FDetails.Add('x Bit $0010 = 1: Show zero values');
      if w and $0020 = 0
        then FDetails.Add('  Bit $0020 = 0: Manual grid line color')
        else FDetails.Add('x Bit $0020 = 1: Automatic grid line color');
      if w and $0040 = 0
        then FDetails.Add('  Bit $0040 = 0: Columns from left to right')
        else FDetails.Add('x Bit $0040 = 1: Columns from right to left');
      if w and $0080 = 0
        then FDetails.Add('  Bit $0080 = 0: Do not show outline symbols')
        else FDetails.Add('x Bit $0080 = 1: Show outline symbols');
      if w and $0100 = 0
        then FDetails.Add('  Bit $0100 = 0: Keep splits if pane freeze is removed')
        else FDetails.Add('x Bit $0100 = 1: Remove splits if pane freeze is removed');
      if w and $0200 = 0
        then FDetails.Add('  Bit $0200 = 0: Sheet not selected')
        else FDetails.Add('x Bit $0200 = 1: Sheet selected');
      if w and $0400 = 0
        then FDetails.Add('  Bit $0400 = 0: Sheet not active')
        else FDetails.Add('x Bit $0400 = 1: Sheet active');
      if w and $0800 = 0
        then FDetails.Add('  Bit $0800 = 0: Show in normal view')
        else FDetails.Add('x Bit $0800 = 1: Show in page break preview');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.4x)', [w, w]),
      'Option flags');

    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Index to first visible row');
    Move(FBuffer[FBufferIndex], w, numbytes);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
      'Index to first visible column');

    if FFormat =sfExcel5 then begin
      numbytes := 4;
      Move(FBuffer[FBufferIndex], dw, numbytes);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x', [DWordLEToN(dw)]),
        'Grid line RGB color');
    end else begin
      numBytes := 2;
      Move(FBuffer[FBufferIndex], w, numbytes);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
        'Color index of grid line color');

      ShowInRow(FCurrRow, FBufferIndex, numbytes, '', 'Not used');

      Move(FBuffer[FBufferIndex], w, numbytes);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
        'Cached magnification factor in page break preview (in percent); 0 = Default (60%)');

      Move(FBuffer[FBufferIndex], w, numbytes);
      ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(WordLEToN(w)),
        'Cached magnification factor in normal view (in percent); 0 = Default (100%)');

      numBytes := 4;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, '', 'Not used');
    end;
  end;
end;


procedure TBIFFGrid.ShowWindowProtect;
var
  numBytes: Integer;
  w: Word;
begin
  RowCount := FixedRows + 1;
  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Protection state of workbook windows:'#13);
    if w = 0
      then FDetails.Add('0 = The workbook windows can be resized or moved and the window state can be changed.')
      else FDetails.Add('1 = The workbook windows cannot be resized or moved and the window state cannot be changed.');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [w]),
    'Protection state of the workbook windows');
end;


procedure TBIFFGrid.ShowWriteAccess;
var
  numbytes: Integer;
  s: String;
begin
  RowCount := FixedRows + 1;
  ExtractString(FBufferIndex, IfThen(FFormat=sfExcel8, 2, 1), FFormat=sfExcel8, s, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, s, 'User name (i.e., the name that you type when you install Microsoft Excel');
end;


procedure TBIFFGrid.ShowWriteProt;
begin
  RowCount := FixedRows + 2;
  ShowInRow(FCurrRow, FBufferIndex, 0, '', 'Write protect: if present file is write-protected');
  ShowInRow(FCurrRow, FBufferIndex, 0, '', 'Write protection password is in FILESHARING record');
end;


procedure TBIFFGrid.ShowXF;
var
  numBytes: Word;
  b: Byte;
  w: word;
  dw : DWord;
begin
  if FFormat = sfExcel2 then begin
    RowCount := FixedRows + 4;
    numBytes := 1;
    b := FBuffer[FBufferIndex];
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(b),
      'Index to font record');
    ShowInRow(FCurrRow, FBufferIndex, numBytes, '',
      '(not used)');

    b := FBuffer[FBufferIndex];
    if Row = FCurrRow then begin
      FDetails.Add('Number format and cell flags:'#13);
      FDetails.Add(Format('Bits 0-5 = %d: Index to FORMAT record', [b and $3F]));
      if b and $40 = 0
        then FDetails.Add('Bit 6    = 0: Cell is not locked')
        else FDetails.Add('Bit 6    = 1: Cell is locked');
      if b and $80 = 0
        then FDetails.Add('Bit 7    = 0: Formula is not hidden')
        else FDetails.Add('Bit 7    = 1: Formula is hidden');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('%d ($%.2x)', [b, b]),
      'Number format and cell flags');

    b := FBuffer[FBufferIndex];
    if Row = FCurrRow then begin
      FDetails.Add('Horizontal alignment, border style and background:'#13);
      case b and $07 of
        0: FDetails.Add('Bits $07 = 0: Horizontal alignment "General"');
        1: FDetails.Add('Bits $07 = 1: Horizontal alignment "Left"');
        2: FDetails.Add('Bits $07 = 2: Horizontal alignemnt "Centered"');
        3: FDetails.Add('Bits $07 = 3: Horizontal alignment "Right"');
        4: FDetails.Add('Bits $07 = 4: Horizontal alignment "Filled"');
        5: FDetails.Add('Bits $07 = 5: Horizontal alignment "Justified"');
        6: FDetails.Add('Bits $07 = 6: Horizontal alignment "Centred across selection"');
        7: FDetails.Add('Bits $07 = 7: Horizontal alignment "Distributed"');
      end;
      if b and $08 = 0
        then FDetails.Add('Bit $08 = 0: Cell has no left border')
        else FDetails.Add('Bit $08 = 1: Cell has left black border');
      if b and $10 = 0
        then FDetails.Add('Bit $10 = 0: Cell has no right border')
        else FDetails.Add('Bit $10 = 1: Cell has right black border');
      if b and $20 = 0
        then FDetails.Add('Bit $20 = 0: Cell has no top border')
        else FDetails.Add('Bit $20 = 1: Cell has top black border');
      if b and $40 = 0
        then FDetails.Add('Bit $40 = 0: Cell has no bottom border')
        else FDetails.Add('Bit $40 = 1: Cell has bottom black border');
      if b and $80 = 0
        then FDetails.Add('Bit $80 = 0: Cell has no shaded background')
        else FDetails.Add('Bit $80 = 1: Cell has shaded background');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]),
      'Horizontal alignment, border style, and background');
  end
  else
  begin // XF (BIFF5 and BIFF8)
    RowCount := FixedRows + IfThen(FFormat=sfExcel5, 7, 10);
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
      'Index to font record');
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    ShowInRow(FCurrRow, FBufferIndex, numBytes, IntToStr(WordLEToN(w)),
       'Index to format record');
    numBytes := 2;
    Move(FBuffer[FBufferIndex], w, numBytes);
    w := WordLEToN(w);
    if Row = FCurrRow then begin
      FDetails.Add('XFType, cell protection, parent style XF:'#13);
      if w and $0001 = 0
        then FDetails.Add('Bit $0001 = 0: Cell is not locked')
        else FDetails.Add('Bit $0001 = 1: Cell is locked');
      if w and $0002 = 0
        then FDetails.Add('Bit $0002 = 0: Formula is not hidden')
        else FDetails.Add('Bit $0002 = 1: Formula is hidden');
      if w and $0004 = 0
        then FDetails.Add('Bit $0004 = 0: Cell XF')
        else FDetails.Add('Bit $0004 = 1: Style XF');
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.4x', [w]),
      'XFType, cell protection, parent style XF');

    numBytes := 1;
    b := FBuffer[FBufferIndex];
    if Row = FCurrRow then begin
      FDetails.Add('Alignment and text break:'#13);
      case b and $03 of
        0: FDetails.Add('Bits 0-2 = 0: Horizontal alignment "General"');
        1: FDetails.Add('Bits 0-2 = 1: Horizontal alignment "Left"');
        2: FDetails.Add('Bits 0-2 = 2: Horizontal alignemnt "Centered"');
        3: FDetails.Add('Bits 0-2 = 3: Horizontal alignment "Right"');
        4: FDetails.Add('Bits 0-2 = 4: Horizontal alignment "Filled"');
        5: FDetails.Add('Bits 0-2 = 5: Horizontal alignment "Justified"');
        6: FDetails.Add('Bits 0-2 = 6: Horizontal alignment "Centred across selection"');
        7: if FFormat = sfExcel8 then
             FDetails.Add('x Bits 0-2 = 7: Horizontal alignment "Distributed"');
      end;
      if b and $08 = 0
        then FDetails.Add('Bit 3    = 0: Text is not wrapped.')
        else FDetails.Add('Bit 3    = 1: Text is wrapped at right border.');
      case (b and $70) shr 4 of
        0: FDetails.Add('Bits 4-6 = 0: Vertical alignment "Top"');
        1: FDetails.Add('Bits 4-6 = 1: Vertical alignment "Centered"');
        2: FDetails.Add('Bits 4-6 = 2: Vertical alignment "Bottom"');
        3: FDetails.Add('Bits 4-6 = 3: Vertical alignment "Justified"');
        4: if FFormat = sfExcel8 then
             FDetails.Add('Bits 4-6 = 4: Vertical alignment "Distributed"');
      end;
      if FFormat = sfExcel8 then begin
        if b and $80 = 0
          then FDetails.Add('Bit 3    = 0: Do NOT justify last line in justified or distibuted text')
          else FDetails.Add('Bit 3    = 1: Justify last line in justified or distibuted text');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]),
      'Alignment and text break');

    numBytes := 1;
    b := FBuffer[FBufferIndex];
    if FFormat = sfExcel5 then begin
      if Row = FCurrRow then begin
        FDetails.Add('Text orientation and flags for used attribute groups:'#13);
        case (b and $03) of
          0: FDetails.Add('Bits $03 = 0: not rotated');
          1: FDetails.Add('Bits $03 = 1: not rotated, letters stacked top-to-bottom');
          2: FDetails.Add('Bits $03 = 2: text rotated 90° counter-clockwise');
          3: FDetails.Add('Bits $03 = 3: text rotated 90° clockwise');
        end;
        if b and $04 = 0
          then FDetails.Add('Bit $04 = 0: No flag for number format')
          else FDetails.Add('Bit $04 = 1: Flag for number format');
        if b and $08 = 0
          then FDetails.Add('Bit $08 = 0: No flag for font')
          else FDetails.Add('Bit $08 = 2: Flag for font');
        if b and $10 = 0
          then FDetails.Add('Bit $10 = 0: No flag for hor/vert alignment, text wrap, indentation, orientation, rotation, and text direction')
          else FDetails.Add('Bit $10 = 1: Flag for hor/vert alignment, text wrap, indentation, orientation, rotation, and text direction');
        if b and $20 = 0
          then FDetails.Add('Bit $20 = 0: No flag for border lines')
          else FDetails.Add('Bit $20 = 1: Flag for border lines');
        if b and $40 = 0
          then FDetails.Add('Bit $40 = 0: No flag for background area style')
          else FDetails.Add('Bit $40 = 1: Flag for background area style');
        if b and $80 = 0
          then FDetails.Add('Bit $80 = 0: No flag for cell protection (cell locked and formula hidden)')
          else FDetails.Add('Bit $80 = 1: Flag for cell protection (cell locked and formula hidden)');
      end;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.2x', [b]),
        'Text orientation and flags for used attribute groups');
    end else
    begin  // sfExcel8
      if Row = FCurrRow then begin
        FDetails.Add('Text rotation angle:'#13);
        if b = 0 then
          FDetails.Add('not rotated')
        else if b <= 90 then
          FDetails.Add(Format('%d degrees counter-clockwise', [b]))
        else if b <= 180 then
          FDetails.Add(Format('%d degrees clockwize', [b-90]))
        else if b = 255 then
          FDetails.Add('not rotated, letters stacked top-to-bottom');
      end;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(b), 'Text rotation angle');
    end;

    if FFormat = sfExcel8 then begin
      numBytes := 1;
      b := FBuffer[FBufferIndex];
      if Row = FCurrRow then begin
        FDetails.Add('Indentation, shrink to cell size, and text direction:'#13);
        FDetails.Add(Format('Bits 0-3: Indent level = %d', [b and $0F]));
        if b and $10 = 0
          then FDetails.Add('Bit $10 = 0: Don''t shrink content to fit into cell')
          else FDetails.Add('Bit $10 = 1: Shrink content to fit into cell');
        if b and $20 = 0
          then FDetails.Add('Bit $20 = 0: Merge Cell option is OFF')
          else FDetails.Add('Bit $20 = 1: Merge Cell option is ON');
        case (b and $C0) shr 6 of
          0: FDetails.Add('Bits 6-7 = 0: Text direction according to context');
          1: FDetails.Add('Bits 6-7 = 1: Text direction left-to-right');
          2: FDetails.Add('Bits 6-7 = 2: Text direction right-to-left');
        end;
      end;
      ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.2x', [b]),
        'Indentation, shrink to cell size, and text direction');

      numBytes := 1;
      b := FBuffer[FBufferIndex];
      if Row = FCurrRow then begin
        FDetails.Add('Flags for used attribute groups:'#13);
        if b and $04 = 0
          then FDetails.Add('Bit $04 = 0: No flag for number format')
          else FDetails.Add('Bit $04 = 1: Flag for number format');
        if b and $08 = 0
          then FDetails.Add('Bit $08 = 0: No flag for font')
          else FDetails.Add('Bit $08 = 2: Flag for font');
        if b and $10 = 0
          then FDetails.Add('Bit $10 = 0: No flag for hor/vert alignment, text wrap, indentation, orientation, rotation, and text direction')
          else FDetails.Add('Bit $10 = 1: Flag for hor/vert alignment, text wrap, indentation, orientation, rotation, and text direction');
        if b and $20 = 0
          then FDetails.Add('Bit $20 = 0: No flag for border lines')
          else FDetails.Add('Bit $20 = 1: Flag for border lines');
        if b and $40 = 0
          then FDetails.Add('Bit $40 = 0: No flag for background area style')
          else FDetails.Add('Bit $40 = 1: Flag for background area style');
        if b and $80 = 0
          then FDetails.Add('Bit $80 = 0: No flag for cell protection (cell locked and formula hidden)')
          else FDetails.Add('Bit $80 = 1: Flag for cell protection (cell locked and formula hidden)');
      end;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.2x', [b]),
        'Flags for used attribute groups');

      numBytes := 4;
      Move(FBuffer[FBufferIndex], dw, numbytes);
      dw := DWordLEToN(dw);
      if Row = FCurrRow then begin
        FDetails.Add('Cell border lines and background area:'#13);
        case dw and $0000000F of
          $0000: FDetails.Add('Bits 0-3 = 0: Left border = No line');
          $0001: FDetails.Add('Bits 0-3 = 1: Left border = thin solid line');
          $0002: FDetails.Add('Bits 0-3 = 2: Left border = medium solid line');
          $0003: FDetails.Add('Bits 0-3 = 3: Left border = dashed line');
          $0004: FDetails.Add('Bits 0-3 = 4: Left border = dotted line');
          $0005: FDetails.Add('Bits 0-3 = 5: Left border = thick solid line');
          $0006: FDetails.Add('Bits 0-3 = 6: Left border = double solid line');
          $0007: FDetails.Add('Bits 0-3 = 7: Left border = hair line');
          $0008: FDetails.Add('Bits 0-3 = 8: Left border = medium dashed');
          $0009: FDetails.Add('Bits 0-3 = 9: Left border = thin dash-dotted');
          $000A: FDetails.Add('Bits 0-3 = 10: Left border = medium dash-dotted');
          $000B: FDetails.Add('Bits 0-3 = 11: Left border = thin dash-dot-dotted');
          $000C: FDetails.Add('Bits 0-3 = 12: Left border = medium dash-dot-dotted');
          $000D: FDetails.Add('Bits 0-3 = 13: Left border = slanted medium dash-dotted');
        end;
        case dw and $000000F0 of
          $0000: FDetails.Add('Bits 4-7 = 0: Right border = No line');
          $0010: FDetails.Add('Bits 4-7 = 1: Right border = thin solid line');
          $0020: FDetails.Add('Bits 4-7 = 2: Right border = medium solid line');
          $0030: FDetails.Add('Bits 4-7 = 3: Right border = dashed line');
          $0040: FDetails.Add('Bits 4-7 = 4: Right border = dotted line');
          $0050: FDetails.Add('Bits 4-7 = 5: Right border = thick solid line');
          $0060: FDetails.Add('Bits 4-7 = 6: Right border = double solid line');
          $0070: FDetails.Add('Bits 4-7 = 7: Right border = hair line');
          $0080: FDetails.Add('Bits 4-7 = 8: Right border = medium dashed');
          $0090: FDetails.Add('Bits 4-7 = 9: Right border = thin dash-dotted');
          $00A0: FDetails.Add('Bits 4-7 = 10: Right border = medium dash-dotted');
          $00B0: FDetails.Add('Bits 4-7 = 11: Right border = thin dash-dot-dotted');
          $00C0: FDetails.Add('Bits 4-7 = 12: Right border = medium dash-dot-dotted');
          $00D0: FDetails.Add('Bits 4-7 = 13: Right border = slanted medium dash-dotted');
        end;
        case dw and $00000F00 of
          $0000: FDetails.Add('Bits 8-11 = 0: Top border = No line');
          $0100: FDetails.Add('Bits 8-11 = 1: Top border = thin solid line');
          $0200: FDetails.Add('Bits 8-11 = 2: Top border = medium solid line');
          $0300: FDetails.Add('Bits 8-11 = 3: Top border = dashed line');
          $0400: FDetails.Add('Bits 8-11 = 4: Top border = dotted line');
          $0500: FDetails.Add('Bits 8-11 = 5: Top border = thick solid line');
          $0600: FDetails.Add('Bits 8-11 = 6: Top border = double solid line');
          $0700: FDetails.Add('Bits 8-11 = 7: Top border = hair line');
          $0800: FDetails.Add('Bits 8-11 = 8: Top border = medium dashed');
          $0900: FDetails.Add('Bits 8-11 = 9: Top border = thin dash-dotted');
          $0A00: FDetails.Add('Bits 8-11 = 10: Top border = medium dash-dotted');
          $0B00: FDetails.Add('Bits 8-11 = 11: Top border = thin dash-dot-dotted');
          $0C00: FDetails.Add('Bits 8-11 = 12: Top border = medium dash-dot-dotted');
          $0D00: FDetails.Add('Bits 8-11 = 13: Top border = slanted medium dash-dotted');
        end;
        case dw and $0000F000 of
          $0000: FDetails.Add('Bits 12-15 = 0: Bottom border = No line');
          $1000: FDetails.Add('Bits 12-15 = 1: Bottom border = thin solid line');
          $2000: FDetails.Add('Bits 12-15 = 2: Bottom border = medium solid line');
          $3000: FDetails.Add('Bits 12-15 = 3: Bottom border = dashed line');
          $4000: FDetails.Add('Bits 12-15 = 4: Bottom border = dotted line');
          $5000: FDetails.Add('Bits 12-15 = 5: Bottom border = thick solid line');
          $6000: FDetails.Add('Bits 12-15 = 6: Bottom border = double solid line');
          $7000: FDetails.Add('Bits 12-15 = 7: Bottom border = hair line');
          $8000: FDetails.Add('Bits 12-15 = 8: Bottom border = medium dashed');
          $9000: FDetails.Add('Bits 12-15 = 9: Bottom border = thin dash-dotted');
          $A000: FDetails.Add('Bits 12-15 = 10: Bottom border = medium dash-dotted');
          $B000: FDetails.Add('Bits 12-15 = 11: Bottom border = thin dash-dot-dotted');
          $C000: FDetails.Add('Bits 12-15 = 12: Bottom border = medium dash-dot-dotted');
          $D000: FDetails.Add('Bits 12-15 = 13: Bottom border = slanted medium dash-dotted');
        end;
        FDetails.Add(Format('Bits 16-22 = %d: Color index for left line color',  [(dw and $007F0000) shr 16]));
        FDetails.Add(Format('Bits 23-29 = %d: Color index for right line color', [(dw and $3F800000) shr 23]));
        if dw and $40000000 = 0
          then FDetails.Add('Bit 30 = 0: No diagonal line from top left to right bottom')
          else FDetails.Add('Bit 30 = 1: Diagonal line from top left to right bottom');
        if dw and $80000000 = 0
          then FDetails.Add('Bit 31 = 0: No diagonal line from bottom left to right top')
          else FDetails.Add('Bit 31 = 1: Diagonal line from bottom left to right top');
      end;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x', [dw]),
        'Cell border lines and background area');

      numBytes := 4;
      Move(FBuffer[FBufferIndex], dw, numbytes);
      if Row = FCurrRow then begin
        FDetails.Add('Cell border lines and background area (cont''d):'#13);
        FDetails.Add(Format('Bits 0-6 = %d: Color index for top line color',  [(dw and $0000007F)]));
        FDetails.Add(Format('Bits 7-13 = %d: Color index for bottom line color', [(dw and $00003F80) shr 7]));
        FDetails.Add(Format('Bits 14-20 = %d: Color index for diagonal line color', [(dw and $001FC000) shr 14]));
        case dw and $01E00000 shr 17 of
          $0: FDetails.Add('Bits 21-24 = 0: Diagonal line style = No line');
          $1: FDetails.Add('Bits 21-24 = 1: Diagonal line style = thin solid line');
          $2: FDetails.Add('Bits 21-24 = 2: Diagonal line style = medium solid line');
          $3: FDetails.Add('Bits 21-24 = 3: Diagonal line style = dashed line');
          $4: FDetails.Add('Bits 21-24 = 4: Diagonal line style = dotted line');
          $5: FDetails.Add('Bits 21-24 = 5: Diagonal line style = thick solid line');
          $6: FDetails.Add('Bits 21-24 = 6: Diagonal line style = double solid line');
          $7: FDetails.Add('Bits 21-24 = 7: Diagonal line style = hair line');
          $8: FDetails.Add('Bits 21-24 = 8: Diagonal line style = medium dashed');
          $9: FDetails.Add('Bits 21-24 = 9: Diagonal line style = thin dash-dotted');
          $A: FDetails.Add('Bits 21-24 = 10: Diagonal line style = medium dash-dotted');
          $B: FDetails.Add('Bits 21-24 = 11: Diagonal line style = thin dash-dot-dotted');
          $C: FDetails.Add('Bits 21-24 = 12: Diagonal line style = medium dash-dot-dotted');
          $D: FDetails.Add('Bits 21-24 = 13: Diagonal line style = slanted medium dash-dotted');
        end;
        case (dw and $FC000000) shr 26 of
          $00: FDetails.Add('Bits 26-31 = 0: Fill pattern = No fill');
          $01: FDetails.Add('Bits 26-31 = 1: Fill pattern = solid fill');
          $02: FDetails.Add('Bits 26-31 = 2: Fill pattern = medium fill');
          $03: FDetails.Add('Bits 26-31 = 3: Fill pattern = dense fill');
          $04: FDetails.Add('Bits 26-31 = 4: Fill pattern = sparse fill');
          $05: FDetails.Add('Bits 26-31 = 5: Fill pattern = horizontal fill');
          $06: FDetails.Add('Bits 26-31 = 6: Fill pattern = vertical fill');
          $07: FDetails.Add('Bits 26-31 = 7: Fill pattern = backslash fill');
          $08: FDetails.Add('Bits 26-31 = 8: Fill pattern = slash fill');
          $09: FDetails.Add('Bits 26-31 = 9: Fill pattern = coarse medium fill');
          $0A: FDetails.Add('Bits 26-31 = 10: Fill pattern = coarse medium horiz fill');
          $0B: FDetails.Add('Bits 26-31 = 11: Fill pattern = sparse horizontal fill');
          $0C: FDetails.Add('Bits 26-31 = 12: Fill pattern = sparse vertical fill');
          $0D: FDetails.Add('Bits 26-31 = 13: Fill pattern = sparse backslash fill');
          $0E: FDetails.Add('Bits 26-31 = 14: Fill pattern = sparse slash fill');
          $0F: FDetails.Add('Bits 26-31 = 15: Fill pattern = cross fill');
          $10: FDetails.Add('Bits 26-31 = 16: Fill pattern = dense backslash fill');
          $11: FDetails.Add('Bits 26-31 = 17: Fill pattern = very sparse fill');
          $12: FDetails.Add('Bits 26-31 = 18: Fill pattern = extremely sparse fill');
        end;
      end;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x', [dw]),
        'Cell border lines and background area (cont''d)');

      numBytes := 2;
      Move(FBuffer[FBufferIndex], w, numbytes);
      w := WordLEToN(w);
      if Row = FCurrRow then begin
        FDetails.Add('Cell border lines and background area (cont''d):'#13);
        FDetails.Add(Format('Bits 0-6 = %d: Color index for pattern color',  [(w and $007F)]));
        FDetails.Add(Format('Bits 7-13 = %d: Color index for pattern background color', [(w and $3F80) shr 7]));
      end;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]),
        'Cell border lines and background area (cont''d)');
    end;

    if FFormat = sfExcel5 then begin
      numBytes := 4;
      Move(FBuffer[FBufferIndex], dw, numBytes);
      dw := DWordLEToN(dw);
      if Row = FCurrRow then begin
        FDetails.Add('Cell border lines and background area:'#13);
        FDetails.Add(Format('Bits 0-6 = %d: Color index for pattern color',  [(dw and $007F)]));
        FDetails.Add(Format('Bits 7-13 = %d: Color index for pattern background color', [(dw and $3F80) shr 7]));
        case (dw and $003F0000) shr 16 of
          $00: FDetails.Add('Bits 16-21 = 0: Fill pattern = No fill');
          $01: FDetails.Add('Bits 16-21 = 1: Fill pattern = solid fill');
          $02: FDetails.Add('Bits 16-21 = 2: Fill pattern = medium fill');
          $03: FDetails.Add('Bits 16-21 = 3: Fill pattern = dense fill');
          $04: FDetails.Add('Bits 16-21 = 4: Fill pattern = sparse fill');
          $05: FDetails.Add('Bits 16-21 = 5: Fill pattern = horizontal fill');
          $06: FDetails.Add('Bits 16-21 = 6: Fill pattern = vertical fill');
          $07: FDetails.Add('Bits 16-21 = 7: Fill pattern = backslash fill');
          $08: FDetails.Add('Bits 16-21 = 8: Fill pattern = slash fill');
          $09: FDetails.Add('Bits 16-21 = 9: Fill pattern = coarse medium fill');
          $0A: FDetails.Add('Bits 16-21 = 10: Fill pattern = coarse medium horiz fill');
          $0B: FDetails.Add('Bits 16-21 = 11: Fill pattern = sparse horizontal fill');
          $0C: FDetails.Add('Bits 16-21 = 12: Fill pattern = sparse vertical fill');
          $0D: FDetails.Add('Bits 16-21 = 13: Fill pattern = sparse backslash fill');
          $0E: FDetails.Add('Bits 16-21 = 14: Fill pattern = sparse slash fill');
          $0F: FDetails.Add('Bits 16-21 = 15: Fill pattern = cross fill');
          $10: FDetails.Add('Bits 16-21 = 16: Fill pattern = dense backslash fill');
          $11: FDetails.Add('Bits 16-21 = 17: Fill pattern = very sparse fill');
          $12: FDetails.Add('Bits 16-21 = 18: Fill pattern = extremely sparse fill');
        end;
        case dw and $01C00000 shr 22 of
          $0: FDetails.Add('Bits 22-24 = 0: Bottom line style = No line');
          $1: FDetails.Add('Bits 22-24 = 1: Bottom line style = thin solid line');
          $2: FDetails.Add('Bits 22-24 = 2: Bottom line style = medium solid line');
          $3: FDetails.Add('Bits 22-24 = 3: Bottom line style = dashed line');
          $4: FDetails.Add('Bits 22-24 = 4: Bottom line style = dotted line');
          $5: FDetails.Add('Bits 22-24 = 5: Bottom line style = thick solid line');
          $6: FDetails.Add('Bits 22-24 = 6: Bottom line style = double solid line');
          $7: FDetails.Add('Bits 22-24 = 7: Bottom line style = hair line');
        end;
        FDetails.Add(Format('Bits 25-31 = %d: Color index for bottom line color', [(dw and $FE000000) shr 25]));
      end;
      ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.8x', [dw]),
        'Cell border lines & background area');

      numBytes := 4;
      Move(FBuffer[FBufferIndex], dw, numBytes);
      dw := DWOrdLEToN(dw);
      if Row = FCurrRow then begin
        FDetails.Add('Cell border lines (cont''d):'#13);
        case dw and $00000007 of
          $00: FDetails.Add('Bits 0-2 = 0: Top border = No line');
          $01: FDetails.Add('Bits 0-2 = 1: Top border = thin solid line');
          $02: FDetails.Add('Bits 0-2 = 2: Top border = medium solid line');
          $03: FDetails.Add('Bits 0-2 = 3: Top border = dashed line');
          $04: FDetails.Add('Bits 0-2 = 4: Top border = dotted line');
          $05: FDetails.Add('Bits 0-2 = 5: Top border = thick solid line');
          $06: FDetails.Add('Bits 0-2 = 6: Top border = double solid line');
          $07: FDetails.Add('Bits 0-2 = 7: Top border = hair line');
        end;
        case (dw and $00000038) shr 3 of
          $0000: FDetails.Add('Bits 3-5 = 0: Left border = No line');
          $0001: FDetails.Add('Bits 3-5 = 1: Left border = thin solid line');
          $0002: FDetails.Add('Bits 3-5 = 2: Left border = medium solid line');
          $0003: FDetails.Add('Bits 3-5 = 3: Left border = dashed line');
          $0004: FDetails.Add('Bits 3-5 = 4: Left border = dotted line');
          $0005: FDetails.Add('Bits 3-5 = 5: Left border = thick solid line');
          $0006: FDetails.Add('Bits 3-5 = 6: Left border = double solid line');
          $0007: FDetails.Add('Bits 3-5 = 7: Left border = hair line');
        end;
        case (dw and $000001C0) shr 6 of
          $0000: FDetails.Add('Bits 6-8 = 0: Right border = No line');
          $0010: FDetails.Add('Bits 6-8 = 1: Right border = thin solid line');
          $0020: FDetails.Add('Bits 6-8 = 2: Right border = medium solid line');
          $0030: FDetails.Add('Bits 6-8 = 3: Right border = dashed line');
          $0040: FDetails.Add('Bits 6-8 = 4: Right border = dotted line');
          $0050: FDetails.Add('Bits 6-8 = 5: Right border = thick solid line');
          $0060: FDetails.Add('Bits 6-8 = 6: Right border = double solid line');
          $0070: FDetails.Add('Bits 6-8 = 7: Right border = hair line');
        end;
        FDetails.Add(Format('Bits 9-15 = %d: Color index for top line color', [(dw and $0000FE00) shr 7]));
        FDetails.Add(Format('Bits 16-22 = %d: Color index for left line color', [(dw and $007F0000) shr 16]));
        FDetails.Add(Format('Bits 23-29 = %d: Color index for right line color', [(dw and $3F800000) shr 23]));
      end;
      ShowInRow(FCurrRow, FBufferIndex, numBytes, Format('$%.8x', [dw]),
        'Cell border lines (cont''d)');
    end;
  end;
end;


procedure TBIFFGrid.ShowXFCRC;
var
  numBytes: Integer;
  w: Word;
  dw: DWord;
begin
  RowCount := FixedRows + 7;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [wordLEToN(w)]),
    'Future record type');

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Attributes:'#13);
    if w and $0001 = 0
      then FDetails.Add('  Bit 0 = 0: The containing record does not specify a range of cells.')
      else FDetails.Add('x Bit 0 = 1: The containing record specifies a range of cells.');
    FDetails.Add('Bit 1: specifies wether to alert the user of possible problems '+
      'when saving the file whithout having reckognized this record.');
    FDetails.Add('Bits 2-15: reserved (MUST be zero, MUST be ignored)');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]),
    'Attributes');

  numbytes := 4;
  Move(FBuffer[FBufferIndex], dw, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)), 'Reserved');
  Move(FBuffer[FBufferIndex], dw, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)), 'Reserved');

  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]), 'Reserved');

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Count of XF records');

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.4x)', [w,w]),
    'Checksum of XF records');
end;


procedure TBIFFGrid.ShowXFEXT;
var
  numBytes: Integer;
  w: Word;
  dw: DWord;
  i, n: Integer;
  et: Word;
  es: Word;
  ct: Word;
  buffidx: Cardinal;
  s: String;
begin
  BeginUpdate;

  RowCount := FixedRows + 100;

  numBytes := 2;
  Move(FBuffer[FBufferIndex], w, numBytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [wordLEToN(w)]),
    'Future record type');

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  if Row = FCurrRow then begin
    FDetails.Add('Attributes:'#13);
    if w and $0001 = 0
      then FDetails.Add('  Bit 0 = 0: The containing record does not specify a range of cells.')
      else FDetails.Add('x Bit 0 = 1: The containing record specifies a range of cells.');
    FDetails.Add('Bit 1: specifies wether to alert the user of possible problems '+
      'when saving the file whithout having reckognized this record.');
    FDetails.Add('Bits 2-15: reserved (MUST be zero, MUST be ignored)');
  end;
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]),
    'Attributes');

  numbytes := 4;
  Move(FBuffer[FBufferIndex], dw, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)), 'Reserved');
  Move(FBuffer[FBufferIndex], dw, numbytes);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(DWordLEToN(dw)), 'Reserved');

  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]), 'Reserved');

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.4x)', [w,w]),
    'XF index');

  numbytes := 2;
  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('$%.4x', [w]), 'Reserved');

  Move(FBuffer[FBufferIndex], w, numbytes);
  w := WordLEToN(w);
  ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
    'Number of extension properties');
  n := w;

  for i:=1 to n do begin
    buffidx := FBufferIndex;
    numbytes := 2;
    Move(FBuffer[FBufferIndex], et, numbytes);
    et := WordLEToN(et);
    if Row = FCurrRow then begin
      FDetails.Add('Type:'#13);
      case et of
        $04: FDetails.Add('Full color extension that specifies the cell interior foreground color.');
        $05: FDetails.Add('Full color extension that specifies the cell interior background color.');
        $06: FDetails.Add('Gradient extension that specifies a cell interior gradient fill.');
        $07: FDetails.Add('Full color extension that specifies the top cell border color.');
        $08: FDetails.Add('Full color extension that specifies the bottom cell border color.');
        $09: FDetails.Add('Full color extension that specifies the left cell border color.');
        $0A: FDetails.Add('Full color extension that specifies the right cell border color.');
        $0B: FDetails.Add('Full color extension that specifies the diagonal cell border color.');
        $0D: FDetails.Add('Full color extension that specifies the cell text color.');
        $0E: FDetails.Add('2-byte unsigned integer that specifies a font scheme.');
        $0F: FDetails.Add('2-byte unsigned integer that specifies the text indentation level (MUST be <= 250).');
      end;
    end;
    ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.4x)', [et, et]),
      Format('Extension property #%d: Type', [i]));
    Move(FBuffer[FBufferIndex], es, numbytes);
    es := WordLEToN(es);
    ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(es),
      Format('Extension property #%d: Data size', [i]));

    case et of
      $04, $05, $07..$0D:  // FullColorExt
        begin
          numbytes := 2;
          Move(FBuffer[FBufferIndex], ct, numbytes);
          ct := WordLEToN(ct);
          if Row = FCurrRow then begin
            FDetails.Add('Full color extension - Color type:'#13);
            case ct of
              0: FDetails.Add('0 - Automatic color');
              1: FDetails.Add('1 - Indexed color');
              2: FDetails.Add('2 - RGB color');
              3: FDetails.Add('3 - Theme color');
              4: FDetails.Add('4 - Color not set');
            end;
          end;
          ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(ct),
            Format('Extension property #%d (Full color extension): Color type', [i]));
          numbytes := 2;
          Move(FBuffer[FBufferIndex], w, numbytes);
          w := WordLEToN(w);
          ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(integer(w)),
            Format('Extension property #%d (Full color extension): Color tint', [i]));
          numbytes := 4;
          Move(FBuffer[FBufferIndex], dw, numbytes);
          dw := DWordLEToN(dw);
          case ct of
            0: s := '(dummy - MUST be 0)';
            1: s := '(index)';
            2: s := '(RGB value)';
            3: s := '(theme)';
            else s := '';
          end;
          ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.8x)', [QWord(dw), QWord(dw)]),
            Format('Extension property #%d (Full color extension): value %s', [i, s]));
          numbytes := 4;
          Move(FBuffer[FBufferIndex], dw, numbytes);
          dw := DWordLEToN(dw);
          ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.8x)', [QWord(dw), QWord(dw)]),
            Format('Extension property #%d (Full color extension): Reserved', [i]));
          Move(FBuffer[FBufferIndex], dw, numbytes);
          dw := DWordLEToN(dw);
          ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.8x)', [QWord(dw), QWord(dw)]),
            Format('Extension property #%d (Full color extension): Reserved', [i]));
        end;

      $06:  // Gradient
        begin
          ShowInRow(FCurrRow, FBufferIndex, es, '(var)',
            Format('Extension property #%d (Gradient): - not interpreted here -', [i]));
        end;

      $0E:  // Font scheme
        begin
          numbytes := 2;
          Move(FBuffer[FBufferIndex], w, numbytes);
          w := WordLEToN(w);
          if Row = FCurrRow then begin
            FDetails.Add('Font scheme:'#13);
            case w of
              0: FDetails.Add('0 - No font scheme');
              1: FDetails.Add('1 - Major scheme');
              2: FDetails.Add('2 - Minor scheme');
              3: FDetails.Add('3 - Ninched scheme');
            end;
          end;
          ShowInRow(FCurrRow, FBufferIndex, numbytes, Format('%d ($%.4x)', [w,w]),
            Format('Extension property #%d Font scheme', [i]));
        end;

      $0F:   // Text indentation level
        begin
          numbytes := 2;
          Move(FBuffer[FBufferIndex], w, numbytes);
          w := WordLEToN(w);
          ShowInRow(FCurrRow, FBufferIndex, numbytes, IntToStr(w),
            Format('Extension property #%d Text indentation level', [i]));
        end;
    end;
    FBufferIndex := buffidx + es;
  end;
  RowCount := FCurrRow;

  EndUpdate(true);
end;


end.