DataMuseum.dk

top - metrics - download

    Length: 21324 (0x534c)
    Types: TextFile
    Names: »MCOMMAND.PAS«

└─⟦505fbc898⟧ Bits:30002732 Turbo Pascal 5.0 for C-DOS Partner
    └─⟦this⟧ »MCALC\MCOMMAND.PAS« 

TextFile

æ Copyright (c) 1985, 88 by Borland International, Inc. å

unit MCOMMAND;

interface

uses Crt, Dos, MCVars, MCUtil, MCDisply, MCParser, MCLib, MCInput;

procedure CheckForSave;
æ If the spreadsheet has been changed, will ask the user if they want to
   save it.
å

procedure MoveRowUp;
æ Moves up 1 row å

procedure MoveRowDown;
æ Moves down one row å

procedure MoveColLeft;
æ Moves left one column å

procedure MoveColRight;
æ Moves right one column å

procedure EditCell(ECell : CellPtr);
æ Edits a selected cell å

procedure ClearSheet;
æ Clears the current spreadsheet å

procedure LoadSheet(FileName : IString);
æ Loads a new spreadsheet å

procedure SaveSheet;
æ Saves the current spreadsheet å

function PageRows(Row : Word; TopPage, Border : Boolean) : Word;
æ Returns the number of rows to print å

function PageCols(Col, Columns : Word; Border : Boolean) : Word;
æ Returns the number of columns to print starting at col å

procedure PrintSheet;
æ Prints a copy of the spreadsheet to a file or to the printer å

procedure SetColWidth(Col : Word);
æ Sets the new column width for a selected column å

procedure GotoCell;
æ Moves to a selected cell å

procedure FormatCells;
æ Prompts the user for a selected format and range of cells å

procedure DeleteCol(Col : Word);
æ Deletes a column å

procedure InsertCol(Col : Word);
æ Inserts a column å

procedure DeleteRow(Row : Word);
æ Deletes a row å

procedure InsertRow(Row : Word);
æ Inserts a row å

procedure SMenu;
æ Executes the commands in the spreadsheet menu å

procedure CMenu;
æ Executes the commands in the column menu å

procedure RMenu;
æ Executes the commands in the row menu å

procedure UMenu;
æ Executes the commands in the utility menu å

procedure MainMenu;
æ Executes the commands in the main menu å

implementation

const
  Name : StringÆ80Å = MSGNAME;

var
  Rec : CellRec;

procedure CheckForSave;
var
  Save : Char;
begin
  if Changed and GetYesNo(Save, MSGSAVESHEET) and (Save = 'Y') then
    SaveSheet;
end; æ CheckForSave å

procedure MoveRowUp;
begin
  DisplayCell(CurCol, CurRow, NOHIGHLIGHT, NOUPDATE);
  if CurRow > TopRow then
    Dec(CurRow)
  else if TopRow > 1 then
  begin
    Scroll(DOWN, 1, Succ(LEFTMARGIN), 3, 80, ScreenRows + 2, WHITE);
    Dec(TopRow);
    DisplayRow(TopRow, NOUPDATE);
    Dec(CurRow);
    SetBottomRow;
  end;
end; æ MoveRowUp å

procedure MoveRowDown;
begin
  DisplayCell(CurCol, CurRow, NOHIGHLIGHT, NOUPDATE);
  if CurRow < BottomRow then
    Inc(CurRow)
  else if BottomRow < MAXROWS then
  begin
    Scroll(UP, 1, Succ(LEFTMARGIN), 3, 80, ScreenRows + 2, WHITE);
    Inc(TopRow);
    Inc(CurRow);
    SetBottomRow;
    DisplayRow(BottomRow, NOUPDATE);
  end;
end; æ MoveRowDown å

procedure MoveColLeft;
var
  Col, OldLeftCol : Word;
  OldColStart : arrayÆ1..SCREENCOLSÅ of Byte;
