Nachdem in der letzten CHIP einiges allgemeines über das NewBASIC berichtet wurde, soll es nun weiter ins Detail gehen. Doch zuerst einige Neuigkeiten: inzwischen gab es weitere Betaversionen - aktuell ist die 3d, welche sich zwar jetzt nicht mehr im Testbereich bei ND befinden, dafür aber auf deren ftp-Server. Voraussetzung ist allerdings immer noch eine Betaversion von NDO 3.0 - die Vollversion gibt es ja noch nicht. Zu finden ist das Archiv im Verzeichnis /pub/newdeal_files und der Dateiname lautet nbbeta*.zip (der * entspricht der jeweiligen Version).

Der Funktionsumfang wurde zwar beibehalten, dafür gibt es aber einige neue Objekte für den Dateizugriff und für den Zugriff auf den Drucker. Auch funktioniert jetzt das compilieren der Programme, so das man sie direkt per Doppelklick im New-Manager starten kann. Es gibt mittlerweile einige sehr interessante Beispiele von Programmierern rund um die Welt, die zeigen, was in NewBASIC steckt.

Ein NewDOS*-Programm besteht in den meisten Fällen aus mehreren Fenstern, hier Forms genannt. Startet man den New-BASIC Builder, wird sofort eine leere Form geöffnet - form l. Da man mit dieser noch nichts anfangen kann, bietet der New-Builder einige Werkzeuge: die Toolbox um die gewünschten Objekte hinzuzufügen und die Eigenschaftsbox um die einzelnen Objekte den eigenen Vorstellungen anzupassen. Die Toolbox unterteilt sich in mehrere Bereiche: "Basic UI" für die Oberflächengestaltung, "Primitive" für einfache Objekte, "Deluxe" für fortgeschrittenere Objekte, "Service" für Objekte, welche direkt auf das NewDOSSystem zugreifen und "Window" mit den zwei verfügbaren Fenster-Objekten.

Um eines der Objekte in der Form zu plazieren, klickt man mit der linken Maustaste auf die entsprechende Taste und bewegt die Maus auf die Form - der Mauszeiger verwandelt sich in einen gebogenen Pfeil. Befindet man sich über der gewünschten Stelle, klickt man noch einmal mit der linken Maustaste und das Objekt wird an der Stelle eingefügt. Wo es dann genau plaziert wird, hängt aber auch von den Eigenschaften der Form ab: ist "Autolayout" aktiviert, wird es entsprechend den dort getroffenen Einstellungen plaziert, ist "AutoLiyout" deaktiviert, kann man es Pixelgenau ausrichten. Hat man das falsche Objekt gewählt und es noch nicht auf der Form abgesetzt, klickt man mit der Maus auf die kleine Taste zwischen der Bereichsauswahl und den einzelnen Objekten auf der Toolbox. Hat man das Objekt bereits in der Form plaziert, markiert man das Objekt mit einem Mausklick - es erhält einen roten Rahmen, und kann es mit einem Druck auf die [Entf] - Taste wieder löschen.

Es empfiehlt sich, bevor man mit der Programmierung beginnt, sich wenigstens einen groben Plan zu machen, wie das Programm einmal aussehen und was es machen soll. Das erspart teilweise viel Arbeit im Nachhinein. Weiterhin ist es sehr praktisch, die Eigenschaftsbox auch während des "zusammenklickens" der Oberfläche bereits geöffnet zu haben (Menü: Window / Component Properties...) um den einzelnen Objekten konkrete Namen zu geben. NewBASIC, vergibt von sich aus eigentlich unbrauchbare Namen: z.B. "buttonl", "button2" usw. für Tasten. In einem einfachen Programm kommt man damit sicher noch zurecht, nicht aber in einem komplexeren. Da sind Namen wie "speichern_button" oder "into_bulton" schon viel eindeutiger. Um diese zu ändern, schreibt man den eindeutigen Namen sowohl in die "Name" als auch in die "Proto"-Eigenschaft der Taste. Die "Caption" - Eigenschaft ist für die Beschriftung der Taste zuständig, in unserem Fall z.B. "Speichern" bzw. "Info" - das ist der Text, den der Anwender sieht.

Die Größe eines Objektes kann man sowohl mit der Maus (grob) als auch mittels deren Eigenschaften ändern. Bei einer Taste passt sich deren Breite im Normalfall automatisch an die eingegebene Beschriftung an. Sollen mehrere Tasten die selbe Breite haben, kann kam deren "Width"-Eigenschaft von "As needed" auf "As specified" setzen. Damit wird das "Width"-Feld freigegeben und man kann die Größe Pixelgenau eingeben.

