Category : Pascal Source Code
Archive   : ANSICOLR.ZIP
Filename : ANSICOLR.PAS

 
Output of file : ANSICOLR.PAS contained in archive : ANSICOLR.ZIP
{*********************************************************}
{* ANSICOLR.PAS 1.0 *}
{* Copyright (c) í áETATech í 1991. *}
{* All rights reserved. *}
{*********************************************************}
{ Wed 12-18-1991 v1.0 }
{ This unit is patterned after the TurboPower OPCOLOR }
{ unit. OPCOLOR allows the programmer to specify screen }
{ colors with easily rememberable names like "RedOnBlue". }
{ I wanted a way to specify the same type of color }
{ definitions, but have the ANSI escape sequence for that }
{ combination to be the output. Hopfully this unit will }
{ accomplish this task making ANSI colors easier for the }
{ programmer. }
{ }
{ The naming conventions of ANSICOLR are similar to that }
{ of OPCOLOR except that all names begin with a lower }
{ case "a" (ie. aRedOnBlack). This will return the ANSI }
{ escape code that will enable this color combination. }
{ All low intensity forground combinations start by }
{ setting the previous colors off, then define the new }
{ color set. To get a color set with the foreground set }
{ to blink, just preface the color combination with "ab" }
{ (ie. abRedOnBlue). Each low intensity color combination}
{ is 10 char., each high intensity color set is 12 char. }
{ and each blinking color set is 14 char. long. }
{ }
{ I retain the copyright for this unit, but release it for}
{ public use with no royalties required. You may use it }
{ in any program that it would be of assistance to you. }
{ In the same regard, I offer NO WARANTEE what so ever }
{ either express or implied. }
{ }
{ If you come up with enhancements or changes to this unit}
{ I would appreciate knowing about them as I would like to}
{ keep the unit up to date. I can be reached at the }
{ places listed below: }
{ }
{ áETATech Computer Consulting The Paradigm BBS }
{ P. O. Box 566742 404/671-1581 }
{ Atlanta, GA 30356-6013 1200-19200 HST }
{*********************************************************}



UNIT AnsiColr;

INTERFACE

CONST

aBlink : BYTE = 16;

aSt : STRING [2] = #27'[';
aEnd : STRING [1] = 'm';
aDef : STRING [4] = #27'[0m';

fgCol : ARRAY [0..31] OF STRING [8] =
('0;30', '0;34', '0;32', '0;36',
'0;31', '0;35', '0;33', '0;37',
'0;1;30', '0;1;34', '0;1;32', '0;1;36',
'0;1;31', '0;1;35', '0;1;33', '0;1;37',
'0;5;30', '0;5;34', '0;5;32', '0;5;36',
'0;5;31', '0;5;35', '0;5;33', '0;5;37',
'0;1;5;30', '0;1;5;34', '0;1;5;32', '0;1;5;36',
'0;1;5;31', '0;1;5;35', '0;1;5;33', '0;1;5;37');

bgCol : ARRAY [0..7] OF STRING [4] =
(';40', ';44', ';42', ';46', ';41', ';45', ';43', ';47');

TYPE
Str14 = STRING [14];




{Black background}
FUNCTION aBlackOnBlack : Str14;
FUNCTION abBlackOnBlack : Str14;
FUNCTION aBlueOnBlack : Str14;
FUNCTION abBlueOnBlack : Str14;
FUNCTION aGreenOnBlack : Str14;
FUNCTION abGreenOnBlack : Str14;
FUNCTION aCyanOnBlack : Str14;
FUNCTION abCyanOnBlack : Str14;
FUNCTION aRedOnBlack : Str14;
FUNCTION abRedOnBlack : Str14;
FUNCTION aMagentaOnBlack : Str14;
FUNCTION abMagentaOnBlack : Str14;
FUNCTION aBrownOnBlack : Str14;
FUNCTION abBrownOnBlack : Str14;
FUNCTION aLtGrayOnBlack : Str14;
FUNCTION abLtGrayOnBlack : Str14;
FUNCTION aDkGrayOnBlack : Str14;
FUNCTION abDkGrayOnBlack : Str14;
FUNCTION aLtBlueOnBlack : Str14;
FUNCTION abLtBlueOnBlack : Str14;
FUNCTION aLtGreenOnBlack : Str14;
FUNCTION abLtGreenOnBlack : Str14;
FUNCTION aLtCyanOnBlack : Str14;
FUNCTION abLtCyanOnBlack : Str14;
FUNCTION aLtRedOnBlack : Str14;
FUNCTION abLtRedOnBlack : Str14;
FUNCTION aLtMagentaOnBlack : Str14;
FUNCTION abLtMagentaOnBlack : Str14;
FUNCTION aYellowOnBlack : Str14;
FUNCTION abYellowOnBlack : Str14;
FUNCTION aWhiteOnBlack : Str14;
FUNCTION abWhiteOnBlack : Str14;

{Blue background}
FUNCTION aBlackOnBlue : Str14;
FUNCTION abBlackOnBlue : Str14;
FUNCTION aBlueOnBlue : Str14;
FUNCTION abBlueOnBlue : Str14;
FUNCTION aGreenOnBlue : Str14;
FUNCTION abGreenOnBlue : Str14;
FUNCTION aCyanOnBlue : Str14;
FUNCTION abCyanOnBlue : Str14;
FUNCTION aRedOnBlue : Str14;
FUNCTION abRedOnBlue : Str14;
FUNCTION aMagentaOnBlue : Str14;
FUNCTION abMagentaOnBlue : Str14;
FUNCTION aBrownOnBlue : Str14;
FUNCTION abBrownOnBlue : Str14;
FUNCTION aLtGrayOnBlue : Str14;
FUNCTION abLtGrayOnBlue : Str14;
FUNCTION aDkGrayOnBlue : Str14;
FUNCTION abDkGrayOnBlue : Str14;
FUNCTION aLtBlueOnBlue : Str14;
FUNCTION abLtBlueOnBlue : Str14;
FUNCTION aLtGreenOnBlue : Str14;
FUNCTION abLtGreenOnBlue : Str14;
FUNCTION aLtCyanOnBlue : Str14;
FUNCTION abLtCyanOnBlue : Str14;
FUNCTION aLtRedOnBlue : Str14;
FUNCTION abLtRedOnBlue : Str14;
FUNCTION aLtMagentaOnBlue : Str14;
FUNCTION abLtMagentaOnBlue : Str14;
FUNCTION aYellowOnBlue : Str14;
FUNCTION abYellowOnBlue : Str14;
FUNCTION aWhiteOnBlue : Str14;
FUNCTION abWhiteOnBlue : Str14;

