Edit in GFA-Basic

Eine GEM-Eingaberoutine -aber am GEM vorbei! Natürlich kann man in GFA-BASIC mit Dialogboxen arbeiten und damit alle möglichen ‘Schweinereien’, die ein unbedarfter Benutzer anrichten kann, um die so mühsam erstellte Eingabemaske zu ruinieren, im Keim ersticken. Man braucht ja nur ein Resource-Construction-Set, zusätzlichen Platz für das . RSC-File und - fast hätte ich es vergessen - viel Zeit! Und davon hat man meist am wenigsten!

Natürlich kann man den FORM INPUT-Befehl des GFA-BASIC verwenden, um nach erfolgter Eingabe festzustellen, daß die Satzzeichen im Vornamen unmöglich Absicht waren, (also AÜAV Plausibilitätsschleife oder gar ein Rücksprung im Programm!?).

Dies und noch mehr erspart einem die Prozedur EDIT. Sie wurde geschrieben, weil der Verfasser genau die zuvor angesprochenen Probleme selbst hatte. Sein Programm sollte eine Liste von Eingaben erwarten, wobei nachträgliche Korrekturmöglichkeiten seitens des Benutzers genauso erwünscht waren wie ein GEM-ähnliches Handling mit den Steuertasten. Außerdem sollte jeweils nur eine ganz speziell zusammengestellte Teilmenge der möglichen Zeichen erlaubt sein.

Den Sprung ins GEM der Dialogboxen wollte der Verfasser sich in GFA-BASIC nicht antun. AA zumal es mit der Ausfilterung unliebsamer Zeichen da gewisse Grenzen und Schwierigkeiten gibt. Der FORM INPUT-Befehl leistet auch einiges, neben der bereits erwähnten Online-Ausfilterung unerwünschter Zeichen sollte aber auch ein Wandern zwischen den Eingabefeldem mittels der Cursor up/ down-Tasten möglich sein.

EDIT kann’s

Die Prozedur EDIT kommuniziert mit dem Hauptprogramm ausschließlich über die Parameterliste. Es gibt also keine globalen Variablen. Sämtliche sonst verwendeten Variablen sind für die Prozedur lokal definiert. Man braucht also keine Angst zu haben, daß eigene Variablennamen zufällig mehrfach Vorkommen. Da die Übergabeschnittstelle auch einen Ausgang haben soll, sind die ‘call by reference’-Parameter via Pointer realisiert. Pascal bietet mehr Komfort in dieser Richtung (var-Parameter), aber man muß glücklich sein, daß Herr Ostrowski ein BASIC geschrieben hat, mit dem man wenigstens keine globalen Variablen braucht.

Für Zeitgenossen, die ein Programm nicht nur abtippen, sondern auch verstehen wollen, ist EDIT ausführlich kommentiert. Besonders die Kommentarzeilen am Anfang helfen, EDIT auch nach mehreren Monaten in der Schreibtischschublade in einem neuen Programm wieder einzusetzen. Man muß natürlich keine Kommentarzeile abtippen, wenn man die dazugehörige Ausgabe der ST-Computer stets zur Hand hat...

Defilee der Parameter

Nun folgt eine Beschreibung der verwendeten Übergabeparameter:

Atx%, Aty%
übergeben die horizontale und vertikale Zeichenposition des Eingabefeldes auf dem Bildschirm. Dabei wird im Window-Modus immer der linke obere Rand des aktuellen Fensters als Ursprung zugrundegelegt. EDIT funktioniert aber auch ohne Fenster!

Maxlen%
übergibt die maximal mögliche Zeichenanzahl des Eingabefeldes ähnlich FORM INPUT. Will man mehr Zeichen eingeben, ertönt ein Glockenzeichen.

Darf ich’s annehmen?

Valid$ ist eines der ‘Bonbons’ von EDIT. Nur die Zeichen, die in diesem String stehen, werden bei der Eingabe überhaupt angenommen und auf den Bildschirm gebracht! Man kann sich damit individuell je Aufruf den zulässigen Zeichenvorrat zusammenstellen.

Ein Beispiel: Für die Eingabe eines (deutschen) Namens benötigt man Groß- und Kleinbuchstaben, die Umlaute, das Leerzeichen und den Bindestrich (für ‘Müller - Lüdenscheid’ !). Sonst aber nichts! Ein kleines Programmstück erzeugt einen passenden Filter:

Buchstabe$="- äöüßÄÖÜ"