Um etwas Übung zu bekommen wird der NewBASIC Builder geöffnet oder falls er schon geöffnet ist, ein neues Modul angelegt (Menü: File / New Module). Danach wählt man die Form aus (rot umrandet) und öffnet die Eigenschaftsbox (Menü: Window / Component Properties...). Die Form wird mit der Caption: "Hallo !" beschriftet. Alle Änderungen in der Eigenschaftsbox müssen mit einem Klick auf (Apply) bestätigt werden. Nun wechselt man in der Toolbox in den Bereich "Deluxe", wählt dort das Text-Objekt und legt es auf der Form, Eigenschaften: Name/Proto: "hallo text". Zurück in den "Basic UI" - Bereich der Toolbox und dort ein "button"-Objekt auswählen. Dieses erhält den Namen/Proto: "hallo button" und die Caption "Hallo ?".

Nun ist zwar die Oberfläche fertig, aber sie sieht noch nicht so besonders aus, die Form ist zu groß und die beiden Objekte "hallo_text" und "hallo_button" "kleben" zusammen, Um dies zu ändern, markiert man die Form (rot eingerahmt) und wechselt in der Eigenschaltsbox in den "Children"-Bereich. Dort befindet sich unter anderem die Eigenschaft "Tile Spacing". Sie ist für den Abstand zwischen den einzelnen Componenten innerhalb der Form zuständig.
Ändert man den Wert auf '5' erhall man einen fünf Pixel großen Abstand zwischen den Objekten "hallo_text" und "hallo_button". Im "General"-Bereich der Eigensehaftsbox wird noch die Breite (Width) und die Höhe (Height) von "As specified" (wie angegeben) auf "As needed" (wie benötigt) eingestellt, um die Form auf eine vernünftige Größe zu bringen. Das Speichern des Programmes sollte man auch nicht vergessen: File / Save.

Bisher haben wir nur mit der Maus "rumgeklickt" und das Ergebnis sieht doch schon ganz gut aus. Im Gegensatz zu IZL haben wir bisher kein Stück Code geschrieben. Unter NewBASIC läuft alles eben etwas anders: NewDOS ist ein Ereignisorienliertes System. Das heißt, die Anwendungen reagieren auf Eingaben vom Benutzer, auf Maus-Aktionen, Tastenanschläge und ähnliches. Damit das Programm möglichst einfach auf solche Ereignisse reagieren kann, haben sich die Leute von NewDeal etwas geniales ausgedacht: jedes Objekt hat mehrere mögliche Ereignisse. Tritt ein Ereignis ein, so wird, falls vorhanden, ein entsprechendes Unterprogramm aufgerufen. In diesem Unterprogramm stehen nun endlich wieder richtige, handfeste Anweisungen. Wie werden nun die Unterprogramme autgerufen? Das Schema ist denkbar einfach: Bei einem Ereignis sucht NewBASIC nach einem Unterprogramm dessen Name aus dem Namen des Objekts, einem tiefgestelltem Bindestrich ("_") und dem Ereignis besteht.

Angenommen, es existiert eine Taste mit dem Namen "button1". Wenn der Benutzer nun auf die Taste klickt (Pressed-Ereignis), so versucht NewBASIC das Unterprogramm mit dem Namen "buttonl_pressed" aufzurufen.

Nur, wie erstellt man jetzt ein Unterprogramm? Ganz einfach: Wir befanden uns bisher die ganze Zeit im "Entwurfs"-Modus. Um nun auf die Codeebene zu gelangen, klickt man doppelt auf ein Objekt. Es erscheint das Editor-Fenster. Wählt man in der "Components"-Liste "hallo_button" und in der "Events"-Liste das "_pressed"-Ereignis erhält man gleich ein Unterprogramm. Das _pressed-Ereignis tritt ein, wenn die Taste gedrückt wird.

Nun erst mal zu diesem Editorfenster: im oberen Bereich befinden sich drei Listen. Die linke Liste enthält die sogenannten Objekte (Components), z. B. ein Textfeld. Wird hier ein Objekt gewählt, erscheinen in der mittleren Liste die dazugehörigen Ereignisse (Events). In der dritten Liste sind alle bisher im Programm enthaltenen Routinen zu sehen. Soll eine geändert werden, so wählt man sie einfach aus dieser Liste.

Es sollte aber eine Ereignisprozedur erstellt werden. Nach Wahl des Objektes "hallo_button" und dem Ereignis "pressed" erhält man bereits eine Routine, die allerdings noch nichts tut. In dieser können nun Anweisungen eingeben werden, die ausgeführt werden, sobald der Benutzer auf die Taste klickt.

Zwischen den beiden schon vorhandenen Zeilen wird folgendes eingegeben:

hallo text.text = "Hallo, schöne Welt!"