{Green background}
FUNCTION aBlackOnGreen : Str14;
FUNCTION abBlackOnGreen : Str14;
FUNCTION aBlueOnGreen : Str14;
FUNCTION abBlueOnGreen : Str14;
FUNCTION aGreenOnGreen : Str14;
FUNCTION abGreenOnGreen : Str14;
FUNCTION aCyanOnGreen : Str14;
FUNCTION abCyanOnGreen : Str14;
FUNCTION aRedOnGreen : Str14;
FUNCTION abRedOnGreen : Str14;
FUNCTION aMagentaOnGreen : Str14;
FUNCTION abMagentaOnGreen : Str14;
FUNCTION aBrownOnGreen : Str14;
FUNCTION abBrownOnGreen : Str14;
FUNCTION aLtGrayOnGreen : Str14;
FUNCTION abLtGrayOnGreen : Str14;
FUNCTION aDkGrayOnGreen : Str14;
FUNCTION abDkGrayOnGreen : Str14;
FUNCTION aLtBlueOnGreen : Str14;
FUNCTION abLtBlueOnGreen : Str14;
FUNCTION aLtGreenOnGreen : Str14;
FUNCTION abLtGreenOnGreen : Str14;
FUNCTION aLtCyanOnGreen : Str14;
FUNCTION abLtCyanOnGreen : Str14;
FUNCTION aLtRedOnGreen : Str14;
FUNCTION abLtRedOnGreen : Str14;
FUNCTION aLtMagentaOnGreen : Str14;
FUNCTION abLtMagentaOnGreen : Str14;
FUNCTION aYellowOnGreen : Str14;
FUNCTION abYellowOnGreen : Str14;
FUNCTION aWhiteOnGreen : Str14;
FUNCTION abWhiteOnGreen : Str14;

{Cyan background}
FUNCTION aBlackOnCyan : Str14;
FUNCTION abBlackOnCyan : Str14;
FUNCTION aBlueOnCyan : Str14;
FUNCTION abBlueOnCyan : Str14;
FUNCTION aGreenOnCyan : Str14;
FUNCTION abGreenOnCyan : Str14;
FUNCTION aCyanOnCyan : Str14;
FUNCTION abCyanOnCyan : Str14;
FUNCTION aRedOnCyan : Str14;
FUNCTION abRedOnCyan : Str14;
FUNCTION aMagentaOnCyan : Str14;
FUNCTION abMagentaOnCyan : Str14;
FUNCTION aBrownOnCyan : Str14;
FUNCTION abBrownOnCyan : Str14;
FUNCTION aLtGrayOnCyan : Str14;
FUNCTION abLtGrayOnCyan : Str14;
FUNCTION aDkGrayOnCyan : Str14;
FUNCTION abDkGrayOnCyan : Str14;
FUNCTION aLtBlueOnCyan : Str14;
FUNCTION abLtBlueOnCyan : Str14;
FUNCTION aLtGreenOnCyan : Str14;
FUNCTION abLtGreenOnCyan : Str14;
FUNCTION aLtCyanOnCyan : Str14;
FUNCTION abLtCyanOnCyan : Str14;
FUNCTION aLtRedOnCyan : Str14;
FUNCTION abLtRedOnCyan : Str14;
FUNCTION aLtMagentaOnCyan : Str14;
FUNCTION abLtMagentaOnCyan : Str14;
FUNCTION aYellowOnCyan : Str14;
FUNCTION abYellowOnCyan : Str14;
FUNCTION aWhiteOnCyan : Str14;
FUNCTION abWhiteOnCyan : Str14;

{Red background}
FUNCTION aBlackOnRed : Str14;
FUNCTION abBlackOnRed : Str14;
FUNCTION aBlueOnRed : Str14;
FUNCTION abBlueOnRed : Str14;
FUNCTION aGreenOnRed : Str14;
FUNCTION abGreenOnRed : Str14;
FUNCTION aCyanOnRed : Str14;
FUNCTION abCyanOnRed : Str14;
FUNCTION aRedOnRed : Str14;
FUNCTION abRedOnRed : Str14;
FUNCTION aMagentaOnRed : Str14;
FUNCTION abMagentaOnRed : Str14;
FUNCTION aBrownOnRed : Str14;
FUNCTION abBrownOnRed : Str14;
FUNCTION aLtGrayOnRed : Str14;
FUNCTION abLtGrayOnRed : Str14;
FUNCTION aDkGrayOnRed : Str14;
FUNCTION abDkGrayOnRed : Str14;
FUNCTION aLtBlueOnRed : Str14;
FUNCTION abLtBlueOnRed : Str14;
FUNCTION aLtGreenOnRed : Str14;
FUNCTION abLtGreenOnRed : Str14;
FUNCTION aLtCyanOnRed : Str14;
FUNCTION abLtCyanOnRed : Str14;
FUNCTION aLtRedOnRed : Str14;
FUNCTION abLtRedOnRed : Str14;
FUNCTION aLtMagentaOnRed : Str14;
FUNCTION abLtMagentaOnRed : Str14;
FUNCTION aYellowOnRed : Str14;
FUNCTION abYellowOnRed : Str14;
FUNCTION aWhiteOnRed : Str14;
FUNCTION abWhiteOnRed : Str14;

{Magenta background}
FUNCTION aBlackOnMagenta : Str14;
FUNCTION abBlackOnMagenta : Str14;
FUNCTION aBlueOnMagenta : Str14;
FUNCTION abBlueOnMagenta : Str14;
FUNCTION aGreenOnMagenta : Str14;
FUNCTION abGreenOnMagenta : Str14;
FUNCTION aCyanOnMagenta : Str14;
FUNCTION abCyanOnMagenta : Str14;
FUNCTION aRedOnMagenta : Str14;
FUNCTION abRedOnMagenta : Str14;
FUNCTION aMagentaOnMagenta : Str14;
FUNCTION abMagentaOnMagenta : Str14;
FUNCTION aBrownOnMagenta : Str14;
FUNCTION abBrownOnMagenta : Str14;
FUNCTION aLtGrayOnMagenta : Str14;
FUNCTION abLtGrayOnMagenta : Str14;
FUNCTION aDkGrayOnMagenta : Str14;
FUNCTION abDkGrayOnMagenta : Str14;
FUNCTION aLtBlueOnMagenta : Str14;
FUNCTION abLtBlueOnMagenta : Str14;
FUNCTION aLtGreenOnMagenta : Str14;
FUNCTION abLtGreenOnMagenta : Str14;
FUNCTION aLtCyanOnMagenta : Str14;
FUNCTION abLtCyanOnMagenta : Str14;
FUNCTION aLtRedOnMagenta : Str14;
FUNCTION abLtRedOnMagenta : Str14;
FUNCTION aLtMagentaOnMagenta : Str14;
FUNCTION abLtMagentaOnMagenta : Str14;
FUNCTION aYellowOnMagenta : Str14;
FUNCTION abYellowOnMagenta : Str14;
FUNCTION aWhiteOnMagenta : Str14;
FUNCTION abWhiteOnMagenta : Str14;

{Brown background}
FUNCTION aBlackOnBrown : Str14;
FUNCTION abBlackOnBrown : Str14;
FUNCTION aBlueOnBrown : Str14;
FUNCTION abBlueOnBrown : Str14;
FUNCTION aGreenOnBrown : Str14;
FUNCTION abGreenOnBrown : Str14;
FUNCTION aCyanOnBrown : Str14;
FUNCTION abCyanOnBrown : Str14;
FUNCTION aRedOnBrown : Str14;
FUNCTION abRedOnBrown : Str14;
FUNCTION aMagentaOnBrown : Str14;
FUNCTION abMagentaOnBrown : Str14;
FUNCTION aBrownOnBrown : Str14;
FUNCTION abBrownOnBrown : Str14;
FUNCTION aLtGrayOnBrown : Str14;
FUNCTION abLtGrayOnBrown : Str14;
FUNCTION aDkGrayOnBrown : Str14;
FUNCTION abDkGrayOnBrown : Str14;
FUNCTION aLtBlueOnBrown : Str14;
FUNCTION abLtBlueOnBrown : Str14;
FUNCTION aLtGreenOnBrown : Str14;
FUNCTION abLtGreenOnBrown : Str14;
FUNCTION aLtCyanOnBrown : Str14;
FUNCTION abLtCyanOnBrown : Str14;
FUNCTION aLtRedOnBrown : Str14;
FUNCTION abLtRedOnBrown : Str14;
FUNCTION aLtMagentaOnBrown : Str14;
FUNCTION abLtMagentaOnBrown : Str14;
FUNCTION aYellowOnBrown : Str14;
FUNCTION abYellowOnBrown : Str14;
FUNCTION aWhiteOnBrown : Str14;
FUNCTION abWhiteOnBrown : Str14;

