Referenzliste Dialog Library -blättern-Referenzliste Window Library

Inhalt | Start

Die Window Library

4. Die Window Library
4.1
4.2
4.3
4.4
4.5
4.6
4.7
4.8
4.9
4.10
4.11
4.12
4.13
4.14
4.15
Das Konzept des virtuellen Bildschirms
Das Prinzip der Fenster-Programmierung mit EasyGem
Maßangaben bei Fenstern
Grafikfenster
Fenstermaße einstellen und abfragen
Die Reihenfolge von Fenstern
Die Abfrage der Maus in Fenstern
Textfenster
Textattribute setzen und abfragen
Eingaben in Textfenstern
Userfenster
Gummiband-Befehle für Grafik- und Userfenster
Blöcke in Fenstern
Befehle für das Standard-Menü
Apple-Events
Referenzliste Window Library


Jeder Besitzer eines Apple-Computers kennt die Vorteile an Bedienerfreundlichkeit, die die Fenstertechnik dem Benutzer bietet. Leider sind Fenster normalerweise nicht gerade leicht zu programmieren. Der ambitionierte Programmierer muß sich durch einen Dschungel von Betriebssystemaufrufen kämpfen, um auch nur einfache Dinge zu erreichen. Der Kern des Problems besteht darin, daß die Fensterbefehle des Mac OS jeder für sich relativ wenig können. Erst das komplexe Zusammenwirken mehrerer Befehle ermöglicht die Verwaltung von Fenstern. EasyGem stellt nun Befehle auf einem höheren Niveau zur Verfügung, die den Erfordernissen von Anwendungsprogrammen eher gerecht werden. Hier ein Überblick über diejenigen Prozeduren und Funktionen von EasyGem, die sich mit der Fenstertechnik beschäftigen.

Vollautomatisch verwaltete Textfenster beliebiger Größe.
Vollautomatisch verwaltete Grafikfenster beliebiger Größe.
Halbautomatisch verwaltete Userfenster auf virtuellen Bildschirmen.
Leichtes Setzen und Abfragen der Fenstermaße.
Alle Omikron Basic Zeichen-Befehle lassen sich in beliebige Fenster umleiten.
Befehle zum Markieren und Verwalten von Blöcken.
Unterstützung des Clipboards (Ausschneiden, Kopieren, Einfügen).
Befehle zum Laden und Speichern von Dokumenten
Befehle zum Drucken von Dokumenten.

In jedem Fenster kann ein individueller Block definiert werden.
Auswertung von Apple-Events.





4.1 Das Konzept des virtuellen Bildschirms

Überlegen wir uns einmal, wozu die Fenstertechnik überhaupt erfunden wurde. Man stand vor dem Problem, daß man mehr Informationen darstellen wollte, als auf einem Bildschirm Platz finden. Eigentlich wird in einer solchen Situation ein größerer Bildschirm nötig oder man muß die Ausgabe auf mehrere Bildschirme verteilen. Beides ist teuer und hat natürliche Grenzen. Darum wurden die virtuellen Bildschirme erfunden. Diese sind in der Praxis nichts anderes als reservierte Speicherbereiche, in denen die Informationen ähnlich verwaltet werden, wie im Bildschirmspeicher des realen Bildschirms.
Da man virtuelle Bildschirme aber leider nicht sehen kann, benötigt man Fenster, durch die zumindest ein Ausschnitt des zugehörigen virtuellen Bildschirms sichtbar ist. Und genau das ist das Konzept für die Fenster Library. Man betrachtet Fenster als Hilfsmittel zur Darstellung von virtuellen Bildschirmen. Vielleicht hilft die Vorstellung von einem rechteckigen Loch (dem Fenster), das man in schwarzen Pappkarton hineinschneidet und dann auf eine Buchseite legt, die größer als das Loch ist. Nun kann man zwar nie die ganze Buchseite auf einmal lesen, kann aber durch Verschieben der Pappe einen anderen Teil der Buchseite sichtbar machen. Im Computer hat man dann beliebig viele solche Pappen, durch die man dann sozusagen auf verschiedene Buchseiten blicken kann.

Für die verschiedenen Anwendungen dieses Konzepts verwaltet die Fenster Library drei verschiedene Typen von virtuellen Bildschirmen.

Grafikbildschirme Die Information wird pixelweise gespeichert.
Textbildschirme Die Information wird Zeichenweise gespeichert.
Userbildschirme Die Datenstruktur von Userbildschirmen können Sie selbst festlegen. Die Fensterbibliothek unterstützt Sie lediglich bei der Bildschirmdarstellung und übernimmt die Verwaltung des Randbereichs.





4.2 Das Prinzip der Fenster-Programmierung mit EasyGem

Die Fenster-Programmierung mit EasyGem bedeutet für Sie vor allem, daß Sie die meisten Dinge nicht selbst programmieren müssen. Eigentlich braucht Ihr Programm gar nichts zu tun, als abzuwarten und immer wieder zu fragen, was der Benutzer gerade auf dem Bildschirm macht. Die Entscheidung, welche Aktionen des Benutzers wichtig sind und was dieser eigentlich gemacht hat, übernimmt EasyGem automatisch. Wenn irgendetwas passiert ist, was für Ihr Programm wichtig ist, meldet EasyGem das über
Easy_Mesag. Dann muß Ihr Programm die Meldung auswerten und entsprechend reagieren. In den meisten Fällen können Sie die nötigen Aktionen jedoch wiederum von EasyGem automatisch mit Win_Domessages erledigen lassen. Allerdings muß Ihr Programm z.B. auf Menü-Aktionen des Benutzers selber reagieren, wie es im Menüteil schon beschrieben wurde.

Ein einfaches Fenster-Programm ohne Menü sieht damit wie folgt aus:

COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init
Gwin_Open Win1,0,21,200,160,320,200,"Fenster 1"
REPEAT
 Easy_Mesag Entry,Buffer$
 Win_Domessages Buffer$
UNTIL FN Win_Closed(Win1)
Easy_Exit
END

Dieses kleine Programm öffnet ein Fenster und ruft dann immer wieder die Befehle Easy_Mesag und Win_Domessages auf. Während dieser Zeit ist auf dem Bildschirm das Fenster und eine Maus zu sehen, und der Benutzer des Programms kann die Maus bewegen und überall hinklicken. Sobald er irgendetwas wichtiges tut, also irgendein Bedienelement des Fensters anklickt, meldet Easy_Mesag statt "nichts Neues..." die entsprechend kodierte Meldung. Die Prozedur Win_Domessages führt daraufhin die Veränderung sofort aus.
Wie Sie sehen, braucht sich Ihr Programm um nichts selbst zu kümmern. Die Überwachung der Maus (ob das Fenster, die Schiebebalken, die Scollpfeile oder andere Bedienelemente angeglickt wurden) übernimmt EasyGem automatisch.


Achtung: Einige Befehle der Fenster Library können das Betriebssystem veranlassen, von sich aus eine Meldung (Message) zu schicken (z.B. Win_Open, Win_Reopen, Win_Setview, Win_Setborder, Win_Top, Win_Setsize, Win_Setwork oder Win_Full). Darum müssen Easy_Mesag und Win_Domessages in einer Schleife regelmäßig aufgerufen werden, so wie im obigen Beispielprogramm.
Den Befehl
Easy_Mesag kennen Sie ja bereits von der Menü-Programmierung. Damit Sie jetzt auch Informationen über Fensteraktionen erhalten, bekommt Easy_Mesag eine zweite Variable, die Sie dann nur noch Win_Domessages zu übergeben brauchen.Der Befehl zum Abholen von Ereignissen (Events) sieht also wie folgt aus:

    

Easy_Mesag R Entry[,R Buffer$]
Meldungen des Betriebssystems abholen.

Entry ist die Variable, die Sie von den Menüs her bereits kennen. In ihr wird mitgeteilt, ob ein Menü-Eintrag ausgewählt wurde. Im Zusammenhang mit Fenstern ist sie weniger interessant. Dafür ist nur Buffer$ wichtig.
Easy_Mesag wartet nicht, bis der Benutzer irgendetwas gemacht hat, sondern kehrt sofort zurück und meldet im Zweifelsfall "Am Bildschirm nichts Neues" an Win_Domessages.

Hinweis: Wer jetzt zusätzlich noch auf Mausklicks im Fenster reagieren will, der benötigt ein nochmals erweitertes Easy_Mesag wie bei Win_Mousepos beschrieben.
Für Profis: Buffer$ ist übrigens genau der 16 Byte lange Event-String des Mac OS, der von 'WaitNextEvent' zurückgegeben wird. Sie können Buffer$ also auch direkt "von Hand" auswerten oder, viel einfacher, den String einfach der Prozedur Win_Domessages übergeben:


Win_Domessages Buffer$[,Closeaction]
Betriebssystemmeldung bearbeiten.

Buffer$ ist dabei der bereits erwähnte, von Easy_Mesag zurückgegebene String. Closeaction enthält die Adresse einer Funktion, die beim Schließen eines Fensters automatisch aufgerufen wird. Diese Funktion können Sie selbst definieren. Sie könnte z.B. zunächst eine Sicherheitsabfrage durchführen , bevor das Fenster geschlossen wird, aber dazu später mehr.

Achtung: Im Unterschied zu älteren EasyGem Versionen muß in Closeaction die Adresse einer Funktion und nicht das Label eines Unterprogramms übergeben werden. 

Hinweis: Verwenden Sie am besten die weiter unten besprochene Prozedur Win_Closeaction, um eine geeignete Action-Funktion zu definieren. Dann können Sie Win_Domessages mit einem Parameter verwenden.



4.3 Maßangaben bei Fenstern

Bevor wir jetzt tiefer in die Materie einsteigen, wollen wir erstmal einige grundlegende Begriffe klar definieren, um spätere Verwirrungen zu vermeiden.

Wir unterscheiden:
Außenmaße des Fensters (border area)
Innenmaße des Fensters (work area)
Gesamtmaße des virtuellen Bildschirms (virtual area)
Sichtausschnitt des virtuellen Bildschirms (view area)
Solche Maße gibt man normalerweise mit vier Zahlen an: Abstand vom linken Rand (X-Position), Abstand vom oberen Rand (Y-Position), Breite (W=Width) und Höhe (H=Height).

(Falls hier kein Bild erscheint, bitte in den Rahmen klicken.)





Der Sichtausschnitt wird immer innen im Fenster dargestellt. Die Breite und Höhe des Sichtausschnitts und des Arbeitsbereichs sind also immer gleich. Die X- und Y-Positionen sind aber verschieden.
Um die verschiedenen Fenstermaße sauber auseinanderhalten zu können, werden die Koordinaten in diesem Handbuch wie folgt bezeichnet:

Border_X,Border_Y,Border_W,Border_H Außenmaße Fenster.
Work_X,Work_Y,Work_W,Work_H Innenmaße Fenster.
Virt_X,Virt_Y,Virt_W,Virt_H Virtueller Bildschirm.
View_X,View_Y,View_W,View_H Sichtausschnitt.

Die genaue Bedeutung der verschiedenen Begriffe entnehmen Sie bitte der Abbildung.



4.4 Grafikfenster


Da Grafikfenster den Ihnen bereits bekannten Omikron Basic Ausgabefenstern sehr ähnlich sind, aber wesentlich mehr Möglichkeiten bieten, wollen wir mit der Beschreibung der Grafikfenster beginnen. Der Befehl zum Öffnen von Grafikfenstern lautet:


Gwin_Open R Win,Win_X,Win_Y,Win_W,Win_H
[,Virt_W,Virt_H],Name$
Gwin_Open R Win,Win_X,Win_Y,Win_W,Win_H,
Virt_W,Virt_H,Name$,Info$[,Kind]
Grafikfenster öffnen.

Gwin_Open bringt ein Fenster auf den Bildschirm, das einen Ausschnitt aus einem virtuellen Grafikbildschirm zeigt. Dazu wird Speicher im Application-Heap Ihres Programmes reserviert. Sie müssen also gegebenenfalls mit COMPILER "MIN_SIZE X" dafür sorgen, daß der Application-Heap groß genug angelegt wird. Dieser Speicherbereich wird dann für den virtuellen Grafikbildschirm verwendet. Mit Gwin_Activate kann man dann sämtliche Ausgabebefehle von Omikron Basic auf den virtuellen Bildschirm umleiten. Die Fenster Library sorgt dafür, daß immer der richtige Ausschnitt aus dem virtuellen Bildschirm im Fenster dargestellt wird.
Die Parameter haben im einzelnen folgende Bedeutung:

Win Win ist die Identifikationsnummer des neuen Fensters. Diese Nummer muß man bei jedem Befehl angeben, der das Fenster ansprechen soll. Deshalb ist es auch nicht erlaubt, ein Fenster anzusprechen, das noch gar nicht geöffnet wurde.
Win_X,
Win_Y
Position des linken oberen Eckpunkts des Fensters auf dem realen Bildschirm, also die Außenmaße.
Win_W,
Win_H
Breite und Höhe des Fensters in Außenmaßen. Hier haben Sie die Möglichkeit, auch negative Zahlen anzugeben. Dann nimmt EasyGem den Absolutbetrag und interpretiert die Zahlen als Innenmaße (Arbeitsbereich).
Virt_W,
Virt_H
Breite und Höhe des virtuellen Bildschirms. Wenn Virt_W und Virt_H weggelassen werden, so gilt Virt_W=Work_W und Virt_H=Work_H. Der virtuelle Bildschirm kann beliebig groß werden, sofern genug Speicher im Application-Heap vorhanden ist. Sollten Sie bei Gwin_Open eine Fehlermeldung erhalten, so liegt es meist daran, daß nicht genug Speicher vorhanden ist.
Name$ Der Name des Fensters, der im Verschiebebalken angezeigt wird.
Info$ Unterhalb des Fensternamens kann noch eine Informationszeile dargestellt werden, die automatisch von EasyGem verwaltet wird. Den Inhalt dieser Zeile bestimmt Info$.
Kind In Kind steht jedes der unteren 12 Bits für jeweils eins der Elemente, aus denen der Randbereich aufgebaut wird. Wenn Kind=0 ist, so wird nur ein dünner Rahmen um das Fenster gezeichnet. Jedes gesetzte Bit fügt dann ein weiteres Randelement hinzu. Damit man sich nicht merken muß, welches Bit für welches Randelement steht, hat jedes Bit einen symbolischen Namen. Man kann die einzelnen Elemente dann einfach aufaddieren.
Mit den Bits 14 bis 17 können Sie weitere Eigenschaften des Fensters einstellen:
. G_Name Der Name des Fensters wird angezeigt.
G_Close Das Fenster hat ein Schließfeld.
G_Full Das sogenannte Vollfeld ist ein Feld, mit dem das Fenster auf Maximalgröße gebracht werden kann.
G_Move Das Fenster läßt sich verschieben.
G_Info Das Fenster hat eine Informationszeile.
G_Size Die Größe des Fensters ist veränderbar.
G_Uparrow Scrollpfeil nach oben darstellen.
G_Dnarrow Scrollpfeil nach unten darstellen.
G_Larrow Scrollpfeil nach links darstellen.
G_Rarrow Scrollpfeil nach rechts darstellen.
G_Vslide Der vertikale Schiebebalken wird dargestellt.
G_Hslide Der horizontale Schiebebalken wird dargestellt.
G_All Alle Randelemente mit Ausnahme der Informationszeile werden dargestellt.
G_Palette (Bit 14) Das Fenster bekommt die System-Farbpalette zugewiesen. Wenn Sie Ihren Computer auf 256 Farben oder weniger eingestellt haben, wird die Farbtabelle des Bildschirms automatisch angepaßt, sobald das Fenster getopt wird.
G_Hide
(Bit 15)
Das Fenster ist unsichtbar, kann aber mit Win_Reopen dargestellt werden.
G_Float
(Bit 16)
Das Fenster wird als sogenanntes Float-Window geöffnet. Dieser Fenstertyp liegt immer über den normalen Fenstern und hat kleinere Randelemente. Float-Windows eignen sich besonders zum Aufbau von Werkzeugkästen, da man die Werkzeuge immer griffbereit haben möchte, wenn man in einem Dokumentenfenster arbeitet.
Es sind immer nur die Float-Windows des gerade aktiven Programms sichtbar, alle anderen Float-Windows werden automatisch vom Bildschirm entfernt.

Die Float-Eigenschaft wird vom Mac OS erst ab System 8.6 unterstützt. Bei älteren Versionen wird zwar auch ein Float-Window dargestellt, das sich aber wie ein normales Dokumentfenster verhält.
G_Sidebar
(Bit 17)
Der Schiebebalken befindet sich an der linken Seite. Dieses Bit hat nur für Float-Fenster Gültigkeit.

Achtung: Wenn dieses Bit gesetzt ist, wird der Name des Fensters nicht angezeigt.
Um ein Fenster mit Bewegungsbalken, Name und Vollfeld zu definieren, gibt man also an: Kind=G_Name+G_Full+G_Move

Hinweis: Die Scrollpfeile und die Schiebebalken können nur jeweils zusammen oder gar nicht dargestellt werden. Sobald ein Bit gesetzt ist, werden die anderen Elemente mit angezeigt.


Wenn Kind weggelassen wird, so werden alle Elemente angezeigt.
Ausnahme: Wenn
Info$ weggelassen wird, so wird natürlich auch keine Informationszeile dargestellt.


Um nun unsere Ausgaben in das Grafikfenster zu bekommen, benötigen wir den Befehl:


Gwin_Activate Win   
Grafikfenster aktivieren.

Nach Aufruf von Gwin_Activate werden alle Befehle, die den Bildschirm ansprechen, auf den virtuellen Grafikbildschirm mit der Nummer Win umgelenkt. Bevor wir das an einem Beispiel erläutern, wollen wir zunächst noch zwei weitere Befehle vorstellen:


Gwin_Disactivate
Grafikfenster deaktivieren.

Gwin_Disactivate hebt die Wirkung von Gwin_Activate wieder auf, d.h. alle Zeichenbefehle sprechen danach wieder den normalen Bildschirm an. Bitte beachten Sie, daß sie keine Ausgaben auf dem normalen Bildschirm machen können, solange ein virtueller Grafikbildschirm aktiviert ist.

Wichtig: Einige EasyGem Befehle heben die Wirkung von Gwin_Activate auf, so daß Sie diese Prozedur immer unmittelbar vor der eigentlichen Ausgabe aufrufen sollten.

Unsere Analogie, bei der wir Fenster mit rechteckigen Ausschnitten in schwarzem Karton verglichen haben, stimmt an einigen Stellen nicht genau. Durch unseren Karton sehen wir den Teil des Buchs, der gerade nicht verdeckt wird, unmittelbar. Da wir jedoch kein gescheites Buch, sondern nur einen dummen Computer vor uns haben, muß dieser den Sichtausschnitt nach einer Änderung des virtuellen Bildschirms wieder in das Fenster hineinübertragen. Diesen Vorgang bezeichnet man als Aktualisierung und der EasyGem Befehl dafür heißt:


Win_Redraw Win[,X,Y,W,H]
Fensterinhalt aktualisieren.


Win_Redraw kopiert den Sichtausschnitt des virtuellen Bildschirms in das reale Fenster hinein, aktualisiert also den Fensterinhalt.
Die Koordinaten
X,Y,W,H sind die virtuellen Bildschirmkoordinaten des Ausschnitts, der aktualisiert werden soll. Dieser Ausschnitt kann auch über das Fenster hinausragen. Normalerweise gibt man keinen Ausschnitt an, da meistens das ganze Fenster aktualisiert werden muß.
Vielleicht ist Ihnen aufgefallen, daß dieser Befehl nicht
Gwin_Redraw, sondern nur Win_Redraw heißt. Das liegt daran, daß Win_Redraw alle Fensterarten, und nicht nur Grafikfenster, aktualisiert. Diese Terminologie behalten wir auch in Zukunft bei. Immer, wenn ein Befehl auf alle Fensterarten angewendet werden kann, beginnt er mit "Win".


Der prinzipielle Weg, mit einem Grafikfenster zu arbeiten, ist also wie folgt:

1. Grafikfenster mit Gwin_Open öffnen.
2. Ausgabe auf dieses Grafikfenster mit
Gwin_Activate umlenken.
3. Alle Bildschirmausgaben wie gewohnt mit Grafikbefehlen oder
PRINT machen.
4. Ausgabe mit
Gwin_Disactivate wieder auf den normalen Bildschirm umlenken.
5. Grafikfenster mit
Win_Redraw aktualisieren.




Beispiel:
COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init:'EasyGem anmelden.
'Grafikfenster öffnen.
Gwin_Open Win1,0,21,200,160,320,200,"Grafikfenster","Info"
Gwin_Activate Win1:'Ausgabe umleiten.
FOR R=10 TO 99 STEP 10
 CIRCLE 160,100,R:'Grafik zeichnen.
NEXT R
Gwin_Disactivate:'Ausgabe auf normal.
Win_Redraw Win1:'Fenster neu zeichnen.
REPEAT
 Easy_Mesag Entry,Buffer$
 Win_Domessages Buffer$
UNTIL FN Win_Closed(Win1)
Easy_Exit:'EasyGem abmelden.
END


Oft soll ein Fenster schon vor dem Programmende vom Bildschirm verschwinden. Dafür gibt es den Befehl:


Win_Close Win    
Fenster schließen.

Man muß aber beachten, daß es danach wirklich gelöscht ist. Wenn das gleiche Fenster später wieder geöffnet werden soll, ist es besser, den Befehl Win_Hide zu verwenden:


Win_Hide Win    
Fenster unsichtbar machen.

Mit Win_Hide kann man ein Fenster vom Bildschirm entfernen. Im Gegensatz zu Win_Close bleibt der virtuelle Bildschirm aber im Speicher. Deshalb kann das Fenster jederzeit wieder sichtbar gemacht werden und zwar mit dem Befehl:


Win_Reopen Win[,Win_X,Win_Y,Win_W,Win_H]
Fenster wieder öffnen.

Win_Reopen bringt ein mit Win_Hide gelöschtes Fenster wieder auf den Bildschirm. Die Parameter Win_X,Win_Y,Win_W,Win_H entsprechen denen bei Gwin_Open. Sie können damit also gleich die Größe vorgeben, in der das Fenster erneut geöffnet werden soll.



4.5 Fenstermaße einstellen und abfragen

Weil ein Fenster nichts anderes darstellt als ein Guckloch auf einen Bildschirm, der nicht selber dargestellt wird, ist es wichtig, die Position des Gucklochs verändern zu können. Normalerweise macht EasyGem das von alleine, zum Beispiel, wenn der Benutzer den Schiebebalken oder die Verschiebepfeile anklickt. Aber in manchen Fällen könnte es sein, daß Sie von Ihrem Programm aus, z.B. auf Tastendruck, das Guckloch verschieben wollen, um einen anderen Bereich des virtuellen Bildschirms darzustellen. Oder Sie wollen das Fenster auf die linke Seite des Bildschirms bringen, um ein weiteres zu öffnen etc.
In EasyGem gibt es für diese Aufgaben eine ganze Reihe von Befehlen, die alle mit "
Win" anfangen, da sie für beliebige Typen von Fenstern gelten:


Win_Setborder Win,Border_X,Border_Y,Border_W,Border_H
Win_Setwork Win,Work_X,Work_Y,Work_W,Work_H
Win_Setview Win,View_X,View_Y,View_W,View_H
Win_Setvirt Win,Virt_X,Virt_Y,Virt_W,Virt_H

Mit Hilfe dieser vier Prozeduren lassen sich alle Maße der Fenster einstellen. Die Begriffe Border, Work, View und Virt wurden ja bereits erklärt. Alle vier Prozeduren gibt es in drei Syntaxformen, die hier für Win_Setborder stellvertretend angegeben sind:


Win_Setborder Win,Border_X,Border_Y
Nur verschieben.
Win_Setborder Win,0,Border_W,Border_H
Nur Größe einstellen.
Win_Setborder Win,Border_X,Border_Y,Border_W,Border_H
Alle Maße festlegen.

Natürlich gibt es auch die entsprechenden Prozeduren, um die momentane Einstellung abzufragen:


Win_Getborder Win,R Border_X,R Border_Y,R Border_W,R Border_H
Win_Getwork Win,R Work_X,R Work_Y,R Work_W,R Work_H
Win_Getview Win,R View_X,R View_Y,R View_W,R View_H
Win_Getvirt Win,R Virt_X,R Virt_Y,R Virt_W,R Virt_H

Auch die Abfrage-Prozeduren gibt es in drei Syntaxformen:

Win_Getborder Win,R Border_X,R Border_Y
Nur Position abfragen.
Win_Getborder Win,0,R Border_W,R Border_H
Nur Größe abfragen.
Win_Getborder Win,R Border_X,R Border_Y,
R Border_W,R Border_H
Alle Maße abfragen.


Die Abfragefunktionen Win_Getborder und Win_Getwork funktionieren nicht nur für Fenster, sondern auch für den Desktop. Anstelle der Fensternummer übergibt man dafür einfach minus eins, also Win_Getborder -1,X,Y,W,H bzw. Win_Getwork -1,X,Y,W,H
Als Ergebnis erhält man dann den ganzen Bildschirm einschließlich der Menüzeile bzw. den Arbeitsbereich des Desktop (also ohne Menüzeile).

