home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1989 / 06 / gr_edit2.inc < prev    next >
Encoding:
Text File  |  1989-01-23  |  17.7 KB  |  470 lines
  1. (* ------------------------------------------------------ *)
  2. (*                  GR-EDIT2.INC                          *)
  3. (*           2.Teil des Vektor-Editors                    *)
  4. (* ------------------------------------------------------ *)
  5. PROCEDURE edit(b:word);     {Hier beginnt die Editor-Arbeit}
  6. CONST
  7.   blink = TRUE;
  8. VAR
  9.   off, paar, anz, akt : INTEGER;
  10.   x, y                : ShortInt;
  11.   st                  : STRING[4];
  12.   linie, junk         : BOOLEAN;
  13.   knoten              : ARRAY[0..255] OF WORD;
  14.  
  15.   FUNCTION vec_art(nr:word):tArt; {Identifiziert Vektor-Art}
  16.   BEGIN
  17.     WITH userfont DO
  18.       vec_art := decodiere_vektor(vect^[nr],
  19.                                   vect^[nr+1],rx,ry,junk);
  20.   END;
  21.  
  22.   PROCEDURE rahmen(farbe : WORD);
  23.   BEGIN                   {Umrahmt angesteuertes Zahlenpaar}
  24.     SetColor(farbe);
  25.     IF GraphDriver > 2 THEN
  26.       Rectangle(tx * (akt AND $F),
  27.                 cy_t + (ty + 1) * (akt SHR 4) - ty + 2,
  28.                 tx * (akt AND $F) + tx + 1,
  29.                 cy_t + (ty + 1) * (akt SHR 4) + 3);
  30.       Rectangle(tx * (akt AND $F) + 1,
  31.                 cy_t + (ty + 1) * (akt SHR 4) - ty + 1,
  32.                 tx * (akt AND $F) + tx,
  33.                 cy_t + (ty + 1) * (akt SHR 4) + 2);
  34.   END;
  35.  
  36.   PROCEDURE blinker(on : BOOLEAN);
  37.   BEGIN                  {setzt "Blinker" auf Graphik-Punkt}
  38.     IF on THEN SetColor(white) ELSE SetColor(black);
  39.     IF (vec_art(knoten[akt]) = normal) OR
  40.        (vec_art(knoten[akt-1]) = normal) THEN
  41.       WITH userfont DO
  42.         Rectangle(cx_g + Round(faktor/korr_faktor*rx) - 2,
  43.                   cy_g - faktor*(ry-info^.unterlaengen)-2,
  44.                   cx_g + Round(faktor/korr_faktor*rx) + 2,
  45.                   cy_g - faktor*(ry-info^.unterlaengen)+2);
  46.     SetColor(white);
  47.   END;
  48.  
  49.   FUNCTION f_taste(blink:BOOLEAN):BOOLEAN; {Funktionstaste?}
  50.   BEGIN
  51.     blinker(TRUE);
  52.     IF blink THEN WHILE NOT KeyPressed DO BEGIN
  53.       blinker(TRUE);   Delay(200);
  54.       blinker(FALSE);  Delay(200);
  55.     END;
  56.     c := ReadKey;
  57.     f_taste := c=#0;         {Funktionstaste wurde gedrückt}
  58.     IF c=#0 THEN c:=ReadKey; {wenn Funktionstaste: welche? }
  59.   END;
  60.  
  61.   PROCEDURE bild_neu;      {Zeichnet Raster und Zeichen neu}
  62.   BEGIN
  63.     WITH userfont,info^ DO BEGIN
  64.       cx := cx_g;  cy := cy_g + faktor*unterlaengen;
  65.       Bar(0,0,txof-1,cy_g+ty);      {Raster-Bereich löschen}
  66.       FOR s:=0 TO breite^[b] DO   {x-Achse: doppelte Punkte}
  67.         PutPixel(cx+Round(faktor*s/korr_faktor)-1,cy,15);
  68.       FOR s:=0 TO breite^[b] DO                   { Raster }
  69.         FOR k := unterlaengen TO hoehe DO
  70.           PutPixel(cx + Round(faktor*s/korr_faktor),
  71.                    cy - faktor*k,15);
  72.       FOR k := unterlaengen TO hoehe DO
  73.         IF k MOD 5 = 0 THEN BEGIN           { Maß-Striche }
  74.           PutPixel(cx-1,cy-faktor*k,1);      { y - Achse  }
  75.           PutPixel(cx-2,cy-faktor*k,1);
  76.           MoveTo(0,cy-faktor*k);
  77.           Str(k:3,st); meintext(4,st);
  78.         END;
  79.       FOR s:=0 TO breite^[b] DO               { x - Achse  }
  80.         IF s MOD 5 = 0 THEN BEGIN
  81.           PutPixel(cx + Round(faktor/korr_faktor*s),
  82.                    cy - faktor*unterlaengen + 1, 4);
  83.           PutPixel(cx + Round(faktor/korr_faktor*s),
  84.                    cy - faktor*unterlaengen + 2, 4);
  85.           Str(s, st);
  86.           MoveTo(cx + Round(faktor/korr_faktor*s) - 5,
  87.                  cy - faktor*unterlaengen - 1);
  88.           meintext(4, st);
  89.         END;
  90.       MoveTo(cx, cy);
  91.       zeichne(userfont, b, FALSE, faktor, 0);
  92.     END;
  93.   END;
  94.  
  95.   PROCEDURE vector_schreiben(n:BYTE);
  96.                                  {Koordinaten eines Knotens}
  97.   BEGIN
  98.     WITH userfont DO BEGIN
  99.       MoveTo(tx*(n AND $F) + 2, cy_t + (ty+1)*(n SHR 4));
  100.       CASE decodiere_vektor(vect^[knoten[n]],
  101.                             vect^[knoten[n]+1],
  102.                             x,y,linie) OF
  103.         normal: BEGIN
  104.                   Bar(GetX,GetY-ty+2,GetX+tx-3,GetY+1);
  105.                   Str(x:2,st); meintext(5,st);
  106.                   Str(y:2,st); meintext(5,'/'+st);
  107.                   IF linie THEN
  108.                     Line(GetX-tx+8,GetY+1,GetX+3,GetY+1);
  109.                 END;
  110.    ref_zeichen: BEGIN         {wird erst in Teil 3 benötigt}
  111.                   Bar(GetX,GetY-ty+2,GetX+2*tx-3,GetY+1);
  112.                   Str(vect^[knoten[n]+1], st);
  113.                   meintext(5, 'R' + #26 + st + ': ');
  114.                   Str(vect^[knoten[n]+2]:2, st);
  115.                   meintext(5, st);
  116.                 END;
  117.          texte: BEGIN         {wird erst in Teil 3 benötigt}
  118.                   Bar(GetX,GetY-ty+2,GetX+2*tx-3,GetY+1);
  119.                   Str(vect^[knoten[n]+2]:3, st);
  120.                   meintext(5, 'Txt' + st + ':');
  121.                   Str(vect^[knoten[n]+1]*2:2, st);
  122.                   meintext(5, st);
  123.                 END;
  124.          kreis: BEGIN         {wird erst in Teil 3 benötigt}
  125.                   Bar(GetX,GetY-ty+2,GetX+2*tx-3,GetY+1);
  126.                   Str(vect^[knoten[n]+2] AND $3F, st);
  127.                   meintext(5, 'Ellip ' + st + '/');
  128.                   Str(vect^[knoten[n]+3] AND $3F, st);
  129.                   meintext(5, st);
  130.                 END;
  131.       END;
  132.     END;
  133.   END;
  134.  
  135.   PROCEDURE vector_plus_minus(n:INTEGER);
  136.                           {Fügt n Eckpunkte ein oder löscht}
  137.   BEGIN
  138.     WITH userfont DO BEGIN
  139.       IF n > 0 THEN
  140.         Move(vect^[paar], vect^[paar + 2*n],
  141.              umfang - 128 - info^.vect_anfang - paar)
  142.       ELSE
  143.         Move(vect^[paar-2*n],vect^[paar],
  144.              umfang - 128 - info^.vect_anfang - paar + 2*n);
  145.       FOR k := b + 1 TO info^.anfang + info^.anzahl - 1 DO
  146.         Inc(offs^[k], 2*n);
  147.       IF (n = 1) AND (vec_art(knoten[akt]) <> normal)
  148.                  AND (paar = knoten[akt]) THEN BEGIN
  149.         vect^[knoten[akt]]   := $80;
  150.         vect^[knoten[akt]+1] := 0;
  151.       END;
  152.       Inc(anz, n); Inc(paar, 2*n); Inc(umfang, 2*n)
  153.     END;
  154.   END;
  155.  
  156.   PROCEDURE vector_neu;      {schreibt alle Koordinaten neu}
  157.   BEGIN
  158.     SetFillStyle(EmptyFill, black);
  159.     Bar(0, cy_t - ty, GetMaxX, GetMaxY);
  160.     anz := 0; paar := off; knoten[0] := off;
  161.     WITH userfont DO
  162.       WHILE (vect^[knoten[anz] + 2] <> 0) OR
  163.             (vect^[knoten[anz] + 3] <> 0) DO BEGIN
  164.         vector_schreiben(anz);
  165.         CASE vec_art(knoten[anz]) OF
  166.           normal       : BEGIN Inc(anz); Inc(paar, 2) END;
  167.           ref_zeichen,
  168.            kreis       : BEGIN
  169.                            knoten[anz+1] := knoten[anz];
  170.                            Inc(anz, 2); Inc(paar, 4);
  171.                            IF anz+1 = akt THEN Dec(akt);
  172.                          END;
  173.            texte       : BEGIN
  174.                            knoten[anz+1] := knoten[anz];
  175.                            Inc(paar,vect^[knoten[anz]+2]+3);
  176.                            Inc(anz, 2);
  177.                            IF anz+1 = akt THEN Dec(akt);
  178.                          END;
  179.            ELSE Exit;
  180.          END; {case}
  181.          knoten[anz] := paar;  {Offset des nächsten Knotens}
  182.       END; {while}
  183.     IF akt > anz-1 THEN BEGIN
  184.       akt := anz-1;
  185.       IF vec_art(knoten[akt]) <> normal THEN Dec(akt);
  186.     END;
  187.     rahmen(white);
  188.   END;
  189.  
  190.   FUNCTION vec_laenge(b0:word):word;
  191.                 {Ermittelt Anzahl der Vektoren einer Grafik}
  192.   BEGIN
  193.     WITH userfont,info^ DO
  194.       IF b0<anfang+anzahl-1 THEN
  195.             vec_laenge:= offs^[b0+1]-offs^[b0]
  196.        ELSE vec_laenge:= umfang-128-vect_anfang-offs^[b0];
  197.     END;
  198.  
  199.   PROCEDURE kopieren;          {Kopiert ein anderes Zeichen}
  200.   VAR altlaenge,neulaenge : word;
  201.       i                   : INTEGER;
  202.  
  203.   BEGIN
  204.      RestoreCrtMode; ClrScr;
  205.      WriteLn('Sie kopieren nun ein anderes Bild und löschen'+
  206.              ' das aktuelle Bild!');
  207.      WriteLn;
  208.      WriteLn('Welches Bild soll kopiert werden? (0=Ende)');
  209.      i:=bildwahl;
  210.      IF i>0 THEN WITH userfont DO BEGIN
  211.         altlaenge:=vec_laenge(i);
  212.         neulaenge:=vec_laenge(b);
  213.         IF altlaenge<>neulaenge THEN
  214.            vector_plus_minus((altlaenge-neulaenge) SHR 1);
  215.         Move(vect^[offs^[i]],vect^[offs^[b]],altlaenge);
  216.         breite^[b]:=breite^[i]
  217.      END;
  218.      SetGraphMode(GraphMode);
  219.      akt:=0; vector_neu
  220.   END;
  221.  
  222.   PROCEDURE text_eingeben; {Plaziert freien Text in Graphik}
  223.   BEGIN                                    {Folgt in Teil 3}
  224.   END;
  225.  
  226.   PROCEDURE referenz;           {Blendet andere Graphik ein}
  227.   BEGIN                                    {Folgt in Teil 3}
  228.   END;
  229.  
  230.   PROCEDURE kreis_zeichnen;   {Zeichnet Kreis+Ellipse/Teile}
  231.   BEGIN                                    {Folgt in Teil 3}
  232.   END;
  233.  
  234. BEGIN                                             {von EDIT}
  235.   WITH userfont DO BEGIN
  236.    off:=offs^[b]; ClearDevice;
  237.    akt:=0; vector_neu; bild_neu;
  238.    REPEAT
  239.      Str(b,st);
  240.      MoveTo(txof,ty-2);
  241.      meintext(5,'Sie bearbeiten:');
  242.      MoveTo(txof,2*ty-2);
  243.      meintext(5,'   Bild '+st);
  244.      MoveTo(txof,cy_g);
  245.      meintext(5,'unterstrichen => ');
  246.      MoveTo(txof,cy_g+ty);
  247.      meintext(5,'           Linie sichtbar');
  248.      Bar(txof,2*ty,GetMaxX,cy_g-ty-1);
  249.      MoveTo(txof,4*ty);
  250.      meintext(5,'Knoten anwählen --> ['#27#26']');
  251.      MoveTo(txof,5*ty);
  252.      meintext(5,'Verändern       --> [V]');
  253.      MoveTo(txof,7*ty);
  254.      meintext(5,'Knoten einfügen --> [F1]');
  255.      MoveTo(txof,8*ty);
  256.      meintext(5,'Knoten löschen  --> [F2]');
  257.      MoveTo(txof,11*ty);
  258.      meintext(5,'Bild kopieren   --> [F4]');
  259.      MoveTo(txof,13*ty);
  260.      meintext(5,'Raster breiter  --> [F7]');
  261.      MoveTo(txof,14*ty);
  262.      meintext(5,'Raster schmaler --> [F8]');
  263.      MoveTo(txof,16*ty);
  264.      meintext(5,'alles löschen   --> [F10]');
  265.      MoveTo(txof,18*ty);
  266.      meintext(5,'Ende            --> [ESC]');
  267.      WHILE f_taste(NOT blink) DO BEGIN     {Funktionstaste ?}
  268.         blinker(FALSE); paar:=knoten[akt];
  269.         CASE c OF
  270.           'K': IF akt>0 THEN BEGIN                  (*  <  *)
  271.                  rahmen(black);
  272.                  IF vec_art(knoten[akt-1])=normal
  273.                     THEN Dec(akt,1)
  274.                  ELSE Dec(akt,2);
  275.                  rahmen(white)
  276.                END;
  277.           'M': IF akt<anz-1 THEN BEGIN              (*  >  *)
  278.                  rahmen(black);
  279.                  IF vec_art(knoten[akt]) = normal
  280.                     THEN Inc(akt,1)
  281.                  ELSE IF akt<anz-2 THEN Inc(akt,2);
  282.                  rahmen(white)
  283.                END;
  284.           ';': BEGIN vector_plus_minus(1);           (* F1 *)
  285.                  Inc(akt); vector_neu
  286.                END;
  287.           '<': IF anz>1 THEN BEGIN                   (* F2 *)
  288.                 CASE vec_art(knoten[akt]) OF
  289.                   normal: vector_plus_minus(-1);
  290.                   kreis,ref_zeichen: vector_plus_minus(-2);
  291.                   texte: BEGIN paar:=knoten[akt+2];
  292.                            vector_plus_minus((knoten[akt]-
  293.                                       knoten[akt+2])DIV 2)
  294.                          END
  295.                 END;
  296.                 vector_neu
  297.                END;
  298.           'D': BEGIN paar:=knoten[0];                (* F0 *)
  299.                  akt:=0;
  300.                  vector_plus_minus(-vec_laenge(b) DIV 2 + 3);
  301.                  vect^[off]:=$80; vect^[off+1]:=0;
  302.                  vector_neu
  303.                END;
  304.           '>': kopieren;                             (* F4 *)
  305.           'B': IF breite^[b]>1 THEN BEGIN Dec(breite^[b]);
  306.                   Dec(vect^[knoten[anz]])            (* F8 *)
  307.                END;
  308.           'A': IF breite^[b]<127 THEN BEGIN Inc(breite^[b]);
  309.                   Inc(vect^[knoten[anz]])            (* F7 *)
  310.                END;
  311.         END;  {case c}
  312.         IF (c IN ['<','D','>','B','A']) AND NOT KeyPressed
  313.            THEN bild_neu;
  314.      END;  {while}
  315.      IF UpCase(c)='V'then                        {Verändern}
  316.       CASE vec_art(knoten[akt]) OF
  317.        normal :
  318.         BEGIN
  319.          Bar(txof,2*ty,GetMaxX,cy_g-ty-1);
  320.          MoveTo(txof,4*ty);
  321.          meintext(5,'Punkt schieben  --> ['#18#29']');
  322.          MoveTo(txof,6*ty);
  323.          meintext(5,'Linie sichtbar  --> [Ins]');
  324.          MoveTo(txof,7*ty);
  325.          meintext(5,'Linie unsichtbar--> [Del]');
  326.          MoveTo(txof,9*ty);
  327.          meintext(5,'Bild einblenden --> [F5] ');
  328.          MoveTo(txof,10*ty);
  329.          meintext(5,'Ellipse zeichnen--> [F6] ');
  330.          MoveTo(txof,12*ty);
  331.          meintext(5,'Text eingeben   --> [F9] ');
  332.          MoveTo(txof,18*ty);
  333.          meintext(5,'        Ende    --> [E]');
  334.          REPEAT
  335.           IF f_taste(blink) THEN BEGIN
  336.            CASE c OF
  337.             'H': vect^[knoten[akt]+1]:=              (* ^ *)
  338.                          (vect^[knoten[akt]+1] AND $80) OR
  339.                          (vect^[knoten[akt]+1]+1) AND $7F;
  340.             'K': IF vect^[knoten[akt]]>$80 THEN      (* < *)
  341.                     Dec(vect^[knoten[akt]]);
  342.             'M': Inc(vect^[knoten[akt]]);            (* > *)
  343.             'P': vect^[knoten[akt]+1]:=              (* v *)
  344.                          (vect^[knoten[akt]+1] AND $80) OR
  345.                          (vect^[knoten[akt]+1]-1) AND $7F;
  346.             '?': referenz;                          (* F5 *)
  347.             '@': kreis_zeichnen;                    (* F6 *)
  348.             'C': text_eingeben;                     (* F9 *)
  349.             'R': vect^[knoten[akt]+1]:=             (*Ins *)
  350.                          vect^[knoten[akt]+1] OR $80;
  351.             'S': vect^[knoten[akt]+1]:=             (*Del *)
  352.                          vect^[knoten[akt]+1] AND $7F;
  353.            END;
  354.            vector_schreiben(akt);
  355.            IF NOT KeyPressed THEN bild_neu
  356.           END
  357.          UNTIL UpCase(c) IN ['E','?','@','C',#13]
  358.         END; {normal}
  359.        ref_zeichen,kreis,texte:
  360.         BEGIN
  361.          Bar(txof,2*ty,GetMaxX,cy_g-ty-1);
  362.          Str(vect^[knoten[akt]+1],st);
  363.          MoveTo(txof,3*ty);
  364.          CASE vec_art(knoten[akt]) OF
  365.           ref_zeichen: meintext(5,'Referenz '#26' Bild '+st);
  366.           kreis      : meintext(5,'Ellipse (Kreis)');
  367.           texte      : BEGIN meintext(5,'Text, ');
  368.                          Str(vect^[knoten[akt]+2]:2,st);
  369.                          meintext(5,'Länge '+st+', ')
  370.                        END
  371.          END;
  372.          MoveTo(txof,6*ty);
  373.          meintext(5,'verschieben: Vektor links');
  374.          MoveTo(txof,8*ty);
  375.          meintext(5,'größer / kleiner--> [+/-]');
  376.          MoveTo(txof,9*ty);
  377.          meintext(5,'drehen  --> [PgUp] [PgDn]');
  378.          MoveTo(txof,18*ty);
  379.          meintext(5,'        Ende    -->   [E]');
  380.          REPEAT
  381.           Bar(txof,4*ty,GetMaxX,5*ty); MoveTo(txof,5*ty);
  382.           Str(vect^[knoten[akt]+2]:2,st);
  383.           CASE vec_art(knoten[akt]) OF
  384.             ref_zeichen: BEGIN
  385.                            meintext(5,'Größe '+st+'/16, ');
  386.                            Str(vect^[knoten[akt]+3]*2,st)
  387.                          END;
  388.             kreis:       Str(vect^[knoten[akt]] AND $F *3,st);
  389.             texte:       BEGIN
  390.                            Str(vect^[knoten[akt]] AND $F,st);
  391.                            meintext(5,'Größe '+st+', ');
  392.                            Str(vect^[knoten[akt]+1]*2,st)
  393.                          END;
  394.           END;
  395.           meintext(5,'Drehung '+st+'°');
  396.           IF f_taste(blink) THEN
  397.            CASE c OF
  398.             'Q': CASE vec_art(knoten[akt]) OF     (* PgDn *)
  399.                   ref_zeichen:
  400.                     IF vect^[knoten[akt]+3]=0 THEN
  401.                       vect^[knoten[akt]+3]:=179
  402.                     ELSE Dec(vect^[knoten[akt]+3]);
  403.                   kreis:
  404.                     IF vect^[knoten[akt]] AND $F >0 THEN
  405.                       Dec(vect^[knoten[akt]])
  406.                     ELSE Inc(vect^[knoten[akt]],$F);
  407.                   texte:
  408.                     IF vect^[knoten[akt]+1]=0 THEN
  409.                       vect^[knoten[akt]+1]:=179
  410.                     ELSE Dec(vect^[knoten[akt]+1])
  411.                  END;
  412.             'I': CASE vec_art(knoten[akt]) OF     (* PgUp *)
  413.                   ref_zeichen: Inc(vect^[knoten[akt]+3]);
  414.                   kreis:
  415.                     IF vect^[knoten[akt]] AND $F <$F THEN
  416.                       Inc(vect^[knoten[akt]])
  417.                     ELSE Dec(vect^[knoten[akt]],$F);
  418.                   texte:
  419.                     IF vect^[knoten[akt]+1]=179 THEN
  420.                       vect^[knoten[akt]+1]:=0
  421.                     ELSE Inc(vect^[knoten[akt]+1])
  422.                  END
  423.            END {case c...}
  424.           ELSE CASE c OF
  425.             '+': CASE vec_art(knoten[akt]) OF
  426.                   ref_zeichen: Inc(vect^[knoten[akt]+2]);
  427.                   kreis:
  428.                     IF (vect^[knoten[akt]+2] AND $3F<$3F) THEN
  429.                        Inc(vect^[knoten[akt]+2]);
  430.                   texte:
  431.                     IF (vect^[knoten[akt]] AND $F < $F) THEN
  432.                        Inc(vect^[knoten[akt]])
  433.                  END;
  434.             '-': CASE vec_art(knoten[akt]) OF
  435.                   ref_zeichen: Dec(vect^[knoten[akt]+2]);
  436.                   kreis:
  437.                     IF (vect^[knoten[akt]+2] AND $3F>0) THEN
  438.                        Dec(vect^[knoten[akt]+2]);
  439.                   texte:
  440.                     IF (vect^[knoten[akt]] AND $F > 1) THEN
  441.                               {Maske für die unteren 4 Bit}
  442.                        Dec(vect^[knoten[akt]])
  443.                  END;
  444.           END;  {if f_taste ...}
  445.           IF c IN ['I','Q','+','-'] THEN BEGIN
  446.              vector_schreiben(akt);
  447.              IF NOT KeyPressed THEN bild_neu
  448.           END
  449.          UNTIL UpCase(c)='E'            {Ende von Verändern}
  450.         END  {ref_zeichen, kreis, texte}
  451.       END  {case vec_art}
  452.    UNTIL c=#27
  453.   END     {with}
  454. END;     {Edit}
  455.  
  456. PROCEDURE editieren;             { Rahmenprozedur für EDIT }
  457. VAR nr:word;
  458. BEGIN
  459.   WITH userfont,info^ DO
  460.     faktor:=cy_g DIV (hoehe-unterlaengen);
  461.   GotoXY(1,16);
  462.   nr:=bildwahl;
  463.   IF nr>0 THEN BEGIN
  464.      SetGraphMode(GraphMode);
  465.      edit(nr);
  466.      RestoreCrtMode
  467.   END
  468. END;
  469.  
  470.