{Light gray backgrouund}
FUNCTION aBlackOnLtGray : Str14;
FUNCTION abBlackOnLtGray : Str14;
FUNCTION aBlueOnLtGray : Str14;
FUNCTION abBlueOnLtGray : Str14;
FUNCTION aGreenOnLtGray : Str14;
FUNCTION abGreenOnLtGray : Str14;
FUNCTION aCyanOnLtGray : Str14;
FUNCTION abCyanOnLtGray : Str14;
FUNCTION aRedOnLtGray : Str14;
FUNCTION abRedOnLtGray : Str14;
FUNCTION aMagentaOnLtGray : Str14;
FUNCTION abMagentaOnLtGray : Str14;
FUNCTION aBrownOnLtGray : Str14;
FUNCTION abBrownOnLtGray : Str14;
FUNCTION aLtGrayOnLtGray : Str14;
FUNCTION abLtGrayOnLtGray : Str14;
FUNCTION aDkGrayOnLtGray : Str14;
FUNCTION abDkGrayOnLtGray : Str14;
FUNCTION aLtBlueOnLtGray : Str14;
FUNCTION abLtBlueOnLtGray : Str14;
FUNCTION aLtGreenOnLtGray : Str14;
FUNCTION abLtGreenOnLtGray : Str14;
FUNCTION aLtCyanOnLtGray : Str14;
FUNCTION abLtCyanOnLtGray : Str14;
FUNCTION aLtRedOnLtGray : Str14;
FUNCTION abLtRedOnLtGray : Str14;
FUNCTION aLtMagentaOnLtGray : Str14;
FUNCTION abLtMagentaOnLtGray : Str14;
FUNCTION aYellowOnLtGray : Str14;
FUNCTION abYellowOnLtGray : Str14;
FUNCTION aWhiteOnLtGray : Str14;
FUNCTION abWhiteOnLtGray : Str14;

{==========================================================================}

IMPLEMENTATION

CONST

{ Foreground and background color constants }

Black : BYTE = 0;
Blue : BYTE = 1;
Green : BYTE = 2;
Cyan : BYTE = 3;
Red : BYTE = 4;
Magenta : BYTE = 5;
Brown : BYTE = 6;
LightGray : BYTE = 7;

{ Foreground color constants }

DarkGray : BYTE = 8;
LightBlue : BYTE = 9;
LightGreen : BYTE = 10;
LightCyan : BYTE = 11;
LightRed : BYTE = 12;
LightMagenta : BYTE = 13;
Yellow : BYTE = 14;
White : BYTE = 15;



FUNCTION MakeAnsiString (ForeG, BackG : BYTE) : Str14;
BEGIN
MakeAnsiString := aSt + fgCol [ForeG] + bgCol [BackG] + aEnd;
END;



{Black background}
FUNCTION aBlackOnBlack : Str14;
BEGIN
aBlackOnBlack := MakeAnsiString (Black, Black);
END;


FUNCTION abBlackOnBlack : Str14;
BEGIN
abBlackOnBlack := MakeAnsiString (Black + aBlink, Black);
END;


FUNCTION aBlueOnBlack : Str14;
BEGIN
aBlueOnBlack := MakeAnsiString (Blue, Black);
END;


FUNCTION abBlueOnBlack : Str14;
BEGIN
abBlueOnBlack := MakeAnsiString (Blue + aBlink, Black);
END;


FUNCTION aGreenOnBlack : Str14;
BEGIN
aGreenOnBlack := MakeAnsiString (Green, Black);
END;


FUNCTION abGreenOnBlack : Str14;
BEGIN
abGreenOnBlack := MakeAnsiString (Green + aBlink, Black);
END;


FUNCTION aCyanOnBlack : Str14;
BEGIN
aCyanOnBlack := MakeAnsiString (Cyan, Black);
END;


FUNCTION abCyanOnBlack : Str14;
BEGIN
abCyanOnBlack := MakeAnsiString (Cyan + aBlink, Black);
END;


FUNCTION aRedOnBlack : Str14;
BEGIN
aRedOnBlack := MakeAnsiString (Red, Black);
END;


FUNCTION abRedOnBlack : Str14;
BEGIN
abRedOnBlack := MakeAnsiString (Red + aBlink, Black);
END;


FUNCTION aMagentaOnBlack : Str14;
BEGIN
aMagentaOnBlack := MakeAnsiString (Magenta, Black);
END;


FUNCTION abMagentaOnBlack : Str14;
BEGIN
abMagentaOnBlack := MakeAnsiString (Magenta + aBlink, Black);
END;


FUNCTION aBrownOnBlack : Str14;
BEGIN
aBrownOnBlack := MakeAnsiString (Brown, Black);
END;


FUNCTION abBrownOnBlack : Str14;
BEGIN
abBrownOnBlack := MakeAnsiString (Brown + aBlink, Black);
END;


FUNCTION aLtGrayOnBlack : Str14;
BEGIN
aLtGrayOnBlack := MakeAnsiString (LightGray, Black);
END;


FUNCTION abLtGrayOnBlack : Str14;
BEGIN
abLtGrayOnBlack := MakeAnsiString (LightGray + aBlink, Black);
END;


FUNCTION aDkGrayOnBlack : Str14;
BEGIN
aDkGrayOnBlack := MakeAnsiString (DarkGray, Black);
END;


FUNCTION abDkGrayOnBlack : Str14;
BEGIN
abDkGrayOnBlack := MakeAnsiString (DarkGray + aBlink, Black);
END;


FUNCTION aLtBlueOnBlack : Str14;
BEGIN
aLtBlueOnBlack := MakeAnsiString (LightBlue, Black);
END;


FUNCTION abLtBlueOnBlack : Str14;
BEGIN
abLtBlueOnBlack := MakeAnsiString (LightBlue + aBlink, Black);
END;


FUNCTION aLtGreenOnBlack : Str14;
BEGIN
aLtGreenOnBlack := MakeAnsiString (LightGreen, Black);
END;


FUNCTION abLtGreenOnBlack : Str14;
BEGIN
abLtGreenOnBlack := MakeAnsiString (LightGreen + aBlink, Black);
END;


FUNCTION aLtCyanOnBlack : Str14;
BEGIN
aLtCyanOnBlack := MakeAnsiString (LightCyan, Black);
END;


FUNCTION abLtCyanOnBlack : Str14;
BEGIN
abLtCyanOnBlack := MakeAnsiString (LightCyan + aBlink, Black);
END;


FUNCTION aLtRedOnBlack : Str14;
BEGIN
aLtRedOnBlack := MakeAnsiString (LightRed, Black);
END;


FUNCTION abLtRedOnBlack : Str14;
BEGIN
abLtRedOnBlack := MakeAnsiString (LightRed + aBlink, Black);
END;