Hinweis: Ein Fenster, das mit Win_Hide gelöscht wurde, kann natürlich nicht mehr abgefragt werden.

Achtung: Bei Textfenstern werden für die Maße im virtuellen Bildschirm (View_X, View_Y, View_W, View_H, Virt_X, Virt_Y, Virt_W, Virt_H) keine Bildschirmpunkte, sondern Buchstabengrößen verwendet. Die Beschreibung von Textfenstern erfolgt weiter hinten.

Das folgende Programm demonstriert als Beispiel die Wirkung von
Win_Setborder:

COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init
DIM Win(2):'Zum Merken der Fensternummern.
FOR I=0 TO 2:'Fenster öffnen.
 Gwin_Open Win(I),0,21,-160,-100,160,100,"Fenster"+STR$(I)
NEXT I
Win_Getwork -1,X,Y,W,H:'Desktop-Größe ermitteln.
FOR I=2 TO 0 STEP -1:'Fenster untereinander anordnen.
 Win_Setborder Win(I),X,Y+(H\3)*I,W,H\3
NEXT I
REPEAT
 Easy_Mesag Entry,Buffer$
 Win_Domessages Buffer$
 W0=FN Win_Closed (Win(0))
 W1=FN Win_Closed (Win(1))
 W2=FN Win_Closed (Win(2))
UNTIL W0 AND W1 AND W2
'Warten, bis alle Fenster geschlossen wurden.
Easy_Exit:'EasyGem abmelden.
END

Wenn Sie ein Fenster auf Maximalgröße bringen wollen, können Sie das natürlich mit den zuvor besprochenen Befehlen tun, einfacher geht das aber mit:


Win_Full Win
Fenster auf Maximalgröße bringen.

Der Befehl hat die gleiche Wirkung wie das Anklicken des Vollfeldes (zweites Feld von rechts im Titelbalken). Win_Full setzt jedoch nicht die Fenstergröße auf den alten Wert zurück, falls das Fenster bereits Maximalgröße hatte.

Neben der Größe eines Fensters möchte man natürlich auch noch die anderen Attribute, wie z.B. die Texte in der Titel- und Infozeile, die Schrittweite beim Scrollen oder den Typ eines Fensters abfragen bzw. verändern können. Auch dafür stellt EasyGem eine ganze Reihe von Prozeduren und Funktionen zur Verfügung, die jetzt erklärt werden:


Win_Name Win,Name$ 
Namen des Fensters mit der Nummer Win ändern.
FN Win_Name$(Win)  
Namen des Fensters mit der Nummer Win abfragen.

Der Name des Fensters wird stets in der Kopfzeile dargestellt.


Win_Info Win,Info$ 
Informationszeile des Fensters mit der Nummer Win ändern.
FN Win_Info$(Win)
Informationszeile des Fensters mit der Nummer Win abfragen.

Achtung: Wenn das Fenster ohne Informationszeile geöffnet wurde, so kann auch nachträglich keine mehr angezeigt werden.


Win_Infoheight(Win,H)
Höhe der Informationszeile einstellen.
FN Win_Infoheight(Win)
Höhe der Informationszeile abfragen.

Wenn Sie selbst Ausgaben in die Infozeile machen wollen oder in der Infozeile freie Controls plazieren möchten, ist es im allgemeinen nötig, die Höhe der Infozeile anzupassen. Das können Sie individuell für jedes Fenster mit der Prozedur Win_Infoheight machen, wobei H die gewünschte Höhe angibt.
In einigen Fällen kann es nötig sein, daß man Ausgaben nicht in ein virtuelles Fenster machen möchte, sondern in ein reales Fenster auf dem Bildschirm. Dabei muß man bedenken, daß die Infozeile zwar von EasyGem verwaltet wird, aber dennoch zum Fensterinhalt gehört. Um die Infozeile in solchen Fällen nicht zu überschreiben, können Sie mit der Funktion
FN Win_Infoheight die Höhe der Infozeile ermitteln und diesen Wert dann als Offset zu den Y-Koordinaten in Ihren Zeichenbefehlen hinzuaddieren.


Win_Setstep Win,Step_X,Step_Y   
Scroll-Schrittweite ändern.

Wenn man die Scrollpfeile im Randbereich des Fensters anklickt, so scrollt der Arbeitsbereich bei Grafik- und Userfenstern um 8 Pixel und bei Textfenstern um 1 Zeichen. Diese Standardeinstellung kann man mit Win_Setstep ändern. Und zwar für X- und Y-Richtung getrennt.


Win_Getstep Win,R Step_X,R Step_Y 
Scroll-Schrittweite abfragen.

Dieser Befehl liefert in Step_X und Step_Y die aktuelle Einstellung der Scroll-Schrittweite für das Fenster mit der Nummer Win.


FN Win_Kind(Win)  
Aufbau des Randbereichs ermitteln.

Der Rückgabewert enthält die Flags, die beim Öffnen des Fensters in Kind übergeben wurden. Um beispielsweise festzustellen, ob ein Fenster ein Schließfeld hat, kann man schreiben:

IF FN Win_Kind(Win) AND G_Close THEN ...


FN Win_Type(Win)           
Typ des Fensters ermitteln.
Diese Funktion liefert als Ergebnis Informationen darüber, ob das Fenster mit der Nummer Win geschlossen ist, oder ob es sich um ein Text-, Grafik-, Userfenster oder um eine Dialogbox handelt. Der Funktionswert hat dabei folgende Bedeutung:

0 : Das Fenster ist geschlossen.
1 : Es handelt sich um ein Textfenster.
2 : Es handelt sich um ein Grafikfenster.
3 : Es handelt sich um ein Userfenster.
4 : Es handelt sich um eine nicht verschiebbare modale Dialogbox.
5 : Es handelt sich um eine verschiebbare modale Dialogbox.
6 : Es handelt sich um eine verschiebbare nichtmodale Dialogbox.


FN Win_Closed(Win)       
Stellt fest, ob das Fenster geschlossen wurde.

Diese Funktion können Sie anwenden, um festzustellen, ob ein Fenster gerade offen oder geschlossen ist. In Win übergeben Sie die Nummer des Fensters, dessen Zustand Sie abfragen wollen. Die Funktion gibt 0 zurück, wenn das Fenster geöffnet ist und -1, wenn das Fenster geschlossen ist oder nie geöffnet wurde.


FN Win_Visible(Win)       
Stellt fest, ob das Fenster sichtbar ist.

Wenn ein Fenster offen ist, bedeutet dies ja noch nicht, dass es gleichzeitig auch sichtbar ist. Zum Beispiel können Sie mit Win_Hide ein Fenster vom Bildschirm entfernen, ohne es zu schliessen. Um nun festzustellen, ob ein existierendes Fenster auch sichtbar ist, gibt es die Funktion FN Win_Visible. Die Funktion gibt -1 zurück, wenn das Fenster sichtbar ist und 0, wenn das Fenster nicht sichtbar ist.

FN Win_Collapsed(Win)       
Stellt fest, ob das Fenster eingeklappt wurde.

Diese Funktion können Sie anwenden, um festzustellen, ob ein Fenster eingeklappt wurde. In Win übergeben Sie die Nummer des Fensters, dessen Zustand Sie abfragen wollen. Die Funktion gibt 0 zurück, wenn das Fenster geöffnet ist und -1, wenn das Fenster eingeklappt wurde.

Win_Setflags Win,Flags 
Flags des Fensters mit der Nummer Win ändern.
FN Win_Getflags(Win)  
Flags des Fensters mit der Nummer Win abfragen.

Diese beiden Befehle dienen dazu, das Verhalten der Fenster Library zu beeinflussen. Zur Zeit sind die untersten 4 Bits belegt.

Bit 0 : Wenn Teile eines Userfensters neu gezeichnet werden müssen, füllt EasyGem diese Bereiche normalerweise zuerst mit der Hintergrundfarbe. Wenn Ihre eigene Redraw-Funktion aber ebenfalls die gesamte Fläche füllt, ist das vorherige Löschen überflüssig. Durch Setzen des untersten Bits mit dem Befehl
Win_Setflags Win,FN Win_Getflags(Win) OR %1 können Sie das Löschen unterdrücken.

Bit 1 : Hat die gleiche Funktion wie Bit 0, nur für die Infozeile. Das Setzen dieses Bits macht natürlich nur Sinn, wenn Sie eigene Ausgaben in die Infozeile machen.

Bit 2 : Wenn Sie auf die Scrollpfeile klicken, wird die Verschiebung des Fensterinhalts normalerweise dadurch realisiert, dass der Fensterausschnitt um die Scrollbreite auf dem Bildschirm verschoben wird und nur der entstehende ungültige Bereich neu gezeichnet wird. Wenn dieses Bit gesetzt ist, wird beim Scrollen der komplette Fensterinhalt neu gezeichnet, wodurch man bei Grafikfenstern und User-Fenstern, die über schnelle Redraw-Routinen verfügen, bessere Scrollergebnisse (weniger ruckelig), erhält.

Bit 3 : Hiermit wird das sogenannte Smartscrolling (der Fensterinhalt folgt den Bewegungen des Schiebers im Scrollbalken) unterdrückt. Das Smartscrolling steht erst ab Mac OS 8.5 zur Verfügung.

Von Win_Domessages kennen Sie ja bereits die Möglichkeit, eine eigene Action-Funktion zu definieren, die dann von EasyGem aufgerufen wird, sobald der Anwender ein Fenster schliessen will. Mit den folgenden Prozeduren können Sie auch noch für andere Ereignisse Action-Funktionen definieren.

Win_Topaction Action
Action-Funktion für das Toppen von Fenstern definieren.
Win_Moveaction Action
Action-Funktion für das Bewegen von Fenstern definieren.
Win_Sizeaction Action
Action-Funktion für die Änderung der Fenstergrösse definieren.
Win_Closeaction Action
Action-Funktion für das Schliessen von Fenstern definieren.

Dabei müssen Sie in Action jeweils die Adresse einer von Ihnen definierten Funktion übergeben. Diese Funktion wird dann von EasyGem aufgerufen, sobald der Anwender die entsprechende Operation ausgeführt hat. Ihre Action-Funktion muss einen Parameter haben:
Action=&FN My_Action()
DEF FN My_Action(Win)
...
END_FN
In Win wird Ihrer Funktion die Fenster-Identifikationsnummer übergeben. Im Falle von Win_Topaction und Win_Closeaction können Sie noch entscheiden, ob das Fenster tatsächlich getoppt bzw. geschlossen werden soll, indem Sie als Funktionswert -1 (Funktion ausführen) oder 0 (Funktion nicht ausführen) zurückgeben.

Die anderen Action-Funktionen werden erst aufgerufen, nachdem die Operation bereits ausgeführt wurde. Zum Beispiel können Sie
Win_Sizeaction benutzen, um Controls, die am unteren Fensterrand definiert wurden, so mitzubewegen, dass sie auch nach einer Änderung der Fenstergrösse am unteren Rand bleiben. Ein weiteres Beispiel für die Verwendung von Action-Funktionen zeigt EasyPaint.BAS im DEMO-Ordner.

Für Profis und solche die es werden wollen gibt es noch zwei Funktionen, die den 'WindowPtr' des Fensters mit der Nummer Win bzw. im Falle von Grafikfenstern auch den 'GWorldPtr' zurückgeben. Dabei handelt es sich um Zeiger auf spezielle Strukturen, die in "Inside Macintosh, Toolbox Essentials bzw. Imaging with Quick Draw" erklärt sind. Diese Pointer benötigen Sie, wenn Sie Mac OS Funktionen direkt auf EasyGem Fenster anwenden wollen:


FN Win_Ptr(Win) 
Liefert den 'WindowPtr' des Fensters mit der Nummer Win.
FN Gwin_Ptr(Win)
Liefert den 'GWorldPtr' des Fensters mit der Nummer Win.
      


4.6 Die Reihenfolge von Fenstern

Wenn man mehr als ein Fenster öffnet, entsteht zwangsläufig eine Reihenfolge der verschiedenen Fenster. Dabei ist eines der Fenster immer ausgezeichnet. Es befindet sich über allen anderen und verfügt als einziges über aktive Bedienelemente. Bei diesem Fenster sind die Schiebebalken zu sehen, der Verschiebebalken enthält ein Raster und das Schließ-, Voll- und Größenfeld enthalten die entsprechenden Symbole. In allen anderen Fenstern dagegen sind die Bedienelemente nicht vorhanden.
Um ein Fenster in den Vordergrund zu bringen oder festzustellen, welches Fenster sich gerade im Vordergrund befindet, gibt es in EasyGem die Prozedur
Win_Top und die Funktion FN Win_Whichtop:


