recordstorage2.pas

一个经典的读写Excel的控件

procedure TRecordStorageGlobals.UpdateDefault(Header: TBIFFHeader; Data: PByteArray);
begin
  case Header.RecID of
    BIFFRECID_CODEPAGE:         UpdateRec(PCODEPAGE,Header,Data);
    BIFFRECID_DSF:              UpdateRec(PDSF,Header,Data);
    BIFFRECID_TABID:            UpdateRec(PTABID,Header,Data);
    BIFFRECID_FNGROUPCOUNT:     UpdateRec(PFNGROUPCOUNT,Header,Data);
    BIFFRECID_WRITEACCESS:      UpdateRec(PWRITEACCESS,Header,Data);
    BIFFRECID_WINDOWPROTECT:    UpdateRec(PWINDOWPROTECT,Header,Data);
    BIFFRECID_PROTECT:          UpdateRec(PPROTECT,Header,Data);
    BIFFRECID_PASSWORD:         UpdateRec(PPASSWORD,Header,Data);
    BIFFRECID_PROT4REV:         UpdateRec(PPROT4REV,Header,Data);
    BIFFRECID_WINDOW1:          UpdateRec(PWINDOW1,Header,Data);
    BIFFRECID_HIDEOBJ:          UpdateRec(PHIDEOBJ,Header,Data);
    BIFFRECID_1904:             UpdateRec(P1904,Header,Data);
    BIFFRECID_BACKUP:           UpdateRec(PBACKUP,Header,Data);
    BIFFRECID_PRECISION:        UpdateRec(PPRECISION,Header,Data);
    BIFFRECID_REFRESHALL:       UpdateRec(PREFRESHALL,Header,Data);
    BIFFRECID_BOOKBOOL:         UpdateRec(PBOOKBOOL,Header,Data);
    BIFFRECID_COUNTRY:          UpdateRec(PCOUNTRY,Header,Data);
    BIFFRECID_RECALCID:         UpdateRec(PRECALCID,Header,Data);
    BIFFRECID_EOF:              UpdateRec(PEOF,Header,Data);
    else begin
      if (Header.RecID and $FF) = BIFFRECID_BOF then
        UpdateRec(PBOF,Header,Data)
      else
        raise Exception.CreateFmt('[int] Unknown default record %.4X',[Header.RecID]);
    end;
  end;
end;

procedure TRecordStorageGlobals.Clear;
begin
  inherited Clear;
end;

function TRecordStorageGlobals.PostCheck: integer;
begin
  Result := 0;
end;

function TRecordStorageGlobals.GetBACKUP: boolean;
begin
  Result := PWordArray(@PBACKUP.Data)[0] = 1;
end;

function TRecordStorageGlobals.GetBOOKBOOL: boolean;
begin
  Result := PWordArray(@PBOOKBOOL.Data)[0] = 1;
end;

function TRecordStorageGlobals.GetCODEPAGE: word;
begin
  Result := PWordArray(@PCODEPAGE.Data)[0];
end;

function TRecordStorageGlobals.GetCOUNTRY: PRecCOUNTRY;
begin
  Result := PRecCOUNTRY(@PCOUNTRY.Data);
end;

function TRecordStorageGlobals.GetRECALCID: PRecRECALCID;
begin
  Result := PRecRECALCID(@PRECALCID.Data);
end;
function TRecordStorageGlobals.GetHIDEOBJ: word;
begin
  Result := PWordArray(@PHIDEOBJ.Data)[0];
end;

function TRecordStorageGlobals.GetPRECISION: boolean;
begin
  Result := PWordArray(@PPRECISION.Data)[0] = 1;
end;

function TRecordStorageGlobals.GetREFRESHALL: boolean;
begin
  Result := PWordArray(@PREFRESHALL.Data)[0] = 1;
end;

function TRecordStorageGlobals.GetWINDOW1: PRecWINDOW1;
begin
  Result := PRecWINDOW1(@PWINDOW1.Data);
end;

function TRecordStorageGlobals.GetWINDOWPROTECT: boolean;
begin
  Result := PWordArray(@PWINDOWPROTECT.Data)[0] = 1;
end;

function TRecordStorageGlobals.GetWRITEACCESS: string;
begin
  SetLength(Result,109);
  System.Move(PWRITEACCESS.Data[3],Pointer(Result)^,109);
  Result := Trim(Result);
end;

procedure TRecordStorageGlobals.SetBACKUP(const Value: boolean);
begin
  PWordArray(@PBACKUP.Data)[0] := Word(Value);
end;

procedure TRecordStorageGlobals.SetBOOKBOOL(const Value: boolean);
begin
  PWordArray(@PBOOKBOOL.Data)[0] := Word(Value);