FUNCTION aLtMagentaOnBlack : Str14;
BEGIN
aLtMagentaOnBlack := MakeAnsiString (LightMagenta, Black);
END;


FUNCTION abLtMagentaOnBlack : Str14;
BEGIN
abLtMagentaOnBlack := MakeAnsiString (LightMagenta + aBlink, Black);
END;


FUNCTION aYellowOnBlack : Str14;
BEGIN
aYellowOnBlack := MakeAnsiString (Yellow, Black);
END;


FUNCTION abYellowOnBlack : Str14;
BEGIN
abYellowOnBlack := MakeAnsiString (Yellow + aBlink, Black);
END;


FUNCTION aWhiteOnBlack : Str14;
BEGIN
aWhiteOnBlack := MakeAnsiString (White, Black);
END;


FUNCTION abWhiteOnBlack : Str14;
BEGIN
abWhiteOnBlack := MakeAnsiString (White + aBlink, Black);
END;



{Blue background}
FUNCTION aBlackOnBlue : Str14;
BEGIN
aBlackOnBlue := MakeAnsiString (Black, Blue);
END;


FUNCTION abBlackOnBlue : Str14;
BEGIN
abBlackOnBlue := MakeAnsiString (Black + aBlink, Blue);
END;


FUNCTION aBlueOnBlue : Str14;
BEGIN
aBlueOnBlue := MakeAnsiString (Blue, Blue);
END;


FUNCTION abBlueOnBlue : Str14;
BEGIN
abBlueOnBlue := MakeAnsiString (Blue + aBlink, Blue);
END;


FUNCTION aGreenOnBlue : Str14;
BEGIN
aGreenOnBlue := MakeAnsiString (Green, Blue);
END;


FUNCTION abGreenOnBlue : Str14;
BEGIN
abGreenOnBlue := MakeAnsiString (Green + aBlink, Blue);
END;


FUNCTION aCyanOnBlue : Str14;
BEGIN
aCyanOnBlue := MakeAnsiString (Cyan, Blue);
END;


FUNCTION abCyanOnBlue : Str14;
BEGIN
abCyanOnBlue := MakeAnsiString (Cyan + aBlink, Blue);
END;


FUNCTION aRedOnBlue : Str14;
BEGIN
aRedOnBlue := MakeAnsiString (Red, Blue);
END;


FUNCTION abRedOnBlue : Str14;
BEGIN
abRedOnBlue := MakeAnsiString (Red + aBlink, Blue);
END;


FUNCTION aMagentaOnBlue : Str14;
BEGIN
aMagentaOnBlue := MakeAnsiString (Magenta, Blue);
END;


FUNCTION abMagentaOnBlue : Str14;
BEGIN
abMagentaOnBlue := MakeAnsiString (Magenta + aBlink, Blue);
END;


FUNCTION aBrownOnBlue : Str14;
BEGIN
aBrownOnBlue := MakeAnsiString (Brown, Blue);
END;


FUNCTION abBrownOnBlue : Str14;
BEGIN
abBrownOnBlue := MakeAnsiString (Brown + aBlink, Blue);
END;


FUNCTION aLtGrayOnBlue : Str14;
BEGIN
aLtGrayOnBlue := MakeAnsiString (LightGray, Blue);
END;


FUNCTION abLtGrayOnBlue : Str14;
BEGIN
abLtGrayOnBlue := MakeAnsiString (LightGray + aBlink, Blue);
END;


FUNCTION aDkGrayOnBlue : Str14;
BEGIN
aDkGrayOnBlue := MakeAnsiString (DarkGray, Blue);
END;


FUNCTION abDkGrayOnBlue : Str14;
BEGIN
abDkGrayOnBlue := MakeAnsiString (DarkGray + aBlink, Blue);
END;


FUNCTION aLtBlueOnBlue : Str14;
BEGIN
aLtBlueOnBlue := MakeAnsiString (LightBlue, Blue);
END;


FUNCTION abLtBlueOnBlue : Str14;
BEGIN
abLtBlueOnBlue := MakeAnsiString (LightBlue + aBlink, Blue);
END;


FUNCTION aLtGreenOnBlue : Str14;
BEGIN
aLtGreenOnBlue := MakeAnsiString (LightGreen, Blue);
END;


FUNCTION abLtGreenOnBlue : Str14;
BEGIN
abLtGreenOnBlue := MakeAnsiString (LightGreen + aBlink, Blue);
END;


FUNCTION aLtCyanOnBlue : Str14;
BEGIN
aLtCyanOnBlue := MakeAnsiString (LightCyan, Blue);
END;


FUNCTION abLtCyanOnBlue : Str14;
BEGIN
abLtCyanOnBlue := MakeAnsiString (LightCyan + aBlink, Blue);
END;


FUNCTION aLtRedOnBlue : Str14;
BEGIN
aLtRedOnBlue := MakeAnsiString (LightRed, Blue);
END;


FUNCTION abLtRedOnBlue : Str14;
BEGIN
abLtRedOnBlue := MakeAnsiString (LightRed + aBlink, Blue);
END;


FUNCTION aLtMagentaOnBlue : Str14;
BEGIN
aLtMagentaOnBlue := MakeAnsiString (LightMagenta, Blue);
END;


FUNCTION abLtMagentaOnBlue : Str14;
BEGIN
abLtMagentaOnBlue := MakeAnsiString (LightMagenta + aBlink, Blue);
END;


FUNCTION aYellowOnBlue : Str14;
BEGIN
aYellowOnBlue := MakeAnsiString (Yellow, Blue);
END;


FUNCTION abYellowOnBlue : Str14;
BEGIN
abYellowOnBlue := MakeAnsiString (Yellow + aBlink, Blue);
END;


FUNCTION aWhiteOnBlue : Str14;
BEGIN
aWhiteOnBlue := MakeAnsiString (White, Blue);
END;


FUNCTION abWhiteOnBlue : Str14;
BEGIN
abWhiteOnBlue := MakeAnsiString (White + aBlink, Blue);
END;



{Green background}
FUNCTION aBlackOnGreen : Str14;
BEGIN
aBlackOnGreen := MakeAnsiString (Black, Green);
END;


FUNCTION abBlackOnGreen : Str14;
BEGIN
abBlackOnGreen := MakeAnsiString (Black + aBlink, Green);
END;


FUNCTION aBlueOnGreen : Str14;
BEGIN
aBlueOnGreen := MakeAnsiString (Blue, Green);
END;


FUNCTION abBlueOnGreen : Str14;
BEGIN
abBlueOnGreen := MakeAnsiString (Blue + aBlink, Green);
END;


FUNCTION aGreenOnGreen : Str14;
BEGIN
aGreenOnGreen := MakeAnsiString (Green, Green);
END;



FUNCTION abGreenOnGreen : Str14;
BEGIN
abGreenOnGreen := MakeAnsiString (Green + aBlink, Green);
END;


FUNCTION aCyanOnGreen : Str14;
BEGIN
aCyanOnGreen := MakeAnsiString (Cyan, Green);
END;


FUNCTION abCyanOnGreen : Str14;
BEGIN
abCyanOnGreen := MakeAnsiString (Cyan + aBlink, Green);
END;


FUNCTION aRedOnGreen : Str14;
BEGIN
aRedOnGreen := MakeAnsiString (Red, Green);
END;


FUNCTION abRedOnGreen : Str14;
BEGIN
abRedOnGreen := MakeAnsiString (Red + aBlink, Green);
END;