For I%=Asc("A") To Asc("Z") 
Buchstabe$=Buchstabe$+Chr$(I%) 
Next 1%
For I%=Asc("a") To Asc("z") 
Buchstabe$=Buchstabe$+Chr$(I%)
Next I%

Eine Eingabe, die nur “j” für ja und “n” für nein erwartet, benötigt schlicht und einfach “jn” als Parameter. Da der Parameter als ‘call by value’ übergeben wird, braucht ja keine Variable verwendet zu werden! Wenn nur natürliche Zahlen eingegeben werden sollen, so übergibt man natürlich “0123456789” etc..

Default$ übergibt einen String, der zu Beginn der Eingabe angezeigt werden soll. Das kann ein fester Name sein oder auch die zu ändernde Variable (siehe Beispielprogramm!). Falls die Länge von Default$ kleiner als Maxlen% ist, so wird das Eingabefeld mit Unterstrichen “ “ aufgefüllt.

Rück’s raus!

Temp%
ist der Zeiger auf die Variable, die nach Rückkehr aus EDIT den eingegebenen String beinhalten soll. Man muß also “*Vorname$” angeben, wenn man etwa die Stringvariable “VornameS” verwendet. Leider kann man keine Feldelemente von Stringvariablen übergeben, man umgeht das Problem aber leicht mit einer Hilfsvariablen (siehe Beispielprogramm).

Changed%
ist der Pointer auf eine Boolesche (logische) Variable ‘Changed!' (also mit “*Changed!" aufrufen!). Sie wird als “_true_” übergeben, falls sich die Eingabe vom Vorgabewert (!) “_Default$_” unterscheidet, sonst als “false”. Das ermöglicht oft ein schnelleres Weiterarbeiten des Programms, wenn der Benutzer den vom Programm angebotenen Vorgabewert widerspruchslos akzeptiert hat.

Quit%
ist schließlich der Pointer auf eine Integer-Variable, deren Inhalt nach Rückkehr aus EDIT anzeigt, welche Taste zum Verlassen der Eingabe geführt hat (siehe unter Steuerzeichen).

Man kann die letzten beiden Parameter ignorieren, muß sie jedoch immer mit angeben. Wer sie niemals benötigt, soll sie halt aus der Prozedur entfernen!

Steuerzeichen - nicht für’s Finanzamt!

Ähnlich wie beim GEM sind während der Eingabe verschiedene Steuerzeichen erlaubt. Cursor links und Cursor rechts verschieben die Schreibmarke innerhalb des momentan im Eingabefeld stehenden Textes jeweils um eine Stelle. ESC löscht das gesamte Eingabefeld. Die Tasten Delete und Backspace funktionieren GEM-üblich.

Ciao bella!

Natürlich kann man die Eingabe auch abschließen, so viel Spaß das Spielen in der Eingabemaske auch macht. Dazu sind von der Prozedur her drei Möglichkeiten vorgesehen: die Return-Taste sowie die Tasten Cursor runter und Cursor hoch. EDIT übergibt in der bereits erwähnten Variablen “Quit%” eine entsprechende Information. War es Return, so wird 1 übergeben, für Cursor runter 2 und für Cursor hoch schließlich 3. Dadurch kann z.B. entschieden werden, ob die Eingabe in einer Maske mit mehreren Feldern weiter unten oder weiter oben fortgesetzt werden soll. Die Retum-Taste dient dann etwa zum Verlassen der gesamten Maske (siehe Beispielprogramm).

No Mouse!

EDIT benötigt den Mauszeiger während der Eingabe nicht und schaltet ihn deshalb zu Beginn der Prozedur ab. Dieser mauslose Zustand wird jedoch vor Rückkehr wieder aufgehoben.

Ich hoffe, daß die Prozedur Ihnen einige “Eingabesorgen” abnimmt, vielleicht lese ich in einer der nächsten Ausgaben dieser Zeitschrift auch über Erweiterungen und/oder Verbesserungen....