begin
  OldLeftCol := LeftCol;
  Move(ColStart, OldColStart, Sizeof(ColStart));
  DisplayCell(CurCol, CurRow, NOHIGHLIGHT, NOUPDATE);
  if (CurCol > LeftCol) then
    Dec(CurCol)
  else if (LeftCol <> 1) then
  begin
    Dec(CurCol);
    Dec(LeftCol);
    SetRightCol;
    SetLeftCol;
    if OldLeftCol <= RightCol then
      Scroll(RIGHT, Pred(ColStartÆSucc(OldLeftCol - LeftCol)Å - LEFTMARGIN),
             Succ(LEFTMARGIN), 3, 80, ScreenRows + 2, WHITE);
    ClearLastCol;
    for Col := LeftCol to Pred(OldLeftCol) do
      DisplayCol(Col, NOUPDATE);
  end;
end; æ MoveColLeft å

procedure MoveColRight;
var
  Col, OldLeftCol, OldRightCol : Word;
  OldColStart : arrayÆ1..SCREENCOLSÅ of Byte;
begin
  OldLeftCol := LeftCol;
  Move(ColStart, OldColStart, Sizeof(ColStart));
  OldRightCol := RightCol;
  DisplayCell(CurCol, CurRow, NOHIGHLIGHT, NOUPDATE);
  if CurCol < RightCol then
    Inc(CurCol)
  else if RightCol < MAXCOLS then
  begin
    Inc(CurCol);
    Inc(RightCol);
    SetLeftCol;
    SetRightCol;
    if OldRightCol >= LeftCol then
      Scroll(LEFT, Pred(OldColStartÆSucc(LeftCol - OldLeftCol)Å - LEFTMARGIN),
             Succ(LEFTMARGIN), 3, 80, ScreenRows + 2, WHITE);
    ClearLastCol;
    for Col := Succ(OldRightCol) to RightCol do
      DisplayCol(Col, NOUPDATE);
  end;
end; æ MoveColRight å

procedure EditCell;
var
  S : IString;
begin
  if ECell = nil then
    Exit;
  case ECell^.Attrib of
    TXT : S := ECell^.T;
    VALUE : Str(ECell^.Value:1:MAXPLACES, S);
    FORMULA : S := ECell^.Formula;
  end; æ case å
  if (not EditString(S, '', MAXINPUT)) or (S = '') then
    Exit;
  Act(S);
  Changed := True;
end; æ EditCell å

procedure ClearSheet;
var
  Col, Row : Word;
begin
  for Row := 1 to LastRow do
  begin
    for Col := 1 to LastCol do
      DeleteCell(Col, Row, NOUPDATE);
  end;
  InitVars;
  SetRightCol;
  SetBottomRow;
  DisplayScreen(NOUPDATE);
  PrintFreeMem;
  Changed := False;
end; æ ClearSheet å

procedure LoadSheet;
var
  Dummy, Size, RealLastCol, RealLastRow : Word;
  F : File;
  Check : StringÆ80Å;
  Allocated : Boolean;
  Blocks : Word;
  RealSize : Byte;