FUNCTION aMagentaOnGreen : Str14;
BEGIN
aMagentaOnGreen := MakeAnsiString (Magenta, Green);
END;


FUNCTION abMagentaOnGreen : Str14;
BEGIN
abMagentaOnGreen := MakeAnsiString (Magenta + aBlink, Green);
END;


FUNCTION aBrownOnGreen : Str14;
BEGIN
aBrownOnGreen := MakeAnsiString (Brown, Green);
END;


FUNCTION abBrownOnGreen : Str14;
BEGIN
abBrownOnGreen := MakeAnsiString (Brown + aBlink, Green);
END;


FUNCTION aLtGrayOnGreen : Str14;
BEGIN
aLtGrayOnGreen := MakeAnsiString (LightGray, Green);
END;


FUNCTION abLtGrayOnGreen : Str14;
BEGIN
abLtGrayOnGreen := MakeAnsiString (LightGray + aBlink, Green);
END;


FUNCTION aDkGrayOnGreen : Str14;
BEGIN
aDkGrayOnGreen := MakeAnsiString (DarkGray, Green);
END;


FUNCTION abDkGrayOnGreen : Str14;
BEGIN
abDkGrayOnGreen := MakeAnsiString (DarkGray + aBlink, Green);
END;


FUNCTION aLtBlueOnGreen : Str14;
BEGIN
aLtBlueOnGreen := MakeAnsiString (LightBlue, Green);
END;


FUNCTION abLtBlueOnGreen : Str14;
BEGIN
abLtBlueOnGreen := MakeAnsiString (LightBlue + aBlink, Green);
END;


FUNCTION aLtGreenOnGreen : Str14;
BEGIN
aLtGreenOnGreen := MakeAnsiString (LightGreen, Green);
END;


FUNCTION abLtGreenOnGreen : Str14;
BEGIN
abLtGreenOnGreen := MakeAnsiString (LightGreen + aBlink, Green);
END;


FUNCTION aLtCyanOnGreen : Str14;
BEGIN
aLtCyanOnGreen := MakeAnsiString (LightCyan, Green);
END;


FUNCTION abLtCyanOnGreen : Str14;
BEGIN
abLtCyanOnGreen := MakeAnsiString (LightCyan + aBlink, Green);
END;


FUNCTION aLtRedOnGreen : Str14;
BEGIN
aLtRedOnGreen := MakeAnsiString (LightRed, Green);
END;


FUNCTION abLtRedOnGreen : Str14;
BEGIN
abLtRedOnGreen := MakeAnsiString (LightRed + aBlink, Green);
END;


FUNCTION aLtMagentaOnGreen : Str14;
BEGIN
aLtMagentaOnGreen := MakeAnsiString (LightMagenta, Green);
END;


FUNCTION abLtMagentaOnGreen : Str14;
BEGIN
abLtMagentaOnGreen := MakeAnsiString (LightMagenta + aBlink, Green);
END;


FUNCTION aYellowOnGreen : Str14;
BEGIN
aYellowOnGreen := MakeAnsiString (Yellow, Green);
END;


FUNCTION abYellowOnGreen : Str14;
BEGIN
abYellowOnGreen := MakeAnsiString (Yellow + aBlink, Green);
END;


FUNCTION aWhiteOnGreen : Str14;
BEGIN
aWhiteOnGreen := MakeAnsiString (White, Green);
END;


FUNCTION abWhiteOnGreen : Str14;
BEGIN
abWhiteOnGreen := MakeAnsiString (White + aBlink, Green);
END;



{Cyan background}
FUNCTION aBlackOnCyan : Str14;
BEGIN
aBlackOnCyan := MakeAnsiString (Black, Cyan);
END;


FUNCTION abBlackOnCyan : Str14;
BEGIN
abBlackOnCyan := MakeAnsiString (Black + aBlink, Cyan);
END;


FUNCTION aBlueOnCyan : Str14;
BEGIN
aBlueOnCyan := MakeAnsiString (Blue, Cyan);
END;


FUNCTION abBlueOnCyan : Str14;
BEGIN
abBlueOnCyan := MakeAnsiString (Blue + aBlink, Cyan);
END;


FUNCTION aGreenOnCyan : Str14;
BEGIN
aGreenOnCyan := MakeAnsiString (Green, Cyan);
END;


FUNCTION abGreenOnCyan : Str14;
BEGIN
abGreenOnCyan := MakeAnsiString (Green + aBlink, Cyan);
END;


FUNCTION aCyanOnCyan : Str14;
BEGIN
aCyanOnCyan := MakeAnsiString (Cyan, Cyan);
END;


FUNCTION abCyanOnCyan : Str14;
BEGIN
abCyanOnCyan := MakeAnsiString (Cyan + aBlink, Cyan);
END;


FUNCTION aRedOnCyan : Str14;
BEGIN
aRedOnCyan := MakeAnsiString (Red, Cyan);
END;


FUNCTION abRedOnCyan : Str14;
BEGIN
abRedOnCyan := MakeAnsiString (Red + aBlink, Cyan);
END;


FUNCTION aMagentaOnCyan : Str14;
BEGIN
aMagentaOnCyan := MakeAnsiString (Magenta, Cyan);
END;


FUNCTION abMagentaOnCyan : Str14;
BEGIN
abMagentaOnCyan := MakeAnsiString (Magenta + aBlink, Cyan);
END;


FUNCTION aBrownOnCyan : Str14;
BEGIN
aBrownOnCyan := MakeAnsiString (Brown, Cyan);
END;


FUNCTION abBrownOnCyan : Str14;
BEGIN
abBrownOnCyan := MakeAnsiString (Brown + aBlink, Cyan);
END;


FUNCTION aLtGrayOnCyan : Str14;
BEGIN
aLtGrayOnCyan := MakeAnsiString (LightGray, Cyan);
END;


FUNCTION abLtGrayOnCyan : Str14;
BEGIN
abLtGrayOnCyan := MakeAnsiString (LightGray + aBlink, Cyan);
END;


FUNCTION aDkGrayOnCyan : Str14;
BEGIN
aDkGrayOnCyan := MakeAnsiString (DarkGray, Cyan);
END;


FUNCTION abDkGrayOnCyan : Str14;
BEGIN
abDkGrayOnCyan := MakeAnsiString (DarkGray + aBlink, Cyan);
END;


FUNCTION aLtBlueOnCyan : Str14;
BEGIN
aLtBlueOnCyan := MakeAnsiString (LightBlue, Cyan);
END;


FUNCTION abLtBlueOnCyan : Str14;
BEGIN
abLtBlueOnCyan := MakeAnsiString (LightBlue + aBlink, Cyan);
END;


FUNCTION aLtGreenOnCyan : Str14;
BEGIN
aLtGreenOnCyan := MakeAnsiString (LightGreen, Cyan);
END;


FUNCTION abLtGreenOnCyan : Str14;
BEGIN
abLtGreenOnCyan := MakeAnsiString (LightGreen + aBlink, Cyan);
END;


FUNCTION aLtCyanOnCyan : Str14;
BEGIN
aLtCyanOnCyan := MakeAnsiString (LightCyan, Cyan);
END;


FUNCTION abLtCyanOnCyan : Str14;
BEGIN
abLtCyanOnCyan := MakeAnsiString (LightCyan + aBlink, Cyan);
END;


