Das R-BASIC Objekt-Handbuch

Einfach unter PC/GEOS programmieren

Willkommen in der Welt der Objekte, Ereignisse und Botschaften

1.0 Überblick

1.1 Ein Beispiel zur Einführung

1.2 Grundlegende Begriffe

1.3 Vereinbarungen für dieses Handbuch

1.4 Syntax für Objektzugriffe

1.5 Vereinbarung von Action-Handlern

1.0 Überblick

In diesem Handbuch wird beschrieben, wie Sie mit R-BASIC Programme erstellen, die sich vollständig ins System integrieren und sich nach außen nicht von 'normalen' (mit dem PC/GEOS SDK erstellten) Programmen unterscheiden.

Zu den grundlegenden Konzepten von GEOS und damit auch von R-BASIC gehören die objektorientierte Programmierung (OOP) und die ereignisorientierte Programmierung. Selbst der 'klassische' Modus von R-BASIC ist intern mit OOP realisiert. Hier erfahren Sie, welche Objekte es gibt, welche Eigenschaften und Fähigkeiten sie haben und wie Sie die nutzen können.

Verweise auf andere Kapitel beziehen sich, wenn nicht explizit anderes angegeben, immer auf das Objekt Handbuch.

Um mit diesem Handbuch arbeiten zu können müssen Sie unbedingt die folgenden Kapitel 1.3 (Vereinbarungen für dieses Handbuch) und 1.4 (Syntax von UI-Objekten) lesen. Die dort vorgestellten Sachverhalte werden in allen darauffolgenden Kapiteln vorausgesetzt.

Im Benutzerhandbuch wird erklärt, wie man das R-BASIC Oberfläche benutzt, wie man Programme in andere Sprachen übersetzt und andere Dinge, die nur indirekt mit dem eigentlichen Programmieren zu tun haben.

Grundlegenden Befehle und Konzepte, die die R-BASIC Programmiersprache ausmachen, finden Sie im R-BASIC Programmierhandbuch. Dort erfahren Sie auch alles über Variablen, Schleifen, Verzweigungen, Unterprogramme und andere grundlegende Dinge.

Das Handbuch 'Spezielle Themen' widmet sich weiterführenden Themen, wie der Arbeit mit Dateien oder die Verwendung von Schriften.

^

1.1 Ein Beispiel zur Einführung

Erstellen der grafischen Oberfläche

In den meisten Fällen beginnt man ein Programm damit, dass man die grafische Oberfläche programmiert. Starten Sie R-BASIC mit einer neuen Datei. Links unten finden Sie die verfügbaren Code-Fenster. Wir benötigen nur die Fenster 'BASIC-Code' und 'UI-Objekte'. Im Fenster 'DIM & DATA' werden bei größeren Projekten globale Vereinbarungen und Variablen untergebracht. Die Codefenster 'Init-Code' und 'Tools' können wir zunächst ignorieren. Hier kann man Teile seines Programmcodes ablegen um das Programm übersichtlicher zu halten. UI steht für User Interface (Benutzerschnittstelle) und bezeichnet die Objekte, mit denen der Benutzer des Programms interagieren kann. Das Fenster 'UI-Objekte' enthält den UI-Code des Programms, der beschreibt, welche Objekte es gibt und welche Eigenschaften sie haben.

Von Klassen und Objekten

Zurück zu unserem UI Code. Das erste Objekt ist vom Typ (man sagt: der Klasse) 'Application' und hat den Namen DemoApplication. Dieses Objekt stellt die Verbindung zum GEOS-System her. Jedes Programm muss genau ein solches Objekt haben. Der Namen (hier: DemoApplication) ist frei wählbar. Über diesen Namen kann man das Objekt im BASIC-Code ansprechen.

Mit END Object wird angezeigt, dass die Definition des Objekts beendet ist.

