home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 10 / praxis / vgacolor.inc < prev   
Encoding:
Text File  |  1990-07-16  |  7.1 KB  |  205 lines
  1. (* ------------------------------------------------------ *)
  2. (*                      VGACOLOR.INC                      *)
  3. (*     Include-Datei zu PAL-EDDI.PAS für VGA-Karten       *)
  4. (*               Turbo Pascal Version 5.5                 *)
  5. (*           (c) 1990 Gerald Arend & TOOLBOX              *)
  6. (* ------------------------------------------------------ *)
  7.  
  8. TYPE
  9.   RGBRec = RECORD
  10.              RedVal, GreenVal, BlueVal: BYTE;
  11.            END;
  12.  
  13. CONST                                 { Die Standardfarben }
  14.   VGAFarben: ARRAY[0..MaxColors] OF RGBRec =
  15.              ((RedVal: $00; GreenVal: $00; BlueVal: $00),
  16.               (RedVal: $00; GreenVal: $00; BlueVal: $3F),
  17.               (RedVal: $09; GreenVal: $3F; BlueVal: $09),
  18.               (RedVal: $00; GreenVal: $3F; BlueVal: $3F),
  19.               (RedVal: $3F; GreenVal: $05; BlueVal: $05),
  20.               (RedVal: $2C; GreenVal: $00; BlueVal: $3F),
  21.               (RedVal: $1C; GreenVal: $12; BlueVal: $00),
  22.               (RedVal: $31; GreenVal: $31; BlueVal: $31),
  23.               (RedVal: $0D; GreenVal: $0D; BlueVal: $0D),
  24.               (RedVal: $00; GreenVal: $00; BlueVal: $1C),
  25.               (RedVal: $00; GreenVal: $1C; BlueVal: $00),
  26.               (RedVal: $00; GreenVal: $1C; BlueVal: $1C),
  27.               (RedVal: $1C; GreenVal: $00; BlueVal: $00),
  28.               (RedVal: $1C; GreenVal: $00; BlueVal: $1C),
  29.               (RedVal: $3F; GreenVal: $3F; BlueVal: $09),
  30.               (RedVal: $3F; GreenVal: $3F; BlueVal: $3F));
  31.  
  32. VAR
  33.   FarbWert: LONGINT;  { Nummer der Farbe von 1 bis 262.144 }
  34.   SchriftY: ARRAY[1..3] OF INTEGER;
  35.   Step: BYTE;
  36.   StepX, StepY, WertX, WertY: INTEGER;
  37.   Ende: BOOLEAN;
  38.   THoehe, TBreite: WORD;
  39.  
  40. PROCEDURE DrawBars;         { Farbbalken und Info erzeugen }
  41. VAR
  42.   n: BYTE;
  43.   s: STRING[6];
  44. BEGIN
  45.   SetFillStyle(SolidFill, MaxColors);
  46.   Bar(0, 0, GetMaxX, 2*TextHeight('X')-1);
  47.   SetTextStyle(DefaultFont, HorizDir, 1);
  48.   SetTextJustify(CenterText, TopText);
  49.   SetColor(0);
  50.   OutTextXY(GetMaxX DIV 2, 2, 'toolbox Pal-Eddi  '+
  51.     'VGA-Modus 640 x 480, 16 Farben aus einer '+
  52.     'Palette von 262.144');
  53.   SetTextJustify(LeftText, BottomText);
  54.   SetColor(MaxColors);
  55.   SetWriteMode(XORPut);
  56.   TBreite:=TextWidth('X');
  57.   THoehe:=TextHeight('X');
  58.   SchriftY[1]:=GetMaxY div 2+7*THoehe;
  59.   SchriftY[2]:=GetMaxY div 2+10*THoehe;
  60.   SchriftY[3]:=GetMaxY div 2+13*THoehe;
  61.   OutTextXY(0, SchriftY[1]-3*THoehe, 'Nr.');
  62.   OutTextXY(0, SchriftY[1], 'Rot');
  63.   OutTextXY(0, SchriftY[2], 'Grün');
  64.   OutTextXY(0, SchriftY[3], 'Blau');
  65.   OutTextXY(0, GetMaxY-6*THoehe,
  66.             '<r> <g> <b>    Farbwert erhöhen');
  67.   OutTextXY(0, GetMaxY-4*THoehe,
  68.             '<R> <G> <B>    Farbwert erniedrigen');
  69.   OutTextXY(GetMaxX DIV 2, GetMaxY-4*THoehe,
  70.             '<C>  Color-Cycling-Demo');
  71.   Str((LONGINT(VGAFarben[0].RedVal)*4096+
  72.       VGAFarben[0].GreenVal * 64 +
  73.       VGAFarben[0].BlueVal):6, s);
  74.   WertX:=10*TBreite;
  75.   WertY:=GetMaxY-10*THoehe;
  76.   OutTextXY(0, WertY, 'Farbwert: '+s);
  77.   Step:=1;
  78.   StepX:=GetMaxX DIV 2+13*TBreite;
  79.   StepY:=GetMaxY-6*THoehe;
  80.   OutTextXY(GetMaxX DIV 2, StepY,
  81.             'Schrittweite:      <+> / <->');
  82.   ShowValue(StepX, StepY, Step, 3);
  83.   FOR n:=0 TO MaxColors DO
  84.   BEGIN
  85.     SetColor(MaxColors);
  86.     Str(n:2, s);
  87.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  88.               SchriftY[1]-3*THoehe, ' #'+s);
  89.     Str(VGAFarben[n].RedVal:4, s);
  90.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  91.               SchriftY[1], s);
  92.     Str(VGAFarben[n].GreenVal:4, s);
  93.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  94.               SchriftY[2], s);
  95.     Str(VGAFarben[n].BlueVal:4, s);
  96.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  97.               SchriftY[3], s);
  98.     SetColor(n);
  99.     SetFillStyle(SolidFill, n);
  100.     Bar(Succ(n)*GetMaxX DIV (MaxColors+2), 2*THoehe,
  101.         (n+2)*GetMaxX DIV (MaxColors+2), GetMaxY div 2);
  102.   END;
  103. END;
  104.  
  105. PROCEDURE InitPalette;                    { Palette setzen }
  106. VAR
  107.   n: BYTE;
  108. BEGIN
  109.   FOR n:=0 TO MaxColors DO
  110.   BEGIN
  111.                      { Erst den Farbwert in der Palette
  112.                        gleich der Palettennummer setzen... }
  113.     SetPalette(n, n);
  114.      { ... und dann erst die RGB-Palettenwerte eintragen ! }
  115.     WITH VGAFarben[n] do
  116.       SetRGBPalette(n, RedVal, GreenVal, BlueVal);
  117.   END;
  118. END;
  119.  
  120. PROCEDURE ChangeColors;      { Farben interaktiv verändern }
  121. VAR
  122.   x: INTEGER;
  123.   n: BYTE;
  124.   ch: CHAR;
  125. BEGIN
  126.   n:=0;
  127.   Ende:=FALSE;
  128.   SetColor(MaxColors);
  129.   DrawFrame(n, SchriftY[3]+10);
  130.   REPEAT
  131.     x:=Succ(n)*GetMaxX DIV (MaxColors+2)+TBreite;
  132.     ch:=ReadKey;
  133.     CASE ch OF
  134.       #0:  BEGIN
  135.              DrawFrame(n, SchriftY[3]+10);
  136.              ch:=ReadKey;
  137.              CASE ch OF
  138.                #75: Add(n, 0, MaxColors, -1, TRUE);   { <- }
  139.                #77: Add(n, 0, MaxColors, 1, TRUE);    { -> }
  140.              END;
  141.              DrawFrame(n, SchriftY[3]+10);
  142.            END;
  143.       'r': BEGIN
  144.                                       { Farbwert verändern }
  145.              Add(VGAFarben[n].RedVal, 0, 63, Step, TRUE);
  146.                                      { Neuen Wert anzeigen }
  147.              ShowValue(x, SchriftY[1],
  148.                        VGAFarben[n].RedVal, 3);
  149.            END;
  150.       'g': BEGIN
  151.              Add(VGAFarben[n].GreenVal, 0, 63, Step, TRUE);
  152.              ShowValue(x, SchriftY[2],
  153.                        VGAFarben[n].GreenVal, 3);
  154.            END;
  155.       'b': BEGIN
  156.              Add(VGAFarben[n].BlueVal, 0, 63, Step, TRUE);
  157.              ShowValue(x, SchriftY[3],
  158.                        VGAFarben[n].BlueVal, 3);
  159.            END;
  160.       'R': BEGIN
  161.              Add(VGAFarben[n].RedVal, 0, 63, -Step, TRUE);
  162.              ShowValue(x, SchriftY[1],
  163.                        VGAFarben[n].RedVal, 3);
  164.            END;
  165.       'G': BEGIN
  166.              Add(VGAFarben[n].GreenVal, 0, 63, -Step, TRUE);
  167.              ShowValue(x, SchriftY[2],
  168.                        VGAFarben[n].GreenVal, 3);
  169.            END;
  170.       'B': BEGIN
  171.              Add(VGAFarben[n].BlueVal, 0, 63, -Step, TRUE);
  172.              ShowValue(x, SchriftY[3],
  173.                        VGAFarben[n].BlueVal, 3);
  174.            END;
  175.       '+': BEGIN                    { Schrittweite erhöhen }
  176.              Add(Step, 1, 8, 1, TRUE);
  177.              ShowValue(StepX, StepY, Step, 3);
  178.            END;
  179.       '-': BEGIN                 { Schrittweite vermindern }
  180.              Add(Step, 1, 8, -1, TRUE);
  181.              ShowValue(StepX, StepY, Step, 3);
  182.            END;
  183.       'c',
  184.       'C': BEGIN
  185.              CycleDemo;
  186.              Exit;
  187.            END;
  188.       #27: BEGIN
  189.              Ende:=TRUE;
  190.              Exit;
  191.            END;
  192.     END;
  193.      { Farbwert aus den einzelnen RGB-Werten zusammenbauen }
  194.     FarbWert:=
  195.       LONGINT(VGAFarben[n].RedVal)*4096+
  196.       VGAFarben[n].GreenVal*64 +
  197.       VGAFarben[n].BlueVal;
  198.     ShowValue(WertX, WertY, FarbWert, 6);  { Wert anzeigen }
  199.     WITH VGAFarben[n] DO         { Palettenwert neu setzen }
  200.       SetRGBPalette(n, RedVal, GreenVal, BlueVal);
  201.   UNTIL FALSE;
  202. END;
  203. (* ------------------------------------------------------ *)
  204. (*                 Ende von VGACOLOR.INC                  *)
  205.