begin
  RealLastCol := 1;
  RealLastRow := 1;
  if FileName = '' then
  begin
    WritePrompt(MSGFILENAME);
    if not EditString(FileName, '', MAXINPUT) then
      Exit;
  end;
  if not Exists(FileName) then
  begin
    ErrorMsg(MSGNOEXIST);
    Exit;
  end;
  Assign(F, FileName);
  Reset(F, 1);
  if IOResult <> 0 then
  begin
    ErrorMsg(MSGNOOPEN);
    Exit;
  end;
  BlockRead(F, CheckÆ1Å, Length(Name), Blocks);
  CheckÆ0Å := Chr(Length(Name));
  if Check <> Name then
  begin
    ErrorMsg(MSGNOMICROCALC);
    Close(F);
    Exit;
  end;
  BlockRead(F, Size, 1, Blocks);
  BlockRead(F, RealSize, 1, Blocks);
  if RealSize <> SizeOf(Real) then
  begin
    ErrorMsg(MSGBADREALS);
    Close(F);
    Exit;
  end;
  SetColor(PROMPTCOLOR);
  GotoXY(1, ScreenRows + 5);
  Write(MSGLOADING);
  GotoXY(Succ(Length(MSGLOADING)), ScreenRows + 5);
  ClearSheet;
  BlockRead(F, LastCol, SizeOf(LastCol), Blocks);
  BlockRead(F, LastRow, SizeOf(LastRow), Blocks);
  BlockRead(F, Size, SizeOf(Size), Blocks);
  BlockRead(F, ColWidth, Sizeof(ColWidth), Blocks);
  repeat
    BlockRead(F, CurCol, SizeOf(CurCol), Blocks);
    BlockRead(F, CurRow, SizeOf(CurRow), Blocks);
    BlockRead(F, FormatÆCurCol, CurRowÅ, 1, Blocks);
    BlockRead(F, Size, SizeOf(Size), Blocks);
    BlockRead(F, Rec, Size, Blocks);
    case Rec.Attrib of
      TXT : begin
        Allocated := AllocText(CurCol, CurRow, Rec.T);
        if Allocated then
          Dummy := SetOFlags(CurCol, CurRow, NOUPDATE);
      end;
      VALUE : Allocated := AllocValue(CurCol, CurRow, Rec.Value);
      FORMULA : Allocated := AllocFormula(CurCol, CurRow, Rec.Formula,
                                          Rec.Fvalue);
    end; æ case å
    if not Allocated then
    begin
      ErrorMsg(MSGFILELOMEM);
      LastRow := RealLastRow;
      LastCol := RealLastCol;
      FormatÆCurCol, CurRowÅ := DEFAULTFORMAT;
    end
    else begin
      CellÆCurCol, CurRowÅ^.Error := Rec.Error;
      if CurCol > RealLastCol then
        RealLastCol := CurCol;
      if CurRow > RealLastRow then
        RealLastRow := CurRow;
    end;
  until (not Allocated) or (EOF(F));
  PrintFreeMem;
  Close(F);
  CurCol := 1;
  CurRow := 1;
  SetRightCol;
  DisplayScreen(NOUPDATE);
  SetColor(White);
  GotoXY(1, ScreenRows + 5);
  ClrEol;
  Changed := False;
end; æ LoadSheet å

procedure SaveSheet;
var
  FileName : IString;
  EndOfFile, Overwrite : Char;
  Size, Col, Row : Word;
  F : File;
  CPtr : CellPtr;
  Blocks : Word;
  RealSize : Byte;
begin
  EndOfFile := #26;
  FileName := '';
  RealSize := SizeOf(Real);
  WritePrompt(MSGFILENAME);
  if not EditString(FileName, '', MAXINPUT) then
    Exit;
  Assign(F, FileName);
  if Exists(FileName) then
  begin
    if (not GetYesNo(Overwrite, MSGOVERWRITE)) or (Overwrite = 'N') then
      Exit;
    Reset(F, 1);
  end
  else
    Rewrite(F, 1);
  if IOResult <> 0 then
  begin
    ErrorMsg(MSGNOOPEN);
    Exit;
  end;
  SetColor(PROMPTCOLOR);
  GotoXY(1, ScreenRows + 5);
  Write(MSGSAVING);
  GotoXY(Length(MSGSAVING) + 1, ScreenRows + 5);
  BlockWrite(F, NameÆ1Å, Length(Name), Blocks);
  BlockWrite(F, EndOfFile, 1, Blocks);
  BlockWrite(F, RealSize, 1, Blocks);
  BlockWrite(F, LastCol, SizeOf(LastCol), Blocks);
  BlockWrite(F, LastRow, SizeOf(LastRow), Blocks);
  Size := MAXCOLS;
  BlockWrite(F, Size, SizeOf(Size), Blocks);
  BlockWrite(F, ColWidth, Sizeof(ColWidth), Blocks);
  for Row := 1 to LastRow do
  begin
    for Col := LastCol downto 1 do
    begin
      if CellÆCol, RowÅ <> nil then
      begin
        CPtr := CellÆCol, RowÅ;
        case CPtr^.Attrib of
          TXT : Size := Length(CPtr^.T) + 3;
          VALUE : Size := Sizeof(Real) + 2;
          FORMULA : Size := Length(CPtr^.Formula) + Sizeof(Real) + 3;
        end; æ case å
        BlockWrite(F, Col, SizeOf(Col), Blocks);
        BlockWrite(F, Row, SizeOf(Row), Blocks);
        BlockWrite(F, FormatÆCol, RowÅ, 1, Blocks);
        BlockWrite(F, Size, SizeOf(Size), Blocks);
        BlockWrite(F, CPtr^, Size, Blocks);
      end;
    end;
  end;
  Close(F);
  SetColor(White);
  GotoXY(1, ScreenRows + 5);
  ClrEol;
  Changed := False;
