home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 03 / tricks / readunit.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1989-12-14  |  5.5 KB  |  148 lines
  1. (* ------------------------------------------------------ *)
  2. (*                    READUNIT.PAS                        *)
  3. (*    Definiert die Prozedur ExtraRead zum Lesen einer    *)
  4. (*  Zeichenkette mit Editiermöglichkeit und Speicherung   *)
  5. (*  der zuletzt gedrückten Taste.                         *)
  6. (*       (c) 1990  Serge Schiltz & TOOLBOX                *)
  7. (* ------------------------------------------------------ *)
  8. UNIT ReadUnit;
  9.  
  10. INTERFACE
  11.  
  12. TYPE
  13.   AllChar = 0..511;
  14.  
  15.   { Typ der zuletzt gedrueckten Taste - ASCII-Code bzw.    }
  16.   { ASCII-Code + 256 bei "erweiterten" Tasten (siehe       }
  17.   { Tabelle C.2 im Referenzbuch von Turbo-Pascal 5.0)      }
  18.  
  19.   PROCEDURE ExtraRead (VAR Entry       : STRING;
  20.                            EntryLength : BYTE;
  21.                        VAR LastChar    : AllChar);
  22.  
  23.   { Entry : zu lesende Zeichenkette                        }
  24.   { EntryLength : maximale Laenge der Zeichenkette         }
  25.   { LastChar : letzte gedrückte Taste                      }
  26.  
  27. IMPLEMENTATION
  28.  
  29. USES Crt;
  30.   { Bei Turbo Pascal 4.0 muss die USES-Anweisung unter     }
  31.   { INTERFACE stehen.                                      }
  32.  
  33.   PROCEDURE ExtraRead (VAR Entry       : STRING;
  34.                            EntryLength : BYTE;
  35.                        VAR LastChar    : AllChar);
  36.   VAR
  37.     Ch       : CHAR;
  38.     CurPoint : BYTE;
  39.     Insert   : BOOLEAN;
  40.     x, y     : BYTE;
  41.     Exit     : BOOLEAN;
  42.     Counter  : BYTE;
  43.   BEGIN
  44.     x        := WhereX;
  45.     y        := WhereY;
  46.     Entry    := '';
  47.     CurPoint := 0;
  48.     Insert   := TRUE;
  49.     Exit     := FALSE;
  50.     REPEAT
  51.       Ch := ReadKey;
  52.       CASE Ch OF
  53.         #1..
  54.         #7,
  55.         #9..
  56.         #31  : BEGIN                         { Crtl-       }
  57.                  LastChar := Ord(Ch);        { Zeichen,    }
  58.                  Exit := TRUE                { Tab, Esc... }
  59.                END;
  60.         #32..
  61.         #255 : BEGIN                         { Buchstabe   }
  62.                  IF (Length(Entry) < EntryLength)
  63.                                     OR NOT Insert THEN BEGIN
  64.                    IF CurPoint = Length(Entry) THEN BEGIN
  65.                      IF Length(Entry) < EntryLength
  66.                                                   THEN BEGIN
  67.                        Entry := Entry + Ch;
  68.                        GotoXY(x + CurPoint, y);
  69.                        Inc(CurPoint);
  70.                        Write(Ch)
  71.                      END;
  72.                    END ELSE BEGIN
  73.                      IF Insert THEN BEGIN
  74.                        Entry := Entry + #32;
  75.                        FOR Counter := Length(Entry)-1
  76.                                         DOWNTO CurPoint+1 DO
  77.                          Entry[Counter+1] := Entry[Counter];
  78.                      END;
  79.                      Inc(CurPoint);
  80.                      Entry[CurPoint] := Ch;
  81.                      GotoXY(x,y);
  82.                      Write(Entry);
  83.                      GotoXY(x + CurPoint, y);
  84.                    END;
  85.                  END;
  86.                END;
  87.         #08  : BEGIN                         { Backspace   }
  88.                  IF CurPoint <> 0 THEN BEGIN
  89.                    FOR Counter := CurPoint
  90.                                        TO Length(Entry)-1 DO
  91.                      Entry[Counter] := Entry[Counter+1];
  92.                    Entry := Copy(Entry,1,Length(Entry)-1);
  93.                    Dec(CurPoint);
  94.                    GotoXY(x,y);
  95.                    Write(Entry,' ');
  96.                    GotoXY(x + CurPoint, y);
  97.                  END;
  98.                END;
  99.          #0  : BEGIN                    { erweiterte Taste }
  100.                  Ch := ReadKey;
  101.                  CASE Ch OF
  102.                    #0..
  103.                    #74,
  104.                    #76,
  105.                    #78..
  106.                    #81,
  107.                    #84..
  108.                    #255 : BEGIN
  109.                             LastChar := Ord(Ch) + 256;
  110.                             Exit := TRUE;
  111.                           END;
  112.                    #82  : Insert := NOT Insert;
  113.                    #83  : BEGIN
  114.                             IF CurPoint <> Length(Entry)
  115.                                                   THEN BEGIN
  116.                               FOR Counter := CurPoint+1 TO
  117.                                           Length(Entry)-1 DO
  118.                                 Entry[Counter] :=
  119.                                            Entry[Counter+1];
  120.                               Entry := Copy(Entry,1,
  121.                                            Length(Entry)-1);
  122.                               GotoXY(x,y);
  123.                               Write(Entry,' ');
  124.                               GotoXY(x+CurPoint,y);
  125.                             END;
  126.                           END;
  127.                    #75  : BEGIN              { Links-Pfeil }
  128.                             IF CurPoint <> 0 THEN BEGIN
  129.                               Dec(CurPoint);
  130.                               GotoXY(x + CurPoint, y);
  131.                             END;
  132.                           END;
  133.                    #77  : BEGIN             { Rechts-Pfeil }
  134.                             IF CurPoint <> Length(Entry)
  135.                                                   THEN BEGIN
  136.                               Inc(CurPoint);
  137.                               GotoXY(x + CurPoint, y);
  138.                             END;
  139.                           END;
  140.                  END;
  141.                END;
  142.       END;
  143.     UNTIL Exit = TRUE;
  144.   END;
  145.  
  146. END.
  147. (* ------------------------------------------------------ *)
  148. (*                Ende von READUNIT.PAS                   *)