unit UTypes;

Windows,

Classes,

Graphics,

ExtCtrls,

Forms;

LEFT_RIGHT = 10; { Default Left/Right margin of element }

CF_NSDDATA: Word; { ClipBoard-Format }

TStringListReader = class

private

FARect: TRect;

FIndentAsInt: Integer;

FKey: string;

FKind: Byte;

FNum: Integer;

FPoint: TPoint;

FStringList: TStringList;

FText: string;

FVal: string;

function NextLineIndent: Integer;

function GetKind(const Kind: string): Byte;

public

constructor Create(const Filename: string);

destructor Destroy; override;

function HasOldFormat: Boolean;

procedure LineBack;

procedure ReadLine;

property ARect: TRect read FARect;

property IndentAsInt: Integer read FIndentAsInt;

property Key: string read FKey;

property Kind: Byte read FKind;

property Num: Integer read FNum;

property Point: TPoint read FPoint;

property StringList: TStringList read FStringList;

property Text: string read FText;

property Val: string read FVal;

end;

TStrType = (nsAlgorithm, nsStatement, nsIf, nsWhile, nsDoWhile, nsFor,

nsSwitch, nsSubProgram, nsListHead, nsCase, nsBreak, nsList);

TStrList = class;

TStrElement = class

private

FKind: Byte;

FList: TStrList;

FNext: TStrElement;

FPrev: TStrElement;

FRct: TRect;

FText: string;

FTextPos: TPoint;

procedure Draw; virtual;

procedure DrawRightBottom; virtual;

procedure DrawLeftBottom; virtual;

procedure DrawCircle(XPos, YPos, Height: Integer);

procedure DrawLines(XPos, YPos, LineHeight: Integer);

procedure DrawLinesRight(XPos, YPos, LineHeight: Integer);

procedure DrawCenteredLines(Center, YPos: Integer; Percent: Real);

procedure DrawContent(XPos, YPos: Integer); virtual;

procedure MoveRight(Width: Integer); virtual;

procedure MoveRightList(Width: Integer); virtual;

procedure MoveDown(Height: Integer); virtual;

procedure MoveDownList(Height: Integer); virtual;

procedure Resize(XPos, YPos: Integer); virtual;

procedure SetRight(Right: Integer); virtual;

procedure SetBottomList(Bottom: Integer); virtual;

procedure SetBottom(Bottom: Integer); virtual;

procedure LoadFromStream(Stream: TStream; Version: Byte); virtual;

procedure LoadFromReader(Reader: TStringListReader); virtual;

procedure SaveToStream(Stream: TStream); virtual;

function GetText(const Indent: string): string; virtual;

procedure RectToStream(Stream: TStream; Rect: TRect);

function GetRectPosAsText(Rect: TRect; Point: TPoint): string;

function RectFromStream(Stream: TStream): TRect;

procedure IntegerToStream(Stream: TStream; Int: Integer);

function IntegerFromStream(Stream: TStream): Integer;

procedure StringToStream(Stream: TStream; const Str: string);

function StringFromStream(Stream: TStream): string;

function AppendToClipboard: string; virtual;

procedure CreateFromClipboard(var ClipboardStr: string); virtual;

procedure SetRctList(X1Pos, Y1Pos, X2Pos, Y2Pos: Integer); virtual;

procedure SetList(List: TStrList); virtual;

public

constructor Create(List: TStrList);

function GetHeadHeight: Integer; virtual;

procedure SetRct(X1Pos, Y1Pos, X2Pos, Y2Pos: Integer);

procedure ResizeList(XPos, YPos: Integer);

procedure SetRightList(Right: Integer);

function GetStatementFromKind(Kind: Byte; const List: TStrList;

Parent: TStrElement): TStrElement;

function GetStatementFromReader(Reader: TStringListReader;

const List: TStrList; Parent: TStrElement): TStrElement;

function GetLineHeight: Integer;

function GetDefaultRectWidth: Integer;

function GetLines: Integer;

function AsString: string; virtual;

function GetKind: string;

function GetMaxDelta: Integer;

procedure Debug; virtual;

procedure Debug1;

procedure Collapse; virtual;

procedure CollapseCase; virtual;

property Kind: Byte read FKind;

property List: TStrList read FList;

property Next: TStrElement read FNext write FNext;

property Prev: TStrElement read FPrev write FPrev;

property Rct: TRect read FRct write FRct;