Das nächste Objekt gehört der Klasse 'Primary' an und hat den Namen 'DemoPrimary'. Man hätte es natürlich auch anders nennen können. Das Primary-Objekt nimmt uns sehr viel Arbeit ab, denn es erzeugt selbständig einige Objekte: das Dateimenü, das System-Menü links oben neben der Titelleiste und die Minimieren-Maximieren-Schalter rechts oben. Auch das Express-Menü wird hier platziert. Das Child (Kind) des Primary-Objekts ist ein View-Objekt, dass in unserem Programm gemeinsam mit seinem 'Content' für alle Ausgaben auf den Bildschirm zuständig ist.

Die letzten beiden Objekte sind ein View-Objekt (Objektklasse 'View' mit dem Namen 'DemoView') und ein Content-Objekt (der Klasse 'BitmapContent' namens 'DemoBitmap'). Diese beiden Objekte arbeiten eng zusammen. Während das Content ausschließlich für die Verwaltung der darzustellenden Grafik zuständig ist kümmert sich das View-Objekt um das Wie, Wann und Wo. Eine ausführliche Beschreibung dieses Zusammenspiels finden Sie im Kapitel über das View-Objekt (Kapitel 4.6). Dabei ist nur das View-Objekt als Child des Primary-Objekts in den Tree eingebunden.

Beachten Sie, dass das BitmapContent-Objekt 'DemoBitmap' nirgends als Child eines Objekts auftaucht, sondern nur als 'Content' des View-Objekts. Das ist für das ordnungsgemäße Zusammenspiel von View und Content erforderlich.

Wenn Sie nun das Programm starten (Menü 'Programm', 'Programm starten') wird es compiliert und ausgeführt. Dabei erzeugt der Compiler die im UI-Code angegeben Objekte und übersetzt den Quelltext im 'BASIC-Code' Fenster in ein für R-BASIC ausführbares Format. Um zur R-BASIC IDE zurückzukehren wählen Sie aus dem Datei-Menü des laufenden BASIC-Programms den 'Beenden' Eintrag.

Ein OnStartup Handler

Nachdem der OnStartup-Handler abgearbeitet ist geht das Programm in den Wartezustand über. Damit wieder etwas passiert müssen wir etwas tun, z.B. einen Button anklicken.

Ein neues Objekt

Wenn sich etwas ereignet

Wird der Button angeklickt, so spricht man von einem Ereignis - in diesem Fall ein Maus-Ereignis. Der Button nimmt dieses Ereignis entgegen und 'weiß' was er damit zu tun hat. Das ist der Kern der objektorientierten Programmierung: Jedes Objekt reagiert auf Ereignisse (Maus, Tastatur, Mitteilungen von anderen Objekten), indem es die Behandlung selbst vollständig übernimmt oder ein weiteres Ereignis auslöst. Auch das Starten des Programms stellt ein Ereignis dar. unser Application-Objekt reagiert auf dieses Ereignis, indem es seinen OnStartup-Handler aufruft (siehe oben). Ein Textobjekt z.B. stellt einen eingegebenen Buchstaben selbständig auf dem Bildschirm dar, für unseren Button aber müssen wir eine eigene Routine (einen eigenen Handler) schreiben, die eine Aktion ausführt.

Die Verknüpfung zwischen der Routine (dem Handler) und dem Button erfolgt wieder in UI-Code. Beim Button heißt die Instancevariable, die man dazu belegen muss, einfach ActionHandler.

Es geht weiter...

Anordnen von Objekten - das Geometriemanagement

Unter GEOS, und damit auch in R-BASIC, funktioniert die Anordnung von Objekten nicht dadurch, dass man festlegt, wo die Objekte platziert werden, sondern wie sie angeordnet werden sollen. Man sagt nicht: platziere den Button dort, sondern man sagt: ordne beide Buttons nebeneinander an. Eine ausführliche Beschreibung dieses Konzepts finden Sie im Kapitel 3.3 (Geometriemanagement), dass Sie unbedingt lesen sollten.

1.2 Grundlegende Begriffe

