home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 10 / praxis / egacolor.inc < prev    next >
Text File  |  1990-07-16  |  6KB  |  185 lines
  1. (* ------------------------------------------------------ *)
  2. (*                      EGACOLOR.INC                      *)
  3. (*     Include-Datei zu PAL-EDDI.PAS für EGA-Karten       *)
  4. (*               Turbo Pascal Version 5.5                 *)
  5. (*           (c) 1990 Gerald Arend & TOOLBOX              *)
  6. (* ------------------------------------------------------ *)
  7.  
  8. CONST                   { Konstanten für Bit-Verknüpfungen }
  9.   AndBits: ARRAY[1..6] OF BYTE = (1, 2, 4, 8, 16, 32);
  10.   OrBits: ARRAY[1..6] OF BYTE = (62, 61, 59, 55, 47, 31);
  11.  
  12. VAR
  13.   EGAFarben: ARRAY[0..MaxColors] OF BYTE;        { Palette }
  14.   SchriftY: ARRAY[1..7] OF INTEGER;
  15.   Step: BYTE;
  16.   StepX, StepY, WertX, WertY: INTEGER;
  17.   Ende: BOOLEAN;
  18.   TBreite, THoehe: WORD;
  19.  
  20. PROCEDURE DrawBars;         { Farbbalken und Info erzeugen }
  21. VAR
  22.   n, m: BYTE;
  23.   s: STRING[4];
  24. CONST
  25.   Bezeichnung: STRING[24] = '1:B+2:G+3:R+4:B-5:G-6:R-';
  26. BEGIN
  27.   SetFillStyle(SolidFill, MaxColors);
  28.   Bar(0, 0, GetMaxX, 2*TextHeight('X')-1);
  29.   SetTextStyle(DefaultFont, HorizDir, 1);
  30.   SetTextJustify(CenterText, TopText);
  31.   SetColor(0);
  32.   OutTextXY(GetMaxX DIV 2, 2, 'toolbox Pal-Eddi  '+
  33.     'EGA-Modus 640 x 350, 16 Farben aus einer '+
  34.     'Palette von 64');
  35.   SetTextJustify(LeftText, BottomText);
  36.   SetColor(MaxColors);
  37.   SetWriteMode(XORPut);
  38.   TBreite:=TextWidth('X');
  39.   THoehe:=TextHeight('X');
  40.   FOR n:=1 TO 6 DO
  41.   BEGIN
  42.     SchriftY[n]:=GetMaxY DIV 2+(n+3)*THoehe*4 DIV 3;
  43.     s:=Copy(Bezeichnung, Succ(Pred(n)*4), 4);
  44.     OutTextXY(0, SchriftY[n], s);
  45.   END;
  46.   SchriftY[7]:=SchriftY[6]+2*THoehe;
  47.   OutTextXY(0, SchriftY[7], 'Wert');
  48.   OutTextXY(0, GetMaxY-4*THoehe,
  49.             '<F1>...<F6>  Bit umschalten');
  50.   OutTextXY(0, GetMaxY-2*THoehe,
  51.             #24#47#25+'          Farbwert ändern');
  52.   OutTextXY(GetMaxX DIV 2, GetMaxY-4*THoehe,
  53.             '<C>  Color-Cycling-Demo');
  54.   OutTextXY(0, SchriftY[1]-3*THoehe, 'Nr.');
  55.   Step:=1;
  56.   StepX:=GetMaxX DIV 2+13*TBreite;
  57.   StepY:=GetMaxY-2*THoehe;
  58.   OutTextXY(GetMaxX DIV 2, StepY,
  59.             'Schrittweite:      <+> / <->');
  60.   ShowValue(StepX, StepY, Step, 3);
  61.   FOR n:=0 TO MaxColors DO
  62.   BEGIN
  63.     SetColor(MaxColors);
  64.     Str(n:2, s);
  65.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  66.               SchriftY[1]-3*THoehe, ' #'+s);
  67.     FOR m:=1 TO 6 DO
  68.       IF EGAFarben[n] AND AndBits[m]>0 THEN
  69.         OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  70.                   SchriftY[m], '  1')
  71.       ELSE
  72.         OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  73.                   SchriftY[m], '  0');
  74.     Str(EGAFarben[n]:3, s);
  75.     OutTextXY(Succ(n)*GetMaxX DIV (MaxColors+2),
  76.               SchriftY[7], s);
  77.     SetColor(n);
  78.     SetFillStyle(SolidFill, n);
  79.     Bar(Succ(n)*GetMaxX DIV (MaxColors+2), 2*THoehe,
  80.        (n+2)*GetMaxX DIV (MaxColors+2), GetMaxY div 2);
  81.   END;
  82. END;
  83.  
  84. PROCEDURE InitPalette;                 { Palette speichern }
  85. VAR
  86.   n: BYTE;
  87.   Palette: PaletteType;
  88. BEGIN
  89.   GetPalette(Palette);
  90.   FOR n:=0 TO MaxColors DO
  91.     EGAFarben[n]:=Palette.Colors[n];
  92. END;
  93.  
  94. PROCEDURE ChangeColors;      { Farben interaktiv verändern }
  95. VAR
  96.   x: INTEGER;
  97.   n, m: BYTE;
  98.   ch: CHAR;
  99.  
  100.   PROCEDURE ToggleBit(VAR Wert: BYTE; Stelle: BYTE);
  101.                             { Ein einzelnes Bit umschalten }
  102.   BEGIN
  103.     IF Wert AND AndBits[Stelle]=0 THEN
  104.       Wert:=Wert OR AndBits[Stelle]
  105.     ELSE
  106.       Wert:=Wert AND OrBits[Stelle];
  107.   END;
  108.  
  109. BEGIN
  110.   n:=0;
  111.   Ende:=FALSE;
  112.   SetColor(MaxColors);
  113.   DrawFrame(n, SchriftY[7]+10);
  114.   REPEAT
  115.     x:=Succ(n)*GetMaxX DIV (MaxColors+2)+TBreite;
  116.     ch:=ReadKey;
  117.     CASE ch OF
  118.       #0:  BEGIN
  119.              ch:=ReadKey;
  120.              CASE ch OF
  121.                #75: BEGIN                             { <- }
  122.                       DrawFrame(n, SchriftY[7]+10);
  123.                       Add(n, 0, MaxColors, -1, TRUE);
  124.                       DrawFrame(n, SchriftY[7]+10);
  125.                     END;
  126.                #77: BEGIN                             { -> }
  127.                       DrawFrame(n, SchriftY[7]+10);
  128.                       Add(n, 0, MaxColors, 1, TRUE);
  129.                       DrawFrame(n, SchriftY[7]+10);
  130.                     END;
  131.                #72,
  132.                #80: BEGIN
  133.                       IF ch=#72 THEN                   { ^ }
  134.                         Add(EGAFarben[n], 0, 63, -Step,
  135.                             TRUE)
  136.                       ELSE                             { v }
  137.                         Add(EGAFarben[n], 0, 63, Step,
  138.                             TRUE);
  139.                                        { Farbwert anzeigen }
  140.                       ShowValue(x, SchriftY[7],
  141.                                 EGAFarben[n], 2);
  142.                       FOR m:=1 TO 6 DO     { Bits anzeigen }
  143.                         IF EGAFarben[n] AND AndBits[m]>0
  144.                         THEN
  145.                           ShowValue(x, SchriftY[m], 1, 2)
  146.                         ELSE
  147.                           ShowValue(x, SchriftY[m], 0, 2);
  148.                     END;
  149.                #59..
  150.                #64: BEGIN { F1...F6: Einzelne Bits togglen }
  151.                       m:=Ord(ch)-58;
  152.                       ToggleBit(EGAFarben[n], m);
  153.                       ShowValue(x, SchriftY[7],
  154.                                 EGAFarben[n], 2);
  155.                       IF EGAFarben[n] AND AndBits[m]>0 THEN
  156.                         ShowValue(x, SchriftY[m], 1, 2)
  157.                       ELSE
  158.                         ShowValue(x, SchriftY[m], 0, 2);
  159.                     END;
  160.              END;
  161.            END;
  162.       '+': BEGIN                    { Schrittweite erhöhen }
  163.              Add(Step, 1, 8, 1, TRUE);
  164.              ShowValue(StepX, StepY, Step, 3);
  165.            END;
  166.       '-': BEGIN                 { Schrittweite vermindern }
  167.              Add(Step, 1, 8, -1, TRUE);
  168.              ShowValue(StepX, StepY, Step, 3);
  169.            END;
  170.       'c',
  171.       'C': BEGIN
  172.              CycleDemo;
  173.              Exit;
  174.            END;
  175.       #27: BEGIN
  176.              Ende:=TRUE;
  177.              Exit;
  178.            END;
  179.     END;
  180.     SetPalette(n, EGAFarben[n]);          { Palette setzen }
  181.   UNTIL FALSE;
  182. END;
  183. (* ------------------------------------------------------ *)
  184. (*                Ende von EGACOLOR.INC                   *)
  185.