property Text: string read FText write FText;

property TextPos: TPoint read FTextPos;

end;

TStrStatement = class(TStrElement)

constructor Create(List: TStrList);

destructor Destroy; override;

function AsString: string; override;

procedure LoadFromReader(Reader: TStringListReader); override;

procedure Debug; override;

end;

TStrIf = class(TStrElement)

private

FElseElem: TStrElement;

FThenElem: TStrElement;

FPercent: Real; // then-width to else-width

procedure Draw; override;

procedure DrawContent(XPos, YPos: Integer); override;

procedure MoveRight(Width: Integer); override;

procedure MoveDown(Height: Integer); override;

procedure Resize(XPos, YPos: Integer); override;

procedure SetRight(Right: Integer); override;

procedure SetBottom(Bottom: Integer); override;

procedure LoadFromStream(Stream: TStream; Version: Byte); override;

procedure LoadFromReader(Reader: TStringListReader); override;

procedure SaveToStream(Stream: TStream); override;

function GetText(const Indent: string): string; override;

function AppendToClipboard: string; override;

procedure CreateFromClipboard(var ClipboardStr: string); override;

procedure SetTextPos;

procedure SetList(List: TStrList); override;

public

constructor Create(List: TStrList);

constructor CreateStructogram(List: TStrList);

destructor Destroy; override;

function GetHeadHeight: Integer; override;

function AsString: string; override;

procedure Debug; override;

procedure Collapse; override;

property ElseElem: TStrElement read FElseElem;

property ThenElem: TStrElement read FThenElem;

end;

TStrWhile = class(TStrElement)

private

FDoElem: TStrElement;

procedure Draw; override;

procedure DrawContent(XPos, YPos: Integer); override;

procedure MoveRight(Width: Integer); override;

procedure MoveDown(Height: Integer); override;

procedure Resize(XPos, YPos: Integer); override;

procedure SetRight(Right: Integer); override;

procedure SetBottom(Bottom: Integer); override;

procedure LoadFromStream(Stream: TStream; Version: Byte); override;

procedure LoadFromReader(Reader: TStringListReader); override;

procedure SaveToStream(Stream: TStream); override;

function GetText(const Indent: string): string; override;

function AppendToClipboard: string; override;

procedure CreateFromClipboard(var ClipboardStr: string); override;

procedure SetList(List: TStrList); override;

public

constructor Create(List: TStrList);

constructor CreateStructogram(List: TStrList);

destructor Destroy; override;

function GetHeadHeight: Integer; override;

function AsString: string; override;

procedure Debug; override;

procedure Collapse; override;

property DoElem: TStrElement read FDoElem;

end;

TStrDoWhile = class(TStrWhile)

private

procedure Draw; override;

procedure DrawContent(XPos, YPos: Integer); override;

procedure Resize(XPos, YPos: Integer); override;

public

constructor Create(List: TStrList);

constructor CreateStructogram(List: TStrList);

procedure SetBottom(Bottom: Integer); override;

function GetHeadHeight: Integer; override;

function AsString: string; override;

procedure Debug; override;

end;

TStrFor = class(TStrWhile)

public

constructor Create(List: TStrList);

constructor CreateStructogram(List: TStrList);

function AsString: string; override;

procedure Debug; override;

end;

TStrCase = class(TStrElement)

private

procedure Draw; override;

procedure DrawRightBottom; override;

procedure DrawLeftBottom; override;

public

constructor Create(List: TStrList);

function AsString: string; override;

procedure Debug; override;

end;

TCaseArray = array of TStrElement;

TStrSwitch = class(TStrElement)

private

FCaseElems: TCaseArray;

FPercent: Real; // then-width to else-width

procedure Draw; override;

procedure DrawContent(XPos, YPos: Integer); override;

procedure MoveRight(Width: Integer); override;

procedure MoveDown(Height: Integer); override;

procedure Resize(XPos, YPos: Integer); override;

procedure SetRight(Right: Integer); override;

procedure SetBottom(Bottom: Integer); override;

procedure LoadFromStream(Stream: TStream; Version: Byte); override;

procedure LoadFromReader(Reader: TStringListReader); override;

procedure SaveToStream(Stream: TStream); override;

function GetText(const Indent: string): string; override;

function AppendToClipboard: string; override;

procedure CreateFromClipboard(var ClipboardStr: string); override;

procedure SetTextPos;