end;

procedure TRecordStorageGlobals.SetCODEPAGE(const Value: word);
begin
  PWordArray(@PCODEPAGE.Data)[0] := Value;
end;

procedure TRecordStorageGlobals.SetDefaultData;
begin
  Clear;

  PBOF := AddDefRec($0809,SizeOf(TRecBOF8));
  BOF.VersionNumber := $0600;
  BOF.BuildIdentifier := $18AF;
  BOF.BuildYear := $07CD;
  BOF.FileHistoryFlags := $000080C9;
  BOF.LowBIFF := $00000106;
  BOF.SubstreamType := $0005;

  PWRITEACCESS := AddDefRec(BIFFRECID_WRITEACCESS,112);
  WRITEACCESS  := '';

  PCODEPAGE := AddDefRecWord(BIFFRECID_CODEPAGE,$04B0);
  PDSF := AddDefRecWord(BIFFRECID_DSF,$0000);
  PTABID := AddDefRec(BIFFRECID_TABID,0);
  PFNGROUPCOUNT := AddDefRecWord(BIFFRECID_FNGROUPCOUNT,$000E);

  PWINDOWPROTECT := AddDefRecWord(BIFFRECID_WINDOWPROTECT,$0000);
  PPROTECT := AddDefRecWord(BIFFRECID_PROTECT,$0000);
  PPASSWORD := AddDefRecWord(BIFFRECID_PASSWORD,$0000);
  PPROT4REV := AddDefRecWord(BIFFRECID_PROT4REV,$0000);

  PWINDOW1 := AddDefRec(BIFFRECID_WINDOW1,SizeOf(TRecWINDOW1));
  WINDOW1.Left := 100;
  WINDOW1.Top := 100;
  WINDOW1.Width := 10000;
  WINDOW1.Height := 7000;
  WINDOW1.Options := $0038;
  WINDOW1.SelectedTabIndex := 0;
  WINDOW1.FirstDispTabIndex := 0;
  WINDOW1.SelectedTabs := 1;
  WINDOW1.TabRatio := $0258;

  PBACKUP := AddDefRecWord(BIFFRECID_BACKUP,0);
  PHIDEOBJ := AddDefRecWord(BIFFRECID_HIDEOBJ,0);
  P1904 := AddDefRecWord(BIFFRECID_1904,0);
  PPRECISION := AddDefRecWord(BIFFRECID_PRECISION,1);
  PREFRESHALL := AddDefRecWord(BIFFRECID_REFRESHALL,0);
  PBOOKBOOL := AddDefRecWord(BIFFRECID_BOOKBOOL,0);

  P_INT_FORMATS := AddDefRec(INTERNAL_FORMATS,0);
  P_INT_BOUNDSHEETS := AddDefRec(INTERNAL_BOUNDSHEETS,0);

  PCOUNTRY := AddDefRec(BIFFRECID_COUNTRY,SizeOf(TRecCOUNTRY));
  COUNTRY.DefaultCountryIndex := $0001;
  COUNTRY.WinIniCountry := $002E;

// According to MS doc's, this record shall only be written by excel, but if
// it's missing, excel asks if "changes shall be saved" when the file containes
// formulas. $00FFFFFF seems to be the highest possible value.
  PRECALCID := AddDefRec(BIFFRECID_RECALCID,SizeOf(TRecRECALCID));
  RECALCID.RecordIdRepeated := BIFFRECID_RECALCID;
  RECALCID.Reserved := 0;
  RECALCID.RecalcEngineId := $00FFFFFF;

  P_INT_NAMES := AddDefRec(INTERNAL_NAMES,0);
  P_INT_MSODRWGRP := AddDefRec(INTERNAL_MSODRWGRP,0);
  P_INT_SST := AddDefRec(INTERNAL_SST,0);

  PEOF := AddDefRec(BIFFRECID_EOF,0);
end;

procedure TRecordStorageGlobals.SetHIDEOBJ(const Value: word);
begin
  PWordArray(@PHIDEOBJ.Data)[0] := Value
end;

procedure TRecordStorageGlobals.SetRECISION(const Value: boolean);
begin
  PWordArray(@PPRECISION.Data)[0] := Word(Value);
end;

procedure TRecordStorageGlobals.SetREFRESHALL(const Value: boolean);
begin
  PWordArray(@PREFRESHALL.Data)[0] := Word(Value);
end;

procedure TRecordStorageGlobals.SetWINDOWPROTECT(const Value: boolean);
begin
  PWordArray(@PWINDOWPROTECT.Data)[0] := Word(Value);
end;

procedure TRecordStorageGlobals.SetWRITEACCESS(const Value: string);
var
  S: string;