end; æ SaveSheet å

function PageRows;
var
  Rows : Word;
begin
  if TopPage then
    Rows := 66 - TOPMARGIN
  else
    Rows := 66;
  if Border then
    Dec(Rows);
  if Pred(Row + Rows) > LastRow then
    PageRows := Succ(LastRow - Row)
  else
    PageRows := Rows;
end; æ PageRows å

function PageCols;
var
  Len : Integer;
  FirstCol : Word;
begin
  if (Col = 1) and Border then
    Len := Columns - LEFTMARGIN
  else
    Len := Columns;
  FirstCol := Col;
  while (Len > 0) and (Col <= LastCol) do
  begin
    Dec(Len, ColWidthÆColÅ);
    Inc(Col);
  end;
  if Len < 0 then
    Dec(Col);
  PageCols := Col - FirstCol;
end; æ PageCols å

procedure PrintSheet;
var
  FileName : IString;
  S : StringÆ132Å;
  ColStr : StringÆMAXCOLWIDTHÅ;
  F : Text;
  Columns, Counter1, Counter2, Counter3, Col, Row, LCol, LRow, Dummy,
    Printed, OldLastCol : Word;
  Answer : Char;
  Border, TopPage : Boolean;
begin
  Col := 1;
  WritePrompt(MSGPRINT);
  FileName := '';
  if not EditString(FileName, '', MAXINPUT) then
    Exit;
  if FileName = '' then
    FileName := 'PRN';
  Assign(F, FileName);
æ$I-å
  Rewrite(F);
  if IOResult <> 0 then
  begin
    ErrorMsg(MSGNOOPEN);
    Exit;
  end;
æ$I+å
  OldLastCol := LastCol;
  for Counter1 := 1 to LastRow do
  begin
    for Counter2 := LastCol to MAXCOLS do
    begin
      if FormatÆCounter2, Counter1Å >= OVERWRITE then
        LastCol := Counter2;
    end;
  end;
  if not GetYesNo(Answer, MSGCOLUMNS) then
    Exit;
  if Answer = 'Y' then
    Columns := 132
  else
    Columns := 80;
  if not GetYesNo(Answer, MSGBORDER) then
    Exit;
  Border := Answer = 'Y';
  while Col <= LastCol do
  begin
    Row := 1;
    TopPage := True;
    LCol := PageCols(Col, Columns, Border) + Col;
    while Row <= LastRow do
    begin
      LRow := PageRows(Row, TopPage, Border) + Row;
      Printed := 0;
      if TopPage then
      begin
        for Counter1 := 1 to TOPMARGIN do
        begin
          Writeln(F);
          Inc(Printed);
        end;
      end;
      for Counter1 := Row to Pred(LRow) do
      begin
        if Border and (Counter1 = Row) and (TopPage) then
        begin
          if (Col = 1) and Border then
          begin
            SÆ0Å := Chr(LEFTMARGIN);
            FillChar(SÆ1Å, LEFTMARGIN, ' ');
          end
          else
            S := '';
          for Counter3 := Col to Pred(LCol) do
          begin
            ColStr := CenterColString(Counter3);
            S := S + ColStr;
          end;
          Writeln(F, S);
          Printed := Succ(Printed);
        end;
        if (Col = 1) and Border then
          S := Pad(WordToString(Counter1, 1), LEFTMARGIN)
        else
          S := '';
        for Counter2 := Col to Pred(LCol) do
          S := S + CellString(Counter2, Counter1, Dummy, DOFORMAT);
        Writeln(F, S);
        Inc(Printed);
      end;
      Row := LRow;
      TopPage := False;
      if Printed < 66 then
        Write(F, FORMFEED);
    end;
    Col := LCol;
  end;
  Close(F);
  LastCol := OldLastCol;