procedure SetList(List: TStrList); override;

procedure AdjustCaseElems(Count: Integer);

public

constructor Create(List: TStrList);

constructor CreateStructogram(List: TStrList);

destructor Destroy; override;

function GetHeadHeight: Integer; override;

function AsString: string; override;

procedure Debug; override;

procedure Collapse; override;

property CaseElems: TCaseArray read FCaseElems write FCaseElems;

end;

TStrSubprogram = class(TStrElement)

private

procedure Draw; override;

procedure Resize(XPos, YPos: Integer); override;

function GetText(const Indent: string): string; override;

public

constructor Create(List: TStrList);

function GetHeadHeight: Integer; override;

function AsString: string; override;

procedure Debug; override;

end;

TStrBreak = class(TStrElement)

private

procedure Draw; override;

procedure Resize(XPos, YPos: Integer); override;

function GetText(const Indent: string): string; override;

public

constructor Create(List: TStrList);

function GetHeadHeight: Integer; override;

function AsString: string; override;

procedure Debug; override;

end;

// head of a FList of statements as part of a statement, used in in If/While/Do/Switch...

TStrListHead = class(TStrElement)

private

FParent: TStrElement;

procedure SetRctList(X1Pos, Y1Pos, X2Pos, Y2Pos: Integer); override;

procedure SetList(List: TStrList); override;

public

constructor Create(List: TStrList; Parent: TStrElement);

constructor CreateStructogram(List: TStrList; Parent: TStrElement);

procedure Resize(XPos, YPos: Integer); override;

destructor Destroy; override;

function AsString: string; override;

procedure Debug; override;

procedure Collapse; override;

procedure CollapseCase; override;

property Parent: TStrElement read FParent;

end;

TListImage = class;

// a whole structure without Algorithm

TStrList = class(TStrElement)

private

FCanvas: TCanvas;

FDirty: Boolean;

FDontMove: Boolean;

FLineHeight: Integer;

FListImage: TListImage;

FLoadError: Boolean;

FPuzzleMode: Integer;

FRctList: TRect;

FSwitchWithCaseLine: Boolean;

procedure PaintShadow;

procedure Draw; override;

procedure SetColors(BlackAndWhite: Boolean);

procedure Resize(XPos, YPos: Integer); override;

procedure SetRctList(X1Pos, Y1Pos, X2Pos, Y2Pos: Integer); override;

public

constructor Create(ScrollBox: TScrollBox; Mode: Integer; Font: TFont);

destructor Destroy; override;

procedure Paint(BlackAndWhite: Boolean = False);

procedure Print;

procedure DrawTo(Canvas: TCanvas);

procedure ResizeAll;

procedure LoadFromStream(Stream: TStream; Version: Byte); override;

procedure LoadFromReader(Reader: TStringListReader); override;

procedure SaveToStream(Stream: TStream); override;

function GetText(const Indent: string): string; override;

function GetRectPos: string;

procedure DeleteElem(Elem: TStrElement);

procedure Insert(Position, Elem: TStrElement);

function GetWidth: Integer;

function GetHeight: Integer;

procedure GetWidthHeigthOfText(const Text: string;

var Width, Height: Integer);

function GetWidthOfOneLine(const Text: string): Integer;

function GetWidthOfLines(const Text: string): Integer;

procedure SetLineHeight;

function AsString: string; override;

procedure Debug; override;

procedure SetList(List: TStrList); override;

procedure SetPuzzleMode(Mode: Integer);

procedure SetFont(Font: TFont);

procedure Collapse; override;

property Canvas: TCanvas read FCanvas;

property Dirty: Boolean read FDirty write FDirty;

property DontMove: Boolean read FDontMove write FDontMove;

property LineHeight: Integer read FLineHeight;

property ListImage: TListImage read FListImage;

property LoadError: Boolean read FLoadError;

property PuzzleMode: Integer read FPuzzleMode;

property RctList: TRect read FRctList write FRctList;

property SwitchWithCaseLine: Boolean read FSwitchWithCaseLine

write FSwitchWithCaseLine;

end;

// a whole structure, inherited form TStrList

TStrAlgorithm = class(TStrList)

private

procedure Resize(XPos, YPos: Integer); override;

public

constructor Create(ScrollBox: TScrollBox; Mode: Integer; Font: TFont);

function GetAlgorithmName: string;

function AsString: string; override;

procedure Debug; override;

end;

TListImage = class(TImage)