Hier sind einige der grundlegenden Begriffe erklärt, die im Handbuch immer wieder vorkommen. Sie müssen diese Begriffe jetzt weder vollständig verstehen noch auswendig lernen. Aber sie können dieses Kapitel zum Nachschlagen benutzen.

Objektorientierte Programmierung (OOP)
OOP ist eine Programmierphilosophie, bei der das Programm aus einzelnen Objekten besteht. Die Objekte verfügen über eine gewisse 'Eigenintelligenz' (Eigenschaften und Fähigkeiten), mit denen die Programmfunktionalität realisiert wird. Zu diesem Zweck tauschen die Objekte Botschaften (Messages) aus und reagieren auf Ereignisse (Events). Unter GEOS sind die meisten Objekte sichtbar, wie z.B. Buttons oder Textobjekte. Es gibt aber auch unsichtbare Objekte, wie z.B. das Application-Objekt (vgl. Kapitel 1.1).

Klassen
Jedes Objekt hat eine bestimmten 'Typ' der in der OOP als Klasse bezeichnet wird. Die Klassendefinition legt fest, welche Eigenschaften und Fähigkeiten die Objekte dieser Klasse haben.

Objekte
Objekte sind konkrete Manifestationen einer Klasse. Welche Eigenschaften und Fähigkeiten ein bestimmtes Objekt hat, wird durch seine Klasse bestimmt. Fachlich korrekt spricht man davon, dass ein bestimmtes Objekt eine Instanz einer bestimmten Klasse ist. Beispielsweise ist der Schalter 'Schließen' in einer Dialogbox eine Instanz der Klasse 'Button'. Es hat sich jedoch eingebürgert vereinfachend zu sagen: Der 'Schließen' Schalter ist ein Button-Objekt.

Window-Objekte
Als Window-Objekte werden alle Objekte bezeichnet, die ein unabhängiges Fenster (Window) auf dem Bildschirm erzeugen. Dazu gehören z.B. Dialogboxen und auch das Hauptfenster des Programms. Diese Fenster sind oft verschieblich und größenveränderlich.

Instance-Variablen
Jedes Objekt muss einen bestimmten Satz an Daten speichern, um korrekt arbeiten zu können. Beispielsweise muss jedes Objekt seine eigene Größe und Position kennen, um sich selbst korrekt darzustellen. Welche Daten das konkret sind, wird von der Klasse des Objekts bestimmt, die Datenwerte selbst sind jedoch für jedes Objekt, d.h. für jede Instanz einer Klasse, verschieden. Die von einem konkreten Objekt verwalteten Daten werden deshalb als Instance-Variablen (englisch für Instanz-Variablen) bezeichnet.

Hints
Hints (engl. Hilfen) sind eine besondere Art von Instance Variablen. Hints werden nur im Objekt gespeichert, wenn Sie explizit angegeben werden. Andernfalls sind sie einfach nicht vorhanden. Das spart eine Menge Platz. Fast alle Instance-Variablen zum Geometrie-Management sind als Hints implementiert. Wie der Name schon sagt sind Hints keine Befehle, sondern Hilfen. Es steht einem Objekt frei, wie es die Hints konkret umsetzt. Dazu gehört auch, dass es Hints ignorieren kann, wenn das angebracht ist.

Ereignisse (Events)
Betätigt der Nutzer eine Taste auf der Tastatur, bewegt er die Maus oder drückt eine Maustaste, so spricht man von einem 'Ereignis'. Ereignisse können auch der Start eines Programms oder vieles andere sein. GEOS registriert dieses Ereignis und sendet eine Message (Botschaft) an die für das entsprechende Ereignis zuständigen Objekte. Die Objekte können dann angemessen reagieren.

Ereignisorientierte Programmierung
Dieser Begriff beschreibt, dass ein GEOS-Programm nur dann etwas tut, wenn ein Ereignis auftritt. Dieses Verfahren ist viel effizienter als z.B. in einer Schleife ständig die Tastatur abzufragen. OOP und ereignisorientierte Programmierung gehen daher Hand in Hand.