end; æ PrintSheet å

procedure SetColWidth;
var
  Width, Row : Word;
begin
  WritePrompt(MSGCOLWIDTH);
  if not GetWord(Width, MINCOLWIDTH, MAXCOLWIDTH) then
    Exit;
  ColWidthÆColÅ := Width;
  SetRightCol;
  if RightCol < Col then
  begin
    RightCol := Col;
    SetLeftCol;
    SetRightCol;
  end;
  for Row := 1 to LastRow do
  begin
    if (CellÆCol, RowÅ <> nil) and (CellÆCol, RowÅ^.Attrib = TXT) then
      ClearOFlags(Succ(Col), Row, NOUPDATE)
    else
      ClearOFlags(Col, Row, NOUPDATE);
    UpdateOFlags(Col, Row, NOUPDATE);
  end;
  DisplayScreen(NOUPDATE);
  Changed := True;
end; æ SetColWidth å

procedure GotoCell;
begin
  WritePrompt(MSGGOTO);
  if not GetCell(CurCol, CurRow) then
    Exit;
  LeftCol := CurCol;
  TopRow := CurRow;
  SetBottomRow;
  SetRightCol;
  SetLeftCol;
  DisplayScreen(NOUPDATE);
end; æ GotoCell å

procedure FormatCells;
var
  Col, Row, Col1, Col2, Row1, Row2, NewFormat, ITemp : Word;
  Temp : Char;
begin
  NewFormat := 0;
  WritePrompt(MSGCELL1);
  if not GetCell(Col1, Row1) then
    Exit;
  WritePrompt(MSGCELL2);
  if not GetCell(Col2, Row2) then
    Exit;
  if (Col1 <> Col2) and (Row1 <> Row2) then
    ErrorMsg(MSGDIFFCOLROW)
  else begin
    if Col1 > Col2 then
      Switch(Col1, Col2);
    if Row1 > Row2 then
      Switch(Row1, Row2);
    if not GetYesNo(Temp, MSGRIGHTJUST) then
      Exit;
    NewFormat := NewFormat + (Ord(Temp = 'Y') * RJUSTIFY);
    if not GetYesNo(Temp, MSGDOLLAR) then
      Exit;
    NewFormat := NewFormat + (Ord(Temp = 'Y') * DOLLAR);
    if not GetYesNo(Temp, MSGCOMMAS) then
      Exit;
    NewFormat := NewFormat + (Ord(Temp = 'Y') * COMMAS);
    if (NewFormat and DOLLAR) <> 0 then
      NewFormat := NewFormat + 2
    else begin
      WritePrompt(MSGPLACES);
      if not GetWord(ITemp, 0, MAXPLACES) then
        Exit;
      NewFormat := NewFormat + ITemp;
    end;
    for Col := Col1 to Col2 do
    begin
      for Row := Row1 to Row2 do
      begin
        FormatÆCol, RowÅ := (FormatÆCol, RowÅ and OVERWRITE) or NewFormat;
        if (Col >= LeftCol) and (Col <= RightCol) and
           (Row >= TopRow) and (Row <= BottomRow) then
        DisplayCell(Col, Row, NOHIGHLIGHT, NOUPDATE);
      end;
    end;
  end;
  Changed := True;
end; æ FormatCells å

procedure DeleteCol;
var
  OldLastCol, Counter, Row : Word;
