{ Copyright (c) 1989 by Borland International, Inc. }

unit TCSheet;
{ Turbo Pascal 5.5 object-oriented example spreadsheet routines.
  This unit is used by TCALC.PAS.
  See TCALC.DOC for an more information about this example.
}

{$N+,S-}

interface

uses Crt, Dos, Objects, TCUtil, TCInput, TCScreen, TCLStr, TCHash, TCCell,
     TCCellSp, TCParser;

const
  DefaultMaxCols = 65535;
  DefaultMaxRows = 65535;
  DefaultMaxDecimalPlaces = 8;
  DefaultDefaultDecimalPlaces = 4;
  DefaultDefaultColWidth = 10;
  EmptyRowsAtTop = 1;
  EmptyRowsAtBottom = 2;
  MinColWidth = 3;
  CurrentChar = #4;
  ChangedChar = '*';
  PrintNormalCols = 80;
  PrintCompressedCols = 132;
  PrintRows = 66;
  PrintTopMargin = 1;
  PrintBottomMargin = 1;
  PrinterCompressChar = #15;
  EditYes = True;
  EditNo = False;
  DisplayYes = True;
  DisplayNo = False;
  WasChanged = True;
  NotChanged = False;
  AutoCalcLetter = 'A';
  FormulaDisplayLetter = 'F';
  MemoryString = 'Memory: ';
  FileHeader = 'TurboCalc Spreadsheet'^Z;
  ErrorString = 'ERROR';
  TempFileName = 'TEMP.TMP';  { Temporary file used for rehashing }
  PrinterName = 'PRN';
  PromptFileSave = 'File to save';
  PromptFilePrint = 'File to print to (ENTER = Printer)';
  PromptOverwriteFile = 'The file exists.  Overwrite it';
  PromptCompressPrint = 'Compress the printing';
  PromptBorderPrint = 'Print the borders';
  PromptColumnWidth = 'Column to change';
  PromptNewWidth = 'New width';
  PromptColumnDelete = 'Column to delete';
  PromptColumnInsert = 'Insert new column before column';
  PromptRowDelete = 'Row to delete';
  PromptRowInsert = 'Insert new row before row';
  PromptSaveYN = 'Save spreadsheet';
  ErrNoOpen = 'Cannot open file';
  ErrDiskFull = 'Disk full';
  ErrPrinterError = 'Printer error';
  ErrNotSpreadsheet = 'Not a TurboCalc spreadsheet file';
  MsgRecalc = 'Recalculating cell values';
  MsgSave = 'Saving spreadsheet';
  MsgLoad = 'Loading spreadsheet';
  MsgBlockDelete = 'Deleting block';

type
  ColStartArray = array[0..ScreenCols] of Byte;
  ColStartPtr = ^ColStartArray;
  SpreadsheetPtr = ^Spreadsheet;
  Spreadsheet = object
    Number : Byte;
    MaxRows : Word;
    MaxCols : Word;
    MaxDecimalPlaces : Byte;
    MaxColWidth : Byte;
    MaxScreenCols : Byte;
    DefaultColWidth : Byte;
    DefaultDecimalPlaces : Byte;
    RowNumberSpace : Byte;
    ColSpace : Byte;
    Current : Boolean;
    Changed : Boolean;
    CurrPos : CellPos;
    LastPos : CellPos;
    ScreenBlock : Block;
    CurrBlock : Block;
    BlockOn : Boolean;
    FileName : PathStr;
    TotalRows : ScreenRowRange;
    DisplayArea : ScreenArea;
    ColArea : ScreenArea;
    RowArea : ScreenArea;
    InfoArea : ScreenArea;
    DataArea : ScreenArea;
    ContentsArea : ScreenArea;
    BlankArea : ScreenArea;
    NoBlankArea : Boolean;
    ColStart : ColStartPtr;
    DisplayFormulas : Boolean;
    AutoCalc : Boolean;
    CellHash : CellHashTable;
    OverwriteHash : OverwriteHashTable;
    WidthHash : WidthHashTable;
    FormatHash : FormatHashTable;
    Next : SpreadsheetPtr;
    constructor Init(InitCells : Longint; InitMaxCols, InitMaxRows : Word;
                     InitMaxDecimalPlaces, InitDefaultDecimalPlaces : Byte;
                     InitDefaultColWidth : Byte);
    destructor Done;
    function GetColStart(Col : Word) : Byte;
    procedure SetAreas(NewNumber : Word; X1 : ScreenColRange;
                       Y1 : ScreenRowRange; X2 : ScreenColRange;
                       Y2 : ScreenRowRange);
    procedure DisplayCols;
    procedure DisplayRows;
    procedure DisplayInfo;
    procedure DisplayAllCells;
    procedure Display;
    procedure DisplayCell(P : CellPos);
    procedure DisplayCellData;
    procedure DisplayCellBlock(C1 : Word; R1 : Word; C2 : Word;
                               R2 : Word);
    procedure DisplayBlock(B : Block);
    procedure DisplayBlockDiff(B1, B2 : Block);
    procedure DisplayCol(Col : Word);
    procedure DisplayRow(Row : Word);
    procedure DisplayMemory;
    procedure DisplayFileName;
    procedure SetChanged(IsChanged : Boolean);
    procedure MakeCurrent;
    procedure MakeNotCurrent;
    procedure Update(UDisplay : Boolean);
    procedure ToggleFormulaDisplay;
    procedure SetScreenColStart(NewCol : Word);
    procedure SetScreenColStop(NewCol: Word);
    procedure SetScreenRowStart(NewRow : Word);
    procedure SetScreenRowStop(NewRow : Word);
    procedure FindScreenColStart;
    procedure FindScreenColStop;
    procedure FindScreenRowStart;
    procedure FindScreenRowStop;
    procedure SetBlankArea;
    function AddCell(CellType : CellTypes; P : CellPos; E : Boolean;
                     V : Extended; I : LStringPtr) : Boolean;
    procedure DeleteCell(P : CellPos; var Deleted : Boolean);
    procedure DeleteBlock(B : Block; var Deleted : Boolean);
    function CellToFString(P : CellPos; var Color : Byte) : String;
    procedure SetLastPos(DPos : CellPos);
    function GetCurrCol : Word;
    function GetCurrRow : Word;
    function ColToX(Col : Word) : Byte;
    function RowToY(Row : Word) : Byte;
    function ColWidth(Col : Word) : Byte;
    function SameCellPos(P1, P2 : CellPos) : Boolean;
    procedure FixOverwrite;
    function FromFile(Name : PathStr) : Boolean;
    procedure ToFile(Name : PathStr);
    procedure CheckForSave;
    procedure ChangeWidth;
    function CellHashStart(TotalCells : Longint) : BucketRange;
    function WidthHashStart(TotalCells : Longint) : BucketRange;
    function OverwriteHashStart(TotalCells : Longint) : BucketRange;
    procedure Print;
    procedure DeleteColumn;
    procedure InsertColumn;
    procedure DeleteRow;
    procedure InsertRow;
  end;