FUNCTION aLtRedOnCyan : Str14;
BEGIN
aLtRedOnCyan := MakeAnsiString (LightRed, Cyan);
END;


FUNCTION abLtRedOnCyan : Str14;
BEGIN
abLtRedOnCyan := MakeAnsiString (LightRed + aBlink, Cyan);
END;


FUNCTION aLtMagentaOnCyan : Str14;
BEGIN
aLtMagentaOnCyan := MakeAnsiString (LightMagenta, Cyan);
END;


FUNCTION abLtMagentaOnCyan : Str14;
BEGIN
abLtMagentaOnCyan := MakeAnsiString (LightMagenta + aBlink, Cyan);
END;


FUNCTION aYellowOnCyan : Str14;
BEGIN
aYellowOnCyan := MakeAnsiString (Yellow, Cyan);
END;


FUNCTION abYellowOnCyan : Str14;
BEGIN
abYellowOnCyan := MakeAnsiString (Yellow + aBlink, Cyan);
END;


FUNCTION aWhiteOnCyan : Str14;
BEGIN
aWhiteOnCyan := MakeAnsiString (White, Cyan);
END;


FUNCTION abWhiteOnCyan : Str14;
BEGIN
abWhiteOnCyan := MakeAnsiString (White + aBlink, Cyan);
END;



{Red background}
FUNCTION aBlackOnRed : Str14;
BEGIN
aBlackOnRed := MakeAnsiString (Black, Red);
END;


FUNCTION abBlackOnRed : Str14;
BEGIN
abBlackOnRed := MakeAnsiString (Black + aBlink, Red);
END;


FUNCTION aBlueOnRed : Str14;
BEGIN
aBlueOnRed := MakeAnsiString (Blue, Red);
END;


FUNCTION abBlueOnRed : Str14;
BEGIN
abBlueOnRed := MakeAnsiString (Blue + aBlink, Red);
END;


FUNCTION aGreenOnRed : Str14;
BEGIN
aGreenOnRed := MakeAnsiString (Green, Red);
END;


FUNCTION abGreenOnRed : Str14;
BEGIN
abGreenOnRed := MakeAnsiString (Green + aBlink, Red);
END;


FUNCTION aCyanOnRed : Str14;
BEGIN
aCyanOnRed := MakeAnsiString (Cyan, Red);
END;


FUNCTION abCyanOnRed : Str14;
BEGIN
abCyanOnRed := MakeAnsiString (Cyan + aBlink, Red);
END;


FUNCTION aRedOnRed : Str14;
BEGIN
aRedOnRed := MakeAnsiString (Red, Red);
END;


FUNCTION abRedOnRed : Str14;
BEGIN
abRedOnRed := MakeAnsiString (Red + aBlink, Red);
END;


FUNCTION aMagentaOnRed : Str14;
BEGIN
aMagentaOnRed := MakeAnsiString (Magenta, Red);
END;


FUNCTION abMagentaOnRed : Str14;
BEGIN
abMagentaOnRed := MakeAnsiString (Magenta + aBlink, Red);
END;


FUNCTION aBrownOnRed : Str14;
BEGIN
aBrownOnRed := MakeAnsiString (Brown, Red);
END;


FUNCTION abBrownOnRed : Str14;
BEGIN
abBrownOnRed := MakeAnsiString (Brown + aBlink, Red);
END;


FUNCTION aLtGrayOnRed : Str14;
BEGIN
aLtGrayOnRed := MakeAnsiString (LightGray, Red);
END;


FUNCTION abLtGrayOnRed : Str14;
BEGIN
abLtGrayOnRed := MakeAnsiString (LightGray + aBlink, Red);
END;


FUNCTION aDkGrayOnRed : Str14;
BEGIN
aDkGrayOnRed := MakeAnsiString (DarkGray, Red);
END;


FUNCTION abDkGrayOnRed : Str14;
BEGIN
abDkGrayOnRed := MakeAnsiString (DarkGray + aBlink, Red);
END;


FUNCTION aLtBlueOnRed : Str14;
BEGIN
aLtBlueOnRed := MakeAnsiString (LightBlue, Red);
END;


FUNCTION abLtBlueOnRed : Str14;
BEGIN
abLtBlueOnRed := MakeAnsiString (LightBlue + aBlink, Red);
END;


FUNCTION aLtGreenOnRed : Str14;
BEGIN
aLtGreenOnRed := MakeAnsiString (LightGreen, Red);
END;


FUNCTION abLtGreenOnRed : Str14;
BEGIN
abLtGreenOnRed := MakeAnsiString (LightGreen + aBlink, Red);
END;


FUNCTION aLtCyanOnRed : Str14;
BEGIN
aLtCyanOnRed := MakeAnsiString (LightCyan, Red);
END;


FUNCTION abLtCyanOnRed : Str14;
BEGIN
abLtCyanOnRed := MakeAnsiString (LightCyan + aBlink, Red);
END;


FUNCTION aLtRedOnRed : Str14;
BEGIN
aLtRedOnRed := MakeAnsiString (LightRed, Red);
END;


FUNCTION abLtRedOnRed : Str14;
BEGIN
abLtRedOnRed := MakeAnsiString (LightRed + aBlink, Red);
END;


FUNCTION aLtMagentaOnRed : Str14;
BEGIN
aLtMagentaOnRed := MakeAnsiString (LightMagenta, Red);
END;


FUNCTION abLtMagentaOnRed : Str14;
BEGIN
abLtMagentaOnRed := MakeAnsiString (LightMagenta + aBlink, Red);
END;


FUNCTION aYellowOnRed : Str14;
BEGIN
aYellowOnRed := MakeAnsiString (Yellow, Red);
END;


FUNCTION abYellowOnRed : Str14;
BEGIN
abYellowOnRed := MakeAnsiString (Yellow + aBlink, Red);
END;


FUNCTION aWhiteOnRed : Str14;
BEGIN
aWhiteOnRed := MakeAnsiString (White, Red);
END;


FUNCTION abWhiteOnRed : Str14;
BEGIN
abWhiteOnRed := MakeAnsiString (White + aBlink, Red);
END;



{Magenta background}
FUNCTION aBlackOnMagenta : Str14;
BEGIN
aBlackOnMagenta := MakeAnsiString (Black, Magenta);
END;


FUNCTION abBlackOnMagenta : Str14;
BEGIN
abBlackOnMagenta := MakeAnsiString (Black + aBlink, Magenta);
END;


FUNCTION aBlueOnMagenta : Str14;
BEGIN
aBlueOnMagenta := MakeAnsiString (Blue, Magenta);
END;


FUNCTION abBlueOnMagenta : Str14;
BEGIN
abBlueOnMagenta := MakeAnsiString (Blue + aBlink, Magenta);
END;


FUNCTION aGreenOnMagenta : Str14;
BEGIN
aGreenOnMagenta := MakeAnsiString (Green, Magenta);
END;


FUNCTION abGreenOnMagenta : Str14;
BEGIN
abGreenOnMagenta := MakeAnsiString (Green + aBlink, Magenta);
END;


FUNCTION aCyanOnMagenta : Str14;
BEGIN
aCyanOnMagenta := MakeAnsiString (Cyan, Magenta);
END;


FUNCTION abCyanOnMagenta : Str14;
BEGIN
abCyanOnMagenta := MakeAnsiString (Cyan + aBlink, Magenta);
END;


FUNCTION aRedOnMagenta : Str14;
BEGIN
aRedOnMagenta := MakeAnsiString (Red, Magenta);
END;