Procedure Edit(Atx%,Aty%,Maxlen%,Valid$,Default$,Temp%, Changed%,Quit%)
    '
    ' **Autor:** Franz Klement  Version: 1.2
    '
    ' Emuliert eine GEM-Editfeld-Eingabe (aber am GEM vorbei!)
    '
    ' Beginn des Editfeldes             (Atx%,Aty%)
    ' Länge des Editfeldes              Maxlen%
    ' Menge der zulässigen Zeichen      Valid$
    ' Defaultwert und Übergabepointer   Default$, Terap%
    ' Textfeld geändert (boolean Ptr)   changed%
    ' Taste des Ausgangs                quit%
    '                                   1: return
    '                                   2: Cursor   down
    '                                   3: Cursor   up
    '
    ' Innerhalb des Editfeldes sind zusätzlich folgende Tasten zulässig:
    ' Cursor left : Cursor ein Zeichen nach links 
    ' Cursor right: Cursor ein Zeichen nach rechts (bis Textende)
    '   Esc         :   löscht  das ganze Eingabefeld
    '   Delete      :   löscht  Zeichen unter Cursor
    '   Backspace   :   löscht  Zeichen links von Cursor
    ' Der Defaultwert wird vorgegeben
    ' Die Maus ist während des Editierens abgeschaltet. 
    Local C%,Ch$,Exception$,Llen%,Lpos%,T$,Raus!
    '
    ' Die Steuerzeichen könnte man zum Teil auch über Control-Tasten ablegen 
    Exception$=Chr$(13)+Chr$(208)+Chr$(200)+Chr$(27)+Chr$(8)
    Exception$=Exception$+Chr$(127)+Chr$(203)+Chr$(205) ! Steuerzeichen
    '
    ' Eingabe vorbereiten
    '
    Hidem
    Raus!=False ! Flag für Schleifenausgang 
    '
    ' Eingabemaske zurechtbasteln
    '
    Llen%=Min(Len(Default$),Maxlen%) ! aktuelle Stringlänge 
    Lpos%=Llen% !   aktuelle    Cursorposi.
    If Maxlen%>Llen%
        T$=Default$+String$(Maxlen%-Llen%,"_") ! auffüllen mit '_'
    Else
        T$=Left$ (Default$, Maxlen%)
    Endif
    '
    ' Tastenabfrage
    '
    Repeat
        Print At(Atx%,Aty%);T$;
        Print At(Atx%+Lpos%,Aty%+1);"~"; !*"Cursor" sichtbar machen
        '
        C%=Inp(2)   ! wartet auf Tastendruck und holt Zeichen von der Tastatur
        '
        Print At(Atx%+Lpos%,Aty%+1);" "; !  Cursor unsichtbar machen
        Ch$=Chr$(C%)
        If Instr(Valid$,Ch$)<>0 And Llen%<Maxlen% Then 
            ' füge Zeichen ein
            T$=Left$(Left$(T$,Lpos%)+Ch$+Mid$(T$,Lpos%+1), Maxlen%)
            Inc Lpos%
            Inc Llen%
        Else
            C%=Instr(Exception$,Ch$) ! hole Exceptions 
            If C%=0 Then
                Print Chr$(7); ! Glocke, weil unerlaubtes Zeichen 
            Endif
            If C%=1 Or C%=2 Or C%=3 Then ! Return, Crsr up or Crsr down gedrückt
                Raus!=True
                *Quit%=C%   !   Übergabe der letzten Taste
                T$=Left$(T$,Llen%) ! Übergabe des aktuellen Strings
                *Temp%=T$   !   by reference
                *Changed%=(T$<>Default$) ! Übergabe, ob Text verändert wurde
            Endif ! Return
            '
            If C%=4 Then ! Escape gedrückt 
                Llen%=0 
                Lpos%=0
                T$=String$(Maxlen%, "_")
            Endif ! Escape
            If C%=5 And Lpos%>0 Then ! Backspace gedrückt 
                T$=Left$(T$,Lpos%-1)+Mid$(T$,Lpos%+1)
                Dec Lpos%
                Dec Llen%
            Endif ! Backspace
            '
            If C%=6 And Lpos%<Llen% Then ! Delete gedrückt 
                T$=Left$(T$,Lpos%)+Mid$(T$,Lpos%+2)+"_"
                Dec Llen%
            Endif ! Delete
            If C%=7 Then ! Crsr left gedrückt 
                If Lpos%>0 Then 
                    Dec Lpos%
                Endif 
            Endif ! Crsr left
            If C%=8 Then ! Crsr right gedrückt 
                If Lpos%<Llen% Then 
                    Inc Lpos%
                Endif 
            Endif ! Crsr right
        Endif 
    Until Raus!
    Showm
Return

Listing: Edit in GFA-BASIC

Franz Klement



Links

Copyright-Bestimmungen: siehe Über diese Seite
Classic Computer Magazines
[ Join Now | Ring Hub | Random | << Prev | Next >> ]