function GetColWidth(var WHash : WidthHashTable; C : Word) : Byte;

implementation

function GetColWidth(var WHash : WidthHashTable; C : Word) : Byte;
{ Returns the width of a column }
var
  W : Word;
begin
  W := WHash.Search(C);
  if W = 0 then
    GetColWidth := WHash.GetDefaultColWidth
  else
    GetColWidth := W;
end; { GetColWidth }

constructor Spreadsheet.Init(InitCells : Longint; InitMaxCols,
                             InitMaxRows : Word; InitMaxDecimalPlaces,
                             InitDefaultDecimalPlaces : Byte;
                             InitDefaultColWidth : Byte);
{ Sets up a new spreadsheet }
begin
  if not CellHash.Init(CellHashStart(InitCells)) then
    Fail;
  if not WidthHash.Init(WidthHashStart(InitCells), InitDefaultColWidth) then
  begin
    CellHash.Done;
    Fail;
  end;
  if not OverwriteHash.Init(OverwriteHashStart(InitCells)) then
  begin
    CellHash.Done;
    WidthHash.Done;
    Fail;
  end;
  if not FormatHash.Init then
  begin
    CellHash.Done;
    WidthHash.Done;
    OverwriteHash.Done;
    Fail;
  end;
  MaxCols := InitMaxCols;
  MaxRows := InitMaxRows;
  RowNumberSpace := Ord(MaxRows >= 10000) + Ord(MaxRows >= 1000) +
                    Ord(MaxRows >= 100) + Ord(MaxRows >= 10) + 2;
  MaxColWidth := ScreenCols - RowNumberSpace;
  MaxScreenCols := MaxColWidth div MinColWidth;
  GetMem(ColStart, MaxScreenCols);
  if ColStart = nil then
  begin
    CellHash.Done;
    WidthHash.Done;
    OverwriteHash.Done;
    FormatHash.Done;
    Fail;
  end;
  CurrPos.Col := 1;
  CurrPos.Row := 1;
  LastPos := CurrPos;
  BlockOn := False;
  FileName := '';
  DisplayFormulas := False;
  AutoCalc := False;
  Current := False;
  Changed := False;
  ScreenBlock.Start.Col := 1;
  ScreenBlock.Start.Row := 1;
  ColSpace := Succ(Ord(MaxCols >= 18279) + Ord(MaxCols >= 703) +
                   Ord(MaxCols >= 27));
  MaxDecimalPlaces := InitMaxDecimalPlaces;
  DefaultColWidth := InitDefaultColWidth;
  DefaultDecimalPlaces := InitDefaultDecimalPlaces;
end; { Spreadsheet.Init }

destructor Spreadsheet.Done;
{ Removes a spreadsheet from memory }
begin
  CellHash.Done;
  WidthHash.Done;
  OverwriteHash.Done;
  FormatHash.Done;
  FreeMem(ColStart, MaxScreenCols);
end; { Spreadsheet.Done }

function Spreadsheet.GetColStart(Col : Word) : Byte;
begin
  GetColStart := ColStart^[Col];
end; { Spreadsheet.GetColStart }

