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

    > Does anyone know how to make the input line a certain number of lines
    > only!...sya the user only gets to us 3 characters....

    Here is the input routine that I use for all of my programs.  You may
    not need it so precise, so you can cut out anything you don't feel is
    necessary but here goes:
    }

    UNIT KeyInput;

    INTERFACE

    USES CRT,CURSOR;

    PROCEDURE GetInput(VAR InStr;                    {String Passed}
                           WhatWas: String;          {Old value to Remember}
                           Len: Byte;                {Length of String Max=255}
                           XPosition,                {X Cursor Position}
                           YPosition,                {Y Cursor Position}
                           BackGroundColor,          {Background Color}
                           ForeGroundColor: Integer; {Foreground Color}
                           BackGroundChar: Char;     {Echoed Character on BkSp}
                           Caps: Boolean);           {CAPS?}
    IMPLEMENTATION

    PROCEDURE GetInput(VAR InStr;
                           WhatWas: String;
                           Len: Byte;
                           XPosition,
                           YPosition,
                           BackGroundColor,
                           ForeGroundColor: Integer;
                           BackGroundChar: Char;
                           Caps: Boolean);

    CONST
       BkSp: Char = Chr($08);

    VAR
       InsertKey: Byte Absolute $0040:$0017;
       Temp: String;
       Ch2,
       C: Char;
       A,
       U,
       B: Byte;
       FirstChar,
       InsertOn,
       NoAdd: Boolean;
       NewString: String Absolute InStr;

    BEGIN
       InsertKey := InsertKey OR $80; {changes to insert mode}
       IF (InsertKey AND $80 > 0) THEN
        BEGIN
           InsertOn := TRUE;
           ShowCursor;
        END
       ELSE
        BEGIN
           InsertOn := FALSE;
           BigCursor;
        END;
       FirstChar := TRUE;
       NewString := '';
       Temp := '';
       GotoXY(XPosition,YPosition);
       TextBackGround(BackGroundColor);
       TextColor(ForeGroundColor);
       FOR U := 1 TO Len DO
        BEGIN
           Write(BackGroundChar); {shows how many characters are available}
        END;
       GotoXY(XPosition,YPosition);
       C := Chr($00); {null character input}
       TextBackGround(ForeGroundColor);
       TextColor(BackGroundColor);
       NewString := WhatWas; {starts with previous value in memory}
       Write(NewString); {writes previous value to screen for editing}
       B := Length(WhatWas);
       A := B;
       TextBackGround(BackGroundColor);
       TextColor(ForeGroundColor);
       WHILE (C <> Chr($0D)) AND (C <> Chr($1B)) DO {not CR or ESC}
        BEGIN
           NoAdd := FALSE;
           IF Caps THEN C := UpCase(ReadKey) {if Caps read uppercase else...}
           ELSE C := ReadKey;
           CASE C OF
              Chr($08): IF B >= 1 THEN {backspace}
                         BEGIN
                            IF FirstChar THEN
                             BEGIN
                                FirstChar := FALSE;
                                GotoXY(XPosition,YPosition);
                                Write(NewString);
                             END;
                            Delete(NewString,B,1);
                            Write(BkSp,BackGroundChar,BkSp);
                            Dec(B);
                            GotoXY(XPosition+B,WhereY);
                            FOR U := B TO Length(NewString) DO
                             BEGIN
                                IF B <> U THEN Temp := Temp + NewString[U]
                                ELSE Temp := '';
                             END;
                            Write(Temp);
                            FOR U := Length(NewString)+1 TO Len DO
                             BEGIN
                                Write(BackGroundChar);
                             END;
                            GotoXY(XPosition+B,WhereY);
                            NoAdd := TRUE;
                            Dec(A);
                         END;
              Chr($1B): BEGIN {Escape}
                           NoAdd := TRUE;
                           NewString := WhatWas;
                        END;
              Chr($19): BEGIN {^Y = clear the editing line}
                           NoAdd := TRUE;
                           NewString := '';
                           GotoXY(XPosition,YPosition);
                           FOR U := 1 TO Len DO
                            BEGIN
                               Write(BackGroundChar);
                            END;
                           FirstChar := FALSE;
                           GotoXY(XPosition,YPosition);
                           B := 0;
                           A := 0;
                        END;
              Chr($0D): NoAdd := TRUE; {enter <CR>}
              Chr($00): BEGIN {extended keys always start with null character}
                           NoAdd := TRUE;
                           IF FirstChar THEN
                            BEGIN
                               FirstChar := FALSE;
                               GotoXY(XPosition,YPosition);
                               Write(NewString);
                            END;
                           C := UpCase(ReadKey);
                           CASE C OF
                              Chr(77): BEGIN {right arrow}
                                        IF B <= Length(NewString)-1 THEN
                                         BEGIN
                                            GotoXY(XPosition+B+1,WhereY);
                                            Inc(B);
                                         END;
                                     END;
                              Chr(75): BEGIN {left arrow}
                                          IF B >= 1 THEN
                                           BEGIN
                                              GotoXY(XPosition+B-1,WhereY);
                                              Dec(B);
                                           END;
                                       END;
                              Chr(71): BEGIN {home}
                                          GotoXY(XPosition,YPosition);
                                          B := 0;
                                       END;
                              Chr(79): BEGIN {end}
                                          GotoXY(XPosition+Length(NewString),YPosition);
                                          B := Length(NewString);
                                       END;
                              Chr(82): BEGIN {insert}
                                          IF InsertOn THEN
                                           BEGIN
                                              InsertOn := FALSE;
                                              BigCursor;
                                           END
                                          ELSE
                                           BEGIN
                                              InsertOn := TRUE;
                                              ShowCursor;
                                           END;
                                       END;
                              Chr(83): BEGIN {del}
                                          IF (B < Length(NewString)) AND (B >= 0) THEN
                                           BEGIN
                                              Delete(NewString,B+1,1);
                                              FOR U := B TO Length(NewString) DO
                                               BEGIN
                                                  IF U <> B THEN Temp := Temp + NewString[U]
                                                  ELSE Temp := '';
                                               END;
                                              GotoXY(XPosition+B,WhereY);
                                              Write(Temp);
                                              Write(BackGroundChar);
                                              GotoXY(XPosition+B,WhereY);
                                              Dec(A);
                                           END;
                                       END;
                           END;
                           WHILE Keypressed DO C := ReadKey;
                        END;
           END;
           IF ((A < Len) AND (NoAdd = FALSE) AND (C <> Chr($08))) OR ((FirstChar) AND
              (NOT(NoAdd)) AND (C <> Chr($08))) THEN
            BEGIN
               IF FirstChar THEN {if first character typed is a real character,then
                                 string is removed to start new one else...}
                BEGIN
                   Delete(NewString,1,Length(NewString));
                   GotoXY(XPosition,YPosition);
                   B := 0;
                   A := 0;
                   FOR U := 1 TO Len DO
                    BEGIN
                       Write(BackGroundChar);
                    END;
                   GotoXY(XPosition,YPosition);
                   FirstChar := FALSE;
                END;
               Inc(B);
               Inc(A);
               IF InsertOn THEN
                BEGIN
                   Insert(C,NewString,B);
                   FOR U := B TO Length(NewString) DO
                    BEGIN
                       IF B <> U THEN Temp := Temp + NewString[U]
                       ELSE Temp := '';
                    END;
                   GotoXY(XPosition+B-1,WhereY);
                   Write(C);
                   Write(Temp);
                   GotoXY(XPosition+B,WhereY);
                END
               ELSE
                BEGIN
                   Insert(C,NewString,B);
                   Delete(NewString,B+1,1);
                   Write(C)
                END;
            END;
        END;
        TextBackGround(0);
    END;

    BEGIN
    END.

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