Win_Top Win
Fenster in den Vordergrund bringen.

Diese Prozedur legt das Fenster über alle anderen, d.h. es wird von keinem anderen mehr überlappt. Alle Felder und Schiebebalken an dem auf diese Weise aktivierten Fenster sind jetzt benutzbar, im Gegensatz zu evtl. darunter liegenden, nicht aktiven Fenstern.


FN Win_Whichtop  
Nummer des aktiven Dokument-Fensters ermitteln.
FN Win_Floattop
Nummer des aktiven Float-Fensters ermitteln.

FN Win_Whichtop gibt die Nummer des Dokument-Fensters zurück, das sich gerade im Vordergrund befindet. Damit ist gemeint, daß das gesuchte Fenster dasjenige ist, welches alle anderen überlappt. Eine Null als Ergebnis zeigt an, daß kein EasyGem Fenster aktiv ist. Dann ist entweder gar kein Fenster geöffnet oder ein anderes Programm hat das aktive Fenster.

Ab Mac OS 8.6 können Sie ja auch Float-Fenster definieren. Diese werden von
FN Win_Whichtop ignoriert, da man sonst ja gar keine Möglichkeit hätte, das oberste Dokument-Fenster zu ermitteln. Wenn Sie herausfinden möchten, welches Float-Fenster oben liegt, können Sie dafür die Funktion FN Win_Floattop verwenden. Ist kein Float-Fenster offen, liefern beide Funktionen das gleiche Ergebnis.



4.7 Die Abfrage der Maus in Fenstern

Wenn der Anwender die Maus bewegt, die Maustaste oder eine Taste auf der Tastatur drückt, dann sind das Ereignisse, die Ihr Programm erfahren muß, um gegebenenfalls richtig darauf zu reagieren. Wenn mehrere Programme parallel laufen, sollte immer nur das aktive Programm diese Meldungen erhalten. Wenn Sie nämlich mit den BASIC-Befehlen
MOUSEBUT und INKEY$ die Maustaste und die Tastatur abfragen, bekommen Sie jeden Tastendruck gemeldet, auch wenn er gar nicht für Ihr Programm bestimmt ist. In EasyGem gibt es darum eine erweiterte Funktion von Easy_Mesag, die nur die für Ihr Programm bestimmten Ereignisse meldet:


Easy_Mesag R Entry,R Buffer$,R Mx,R My
[,R Mb[,R Modifier[,R Clicks]]]

Mx und My sind die Mausposition.
Mb steht für den Mausknopfzustand.
Modifier ist der Zustand der sogenannten Modifier-Keys (Befehl, Shift, Control, Alternate, CapsLock).
Clicks gibt die Anzahl der Mausklicks zurück (1=Normal, 2=Doppelklick, 3=Trippelclick usw.).

Hinweis bei Verwendung von Mäusen mit zwei oder drei Tasten:
Definieren Sie Ihre Mehrtastenmaus so, daß die zweite Maustaste wie [Cmd]+[Return] und die dritte wie [Alt]+[Return] wirkt. Dann erhalten Sie in
Mb Werte zwischen 0 (kein Taste gedrückt) und 7 (alle drei Tasten gedrückt) zurück. Natürlich können Sie auch die mittlere Taste mit einem Doppelklick belegen und die rechte als zweite Maustaste verwenden oder jede beliebige andere Kombination.

Um jetzt festzustellen, auf welchem Fenster an welche Stelle des virtuellen Bildschirms geklickt wurde, ist nur noch die Prozedur
Win_Mousepos nötig. Dies ist ein sehr wichtiger Befehl, wenn die Maus innerhalb eines Fensters einsetzbar sein soll. Win_Mousepos gibt nämlich die Nummer des Fensters zurück, über welchem sich gerade die Maus befindet und rechnet dabei noch gleich Bildschirmkoordinaten in virtuelle Koordinaten um.


Win_Mousepos R Win[,Xin,Yin],R Xout,R Yout
Mausposition ermitteln.

In Win erhalten Sie die Nummer des Fensters, über dem sich die Maus befindet. Eine Null bedeutet, daß es kein EasyGem-Fenster ist.
Xin und Yin können weggelassen werden. Dann erhalten Sie in Xout und Yout die Position der Maus auf dem virtuellen Bildschirm, der zu dem Fenster mit der Nummer Win gehört.
In
Xin und Yin kann man aber auch eine beliebige Position auf dem realen Bildschirm übergeben, die dann in die entsprechenden virtuellen Koordinaten umgerechnet und in Xout und Yout zurückgegeben wird. Wenn Win die Nummer eines Textfensters ist, wird das Ergebnis nicht in Pixeln, sondern in Buchstabengrößen geliefert.

Beispiel:
COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init
Gwin_Open Win1,0,21,-320,-200,320,200,"Fenster 1"
OUTLINE OFF
REPEAT
 Easy_Mesag Entry,Buffer$,Mx,My,Mb,Modifier
 Win_Domessages Buffer$
 IF Mb THEN
  Win_Mousepos Win,X,Y
  IF Win=Win1 THEN
   'Mit Shift-Taste: Punkte löschen, sonst setzen.
   IF Modifier SHR 8 AND 2
    THEN FILL COLOR =0
    ELSE FILL COLOR =1
   ENDIF
   Gwin_Activate Win1
   PBOX X,Y,5,5:'Punkt im virtuellen Bildschirm zeichnen.
   Win_Redraw Win1,X,Y,5,5:'Fenster aktualisieren.
  ENDIF
 ENDIF
UNTIL FN Win_Closed(Win1)
Easy_Exit
END




4.8 Textfenster

Natürlich können Sie auch in Grafikfenster Texte ausgeben, der Nachteil ist nur, daß die Information pixelweise gespeichert wird und der Speicherverbrauch dadurch sehr groß werden kann. Außerdem können Sie den Text schlecht editieren, da die Information ja wie ein Bild verarbeitet wird und Sie gar nicht wissen, welches Zeichen an welcher Stelle steht. Für die Ausgabe langer Texte (z.B. Meßergebnisse) oder das Editieren von Texten (Texterfassung) stellt EasyGem deshalb spezielle Textfenster zur Verfügung, in denen die Information nicht pixelweise, sondern Zeichenweise abgelegt ist.
Die Fenster können dabei maximal 32766 Zeichen breit sein. Die Anzahl der Zeilen ist in der Standardeinstellung auf 5000 für alle Textfenster zusammen beschränkt, kann aber beliebig vergrößert werden, so daß die Größe Ihrer Textdokumente in der Praxis nur durch den verfügbaren Speicher begrenzt ist.
Damit kommen wir gleich zum ersten Befehl für Textfenster:


Twin_Maxspace Lines  
Maximale Anzahl Textzeilen für Textfenster festlegen.

Mit diesem Befehl können Sie mehr Zeilen für Textfenster reservieren. In Lines gibt man an, wieviele Zeilen für alle Textfenster zusammengezählt benötigt werden. Twin_Maxspace sollte direkt nach Easy_Init aufgerufen werden, da Twin_Maxspace ein Stringfeld redimensioniert. Alternativ können Sie natürlich auch den erweiterten Easy_Init Befehl verwenden, um mehr Platz für Ihre Textfenster zu bekommen.

Wichtig: Der Inhalt der Textfenster wird in einem Stringfeld gespeichert. Sie müssen deshalb mit COMPILER "BAS_MEM X" dafür sorgen, daß genug BASIC-Speicher für den String-Heap vorhanden ist. Um die benötigte Menge abzuschätzen, multiplizieren Sie einfach die Breite des virtuellen Textfensters mit der Höhe und das Ergebnis nochmal mit drei. Dann haben Sie genug Platz für Ihre Textfenster.

EasyGem verwaltet für Sie virtuelle Textfenster mit folgenden Möglichkeiten:

Virtuelle Textfenster mit beliebiger Höhe und maximal 32766 Zeichen Breite.
Jedem Fenster kann ein eigener Zeichensatz mit allen Attributen zugeordnet werden.
Eigene Ein- und Ausgabebefehle mit vielen Variationsmöglichkeiten.
Ausgaben in das virtuelle Textfenster werden sofort auf dem realen Bildschirm sichtbar.

Halbautomatische Verwaltung von Textblöcken.
Unterstützung des Clipboards (Ausschneiden, Kopieren, Einfügen).
Befehle zum Laden und Speichern von Texten.
Befehle zum Drucken von Texten.


Alle Textfensterbefehle beginnen mit
"Twin_" , um von vornherein eine klare Gruppierung sicherzustellen.
Um mit Textfenstern arbeiten zu können, muß man natürlich erstmal so ein Fenster öffnen. Dafür gibt es den Befehl:



Twin_Open R Win,Win_X,Win_Y,Win_W,Win_H
[,Virt_W,Virt_H],Name$

Twin_Open R Win,Win_X,Win_Y,Win_W,Win_H,
Virt_W,Virt_H, Name$, Info$[,Kind]
 
Textfenster öffnen.

Twin_Open hat die gleichen Parameter wie Gwin_Open, nur werden Virt_W und Virt_H in Buchstaben und nicht in Bildpunkten angegeben. Eine nochmalige Beschreibung wollen wir uns deshalb hier sparen. Bitte schlagen Sie bei Gwin_Open nach, wenn Sie sich über die Bedeutung der Parameter im unklaren sind.

Hinweis: Textfensterbefehle sind nur auf Fenster anwendbar, die mit dem Befehl Twin_Open geöffnet wurden.


Nachdem Sie nun wissen, wie man ein Textfenster öffnet, möchten Sie sicherlich auch etwas darin ausgeben. Dafür gibt es den Befehl:

Twin_Print Win[[,Y,X],Txt$] 
Text ausgeben und neue Zeile anfangen.
Twin_Print_ Win[,Y,X][,Txt$] 
Text ausgeben, ohne neue Zeile anzufangen.

Twin_Print ist das Gegenstück zum BASIC-Befehl PRINT. Twin_Print Win gibt einfach eine Leerzeile aus. Wenn Txt$ mit angegeben wird, so erscheint der Text an der momentanen Cursorposition. Wenn man Y und X mit angibt, so kann man wie mit dem BASIC-Befehl PRINT @(Y,X) den Cursor positionieren, bevor der Text ausgegeben wird. Übrigens werden die wichtigsten Steuersequenzen des VT52-Emulators richtig interpretiert. Anwendbare Escape-Codes sind: A, B, C, D, E, H, I, J, K, L, M, Y, d, l, o. Die Bedeutung ist im Omikron Basic Handbuch erklärt.
Der Befehl
Twin_Print löst einen Zeilenvorschub aus, genau wie der BASIC-Befehl PRINT "TEXT"
Um den Zeilenvorschub bei
Twin_Print auszuschalten, verwendet man Twin_Print_ , also Twin_Print mit einem Unterstreichungszeichen angehängt.

Hinweis: Twin_Print_ gibt es natürlich nicht in der Version mit einem Parameter, da dieser Befehl nur einen Zeilenvorschub auslösen würde, der durch den Unterstrich aber wieder unterdrückt wäre, dieser Befehl also gar nichts machen würde.

Beispiel:
COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init
Twin_Open Win1,0,21,-240,-320,35,20,"Textfenster","Info"
FOR I=1 TO 10:'10 Zeilen Text ausgeben.
 Twin_Print Win1,"Dies ist die"+ STR$(I)+". Zeile."
NEXT I
REPEAT
 Easy_Mesag 0,Buffer$:'Der erste Parameter ist 0, da wir kein Menü haben.
 Win_Domessages Buffer$
UNTIL FN Win_Closed(Win1)
Easy_Exit
END

Nun kommt es häufig vor, daß man den Text zuerst in den virtuellen Bildschirm schreiben möchte, um dann das ganze Fenster mit Win_Redraw auf einmal zu aktualisieren. Wenn man viele Textausgaben hintereinander macht, so kann man die Ausgabe durch diese Vorgehensweise erheblich beschleunigen und gleichzeitig den Flimmereffekt bei der Ausgabe vermeiden. Dafür gibt es die zu Twin_Print korrespondierenden Befehle:


Twin_Iprint Win[[,Y,X],Txt$]
Text virtuell ausgeben und neue Zeile anfangen.
Twin_Iprint_ Win[,Y,X][,Txt$]
Text virtuell ausgeben, ohne neue Zeile anzufangen.

Das "I" steht dabei für Intern und bedeutet, daß die Operation nur auf dem internen virtuellen Bildschirm ausgeführt wird.
Da es auch noch andere Befehle für Textfenster gibt, die auch in einer internen Version vorhanden sind, schreiben wir diese ab jetzt immer gleich mit unter die normalen Befehle, ohne extra darauf einzugehen.

Wenn Sie den ganzen virtuellen Textbildschirm löschen möchten, können Sie dafür den folgenden Befehl benutzen:


Twin_Cls Win 
Textbildschirm löschen und Ergebnis sofort anzeigen.
Twin_Icls Win 
Textbildschirm löschen.

Wie beim BASIC-Befehl CLS wird der Cursor in die Position (0,0) gebracht, und der virtuelle Bildschirm gelöscht.

Manchmal muß man den virtuellen Text nach oben oder nach unten scrollen, zum Beispiel, weil man die Information am Anfang bzw. am Ende nicht mehr benötigt, oder weil nicht mehr genu Platz ist für die beabsichtigte Ausgabe. Wohlgemerkt, hiermit ist nicht das Scrollen im realen Fenster gemeint, sondern das Scrollen auf dem virtuellen Textbildschirm. Darum sind die rausgescrollten Zeilen danach auch verloren und nicht einfach nur nicht mehr sichtbar!


Twin_Scrollup Win[,N]
Textfenster nach oben scrollen und Ergebnis sofort anzeigen.
Twin_Iscrollup Win[,N]
Textfenster nach oben scrollen.
Twin_Scrolldown Win[,N]
Textfenster nach unten scrollen und Ergebnis sofort anzeigen.
Twin_Iscrolldown Win[,N]
Textfenster nach unten scrollen.

Twin_Scrollup schiebt einen virtuellen Textbildschirm um N Zeilen nach oben. Die unteren N Zeilen sind danach leer. Der rausgescrollte Text ist verloren. Entsprechend schiebt Twin_Scrolldown alle Zeilen nach unten. Wenn N weggelassen wird, so wird um eine Zeile gescrollt.

Beispiel:
COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init
Twin_Open Win1,0,21,-240,-128,80,8,"Textfenster","Info"
T= TIMER
FOR I=1 TO 26:'Buchstaben A bis Z ausgeben.
 Twin_Print Win1,CHR$(64+I)*80
NEXT I
Win_Info Win1,"Normaler Print:"+ STR$(( TIMER -T)/200)+" sec"
'Jetzt das ganze nochmal intern.
Twin_Open Win2,40,61,-240,-128,80,8,"Textfenster","Info"
T= TIMER
FOR I=1 TO 26:'Buchstaben A bis Z ausgeben.
 Twin_Iprint Win2,CHR$(64+I)*80
NEXT I
Win_Redraw Win2
Win_Info Win2,"Interner Print:"+ STR$((TIMER -T)/200)+" sec"
REPEAT
 Easy_Mesag 0,Buffer$
 Win_Domessages Buffer$
UNTIL FN Win_Closed(Win1) OR FN Win_Closed(Win2)
Easy_Exit
END


Zusätzlich zu den Print-Befehlen gibt es noch eine direkte Möglichkeit, den Inhalt eines Textfensters zu verändern oder abzufragen. Dabei wird der angegebene Text direkt in das virtuelle Textfenster geschrieben, ohne daß darin enthaltene Steuerzeichen (Escape-Sequenzen siehe oben) ausgewertet werden.


Twin_Setline Win,Y,Txt$
Textfensterzeile setzen.
FN Twin_Getline$(Win,Y)
Textfensterzeile auslesen.
FN Twin_Getlen(Win,Y)
Länge der Textfensterzeile ermitteln.

Es wird der Inhalt der Y-ten Zeile des Fensters mit der Nummer Win verändert bzw. abgefragt.
Wenn man neue Eingabefunktionen schreiben, oder den Inhalt eines Fensters abspeichern oder ausdrucken will, so sind diese Funktion sehr nützlich.
Die Funktion
FN Twin_Getlen liefert nicht die Breite des virtuellen Textbildschirms sondern die tatsächliche Länge des Textes in der Y-ten Zeile. Das Ergebnis kann also auch null sein, wenn sich nämlich kein Text in der besagten Zeile befindet.

Häufig stellt sich die Aufgabe, daß einTextstück in den fortlaufenden Text eines Fensters eingesetzt bzw. eine bestimmte Anzahl Zeichen aus dem Text entfernt werden soll. Dafür gibt es ebenfalls zwei Befehle in EasyGem:


Twin_Insert Win,Y,X,Txt$
Text einsetzen.
Twin_Iinsert Win,Y,X,Txt$
Text nur virtuell einsetzen.
Twin_Delete Win,Y,X,N
Text entfernen.
Twin_Idelete Win,Y,X,N
Text nur virtuell entfernen.

Diese vier Prozeduren arbeiten so, daß die nachfolgenden Zeilen so umgebrochen werden, daß es nicht zu Wortzerstückelungen kommt. Getrennt wird immer nur an den Stellen, an denen ein Füllzeichen steht.
Txt$ enthält den einzusetzenden Text und N die Anzahl der zu entfernenden Zeichen.

Achtung: Die internen Befehle arbeiten nur auf dem virtuellen Bildschirm. Um das Ergebnis sichtbar zu machen, müssen Sie anschließend mit Win_Redraw das reale Fenster aktualisieren.

Daß man die Cursorposition mit Twin_Print_ verändern kann, haben wir ja bereits erwähnt, manchmal möchte man aber auch wissen, wo sich der Cursor gerade befindet. Dafür gibt es die beiden Abfragefunktionen:


FN Twin_Csrlin(Win)   
Aktuelle Cursorzeile ermitteln.
FN Twin_Pos(Win) 
Aktuelle Cursorspalte ermitteln.

Diese beiden Funktionen sind ein Pendant zu den BASIC-Funktionen CSRLIN bzw. POS, mit dem Unterschied, daß die Zählung bei FN Twin_Csrlin bei null und nicht bei eins beginnt.



4.9 Textattribute setzen und abfragen

Unter EasyGem können Sie jedem Textfenster individuelle Textattribute zuordnen. Sie können also z.B. in dem einen Fenster mit fetter, blauer Schrift arbeiten und in dem anderen mit magerer gelber Schrift auf schwarzem Hintergrund. Natürlich lassen sich auch die anderen Attribute wie Textgröße oder Textfont verändern. Im einzelnen gibt es dafür die folgenden Befehle und Funktionen:


Twin_Setfont Win,Font_Nr
Setzt den Textfont.
FN Twin_Getfont(Win)    
Ergibt den eingestellten Textfont.

In Font_Nr muß die Identifikations-Nummer des gewünschten Fonts übergeben werden (z.B. Monaco=4, Courier=22). Wenn Sie nur den Namen des Fonts kennen, können Sie mit der Funktion FN Get_Font_Number aus der Extension Library die zugehörige Identifikationsnummer ermitteln.

 
Twin_Setsize Win,Font_Size    
Setzt die Textgröße.
FN Twin_Getsize(Win)    
Ergibt die eingestellte Textgröße.

Die Standardeinstellung ist 13 Punkte. Sie können natürlich auch jeden beliebigen anderen Wert für Font_Size einsetzen.

Aus Kompatibilitätsgründen zu älteren EasyGem Versionen gibt es für die Einstellung der Textgröße auch noch den Befehl:


Twin_Settextsize Win,Font_Size      
Textgröße ändern.

Dabei werden die Werte in Font_Size wie folgt interpretiert:
0 = 8 Punkte, 1= 10 Punkte, 2= 13 Punkte und alle anderen Zahlen wie bei
Twin_Setsize.


Twin_Setface Win,Font_Face    
Setzt den Textstil.
FN Twin_Getface(Win)    
Ergibt den eingestellten Textstil.

Damit kann man den Textstil verändern bzw. abfragen. In Font_Face müssen Flags übergeben werden, wie sie im Omikron Basic Handbuch bei TEXT STYLE beschrieben sind.


Twin_Setbackcolor Win,Font_Backcolor    
Setzt die Hintergrundfarbe.
FN Twin_Getbackcolor(Win)       
Ergibt die eingestellte Hintergrundfarbe.
Twin_Setforecolor Win,Font_Forecolor    
Setzt die Textfarbe.
FN Twin_Getforecolor(Win)             
Ergibt die eingestellte Textfarbe.

Mit diesen vier Befehlen läßt sich die Hintergrund- bzw. Vordergrundfarbe einstellen bzw. abfragen. Die Farbe ist dabei durch einen Index gekennzeichnet wie bei dem BASIC-Befehl TEXT COLOR.

Häufig möchte man gerne wissen, wieviele Textzeilen bzw. -spalten in ein gegebenes reales Fenster passen. Dazu muß man natürlich die Höhe bzw. Breite eines Zeichens kennen. Dafür stellt EasyGem zwei Funktionen zur Verfügung, die bei Ihrem Aufruf die aktuellen Werte, die ja von den gerade eingestellten Textattributen abhängen, zurückliefern.

FN Twin_Cellwidth(Win)           
Buchstabenbreite ermitteln.
FN Twin_Cellheight(Win)         
Buchstabenhöhe ermitteln.

Mit diesen beiden Funktionen kann man also den Platzbedarf eines Buchstabens ermitteln.




4.10 Eingaben in Textfenstern

Kommen wir zunächst zur einfachsten Eingabe, der Eingabe eines einzelnen Zeichens. In Omikron Basic können Sie ja mit dem Befehl
INKEY$ jederzeit feststellen, ob eine Taste gedrückt wurde. Einen ähnlichen Befehl gibt es auch bei EasyGem:


Twin_Inkey Win    
Eingabe eines Zeichens veranlassen.

Der Befehl Twin_Inkey macht zunächst mal weiter nichts, als daß er EasyGem veranlaßt, auf Tastendrücke zu achten, die gemacht werden, während das Fenster mit der Nummer Win das aktive EasyGem-Fenster ist.
Die Prozedur
Win_Domessages erledigt nun nicht nur alle Fensterbewegungen, sondern testet regelmäßig, ob eine Taste gedrückt wurde. Falls das der Fall ist, wird der Tastencode vermerkt und dem aktiven Fenster zugeordnet. Nun wissen Sie aber immer noch nicht, welche Taste gedrückt wurde. Um das zu erfahren, gibt es die Funktion:


FN Twin_Inkey(Win)          
Eingabe eines Zeichens abfragen.

Die Funktion Twin_Inkey liefert als Ergebnis null, wenn keine Taste gedrückt wurde, andernfalls eine Long-Integer-Zahl mit den Informationen über die gedrückte Taste. Im niederwertigsten Byte befindet sich der ASCII-Code, das zweite ist immer null, das dritte enthält den Virtual-Key-Code und das höchstwertigste die Modifier-Keys. Die Informationen sind dabei genauso codiert wie bei dem BASIC-Befehl INKEY$.
FN Twin_Inkey kann zwar beliebig oft abgefragt werden, liefert aber solange immer das gleiche Ergebnis, bis erneut der Befehl Twin_Inkey aufgerufen wird.

Beispiel:
COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init
N$="Twin_Inkey-Test":I$="Ende mit Taste Esc"
Twin_Open Win1,0,21,-240,-340,80,25,N$,I$
REPEAT
 Twin_Print_ Win1,"Bitte eine Taste drücken:"
 Twin_Inkey Win1:'Schaltet die Tastenüberwachung ein.
 REPEAT
  Easy_Mesag 0,Buffer$
  Win_Domessages Buffer$
  IF FN Win_Closed(Win1) THEN Easy_Exit :END
 UNTIL FN Twin_Inkey(Win1):'Bis eine Taste gedrückt wurde.
 A=FN Twin_Inkey(Win1):'Welche Taste wurde gedrückt?
 Twin_Print Win1:'Ergebnis darstellen.
 Twin_Print Win1,"Der ASCII-Code ist:"+STR$(A AND 255)
 Twin_Print Win1,"Der Virtual-Key-Code ist:"+STR$(HIGH(A) AND 255)
 Twin_Print Win1,"Die Modifier-Keys sind:"+STR$(A SHR 24)
 Twin_Print Win1
UNTIL FN Win_Closed(Win1) OR (A AND 255)=27
'Bis Fenster zu oder Esc-Taste gedrückt.
Easy_Exit
END

Wenn Sie die Tastaturüberwachung für ein bestimmtes Fenster vorzeitig abbrechen möchten, bevor eine Taste gedrückt wurden, können Sie dafür den folgenden Befehl verwenden:


Twin_Inkey_Clear Win          
Eingabe abbrechen.

Der Befehl Twin_Inkey_Clear bricht die Eingabe in einem Fenster vorzeitig ab und wirkt sowohl auf eine einfache Zeicheneingabe (Twin_Inkey) als auch auf den Twin_Input Befehl, der jetzt besprochen wird.