Botschaften (Messages)
Die Informationen, die Objekte untereinander austauschen werden als Messages oder auf Deutsch als Botschaften bezeichnet. Botschaften sind eines der Kernkonzepte in der objektorientierten Programmierung.

Methoden
Die Routine, die ausgeführt wird, wenn ein Objekt eine Message erhält, wird als 'Methode' bezeichnet. Die meisten Methoden sind R-BASIC-intern, d.h. sie sind für den R-BASIC Programmierer nicht direkt zugänglich, sondern werden automatisch ausgeführt. Es gibt davon jedoch Ausnahmen. Wenn Sie z.B. wollen, das eine Dialogbox auf dem Bildschirm erscheint, dann müssen Sie der Dialog-Objekt eine Message senden, die keine Instance-Variable setzt, sondern die Dialogbox auf den Schirm bringt. In diesem Beispiel müssen Sie schreiben
  MyDialog.Open
wobei 'Open' die Methode ist, die das Objekt namens 'MyDialog' auszuführen hat, damit es auf dem Bildschirm erscheint.

Action-Handler
R-BASIC realisiert die OOP-Konzepte konzeptionell über Action-Handler. Registriert ein Objekt ein Ereignis, z.B. das Anklicken eines Buttons, so sendet es eine Message an den R-BASIC-Kern. Sie enthält die Information, welche Programm-Routine ausgeführt werden soll. Diese Programm-Routine wird als ActionHandler bezeichnet, da sie eine Aktion des Users behandelt. Der R-BASIC Kern führt den Handler (der in R-BASIC-Code geschrieben ist) aus und geht dann wieder auf 'Stand-by' bis das nächste Ereignis eintritt.

ActionHandler können auch Botschaften an andere Objekte aussenden oder Methoden ausführen. Beispielsweise wird die Anweisung
  EndeButton.enabled = FALSE
über eine Message an den EndeButton realisiert. Der Button disabled sich daraufhin. Die gesamte Programmfunktionalität eines BASIC-Programms steckt also in den verschiedenen ActionHandlern.

Objekt-Tree, Parents und Children
Objekte sind unter GEOS in sogenannten Bäumen (Trees) organisiert. Jedes Objekt hat genau ein Parent (Eltern) und kann kein, ein oder mehrere Children (Kinder) haben. Der Objekttree eines Programms dient sowohl der Kommunikation der Objekte untereinander (was in R-BASIC meist intern stattfindet) als auch der Organisation der Objekte auf dem Bildschirm. Details dazu finden Sie im Anschnitt 2.1 (Arbeit mit Objekt Bäumen).

Vererbung
Der Begriff beschreibt, dass die Objektklassen voneinander abstammen. Eine neue Klasse wird von einer Vorgängerklasse abgeleitet. Dabei 'erbt' die neue Objektklasse die Eigenschaften und Fähigkeiten seiner Vorgängerklasse. Hinzu kommen neue Eigenschaften und Fähigkeiten, die der Vorgänger nicht hat. Ein Beispiel: Die meisten R-BASIC-Objekte können mit einer Aufschrift (Caption$) versehen werden. Bei Primary-Objekten erscheint sie in der Titelzeile, bei Buttons ist es 'die' Aufschrift. Es macht nun keinen Sinn, diese Fähigkeit für jede Objektklasse von Grund auf neu zu implementieren, sondern sie ist in einer Klasse implementiert, die im GEOS SDK als 'GenericClass' bezeichnet wird und von der die allermeisten R-BASIC-Objekte abstammen.

Folgen:
In der GenericClass ist z.B. auch das Geometrie-Management implementiert, so dass bei allen von der GenericClass abstammenden R-BASIC-Objekten das Geometrie-Management über die gleichen Befehle abgewickelt wird. Das gilt auch für viele weitere grundlegende Fähigkeiten von R-BASIC-Objekten. Das Handbuch ist deshalb so organisiert, dass die allen Objektklassen gemeinsamen Eigenschaften in separaten Kapiteln beschrieben werden. In den Kapiteln über die konkreten Klassen werden dann nur eventuelle Abweichungen ('überschriebene' Eigenschaften) und die neu hinzugekommenen Fähigkeiten, Eigenschaften und Instance-Variablen beschrieben.