begin
  S := Copy(Value,1,109);
  FillChar(PWRITEACCESS.Data[0],112,' ');
  System.Move(Pointer(S)^,PWRITEACCESS.Data[3],Length(S));
  PWRITEACCESS.Data[0] := Length(S);
  PWRITEACCESS.Data[1] := 0;
  PWRITEACCESS.Data[2] := 0;
end;

function TRecordStorageGlobals.GetBOF: PRecBOF8;
begin
  Result := PRecBOF8(@PBOF.Data);
end;

constructor TRecordStorageGlobals.Create;
begin
  inherited Create;
end;

procedure TRecordStorageGlobals.UpdateInternal(Id: word);
begin
  case Id of
    INTERNAL_FORMATS:     UpdateIntRec(P_INT_FORMATS,Id);
    INTERNAL_BOUNDSHEETS: UpdateIntRec(P_INT_BOUNDSHEETS,Id);
    INTERNAL_NAMES:       UpdateIntRec(P_INT_NAMES,Id);
    INTERNAL_MSODRWGRP:   UpdateIntRec(P_INT_MSODRWGRP,Id);
    INTERNAL_SST:         UpdateIntRec(P_INT_SST,Id);
    else
      raise Exception.CreateFmt('[int] Unknown int. default record %.4X',[Id]);
  end;
end;

procedure TRecordStorageGlobals.MoveDefault(Rec, NewRec: PRecordData);
begin
  case Rec.RecId of
    INTERNAL_FORMATS:           P_INT_FORMATS := NewRec;
    INTERNAL_BOUNDSHEETS:       P_INT_BOUNDSHEETS := NewRec;
    INTERNAL_NAMES:             P_INT_NAMES := NewRec;
    INTERNAL_MSODRWGRP:         P_INT_MSODRWGRP := NewRec;
    INTERNAL_SST:               P_INT_SST := NewRec;

    BIFFRECID_CODEPAGE:         PCODEPAGE := NewRec;
    BIFFRECID_DSF:              PDSF := NewRec;
    BIFFRECID_TABID:            PTABID := NewRec;
    BIFFRECID_FNGROUPCOUNT:     PFNGROUPCOUNT := NewRec;
    BIFFRECID_WRITEACCESS:      PWRITEACCESS := NewRec;
    BIFFRECID_WINDOWPROTECT:    PWINDOWPROTECT := NewRec;
    BIFFRECID_PROTECT:          PPROTECT := NewRec;
    BIFFRECID_PASSWORD:         PPASSWORD := NewRec;
    BIFFRECID_PROT4REV:         PPROT4REV := NewRec;
    BIFFRECID_WINDOW1:          PWINDOW1 := NewRec;
    BIFFRECID_HIDEOBJ:          PHIDEOBJ := NewRec;
    BIFFRECID_1904:             P1904 := NewRec;
    BIFFRECID_BACKUP:           PBACKUP := NewRec;
    BIFFRECID_PRECISION:        PPRECISION := NewRec;
    BIFFRECID_REFRESHALL:       PREFRESHALL := NewRec;
    BIFFRECID_BOOKBOOL:         PBOOKBOOL := NewRec;
    BIFFRECID_COUNTRY:          PCOUNTRY := NewRec;
    BIFFRECID_RECALCID:         PRECALCID := NewRec;
    BIFFRECID_EOF:              PEOF := NewRec;
    else
      raise Exception.CreateFmt('[int] Unknown move default record %.4X',[Rec.RecID]);
  end;
end;

{ TRecordStorageSheet }

procedure TRecordStorageSheet.UpdateDefault(Header: TBIFFHeader; Data: PByteArray);
begin
  case Header.RecID of
    BIFFRECID_CALCMODE:         UpdateRec(PCALCMODE,Header,Data);
    BIFFRECID_CALCCOUNT:        UpdateRec(PCALCCOUNT,Header,Data);
    BIFFRECID_REFMODE:          UpdateRec(PREFMODE,Header,Data);
    BIFFRECID_ITERATION:        UpdateRec(PITERATION,Header,Data);
    BIFFRECID_DELTA:            UpdateRec(PDELTA,Header,Data);
    BIFFRECID_SAVERECALC:       UpdateRec(PSAVERECALC,Header,Data);
    BIFFRECID_PRINTGRIDLINES:   UpdateRec(PPRINTGRIDLINES,Header,Data);
    BIFFRECID_PRINTHEADERS:     UpdateRec(PPRINTHEADERS,Header,Data);
    BIFFRECID_GRIDSET:          UpdateRec(PGRIDSET,Header,Data);
    BIFFRECID_GUTS:             UpdateRec(PGUTS,Header,Data);
    BIFFRECID_DEFAULTROWHEIGHT: UpdateRec(PDEFAULTROWHEIGHT,Header,Data);
    BIFFRECID_WSBOOL:           UpdateRec(PWSBOOL,Header,Data);
    BIFFRECID_HCENTER:          UpdateRec(PHCENTER,Header,Data);
    BIFFRECID_VCENTER:          UpdateRec(PVCENTER,Header,Data);