begin
  if Col > LastCol then
    Exit;
  OldLastCol := LastCol;
  for Counter := 1 to LastRow do
    DeleteCell(Col, Counter, NOUPDATE);
  PrintFreeMem;
  if Col <> OldLastCol then
  begin
    Move(CellÆSucc(Col), 1Å, CellÆCol, 1Å, MAXROWS * Sizeof(CellPtr) *
         (OldLastCol - Col));
    Move(FormatÆSucc(Col), 1Å, FormatÆCol, 1Å, MAXROWS * (OldLastCol - Col));
    Move(ColWidthÆSucc(Col)Å, ColWidthÆColÅ, OldLastCol - Col);
  end;
  FillChar(CellÆOldLastCol, 1Å, MAXROWS * Sizeof(CellPtr), 0);
  FillChar(FormatÆOldLastCol, 1Å, MAXROWS, DEFAULTFORMAT);
  ColWidthÆOldLastColÅ := DEFAULTWIDTH;
  SetRightCol;
  if CurCol > RightCol then
  begin
    Inc(RightCol);
    SetLeftCol;
  end;
  ClearLastCol;
  if OldLastCol = LastCol then
    Dec(LastCol);
  for Counter := 1 to LastCol do
  begin
    for Row := 1 to LastRow do
    begin
      if (CellÆCounter, RowÅ <> nil) and
         (CellÆCounter, RowÅ^.Attrib = FORMULA) then
        FixFormula(Counter, Row, COLDEL, Col);
      UpdateOFlags(Col, Row, NOUPDATE);
    end;
  end;
  for Counter := Col to RightCol do
    DisplayCol(Counter, NOUPDATE);
  LastCol := MAXCOLS;
  SetLastCol;
  Changed := True;
  Recalc;
end; æ DeleteCol å

procedure InsertCol;
var
  Counter, Row : Word;
begin
  if (LastCol = MAXCOLS) or (Col > LastCol) then
    Exit;
  if Col <> LastCol then
  begin
    Move(CellÆCol, 1Å, CellÆCol + 1, 1Å, MAXROWS * Sizeof(CellPtr) *
           Succ(LastCol - Col));
    Move(FormatÆCol, 1Å, FormatÆCol + 1, 1Å, MAXROWS * Succ(LastCol - Col));
    Move(ColWidthÆColÅ, ColWidthÆCol + 1Å, Succ(LastCol - Col));
  end;
  if LastCol < MAXCOLS then
    Inc(LastCol);
  FillChar(CellÆCol, 1Å, MAXROWS * Sizeof(CellPtr), 0);
  FillChar(FormatÆCol, 1Å, MAXROWS, DEFAULTFORMAT);
  ColWidthÆColÅ := DEFAULTWIDTH;
  SetRightCol;
  if CurCol > RightCol then
  begin
    Inc(RightCol);
    SetLeftCol;
  end;
  for Counter := 1 to LastCol do
  begin
    for Row := 1 to LastRow do
    begin
      if (CellÆCounter, RowÅ <> nil) and
         (CellÆCounter, RowÅ^.Attrib = FORMULA) then
        FixFormula(Counter, Row, COLADD, Col);
      UpdateOFlags(Col, Row, NOUPDATE);
    end;
  end;
  for Counter := Col to RightCol do
    DisplayCol(Counter, NOUPDATE);
  LastCol := MAXCOLS;
  SetLastCol;
  Changed := True;
  Recalc;
end; æ InsertCol å

procedure DeleteRow;
var
  OldLastRow, Counter, RowC : Word;
begin
  if Row > LastRow then
    Exit;
  OldLastRow := LastRow;
  for Counter := 1 to LastCol do
    DeleteCell(Counter, Row, NOUPDATE);
  PrintFreeMem;
  if Row <> OldLastRow then
  begin
    for Counter := 1 to MAXCOLS do
    begin
      Move(CellÆCounter, Succ(Row)Å, CellÆCounter, RowÅ,
           Sizeof(CellPtr) * (OldLastRow - Row));
      Move(FormatÆCounter, Succ(Row)Å, FormatÆCounter, RowÅ,
           OldLastRow - Row);
    end;
  end;
  for Counter := 1 to LastCol do
  begin
    CellÆCounter, OldLastRowÅ := nil;
    FormatÆCounter, OldLastRowÅ := DEFAULTFORMAT;
  end;
  if OldLastRow = LastRow then
    Dec(LastRow);
  for Counter := 1 to LastCol do
  begin
    for RowC := 1 to LastRow do
    begin
      if (CellÆCounter, RowCÅ <> nil) and
         (CellÆCounter, RowCÅ^.Attrib = FORMULA) then
        FixFormula(Counter, RowC, ROWDEL, Row);
    end;
  end;
  for Counter := Row to BottomRow do
    DisplayRow(Counter, NOUPDATE);
  LastRow := MAXROWS;
  SetLastRow;
  Changed := True;
  Recalc;
