[Back to ANSI SWAG index] [Back to Main SWAG index] [Original]

    {*********************************************************}
    {*                   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.

[Back to ANSI SWAG index] [Back to Main SWAG index] [Original]