FUNCTION abRedOnMagenta : Str14;
BEGIN
abRedOnMagenta := MakeAnsiString (Red + aBlink, Magenta);
END;


FUNCTION aMagentaOnMagenta : Str14;
BEGIN
aMagentaOnMagenta := MakeAnsiString (Magenta, Magenta);
END;


FUNCTION abMagentaOnMagenta : Str14;
BEGIN
abMagentaOnMagenta := MakeAnsiString (Magenta + aBlink, Magenta);
END;


FUNCTION aBrownOnMagenta : Str14;
BEGIN
aBrownOnMagenta := MakeAnsiString (Brown, Magenta);
END;


FUNCTION abBrownOnMagenta : Str14;
BEGIN
abBrownOnMagenta := MakeAnsiString (Brown + aBlink, Magenta);
END;


FUNCTION aLtGrayOnMagenta : Str14;
BEGIN
aLtGrayOnMagenta := MakeAnsiString (LightGray, Magenta);
END;


FUNCTION abLtGrayOnMagenta : Str14;
BEGIN
abLtGrayOnMagenta := MakeAnsiString (LightGray + aBlink, Magenta);
END;


FUNCTION aDkGrayOnMagenta : Str14;
BEGIN
aDkGrayOnMagenta := MakeAnsiString (DarkGray, Magenta);
END;


FUNCTION abDkGrayOnMagenta : Str14;
BEGIN
abDkGrayOnMagenta := MakeAnsiString (DarkGray + aBlink, Magenta);
END;


FUNCTION aLtBlueOnMagenta : Str14;
BEGIN
aLtBlueOnMagenta := MakeAnsiString (LightBlue, Magenta);
END;


FUNCTION abLtBlueOnMagenta : Str14;
BEGIN
abLtBlueOnMagenta := MakeAnsiString (LightBlue + aBlink, Magenta);
END;


FUNCTION aLtGreenOnMagenta : Str14;
BEGIN
aLtGreenOnMagenta := MakeAnsiString (LightGreen, Magenta);
END;


FUNCTION abLtGreenOnMagenta : Str14;
BEGIN
abLtGreenOnMagenta := MakeAnsiString (LightGreen + aBlink, Magenta);
END;


FUNCTION aLtCyanOnMagenta : Str14;
BEGIN
aLtCyanOnMagenta := MakeAnsiString (LightCyan, Magenta);
END;


FUNCTION abLtCyanOnMagenta : Str14;
BEGIN
abLtCyanOnMagenta := MakeAnsiString (Lightcyan + aBlink, Magenta);
END;


FUNCTION aLtRedOnMagenta : Str14;
BEGIN
aLtRedOnMagenta := MakeAnsiString (LightRed, Magenta);
END;


FUNCTION abLtRedOnMagenta : Str14;
BEGIN
abLtRedOnMagenta := MakeAnsiString (LightRed + aBlink, Magenta);
END;


FUNCTION aLtMagentaOnMagenta : Str14;
BEGIN
aLtMagentaOnMagenta := MakeAnsiString (LightMagenta, Magenta);
END;


FUNCTION abLtMagentaOnMagenta : Str14;
BEGIN
abLtMagentaOnMagenta := MakeAnsiString (LightMagenta + aBlink, Magenta);
END;


FUNCTION aYellowOnMagenta : Str14;
BEGIN
aYellowOnMagenta := MakeAnsiString (Yellow, Magenta);
END;


FUNCTION abYellowOnMagenta : Str14;
BEGIN
abYellowOnMagenta := MakeAnsiString (Yellow + aBlink, Magenta);
END;


FUNCTION aWhiteOnMagenta : Str14;
BEGIN
aWhiteOnMagenta := MakeAnsiString (White, Magenta);
END;


FUNCTION abWhiteOnMagenta : Str14;
BEGIN
abWhiteOnMagenta := MakeAnsiString (White + aBlink, Magenta);
END;



{Brown background}
FUNCTION aBlackOnBrown : Str14;
BEGIN
aBlackOnBrown := MakeAnsiString (Black, Brown);
END;


FUNCTION abBlackOnBrown : Str14;
BEGIN
abBlackOnBrown := MakeAnsiString (Black + aBlink, Brown);
END;


FUNCTION aBlueOnBrown : Str14;
BEGIN
aBlueOnBrown := MakeAnsiString (Blue, Brown);
END;


FUNCTION abBlueOnBrown : Str14;
BEGIN
abBlueOnBrown := MakeAnsiString (Blue + aBlink, Brown);
END;


FUNCTION aGreenOnBrown : Str14;
BEGIN
aGreenOnBrown := MakeAnsiString (Green, Brown);
END;


FUNCTION abGreenOnBrown : Str14;
BEGIN
abGreenOnBrown := MakeAnsiString (Green + aBlink, Brown);
END;


FUNCTION aCyanOnBrown : Str14;
BEGIN
aCyanOnBrown := MakeAnsiString (Cyan, Brown);
END;


FUNCTION abCyanOnBrown : Str14;
BEGIN
abCyanOnBrown := MakeAnsiString (Cyan + aBlink, Brown);
END;


FUNCTION aRedOnBrown : Str14;
BEGIN
aRedOnBrown := MakeAnsiString (Red, Brown);
END;


FUNCTION abRedOnBrown : Str14;
BEGIN
abRedOnBrown := MakeAnsiString (Red + aBlink, Brown);
END;


FUNCTION aMagentaOnBrown : Str14;
BEGIN
aMagentaOnBrown := MakeAnsiString (Magenta, Brown);
END;


FUNCTION abMagentaOnBrown : Str14;
BEGIN
abMagentaOnBrown := MakeAnsiString (Magenta + aBlink, Brown);
END;


FUNCTION aBrownOnBrown : Str14;
BEGIN
aBrownOnBrown := MakeAnsiString (Brown, Brown);
END;


FUNCTION abBrownOnBrown : Str14;
BEGIN
abBrownOnBrown := MakeAnsiString (Brown + aBlink, Brown);
END;


FUNCTION aLtGrayOnBrown : Str14;
BEGIN
aLtGrayOnBrown := MakeAnsiString (LightGray, Brown);
END;


FUNCTION abLtGrayOnBrown : Str14;
BEGIN
abLtGrayOnBrown := MakeAnsiString (LightGray + aBlink, Brown);
END;


FUNCTION aDkGrayOnBrown : Str14;
BEGIN
aDkGrayOnBrown := MakeAnsiString (DarkGray, Brown);
END;


FUNCTION abDkGrayOnBrown : Str14;
BEGIN
abDkGrayOnBrown := MakeAnsiString (DarkGray + aBlink, Brown);
END;


FUNCTION aLtBlueOnBrown : Str14;
BEGIN
aLtBlueOnBrown := MakeAnsiString (LightBlue, Brown);
END;


FUNCTION abLtBlueOnBrown : Str14;
BEGIN
abLtBlueOnBrown := MakeAnsiString (LightBlue + aBlink, Brown);
END;


FUNCTION aLtGreenOnBrown : Str14;
BEGIN
aLtGreenOnBrown := MakeAnsiString (LightGreen, Brown);
END;


FUNCTION abLtGreenOnBrown : Str14;
BEGIN
abLtGreenOnBrown := MakeAnsiString (LightGreen + aBlink, Brown);
END;