//    BIFFRECID_PLS:              IPLS              := Count - 1;
    BIFFRECID_SETUP:            UpdateRec(PSETUP,Header,Data);
    BIFFRECID_PROTECT:          UpdateRec(PPROTECT,Header,Data);
    BIFFRECID_DEFCOLWIDTH:      UpdateRec(PDEFCOLWIDTH,Header,Data);
    BIFFRECID_DIMENSIONS:       UpdateRec(PDIMENSIONS,Header,Data);
    BIFFRECID_WINDOW2:          UpdateRec(PWINDOW2,Header,Data);
    BIFFRECID_SELECTION:        UpdateRec(PSELECTION,Header,Data);
    BIFFRECID_EOF:              UpdateRec(PEOF,Header,Data);
    else begin
      if (Header.RecID and $FF) = BIFFRECID_BOF then
        UpdateRec(PBOF,Header,Data)
      else
        raise Exception.CreateFmt('[int] Unknown default record %.4X',[Header.RecID]);
    end;
  end;
end;

function TRecordStorageSheet.GetDELTA: double;
begin
  Result := PDouble(@PDELTA.Data)^;
end;

function TRecordStorageSheet.GetCALCMODE: word;
begin
  Result := PWordArray(@PCALCMODE.Data)[0];
end;

procedure TRecordStorageSheet.SetDELTA(const Value: double);
begin
  PDouble(@PDELTA.Data)^ := Value;
end;

procedure TRecordStorageSheet.SetCALCMODE(const Value: word);
begin
  PWordArray(@PCALCMODE.Data)[0] := Value;
end;

procedure TRecordStorageSheet.SetDefaultData;
begin
  Clear;

  PBOF := AddDefRec($0809,SizeOf(TRecBOF8));
  BOF.VersionNumber := $0600;
  BOF.BuildIdentifier := $18AF;
  BOF.BuildYear := $07CD;
  BOF.FileHistoryFlags := $000080C9;
  BOF.LowBIFF := $00000106;
  BOF.SubstreamType := $0010;

  PCALCMODE := AddDefRecWord(BIFFRECID_CALCMODE,$0001);
  PCALCCOUNT := AddDefRecWord(BIFFRECID_CALCCOUNT,$0064);
  PREFMODE := AddDefRecWord(BIFFRECID_REFMODE,$0001);
  PITERATION := AddDefRecWord(BIFFRECID_ITERATION,$0000);

  PDELTA := AddDefRec(BIFFRECID_DELTA,SizeOf(double));
  DELTA := 0.001;

  PSAVERECALC := AddDefRecWord(BIFFRECID_SAVERECALC,$0001);
  PPRINTGRIDLINES := AddDefRecWord(BIFFRECID_PRINTGRIDLINES,$0000);
  PPRINTHEADERS := AddDefRecWord(BIFFRECID_PRINTHEADERS,$0000);
  PGRIDSET := AddDefRecWord(BIFFRECID_GRIDSET,$0001);

  PGUTS := AddDefRec(BIFFRECID_GUTS,SizeOf(TRecGUTS));
  GUTS.SizeRow := 0;
  GUTS.SizeCol := 0;
  GUTS.LevelRow := 0;
  GUTS.LevelCol := 0;

  PDEFAULTROWHEIGHT := AddDefRec(BIFFRECID_DEFAULTROWHEIGHT,SizeOf(TRecDEFAULTROWHEIGHT));
  DEFAULTROWHEIGHT.Options := $0000;
  DEFAULTROWHEIGHT.Height := $00FF;

  PWSBOOL := AddDefRecWord(BIFFRECID_WSBOOL,$04C1);

  P_INT_PAGEBREAKES := AddDefRec(INTERNAL_PAGEBREAKES,0);
  P_INT_HEADER := AddDefRec(INTERNAL_HEADER,0);
  P_INT_MARGINS := AddDefRec(INTERNAL_MARGINS,0);

  PHCENTER := AddDefRecWord(BIFFRECID_HCENTER,$0000);
  PVCENTER := AddDefRecWord(BIFFRECID_VCENTER,$0000);

  PSETUP := AddDefRec(BIFFRECID_SETUP,SizeOf(TRecSETUP));