end; æ DeleteRow å

procedure InsertRow;
var
  Counter, RowC : Word;
begin
  if (LastRow = MAXROWS) or (Row > LastRow) then
    Exit;
  if Row <> LastRow then
  begin
    for Counter := 1 to MAXCOLS do
    begin
      Move(CellÆCounter, RowÅ, CellÆCounter, Succ(Row)Å,
           Sizeof(CellPtr) * Succ(LastRow - Row));
      Move(FormatÆCounter, RowÅ, FormatÆCounter, Succ(Row)Å,
           Succ(LastRow - Row));
    end;
  end;
  Inc(LastRow);
  for Counter := 1 to LastCol do
  begin
    CellÆCounter, RowÅ := nil;
    FormatÆCounter, RowÅ := DEFAULTFORMAT;
  end;
  for Counter := 1 to LastCol do
  begin
    for RowC := 1 to LastRow do
    begin
      if (CellÆCounter, RowCÅ <> nil) and
         (CellÆCounter, RowCÅ^.Attrib = FORMULA) then
        FixFormula(Counter, RowC, ROWADD, Row);
    end;
  end;
  for Counter := Row to BottomRow do
    DisplayRow(Counter, NOUPDATE);
  LastRow := MAXROWS;
  SetLastRow;
  Changed := True;
  Recalc;
end; æ InsertRow å

procedure SMenu;
var
  FileName : IString;
  X : Word;
begin
  FileName := '';
  case GetCommand(SMNU, SCOMMAND) of
    1 : begin
      CheckForSave;
      LoadSheet(FileName);
    end;
    2 : SaveSheet;
    3 : PrintSheet;
    4 : begin
      CheckForSave;
      ClearSheet;
    end;
  end; æ case å
end; æ SMenu å

procedure CMenu;
begin
  case GetCommand(CMNU, CCOMMAND) of
    1 : InsertCol(CurCol);
    2 : DeleteCol(CurCol);
    3 : SetColWidth(CurCol);
  end; æ case å
end; æ CMenu å

procedure RMenu;
begin
  case GetCommand(RMNU, RCOMMAND) of
    1 : InsertRow(CurRow);
    2 : DeleteRow(CurRow);
  end; æ case å
end; æ CMenu å

procedure UMenu;
begin
  case GetCommand(UMenuString, UCommandString) of
    1 : Recalc;
    2 : begin
      ChangeFormDisplay(not FormDisplay);
      DisplayScreen(UPDATE);
    end;
    3 : begin
      if ScreenRows = 38 then
      begin
        ScreenRows := 20;
        TextMode(Lo(LastMode));
        SetCursor(NoCursor);
        RedrawScreen;
      end
      else begin
        TextMode(Lo(LastMode) + Font8x8);
        if (LastMode and Font8x8) <> 0 then
        begin
          ScreenRows := 38;
          SetCursor(NoCursor);
          RedrawScreen;
        end;
      end;
    end;
  end; æ case å
end; æ UMenu å

procedure MainMenu;
begin
  case GetCommand(MNU, COMMAND) of
    1 : SMenu;
    2 : FormatCells;
    3 : begin
      DeleteCell(CurCol, CurRow, UPDATE);
      PrintFreeMem;
      if AutoCalc then
        Recalc;
    end;
    4 : GotoCell;
    5 : CMenu;
    6 : RMenu;
    7 : EditCell(CurCell);
    8 : UMenu;
    9 : ChangeAutoCalc(not AutoCalc);
    10 : begin
      CheckForSave;
      Stop := True;
    end;
  end; æ case å
  GotoXY(1, ScreenRows + 4);
  ClrEol;
end; æ MainMenu å

end.
«eof»