Vom BASIC her kennen Sie ja sicherlich den
INPUT-Befehl. Man kann damit nicht nur einzelne Zeichen eingeben, sondern auch ganze Zeilen und man kann seine Eingabe noch korrigieren (Pfeiltasten, Backspace, Insert, Delete ... ), bevor man die Eingabe endgültig mit [Return] abschließt.
Noch komfortabler geht es mit dem Omikron Basic Befehl
INPUT USING. Man kann wesentliche Parameter vorweg bestimmen, z.B. die Zeichenkette, die geändert wird, die maximale Eingabelänge, das Füllzeichen bis zur maximalen Eingabelänge, die Cursorposition innerhalb der Eingabe, welche Zeichen überhaupt erlaubt sind und welche Tasten das Ende der Eingabe bewirken sollen.
All diese Möglichkeiten bietet auch EasyGem mit dem Befehl:


Twin_Input Win[,Def$[,Usng$[,Length[,F_Char[,Posn]]]]  
Eingabe einer Zeile.
Twin_Input Win,Y,X,Def$,Usng$,Length,F_Char,Posn  
Eingabe einer Zeile mit Positionierung.

Win ist die Nummer des Fensters, in dem die Eingabe erfolgen soll.
Def$ ist der Text, der in der Eingabe zunächst dargestellt wird. Ist Def$ nicht angegeben, so ist die Eingabe zu Beginn leer.
Usng$ ist eine Zeichenkette, die angibt, welche Zeichen zugelassen sind. Ihre Bedeutung wird im Omikron Basic Handbuch bei INPUT USING erklärt. Wird Usng$ nicht angegeben, so sind alle Zeichen zugelassen.
Length gibt die maximale Länge der Eingabe an. Wenn die Maximallänge nicht angegeben ist, kann bis zur letzten Spalte im virtuellen Bildschirm eingegeben werden.
F_Char enthält den ASCII-Code des Füllzeichens bis zur maximalen Eingabelänge. Ist F_Char nicht angegeben, so wird entweder 95 (Unterstreichung bis zur Maximallänge) oder 0 (kein Füllzeichen, wenn keine Maximallänge angegeben wurde) angenommen.
Posn dient zum Einstellen der Cursorposition. Ist Posn nicht angegeben, steht der Cursor zu Beginn ganz links in der Eingabezeile.

Nach dem Aufruf von Twin_Input erscheint zunächst ein blinkender Cursor und gegebenenfalls der Defaulttext bzw. die Eingabemaske. Damit EasyGem die Tastatur auch überwachen und auf eventuelle Eingaben reagieren kann, ist es notwendig, daß Easy_Mesag und Win_Domessages regelmäßig aufgerufen werden.


FN Twin_Input(Win)          
Testet, ob die Eingabe einer Zeile beendet wurde.

Die Funktion ergibt 0, wenn die Eingabe noch nicht beendet ist, und nicht 0, wenn die Eingabe bereits beendet wurde. Dabei bedeutet:
-1 : Die Eingabe wurde durch eine linke Randüberschreitung beendet.
-2 : Die Eingabe wurde durch eine rechte Randüberschreitung beendet.
>0: Die Funktion gibt einen Wert wie bei
FN Twin_Inkey zurück, der die Abbruchtaste enthält.

Die Taste, die das Ende der Eingabe ausgelöst hat, kann auch später noch mit
FN Twin_Inkey ermittelt werden.

FN Twin_Input_Pos(Win)          
Gibt die Cursorposition zurück.

Diese Funktion liefert die aktuelle Cursorposition innerhalb der Eingabezeile.


FN Twin_Input$(Win)          
Gibt den eingegebenen String zurück.

Hiermit läßt sich abfragen, welcher Text in dem Fenster mit der Nummer Win zuletzt eingegeben wurde.


Twin_Input_Fullbuff          
Diese Prozedur hat keine Bedeutung mehr und ist nur aus Kompatibilitätsgründen zu älteren EasyGem Versionen vorhanden.
Beispiel:
COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init
Win_Closeaction &FN Closeaction()
Win_Getwork -1,X,Y,W,H:'Desktop-Größe ermitteln.
Twin_Open Win1,X,Y,W,H,80,25,"Text"
REPEAT
 Twin_Print Win1,"Bitte geben Sie Ihren Namen ein:"
 Twin_Input Win1,"Susi Sorglos","á%0",35,95,5
 REPEAT
  Easy_Mesag 0,Buffer$
  Win_Domessages Buffer$
 UNTIL FN Twin_Input(Win1) OR FN Win_Closed(Win1)
 IF FN Win_Closed(Win1)=0 THEN
  Twin_Print Win1
  A$=FN Twin_Input$(Win1)+" ist ein schöner Name."
  Twin_Print Win1,A$
 ENDIF
UNTIL FN Win_Closed(Win1)
Easy_Exit
END

DEF FN Closeaction(Win):LOCAL A$
 A$=
"[2][Wollen Sie wirklich|keinen Namen eingeben?][ Ja |Doch]"
 FORM_ALERT(1,A$,R)
 RETURN R-2
END_FN


Nun will man ja manchmal nicht einzelne Zeilen, sondern den gesamten Text eines Fensters editieren. Dafür gibt es in EasyGem den Befehl:


Twin_Fullinput Win[,Y,X[,Usng$[,F_Char]]]      
Der gesamte Text wird editiert.

Die Bedeutung der Parameter ist die gleiche wie bei Twin_Input. Der Unterschied besteht darin, daß der gesamte Text eines Fensters editiert wird. Wenn also der eingefügte Text zum Beispiel nicht in die aktuelle Zeile paßt, wird der nachfolgende Text automatisch umgebrochen. Dabei achtet EasyGem darauf, daß Wörter nicht zerteilt werden. Die Auftrennung der Zeilen erfolgt also immer nur bei den Füllzeichen oder bei Absätzen. Auch wenn Textstücke gelöscht werden, rücken die nachfolgenden Zeilen automatisch nach.
Absätze kann man mit [Return] erzeugen. Dann wird eine neue Zeile aufgemacht und der Cursor an den Anfang der neuen Zeile gesetzt.
Dieser Befehl ermöglicht es Ihnen also, sehr leicht einen einfachen Texteditor zu programmieren, wie es an dem Beispielprogramm EasyPaint.BAS im DEMO-Ordner gezeigt wird.




4.11 Userfenster

Die sogenannten Userfenster geben Ihnen maximalen Gestaltungsspielraum bei der Festlegung des Fensterinhalts. Da EasyGem jetzt aber nicht mehr wissen kann, was sich in Ihren Userfenstern befindet und wie es dargestellt werden muß, sind Sie dafür selbst verantwortlich. Dafür bekommt der Befehl zum Öffnen eines Userfensters einen zusätzlichen Parameter, der bei allen Varianten mit angegeben werden muß und die Adresse einer Funktion enthält, die Sie selbst definieren müssen und die von EasyGem immer dann aufgerufen wird, wenn das Fenster oder Teile davon neu gezeichnet werden müssen. Auch bei Userfenstern nimmt Ihnen EasyGem also die Überwachung der Bedienelemente ab.


Uwin_Open R Win,Win_X,Win_Y,Win_W,Win_H
[,Virt_W,Virt_H],Name$,Redraw
Uwin_Open R Win,Win_X,Win_Y,Win_W,Win_H,
Virt_W,Virt_H,Name$,Info$ [,Kind],Redraw

Die Parameter sind also die gleichen wie bei Gwin_Open. Neu ist nur Redraw, das die Adresse auf eine von Ihnen definierte Funktion enthalten muß. Diese Funktion muß 7 Parameter übernehmen und damit folgenden prinzipiellen Aufbau haben:

DEF FN My_Redraw(Win,X,Y,W,H,X_Offset,Y_Offset)

In Win bekommen Sie die Nummer des Fensters, das neugezeichnet werden muß.
X,Y,W,H bezeichnen das Rechteck auf dem virtuellen Bildschirm, das aktualisiert werden muß.
X_Offset,Y_Offset enthalten einen Offset, der von EasyGem berechnet wird und alle Parameter wie Position der Schieber, Vorhandensein einer Infozeile usw. berücksichtigt, so daß Sie diesen Offset nur von Ihren virtuellen Koordinaten zu subtrahieren brauchen, um im realen Fenster das richtige Gebiet zu aktualisieren. Wenn Ihre Funktion das geforderte Gebiet aktualisieren konnte, sollte Sie den Wert -1 zurückgeben und sonst 0.
Das klingt natürlich jetzt alles erstmal sehr theoretisch und darum wollen wir versuchen, das Ganze an einem Beispiel deutlich zu machen. Im DEMO-Ordner finden Sie die Programme EasyFractal.BAS und EasyPaint.BAS, die ebenfalls den Umgang mit Userfenstern demonstrieren.

Das folgende Beispiel verwaltet einen virtuellen Userbildschirm mit 2000x2000 Punkten Größe, der nur Kreise enthält:

COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init
N$="Userfenster":I$=" Information"
Redraw=&FN Redraw_Circle(0,0,0,0,0,0,0)
Uwin_Open Win1,0,21,300,300,2000,2000,N$,I$,Redraw
Win_Setview Win1,850,0:'Obere Mitte von Win1 sichtbar machen.
REPEAT
 Easy_Mesag 0,Buffer$
 Win_Domessages Buffer$
UNTIL FN Win_Closed(Win1)
Easy_Exit
END

DEF FN Redraw_Circle(Win,X,Y,W,H,X_Offset,Y_Offset)
 LOCAL Xm=1000,Ym=1000,K#,T
 K#= SQR(.5)
 FOR R=0 TO 1000 STEP 20
  'Jetzt müssen wir erstmal feststellen, ob Teile dieses
  'Kreises durch das Rechteck X,Y,W,H gehen.
  T=R*K#:'Seitenlänge des im Kreis liegenden Quadrats/2.
  'Bereich im umfassenden Quadrat?
  IF ABS(Xm-X)<R OR ABS(Xm-X-W)<R OR ABS(Ym-Y)<R OR ABS(Ym-Y-H)<R
   THEN'Bereich außerhalb des im Kreis liegenden Quadrats.
    IF ABS(Xm-X)>T OR ABS(Xm-X-W)>T OR ABS(Ym-Y)>T OR ABS(Ym-Y-H)>T
     THEN CIRCLE Xm-X_Offset,Ym-Y_Offset,R
    ENDIF
  ENDIF
 NEXT R
 RETURN -1
END_FN

Wie Sie an diesem Beispiel sehen können, ist es mit Userfenstern möglich, einen sehr großen virtuellen Bildschirm (2000 x 2000 Pixel) ohne zusätzlichen Speicherverbrauch zu verwalten. Ein Grafikfenster hätte dafür bei 256 Farben 4 Millionen Bytes im Applicationheap benötigt und bei einer Truecolor-Auflösung sogar 16 Millionen.
Natürlich können Sie in Ihrem Userfenster nicht nur Kreise darstellen, sondern beliebige Objekte, also z.B. auch Texte. Sie müssen nur alles selbst verwalten, da EasyGem nicht wissen kann, was sich in Ihren Fenstern befinden soll.
Bitte beachten Sie auch das Beispielprogramm EasyPaint.BAS im DEMO-Ordner. Dort wird gezeigt, wie man Userfenster benutzen kann, um sich sehr leicht Toolboxen für ein Malprogramm zu definieren.
Hinweis: Da es bei Userfenstern keinerlei Vorgaben für den Inhalt und die Art der Darstellung gibt, kann EasyGem Sie bei der Programmierung auch nicht so stark mit speziellen Prozeduren und Funktionen unterstützen wie bei Grafik- oder Textfenstern. Es gibt daher nur wenige spezielle Befehle für Userfenster. Natürlich können sie aber alle Befehle, die mit "Win" anfangen auch für Userfenster verwenden.


In einigen Fällen kann es von Vorteil sein, direkt in ein reales Fenster auszugeben. Dafür gibt es den Befehl:

Win_Activate Win    
Ausgabe in reales Fenster umlenken.

Das Fenster wird dadurch zu einem lokalen Grafikport. Der Punkt (0,0) liegt dabei im Innenbereich des Fensters in der linken oberen Ecke über der Infozeile! Wenn Sie also direkt in ein Fenster zeichnen wollen, müssen Sie zu den Y-Koordinaten jeweils noch die Höhe der Infozeile addieren, damit diese nicht übermalt wird.



4.12 Gummiband-Befehle für Grafik- und Userfenster

Bei grafischen Anwendungen ist es häufig erforderlich, elastische Linien, Rechtecke, Kreise etc. darzustellen, die wie ein Gummiband der Mausbewegung folgen und dem Anwender es ermöglichen, geometrische Grundfiguren zu definieren. Dafür gibt es in EasyGem eine Reihe von Prozeduren, die nachfolgend besprochen werden.


Elastic_Line Win,X1,Y1,R X2,R Y2,R Mb[,Action]
Elastische Linie darstellen.
Elastic_Rect Win,X,Y,R W,R H,R Mb[,Action]
Elastisches Rechteck darstellen.
Elastic_Roundrect Win,X,Y,R W,R H,R Mb[,Action]
Elastisches Rechteck mit runden Ecken darstellen.
Elastic_Circle Win,X,Y,R Ra,R Mb[,Action]
Elastischen Kreis darstellen.
Elastic_Ellipse Win,X,Y,R Rx,R Ry,R Mb[,Action]
Elastische Ellipse darstellen.

Allen gemeinsam ist, daß in den ersten drei Parametern eine Fenster-Identifikationsnummer und die Starposition (in virtuellen Koordinaten) übergeben werden müssen.
Elastic_Line gibt in (X2,Y2) den Endpunkt der Gummiband-Linie zurück.
Elastic_Rect und Elastic_Roundrect geben in W und H die Breite und die Höhe des aufgezogenen Rechtecks zurück.
Elastic_Circle liefert in Ra den Radius des aufgezogenen Kreises.
Elastic_Ellipse gibt in Rx und Ry die beiden Halbachsen der Gummiband-Ellipse zurück.
Nach dem Aufruf eines Elastic-Befehls übernimmt EasyGem die Kontrolle über die Mausbewegung, solange
MOUSEBUT=1 ist, also die Maustaste ohne zusätzliche Modifier-Keys (Cmd,Alt ...) gedrückt ist. Erreicht die Maus den Fensterrand, wird das Fenster automatisch weitergescrollt, so daß das Gummiband sich über das ganze virtuelle Fenster erstrecken kann.
Wenn der Anwender die Maustaste losläßt oder zusätzlich eine Modifier-Taste drückt, kehrt die jeweilige Prozedur zurück und übergibt Ihrem Programm in
Mb den Wert von MOUSEBUT, der zum Abbruch geführt hat.
Dadurch, daß es verschiedene Abbruchmöglichkeiten gibt, kann Ihr Programm ünterschiedlich reagieren, z.B. bei normalem Abbruch das Objekt zeichnen, beim Abbruch mit Cmd-Taste aber nicht.

Hinweis: Bei Elastic_Roundrect wird mit den aktuell eingestellten Rundungen gezeichnet. Die Rundungen können Sie mit dem Befehl Set_Roundings aus der Extension Library einstellen.

In
Action können Sie bei Bedarf noch die Adresse einer Action-Funktion übergeben (&FN My_Action(,,)), die bei jeder Mausbewegung von EasyGem aufgerufen wird und z.B. die aktuelle Mausposition in der Infozeile anzeigen könnte.
Die Action-Funtion muß drei Parameter haben, in denen die Fenster-Identifikationsnummer und die Mausposition auf dem virtuellen Bildschirm übergeben werden, bei Textfenstern natürlich wieder in Buchstaben statt in Pixeln.

Beispiel:
DEF FN My_Action(Win,X,Y)

Siehe auch das Programm EasyPaint.BAS im DEMO-Ordner.




4.13 Blöcke in Fenstern

Häufig möchte man als Programmierer bestimmte Bereiche eines Fensters markieren, um den Inhalt dann auszuschneiden, zu kopieren oder anderweitig zu verarbeiten. Um Ihnen diese Arbeit stark zu erleichtern, wurden in EasyGem Blockfunktionen eingebaut, die fast alle Arbeiten für Sie übernehmen. Die Befehle haben eine ähnliche Syntax wie diejenigen zum Einstellen und Abfragen der Fenstermaße, nur daß bei Textfenstern die Positionen des ersten und letzten Buchstabens angegeben werden müssen:


Gwin_Setblock Win,X,Y
Nur Blockanfang verändern.
Gwin_Setblock Win,0,W,H
Nur Blockgröße verändern.
Gwin_Setblock Win,X,Y,W,H
Blockanfang und Blockgröße verändern.


Twin_Setblock Win,X1,Y1
Nur Blockanfang verändern.
Twin_Setblock Win,0,X2,Y2
Nur Blockende verändern.
Twin_Setblock Win,X1,Y1,X2,Y2
Blockanfang und Blockende verändern.


Uwin_Setblock Win,X,Y
Nur Blockanfang verändern.
Uwin_Setblock Win,0,W,H
Nur Blockgröße verändern.
Uwin_Setblock Win,X,Y,W,H
Blockanfang und Blockgröße verändern.

Die Koordinaten des Blocks (X,Y,W,H bzw. X1,Y1,X2,Y2) müssen als virtuelle Koordinaten angegeben werden. Nach Ausführung des Befehls wird der Block im realen Fenster sofort sichtbar. In Textfenstern erkennt man den Block daran, daß die Farben invertiert sind, während in Grafik- und Userfenstern der markierte Bereich von einer dünnen gestrichelten Linie umrandet wird, bei der die Striche ständig von links oben nach rechts unten laufen.
Wenn Sie die Blockmarkierung wieder entfernen möchten, geben Sie einfach vier Nullen als Parameter ein.

Natürlich muß es auch eine Möglichkeit geben, einen definierten Block wieder abzufragen, also seinen Anfangs- und Endpunkt festzustellen. Dafür gibt es die entsprechenden Abfragefunktionen:


Gwin_Getblock Win,R X,R Y
Nur Blockanfang abfragen.
Gwin_Getblock Win,0,R W,R H
Nur Blockgröße abfragen.
Gwin_Getblock Win,R X,R Y,R W,R H
Blockanfang und Blockgröße abfragen.

Twin_Getblock Win,R X1,R Y1
Nur Blockanfang abfragen.
Twin_Getblock Win,0,R X2,R Y2
Nur Blockende abfragen.
Twin_Getblock Win,R X1,R Y1,R X2,R Y2
Blockanfang und Blockende abfragen.

Uwin_Getblock Win,R X,R Y
Nur Blockanfang abfragen.
Uwin_Getblock Win,0,R W,R H
Nur Blockgröße abfragen.
Uwin_Getblock Win,R X,R Y,R W,R H
Blockanfang und Blockgröße abfragen.

Hinweis: Für W und H können ab Omikron Basic 6.17 auch negative Werte angegeben werden. Dann wird der Block ausgehend von dem Punkt (X,Y) nach links bzw. oben angelegt.

Wichtig: Die Parameter hinter den Blockbefehlen müssen bei Textfenstern in Buchstaben und bei Grafik- und Userfenstern in Pixeln angegeben werden.

Mit den Blockfunktionen können Sie beliebige Bereiche des virtuellen Bildschirms während des Ablaufs Ihres Programms als selektiert definieren. Im allgemeinen möchte man aber auch die Möglichkeit haben, einen Block mit der Maus zu definieren (Block aufziehen). Eine solche Routine könnten Sie zwar mit den obigen Funktionen leicht selbst programmieren, aber auch diese Arbeit kann Ihnen EasyGem abnehmen, nämlich mit den folgenden Befehlen:


Gwin_Select Win,X,Y,R W,R H[,Action]
Block in Grafikfenster aufziehen.

Twin_Select Win,X1,Y1,R X2,R Y2[,Action]
Block in Textfenster aufziehen.

Uwin_Select Win,X,Y,R W,R H[,Action]
Block in Userfenster aufziehen.

Sobald sich die Maus im Fenster befindet und der Anwender die Maustaste gedrückt hat, übergeben Sie in (X,Y) bzw. (X1,Y1) die aktuelle Mausposition auf dem virtuellen Bildschirm als Anfangspunkt des Blocks. Nach dem Aufruf der Prozedur übernimmt EasyGem die Kontrolle über die Mausbewegung und zeichnet ständig ein Gummiband-Rechteck vom Anfangspunkt zur aktuellen Mausposition. Wenn die Maus dabei den Fensterrand erreicht, wird das Fenster automatisch weitergescrollt, so daß der Block sich über das ganze virtuelle Fenster erstrecken kann. Die Prozedur kehrt zurück, sobald MOUSEBUT<>1 ist, wenn also die Maustaste losgelassen wird, oder bei gedrückter Maustaste zusätzlich ein Modifier-Key (Cmd, Shift, Ctrl, Alt ...) gedrückt wird. In (W,H) erhalten Sie die Breite und Höhe des selektierten Blocks zurück bzw. bei Textfenstern in (X2,Y2) die Position des ersten Buchstabens hinter dem Block.
In
Action können Sie bei Bedarf noch die Adresse einer Action-Funktion übergeben (&FN My_Action(,,)), die bei jeder Mausbewegung von EasyGem aufgerufen wird und z.B. die aktuelle Mausposition in der Infozeile anzeigen könnte.
Die Action-Funtion muß drei Parameter haben, in denen die Fenster-Identifikationsnummer und die Mausposition auf dem virtuellen Bildschirm übergeben werden, bei Textfenstern natürlich wieder in Buchstaben statt in Pixeln.

Beispiel:
DEF FN My_Action(Win,X,Y)

Siehe auch das Programm EasyPaint.BAS im DEMO-Ordner.

Beispiel:
COMPILER "MIN_SIZE 1000000"
COMPILER "BAS_MEM 1000000"
COMPILER "Warnings off"

Easy_Init:'EasyGem anmelden.
'Grafikfenster öffnen.
N$="Grafikfenster":I$="Block aufziehen"
Gwin_Open Win1,0,21,-320,-200,320,200,N$,I$
Gwin_Activate Win1:'Ausgabe umleiten.
FOR R=10 TO 99 STEP 10
 CIRCLE 160,100,R:'Grafik zeichnen.
NEXT R
Gwin_Disactivate:'Ausgabe auf normal.
Win_Redraw Win1:'Fenster neu zeichnen.
REPEAT
 Easy_Mesag Entry,Buffer$,Mx,My,Mb
 Win_Domessages Buffer$
 IF Mb AND CVI(Buffer$) THEN
  'Die Maustaste wurde gedrückt und das Ereignis wurde noch
  'nicht von Win_Domessages bearbeitet.
  Win_Mousepos Win,X,Y
  IF Win THEN Gwin_Select Win,X,Y,W,H:'Block aufziehen.
 ENDIF
UNTIL FN Win_Closed(Win1)
Easy_Exit:'EasyGem abmelden.
END




4.14 Befehle für das Standard-Menü

Wie wir am Ende des Kapitels über die Menü-Programmierung ja schon erwähnt haben, sollte jedes Programm elementare Grundfunktionen wie Öffnen, Speichern, Drucken oder die Unterstützung der Clipboard-Funktionen ermöglichen. Einige Teile des Beispielmenüs wie 'Schließen' oder 'Beenden' sind sicher sehr leicht zu realisieren, andere dagegen erfordern einen erheblichen Programmieraufwand. Darum unterstützt Sie EasyGem hierbei mit speziellen Befehlen.


Gwin_Load R Win,Win_X,Win_Y,Win_W,Win_H
[,Virt_W,Virt_H],Name$,File$
Gwin_Load R Win,Win_X,Win_Y,Win_W,Win_H,
Virt_W,Virt_H,Name$,Info$ [,Kind],File$
Grafikdatei laden.

Twin_Load R Win,Win_X,Win_Y,Win_W,Win_H
[,Virt_W,Virt_H],Name$,File$
Twin_Load R Win,Win_X,Win_Y,Win_W,Win_H,
Virt_W,Virt_H,Name$,Info$ [,Kind],$
Textdatei laden.

Diese Befehle entsprechen in Ihrer Syntax den Befehlen Gwin_Open bzw. Twin_Open, haben aber den zusätzlichen Parameter File$, in dem Sie einen FileSpecificationRecord übergeben müssen. Wenn die Datei das richtige Format hat (PICT bzw. TEXT), wird automatisch ein virtuelles Fenster passender Größe geöffnet und die Datei in dieses Fenster geladen (Virt_W=0,Virt_H=0). Natürlich können Sie die Größe des virtuellen Bildschirm mit Virt_W und Virt_H auch selber vorgeben.
TEXT-Dateien werden im String-Heap gespeichert und PICT-Dateien im Application-Heap. Sie müssen daran denken, daß mit den Compiler-Steuerwörtern COMPILER "BAS_MEM X" bzw. COMPILER "MIN_SIZE X" genug Speicher vorhanden ist.
Einen entsprechenden Befehl für Userfenster gibt es nicht, da EasyGem ja das Format in Ihrem Userfenster nicht bekannt sein kann und EasyGem die Datei deswegen auch nicht laden kann.

Hinweis: Wenn Ihr Computer auf 256 Farben oder weniger eingestellt ist, erzeugt EasyGem bei Gwin_Load automatisch eine Farbtabelle, die für das zu ladende PICT-Bild optimiert ist. Dadurch kann es passieren, daß andere Objekte auf dem Bildschirm sich in Ihrer Farbe veränderen.

Natürlich möchte man Dateien nicht nur laden, sondern auch speichern können. Dafür gibt es die folgenden EasyGem Befehle:


Gwin_Save Win[,X,Y,W,H],File$
Grafikfenster speichern.
Twin_Save Win[,X1,Y1,X2,Y2],Format,File$
Textfenster speichern.
Uwin_Save Win[,X,Y,W,H],File$
Userfenster speichern.

Diese Befehle ermöglichen es Ihnen, den Inhalt eines virtuellen Fensters oder bei Angabe von X,Y,W,H bzw. X1,Y1,X2,Y2 einen beliebigen Ausschnitt davon in eine Datei zu speichern. Die Koordinaten sind bei Gwin_Save und Uwin_Save in Pixeln auf dem virtuellen Bildschirm und bei Twin_Save in Buchstaben anzugeben. In File$ muß wieder ein FileSpecificationRecord übergeben werden.
Bei Grafik- und Userfenstern wird eine Datei vom Typ
'PICT' erzeugt, während bei Textfenstern der Dateityp 'TEXT' benutzt wird.
Bei Textfenstern muß in
Format zusätzlich noch ein Flag übergeben werden, das festlegt, ob die Datei im Apple-Format (Format=0) oder im DOS-Format (Format=1) gespeichert wird.

Besonders hohe Ansprüche an die Programmierkunst stellt das Schreiben von Druckroutinen, da man verschiedene Dinge berücksichtigen muß. Zum Beispiel paßt häufig das Fenster nicht auf eine Papierseite und man muß es in geeigneter Weise auf mehrere Seiten verteilen. Um Ihnen diese lästigen Arbeiten zu ersparen, haben wir Prozeduren zum Ausdrucken von beliebigen Fenstern in EasyGem integriert:


Gwin_Hcopy Win[,X,Y,W,H]
Grafikfenster drucken.
Twin_Hcopy Win[,X1,Y1,X2,Y2]
Textfenster drucken.
Uwin_Hcopy Win[,X,Y,W,H]
Userfenster drucken.

Wie Sie sehen, ähneln diese Befehle sehr stark den Befehlen zum Speichern von Fensterinhalten. Bei Bedarf kann man mit X,Y,W,H bzw. X1,Y1,X2,Y2 wieder einen Bereich definieren, der gedruckt werden soll.

Die übrigen Einträge im Datei-Menü können Sie leicht selbst programmieren wie Sie an dem Beispielprogramm EasyPaint.BAS im DEMO-Ordner sehen können.


Auch für das Bearbeiten-Menü stellt EasyGem leicht zu bedienende Prozeduren zur Verfügung, die es Ihnen ermöglichen, ohne großen Programmieraufwand Ihre Programme mit gewissen Standardeigenschaften auszurüsten. Wenn Sie eine der folgenden Prozeduren aufrufen, sollten Sie danach noch ein
Win_Redraw folgen lassen (außer bei den Copy-Befehlen), damit die Änderungen auf dem virtuellen Bildschirm auch in dem realen Fenster sichtbar werden.


Gwin_Cut Win[,X,Y,W,H]
Grafikfenster ausschneiden.
Twin_Cut Win[,X1,Y1,X2,Y2],Format
Textfenster ausschneiden.

Diese Befehle ermöglichen es, ein ganzes virtuelles Fenster oder einen mit X,Y,W,H bzw. X1,Y1,X2,Y2 definierten Ausschnitt auf das Clipboard zu kopieren und anschließend auf dem virtuellen Bildschirm zu löschen. Format hat wieder die gleiche Bedeutung wie bei Twin_Save.
Für Userfenster gibt es diesen Befehl nicht, da EasyGem das Datenformat in Ihrem Userfenster nicht kennen kann und daher den markierten Bereich zwar kopieren, aber anschließend nicht löschen könnte.

Wenn Sie ein virtuelles Fenster oder einen markierten Bereich davon nur auf das Clipboard kopieren, anschließend auf dem virtuellen Bildschirm aber nicht löschen möchten, verwenden Sie am besten die folgenden Befehle:


Gwin_Copy Win[,X,Y,W,H]
Grafikfenster kopieren.
Twin_Copy Win[,X1,Y1,X2,Y2],Format
Textfenster kopieren.
Uwin_Copy Win[,X,Y,W,H]
Userfenster kopieren.

Da nach dem Kopieren nichts gelöscht werden muß, gibt es diesen Befehl auch in einer Version für Userfenster.


Nachdem wir nun die Befehle zum Ausschneiden und Kopieren kennengelert haben, kommen wir zum Gegenteil, dem Einsetzen von Bild- bzw. Textblöcken:


Gwin_Paste Win[,X,Y[,W,H]][,File$]
Bild in Grafikfenster einsetzen.
Gwin_Paste Win,X,Y,W,H,File$,Action
Bild in Grafikfenster einsetzen, mit Redraw-Funktion.
Twin_Paste Win[,X1,Y1][,File$]
Text in Textfenster einsetzen.

Mit X,Y bzw. X1,Y1 können Sie festlegen, wo auf dem virtuellen Bildschirm die Grafik bzw. der Text eingesetzt werden sollen. In File$ können Sie zusätzlich einen FileSpecificationRecord übergeben. Dann werden die Daten nicht vom Clipboard geholt, sondern aus dem spezifizierten File.
Bei Grafikfenstern haben Sie zusätzlich auch noch die Möglichkeit, die Größe des Bildes mit
W,H zu beeinflussen. Wenn Sie in W und H den Wert null übergeben, erzeugt EasyGem automatisch einen Geisterrahmen, der die Originalgröße des einzusetzenden Blocks hat und sich mit der Maus im Grafikfenster bewegen läßt. Bei Kontakt mit dem Fensterrand wird automatisch weitergescrollt. Sobald die Maustaste gedrückt wird, setzt Gwin_Paste den Block an der aktuellen Mausposition ein und kehrt zurück. Das Einzetzen des Blocks kann verhindert werden, wenn beim Drücken der Maustaste zusätzlich eine Modifier-Taste (Shift, Ctrl ...) betätigt wird.
Bei
Gwin_Paste gibt es noch eine zusätzliche Syntax mit einem weiteren Parameter. In Action können Sie die Adresse einer Action-Funktion (&FN My_Action(,,)) übergeben, die dann von Gwin_Paste ständig aufgerufen wird, während der Geisterrahmen mit der Maus über den Bildschirm bewegt wird. Diese Action-Funktion kann zum Beispiel dazu benutzt werden, die aktuelle Mausposition in der Infozeile anzuzeigen.
Die Action-Funtion muß drei Parameter haben, in denen die Fenster-Identifikationsnummer und die Mausposition auf dem viruellen Bildschirm übergeben werden:

DEF FN My_Action(Win,X,Y)

Siehe auch das Programm EasyPaint.BAS im DEMO-Ordner.
Wenn nur die Fensternummer als Parameter angegeben wird, setzt EasyGem das Bild bzw. den Text in der linken oberen Ecke des virtuellen Bildschirms ein.
Für Userfenster steht dieser Befehl aus den oben erwähnten Gründen nicht zur Verfügung.

Der letzte Befehl aus dieser Gruppe dient zum Löschen von rechteckigen Bildausschnitten in Grafikfenster bzw. Textstücken in Textfenstern und lautet:


Gwin_Clear Win[,X,Y,W,H]
Grafikfenster löschen.
Twin_Clear Win[,X1,Y1,X2,Y2]
Textfenster löschen.

Diese Befehle entsprechen in ihrer Syntax den Befehlen Gwin_Cut bzw. Twin_Cut, mit dem einzigen Unterschied, daß vor dem Löschen der Inhalt nicht auf das Clipboard kopiert wird. Auch diese Befehle gibt es nicht für Userfenster.
Auf ein gedrucktes Beispiel wollen wir an dieser Stelle verzichten, da die Verwendung dieser Befehle in dem Programm EasyPaint.BAS im DEMO-Ordner gezeigt wird.



4.15 Apple-Events

Bei einem Multitasking-Betriebssystem wie dem Mac OS ist es gelegendlich erforderlich, daß die parallel laufenden Programme untereinander Informationen austauschen. Wenn Sie z.B. eine BASIC-Datei auf das Omikron Basic Programmicon ziehen, teilt der Finder dies dem Omikron Basic mit, das daraufhin diese Datei öffnet. Das geschieht über sogenannte High-Level-Events. Eine Untergruppe dieser High-Level-Events bilden die Apple-Events, von denen jedes Programm mindestens die vier grundlegenden unterstützen sollte. Da die Auswertung recht kompliziert ist, hilft EasyGem Ihnen, diese Mindestanforderung zu erfüllen.
Dazu betrachten wir nochmal die Prozedur
Easy_Mesag:


Easy_Mesag R Entry,R Buffer$,R Ev_Msk,R Mx,R My,R Mb,
R Modifier,R Clicks,R Kbrd

Wenn ein High-Level-Event Ihrem Programm gemeldet wird, überprüft EasyGem zunächst, ob es sich um einen der vier grundlegenden Apple-Events handelt. Wenn dies der Fall ist, werden eventuelle Parameter extrahiert und an Ihr Programm weitergeleitet. Den Eventtyp erhalten Sie dabei in der Variablen Entry und die Parameter werden an Buffer$ angehängt.
Dabei gibt es folgende Möglichkeiten:

Entry =
CVIL("oapp")
Dieser Open-Application-Event hat keine Parameter und wird Ihrem Programm gleich nach dem Start geschickt. Sie können darauf z.B. mit der Öffnung eines neuen Fensters reagieren, damit der Anwender sofort nach dem Programmstart mit der Arbeit beginnen kann.
Entry =
CVIL("odoc")
Dies ist ein Open-Document-Event. Wenn Sie diese Meldung bekommen, wird von Ihrem Programm erwartet, daß es ein Dokument öffnet. Dazu wird an Buffer$ ein FileSpecificationRecord angehängt, der das File spezifiziert, das geöffnet werden soll (Fsspec$=MID$(Buffer$,17)).
Entry =
CVIL("pdoc")
Dieser Print-Document-Event bedeutet, daß Ihr Programm die Datei drucken soll, deren FileSpecificationRecord Sie ab Position 17 in Buffer$ erhalten. Eine solche Meldung erhalten Sie z.B., wenn eine Datei Ihres Programms selektiert ist und Sie im Finder 'Drucken' anklicken.
Entry =
CVIL("quit")
Dieser Event bedeutet, daß Ihr Programm beendet werden soll, z.B. weil der Anwender den Computer ausschalten will. Sie brauchen dann einfach nur Ihre Beenden-Prozedur aufzurufen.


Natürlich gibt es noch andere High-Level-Events, die von EasyGem aber nicht automatisch bearbeitet werden. Wenn Sie tiefer in die Materie einsteigen möchten, finden Sie ausführliche Informationen zu diesem Thema in dem Buch "Inside Macintosh, Interapplication Communication", aber wie gesagt, die Sache ist recht kompliziert.
Vielleicht ist Ihnen aufgefallen, daß die obige Easy_Mesag Prozedur zwei Parameter mehr hat, als die Version, die Sie von der Abfrage der Maus in Fenstern schon kennen.
Als letzter Parameter ist
Kbrd hinzugekommen. In dieser Variablen bekommen Sie Informationen über eine gedrückte Keyboard-Taste. Sie entspricht im Aufbau dem im Omikron Basic Handbuch bei INKEY$ beschriebenen String (siehe auch bei Twin_Inkey weiter oben).
Hinter
Buffer$ steht jetzt die Variable Ev_Msk. Mit dieser Event-Maske können Sie zum einen festlegen, welche Events Sie überhaupt empfangen wollen, zu anderen teilt Ihnen EasyGem darin mit, welche Ereignisse tatsächlich stattgefunden haben. Dazu ist jedem Bit entsprechend der folgenden Tabelle ein Ereignis zugeordnet.


Bit 1 Maustaste gedrückt.
Bit 2 Maustaste losgelassen.
Bit 3 Keyboardtaste gedrückt.
Bit 4 Keyboardtaste losgelassen.
Bit 5 Automatische Tastenwiederholung.
Bit 6 Fenster aktualisieren.
Bit 7 Diskette wurde eingeschoben.
Bit 8 Programm aktivieren (zum vordersten Prozess machen).
Bit 10 High-Level-Event.
Bit 15 Operating-System-Event.
 
Im allgemeinen werden Sie alle Ereignisse erfahren wollen. Dann müssen Sie vor jedem Aufruf von Easy_Mesag Ev_Msk=-1 setzen.

Die Verwendung der erweiterten
Easy_Mesag Funktion und der Apple-Events zeigen die Beispielprogramme EasyFractal.BAS und EasyPaint.BAS im DEMO-Ordner.





Referenzliste Dialog Library -blättern- Referenzliste Window Library

Inhalt | Start



© 1998-2000 Berkhan-Software
www.berkhan.de | Online bestellen