private

FStrList: TStrList;

public

// the constructor in TImage is not overload

constructor Create(ScrollBox: TScrollBox; List: TStrList); reintroduce;

property StrList: TStrList read FStrList;

end;

Math,

Types,

Themes,

UITypes,

SysUtils,

Printers,

UUtils,

UConfiguration,

UMessages;

DO_LEFT = 22; { Default Left margin of do-element }

DO_BREAK = 15;

DO_SUB = 16;

SEP = #254; { Separator of commands }

TERM = #255; { Terminator of commands }

RECT_WIDTH = 75; { Minimal width of a rectangle }

TOP_BOTTOM = 4; { Default top/bottom margin of element }

constructor TStringListReader.Create(const Filename: string);

FNum := 0;

FStringList := TStringList.Create;

try

FStringList.LoadFromFile(Filename);

except

on E: Exception do

ErrorMsg(E.Message);

end;

end;

function TStringListReader.HasOldFormat: Boolean;

Result := (FStringList.Count > 0) and (FStringList[0] <> 'JSG: true');

end;

function TStringListReader.NextLineIndent: Integer;

Str: string;

Posi: Integer;

if FNum < FStringList.Count - 1 then

begin

Str := FStringList[FNum + 1];

Posi := 1;

if Str <> '' then

while Str[Posi] = ' ' do

Inc(Posi);

Result := Posi - 1;

end

else

Result := 0;

end;

procedure TStringListReader.ReadLine;

Line: string;

Pos1, Pos2: Integer;

function getInt: Integer;

var

Pos1: Integer;

begin

Pos1 := Pos(' ', FVal);

if Pos1 > 1 then

begin

Result := StrToInt(Copy(FVal, 1, Pos1 - 1));

Delete(FVal, 1, Pos1);

end

else

Result := 0;

end;

FKind := Ord(nsStatement);

FText := '';

FARect := Rect(0, 0, 0, 0);

FPoint.X := 0;

FPoint.Y := 0;

Line := '';

FIndentAsInt := 0;

FKey := '';

FVal := '';

Inc(FNum);

while (FNum < FStringList.Count) and (Trim(FStringList[FNum]) = '') do

Inc(FNum);

if FNum < FStringList.Count then

begin

Line := FStringList[FNum];

Pos2 := 1;

if Line <> '' then

while Line[Pos2] = ' ' do

Inc(Pos2);

FIndentAsInt := Pos2 - 1;

Line := UnHideCrLf(Trim(Line));

end;

Pos1 := Length(Line);

while (Pos1 > 0) and (Line[Pos1] <> '|') do

Dec(Pos1);

if Pos1 > 0 then

begin

FVal := Copy(Line, Pos1 + 1, Length(Line)) + ' ';

FARect.Left := getInt;

FARect.Top := getInt;

FARect.Right := getInt;

FARect.Bottom := getInt;

FPoint.X := getInt;

FPoint.Y := getInt;

end;

FText := Copy(Line, 1, Pos1 - 1);

if FText = '' then

begin

Pos2 := Pos(':', Line);

if Pos2 > 0 then

begin

FKey := Copy(Line, 1, Pos2 - 1);

FVal := Copy(Line, Pos2 + 2, Length(Line));

if (FKey <> '') and (FVal = '') then

FKind := GetKind(FKey);

end;

end

else if FText[1] = '|' then

Delete(FText, 1, 1);

end;

function TStringListReader.GetKind(const Kind: string): Byte;

if Kind = 'Algorithm' then

Result := Ord(nsAlgorithm)

else if Kind = 'if' then

Result := Ord(nsIf)

else if Kind = 'while' then

Result := Ord(nsWhile)

else if Kind = 'do while' then

Result := Ord(nsDoWhile)

else if Kind = 'for' then

Result := Ord(nsFor)

else if Kind = 'switch' then

Result := Ord(nsSwitch)

else if Kind = 'subprogram' then

Result := Ord(nsSubProgram)

else if Kind = 'list head' then

Result := Ord(nsListHead)

else if Kind = 'case' then

Result := Ord(nsCase)

else if Kind = 'break' then

Result := Ord(nsBreak)

else if Kind = 'List' then

Result := Ord(nsList)

else

Result := Ord(nsStatement);

end;

procedure TStringListReader.LineBack;

Dec(FNum);

end;

destructor TStringListReader.Destroy;