^

1.3 Vereinbarungen für dieses Handbuch

numWert	Ein numerischer Wert allgemein z.B. 12 oder -17.4 Alle grünen und nicht weiter gekennzeichneten Elemente bedeuten einen numerischen Wert. Darunter sind z.B.:
x, y, sizeX, sizeY	Positions- oder Größenangaben,
n	eine Anzahl oder eine Position.
index	Der mögliche Wertebereich eines Index beginnt immer bei Null. Im BASIC-Code kann anstelle einer Zahl auch immer ein numerischer Ausdruck (Variablen, Funktionen..) stehen.
"Text"	Die Anführungszeichen ".." kennzeichnen eine beliebige String-Konstante, z.B. "Ja, ich will" Im BASIC-Code kann anstelle eines expliziten Textes auch immer ein String-Ausdruck (Variablen, Funktionen..) stehen.
[ .. ]	Eckige Klammern kennzeichnen ein optionales Element, d.h. das Element kann angegeben werden, muss aber nicht vorhanden sein.
x | y	Eine Alternative wird durch einen senkrechten Strich gekennzeichnet. Z.B. visible = TRUE | FALSE bedeutet, dass visible = TRUE oder visible = FALSE möglich ist.
TRUE	R-BASIC Konstante mit dem Wert -1 Wird verwendet, wenn eine Eigenschaft 'erfüllt' oder 'wahr' ist. z.B. <obj>.visible = TRUE gibt an, dass das Objekt sichtbar ist.
FALSE	R-BASIC Konstante mit dem Wert 0 Wird verwendet, wenn eine Eigenschaft 'nicht erfüllt' oder 'falsch' ist. z.B. <obj>.enabled = FASLE gibt an, dass der Nutzer nicht mit dem Objekt interagieren kann (es wird i.a. 'grau' dargestellt).
My.., Demo.., Test..	Zeigen an, dass das entsprechende Element (Objekt, Routine, ActionHandler usw.) von Programmierer selbst definiert wurde, d.h. nicht aus R-BASIC stammt.
<objVar>	Objekt-Variable Variable vom Typ OBJECT, z.B. DIM ov as OBJECT
<obj>, <obj2>>	Referenz auf ein Objekt: namentlich aufgeführtes Objekt oder Objekt-Variable. Felder und Struktur-Elemente vom Typ OBJECT sind erlaubt. In diesem Handbuch bezeichnen wir das als 'Objekt Referenz'.
<objektListe>	Liste von namentlich aufgeführten Objekten
<numVar>	Numerische Variable (Real, Word, Integer usw.) auch z.B. <pos>, <index>, <breite>, usw.
<numExpr>	Numerischer Ausdruck
<stringVar>	String-Variable auch z.B. <name$>, <path$>, usw.
<stringExpr>	String Ausdruck
<handleVar>	Handle-Variable auch z.B. <han>, <gsHan>, usw.
<handleExpr>	Handle Ausdruck
<structVar>	Struktur-Variable
<structExpr>	Struktur Ausdruck
<Handler>	Der Name eines Action-Handlers

Sicher erkennen Sie das System dahinter, so dass Sie auch Elemente, die hier nicht explizit aufgeführt sind, zuordnen können.

Instancevariablen werden häufig in einer Tabelle dargestellt.

Beispiel:

Variable	Syntax im UI-Code	Im BASIC-Code
Children	Children = <objektListe>	nur lesen
numChildren	--	nur lesen
parent	--	lesen, schreiben

Dabei bedeuten:

Variable:	Name der Instancevariablen
Syntax im UI-Code:	Belegung der Instancevariablen im UI-Code Fenster Die so festgelegten Werte stehen beim Programmstart sofort zur Verfügung.
Im BASIC Code:	Beschreibt, ob und wie man die Instancevariable vom BASIC Code aus (d.h. zur Laufzeit des Programms) ansprechen kann. Die Syntax dafür ist für alle Instancevariablen gleich und wird weiter unten, im Abschnitt 'Syntax für Objektzugriffe', beschrieben. Eventuelle Ausnahmen sind bei den entsprechenden Instancevariablen selbst beschrieben.
--	Ein Strich bedeutet, dass die Variable hier nicht verwendet werden kann.

^

1.4 Syntax für Objektzugriffe

Vereinbaren von Objekten

Objekte müssen im Fenster 'UI-Objekte' vereinbart werden. Die Vereinbarung beginnt der Objekt-Klasse, gefolgt vom (frei wählbaren) Namen des Objekts. Dann folgen die Instance-Werte für dieses Objekt. Die Anweisung 'END OBJECT' beendet die Objekt-Vereinbarung.

Zugriff auf Objekte

Objektzugriffe erfolgen entweder mit ihrem Namen oder über eine Objekt-Variable (Variable vom Typ OBJECT). Zur Vereinfachung bezeichnen wir die beiden Möglichkeiten als 'Objekt-Referenz'.

Lesen von Instance-Variablen im BASIC-Code

Auf Instance-Variablen wird mit einer Objekt-Referenz (namentlich aufgeführte Objekte oder Objekt-Variablen, siehe oben), gefolgt von einem Punkt und dem Namen der Instance-Variablen, zugegriffen.

MyPrimary.Children(0).Caption$

Schreiben in Instance-Variablen im BASIC-Code

Wie beim Lesen werden die Instance-Variablen auch beim Schreiben durch einen Punkt von der Objekt-Referenz getrennt. Das Objekt kann auch hier namentlich aufgeführt oder über eine Objekt-Variable referenziert werden. Die Syntax beim Schreiben in Instance-Variablen entspricht ansonsten genau derjenigen im UI-Code, Berechnungen mit Variablen und Funktionen sind im Gegensatz zum UI-Code aber zulässig.

1.5 Vereinbarung von Action-Handlern

Action-Handler sind spezielle Unterprogramme, die aufgerufen werden, wenn ein Ereignis eintritt, z.B. ein Button gedrückt oder mit der Maus geklickt wird.

Der Typ
Jeder Typ von Ereignissen erfordert auch einen speziellen Typ von Action-Handlern: Das Drücken eines Buttons z.B. ButtonAction, ein Mausereignis wird von einem Handler des Typs MouseAction behandelt.

Parameter
Jeder Typ von Action-Handlern hat einen eigenen Satz an Parametern. Allen gemeinsam ist der erste Parameter 'sender' vom Typ OBJECT. Er enthält eine Referenz auf das Objekt, dass das Ereignis ausgelöst hat. Dann folgen bis zu drei numerische Parameter, deren Bezeichnung und Bedeutung vom Typ des Handlers abhängt.

Vereinbarung des Handlers
Ein Handler wird vereinbart indem der Typ des Handlers, gefolgt von einem (frei wählbaren) Namen, angegeben wird. Die Parameter des Action-Handlers werden beim Vereinbaren des Handlers nicht explizit angegeben. Die Anweisung END ACTION schließt den Handler ab.

Tipp: Verwenden Sie den Menüpunkt 'Extras'-'Code Bausteine'-'Action-Handler'. Damit erhalten Sie neben dem Handler-Rumpf einen Kommentarblock mit allen Parametern des Handlers. Da Actionhandler spezielle Unterprogramme sind gelten die gleichen Regeln wie bei SUB's und FUNCTION's, d.h. es können z.B. lokale Variablen definiert, andere SUB's oder FUNCTION's gerufen oder Operationen mit Objekten durchgeführt werden. Andere ActionHandler können jedoch nicht direkt aufgerufen werden.