Jetzt müßte die Routine folgendermaßen aussehen:

sub hallo_button_pressed(self as button)
    hallo_text.text = "Hallo, schöne Welt !"
end sub

Das ganze funktioniert zwar jetzt schon, aber eine kleine Änderung sollten wir noch vornehmen. Das "ö" stellt ein Sonderzeichen dar, welches es nicht im Englischen gibt und da niemand voraussagen kann, was damit passiert, wenn das Programm einmal in einem anderen Editor geöffnet wird, wird es durch "chr(154)" ersetzt. "chr()" liefen das entsprechende Zeichen zum angegebenen Code, in unserem Eall ein "ö". Eine Übersicht dieser Zeichencode befindet sich z. B. im Anhang das Handbuches zu Geoworks Ensemble, New Deal Office. Auch dem NewBASIC Magazin Nr .5 wird eine beiliegen. Nach dieser Änderung sieht die Routine wie folgt aus:

sub hallo_button_pressed(self as button)
    hallo_text.text = "Hallo, sch"+chr(154)"neWelt!"
end sub

Was die Befehle bedeuteten, wird gleich erklärt, aber erst einmal soll das Programm getestet werden ([Run]). Nach einem Klick auf die Taste [Hallo ?] erscheint im Text-Objekt "Hallo, schöne Welt!".
Es ist also nicht schwierig, NewBASIC dazu zu bringen, auf Ereignisse zu reagieren.
Es ist ja schon mal nicht schlecht, dass man die Eigenschaften von einem Objekt ändern kann. Was aber noch wichtiger ist, ist die Tatsache, daß diese Eigenschaften auch vom Programm geändert werden können. Zum Beispiel ist es möglich, daß der Text im Textfeld auf "Nobody" gesetzt werden kann, wenn der Benutzer auf einen Knopf drückt usw.
Um nun auf eine Eigenschaft zugreiten zu können, müssen zwei Dinge bekannt sein:

1.   der Name des Objekts
2.   die Eigenschaft

Angenommen, es soll der Text des Textfeldes geändert werden (das "hallo_text" heißt), so sieht der Zugriff so aus:

hallo_text.text = "Nobody"

Der Name des Objekts ist durch einen Punkt vom Namen der Eigenschaft abgegrenzt:

.

Mit dieser Eigenschaft kann man genauso umgehen wie mit einer Variablen:

A=textl.text
textl.text=B
If textl.text = "" Then
...

Im folgenden einige wichtige Eigenschaften, die zu den meisten Objekten gehören:

Eigenschaft - Bedeutung

Name - Gibt den Namen des Objekts an. Der Name wird in der Objekt-Liste im Editor und in der Eigenschaftsbox verwendet.

Proto - Gibt die Proto-Eigenschaft des Objektes an. Diese wird z. B. für die Ereignis-Routinen verwendet: <-Name>_. Heißt ein Objekt zum Beispiel "KNOPF" und handelt es sich um das pressed-Ereignis, so wird die Routine "KNOPF_pressed" aufgerufen, falls vorhanden. Es empfiehlt sich, der Name- und Proto-Eigenschaft denselben Namen zuzuweisen, um später eventuelle Verwirrungen zu venneiden.

Caption - Diese Eigenschaft gibt die Beschriftung eines Objekts an. Sie hat aber nichts mit der Name-Eigenschaft zu tun!

Enabled - Ist diese Eigenschaft aktiviert, so kann das Objekt normal benutzt werden. Ist die Eigenschaft dagegen deaktiviert, kann das Objekt nicht benutzt werden.

Visible - Gibt an, ob ein Objekt sichtbar ist. Ist Visible aktiviert, so ist das Objekt zu sehen. Ist es deaktiviert, so ist das Objekt unsichtbar.

Text - Nur für Textfelder. Diese Eigenschaft gibt den Text an, den das Objekt enthält. Diese Eigenschaft ändert sich, sobald der Benutzer etwas im Textfeld eingibt.

Es werden sicher noch mehr Eigenschaften dazukommen, aber für diesen Kursteil sollte es reichen. Wem die Zeit bis zum nächsten Kursteil zu lang wird, der kann sich ja mit dem "NewBASIC Magazin" beschäftigen. Zu finden sowohl auf dem GUC-Server (www.geosuserclub.com) als auch auf meiner Homepage (Adresse wird nachgereicht).

Hinweis: NewBASIC arbeitet teilweise sehr ähnlich wie Visual Basic. Wenn man preiswert an ein Buch für Visual Basic herankommt, kann man sich damit auch sehr gut in NewBASIC einarbeiten.

* NewDOS: die Basis des New Deal Office Paketes, bei Geoworks Ensemble hieß es noch GEOS

Dirk Haase