FreeAndNil(FStringList);

inherited;

end;

constructor TStrElement.Create(List: TStrList);

FKind := 0;

FText := '';

FNext := nil;

FPrev := nil;

Self.FList := List;

end;

procedure TStrElement.DrawCircle(XPos, YPos, Height: Integer);

with FList.Canvas do

begin

Ellipse(XPos - Height, YPos - Height, XPos + Height, YPos + Height);

MoveTo(XPos - Height, YPos + Height);

LineTo(XPos + Height, YPos - Height);

end;

end;

procedure TStrElement.DrawLines(XPos, YPos, LineHeight: Integer);

Str, Str1: string;

Posi: Integer;

BrushColor: TColor;

BrushColor := FList.Canvas.Brush.Color;

FList.Canvas.Brush.Style := bsClear;

Str := FText;

Posi := Pos(#13#10, Str);

while Posi > 0 do

begin

Str1 := Copy(Str, 1, Posi - 1);

Delete(Str, 1, Posi + 1);

FList.Canvas.TextOut(XPos, YPos, Str1);

YPos := YPos + LineHeight;

Posi := Pos(#13#10, Str);

end;

if Str <> '' then

FList.Canvas.TextOut(XPos, YPos, Str);

FList.Canvas.Brush.Style := bsSolid;

FList.Canvas.Brush.Color := BrushColor;

end;

procedure TStrElement.DrawLinesRight(XPos, YPos, LineHeight: Integer);

Str, Str1: string;

Posi: Integer;

BrushColor: TColor;

BrushColor := FList.Canvas.Brush.Color;

FList.Canvas.Brush.Style := bsClear;

Str := FText;

Posi := Pos(#13#10, Str);

while Posi > 0 do

begin

Str1 := Copy(Str, 1, Posi - 1);

Delete(Str, 1, Posi + 1);

XPos := FRct.Right - FList.Canvas.TextWidth(Str1) - LEFT_RIGHT div 2;

FList.Canvas.TextOut(XPos, YPos, Str1);

YPos := YPos + LineHeight;

Posi := Pos(#13#10, Str);

end;

if Str <> '' then

begin

XPos := FRct.Right - FList.Canvas.TextWidth(Str) - LEFT_RIGHT div 2;

FList.Canvas.TextOut(XPos, YPos, Str);

end;

FList.Canvas.Brush.Style := bsSolid;

FList.Canvas.Brush.Color := BrushColor;

end;

procedure TStrElement.DrawCenteredLines(Center, YPos: Integer; Percent: Real);

Str, Str1: string;

XPos, Width, Posi: Integer;

BrushColor: TColor;

FList.Canvas.Rectangle(FRct.Left, FRct.Top, FRct.Right + 1, FRct.Bottom + 1);

BrushColor := FList.Canvas.Brush.Color;

FList.Canvas.Brush.Style := bsClear;

Str := FText;

YPos := FTextPos.Y;

Posi := Pos(#13#10, Str);

while Posi > 0 do

begin

Str1 := Copy(Str, 1, Posi - 1);

Delete(Str, 1, Posi + 1);

Width := Round(Percent * FList.GetWidthOfOneLine(Str1));

XPos := Center - Width;

FList.Canvas.TextOut(XPos, YPos, Str1);

YPos := YPos + FList.LineHeight;

Posi := Pos(#13#10, Str);

end;

if Str <> '' then

begin

Width := Round(Percent * FList.GetWidthOfOneLine(Str));

XPos := Center - Width;

FList.Canvas.TextOut(XPos, YPos, Str);

end;

FList.Canvas.Brush.Style := bsSolid;

FList.Canvas.Brush.Color := BrushColor;

end;

procedure TStrElement.DrawContent(XPos, YPos: Integer);

if FText = '' then

begin

XPos := (FRct.Left + FRct.Right + 1) div 2;

YPos := (FRct.Top + FRct.Bottom + 1) div 2;

DrawCircle(XPos, YPos, (GetLineHeight - 10) div 2);

end

else

DrawLines(XPos, YPos, FList.LineHeight);

end;

procedure TStrElement.Draw;

FList.Canvas.Rectangle(FRct.Left, FRct.Top, FRct.Right + 1, FRct.Bottom + 1);

DrawContent(FTextPos.X, FTextPos.Y);

end;

procedure TStrElement.DrawRightBottom;

end;

procedure TStrElement.DrawLeftBottom;

end;

procedure TStrElement.MoveRight(Width: Integer);

FRct.Left := FRct.Left + Width;

FRct.Right := FRct.Right + Width;

FTextPos.X := FTextPos.X + Width;

end;

procedure TStrElement.MoveDown(Height: Integer);

FRct.Top := FRct.Top + Height;

FRct.Bottom := FRct.Bottom + Height;

FTextPos.Y := FTextPos.Y + Height;

end;

procedure TStrElement.MoveRightList(Width: Integer);

MoveRight(Width);

var

Tmp := FNext;

while Assigned(Tmp) do

begin

Tmp.MoveRight(Width);

Tmp := Tmp.FNext;

end;

end;

procedure TStrElement.MoveDownList(Height: Integer);

MoveDown(Height);

var

Tmp := FNext;

while Assigned(Tmp) do

begin

Tmp.MoveDown(Height);

Tmp := Tmp.FNext;

end;

end;

procedure TStrElement.Resize(XPos, YPos: Integer);

Width, Height: Integer;

FList.GetWidthHeigthOfText(FText, Width, Height);

if FList.PuzzleMode = 1 then

SetRct(XPos, YPos, XPos + FRct.Right - FRct.Left,

YPos + FRct.Bottom - FRct.Top)

else if FList.PuzzleMode = 2 then

SetRct(XPos, YPos, XPos + FRct.Right - FRct.Left, YPos + Height)

else

SetRct(XPos, YPos, XPos + Width, YPos + Height);

end;

procedure TStrElement.SetRight(Right: Integer);

FRct.Right := Right;

end;

procedure TStrElement.SetBottomList(Bottom: Integer);

SetBottom(Bottom);

var

Tmp := FNext;

if Assigned(Tmp) then

begin

while Assigned(Tmp.FNext) do

Tmp := Tmp.FNext;

Tmp.SetBottom(Bottom);

end;

end;

procedure TStrElement.SetBottom(Bottom: Integer);

FRct.Bottom := Bottom;

end;

procedure TStrElement.ResizeList(XPos, YPos: Integer);

X1Pos, Y1Pos: Integer;

Tmp: TStrElement;

AKind: Byte;

// calculate width

Resize(XPos, YPos); // Listhead or StrList

AKind := Ord(nsAlgorithm);

if FKind = AKind then

X1Pos := GetDefaultRectWidth + FList.Canvas.Font.Size + 2 * LEFT_RIGHT

else

X1Pos := Self.FRct.Right;

Y1Pos := Self.FRct.Bottom;

Tmp := FNext;

while Assigned(Tmp) do

begin

Tmp.Resize(XPos, Y1Pos);

X1Pos := Max(X1Pos, Tmp.FRct.Right);

Y1Pos := Tmp.FRct.Bottom;

Tmp := Tmp.FNext;

end;

// set width

SetRightList(X1Pos);

SetRctList(XPos, YPos, X1Pos, Y1Pos);

end;

procedure TStrElement.SetRightList(Right: Integer);

SetRight(Right);

var

Tmp := FNext;

while Assigned(Tmp) do

begin

Tmp.SetRight(Right);

Tmp := Tmp.FNext;

end;

FRct.Right := Right;

end;

function TStrElement.GetLineHeight: Integer;

Result := FList.LineHeight;

end;

function TStrElement.GetDefaultRectWidth: Integer;

Result := Round(RECT_WIDTH * (FList.Canvas.Font.Size / 12.0));

end;

function TStrElement.GetLines: Integer;

Posi, Num: Integer;

Str: string;

Num := 0;

Str := FText;

Posi := Pos(#13#10, Str);

while Posi > 0 do

begin

Delete(Str, 1, Posi + 1);

Inc(Num);

Posi := Pos(#13#10, Str);

end;

if Str <> '' then

Inc(Num);

if Num = 0 then

Num := 1;

Result := Num;

end;

function TStrElement.GetHeadHeight: Integer;

Result := GetLineHeight;

end;

procedure TStrElement.LoadFromStream(Stream: TStream; Version: Byte);

Bye: Byte;

Str: ShortString;

if Version >= $0E then

begin

FText := StringFromStream(Stream);

FRct := RectFromStream(Stream);

FTextPos.X := IntegerFromStream(Stream);

FTextPos.Y := IntegerFromStream(Stream);

end

else

begin

Stream.Read(Bye, 1);

SetLength(Str, Bye);

Stream.Read(Str[1], Bye);

FText := string(Str);

end;

end;

procedure TStrElement.LoadFromReader(Reader: TStringListReader);

Reader.ReadLine;

FText := Reader.FText;

FRct := Reader.FARect;

FTextPos := Reader.FPoint;

end;

procedure TStrElement.SaveToStream(Stream: TStream);

Stream.Write(FKind, 1);

StringToStream(Stream, FText);

RectToStream(Stream, FRct);

IntegerToStream(Stream, FTextPos.X);

IntegerToStream(Stream, FTextPos.Y);

end;

function TStrElement.GetText(const Indent: string): string;

var

Str := HideCrLf(FText);

if (Str <> '') and (Str[1] = ' ') then

Str := '|' + Str;

Result := Indent + Str + GetRectPosAsText(FRct, FTextPos) + CrLf;

end;

procedure TStrElement.RectToStream(Stream: TStream; Rect: TRect);

IntegerToStream(Stream, Rect.Left);

IntegerToStream(Stream, Rect.Top);

IntegerToStream(Stream, Rect.Right);

IntegerToStream(Stream, Rect.Bottom);

end;

function TStrElement.GetRectPosAsText(Rect: TRect; Point: TPoint): string;

Result := '|' + IntToStr(Rect.Left) + ' ' + IntToStr(Rect.Top) + ' ' +

IntToStr(Rect.Right) + ' ' + IntToStr(Rect.Bottom) + ' ' + IntToStr(Point.X)

+ ' ' + IntToStr(Point.Y);

end;

function TStrElement.RectFromStream(Stream: TStream): TRect;

Result.Left := IntegerFromStream(Stream);

Result.Top := IntegerFromStream(Stream);

Result.Right := IntegerFromStream(Stream);

Result.Bottom := IntegerFromStream(Stream);

end;

procedure TStrElement.IntegerToStream(Stream: TStream; Int: Integer);

Small: SmallInt;

Small := SmallInt(Int);

Stream.Write(Small, 2);

end;

function TStrElement.IntegerFromStream(Stream: TStream): Integer;

Result := 0;

Stream.Read(Result, 2);

end;

procedure TStrElement.StringToStream(Stream: TStream; const Str: string);

Size: LongInt;

Size := Length(Str) * SizeOf(Char);

Stream.Write(Size, SizeOf(Size));

Stream.Write(Pointer(Str)^, Size);

end;

function TStrElement.StringFromStream(Stream: TStream): string;

Size: LongInt;

Stream.Read(Size, SizeOf(Size));

SetLength(Result, Size div SizeOf(Char));

Stream.Read(Pointer(Result)^, Size);

end;

function TStrElement.AppendToClipboard: string;

Result := Chr(FKind) + FText + SEP;

end;

procedure TStrElement.CreateFromClipboard(var ClipboardStr: string);

Index: Byte;

Index := Pos(SEP, ClipboardStr);

FText := Copy(ClipboardStr, 2, Index - 2);

Delete(ClipboardStr, 1, Index);

end;

procedure TStrElement.SetRct(X1Pos, Y1Pos, X2Pos, Y2Pos: Integer);

FRct.Left := X1Pos;

FRct.Top := Y1Pos;

FRct.Right := X2Pos;

FRct.Bottom := Y2Pos;

FTextPos.X := FRct.Left + LEFT_RIGHT div 2;

FTextPos.Y := FRct.Top + TOP_BOTTOM div 2;

end;

procedure TStrElement.SetRctList(X1Pos, Y1Pos, X2Pos, Y2Pos: Integer);

end;

procedure TStrElement.SetList(List: TStrList);

Self.FList := List;

end;

function TStrElement.GetStatementFromKind(Kind: Byte; const List: TStrList;

Parent: TStrElement): TStrElement;

case Kind of

Ord(nsAlgorithm):

Result := nil;

Ord(nsStatement):

Result := TStrStatement.Create(List);

Ord(nsIf):

Result := TStrIf.Create(List);

Ord(nsWhile):

Result := TStrWhile.Create(List);

Ord(nsDoWhile):

Result := TStrDoWhile.Create(List);

Ord(nsFor):

Result := TStrFor.Create(List);

Ord(nsSwitch):

Result := TStrSwitch.Create(List);

Ord(nsSubProgram):

Result := TStrSubprogram.Create(List);

Ord(nsListHead):