1926 lines
61 KiB
Plaintext
1926 lines
61 KiB
Plaintext
|
||
{ Copyright (c) 1989 by Borland International, Inc. }
|
||
|
||
unit TCCell;
|
||
{ Turbo Pascal 5.5 object-oriented example cell routines.
|
||
This unit is used by TCALC.PAS.
|
||
See TCALC.DOC for an more information about this example.
|
||
}
|
||
|
||
{$N+,S-}
|
||
|
||
interface
|
||
|
||
uses Objects, TCUtil, TCLStr, TCScreen, TCHash;
|
||
|
||
const
|
||
DollarString = ' $ ';
|
||
RepeatFirstChar = '\';
|
||
TextFirstChar = ' ';
|
||
EmptyCellName = 'Empty';
|
||
ValueCellName = 'Value';
|
||
TextCellName = 'Text';
|
||
FormulaCellName = 'Formula';
|
||
RepeatCellName = 'Repeat';
|
||
DecPlacesPart = $0F;
|
||
JustShift = 4;
|
||
JustPart = $03;
|
||
DollarPart = $40;
|
||
CommasPart = $80;
|
||
NoMemory = 203;
|
||
|
||
type
|
||
SSStream = object(DosStream)
|
||
procedure RegisterTypes; virtual;
|
||
end;
|
||
CellTypes = (ClEmpty, ClValue, ClText, ClFormula, ClRepeat);
|
||
CellPos = record
|
||
Col : Word;
|
||
Row : Word;
|
||
end;
|
||
FormatType = Byte;
|
||
Justification = (JLeft, JCenter, JRight);
|
||
DollarStr = String[Length(DollarString)];
|
||
Block = object
|
||
Start, Stop : CellPos;
|
||
constructor Init(InitStart : CellPos);
|
||
function ExtendTo(NewLoc : CellPos) : Boolean;
|
||
function CellInBlock(CheckCell : CellPos) : Boolean;
|
||
end;
|
||
CellHashTablePtr = ^CellHashTable;
|
||
CellPtr = ^Cell;
|
||
CellHashTable = object(HashTable) { Keeps pointers to all cells }
|
||
CurrCell : CellPtr; { Information about the cell that is being }
|
||
CurrLoc : CellPos; { added, deleted, or searched for }
|
||
constructor Init(InitBuckets : BucketRange);
|
||
destructor Done;
|
||
function Add(ACell : CellPtr) : Boolean;
|
||
procedure Delete(DelLoc : CellPos; var DeletedCell : CellPtr);
|
||
{ Removes a cell from the hash table }
|
||
function Search(SPos : CellPos) : CellPtr;
|
||
{ Searches for a cell in the hash table }
|
||
function HashValue : Word; virtual;
|
||
{ Computes the hash value of the cell }
|
||
function Found(Item : HashItemPtr) : Boolean; virtual;
|
||
{ Returns True if the hash item being searched for is found }
|
||
procedure CreateItem(var Item : HashItemPtr); virtual;
|
||
{ Fills in the information for a new hash item }
|
||
function ItemSize : HashItemSizeRange; virtual;
|
||
procedure Load(var S : SSStream; Total : Longint);
|
||
procedure Store(var S : SSStream);
|
||
function FirstItem : CellPtr;
|
||
function NextItem : CellPtr;
|
||
end;
|
||
FormatHashTable = object(HashTable)
|
||
CurrStart, CurrStop : CellPos;
|
||
CurrFormat : FormatType;
|
||
constructor Init;
|
||
destructor Done;
|
||
function Overwrite(NewStart, NewStop : CellPos) : Boolean;
|
||
function Add(NewStart, NewStop : CellPos;
|
||
NewFormat : FormatType) : Boolean;
|
||
function Delete(DStart, DStop : CellPos) : Boolean;
|
||
function Search(SPos : CellPos; var F : FormatType) : Boolean;
|
||
function HashValue : Word; virtual;
|
||
function Found(Item : HashItemPtr) : Boolean; virtual;
|
||
procedure CreateItem(var Item : HashItemPtr); virtual;
|
||
function ItemSize : HashItemSizeRange; virtual;
|
||
procedure Load(var S : SSStream; Total : Longint);
|
||
procedure Store(var S : SSStream);
|
||
end;
|
||
WidthHashTable = object(HashTable)
|
||
CurrCol : Word;
|
||
CurrWidth : Byte;
|
||
DefaultColWidth : Byte;
|
||
constructor Init(InitBuckets : BucketRange; InitDefaultColWidth : Byte);
|
||
destructor Done;
|
||
function Add(SCol : Word; NewWidth : Byte) : Boolean;
|
||
procedure Delete(Col : Word);
|
||
function Search(Col : Word) : Byte;
|
||
function HashValue : Word; virtual;
|
||
function Found(Item : HashItemPtr) : Boolean; virtual;
|
||
procedure CreateItem(var Item : HashItemPtr); virtual;
|
||
function ItemSize : HashItemSizeRange; virtual;
|
||
function GetDefaultColWidth : Byte;
|
||
procedure Load(var S : SSStream; Total : Longint);
|
||
procedure Store(var S : SSStream);
|
||
end;
|
||
OverwriteHashTable = object(HashTable)
|
||
CurrCell : CellPtr;
|
||
CurrPos : CellPos;
|
||
EndCol : Word;
|
||
constructor Init(InitBuckets : BucketRange);
|
||
destructor Done;
|
||
function Add(SCell : CellPtr; Overwritten : Word) : Boolean;
|
||
procedure Delete(SPos : CellPos);
|
||
function Change(SCell : CellPtr; Overwritten : Word) : Boolean;
|
||
function Search(SPos : CellPos) : CellPtr;
|
||
function HashValue : Word; virtual;
|
||
function Found(Item : HashItemPtr) : Boolean; virtual;
|
||
procedure CreateItem(var Item : HashItemPtr); virtual;
|
||
function ItemSize : HashItemSizeRange; virtual;
|
||
end;
|
||
GetColWidthFunc = function(var WHash : WidthHashTable;
|
||
C : Word) : Byte;
|
||
Cell = object(Base)
|
||
Loc : CellPos;
|
||
constructor Init(InitLoc : CellPos);
|
||
destructor Done; virtual;
|
||
function CellType : CellTypes; virtual;
|
||
function LegalValue : Boolean; virtual;
|
||
function Name : String; virtual;
|
||
function Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType; virtual;
|
||
function Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable; var LastPos : CellPos;
|
||
MaxCols : Word; GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function ShouldUpdate : Boolean; virtual;
|
||
function HasError : Boolean; virtual;
|
||
function CurrValue : Extended; virtual;
|
||
function OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc; EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word; virtual;
|
||
procedure EditString(MaxDecPlaces : Byte; var L : LStringPtr); virtual;
|
||
function DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String; virtual;
|
||
function FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos; FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String; virtual;
|
||
function CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr; virtual;
|
||
end;
|
||
EmptyCellPtr = ^EmptyCell;
|
||
EmptyCell = object(Cell)
|
||
constructor Init;
|
||
function CellType : CellTypes; virtual;
|
||
function LegalValue : Boolean; virtual;
|
||
function Name : String; virtual;
|
||
function Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType; virtual;
|
||
function Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable; var LastPos : CellPos;
|
||
MaxCols : Word; GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function ShouldUpdate : Boolean; virtual;
|
||
function HasError : Boolean; virtual;
|
||
function CurrValue : Extended; virtual;
|
||
function OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc; EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word; virtual;
|
||
procedure EditString(MaxDecPlaces : Byte; var L : LStringPtr); virtual;
|
||
function DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String; virtual;
|
||
function FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos; FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String; virtual;
|
||
function CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr; virtual;
|
||
end;
|
||
ValueCellPtr = ^ValueCell;
|
||
ValueCell = object(Cell)
|
||
Error : Boolean;
|
||
Value : Extended; { A cell with a numeric value }
|
||
constructor Init(InitLoc : CellPos; InitError : Boolean;
|
||
InitValue : Extended);
|
||
function CellType : CellTypes; virtual;
|
||
function LegalValue : Boolean; virtual;
|
||
function Name : String; virtual;
|
||
function Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType; virtual;
|
||
function Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable; var LastPos : CellPos;
|
||
MaxCols : Word; GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function ShouldUpdate : Boolean; virtual;
|
||
function HasError : Boolean; virtual;
|
||
function CurrValue : Extended; virtual;
|
||
function OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc; EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word; virtual;
|
||
procedure EditString(MaxDecPlaces : Byte; var L : LStringPtr); virtual;
|
||
function DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String; virtual;
|
||
function FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos; FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String; virtual;
|
||
function CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr; virtual;
|
||
constructor Load(var S : SSStream);
|
||
procedure Store(var S : SSStream);
|
||
end;
|
||
TextCellPtr = ^TextCell;
|
||
TextCell = object(Cell)
|
||
Txt : LStringPtr; { A cell with text }
|
||
constructor Init(InitLoc : CellPos; InitTxt : LStringPtr);
|
||
destructor Done; virtual;
|
||
function CellType : CellTypes; virtual;
|
||
function LegalValue : Boolean; virtual;
|
||
function Name : String; virtual;
|
||
function Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType; virtual;
|
||
function Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable; var LastPos : CellPos;
|
||
MaxCols : Word; GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function ShouldUpdate : Boolean; virtual;
|
||
function HasError : Boolean; virtual;
|
||
function CurrValue : Extended; virtual;
|
||
function OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc; EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word; virtual;
|
||
procedure EditString(MaxDecPlaces : Byte; var L : LStringPtr); virtual;
|
||
function DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String; virtual;
|
||
function FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos; FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String; virtual;
|
||
function CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr; virtual;
|
||
constructor Load(var S : SSStream);
|
||
procedure Store(var S : SSStream);
|
||
end;
|
||
FormulaCellPtr = ^FormulaCell;
|
||
FormulaCell = object(Cell)
|
||
Error : Boolean;
|
||
Value : Extended;
|
||
Formula : LStringPtr; { A cell with a formula }
|
||
constructor Init(InitLoc : CellPos; InitError : Boolean;
|
||
InitValue : Extended; InitFormula : LStringPtr);
|
||
destructor Done; virtual;
|
||
function CellType : CellTypes; virtual;
|
||
function LegalValue : Boolean; virtual;
|
||
function Name : String; virtual;
|
||
function Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType; virtual;
|
||
function Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable; var LastPos : CellPos;
|
||
MaxCols : Word; GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function ShouldUpdate : Boolean; virtual;
|
||
function HasError : Boolean; virtual;
|
||
function CurrValue : Extended; virtual;
|
||
function OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc; EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word; virtual;
|
||
procedure EditString(MaxDecPlaces : Byte; var L : LStringPtr); virtual;
|
||
function DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String; virtual;
|
||
function FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos; FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String; virtual;
|
||
function CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr; virtual;
|
||
constructor Load(var S : SSStream);
|
||
procedure Store(var S : SSStream);
|
||
function GetFormula : LStringPtr;
|
||
end;
|
||
RepeatCellPtr = ^RepeatCell;
|
||
RepeatCell = object(Cell)
|
||
RepeatChar : Char; { A cell with text that will repeat - used for
|
||
underlining, etc. }
|
||
constructor Init(InitLoc : CellPos; InitChar : Char);
|
||
function CellType : CellTypes; virtual;
|
||
function LegalValue : Boolean; virtual;
|
||
function Name : String; virtual;
|
||
function Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType; virtual;
|
||
function Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable; var LastPos : CellPos;
|
||
MaxCols : Word; GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word; virtual;
|
||
function ShouldUpdate : Boolean; virtual;
|
||
function HasError : Boolean; virtual;
|
||
function CurrValue : Extended; virtual;
|
||
function OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc; EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word; virtual;
|
||
procedure EditString(MaxDecPlaces : Byte; var L : LStringPtr); virtual;
|
||
function DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String; virtual;
|
||
function FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos; FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String; virtual;
|
||
function CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr; virtual;
|
||
constructor Load(var S : SSStream);
|
||
procedure Store(var S : SSStream);
|
||
end;
|
||
|
||
var
|
||
Empty : CellPtr; { This is a special cell. It is used as the return
|
||
value if a cell cannot be found so that the EmptyCell
|
||
methods can be executed instead of having special
|
||
routines that act differently depending on whether a
|
||
cell is found ot not. }
|
||
|
||
implementation
|
||
|
||
var
|
||
SavedExitProc : Pointer;
|
||
|
||
procedure SSStream.RegisterTypes;
|
||
{ Registers the different cell types so that they will be written out
|
||
correctly to disk }
|
||
begin
|
||
DosStream.RegisterTypes;
|
||
Register(TypeOf(ValueCell), @ValueCell.Store, @ValueCell.Load);
|
||
Register(TypeOf(TextCell), @TextCell.Store, @TextCell.Load);
|
||
Register(TypeOf(FormulaCell), @FormulaCell.Store, @FormulaCell.Load);
|
||
Register(TypeOf(RepeatCell), @RepeatCell.Store, @RepeatCell.Load);
|
||
end; { SSStream.RegisterTypes }
|
||
|
||
constructor Block.Init(InitStart : CellPos);
|
||
{ Initializes a block of cells, setting the end to be the same as the start }
|
||
begin
|
||
Start := InitStart;
|
||
Stop := Start;
|
||
end; { Block.Init }
|
||
|
||
function Block.ExtendTo(NewLoc : CellPos) : Boolean;
|
||
{ Extends a block to a new position, as long as the new position is to the
|
||
right and down from the old position }
|
||
begin
|
||
if (NewLoc.Col >= Start.Col) and (NewLoc.Row >= Start.Row) then
|
||
begin
|
||
Stop := NewLoc;
|
||
ExtendTo := True;
|
||
end
|
||
else
|
||
ExtendTo := False;
|
||
end; { Block.ExtendTo }
|
||
|
||
function Block.CellInBlock(CheckCell : CellPos) : Boolean;
|
||
{ Checks to see if a cell is inside a particular block }
|
||
begin
|
||
CellInBlock := (CheckCell.Col >= Start.Col) and
|
||
(CheckCell.Col <= Stop.Col) and
|
||
(CheckCell.Row >= Start.Row) and
|
||
(CheckCell.Row <= Stop.Row);
|
||
end; { Block.CellInBlock }
|
||
|
||
constructor CellHashTable.Init(InitBuckets : BucketRange);
|
||
{ Initializes a cell hash table, which stores pointers to the cells in a
|
||
spreadsheet }
|
||
begin
|
||
if not HashTable.Init(InitBuckets) then
|
||
Fail;
|
||
end; { CellHashTable.Init }
|
||
|
||
destructor CellHashTable.Done;
|
||
{ Removes a cell hash table from memory }
|
||
var
|
||
CP : CellPtr;
|
||
begin
|
||
CP := FirstItem;
|
||
while CP <> nil do
|
||
begin
|
||
Dispose(CP, Done);
|
||
CP := NextItem;
|
||
end;
|
||
HashTable.Done;
|
||
end; { CellHashTable.Done }
|
||
|
||
function CellHashTable.Add(ACell : CellPtr) : Boolean;
|
||
{ Adds a cell to a cell hash table }
|
||
begin
|
||
CurrCell := ACell;
|
||
CurrLoc := CurrCell^.Loc;
|
||
Add := HashTable.Add;
|
||
end; { CellHashTable.Add }
|
||
|
||
procedure CellHashTable.Delete(DelLoc : CellPos; var DeletedCell : CellPtr);
|
||
{ Deletes a cell from a cell hash table }
|
||
begin
|
||
CurrLoc := DelLoc;
|
||
HashTable.Delete(@DeletedCell);
|
||
end; { CellHashTable.Delete }
|
||
|
||
function CellHashTable.Search(SPos : CellPos) : CellPtr;
|
||
{ Searches for a cell in a cell hash table, returning the cell if found, or
|
||
returning the Empty cell if not found }
|
||
var
|
||
I : HashItemPtr;
|
||
C : CellPtr;
|
||
begin
|
||
CurrLoc := SPos;
|
||
I := HashTable.Search;
|
||
if I = nil then
|
||
Search := Empty
|
||
else begin
|
||
Move(I^.Data, C, SizeOf(C));
|
||
Search := C;
|
||
end;
|
||
end; { CellHashTable.Search }
|
||
|
||
function CellHashTable.HashValue : Word;
|
||
{ Calculates the hash value of a cell }
|
||
begin
|
||
HashValue := CurrLoc.Col + CurrLoc.Row;
|
||
end; { CellHashTable.HashValue }
|
||
|
||
function CellHashTable.Found(Item : HashItemPtr) : Boolean;
|
||
{ Checks to see if a hash item is the one searched for by comparing the
|
||
location information in both }
|
||
var
|
||
C : CellPtr;
|
||
begin
|
||
Move(Item^.Data, C, SizeOf(C));
|
||
Found := Compare(C^.Loc, CurrLoc, SizeOf(CurrLoc));
|
||
end; { CellHashTable.Found }
|
||
|
||
procedure CellHashTable.CreateItem(var Item : HashItemPtr);
|
||
{ Writes the cell poionter information out to the hash item }
|
||
begin
|
||
Move(CurrCell, Item^.Data, SizeOf(CurrCell));
|
||
end; { CellHashTable.CreateItem }
|
||
|
||
function CellHashTable.ItemSize : HashItemSizeRange;
|
||
{ The hash item size is current - just cell pointers are stored }
|
||
begin
|
||
ItemSize := SizeOf(CurrCell);
|
||
end; { CellHashTable.ItemSize }
|
||
|
||
procedure CellHashTable.Load(var S : SSStream; Total : Longint);
|
||
{ Loads a cell hash table from disk }
|
||
var
|
||
Counter : Longint;
|
||
begin
|
||
for Counter := 1 to Total do
|
||
begin
|
||
if not Add(CellPtr(S.Get)) then
|
||
begin
|
||
S.Error(NoMemory);
|
||
Exit;
|
||
end;
|
||
end;
|
||
end; { CellHashTable.Load }
|
||
|
||
procedure CellHashTable.Store(var S : SSStream);
|
||
{ Writes a cell hash table to disk }
|
||
var
|
||
CP : CellPtr;
|
||
begin
|
||
CP := FirstItem;
|
||
while CP <> nil do
|
||
begin
|
||
S.Put(CP);
|
||
CP := NextItem;
|
||
end;
|
||
end; { CellHashTable.Store }
|
||
|
||
function HashItemPtrToCellPtr(H : HashItemPtr) : CellPtr;
|
||
{ Converts a hash item pointer to a cell pointer }
|
||
var
|
||
CP : CellPtr;
|
||
begin
|
||
if H = nil then
|
||
HashItemPtrToCellPtr := nil
|
||
else begin
|
||
Move(H^.Data, CP, SizeOf(CP));
|
||
HashItemPtrToCellPtr := CP;
|
||
end;
|
||
end; { HashItemPtrToCellPtr }
|
||
|
||
function CellHashTable.FirstItem : CellPtr;
|
||
{ Returns the first hash item in a cell hash table }
|
||
begin
|
||
FirstItem := HashItemPtrToCellPtr(HashTable.FirstItem);
|
||
end; { CellHashTable.FirstItem }
|
||
|
||
function CellHashTable.NextItem : CellPtr;
|
||
{ Returns the second and subsequent hash items in a cell hash table }
|
||
begin
|
||
NextItem := HashItemPtrToCellPtr(HashTable.NextItem);
|
||
end; { CellHashTable.NextItem }
|
||
|
||
constructor WidthHashTable.Init(InitBuckets : BucketRange;
|
||
InitDefaultColWidth : Byte);
|
||
{ Initializes the width hash table, which stores column widths that are
|
||
different than the default. It stores the column and the width in the
|
||
hash table }
|
||
begin
|
||
if not HashTable.Init(InitBuckets) then
|
||
Fail;
|
||
DefaultColWidth := InitDefaultColWidth;
|
||
end; { WidthHashTable.Init }
|
||
|
||
destructor WidthHashTable.Done;
|
||
begin
|
||
HashTable.Done;
|
||
end; { WidthHashTable.Done }
|
||
|
||
function WidthHashTable.Add(SCol : Word; NewWidth : Byte) : Boolean;
|
||
begin
|
||
CurrCol := SCol;
|
||
CurrWidth := NewWidth;
|
||
Add := HashTable.Add;
|
||
end; { WidthHashTable }
|
||
|
||
procedure WidthHashTable.Delete(Col : Word);
|
||
begin
|
||
CurrCol := Col;
|
||
HashTable.Delete(nil);
|
||
end; { WidthHashTable.Delete }
|
||
|
||
function WidthHashTable.Search(Col : Word) : Byte;
|
||
var
|
||
I : HashItemPtr;
|
||
W : Byte;
|
||
begin
|
||
CurrCol := Col;
|
||
I := HashTable.Search;
|
||
if I = nil then
|
||
Search := 0
|
||
else begin
|
||
Move(I^.Data[SizeOf(CurrCol)], W, SizeOf(W));
|
||
Search := W;
|
||
end;
|
||
end; { WidthHashTable.Search }
|
||
|
||
function WidthHashTable.HashValue : Word;
|
||
begin
|
||
HashValue := CurrCol;
|
||
end; { WidthHashTable.HashValue }
|
||
|
||
function WidthHashTable.Found(Item : HashItemPtr) : Boolean;
|
||
var
|
||
C : Word;
|
||
begin
|
||
Move(Item^.Data, C, SizeOf(C));
|
||
Found := CurrCol = C;
|
||
end; { WidthHashTable.Found }
|
||
|
||
procedure WidthHashTable.CreateItem(var Item : HashItemPtr);
|
||
begin
|
||
Move(CurrCol, Item^.Data, SizeOf(CurrCol));
|
||
Move(CurrWidth, Item^.Data[SizeOf(CurrCol)], SizeOf(CurrWidth));
|
||
end; { WidthHashTable.CreateItem }
|
||
|
||
function WidthHashTable.ItemSize : HashItemSizeRange;
|
||
begin
|
||
ItemSize := SizeOf(CurrCol) + SizeOf(CurrWidth);
|
||
end; { WidthHashTable.ItemSize }
|
||
|
||
function WidthHashTable.GetDefaultColWidth : Byte;
|
||
begin
|
||
GetDefaultColWidth := DefaultColWidth;
|
||
end; { WidthHashTable.GetDefaultColWidth }
|
||
|
||
procedure WidthHashTable.Load(var S : SSStream; Total : Longint);
|
||
var
|
||
Counter : Longint;
|
||
Col : Word;
|
||
Width : Byte;
|
||
begin
|
||
for Counter := 1 to Total do
|
||
begin
|
||
S.Read(Col, SizeOf(Col));
|
||
S.Read(Width, SizeOf(Width));
|
||
if not Add(Col, Width) then
|
||
begin
|
||
S.Error(NoMemory);
|
||
Exit;
|
||
end;
|
||
end;
|
||
end; { WidthHashTable.Load }
|
||
|
||
procedure WidthHashTable.Store(var S : SSStream);
|
||
var
|
||
H : HashItemPtr;
|
||
Col : Word;
|
||
Width : Byte;
|
||
begin
|
||
H := FirstItem;
|
||
while H <> nil do
|
||
begin
|
||
Move(H^.Data, Col, SizeOf(Col));
|
||
S.Write(Col, SizeOf(Col));
|
||
Move(H^.Data[SizeOf(Col)], Width, SizeOf(Width));
|
||
S.Write(Width, SizeOf(Width));
|
||
H := NextItem;
|
||
end;
|
||
end; { WidthHashTable.Store }
|
||
|
||
constructor FormatHashTable.Init;
|
||
{ Initializes a format hash table, which is used to store formatted areas
|
||
that differ from the default. The area and the format are stored in the
|
||
hash table }
|
||
begin
|
||
if not HashTable.Init(1) then { Use a single bucket so that a search
|
||
Fail; will be possible }
|
||
end; { FormatHashTable.Init }
|
||
|
||
destructor FormatHashTable.Done;
|
||
begin
|
||
HashTable.Done;
|
||
end; { FormatHashTable.Done }
|
||
|
||
function FormatHashTable.Overwrite(NewStart, NewStop : CellPos) : Boolean;
|
||
{ Checks to see if a new format area has overwritten an old one, requiring
|
||
the old area to be overwritten or broken into parts }
|
||
var
|
||
H : HashItemPtr;
|
||
AStart, AStop, BStart, BStop : CellPos;
|
||
OldF, F : FormatType;
|
||
P : CellPos;
|
||
Added : Boolean;
|
||
begin
|
||
Overwrite := False;
|
||
H := HashData^[1];
|
||
while H <> nil do
|
||
begin
|
||
Move(H^.Data, BStart, SizeOf(CellPos));
|
||
Move(H^.Data[SizeOf(CellPos)], BStop, SizeOf(CellPos));
|
||
if ((((NewStart.Col >= BStart.Col) and (NewStart.Col <= BStop.Col)) or
|
||
((NewStop.Col >= BStart.Col) and (NewStop.Col <= BStop.Col))) and
|
||
(((NewStart.Row >= BStart.Row) and (NewStart.Row <= BStop.Row)) or
|
||
((NewStop.Row >= BStart.Row) and (NewStop.Row <= BStop.Row)))) or
|
||
((((BStart.Col >= NewStart.Col) and (BStart.Col <= NewStop.Col)) or
|
||
((BStop.Col >= NewStart.Col) and (BStop.Col <= NewStop.Col))) and
|
||
(((BStart.Row >= NewStart.Row) and (BStart.Row <= NewStop.Row)) or
|
||
((BStop.Row >= NewStart.Row) and (BStop.Row <= NewStop.Row)))) then
|
||
begin
|
||
Move(H^.Data[SizeOf(CellPos) shl 1], F, SizeOf(F));
|
||
CurrStart := BStart;
|
||
CurrStop := BStop;
|
||
HashTable.Delete(nil);
|
||
if BStart.Row < NewStart.Row then
|
||
begin
|
||
AStart := BStart;
|
||
AStop.Col := BStop.Col;
|
||
AStop.Row := Pred(NewStart.Row);
|
||
if not Add(AStart, AStop, F) then
|
||
Exit;
|
||
end;
|
||
if BStop.Row > NewStop.Row then
|
||
begin
|
||
AStart.Col := BStart.Col;
|
||
AStart.Row := Succ(NewStop.Row);
|
||
AStop.Col := BStop.Col;
|
||
AStop.Row := BStop.Row;
|
||
if not Add(AStart, AStop, F) then
|
||
Exit;
|
||
end;
|
||
if BStart.Col < NewStart.Col then
|
||
begin
|
||
AStart.Col := BStart.Col;
|
||
AStart.Row := Max(BStart.Row, NewStart.Row);
|
||
AStop.Col := Pred(NewStart.Col);
|
||
AStop.Row := Min(BStop.Row, NewStop.Row);
|
||
if not Add(AStart, AStop, F) then
|
||
Exit;
|
||
end;
|
||
if BStop.Col > NewStop.Col then
|
||
begin
|
||
AStart.Col := Succ(NewStop.Col);
|
||
AStart.Row := Max(BStart.Row, NewStart.Row);
|
||
AStop.Col := BStop.Col;
|
||
AStop.Row := Min(BStop.Row, NewStop.Row);
|
||
if not Add(AStart, AStop, F) then
|
||
Exit;
|
||
end;
|
||
end;
|
||
H := H^.Next;
|
||
end;
|
||
Overwrite := True;
|
||
end; { FormatHashTable.Overwrite }
|
||
|
||
function FormatHashTable.Add(NewStart, NewStop : CellPos;
|
||
NewFormat : FormatType) : Boolean;
|
||
begin
|
||
if not Overwrite(NewStart, NewStop) then
|
||
begin
|
||
Add := False;
|
||
Exit;
|
||
end;
|
||
CurrStart := NewStart;
|
||
CurrStop := NewStop;
|
||
CurrFormat := NewFormat;
|
||
Add := HashTable.Add;
|
||
end; { FormatHashTable.Add }
|
||
|
||
function FormatHashTable.Delete(DStart, DStop : CellPos) : Boolean;
|
||
begin
|
||
Delete := Overwrite(DStart, DStop);
|
||
end; { FormatHashTable.Delete }
|
||
|
||
function FormatHashTable.Search(SPos : CellPos; var F : FormatType) :
|
||
Boolean;
|
||
var
|
||
H : HashItemPtr;
|
||
begin
|
||
CurrStart := SPos;
|
||
H := HashTable.Search;
|
||
if H = nil then
|
||
Search := False
|
||
else begin
|
||
Move(H^.Data[SizeOf(CellPos) shl 1], F, SizeOf(F));
|
||
Search := True;
|
||
end;
|
||
end; { FormatHashTable.Search }
|
||
|
||
function FormatHashTable.HashValue : Word;
|
||
{ Since the hash table has only one bucket, the hash value is always 1 }
|
||
begin
|
||
HashValue := 1;
|
||
end; { FormatHashTable.HashValue }
|
||
|
||
function FormatHashTable.Found(Item : HashItemPtr) : Boolean;
|
||
var
|
||
P : CellPos;
|
||
B : Block;
|
||
Start, Stop : CellPos;
|
||
Good : Boolean;
|
||
begin
|
||
Move(Item^.Data, Start, SizeOf(CellPos));
|
||
Move(Item^.Data[SizeOf(CellPos)], Stop, SizeOf(CellPos));
|
||
B.Init(Start);
|
||
B.Stop := Stop;
|
||
Found := B.CellInBlock(CurrStart);
|
||
end; { FormatHashTable.Found }
|
||
|
||
procedure FormatHashTable.CreateItem(var Item : HashItemPtr);
|
||
begin
|
||
with Item^ do
|
||
begin
|
||
Move(CurrStart, Data, SizeOf(CellPos));
|
||
Move(CurrStop, Data[SizeOf(CellPos)], SizeOf(CellPos));
|
||
Move(CurrFormat, Data[SizeOf(CellPos) shl 1], SizeOf(CurrFormat));
|
||
end; { with }
|
||
end; { FormatHashTable.CreateItem }
|
||
|
||
function FormatHashTable.ItemSize : HashItemSizeRange;
|
||
begin
|
||
ItemSize := (SizeOf(CellPos) shl 1) + SizeOf(FormatType);
|
||
end; { FormatHashTable.ItemSize }
|
||
|
||
procedure FormatHashTable.Load(var S : SSStream; Total : Longint);
|
||
var
|
||
Counter : Longint;
|
||
C1, C2 : CellPos;
|
||
Format : FormatType;
|
||
begin
|
||
for Counter := 1 to Total do
|
||
begin
|
||
S.Read(C1, SizeOf(C1));
|
||
S.Read(C2, SizeOf(C2));
|
||
S.Read(Format, SizeOf(Format));
|
||
if not Add(C1, C2, Format) then
|
||
begin
|
||
S.Error(NoMemory);
|
||
Exit;
|
||
end;
|
||
end;
|
||
end; { FormatHashTable.Load }
|
||
|
||
procedure FormatHashTable.Store(var S : SSStream);
|
||
var
|
||
H : HashItemPtr;
|
||
C : CellPos;
|
||
Format : Byte;
|
||
begin
|
||
H := FirstItem;
|
||
while H <> nil do
|
||
begin
|
||
Move(H^.Data, C, SizeOf(C));
|
||
S.Write(C, SizeOf(C));
|
||
Move(H^.Data[SizeOf(CellPos)], C, SizeOf(C));
|
||
S.Write(C, SizeOf(C));
|
||
Move(H^.Data[SizeOf(CellPos) shl 1], Format, SizeOf(Format));
|
||
S.Write(Format, SizeOf(Format));
|
||
H := NextItem;
|
||
end;
|
||
end; { FormatHashTable.Store }
|
||
|
||
constructor OverwriteHashTable.Init(InitBuckets : BucketRange);
|
||
{ Initializes an overwrite hash table, which keeps track of which cells are
|
||
overwritten by other cells }
|
||
begin
|
||
if not HashTable.Init(InitBuckets) then
|
||
Fail;
|
||
end; { OverwriteHashTable.Init }
|
||
|
||
destructor OverwriteHashTable.Done;
|
||
begin
|
||
HashTable.Done;
|
||
end; { OverwriteHashTable.Done }
|
||
|
||
function OverwriteHashTable.Add(SCell : CellPtr;
|
||
Overwritten : Word) : Boolean;
|
||
var
|
||
CP : CellPtr;
|
||
begin
|
||
if Overwritten = 0 then
|
||
begin
|
||
Add := True;
|
||
Exit;
|
||
end;
|
||
CP := Search(SCell^.Loc);
|
||
if CP <> Empty then
|
||
begin
|
||
if not Change(CP, Pred(SCell^.Loc.Col)) then
|
||
begin
|
||
Add := False;
|
||
Exit;
|
||
end;
|
||
end;
|
||
CurrCell := SCell;
|
||
CurrPos := SCell^.Loc;
|
||
EndCol := CurrPos.Col + Overwritten;
|
||
Add := HashTable.Add;
|
||
end; { OverwriteHashTable.Add }
|
||
|
||
procedure OverwriteHashTable.Delete(SPos : CellPos);
|
||
begin
|
||
CurrPos := SPos;
|
||
HashTable.Delete(nil);
|
||
end; { OverwriteHashTable.Delete }
|
||
|
||
function OverwriteHashTable.Change(SCell : CellPtr;
|
||
Overwritten : Word) : Boolean;
|
||
begin
|
||
if Overwritten = 0 then
|
||
begin
|
||
Delete(SCell^.Loc);
|
||
Change := True;
|
||
end
|
||
else begin
|
||
CurrCell := SCell;
|
||
CurrPos := CurrCell^.Loc;
|
||
EndCol := SCell^.Loc.Col + Overwritten;
|
||
Change := HashTable.Change;
|
||
end;
|
||
end; { OverwriteHashTable.Change }
|
||
|
||
function OverwriteHashTable.Search(SPos : CellPos) : CellPtr;
|
||
var
|
||
I : HashItemPtr;
|
||
C : CellPtr;
|
||
begin
|
||
CurrPos := SPos;
|
||
I := HashTable.Search;
|
||
if I = nil then
|
||
Search := Empty
|
||
else begin
|
||
Move(I^.Data, C, SizeOf(C));
|
||
Search := C;
|
||
end;
|
||
end; { OverwriteHashTable.Search }
|
||
|
||
function OverwriteHashTable.HashValue : Word;
|
||
begin
|
||
HashValue := CurrPos.Row;
|
||
end; { OverwriteHashTable.HashValue }
|
||
|
||
function OverwriteHashTable.Found(Item : HashItemPtr) : Boolean;
|
||
var
|
||
C : CellPtr;
|
||
E : Word;
|
||
begin
|
||
Move(Item^.Data, C, SizeOf(C));
|
||
Move(Item^.Data[SizeOf(C)], E, SizeOf(E));
|
||
with CurrPos do
|
||
Found := (Row = C^.Loc.Row) and (Col >= C^.Loc.Col) and
|
||
(Col <= E);
|
||
end; { OverwriteHashTable.Found }
|
||
|
||
procedure OverwriteHashTable.CreateItem(var Item : HashItemPtr);
|
||
begin
|
||
Move(CurrCell, Item^.Data, SizeOf(CurrCell));
|
||
Move(EndCol, Item^.Data[SizeOf(CurrCell)], SizeOf(EndCol));
|
||
end; { OverwriteHashTable.CreateItem }
|
||
|
||
function OverwriteHashTable.ItemSize : HashItemSizeRange;
|
||
begin
|
||
ItemSize := SizeOf(CurrCell) + SizeOf(EndCol);
|
||
end; { OverwriteHashTable.ItemSize }
|
||
|
||
constructor Cell.Init(InitLoc : CellPos);
|
||
{ Initializes a cell's location }
|
||
begin
|
||
Loc := InitLoc;
|
||
end; { Cell.Init }
|
||
|
||
destructor Cell.Done;
|
||
{ Frees memory used by the cell }
|
||
begin
|
||
end; { Cell.Done }
|
||
|
||
function Cell.CellType : CellTypes;
|
||
{ Returns the type of a cell - used in copying cells }
|
||
begin
|
||
Abstract('Cell.CellType');
|
||
end; { Cell.CellType }
|
||
|
||
function Cell.LegalValue : Boolean;
|
||
{ Returns True if the cell has a legal numeric value }
|
||
begin
|
||
Abstract('Cell.LegalValue');
|
||
end; { Cell.LegalValue }
|
||
|
||
function Cell.Name : String;
|
||
{ Returns the name of the cell type }
|
||
begin
|
||
Abstract('Cell.Name');
|
||
end; { Cell.Name }
|
||
|
||
function Cell.Format(var FHash : FormatHashTable; FormulasDisplayed : Boolean) :
|
||
FormatType;
|
||
{ Returns the format of a cell }
|
||
begin
|
||
Abstract('Cell.Format');
|
||
end; { Cell.Format }
|
||
|
||
function Cell.Width(var FHash : FormatHashTable; FormulasDisplayed : Boolean) :
|
||
Word;
|
||
{ Returns the width of a cell (including the cells that it will overwrite) }
|
||
begin
|
||
Abstract('Cell.Width');
|
||
end; { Cell.Width }
|
||
|
||
function Cell.Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
var LastPos : CellPos;
|
||
MaxCols : Word;
|
||
GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
{ Calculates how many cells a cell will overwrite }
|
||
begin
|
||
Abstract('Cell.Overwritten');
|
||
end; { Cell.Overwritten }
|
||
|
||
function Cell.ShouldUpdate : Boolean;
|
||
{ Returns True if the cell needs to be updated when the spreadsheet changes }
|
||
begin
|
||
Abstract('Cell.ShouldUpdate');
|
||
end; { Cell.ShouldUpdate }
|
||
|
||
function Cell.HasError : Boolean;
|
||
{ Returns True if the cell has a numeric error in it }
|
||
begin
|
||
Abstract('Cell.HasError');
|
||
end; { Cell.HasError }
|
||
|
||
function Cell.CurrValue : Extended;
|
||
{ Returns the current numeric value of a cell }
|
||
begin
|
||
Abstract('Cell.CurrValue');
|
||
end; { Cell.CurrValue }
|
||
|
||
function Cell.OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc; EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word;
|
||
{ Determines, for overwritten cells, where in the overwriting data they will
|
||
Start to display a value }
|
||
begin
|
||
Abstract('Cell.OverwriteStart');
|
||
end; { Cell.OverwriteStart }
|
||
|
||
procedure Cell.EditString(MaxDecPlaces : Byte;
|
||
var L : LStringPtr);
|
||
{ Sets up a long string with the cell's value that can be edited }
|
||
begin
|
||
Abstract('Cell.EditString');
|
||
end; { Cell.EditString }
|
||
|
||
function Cell.DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String;
|
||
{ Returns the string that will be displayed just above the input line }
|
||
begin
|
||
Abstract('Cell.DisplayString');
|
||
end; { Cell.DisplayString }
|
||
|
||
function Cell.FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos; FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String;
|
||
{ Returns the string that will be printed in a cell }
|
||
begin
|
||
Abstract('Cell.FormattedString');
|
||
end; { Cell.FormattedString }
|
||
|
||
function Cell.CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr;
|
||
{ Copies a cell's string information to another cell's }
|
||
begin
|
||
Abstract('Cell.CopyString');
|
||
end; { Cell.CopyString }
|
||
|
||
constructor EmptyCell.Init;
|
||
var
|
||
NewLoc : CellPos;
|
||
begin
|
||
NewLoc.Col := 0;
|
||
NewLoc.Row := 0;
|
||
Cell.Init(NewLoc);
|
||
end; { EmptyCell.Init }
|
||
|
||
function EmptyCell.CellType : CellTypes;
|
||
begin
|
||
CellType := ClEmpty;
|
||
end; { EmptyCell.CellType }
|
||
|
||
function EmptyCell.LegalValue : Boolean;
|
||
begin
|
||
LegalValue := True;
|
||
end; { EmptyCell.LegalValue }
|
||
|
||
function EmptyCell.Name : String;
|
||
begin
|
||
Name := EmptyCellName;
|
||
end; { EmptyCell.Name }
|
||
|
||
function EmptyCell.Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType;
|
||
begin
|
||
Format := 0;
|
||
end; { EmptyCell.Format }
|
||
|
||
function EmptyCell.Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
begin
|
||
Width := 0;
|
||
end; { EmptyCell.Width }
|
||
|
||
function EmptyCell.Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
var LastPos : CellPos;
|
||
MaxCols : Word;
|
||
GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
begin
|
||
Overwritten := 0;
|
||
end; { EmptyCell.Overwritten }
|
||
|
||
function EmptyCell.ShouldUpdate : Boolean;
|
||
begin
|
||
ShouldUpdate := False;
|
||
end; { EmptyCell.ShouldUpdate }
|
||
|
||
function EmptyCell.HasError : Boolean;
|
||
begin
|
||
HasError := False;
|
||
end; { Cell.HasError }
|
||
|
||
function EmptyCell.CurrValue : Extended;
|
||
begin
|
||
CurrValue := 0;
|
||
end; { EmptyCell.CurrValue }
|
||
|
||
function EmptyCell.OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word;
|
||
begin
|
||
OverwriteStart := 1;
|
||
end; { EmptyCell.OverwriteStart }
|
||
|
||
procedure EmptyCell.EditString(MaxDecPlaces : Byte;
|
||
var L : LStringPtr);
|
||
var
|
||
Good : Boolean;
|
||
begin
|
||
Good := L^.FromString('');
|
||
end; { EmptyCell.EditString }
|
||
|
||
function EmptyCell.DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String;
|
||
begin
|
||
DisplayString := '';
|
||
end; { EmptyCell.DisplayString }
|
||
|
||
function EmptyCell.FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos;
|
||
FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String;
|
||
var
|
||
CP : CellPtr;
|
||
begin
|
||
CP := OHash.Search(CPos);
|
||
if CP <> Empty then
|
||
FormattedString := CP^.FormattedString(OHash, FHash, WHash, GetColWidth,
|
||
Loc, FormulasDisplayed,
|
||
CP^.OverWriteStart(FHash, WHash,
|
||
GetColWidth, CPos.Col,
|
||
FormulasDisplayed), ColWidth,
|
||
DString, Color)
|
||
else begin
|
||
FormattedString := '';
|
||
DString := '';
|
||
Color := Colors.BlankColor;
|
||
end;
|
||
end; { EmptyCell.FormattedString }
|
||
|
||
function EmptyCell.CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr;
|
||
begin
|
||
CopyString := L;
|
||
end; { EmptyCell.CopyString }
|
||
|
||
constructor ValueCell.Init(InitLoc : CellPos; InitError : Boolean;
|
||
InitValue : Extended);
|
||
begin
|
||
Cell.Init(InitLoc);
|
||
Error := InitError;
|
||
Value := InitValue;
|
||
end; { ValueCell.Init }
|
||
|
||
function ValueCell.CellType : CellTypes;
|
||
begin
|
||
CellType := ClValue;
|
||
end; { ValueCell.CellType }
|
||
|
||
function ValueCell.LegalValue : Boolean;
|
||
begin
|
||
LegalValue := True;
|
||
end; { ValueCell.LegalValue }
|
||
|
||
function ValueCell.Name : String;
|
||
begin
|
||
Name := ValueCellName;
|
||
end; { ValueCell.Name }
|
||
|
||
function ValueCell.Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType;
|
||
var
|
||
F : FormatType;
|
||
begin
|
||
if FHash.Search(Loc, F) then
|
||
Format := F
|
||
else
|
||
Format := (Ord(JRight) shl 4) + 4;
|
||
end; { ValueCell.Format }
|
||
|
||
function ValueCell.Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
var
|
||
S : String;
|
||
F : FormatType;
|
||
P, W : Word;
|
||
begin
|
||
F := Format(FHash, FormulasDisplayed);
|
||
Str(Value:1:(F and DecPlacesPart), S);
|
||
W := Length(S);
|
||
if (F and DollarPart) <> 0 then
|
||
Inc(W, Length(DollarString));
|
||
if (F and CommasPart) <> 0 then
|
||
begin
|
||
P := Pos('.', S);
|
||
if P = 0 then
|
||
P := Length(S);
|
||
Inc(W, (P - 2) div 3);
|
||
end;
|
||
Width := W;
|
||
end; { ValueCell.Width }
|
||
|
||
function ValueCell.Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
var LastPos : CellPos;
|
||
MaxCols : Word;
|
||
GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
var
|
||
CellWidth : Longint;
|
||
Total : Word;
|
||
P : CellPos;
|
||
begin
|
||
P := Loc;
|
||
CellWidth := Width(FHash, FormulasDisplayed);
|
||
Total := 0;
|
||
repeat
|
||
Inc(Total);
|
||
Dec(CellWidth, GetColWidth(WHash, P.Col));
|
||
Inc(P.Col);
|
||
until (CellWidth <= 0) or (P.Col = MaxCols) or (CHash.Search(P) <> Empty);
|
||
Dec(Total);
|
||
Overwritten := Total;
|
||
end; { ValueCell.Overwritten }
|
||
|
||
function ValueCell.ShouldUpdate : Boolean;
|
||
begin
|
||
ShouldUpdate := False;
|
||
end; { ValueCell.ShouldUpdate }
|
||
|
||
function ValueCell.HasError : Boolean;
|
||
begin
|
||
HasError := Error;
|
||
end; { ValueCell.HasError }
|
||
|
||
function ValueCell.CurrValue : Extended;
|
||
begin
|
||
CurrValue := Value;
|
||
end; { ValueCell.CurrValue }
|
||
|
||
function ValueCell.OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word;
|
||
var
|
||
F : FormatType;
|
||
C, Place : Word;
|
||
begin
|
||
F := Format(FHash, DisplayFormulas);
|
||
Place := 1;
|
||
C := Loc.Col;
|
||
repeat
|
||
Inc(Place, GetColWidth(WHash, C));
|
||
Inc(C);
|
||
until C = EndCol;
|
||
if (F and DollarPart) <> 0 then
|
||
Dec(Place, Length(DollarString));
|
||
OverwriteStart := Place;
|
||
end; { ValueCell.OverwriteStart }
|
||
|
||
procedure ValueCell.EditString(MaxDecPlaces : Byte;
|
||
var L : LStringPtr);
|
||
var
|
||
S : String;
|
||
Good : Boolean;
|
||
begin
|
||
Str(Value:1:MaxDecPlaces, S);
|
||
Good := L^.FromString(S);
|
||
end; { ValueCell.EditString }
|
||
|
||
function ValueCell.DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String;
|
||
var
|
||
S : String;
|
||
begin
|
||
Str(Value:1:MaxDecPlaces, S);
|
||
DisplayString := S;
|
||
end; { ValueCell.DisplayString }
|
||
|
||
function ValueCell.FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos;
|
||
FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String;
|
||
var
|
||
Counter : Word;
|
||
S : String;
|
||
F : FormatType;
|
||
begin
|
||
F := Format(FHash, FormulasDisplayed);
|
||
Str(Value:1:F and DecPlacesPart, S);
|
||
if (Start = 1) and ((F and DollarPart) <> 0) then
|
||
DString := ' $ '
|
||
else
|
||
DString := '';
|
||
if (F and CommasPart) <> 0 then
|
||
begin
|
||
Counter := Pos('.', S);
|
||
if Counter = 0 then
|
||
Counter := System.Length(S);
|
||
while Counter > 4 do
|
||
begin
|
||
System.Insert(',', S, Counter - 3);
|
||
Dec(Counter, 3);
|
||
end;
|
||
end;
|
||
Color := Colors.ValueCellColor;
|
||
FormattedString := Copy(S, Start, ColWidth);
|
||
end; { ValueCell.FormattedString }
|
||
|
||
function ValueCell.CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr;
|
||
begin
|
||
CopyString := L;
|
||
end; { ValueCell.CopyString }
|
||
|
||
constructor ValueCell.Load(var S : SSStream);
|
||
begin
|
||
S.Read(Loc, SizeOf(Loc));
|
||
S.Read(Error, SizeOf(Error));
|
||
S.Read(Value, SizeOf(Value));
|
||
end; { ValueCell.Load }
|
||
|
||
procedure ValueCell.Store(var S : SSStream);
|
||
begin
|
||
S.Write(Loc, SizeOf(Loc));
|
||
S.Write(Error, SizeOf(Error));
|
||
S.Write(Value, SizeOf(Value));
|
||
end; { ValueCell.Store }
|
||
|
||
constructor TextCell.Init(InitLoc : CellPos; InitTxt : LStringPtr);
|
||
begin
|
||
Cell.Init(InitLoc);
|
||
Txt := New(LStringPtr, Init);
|
||
if Txt = nil then
|
||
Fail;
|
||
if not Txt^.Assign(InitTxt^) then
|
||
begin
|
||
Done;
|
||
Fail;
|
||
end;
|
||
end; { TextCell.Init }
|
||
|
||
destructor TextCell.Done;
|
||
begin
|
||
Dispose(Txt, Done);
|
||
end; { TextCell.Done }
|
||
|
||
function TextCell.CellType : CellTypes;
|
||
begin
|
||
CellType := ClText;
|
||
end; { TextCell.CellType }
|
||
|
||
function TextCell.LegalValue : Boolean;
|
||
begin
|
||
LegalValue := False;
|
||
end; { TextCell.LegalValue }
|
||
|
||
function TextCell.Name : String;
|
||
begin
|
||
Name := TextCellName;
|
||
end; { TextCell.Name }
|
||
|
||
function TextCell.Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType;
|
||
var
|
||
F : FormatType;
|
||
begin
|
||
if FHash.Search(Loc, F) then
|
||
Format := F
|
||
else
|
||
Format := 0;
|
||
end; { TextCell.Format }
|
||
|
||
function TextCell.Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
begin
|
||
Width := Txt^.Length;
|
||
end; { TextCell.Width }
|
||
|
||
function TextCell.Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
var LastPos : CellPos;
|
||
MaxCols : Word;
|
||
GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
var
|
||
CellWidth : Longint;
|
||
Total : Word;
|
||
P : CellPos;
|
||
begin
|
||
P := Loc;
|
||
CellWidth := Width(FHash, FormulasDisplayed);
|
||
Total := 0;
|
||
repeat
|
||
Inc(Total);
|
||
Dec(CellWidth, GetColWidth(WHash, P.Col));
|
||
Inc(P.Col);
|
||
until (CellWidth <= 0) or (P.Col = MaxCols) or (CHash.Search(P) <> Empty);
|
||
Dec(Total);
|
||
Overwritten := Total;
|
||
end; { TextCell.Overwritten }
|
||
|
||
function TextCell.ShouldUpdate : Boolean;
|
||
begin
|
||
ShouldUpdate := False;
|
||
end; { TextCell.ShouldUpdate }
|
||
|
||
function TextCell.HasError : Boolean;
|
||
begin
|
||
HasError := False;
|
||
end; { TextCell.HasError }
|
||
|
||
function TextCell.CurrValue : Extended;
|
||
begin
|
||
CurrValue := 0;
|
||
end; { TextCell.CurrValue }
|
||
|
||
function TextCell.OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word;
|
||
var
|
||
F : FormatType;
|
||
C, Place : Word;
|
||
begin
|
||
F := Format(FHash, DisplayFormulas);
|
||
Place := 1;
|
||
C := Loc.Col;
|
||
repeat
|
||
Inc(Place, GetColWidth(WHash, C));
|
||
Inc(C);
|
||
until C = EndCol;
|
||
OverwriteStart := Place;
|
||
end; { TextCell.OverwriteStart }
|
||
|
||
procedure TextCell.EditString(MaxDecPlaces : Byte;
|
||
var L : LStringPtr);
|
||
var
|
||
Good : Boolean;
|
||
begin
|
||
Good := L^.Assign(Txt^);
|
||
end; { TextCell.EditString }
|
||
|
||
function TextCell.DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String;
|
||
begin
|
||
DisplayString := Txt^.Copy(2, Scr.CurrCols);
|
||
end; { TextCell.DisplayString }
|
||
|
||
function TextCell.FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos;
|
||
FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String;
|
||
begin
|
||
DString := '';
|
||
Color := Colors.TextCellColor;
|
||
FormattedString := Txt^.Copy(Succ(Start), ColWidth);
|
||
end; { TextCell.FormattedString }
|
||
|
||
function TextCell.CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr;
|
||
var
|
||
Good : Boolean;
|
||
begin
|
||
Good := L^.Assign(Txt^);
|
||
CopyString := L;
|
||
end; { TextCell.CopyString }
|
||
|
||
constructor TextCell.Load(var S : SSStream);
|
||
begin
|
||
S.Read(Loc, SizeOf(Loc));
|
||
Txt := New(LStringPtr, Init);
|
||
if Txt = nil then
|
||
begin
|
||
S.Error(NoMemory);
|
||
Exit;
|
||
end;
|
||
if not Txt^.FromStream(S) then
|
||
begin
|
||
Dispose(Txt, Done);
|
||
S.Error(NoMemory);
|
||
end;
|
||
end; { TextCell.Load }
|
||
|
||
procedure TextCell.Store(var S : SSStream);
|
||
begin
|
||
S.Write(Loc, SizeOf(Loc));
|
||
Txt^.ToStream(S);
|
||
end; { TextCell.Store }
|
||
|
||
constructor FormulaCell.Init(InitLoc : CellPos; InitError : Boolean;
|
||
InitValue : Extended; InitFormula : LStringPtr);
|
||
begin
|
||
Cell.Init(InitLoc);
|
||
Formula := New(LStringPtr, Init);
|
||
if Formula = nil then
|
||
Fail;
|
||
if not Formula^.Assign(InitFormula^) then
|
||
begin
|
||
Done;
|
||
Fail;
|
||
end;
|
||
Error := InitError;
|
||
Value := InitValue;
|
||
end; { FormulaCell.Init }
|
||
|
||
destructor FormulaCell.Done;
|
||
begin
|
||
Dispose(Formula, Done);
|
||
end; { FormulaCell.Done }
|
||
|
||
function FormulaCell.CellType : CellTypes;
|
||
begin
|
||
CellType := ClFormula;
|
||
end; { FormulaCell.CellType }
|
||
|
||
function FormulaCell.LegalValue : Boolean;
|
||
begin
|
||
LegalValue := True;
|
||
end; { FormulaCell.LegalValue }
|
||
|
||
function FormulaCell.Name : String;
|
||
begin
|
||
Name := FormulaCellName;
|
||
end; { FormulaCell.Name }
|
||
|
||
function FormulaCell.Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType;
|
||
var
|
||
F : FormatType;
|
||
begin
|
||
if FHash.Search(Loc, F) then
|
||
Format := F
|
||
else if FormulasDisplayed then
|
||
Format := 0
|
||
else
|
||
Format := (Ord(JRight) shl 4) + 4;
|
||
end; { FormulaCell.Format }
|
||
|
||
function FormulaCell.Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
var
|
||
S : String;
|
||
F : Byte;
|
||
P, W : Word;
|
||
begin
|
||
if FormulasDisplayed then
|
||
Width := Formula^.Length
|
||
else begin
|
||
F := Format(FHash, FormulasDisplayed);
|
||
Str(Value:1:(F and DecPlacesPart), S);
|
||
W := Length(S);
|
||
if (F and DollarPart) <> 0 then
|
||
Inc(W, Length(DollarString));
|
||
if (F and CommasPart) <> 0 then
|
||
begin
|
||
P := Pos('.', S);
|
||
if P = 0 then
|
||
P := Length(S);
|
||
Inc(W, (P - 2) div 3);
|
||
end;
|
||
Width := W;
|
||
end;
|
||
end; { FormulaCell.Width }
|
||
|
||
function FormulaCell.Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
var LastPos : CellPos;
|
||
MaxCols : Word;
|
||
GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
var
|
||
CellWidth : Longint;
|
||
Total : Word;
|
||
P : CellPos;
|
||
begin
|
||
P := Loc;
|
||
CellWidth := Width(FHash, FormulasDisplayed);
|
||
Total := 0;
|
||
repeat
|
||
Inc(Total);
|
||
Dec(CellWidth, GetColWidth(WHash, P.Col));
|
||
Inc(P.Col);
|
||
until (CellWidth <= 0) or (P.Col = MaxCols) or (CHash.Search(P) <> Empty);
|
||
Dec(Total);
|
||
Overwritten := Total;
|
||
end; { FormulaCell.Overwritten }
|
||
|
||
function FormulaCell.ShouldUpdate : Boolean;
|
||
begin
|
||
ShouldUpdate := True;
|
||
end; { FormulaCell.ShouldUpdate }
|
||
|
||
function FormulaCell.HasError : Boolean;
|
||
begin
|
||
HasError := Error;
|
||
end; { FormulaCell.HasError }
|
||
|
||
function FormulaCell.CurrValue : Extended;
|
||
begin
|
||
CurrValue := Value;
|
||
end; { FormulaCell.CurrValue }
|
||
|
||
function FormulaCell.OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word;
|
||
var
|
||
F : FormatType;
|
||
C, Place : Word;
|
||
begin
|
||
F := Format(FHash, DisplayFormulas);
|
||
Place := 1;
|
||
C := Loc.Col;
|
||
repeat
|
||
Inc(Place, GetColWidth(WHash, C));
|
||
Inc(C);
|
||
until C = EndCol;
|
||
if (not DisplayFormulas) and ((F and DollarPart) <> 0) then
|
||
Dec(Place, Length(DollarString));
|
||
OverwriteStart := Place;
|
||
end; { FormulaCell.OverwriteStart }
|
||
|
||
procedure FormulaCell.EditString(MaxDecPlaces : Byte;
|
||
var L : LStringPtr);
|
||
var
|
||
Good : Boolean;
|
||
begin
|
||
Good := L^.Assign(Formula^);
|
||
end; { FormulaCell.EditString }
|
||
|
||
function FormulaCell.DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String;
|
||
var
|
||
S : String;
|
||
begin
|
||
if not FormulasDisplayed then
|
||
DisplayString := Formula^.ToString
|
||
else begin
|
||
Str(Value:1:MaxDecPlaces, S);
|
||
DisplayString := S;
|
||
end;
|
||
end; { FormulaCell.DisplayString }
|
||
|
||
function FormulaCell.FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos;
|
||
FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String;
|
||
var
|
||
S : String;
|
||
Counter : Word;
|
||
F : FormatType;
|
||
begin
|
||
if FormulasDisplayed then
|
||
begin
|
||
DString := '';
|
||
Color := Colors.FormulaCellColor;
|
||
FormattedString := Formula^.Copy(1, ColWidth);
|
||
end
|
||
else begin
|
||
F := Format(FHash, FormulasDisplayed);
|
||
Str(Value:1:F and DecPlacesPart, S);
|
||
if (Start = 1) and ((F and DollarPart) <> 0) then
|
||
DString := ' $ '
|
||
else
|
||
DString := '';
|
||
if (F and CommasPart) <> 0 then
|
||
begin
|
||
Counter := Pos('.', S);
|
||
if Counter = 0 then
|
||
Counter := Length(S);
|
||
while Counter > 4 do
|
||
begin
|
||
Insert(',', S, Counter - 3);
|
||
Dec(Counter, 3);
|
||
end;
|
||
end;
|
||
Color := Colors.ValueCellColor;
|
||
FormattedString := Copy(S, Start, ColWidth);
|
||
end;
|
||
end; { FormulaCell.FormattedString }
|
||
|
||
function FormulaCell.CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr;
|
||
var
|
||
Good : Boolean;
|
||
begin
|
||
Good := L^.Assign(Formula^);
|
||
CopyString := L;
|
||
end; { FormulaCell.CopyString }
|
||
|
||
constructor FormulaCell.Load(var S : SSStream);
|
||
begin
|
||
S.Read(Loc, SizeOf(Loc));
|
||
Formula := New(LStringPtr, Init);
|
||
if Formula = nil then
|
||
begin
|
||
S.Error(NoMemory);
|
||
Exit;
|
||
end;
|
||
if not Formula^.FromStream(S) then
|
||
begin
|
||
Dispose(Formula, Done);
|
||
S.Error(NoMemory);
|
||
end;
|
||
end; { FormulaCell.Load }
|
||
|
||
procedure FormulaCell.Store(var S : SSStream);
|
||
begin
|
||
S.Write(Loc, SizeOf(Loc));
|
||
Formula^.ToStream(S);
|
||
end; { FormulaCell.Store }
|
||
|
||
function FormulaCell.GetFormula : LStringPtr;
|
||
begin
|
||
GetFormula := Formula;
|
||
end; { FormulaCell.GetFormula }
|
||
|
||
constructor RepeatCell.Init(InitLoc : CellPos; InitChar : Char);
|
||
begin
|
||
Cell.Init(InitLoc);
|
||
RepeatChar := InitChar;
|
||
end; { RepeatCell.Init }
|
||
|
||
function RepeatCell.CellType : CellTypes;
|
||
begin
|
||
CellType := ClRepeat;
|
||
end; { RepeatCell.CellType }
|
||
|
||
function RepeatCell.LegalValue : Boolean;
|
||
begin
|
||
LegalValue := False;
|
||
end; { RepeatCell.LegalValue }
|
||
|
||
function RepeatCell.Name : String;
|
||
begin
|
||
Name := RepeatCellName;
|
||
end; { RepeatCell.Name }
|
||
|
||
function RepeatCell.Format(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : FormatType;
|
||
begin
|
||
Format := 0;
|
||
end; { RepeatCell.Format }
|
||
|
||
function RepeatCell.Width(var FHash : FormatHashTable;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
begin
|
||
Width := 2;
|
||
end; { RepeatCell.Width }
|
||
|
||
function RepeatCell.Overwritten(var CHash : CellHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
var LastPos : CellPos;
|
||
MaxCols : Word;
|
||
GetColWidth : GetColWidthFunc;
|
||
FormulasDisplayed : Boolean) : Word;
|
||
var
|
||
Total : Word;
|
||
P : CellPos;
|
||
begin
|
||
P := Loc;
|
||
Total := 0;
|
||
repeat
|
||
Inc(Total);
|
||
Inc(P.Col);
|
||
until (P.Col > LastPos.Col) or (CHash.Search(P) <> Empty) or
|
||
(P.Col = 0);
|
||
Dec(Total);
|
||
if (P.Col > LastPos.Col) or (P.Col = 0) then
|
||
Total := MaxCols - Loc.Col;
|
||
Overwritten := Total;
|
||
end; { RepeatCell.Overwritten }
|
||
|
||
function RepeatCell.ShouldUpdate : Boolean;
|
||
begin
|
||
ShouldUpdate := False;
|
||
end; { RepeatCell.ShouldUpdate }
|
||
|
||
function RepeatCell.HasError : Boolean;
|
||
begin
|
||
HasError := False;
|
||
end; { RepeatCell.HasError }
|
||
|
||
function RepeatCell.CurrValue : Extended;
|
||
begin
|
||
CurrValue := 0;
|
||
end; { RepeatCell.CurrValue }
|
||
|
||
function RepeatCell.OverwriteStart(var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
EndCol : Word;
|
||
DisplayFormulas : Boolean) : Word;
|
||
begin
|
||
OverwriteStart := 1;
|
||
end; { RepeatCell.OverwriteStart }
|
||
|
||
procedure RepeatCell.EditString(MaxDecPlaces : Byte;
|
||
var L : LStringPtr);
|
||
var
|
||
Good : Boolean;
|
||
begin
|
||
Good := L^.FromString(RepeatFirstChar + RepeatChar);
|
||
end; { RepeatCell.EditString }
|
||
|
||
function RepeatCell.DisplayString(FormulasDisplayed : Boolean;
|
||
MaxDecPlaces : Byte) : String;
|
||
begin
|
||
DisplayString := FillString(Scr.CurrCols, RepeatChar);
|
||
end; { RepeatCell.DisplayString }
|
||
|
||
function RepeatCell.FormattedString(var OHash : OverwriteHashTable;
|
||
var FHash : FormatHashTable;
|
||
var WHash : WidthHashTable;
|
||
GetColWidth : GetColWidthFunc;
|
||
CPos : CellPos;
|
||
FormulasDisplayed : Boolean;
|
||
Start : Word; ColWidth : Byte;
|
||
var DString : DollarStr;
|
||
var Color : Byte) : String;
|
||
begin
|
||
DString := '';
|
||
Color := Colors.RepeatCellColor;
|
||
FormattedString := PadChar('', RepeatChar, ColWidth);
|
||
end; { RepeatCell.FormattedString }
|
||
|
||
function RepeatCell.CopyString(ColLit, RowLit : Boolean; Diff : Longint;
|
||
var L : LStringPtr) : LStringPtr;
|
||
begin
|
||
EditString(0, L);
|
||
CopyString := L;
|
||
end; { RepeatCell.CopyString }
|
||
|
||
constructor RepeatCell.Load(var S : SSStream);
|
||
begin
|
||
S.Read(Loc, SizeOf(Loc));
|
||
S.Read(RepeatChar, SizeOf(RepeatChar));
|
||
end; { RepeatCell.Load }
|
||
|
||
procedure RepeatCell.Store(var S : SSStream);
|
||
begin
|
||
S.Write(Loc, SizeOf(Loc));
|
||
S.Write(RepeatChar, SizeOf(RepeatChar));
|
||
end; { RepeatCell.Store }
|
||
|
||
{$F+}
|
||
|
||
procedure CellExit;
|
||
{ Removes Empty cell from memory, restores ExitProc }
|
||
begin
|
||
Dispose(Empty, Done);
|
||
ExitProc := SavedExitProc;
|
||
end; { CellExit }
|
||
|
||
{$F-}
|
||
|
||
begin
|
||
SavedExitProc := ExitProc;
|
||
ExitProc := @CellExit;
|
||
Empty := New(EmptyCellPtr, Init);
|
||
end.
|
||
|