procedure Spreadsheet.SetAreas(NewNumber : Word; X1 : ScreenColRange;
                               Y1 : ScreenRowRange; X2 : ScreenColRange;
                               Y2 : ScreenRowRange);
{ Sets up a spreadsheet's display areas }
begin
  Number := NewNumber;
  TotalRows := Y2 - Y1 - 2;
  ColArea.Init(X1 + RowNumberSpace, Y1, X2, Y1, Colors.ColColor);
  RowArea.Init(X1, Succ(Y1), Pred(X1 + RowNumberSpace), Y2 - 2,
               Colors.RowColor);
  InfoArea.Init(X1, Y1, Pred(X1 + RowNumberSpace), Y1, Colors.InfoColor);
  DisplayArea.Init(X1 + RowNumberSpace, Succ(Y1), X2, Y2 - 2,
                   Colors.BlankColor);
  DataArea.Init(X1, Pred(Y2), X2, Pred(Y2), Colors.BlankColor);
  ContentsArea.Init(X1, Y2, X2, Y2, Colors.ContentsColor);
  SetScreenColStart(ScreenBlock.Start.Col);
  SetScreenRowStart(ScreenBlock.Start.Row);
  SetBlankArea;
end; { Spreadsheet.SetAreas }

procedure Spreadsheet.DisplayCols;
{ Shows the column headings }
var
  C : Word;
begin
  ColArea.Clear;
  with ScreenBlock do
  begin
    for C := Start.Col to Stop.Col do
      WriteXY(CenterStr(ColToString(C), ColWidth(C)),
              ColStart^[C - Start.Col], ColArea.UpperLeft.Row,
              Colors.ColColor);
  end; { with }
end; { Spreadsheet.DisplayCols }

procedure Spreadsheet.DisplayRows;
{ Shows the row headings }
var
  R : Word;
begin
  RowArea.Clear;
  with ScreenBlock do
  begin
    for R := Start.Row to Stop.Row do
      with RowArea do
        WriteXY(LeftJustStr(RowToString(R), RowNumberSpace),
                UpperLeft.Col, R - Start.Row + UpperLeft.Row,
                Colors.RowColor);
  end; { with }
end; { Spreadsheet.DisplayRows }

procedure Spreadsheet.DisplayInfo;
{ Shows the spreadsheet number, current dot, and state of AutoCalc and
  formula display }
begin
  InfoArea.Clear;
  with InfoArea do
    WriteXY(NumToString(Number), UpperLeft.Col, UpperLeft.Row,
                Colors.InfoColor);
  if Current then
    Write(CurrentChar)
  else
    Write(' ');
  if AutoCalc then
    Write(AutoCalcLetter)
  else
    Write(' ');
  if DisplayFormulas then
    Write(FormulaDisplayLetter)
  else
    Write(' ');
end; { Spreadsheet.DisplayRows }

procedure Spreadsheet.DisplayAllCells;
{ Displays all of the cells on the screen }
begin
  DisplayArea.Clear;
  DisplayBlock(ScreenBlock);
end; { Spreadsheet.DisplayAllCells }

procedure Spreadsheet.DisplayCell(P : CellPos);
{ Displays a single cell }
var
  S : String[ScreenCols];
  Color : Byte;
begin
  S := CellToFString(P, Color);
  WriteXY(S, ColToX(P.Col), RowToY(P.Row), Color);
end; { Spreadsheet.DisplayCell }

procedure Spreadsheet.DisplayCellData;
{ Displays information about a cell - its type and its contents }
var
  CP : CellPtr;
begin
  CP := CellHash.Search(CurrPos);
  with DataArea do
    WriteXY(LeftJustStr(ColToString(CurrPos.Col) +
                RowToString(CurrPos.Row) + ' ' + CP^.Name, 19),
                UpperLeft.Col, UpperLeft.Row, Colors.CellDataColor);
  with ContentsArea do
  begin
    Clear;
    WriteXY(LeftJustStr(CP^.DisplayString(DisplayFormulas,
                MaxDecimalPlaces), Scr.CurrCols), UpperLeft.Col,
                UpperLeft.Row, Colors.ContentsColor);
  end; { with }
end; { Spreadsheet.DisplayCellData }

procedure Spreadsheet.DisplayCellBlock(C1 : Word; R1 : Word;
                                       C2 : Word; R2 : Word);
{ Displays all cells within a range of rows and columns }
var
  P : CellPos;
begin
  with ScreenBlock do
  begin
    for P.Row := Max(R1, Start.Row) to Min(R2, Stop.Row) do
    begin
      for P.Col := Max(C1, Start.Col) to Min(C2, Stop.Col) do
        DisplayCell(P);
    end;
  end; { with }
end; { Spreadsheet.DisplayCellBlock }

procedure Spreadsheet.DisplayBlock(B : Block);
{ Displays all cells within a certain block }
begin
  with B do
    DisplayCellBlock(Start.Col, Start.Row, Stop.Col, Stop.Row);
end; { Spreadsheet.DisplayBlock }

procedure Spreadsheet.DisplayBlockDiff(B1, B2 : Block);
{ When a block is extended, this will update the screen to show the new
  block }
var
  B : Block;
  DisplayMiddle : Boolean;
begin
  if Compare(B1, B2, SizeOf(Block)) then
    Exit;
  with B do
  begin
    DisplayMiddle := False;
    if B1.Stop.Col <> B2.Stop.Col then
    begin
      B.Start.Row := B1.Start.Row;
      B.Start.Col := Min(Succ(B1.Stop.Col), Succ(B2.Stop.Col));
      B.Stop.Row := Min(B1.Stop.Row, B2.Stop.Row);
      B.Stop.Col := Max(B1.Stop.Col, B2.Stop.Col);
      DisplayBlock(B);
      DisplayMiddle := True;
    end;
    if B1.Stop.Row <> B2.Stop.Row then
    begin
      B.Start.Row := Min(Succ(B1.Stop.Row), Succ(B2.Stop.Row));
      B.Start.Col := B1.Start.Col;
      B.Stop.Row := Max(B1.Stop.Row, B2.Stop.Row);
      B.Stop.Col := Min(B1.Stop.Col, B2.Stop.Col);
      DisplayBlock(B);
      DisplayMiddle := True;
    end;
    if DisplayMiddle then
    begin
      B.Start.Row := Min(Succ(B1.Stop.Row), Succ(B2.Stop.Row));
      B.Start.Col := Min(Succ(B1.Stop.Col), Succ(B2.Stop.Col));
      B.Stop.Row := Max(B1.Stop.Row, B2.Stop.Row);
      B.Stop.Col := Max(B1.Stop.Col, B2.Stop.Col);
      DisplayBlock(B);
    end;
  end; { with }
end; { Spreadsheet.DisplayBlockDiff }

procedure Spreadsheet.DisplayCol(Col : Word);
{ Display a column of cells }
begin
  with ScreenBlock do
    DisplayCellBlock(Col, Start.Row, Col, Stop.Row);
end; { Spreadsheet.DisplayCol }

procedure Spreadsheet.DisplayRow(Row : Word);
{ Display a row of cells }
begin
  with ScreenBlock do
    DisplayCellBlock(Start.Col, Row, Stop.Col, Row);
end; { Spreadsheet.DisplayRow }

procedure Spreadsheet.DisplayMemory;
{ Display the amount of free memory }
begin
  WriteXY(RightJustStr(NumToString(MemAvail), 6), Scr.CurrCols - 5, 1,
          Colors.MemoryColor);
end; { Spreadsheet.DisplayMemory }

procedure Spreadsheet.DisplayFileName;
{ Display the spreadsheet's file name, and whether or not it has been
  updated }
var
  S : PathStr;
begin
  with DataArea do
  begin
    if FileName = '' then
      S := 'No file'
    else
      S := FExpand(FileName);
    WriteXY(LeftJustStr(S, LowerRight.Col - UpperLeft.Col - 20),
            UpperLeft.Col + 21, UpperLeft.Row, Colors.FileNameColor);
  end; { with }
end; { Spreadsheet.DisplayFileName }

procedure Spreadsheet.Display;
{ Display the entire spreadsheet }
begin
  DisplayCols;
  DisplayRows;
  DisplayInfo;
  DisplayAllCells;
  DisplayMemory;
  DisplayCellData;
  DisplayFileName;
  SetChanged(Changed);
end; { Spreadsheet.Display }

procedure Spreadsheet.SetChanged(IsChanged : Boolean);
{ Sets a spreadsheet as being changed or not changed }
var
  C : Char;
begin
  Changed := IsChanged;
  if Changed then
    C := ChangedChar
  else
    C := ' ';
  with DataArea.UpperLeft do
    WriteXY(C, Col + 19, Row, Colors.ChangedColor);
end; { Spreadsheet.SetChanged }

procedure Spreadsheet.MakeCurrent;
{ Make a spreadsheet the current one }
begin
  Current := True;
  DisplayInfo;
end; { Spreadsheet.MakeCurrent }

procedure Spreadsheet.MakeNotCurrent;
{ Make a spreadsheet not the current one }
begin
  Current := False;
  DisplayInfo;
end; { Spreadsheet.MakeNotCurrent }

procedure Spreadsheet.Update(UDisplay : Boolean);
{ Update any cells in the spreadsheet that need updating }
var
  P, U : CellPos;
  CP : CellPtr;
  O : Word;
begin
  Scr.PrintMessage(MsgRecalc);
  with CellHash do
  begin
    for P.Row := 1 to LastPos.Row do
    begin
      for P.Col := 1 to LastPos.Col do
      begin
        CP := Search(P);
        if CP^.ShouldUpdate then
        begin
          with FormulaCellPtr(CP)^ do
          begin
            Parser.Init(@CellHash, Formula, MaxCols, MaxRows);
            Parser.Parse;
            Value := Parser.ParseValue;
            Error := Parser.ParseError;
            O := CP^.Overwritten(CellHash, FormatHash, WidthHash,
                 LastPos, MaxCols, GetColWidth, DisplayFormulas);
            if (OverwriteHash.Change(CP, O)) and UDisplay and
               (CP^.Loc.Col + O >= ScreenBlock.Start.Col) then
            begin
              U := CP^.Loc;
              for U.Col := CP^.Loc.Col to ScreenBlock.Stop.Col do
              begin
                if ScreenBlock.CellInBlock(U) then
                DisplayCell(U);
              end;
            end;
          end; { with }
        end;
      end;
    end;
  end; { with }
  if UDisplay then
    DisplayMemory;
  Scr.ClearMessage;
end; { Spreadsheet.Update }

procedure Spreadsheet.ToggleFormulaDisplay;
{ Change from showing formulas to showing values and vice versa }
var
  CP : CellPtr;
  OChanged : Boolean;
begin
  DisplayFormulas := not DisplayFormulas;
  DisplayInfo;
  OChanged := True;
  with CellHash do
  begin
    CP := FirstItem;
    while (CP <> nil) and OChanged do
    begin
      if CP^.ShouldUpdate then
        OChanged := OverwriteHash.Change(CP, CP^.Overwritten(CellHash,
                                         FormatHash, WidthHash, LastPos,
                                         MaxCols, GetColWidth,
                                         DisplayFormulas));
      CP := NextItem;
    end;
  end; { with }
  DisplayAllCells;
  DisplayMemory;
end; { Spreadsheet.ToggleFormulaDisplay }

procedure Spreadsheet.SetScreenColStart(NewCol : Word);
{ Find the starting screen column }
begin
  ScreenBlock.Start.Col := NewCol;
  FindScreenColStop;
  FindScreenColStart;
end; { Spreadsheet.SetScreenColStart }

procedure Spreadsheet.SetScreenColStop(NewCol : Word);
{ Find the ending screen column }
begin
  ScreenBlock.Stop.Col := NewCol;
  FindScreenColStart;
  FindScreenColStop;
end; { Spreadsheet.SetScreenColStop }

procedure Spreadsheet.SetScreenRowStart(NewRow : Word);
{ Find the starting screen row }
begin
  ScreenBlock.Start.Row := NewRow;
  FindScreenRowStop;
end; { Spreadsheet.SetScreenRowStart }

procedure Spreadsheet.SetScreenRowStop(NewRow : Word);
{ Find the ending screen row }
begin
  ScreenBlock.Stop.Row := NewRow;
  FindScreenRowStart;
end; { Spreadsheet.SetScreenRowStop }

procedure Spreadsheet.FindScreenColStart;
{ Find the starting screen column when the ending column is known }
var
  Index, Place : Integer;
  Temp, Width : Byte;
begin
  with ScreenBlock do
  begin
    Index := 0;
    Place := Succ(DisplayArea.LowerRight.Col);
    Width := ColWidth(Stop.Col);
    repeat
      ColStart^[Index] := Place - Width;
      Dec(Place, Width);
      Inc(Index);
      if Stop.Col - Index = 0 then
        Width := 0
      else
        Width := ColWidth(Stop.Col - Index);
    until (Width = 0) or (Place - Width < DisplayArea.UpperLeft.Col);
    Start.Col := Succ(Stop.Col - Index);
    Dec(Index);
    if ColStart^[Index] <> DisplayArea.UpperLeft.Col then
    begin
      Temp := ColStart^[Index] - DisplayArea.UpperLeft.Col;
      for Place := 0 to Index do
        Dec(ColStart^[Place], Temp);
    end;
    if Index > 0 then
    begin
      for Place := 0 to (Pred(Index) shr 1) do
      begin
        Temp := ColStart^[Index - Place];
        ColStart^[Index - Place] := ColStart^[Place];
        ColStart^[Place] := Temp;
      end;
    end;
  end; { with }
end; { Spreadsheet.FindScreenColStart }

procedure Spreadsheet.FindScreenColStop;
{ Find the ending screen column when the starting column is known }
var
  Index, Place : Byte;
  Width : Byte;
begin
  with ScreenBlock do
  begin
    Index := 0;
    Place := DisplayArea.UpperLeft.Col;
    Width := ColWidth(Start.Col);
    repeat
      ColStart^[Index] := Place;
      Inc(Place, Width);
      Inc(Index);
      if Longint(Index) + Start.Col > MaxCols then
        Width := 0
      else
        Width := ColWidth(Index + Start.Col);
    until (Width = 0) or (Place + Width > Succ(DisplayArea.LowerRight.Col));
    Stop.Col := Pred(Start.Col + Index);
  end; { with }
end; { Spreadsheet.FindScreenColStop }

procedure Spreadsheet.FindScreenRowStart;
{ Find the starting screen row when the ending row is known }
begin
  with ScreenBlock do
  begin
    if Longint(Stop.Row) - TotalRows < 0 then
    begin
      Start.Row := 1;
      FindScreenRowStop;
    end
    else
      Start.Row := Succ(Stop.Row - TotalRows);
  end; { with }
end; { Spreadsheet.FindScreenRowStart }

procedure Spreadsheet.FindScreenRowStop;
{ Find the ending screen row when the starting row is known }
begin
  with ScreenBlock do
  begin
    if Longint(Start.Row) + TotalRows > Succ(LongInt(MaxRows)) then
    begin
      Stop.Row := MaxRows;
      FindScreenRowStart;
    end
    else
      Stop.Row := Pred(Start.Row + TotalRows);
  end; { with }
end; { Spreadsheet.FindScreenRowStop }

procedure Spreadsheet.SetBlankArea;
{ Find the size of the blank area (the area at the right edge of the
  spreadsheet that is not used }
var
  C : Word;
begin
  with BlankArea do
  begin
    Move(DisplayArea, BlankArea, SizeOf(DisplayArea));
    with ScreenBlock do
      C := ColStart^[Stop.Col - Start.Col] + ColWidth(Stop.Col);
    if C > DisplayArea.LowerRight.Col then
      NoBlankArea := True
    else begin
      NoBlankArea := False;
      UpperLeft.Col := C;
    end;
  end; { with }
end; { Spreadsheet.SetBlankArea }

function Spreadsheet.AddCell(CellType : CellTypes; P : CellPos; E : Boolean;
                             V : Extended; I : LStringPtr) : Boolean;
{ Add a new cell to the spreadsheet }
var
  CP, S : CellPtr;
  OldLastPos : CellPos;
  Good : Boolean;
begin
  AddCell := False;
  case CellType of
    ClValue : CP := New(ValueCellPtr, Init(P, E, V));
    ClFormula : CP := New(FormulaCellPtr, Init(P, E, V, I));
    ClText : CP := New(TextCellPtr, Init(P, I));
    ClRepeat : CP := New(RepeatCellPtr, Init(P, I^.Data^[2]));
  end; { case }
  if CP = nil then
    Exit;
  if not CellHash.Add(CP) then
  begin
    Dispose(CP, Done);
    Exit;
  end;
  OldLastPos := LastPos;
  LastPos.Col := Max(P.Col, LastPos.Col);
  LastPos.Row := Max(P.Row, LastPos.Row);
  if not OverwriteHash.Add(CP, CP^.Overwritten(CellHash, FormatHash,
                           WidthHash, LastPos, MaxCols, GetColWidth,
                           DisplayFormulas)) then
  begin
    LastPos := OldLastPos;
    CellHash.Delete(CP^.Loc, S);
    Dispose(CP, Done);
    Exit;
  end;
  S := OverwriteHash.Search(CP^.Loc);
  if S <> Empty then
    Good := OverwriteHash.Change(S, S^.Overwritten(CellHash, FormatHash,
                                 WidthHash, LastPos, MaxCols, GetColWidth,
                                 DisplayFormulas));
  AddCell := True;
end; { Spreadsheet.AddCell }

procedure Spreadsheet.DeleteCell(P : CellPos; var Deleted : Boolean);
{ Delete a cell from the spreadsheet }
var
  CP : CellPtr;
  Good : Boolean;
begin
  CellHash.Delete(P, CP);
  if CP <> nil then
  begin
    Dispose(CP, Done);
    OverwriteHash.Delete(P);
    if P.Col > 1 then
    begin
      Dec(P.Col);
      CP := OverwriteHash.Search(P);
      if CP = Empty then
        CP := CellHash.Search(P);
      if CP <> Empty then
        Good := OverwriteHash.Change(CP, CP^.Overwritten(CellHash,
                                     FormatHash, WidthHash, LastPos, MaxCols,
                                     GetColWidth, DisplayFormulas));
    end;
    Deleted := True;
  end
  else
    Deleted := False;
end; { Spreadsheet.DeleteCell }

procedure Spreadsheet.DeleteBlock(B : Block; var Deleted : Boolean);
{ Delete a block of cells from the spreadsheet }
var
  P : CellPos;
  H, D : HashItemPtr;
  Counter : Word;
  CP : CellPtr;
begin
  Scr.PrintMessage(MsgBlockDelete);
  Deleted := False;
  with CellHash, B do
  begin
    for Counter := 1 to Buckets do
    begin
      H := HashData^[Counter];
      while H <> nil do
      begin
        D := H;
        H := H^.Next;
        Move(D^.Data, CP, SizeOf(CP));
        with CP^ do
        begin
          if CellInBlock(Loc) then
            DeleteCell(Loc, Deleted);
        end; { with }
      end;
    end;
  end; { with }
  Scr.ClearMessage;
end; { DeleteBlock }

function Spreadsheet.CellToFString(P : CellPos; var Color : Byte) : String;
{ Create a formatted string from a cell }
var
  CP : CellPtr;
  S : String;
  S1 : DollarStr;
  F : FormatType;
  ColorFound : Boolean;
  Colr : Byte;
begin
  ColorFound := True;
  if Current and (SameCellPos(P, CurrPos)) then
    Color := Colors.HighlightColor
  else if BlockOn and (CurrBlock.CellInBlock(P)) then
    Color := Colors.BlockColor
  else
    ColorFound := False;
  CP := CellHash.Search(P);
  if (CP^.HasError) then
  begin
    S := ErrorString;
    S1 := '';
    if ColorFound then
      Inc(Color, Blink)
    else
      Color := Colors.CellErrorColor;
    F := Ord(JCenter) shl JustShift;
  end
  else begin
    S := CP^.FormattedString(OverwriteHash, FormatHash, WidthHash,
                             GetColWidth, P, DisplayFormulas, 1,
                             ColWidth(P.Col), S1, Colr);
    if not ColorFound then
      Color := Colr;
    F := CP^.Format(FormatHash, DisplayFormulas);
  end;
  case Justification((F shr JustShift) and JustPart) of
    JLeft : CellToFString := S1 + LeftJustStr(S, ColWidth(P.Col) -
                                             Length(S1));
    JCenter : CellToFString := S1 + CenterStr(S, ColWidth(P.Col) -
                                              Length(S1));
    JRight : CellToFString := S1 + RightJustStr(S, ColWidth(P.Col) -
                                                Length(S1));
  end; { case }
end; { Spreadsheet.CellToFString }

procedure Spreadsheet.SetLastPos(DPos : CellPos);
{ Find the last position used in a spreadsheet }
var
  CP : CellPtr;
  Counter : Word;
  ColFound, RowFound : Boolean;
begin
  with CellHash do
  begin
    ColFound := DPos.Col < LastPos.Col;
    RowFound := DPos.Row < LastPos.Row;
    if (not ColFound) or (not RowFound) then
    begin
      if not ColFound then
        LastPos.Col := 1;
      if not RowFound then
        LastPos.Row := 1;
      CP := FirstItem;
      while CP <> nil do
      begin
        if not ColFound then
        begin
          if CP^.Loc.Col > LastPos.Col then
          begin
            LastPos.Col := CP^.Loc.Col;
            ColFound := LastPos.Col = DPos.Col;
            if ColFound and RowFound then
              Exit;
          end;
        end;
        if not RowFound then
        begin
          if CP^.Loc.Row > LastPos.Row then
          begin
            LastPos.Row := CP^.Loc.Row;
            RowFound := LastPos.Row = DPos.Row;
            if ColFound and RowFound then
              Exit;
          end;
        end;
        CP := NextItem;
      end;
    end;
  end; { with }
end; { Spreadsheet.SetLastPos }

function Spreadsheet.GetCurrCol : Word;
{ Find the current column }
begin
  GetCurrCol := CurrPos.Col;
end; { Spreadsheet.GetCurrCol }

function Spreadsheet.GetCurrRow : Word;
{ Find the current row }
begin
  GetCurrRow := CurrPos.Row;
end; { Spreadsheet.GetCurrRow }

function Spreadsheet.ColToX(Col : Word) : Byte;
{ Find where on the screen a column starts }
begin
  ColToX := ColStart^[Col - ScreenBlock.Start.Col];
end; { Spreadsheet.ColToX }

function Spreadsheet.RowToY(Row : Word) : Byte;
{ Find where on the screen a row starts }
begin
  RowToY := Row + DisplayArea.UpperLeft.Row - ScreenBlock.Start.Row;
end; { Spreadsheet.RowToY }

{$F+}

function Spreadsheet.ColWidth(Col : Word) : Byte;
{ Returns the width of a column }
var
  Width : Word;
begin
  Width := WidthHash.Search(Col);
  if Width = 0 then
    ColWidth := DefaultColWidth
  else
    ColWidth := Width;
end; { Spreadsheet.ColWidth }

{$F-}

function Spreadsheet.SameCellPos(P1, P2 : CellPos) : Boolean;
{ Returns True if two cells are at the same position }
begin
  SameCellPos := Compare(P1, P2, SizeOf(CellPos));
end; { Spreadsheet.SameCellPos }

procedure Spreadsheet.FixOverwrite;
{ Fixes the overwrite hash table when the formats have been changed }
var
  CP, D : CellPtr;
  Counter : Word;
  Good : Boolean;
begin
  with CellHash do
  begin
    CP := FirstItem;
    while CP <> nil do
    begin
      if not OverwriteHash.Add(CP, CP^.Overwritten(CellHash, FormatHash,
                               WidthHash, LastPos, MaxCols, GetColWidth,
                               DisplayFormulas)) then
      begin
        CellHash.Delete(CP^.Loc, D);
        Dispose(CP, Done);
        Exit;
      end;
      CP := OverwriteHash.Search(CP^.Loc);
      if CP <> Empty then
        Good := OverwriteHash.Change(CP, CP^.Overwritten(CellHash,
                                     FormatHash, WidthHash, LastPos,
                                     MaxCols, GetColWidth,
                                     DisplayFormulas));
      CP := NextItem;
    end;
  end; { with }
end; { Spreadsheet.FixOverwrite }

function Spreadsheet.FromFile(Name : PathStr) : Boolean;
{ Reads a spreadsheet from disk }
var
  Header : String[Length(FileHeader)];
  TotalC : Longint;
  TotalW : Word;
  TotalF : Longint;
  S : SSStream;
  NewLastPos : CellPos;
begin
  FromFile := True;
  Name := UpperCase(Name);
  S.Init(Name, SOpen);
  if S.Status <> 0 then
  begin
    Scr.PrintError(ErrNoOpen);
    Init(0, DefaultMaxCols, DefaultMaxRows, DefaultMaxDecimalPlaces,
         DefaultDefaultDecimalPlaces, DefaultDefaultColWidth);
    Exit;
  end
  else begin
    Header[0] := Chr(Length(FileHeader));
    S.Read(Header[1], Length(FileHeader));
    if (S.Status <> 0) or (Header <> FileHeader) then
    begin
      Scr.PrintError(ErrNotSpreadsheet);
      S.Done;
      Init(0, DefaultMaxCols, DefaultMaxRows, DefaultMaxDecimalPlaces,
           DefaultDefaultDecimalPlaces, DefaultDefaultColWidth);
      Exit;
    end;
    FileName := Name;
    S.Read(NewLastPos, SizeOf(NewLastPos));
    S.Read(TotalW, SizeOf(TotalW));
    S.Read(TotalF, SizeOf(TotalF));
    S.Read(TotalC, SizeOf(TotalC));
    if not Init(TotalC, DefaultMaxCols, DefaultMaxRows,
                DefaultMaxDecimalPlaces, DefaultDefaultDecimalPlaces,
                DefaultDefaultColWidth) then
    begin
      S.Done;
      FromFile := False;
      Exit;
    end;
    LastPos := NewLastPos;
    Scr.PrintMessage(MsgLoad);
    FileName := Name;
    WidthHash.Load(S, TotalW);
    FormatHash.Load(S, TotalF);
    CellHash.Load(S, TotalC);
    S.Done;
    FixOverwrite;
    Update(DisplayNo);
    Scr.ClearMessage;
  end;
  FromFile := True;
end; { Spreadsheet.FromFile }

procedure Spreadsheet.ToFile(Name : PathStr);
{ Writes a spreadsheet to disk }
var
  Header : String[Length(FileHeader)];
  S : SSStream;
begin
  S.Init(Name, SCreate);
  if S.Status <> 0 then
  begin
    Scr.PrintError(ErrNoOpen);
    Exit;
  end;
  Scr.PrintMessage(MsgSave);
  FileName := Name;
  Header := FileHeader;
  S.Write(Header[1], Length(Header));
  S.Write(LastPos, SizeOf(LastPos));
  S.Write(WidthHash.Items, 2);
  S.Write(FormatHash.Items, SizeOf(FormatHash.Items));
  S.Write(CellHash.Items, SizeOf(CellHash.Items));
  WidthHash.Store(S);
  FormatHash.Store(S);
  CellHash.Store(S);
  Scr.ClearMessage;
  S.Done;
  if S.Status <> 0 then
    Scr.PrintError(ErrDiskFull)
  else
    SetChanged(NotChanged);
end; { Spreadsheet.ToFile }

procedure Spreadsheet.CheckForSave;
{ Before prompting for a file name, this will check to see if you want to
  save the spreadsheet }
var
  S : PathStr;
  GoodFile, ESCPressed : Boolean;
begin
  if Changed and (GetYesNo(PromptSaveYN, ESCPressed)) then
  begin
    S := FileName;
    repeat
      GoodFile := True;
      if S = '' then
      begin
        S := ReadString(PromptFileSave, Pred(SizeOf(PathStr)), ESCPressed);
        if S = '' then
          Exit;
      end;
      if FileExists(S) then
      begin
        GoodFile := GetYesNo(PromptOverwriteFile, ESCPressed);
        if ESCPressed then
          Exit;
        if not GoodFile then
          S := '';
      end;
    until GoodFile;
    ToFile(S);
  end;
end; { Spreadsheet.CheckForSave }

procedure Spreadsheet.ChangeWidth;
{ Changes the width of a column }
var
  W, C : Word;
  Good : Boolean;
  P : CellPos;
  O : Word;
  CP : CellPtr;
begin
  C := GetColumn(PromptColumnWidth, MaxCols, ColSpace);
  if C = 0 then
    Exit;
  W := GetNumber(PromptNewWidth, MinColWidth, MaxColWidth, Good);
  if not Good then
    Exit;
  with WidthHash do
  begin
    Delete(C);
                if W <> DefaultColWidth then
                        Good := Add(C, W);
  end; { with }
  if not Good then
    Exit;
  SetScreenColStart(ScreenBlock.Start.Col);
  SetChanged(WasChanged);
  with OverwriteHash do
  begin
    Done;
    Init(OverwriteHashStart(CellHash.Items));
  end;
  with CellHash do
  begin
    CP := FirstItem;
    while CP <> nil do
    begin
      O := CP^.Overwritten(CellHash, FormatHash, WidthHash, LastPos,
                           MaxCols, GetColWidth, DisplayFormulas);
      if O <> 0 then
        Good := OverwriteHash.Add(CP, O);
      CP := NextItem;
    end;
  end; { with }
  if CurrPos.Col > ScreenBlock.Stop.Col then
    SetScreenColStart(CurrPos.Col);
  Display;
end; { Spreadsheet.ChangeWidth }

function Spreadsheet.CellHashStart(TotalCells : Longint) : BucketRange;
{ Formula that determines the number of cell hash table buckets }
begin
  CellHashStart := Max(100, Min(MaxBuckets, TotalCells div 10));
end; { Spreadsheet.CellHashStart }

function Spreadsheet.WidthHashStart(TotalCells : Longint) : BucketRange;
{ Formula that determines the number of width hash table buckets }
begin
  WidthHashStart := 10;
end; { Spreadsheet.WidthHashStart }

function Spreadsheet.OverwriteHashStart(TotalCells : Longint) : BucketRange;
{ Formula that determines the number of overwrite hash table buckets }
begin
  OverwriteHashStart := 10;
end; { Spreadsheet.OverwriteHashStart }

procedure Spreadsheet.Print;
{ Prints a spreadsheet to a file or a printer }
var
  S : PathStr;
  F : Text;
  PageCols : Byte;
  PageV, PageH : Word;
  Finished, GoodFile, Error, Compress, Border, ESCPressed : Boolean;
  StartCol : Word;
  StartRow : Word;

  procedure WString(S : String);
  begin
    Writeln(F, S);
    if IOResult <> 0 then
    begin
      if S = PrinterName then
        Scr.PrintError(ErrPrinterError)
      else
        Scr.PrintError(ErrDiskFull);
      Error := True;
      Finished := True;
    end;
  end; { WString }

  function RowStartString(Row : Word) : String;
  begin
    if (PageH = 1) and Border then
      RowStartString := LeftJustStr(RowToString(Row), RowNumberSpace)
    else
      RowStartString := '';
  end; { RowStartString }

  procedure PrintPage;
  var
    Counter : Word;
    S : String;
    Color, Cols, Rows : Byte;
    P : CellPos;
  begin
    for Counter := 1 to PrintTopMargin do
    begin
      WString('');
      if Error then
        Exit;
    end;
    Rows := Min(PrintRows - PrintTopMargin - PrintBottomMargin,
                Succ(MaxRows - StartRow));
    if Border then
      Dec(Rows);
    Cols := 0;
    Counter := Length(RowStartString(StartRow));
    while Counter <= PageCols do
    begin
      Inc(Counter, ColWidth(Cols + StartCol));
      Inc(Cols);
    end;
    Dec(Cols);
    Cols := Min(Cols, Succ(MaxCols - StartCol));
    if Border and (PageV = 1) then
    begin
      S := FillString(Length(RowStartString(StartRow)), ' ');
      for Counter := StartCol to Pred(StartCol + Cols) do
        S := S + CenterStr(ColToString(Counter), ColWidth(Counter));
      WString(S);
      if Error then
        Exit;
    end;
    for P.Row := StartRow to Pred(StartRow + Rows) do
    begin
      S := RowStartString(P.Row);
      for P.Col := StartCol to Pred(StartCol + Cols) do
        S := S + CellToFString(P, Color);
      WString(S);
      if Error then
        Exit;
    end;
    Inc(StartCol, Cols);
    if (StartCol > LastPos.Col) or (StartCol = 0) then
    begin
      Inc(StartRow, Rows);
      if (StartRow > LastPos.Row) or (StartRow = 0) then
        Finished := True
      else begin
        Inc(PageV);
        PageH := 1;
        StartCol := 1;
      end;
    end
    else
      Inc(PageH);
    Write(F, Chr(FF));
  end; { PrintPage }

begin { Spreadsheet.Print }
  repeat
    GoodFile := True;
    S := ReadString(PromptFilePrint, Pred(SizeOf(PathStr)), ESCPressed);
    if ESCPressed then
      Exit;
    if S = '' then
      S := PrinterName
    else begin
      if FileExists(S) then
      begin
        GoodFile := GetYesNo(PromptOverwriteFile, ESCPressed);
        if ESCPressed then
          Exit;
      end;
    end;
  until GoodFile;
  Compress := GetYesNo(PromptCompressPrint, ESCPressed);
  if ESCPressed then
    Exit;
  Border := GetYesNo(PromptBorderPrint, ESCPressed);
  if ESCPressed then
    Exit;
  Error := False;
{$I-}
  Assign(F, S);
  Rewrite(F);
  if IOResult <> 0 then
  begin
    Scr.PrintError(ErrNoOpen);
    Exit;
  end;
  if Compress then
  begin
    PageCols := PrintCompressedCols;
    Write(F, PrinterCompressChar);
  end
  else
    PageCols := PrintNormalCols;
  PageV := 1;
  PageH := 1;
  StartCol := 1;
  StartRow := 1;
  Finished := False;
  repeat
    PrintPage;
  until Finished;
  Close(F);
{$I+}
end; { Spreadsheet.Print }

procedure Spreadsheet.DeleteColumn;
{ Deletes a column from the spreadsheet }
var
  C : Word;
  Start, Stop, P, OldPos, OldSPos : CellPos;
  Deleted : Boolean;
  OldName : PathStr;
  CP : CellPtr;
  H : HashItemPtr;
  B : Block;
  F : File;
  Good : Boolean;
begin
  C := GetColumn(PromptColumnDelete, MaxCols, ColSpace);
  if C = 0 then
    Exit;
  OldPos := CurrPos;
  OldSPos := ScreenBlock.Start;
  P.Col := C;
  Deleted := False;
  if P.Col <= LastPos.Col then
  begin
    with B do
    begin
      Start.Col := P.Col;
      Start.Row := 1;
      Stop.Col := P.Col;
      Stop.Row := LastPos.Row;
      Good := FormatHash.Delete(Start, Stop);
    end; { with }
    DeleteBlock(B, Deleted);
  end;
  Dec(LastPos.Col);
  WidthHash.Delete(C);
  with CellHash do
  begin
    CP := FirstItem;
    while CP <> nil do
    begin
      with CP^ do
      begin
        if Loc.Col > C then
          Dec(Loc.Col);
        if (CP^.ShouldUpdate) and (Loc.Col > C) then
          FixFormulaCol(CP, -1, MaxCols, MaxRows);
      end; { with }
      CP := NextItem;
    end;
  end; { with }
  with WidthHash do
  begin
    H := FirstItem;
    while H <> nil do
    begin
      if WordPtr(@H^.Data)^ > C then
        Dec(WordPtr(@H^.Data)^);
      H := NextItem;
    end;
  end; { with }
  with FormatHash do
  begin
    H := FirstItem;
    while H <> nil do
    begin
      Move(H^.Data, Start, SizeOf(Start));
      Move(H^.Data[SizeOf(CellPos)], Stop, SizeOf(Stop));
      if (Start.Col = C) and (Stop.Col = C) then
        Good := Delete(Start, Stop)
      else begin
        if Start.Col > C then
        begin
          Dec(Start.Col);
          Move(Start, H^.Data, SizeOf(Start));
        end;
        if Stop.Col > C then
        begin
          Dec(Stop.Col);
          Move(Stop, H^.Data[SizeOf(CellPos)], SizeOf(Stop));
        end;
      end;
      H := NextItem;
    end;
  end; { with }
  OldName := FileName;
  ToFile(TempFileName);
  Done;
  Good := FromFile(TempFileName);
  Assign(F, TempFileName);
  Erase(F);
  FileName := OldName;
  if Deleted then
    P.Row := LastPos.Row
  else
    P.Row := 1;
  Dec(P.Col);
  SetLastPos(P);
  MakeCurrent;
  SetChanged(WasChanged);
  CurrPos := OldPos;
  SetScreenColStart(OldSPos.Col);
  SetScreenRowStart(OldSPos.Row);
  Display;
end; { Spreadsheet.DeleteColumn }

procedure Spreadsheet.InsertColumn;
{ Inserts a column into the spreadsheet }
var
  C : Word;
  Start, Stop, P, OldPos, OldSPos : CellPos;
  Deleted : Boolean;
  H : HashItemPtr;
  OldName : PathStr;
  CP : CellPtr;
  B : Block;
  F : File;
  Good : Boolean;
begin
  C := GetColumn(PromptColumnInsert, MaxCols, ColSpace);
  if C = 0 then
    Exit;
  OldPos := CurrPos;
  OldSPos := ScreenBlock.Start;
  Deleted := False;
  if LastPos.Col = MaxCols then
  begin
    with B do
    begin
      Start.Col := MaxCols;
      Start.Row := 1;
      Stop.Col := MaxCols;
      Stop.Row := LastPos.Row;
      Good := FormatHash.Delete(Start, Stop);
    end; { with }
    DeleteBlock(B, Deleted);
  end
  else
    Inc(LastPos.Col);
  P.Col := C;
  WidthHash.Delete(MaxCols);
  with CellHash do
  begin
    CP := FirstItem;
    while CP <> nil do
    begin
      with CP^ do
      begin
        if Loc.Col >= C then
          Inc(Loc.Col);
        if (CP^.ShouldUpdate) and (Loc.Col >= C) then
          FixFormulaCol(CP, 1, MaxCols, MaxRows);
      end; { with }
      CP := NextItem;
    end;
  end; { with }
  with WidthHash do
  begin
    H := FirstItem;
    while H <> nil do
    begin
      if WordPtr(@H^.Data)^ >= C then
        Inc(WordPtr(@H^.Data)^);
      H := NextItem;
    end;
  end; { with }
  with FormatHash do
  begin
    H := FirstItem;
    while H <> nil do
    begin
      Move(H^.Data, Start, SizeOf(Start));
      Move(H^.Data[SizeOf(CellPos)], Stop, SizeOf(Stop));
      if Start.Col >= C then
      begin
        Inc(Start.Col);
        Move(Start, H^.Data, SizeOf(Start));
      end;
      if Stop.Col >= C then
      begin
        Inc(Stop.Col);
        Move(Stop, H^.Data[SizeOf(CellPos)], SizeOf(Stop));
      end;
      H := NextItem;
    end;
  end; { with }
  OldName := FileName;
  ToFile(TempFileName);
  Done;
  Good := FromFile(TempFileName);
  Assign(F, TempFileName);
  Erase(F);
  FileName := OldName;
  if Deleted then
    P.Row := LastPos.Row
  else
    P.Row := 1;
  if LastPos.Col = MaxCols then
    P.Col := MaxCols
  else
    Inc(P.Col);
  SetLastPos(P);
  MakeCurrent;
  SetChanged(WasChanged);
  CurrPos := OldPos;
  SetScreenColStart(OldSPos.Col);
  SetScreenRowStart(OldSPos.Row);
  Display;
end; { Spreadsheet.InsertColumn }

procedure Spreadsheet.DeleteRow;
{ Deletes a row from the spreadsheet }
var
  R : Word;
  Start, Stop, P, OldPos, OldSPos : CellPos;
  Deleted : Boolean;
  OldName : PathStr;
  CP : CellPtr;
  B : Block;
  F : File;
  Good : Boolean;
  H : HashItemPtr;
begin
  R := GetRow(PromptRowDelete, MaxRows);
  if (R = 0) or (R > LastPos.Row) then
    Exit;
  OldPos := CurrPos;
  OldSPos := ScreenBlock.Start;
  P.Row := R;
  if P.Row <= LastPos.Row then
  begin
    with B do
    begin
      Start.Col := 1;
      Start.Row := P.Row;
      Stop.Col := LastPos.Col;
      Stop.Row := P.Row;
      Good := FormatHash.Delete(Start, Stop);
    end; { with }
    DeleteBlock(B, Deleted);
  end;
  Dec(LastPos.Row);
  with CellHash do
  begin
    CP := FirstItem;
    while CP <> nil do
    begin
      with CP^ do
      begin
        if Loc.Row > R then
          Dec(Loc.Row);
        if (CP^.ShouldUpdate) and (Loc.Row > R) then
          FixFormulaRow(CP, -1, MaxCols, MaxRows);
      end; { with }
      CP := NextItem;
    end;
  end; { with }
  with FormatHash do
  begin
    H := FirstItem;
    while H <> nil do
    begin
      Move(H^.Data, Start, SizeOf(Start));
      Move(H^.Data[SizeOf(CellPos)], Stop, SizeOf(Stop));
      if (Start.Row = R) and (Stop.Row = R) then
        Good := Delete(Start, Stop)
      else begin
        if Start.Row > R then
        begin
          Dec(Start.Row);
          Move(Start, H^.Data, SizeOf(Start));
        end;
        if Stop.Row > R then
        begin
          Dec(Stop.Row);
          Move(Stop, H^.Data[SizeOf(CellPos)], SizeOf(Stop));
        end;
      end;
      H := NextItem;
    end;
  end; { with }
  OldName := FileName;
  ToFile(TempFileName);
  Done;
  Good := FromFile(TempFileName);
  Assign(F, TempFileName);
  Erase(F);
  FileName := OldName;
  if Deleted then
    P.Col := LastPos.Col
  else
    P.Col := 1;
  Dec(P.Row);
  SetLastPos(P);
  MakeCurrent;
  SetChanged(WasChanged);
  CurrPos := OldPos;
  SetScreenColStart(OldSPos.Col);
  SetScreenRowStart(OldSPos.Row);
  Display;
end; { Spreadsheet.DeleteRow }

procedure Spreadsheet.InsertRow;
{ Inserts a row into the spreadsheet }
var
  R : Word;
  Start, Stop, P, OldPos, OldSPos : CellPos;
  Deleted : Boolean;
  OldName : PathStr;
  CP : CellPtr;
  B : Block;
  F : File;
  Good : Boolean;
  H : HashItemPtr;
begin
  R := GetRow(PromptRowInsert, MaxRows);
  if (R = 0) or (R > LastPos.Row) then
    Exit;
  OldPos := CurrPos;
  OldSPos := ScreenBlock.Start;
  if LastPos.Row = MaxRows then
  begin
    with B do
    begin
      Start.Col := 1;
      Start.Row := MaxRows;
      Stop.Col := LastPos.Col;
      Stop.Row := MaxRows;
      Good := FormatHash.Delete(Start, Stop);
    end; { with }
    DeleteBlock(B, Deleted);
  end
  else
    Inc(LastPos.Row);
  P.Row := R;
  with CellHash do
  begin
    CP := FirstItem;
    while CP <> nil do
    begin
      with CP^ do
      begin
        if Loc.Row >= R then
          Inc(Loc.Row);
        if (CP^.ShouldUpdate) and (Loc.Row >= R) then
          FixFormulaRow(CP, 1, MaxCols, MaxRows);
      end; { with }
      CP := NextItem;
    end;
  end; { with }
  with FormatHash do
  begin
    H := FirstItem;
    while H <> nil do
    begin
      Move(H^.Data, Start, SizeOf(Start));
      Move(H^.Data[SizeOf(CellPos)], Stop, SizeOf(Stop));
      if Start.Row >= R then
      begin
        Inc(Start.Row);
        Move(Start, H^.Data, SizeOf(Start));
      end;
      if Stop.Row >= R then
      begin
        Inc(Stop.Row);
        Move(Stop, H^.Data[SizeOf(CellPos)], SizeOf(Stop));
      end;
      H := NextItem;
    end;
  end; { with }
  OldName := FileName;
  ToFile(TempFileName);
  Done;
  Good := FromFile(TempFileName);
  Assign(F, TempFileName);
  Erase(F);
  FileName := OldName;
  if Deleted then
    P.Col := LastPos.Col
  else
    P.Col := 1;
  if LastPos.Row = MaxRows then
    P.Row := MaxRows
  else
    Inc(P.Row);
  SetLastPos(P);
  MakeCurrent;
  SetChanged(WasChanged);
  CurrPos := OldPos;
  SetScreenColStart(OldSPos.Col);
  SetScreenRowStart(OldSPos.Row);
  Display;
end; { Spreadsheet.InsertRow }

end.