FUNCTION aLtCyanOnBrown : Str14;
BEGIN
aLtCyanOnBrown := MakeAnsiString (LightCyan, Brown);
END;


FUNCTION abLtCyanOnBrown : Str14;
BEGIN
abLtCyanOnBrown := MakeAnsiString (LightCyan + aBlink, Brown);
END;


FUNCTION aLtRedOnBrown : Str14;
BEGIN
aLtRedOnBrown := MakeAnsiString (LightRed, Brown);
END;


FUNCTION abLtRedOnBrown : Str14;
BEGIN
abLtRedOnBrown := MakeAnsiString (LightRed + aBlink, Brown);
END;


FUNCTION aLtMagentaOnBrown : Str14;
BEGIN
aLtMagentaOnBrown := MakeAnsiString (LightMagenta, Brown);
END;


FUNCTION abLtMagentaOnBrown : Str14;
BEGIN
abLtMagentaOnBrown := MakeAnsiString (LightMagenta + aBlink, Brown);
END;


FUNCTION aYellowOnBrown : Str14;
BEGIN
aYellowOnBrown := MakeAnsiString (Yellow, Brown);
END;


FUNCTION abYellowOnBrown : Str14;
BEGIN
abYellowOnBrown := MakeAnsiString (Yellow + aBlink, Brown);
END;


FUNCTION aWhiteOnBrown : Str14;
BEGIN
aWhiteOnBrown := MakeAnsiString (White, Brown);
END;


FUNCTION abWhiteOnBrown : Str14;
BEGIN
abWhiteOnBrown := MakeAnsiString (White + aBlink, Brown);
END;



{Light gray backgrouund}
FUNCTION aBlackOnLtGray : Str14;
BEGIN
aBlackOnLtGray := MakeAnsiString (Black, LightGray);
END;


FUNCTION abBlackOnLtGray : Str14;
BEGIN
abBlackOnLtGray := MakeAnsiString (Black + aBlink, LightGray);
END;


FUNCTION aBlueOnLtGray : Str14;
BEGIN
aBlueOnLtGray := MakeAnsiString (Blue, LightGray);
END;


FUNCTION abBlueOnLtGray : Str14;
BEGIN
abBlueOnLtGray := MakeAnsiString (Blue + aBlink, LightGray);
END;


FUNCTION aGreenOnLtGray : Str14;
BEGIN
aGreenOnLtGray := MakeAnsiString (Green, LightGray);
END;


FUNCTION abGreenOnLtGray : Str14;
BEGIN
abGreenOnLtGray := MakeAnsiString (Green + aBlink, LightGray);
END;


FUNCTION aCyanOnLtGray : Str14;
BEGIN
aCyanOnLtGray := MakeAnsiString (Cyan, LightGray);
END;


FUNCTION abCyanOnLtGray : Str14;
BEGIN
abCyanOnLtGray := MakeAnsiString (Cyan + aBlink, LightGray);
END;


FUNCTION aRedOnLtGray : Str14;
BEGIN
aRedOnLtGray := MakeAnsiString (Red, LightGray);
END;


FUNCTION abRedOnLtGray : Str14;
BEGIN
abRedOnLtGray := MakeAnsiString (Red + aBlink, LightGray);
END;


FUNCTION aMagentaOnLtGray : Str14;
BEGIN
aMagentaOnLtGray := MakeAnsiString (Magenta, LightGray);
END;


FUNCTION abMagentaOnLtGray : Str14;
BEGIN
abMagentaOnLtGray := MakeAnsiString (Magenta + aBlink, LightGray);
END;


FUNCTION aBrownOnLtGray : Str14;
BEGIN
aBrownOnLtGray := MakeAnsiString (Brown, LightGray);
END;


FUNCTION abBrownOnLtGray : Str14;
BEGIN
abBrownOnLtGray := MakeAnsiString (Brown + aBlink, LightGray);
END;


FUNCTION aLtGrayOnLtGray : Str14;
BEGIN
aLtGrayOnLtGray := MakeAnsiString (LightGray, LightGray);
END;


FUNCTION abLtGrayOnLtGray : Str14;
BEGIN
abLtGrayOnLtGray := MakeAnsiString (LightGray + aBlink, LightGray);
END;


FUNCTION aDkGrayOnLtGray : Str14;
BEGIN
aDkGrayOnLtGray := MakeAnsiString (DarkGray, LightGray);
END;


FUNCTION abDkGrayOnLtGray : Str14;
BEGIN
abDkGrayOnLtGray := MakeAnsiString (DarkGray + aBlink, LightGray);
END;


FUNCTION aLtBlueOnLtGray : Str14;
BEGIN
aLtBlueOnLtGray := MakeAnsiString (LightBlue, LightGray);
END;


FUNCTION abLtBlueOnLtGray : Str14;
BEGIN
abLtBlueOnLtGray := MakeAnsiString (LightBlue + aBlink, LightGray);
END;


FUNCTION aLtGreenOnLtGray : Str14;
BEGIN
aLtGreenOnLtGray := MakeAnsiString (LightGreen, LightGray);
END;


FUNCTION abLtGreenOnLtGray : Str14;
BEGIN
abLtGreenOnLtGray := MakeAnsiString (LightGreen + aBlink, LightGray);
END;


FUNCTION aLtCyanOnLtGray : Str14;
BEGIN
aLtCyanOnLtGray := MakeAnsiString (LightCyan, LightGray);
END;


FUNCTION abLtCyanOnLtGray : Str14;
BEGIN
abLtCyanOnLtGray := MakeAnsiString (LightCyan + aBlink, LightGray);
END;


FUNCTION aLtRedOnLtGray : Str14;
BEGIN
aLtRedOnLtGray := MakeAnsiString (LightRed, LightGray);
END;


FUNCTION abLtRedOnLtGray : Str14;
BEGIN
abLtRedOnLtGray := MakeAnsiString (LightRed + aBlink, LightGray);
END;


FUNCTION aLtMagentaOnLtGray : Str14;
BEGIN
aLtMagentaOnLtGray := MakeAnsiString (LightMagenta, LightGray);
END;



FUNCTION abLtMagentaOnLtGray : Str14;
BEGIN
abLtMagentaOnLtGray := MakeAnsiString (LightMagenta + aBlink, LightGray);
END;


FUNCTION aYellowOnLtGray : Str14;
BEGIN
aYellowOnLtGray := MakeAnsiString (Yellow, LightGray);
END;


FUNCTION abYellowOnLtGray : Str14;
BEGIN
abYellowOnLtGray := MakeAnsiString (Yellow + aBlink, LightGray);
END;


FUNCTION aWhiteOnLtGray : Str14;
BEGIN
aWhiteOnLtGray := MakeAnsiString (White, LightGray);
END;


FUNCTION abWhiteOnLtGray : Str14;
BEGIN
abWhiteOnLtGray := MakeAnsiString (White + aBlink, LightGray);
END;




BEGIN
END.


  3 Responses to “Category : Pascal Source Code
Archive   : ANSICOLR.ZIP
Filename : ANSICOLR.PAS

  1. Very nice! Thank you for this wonderful archive. I wonder why I found it only now. Long live the BBS file archives!

  2. This is so awesome! 😀 I’d be cool if you could download an entire archive of this at once, though.

  3. But one thing that puzzles me is the “mtswslnkmcjklsdlsbdmMICROSOFT” string. There is an article about it here. It is definitely worth a read: http://www.os2museum.com/wp/mtswslnk/