===========================================================================
= Handbuch für Caruh - den Multitasking-Manager für FutureOS - 2021.12.17 =
===========================================================================

----------------------
- Inhalteverzeichnis -
----------------------

 I. Übersicht
 I.1. Allgemeine Informationen
 I.2. Typen von Tasks
Vordergrund-Tasks
Hintergrund-Tasks
Zusammenfassung

 II. Benutzen des Taskers Caruh
 II.1. Submenue <D>atei
 II.2. Submenue earbeiten
 II.3. Submenue <O>ptionen
 II.4. Submenue <T>asks
 II.5. Submenue <H>ilfe

III. Aufbau von Caruh
III.1. Speicherbelegung der Applikation Caruh im unteren RAM
Variablen in Caruh
Einsprünge in Caruh
III.2. Speicherbelegung der Applikation Caruh im zentralen RAM
Task-Variablen
Aufbau der Speicheradresse &BE02(CCON2)
Die Task-Tabelle
Die VRAM / Multi-Bildschirm Tabelle

 IV. Aufbau eines Tasks
Aufbau eines beliebigen Tasks innerhalb seines 16 KB Block
Die Aktions- und Konfigurations-Bits

 V. Programmierung eines Tasks
Task Konventionen: Anforderungen an Tasks

 VI. OS Funktionen für Tasks
GUI und OS Funktionen von Caruh

VII. Beispiele
Einen regulären Hingergrund-Task zum Vordergrund-Task schalten
Wie kann nun ein Vordergrund-Task die Kontrolle an Caruh zurückgeben?
Reservieren von Teilen des gemeinsamen Bildschirms

----------------
- I. Übersicht -
----------------

I.1. Allgemeine Informationen
-----------------------------
Die Applikation 'Caruh' ist ein Teil des Betriebsystems FutureOS.
Caruh ist ein Tasker, das ist ein Multitasking-Manager. Oder besser gesagt ein
Programm um mehrere Applikationen (Tasks) gleichzeitig am CPC laufen zu lassen.
Die einzelnen 'Tasks' können sich dabei kooperativ verhalten.

Welche Eigenschaften hat Caruh, bzw. haben die Tasks?

- Die Applikation Caruh befindet sich im unteren RAM zwischen &0000 und &37FF.
 Der Bereich von &4000 bis &7FFF wird ebenfalls verwendet (Puffer, Tabellen)

- Caruh arbeitet in Bildschirm MODE 2, im 80 Zeichen x 25 Zeilen Modus

- Als Benutzerschnittstelle wird CBM benutzt: Caruh lässt sich also so wie die
 meisten anderen FutureOS Applikationen bedienen.

- Zusätzlich zu den Pull-Down Menüs am oberen Bildschirmrand kommt noch eine
 Task-Zeile am unteren Ende des Bildschirms.
 Dort werden mittig die Namen vierer Tasks angezeigt. Mit den Pfeilen ganz
 links und ganz rechts kann man sich horizontal durch die Namen der Tasks
 rollen.

- Die Oberfläche von Caruh bietet Funktionen um einen oder mehrere Tasks zu
 laden, speichern, löschen oder seine Priorität einzustellen.

- Die maximale Anzahl verschiedener Tasks beträgt 255 (bei 4 MB RAM Ausbau)

- Ein Task kann eine maximale Größe von 15,75 KB erreichen

- Die Tasks werden dynamisch verwaltet. Task-Nummern können sich also ändern.
 Beim Löschen eines Tasks beispielsweise werden die höheren Nummern angepasst

- Jede Task hat sein eigenes 16 KB großes Erweiterungs-RAM (E-RAM).
 Diese E-RAMs werden zwischen &4000 und &7FFF eingeblendet, dementsprechend
 wird ein Task immer an die Startadresse &4000 assembliert.

I.2. Typen von Tasks
--------------------
Es gibt Vordergrund und Hintergrund Tasks. Ein Hintergrund-Task kann durch den
Anwender als Vordergrund-Task geschalten werden - falls der Task dies erlaubt.

Vordergrund-Tasks
-----------------
Ein Vordergrund-Task ist in der Lage den gesamten Bildschirm zu übernehmen und
z.B. darauf zu schreiben. Weiterhin darf er auch die Tastatur abfragen.

Er muss auf die Taste 'ESCape' reagieren und die Kontrolle dann wieder zurück
an Caruh geben.

Jeder Vordergrund-Task ist immer auch ein Hintergrund-Task (solange er die Aus-
gabe auf den Bildschirm nicht übernommen hat).

Nur der Anwender kann einen Hintergrund-Task in den Vordergrund schalten!
Es kann nur einen Vordergrund-Task zu einer Zeit geben!

Hintergrund-Tasks
-----------------
Ein Hintergrund-Task ist lediglich dazu in der Lage auf Teile des Allgemeinen
Bildschirms zu schreiben. Dort kann er sich Bereiche reservieren.

Zusammenfassung:
----------------
1. Ein Task kann ein (reiner) Hintergrund-Task sein.
 - Er darf Teile des Allgemeinen Bildschirms reservieren und darauf schreiben
 - Er darf den kompletten Bildschirm nicht übernehmen
 - Er ist dadurch gekennzeichnet, dass in seinem E-RAM Bit 0 an Adresse &7FF8
 (TCON8) gelöscht ist

2. Ein Task kann von Caruh in den 'Vordergrund' geschalten werden.
 - Es gibt immer nur einen Vordergrund Task
 - Beim Start von Caruh ist Caruh selbst der Vordergrund-Task
 - Wird ein anderer Task zum Vordergrund-Task so darf er den gesamten
 Bildschirm nutzen. Und die Tastatur und die Joysticks.
 - Er muss allerdings auch die Kontrolle zurück geben können bei 'ESC'
 - Er ist dadurch gekennzeichnet, dass in seinem E-RAM Bit 0 an Adresse &7FF8
 (TCON8) gesetzt ist

Achtung: Um einen Task auf Vordergrund schalten zu können muss Bit 1 an Adresse
-------- &7FF8 (TCON8) gesetzt sein. Dies wird vom Task selbst erledigt.

Der Druck auf die 'ESC' Taste muss den Task wieder in den Hintergrund schalten!
Dabei wird von Caruh selbst auf ESC geprüft. Aber auch der Task muss/sollte das

----------------------------------
- II. Benutzen des Taskers Caruh -
----------------------------------

II.1. Submenue <D>atei
----------------------
<T>ask laden Hotkey: t oder T - Einen Task laden
---------------------------------------------------
Diese Funktion läd und startet einen Task. Seine Datei darf maximal 16 KB groß
sein (inklusive des Headers).

Task sei. Hotkey: p oder P - Speichern eines Tasks
--------------------------------------------------------
Diese Funktion dient dazu einen Task zu speichern, das sind immer 16 KB E-RAM.
Das Speichern auf ein beliebiges Medium erfolgt in Kooperation mit dem Task,
dadurch kann sich ein Task auf sein Abgespeichert-werden vorbereiten.
Ein gespeicherter Task kann später oder auf einem anderen Computer fortgesetzt
werden. Diese Funktion kann auch zur Fehlersuche verwendet werden.

<A>lle laden Hotkey: a oder A - Startet alle markierten Dateien als Tasks
----------------------------------------------------------------------------
Diese Funktion läd und started mehrere markierte Dateien auf einmal. Sie werden
als Tasks eingebunden.
Normalerweise würde man die entsprechenden Dateien zuerst im FutureOS Turbo
Destiop markieren. Anschließend können sie alle mit dieser Funktion geladen und
gestartet werden.
Auf diese Art kann man seine persönliche Auswahl an Tasks direkt starten.

<S>pei. Tab. Hotkey: s oder S - Speichert die 16 KB Task-Tabelle
-------------------------------------------------------------------
Diese Funktion speichert die 16 KB des Hauptspeichers (&4000 bis &7FFF).
Dieser Bereich enthält die Task-Variablen, die Task-Tabelle und die VRAM
Tabelle.
Ja, diese Funktion dient der Fehlersuche ;-) :-)

DIRs lese<n> Hotkey: n oder N - Lesen aller DIRs von markierten Medien
-------------------------------------------------------------------------
Hier kann man Laufwerke / Medien / Geräte auswählen und anschließend ihre DIRs
(Inhaltsverzeichnisse) einlesen. Dadurch kann von diesen Medien geladen und auf
sie gespeichert werden.

S<c>hließen Hotkey: c oder C - Beende alle Tasks und Caruh selbst
---------------------------------------------------------------------
Diese Funktion beendet und löscht alle Tasks, die zuvor benutzten E-RAMs werden
frei gegeben. Die Applikation Caruh wird beendet.

<V>ersion Hotkey: v oder V - Zeigt die Versionsnummer von Caruh
---------------------------------------------------------------------
Hier wird die Version von Caruh angezeigt, und das Datum der letzten Änderung.

eenden Hotkey: b oder B - Beende alles Tasks. Beende die Applikation
-----------------------------------------------------------------------------
Siehe 'S<c>hließen' zuvor

II.2. Submenue earbeiten
---------------------------
<L>oeschen Hotkey: l oder L - Lösche Task = 'eende Task' (siehe unten)
------------------------------------------------------------------------------
Diese Funktion beendet einen Task. Das von ihm genutzte E-RAM wird freigegeben

Gehe zu <o> Hotkey: o oder L - Gehe zu Task = 'Schalte <a>uf' (siehe unten)
-------------------------------------------------------------------------------
Diese Funktion schaltet einen Task in den Vordergrund, wenn dies dem Task auch
möglich ist.

<A>ufruf OS Hotkey: a oder A - Desktop aufrufen, Rückkehr mit OK Icon
-------------------------------------------------------------------------
Mit dieser Funktion kann der Anwender das Turbo Desktop des FutureOS temporär
aufrufen.
Im Desktop können nun beliebige Aufgaben erfüllt werden, z.B. Dateien markieren
Aber man muß das 'OK' Icon benutzen um zum Task Manager Caruh zurück zu kehren!

II.3. Submenue <O>ptionen
-------------------------
<M>ode Hotkey: m oder M - Selektiere den MODE 0-3 für Tasks
--------------------------------------------------------------------
Hier kann der User den Bildschirm-Modus (0-3) für die Tasks auswählen.
Ja, auch MODE 3 wird unterstützt, der wohl kaum Anwendung finden wird.
Allerdings wird Caruh selbst immer in MODE 2 arbeiten.

<F>arben Hotkey: f oder F - Wähle Farben für BORDER, PAPER und PENs
--------------------------------------------------------------------------
Die Farbe für BORDER, PAPER und die PENs 0-15 kann hier gewählt werden.
Diese Auswahl gilt für Caruh und alle aktiven Tasks.

F<o>rmat Hotkey: o oder O - Wähle das Bildschirm-Format (80x25, 64x32)
-----------------------------------------------------------------------------
Für aktive Tasks kann hier ein Bildschirm-Format ausgewählt werden.
Diese Auswahl hat jedoch keinen Einfluß auf das Interface von Caruh's selbst.

<S>prache Hotkey: s oder S - Selektiere eine Sprache für die Tasks
------------------------------------------------------------------------
Dieser Punkt erlaubt es die Sprache von FutureOS einzustellen. Die so gewählte
Sprache findet sich in der Konfigurations-Variable KF_CPC (&B976) in den Bits:
5,4,3 = 000 ==> OS Anwender spricht Deutsch
 = 001 ==> Franzoesich
 = 010 ==> Englisch
 = 011 ==> Griechisch
 = 100 ==> Spanisch
 = 101 ==> Hollaendisch
Jeder Task kann lesen welche Sprache selektiert wurde. Caruh selbst jedoch wird
seine Sprache nicht ändern, denn das würde zu viel Speicher kosten.
Statt dessen existieren Versionen von Caruh in jeder der obigen Sprachen.

II.4. Submenue <T>asks
----------------------
<S>tarte Task Hotkey: s oder S - Task laden und starten
---------------------------------------------------------
Siehe '<T>ask laden' zuvor

eende Task Hotkey: b oder B - Task beenden, E-RAM freigeben
----------------------------------------------------------------
Siehe '<L>oeschen' zuvor

rioritaet Hotkey: p oder P - Setze die Priorität eines Task auf 1-255
---------------------------------------------------------------------------
Diese Funktion setzt die Priorität eines Tasks auf einen Wert von 1 bis 255.
Je kleiner die Nummer ist, desto höher ist die Priorität des Tasks, sie
entspricht in etwas 1/300 Sekunde Wartezeit.

Schalte <a>uf Hotkey: a oder A - Schalte Task in den Vordergrund
------------------------------------------------------------------
Siehe 'Gehe zu <o>' zuvor

II.5. Submenue <H>ilfe
----------------------
<H>ilfe Hotkey: h oder H - Zeigt einen Hilfsbildschirm
--------------------------------------------------------------
Nur eine Hilfsbildschirm zur Benutzung.

nfo Hotkey: i oder I - Zeigt (momentan noch) die Versionsnummer
---------------------------------------------------------------------------
Siehe '<V>ersion' zuvor

<N>eues Hotkey: n oder N - Zeigt (momentan noch) die Versionsnummer
---------------------------------------------------------------------------
Siehe '<V>ersion' zuvor

<M>enue Hotkey: m oder M - Informationen zum CBM Menue-System
---------------------------------------------------------------------
Hier werden Informationen zum CBM Menue-System gezeigt, welches Caruh als
Rahmen dient.

-$<$>$- Hotkey: $ oder 4 - Geld für dieses Projekt spenden
------------------------------------------------------------------
Niemand hat auch nur einen Pfennig für meine Arbeit gespendet.
Also lassen wir das ... ;-)

.w<w>w. Hotkey: w oder W - Wo man Unterstützung im Internet findet
--------------------------------------------------------------------------
Dies ist Dein Weg zur FutuerOS Heimseit und damit auch zur Hilfe für Caruh :-)

-------------------------
- III. Aufbau von Caruh -
-------------------------

III.1. Speicherbelegung der Applikation Caruh im unteren RAM
------------------------------------------------------------
Der Programm-Kode von Caruh befindet sich ab &0000 im RAM und erstreckt sich
momentan bis etwas &2000.
Ab Adresse &3800 befindet sich (wie üblich) der Zeichensatz bis zu &3FFF.
Es stehen also noch etwa 5-6 KB für zukünftige Erweiterungen von Caruh zur
Verfügung.
Im unteren RAM befinden sich relativ wenig Variablen, da es geplant ist Caruh
eventuell eines Tages als Lower ROM zu integrieren.
Es existieren jedoch einige für den Programmierer und seine Tasks interessanten
Einsprünge.

Variablen in Caruh
------------------
- Speicheradresse &000E enthält den Bildschirm Modus (0-3) der vom Benutzer mit
 Hilfe von Caruh eingestellt wurde.
 Jeder Task kann den gewünschten Bildschirm-Modus aus diesem Byte lesen, falls
 der Task in den Vordergrund geschalten wird.

- Speicheradresse &000F enthält das Bildschirm Format, das der Anwender mittels
 Caruh eingestellt hat (0 für 80x25, 1 für 68x30 und 3 für 64x32 Format).
 Jeder Task kann das gewünschte Bildschirm-Format aus diesem Byte lesen, falls
 der Task in den Vordergrund geschalten wird.

Einsprünge in Caruh
-------------------
- An der RAM Adresse &0003 kann die Funktion 'SAOMS' aufgerufen werden.
 Sie erlaubt es dem Anwender ein Stück des Multi-Bilschirms (normale Ansicht)
 zu reservieren.

- An Adresse &0008 kann das von CBM her bekannte Menu-System 'M_DISP2' durch
 den Befehl 'RST 1' aufgerufen werden.

- An Adresse &000B kann der von CBM her bekannte Fenster-Rahmen-Zeichner
 'DR_WIN' durch 'CALL &000B' aufgerufen werden.

- An Adresse &0010 ruft man die Funktion 'SEPRI' mittels des Z80 Befehls
 'RST 2' auf. Mit 'SEPRI' kann ein Task seine Priorität ändern.
 Jeder Task wird nach dem Laden mit der höchsten Priorität '1' gestartet.
 Es sind Werte von 1 bis 255 zulässig. Kleinere Werte haben höhere Priorität.

- An Adresse &0013 ruft man die Funktion 'RFMSA' mittels des Befehls
 'CALL &0013' auf. 'RFMSA' dient dazu einem Task ein Stück des gemeinsamen
 Bildschirms zu reservieren. Damit ist die Ansicht gemeint, die nach dem Start
 von Caruh zu sehen ist. Der Task darf dann in diesen Bereich schreiben.

III.2. Speicherbelegung der Applikation Caruh im zentralen RAM
--------------------------------------------------------------
Das zentrale RAM (Hauptspeicher, I/O: &7FC0) wird von &4000 bis &7FFF wie folgt
belegt. Es existieren drei RAM Abschnitte die zur Task-Verwaltung dienen:

- Task Variablen (diese sind im ersten Element der Task-Tabelle enthalten)
(beziehungsweise im oberen RAM)

- Task Tabelle (diese enthält ein Element für jeden Task von 1-255)

- VRAM Tabelle (diese definiert welcher Task welchen Teil des Bildes nutzt)

Task-Variablen
--------------
Die Task-Variablen dienen Caruh zur Verwaltung der einzelnen Tasks, sie zeigen
was sich aktuell abspielt.

- &4000(TASK_AKT): Dieses Byte zeigt auf die Nummer des gerade aktiven Tasks

- &4001(TASK_NUM): Dieses Byte enthält die Anzahl aller vorhandenen Tasks

- &4002(DIS_A_T): Dies Byte enthält die Nummer des ersten Tasks der Task-Zeile
 Damit ist die unterste Zeile von Caruh gemeint (Task links)

- &400C/D(TA_ESEL): Diese 16 Bit enthalten den I/O E-RAM Select, wenn ein neuer
 Task ins E-RAM geladen wird

- &400E/F(TA_OSEV): Diese 16 Bit enthalten einen Zeiger auf eine der XRAM_??
 Variablen, wenn ein neuer Task ins E-RAM geladen wird

- &4010: Hier beginnt das erste Element von Task#1 (16 Bytes)
 In Source-Code von Caruh wäre das 'TT_START + T_T_E_L'.
Wobei sich TT_START(=&4000) + T_T_E_L(=&0010) = &4010 ergibt!

- &7FE4-&7FFF: Dieser Bereich wird für Caruh selbst (als Task #1) benötigt!

Im oberen RAM werden zwei weitere Bytes von Caruh benutzt!
Sie dienen der Kommunikation zwischen Caruh und den Tasks:

- &BE02 (CCON2): Zentrales Kommunikations-Byte zwischen Caruh und den Tasks

Aufbau der Speicheradresse &BE02(CCON2)
---------------------------------------
- Bit 0: = 0 -> Alle Tasks sind im Hintergrund (das ist der Normalzustand)
In diesem Fall fungiert Caruh als Vordergrund-Task
= 1 -> Ein Task ist im Vordergrund aktiv, d.h. übernimmt Bildschirm,
 Tastaturabfrage etc.
Dieses Bit wird vom Task selbst eingeschalten, sobald der aktiv
die Kontrolle über den Bildschirm etc. übernommen hat.
Dieses Bit MUSS aber auch vom dem Task selbst wieder gelöscht
werden, sobald der die Kontrolle über den Bildschirm wieder an
Caruh zurückgibt.
Beim Drück auf die ESC-Taste muss der Task den Bildschirm etc.
wieder an Caruh zurückgeben. Dazu wird Bit 0 an &BE02 gelöscht.

- Bit 1: -> reserviert
- Bit 2: -> reserviert
- Bit 3: -> reserviert
- Bit 4: -> reserviert
- Bit 5: -> reserviert
- Bit 6: -> reserviert

- Bit 7: = 0 -> Caruh gibt momentan keine Zeichen aus. -> Tasks laufen Normal
= 1 -> Caruh gibt gerade Text auf dem Bildschirm aus. Beispielsweise
werden Menüs dargestellt, Dateien oder Optionen ausgewählt etc.
-> Die Tasks dürfen NICHTS am Bildschirm darstellen!

- &BE03 (TTNS3): Tempörärer Task-Nummern-Speicher an &BE03
Speichert die Nummer eines Tasks (2-255) für Unterprogramme

Die Task-Tabelle
----------------
Die Task-Tabelle beginnt rechnerisch ab &4000 im Hauptspeicher.
Ein Eintrag der Task-Tabelle ist 16 Bytes lang.
Dementsprechend reicht sie also von &4000 bis &4FFF im zentralen RAM (&7FC0).

Das erste Element der Task-Tabelle mit Nummer '0' ist jedoch speziell belegt:
Da es keinen Task mit der Nummer &00 gibt stehen die Bytes &4000-&400F für die
Task Variablen (Siehe oben unter 'Task-Variablen') zur Verfügung.

Das erste reale Element beginnt also ab &4010 für den ersten Task (#1).

Jedes Element besteht aus 16 Bytes:

0...: Task-Nummer (= Nummer des Tasks der durch diesen Eintrag verwalted wird)
1...: Priörität: Wie viele 1/300 Sekunden wird gewartet bis der Task erneut
 aufgerufen wird. Der Wert 0 wird hierbei als 256 interpretiert.
 Je kleiner der Wert ist, desto höher ist die Task-Priorität.
2...: Wiederlade-Wert für das Prioritäts-Byte, sobald das Prioritäts-Byte den
 Wert &00 erreicht hat (siehe Byte 1)
3- 4: Diese 16 Bit enthalten das E-RAM in dem sich der Task befindet
 (16 Bit, physikalische I/O-Adresse: &7FC4-&78FF, deckt 4 MB ab)
5-15: Der Namen des Tasks, er entspricht dem Dateinamen (11 Buchstaben)

Ab Adresse &4020 folgen die Daten für Task #2, am &4030 für Task #3, an &4040
für Task #4 und so weiter...

Die VRAM / Multi-Bildschirm Tabelle
-----------------------------------
Solange Caruh als Vordergrund Task aktiv ist können andere Tasks lediglich
Teile des Allgemeinen Bildschirms nutzen. Das ist der Bildschirm, der nach dem
Start von Caruh mit seinem Menüsystem angezeigt wird.
Solange der 'Allgemeine Bildschirm' genutzt wird ist folgendes möglich:

- Jeder Task kann sich Teile des VRAMs / Allgemeinen Bildschirms reservieren
- Jeder Task darf auf für ihn reservierte Teile des Allgemeinen Bildschirms
 schreiben, zeichnen oder auf andere Weise Daten ausgeben
- Dabei werden keine chaotischen, überlappenden Fenster genutzt!

So ist es also möglich, dass alle Tasks auf dem Hauptbildschirm Daten ausgeben.
Das ist der Multi-Bildschirm-Modus.

Um den Bildschirm (80 Zeichen auf 25 Zeilen) aufzuteilen gibt es die VRAM- bzw.
Multi-Bildschirm-Tabelle. Diese Tabelle umfasst 2000 Bytes (= 80 * 25).

Die Tabelle liegt im Hauptspeicher von &7800 bis zu &7FCF.
Die Bytes von &7FD0 bis &7FFF sind dementsprechend NICHT Teil der Tabelle.

Jedes Byte der VRAM (Multi-Bildschirm) Tabelle entspricht einem Zeichen auf dem
Bildschirm.

Dabei beginnt die Tabelle beim ersten Zeichen in der obersten Zeile ganz links.
Es folgen Zeichen um Zeichen der ersten Zeile von Links nach Rechts.
Anschließend folgen Zeile für Zeile von oben nach unten.

Welche Bedeutung haben die Bytes in der VRAM Tabelle?
-----------------------------------------------------
Ein Null-Byte in der Tabelle definiert dabei eine verfügbare Bildschirmposition
und ist somit für Tasks verfügbar.

Ist ein Byte der Tabelle von einem Wert(1-255) belegt, so ist die entsprechende
Position auf dem Bildschirm bereits von einem Task belegt.

Caruh belegt dabei die obersten vier Zeilen und die unterste Zeile für sein
Menü-System und die untere Task-Bar.

--------------------------
- IV. Aufbau eines Tasks -
--------------------------
Die Einsprung / Start / Ladeadresse eines jeden Tasks ist immer Adresse &4000
Die Dateilänge darf maximal 16 KB betragen (inclusive eines Headers!)

Jeder Task belegt einen 16 KB Block (E-RAM Block) von &4000 bis &7EFF.
Aktuell werden dafür die ersten 512 KB Erweiterungs-Speicher genutzt.
Es sollen jedoch schon bald die vollen 4 MB E-RAM genutzt werden (->Update2025)

Aufbau eines beliebigen Tasks innerhalb seines 16 KB Block:
-------------------------------------------------------------------------------
- &4000-&7EFF: Programm-Bereich - --> Applikationslänge maximal 15,75 KB
-------------------------------------------------------------------------------
- &7F00-&7FF7: Stack (jeder Task hat seinen eigenen Stack). 124 Elemente.
-------------------------------------------------------------------------------
- &7FF8-&7FF9: (TCON8 und TCON9) 16 Aktions- und Konfigurations-Bits
 Bitte sehen Sie sich dazu den folgenden Abschnitt an :-)
-------------------------------------------------------------------------------
- &7FFA-&7FFB: (TER16) 16 Bit E-RAM Auswahl des Tasks (&7FC4-&78FF)
-------------------------------------------------------------------------------
- &7FFC......: (TAPRI) Wert der aus der Teilzeit-/Prioritäts Variable der Task-
 Tabelle kopiert wird (bei Änderung der Priörität)
 (Also wie viele 1/300 Sekunden vor Task-Aufruf gewartet wird)
 Es handelt sich um das Prioritäts-Byte
-------------------------------------------------------------------------------
- &7FFD......: (TNUME) Nummer des Tasks &01-&FF (255 mögliche Tasks).
 Die Tasks sind dynamisch! (Variablen-Name in Caruh: TNUME)
-------------------------------------------------------------------------------
- &7FFE-&7FFF: (TSPSE) Puffer für den Stack-Pointer SP dieses Tasks.
 Beim Umschalten der Tasks wird auch SP gesichert.
 -> Das zu ladende Programm (ohne Header) ist also maximal &3F00 Bytes lang.
 -> Das zu ladende Programm (mit Header) ist also maximal &3F80 Bytes lang.
-------------------------------------------------------------------------------

Beim ersten Start eines Tasks wird sein Spackpointer (SP) auf &7FF8 gesetzt.
-> So wird das erste 16 Bit Stack-Element in die Adressen &7FF6 und &7FF7
 geschrieben.
 Dies ist üblicherweise die Rücksprung-Adresse bei der Task-Umschaltung.

Die Aktions- und Konfigurations-Bits
------------------------------------
Die Speicherstellen &7FF8 und &7FF9 eines jeden Tasks enthalten 16 Aktions- und
Konfigurations-Bits. Dazu kommen Reaktions-Bits, die vom Task gesetzt werden:

Speicheradresse &7FF8 (TCON8)
-----------------------------
Bits die mit einem '=' gekennzeichnet sind werden vom Task gesetzt und
Bits die mit einem '-' gekennzeichnet sind werden von Caruh gesetzt.
Bits die mit einem '*' gekennzeichnet sind werden sowohl von Caruh als auch vom
Task selbst manipuliert. Siehe gesonderte Abschnitte.

* Bit 0: = 0 -> Task ist im Hintergrund (das ist der Normalzustand)
= 1 -> Task ist im Vordergrund aktiv, d.h. übernimmt Bildschirm,
 Tastaturabfrage etc. Dieses Bit wird von Caruh eingeschalten.
Es wird/kann aber vom Task gelöscht werden.
(Foreground-Bit)

= Bit 1: = 0 -> Task kann kein Vordergrund-Task werden
= 1 -> Task kann als Vordergrund-Task geschalten werden
Dieses Bit muss vom Task selbst gesetzt werden!
(Switch-Bit)

- Bit 2: -> reserviert

= Bit 3: = 0 -> Normale Funktion -> Task arbeitet normal weiter...
= 1 -> Setzen dieses Bits bestimmt den Task zur Löschung!
Dieses Bit wird von dem Task selbst gesetzt!
(Kill-Bit)

= Bit 4: = 0 -> Der Task kann nicht gespeichert werden bzw. muss nicht extra
mittels dem 'Save-Bit 7' darauf vorbereiter werden.
= 1 -> Dieser Task kann gesichert werden und sollte mittels des Bits 7
darauf vorbereitet werden.
Dieses Bit wird von dem Task selbst gesetzt!
(Storable-Bit)

* Bit 5: = 0 -> Der Task wurde bisher nicht gespeichert
= 1 -> Der Task wurde gespeichert, nachdem das Save-Bit gesetzt wurde.
Dieses Bit 5 wird vom System Caruh gesetzt, nach dem Sichern.
(Das Hold-Bit 6 wurde zuvor vom Task selbst gesetzt)
Dieses Bit 5 muss von dem Task selbst zurück gesetzt werden,
wenn der Task mehrmals gesichert werden soll.
(Secured-Bit)

= Bit 6: = 0 -> Task ist weiterhin in Arbeit -> nicht abspeichern! Warten!
= 1 -> Task kann jetzt vom System jederzeit gespeichert werden
Dieses Bit muss von dem Task selbst gesetzt werden!
(Hold-Bit)

- Bit 7: = 0 -> Normaler Ablauf. Der Task läuft...
= 1 -> Das System verlangt vom Task sich auf sein Abspeichern
vorzubereiten. Sein Neustart erfolgt dann wieder an &4000
(Save-Bit)

-------------------------------------------------------------------------------

Speicheradresse &7FF9 (TCON9)
-----------------------------
- Bit 0: -> reserviert für zukünftige Erweiterungen
- Bit 1: -> reserviert
- Bit 2: -> reserviert
- Bit 3: -> reserviert
- Bit 4: -> reserviert
- Bit 5: -> reserviert
- Bit 6: -> reserviert
- Bit 7: -> reserviert

-------------------------------------------------------------------------------

---------------------------------
- V. Programmierung eines Tasks -
---------------------------------

Um einen Task zu programmieren sind bestimmte Konventionen einzuhalten. Hierbei
gelten strikte Regeln, die in jedem Falle einzuhalten sind.

Jedoch stellt Caruh den Tasks auch hilfreiche Funktionen zur Seite.
Dazu siehe später unter VI.

Task Konventionen: Anforderungen an Tasks
-----------------------------------------
- Tasks müssen ihre Erweiterungs-RAM (E-RAM) Konfiguration beibehalten
 Jeder Task kann seinen eigenen RAM-Banking-Status aus den Adressen &7FFA und
 &7FFB lesen. Z.B. durch einen LD BC,(TER16). Solle trozdem illegales Banking
 durchgeführt werden, so sind hierfür die Interrupts abzuschalten.

- Tasks müssen den ROM/RAM Status beibehalten (Das obere ROM ist immer ein).
 Müssen z.B. Daten aus dem Bildschirmspeicher gelesen werden, so sind hierfür
 die Interrupts zeitweilig auszuschalten. Status des unteren ROMs beachten!

- Ein Task darf maximal 15,75 KB lang sein, denn oberhalb befinden sich Stack
 und Task-Variablen (siehe oben: 'Aufbau eines Tasks')

- Tasks benötigen keinen Header, das sie immer an Adresse &4000 geladen werden
 Tasks, die einen Header besitzen dürfen inclusive des Headers nicht größer
 als 16 KB sein.

- Tasks / Dateien größer als 16 KB werden von Caruh NICHT geladen / gestartet

- Ein Task darf nur auf den Bildschirm ausgeben, wenn in Caruh-Variable CCON2
 (an Adresse &BE02) die Bits 0 und 7 beide gelöscht sind.
 Ausnahme: Ein Task hat selbst das Bit 0 gesetzt und ist so im Vordergrund.

- Während des Aufruf von OS Funktionen die auf die Hardware zugreifen müssen
 die Interrupts AUS und anschließend wieder EINgeschaltern werden.
 Selbiges gilt auch für den direkten Zugriff auf I/O Adressen.

- Während des Aufruf von OS Funktionen die den Stackpointer SP nutzen müssen
 die Interrupts AUS und anschließend wieder EINgeschaltern werden. Beispiel:

DI ;Interrupts ausschalten
CALL CUR_CPY ;OS Funktion aufrufen, die SP verändert
EI ;Anschließend Interrupts einschalten

 Entsprechende OS Funktionen sind in ROM A:
 - CUR_CPY
 - B8DIN
 - B16DIN
 - und alle TERM_2(?) OS Funktionen (wegen der Steuerzeichen!)
 -> Siehe dazu folgendes...

- Die Zeichenausgabe nutzt die OS Variable C_POS um die Cursor-POSition zu
 definieren. Will ein Task nun Text ausgeben, so ist diese Variable zuerst zu
 sichern, dann für die aktuelle Textausgabe zu setzen (dann Text ausgeben) und
 anschließend ist C_POS wieder zu restaurieren. Während dieser Zeit müssen die
 Interrupts natürlich ausgeschalten werden. Hier ein Beispiel

C_POS EQU &B848
;
DI ;Interrupts ausschalten
;
LD HL,(C_POS) ; / Alte Cursor-POSition sichern
 LD (Puffer),HL ;/
;
LD HL,&BFFF + (Zeile * 80) + Spalten ; / Cursor-POSition setzen
LD (C_POS),HL ;/
;
LD HL,Text ;Zeiger auf den auszugebenden Text
CALL TERM_2 ;OS Funktion aufrufen, die Zeichen ausgibt
;
LD HL,(Puffer) ; / Alte Cursor-POSition restaurieren
 LD (C_POS),HL ;/
;
EI ;Anschließend Interrupts einschalten

- Das OS ROM A muss immer eingeblendet bleiben!
 Wird das ROM geändert oder eine OS Funktion in den anderen OS ROMs B, C, D
 aufgerufen so müssen die Interrupts AUS und anschließend wieder
 EINgeschaltern werden. Siehe Beispiel:

DI ;Interrupts ausschalten
LD IX,LESC ;OS Funktion liegt in ROM C -> Namen in IX laden
CALL ROM_A2C ;OS Funktion in ROM C aufrufen
EI ;Anschließend Interrupts einschalten

- Kooperative Tasks können zum nächsten Task weiterschalten, solange sie keine
 Aufgaben haben (z.B. Warten auf ein Ereignis etc.)
 Dies geschieht durch die Befehle:

DI ;Interrupts ausschalen
RST 7 ;Interrupt-Eingang aufrufen

 Dabei ist der 'DI' Befehl nötig, um einem zeitgleich auftretendem Interrupt
 entgegen zu wirken. Ohne 'DI' könnte es zu fatalen Folgen kommen.
 Nach der Abarbeitung des 'RST 7' werden die Interrupts wieder eingeschalten.
 Die Befehlsfolge 'DI:RST 7' entspricht somit einem System-Interrupt.

- Jeder Task muss einige Bit der Aktions- & Konfigurations-Bits selbst setzen.
 Diese befinden sich in den Speicherstellen &7FF8 und &7FF9 (siehe oben!).

- Vollschirm-fähige Tasks sind fähig, den gesamten Bildschirm nutzen können.
 Solche Tasks haben in ihrem E-RAM selbst das Bit 1 (Switch-Bit) der Adresse
 &7FF8 gesetzt.
 Alle anderen Tasks (z.B. ohne Bildschirmausgabe) sollen dieses Switch-Bit
 löschen.
 Jeder Vollschirm-Task sollte das Bit 0 (Foreground-Bit) an der Adresse &7FF8
 regelmäßig lesen. Denn wenn es gesetzt ist, dann steht dem Task der gesamte
 Bildschirm zur Verfügung.
 Sollte die Taste 'ESC' gedrückt werden, dann sollte sich der Task wieder in
 den Hintergrund schalten. Dies geschieht durch das Löschen des Bits 0 an der
 Adresse &7FF8 im Task E-RAM.

- Will sich ein Task selbst beenden und aus dem System entfernen so setzt er
 das Bit 3 (Kill-Bit). Das System wird den Task bei Zeiten löschen.
 --> Konkret heißt das der Task schreibt den Wert &08 an Adresse &7FF8 und
 kann denn den Task Manger aufrufen mittels 'DI:RST 7'.
 Anschließend solle ein Sprung auf den vorigen 'DI' Befehl folgen:

 LOOP DI ;Interrupts aus, das ist vor JEDEM RST 7 nötig!
RST 7 ;Caruh (bzw. nächsten Task) aufrufen...
JR LOOP ;Warten auf Terminierung des Tasks durch Caruh

- Speicherbare Tasks sind Tasks die mit dem System zusammenarbeiten um eine
 Kopie von ihnen abzuspeichern. Um dem System anzuzeigen, dass es sich um
 einen Speicherbaren Task handelt setzt der Task selbstständig das Bit 4
 (Storable-Bit) an der Adresse &7FF8 in seinem eigenen E-RAM.
 Tasks die keinen Wert darauf legen gespeicher werden zu können sollten bei
 ihrem Aufruf einmal dieses Bit 4 löschen.
 Ein Speicherbarer Task sollte regelmäßig überprüfen, ob das System ihn jetzt
 speichern will. Dies ist der Fall wenn Caruh das Bit 0 (Save-Bit) setzt.
 Sobald also das Save-Bit an Adresse &7FF8 gesetzt wurde sollte der Task alle
 nötigen Schritte unternehmen um sich auf das Speichern vorzubereiten.
 Ist das Task bereit gesichert zu werden, dann muss der das Bit 6 (Hold-Bit)
 an Adresse &7FF8 setzen.
 Anschließend findet das Speichern des Tasks statt, darüm kümmert sich Caruh
 selbst.
 Sobald der Task erfolgreich von Caruh gesichert wurde, setzt Caruh das Bit 5
 (Secured-Bit) an E-RAM Adresse &7FF8.
 Dem Task ist nun bekannt, das er erfolgreich gespeichert wurden, das sollte
 nun das 'Secured-Bit' zurücksetzten und nach Adresse &4000 springen.
 Vom System Caruh gesicherte Tasks werden (wie jeder andere auch) an Adresse
 &4000 geladen und auch dort gestartet

-------------------------------
- VI. OS Funktionen für Tasks -
-------------------------------
Der Tasker Caruh stellt Tasks mehrere OS Funktionen zur Verfügung.
Weiterhin können gewisse Parameter in RAM Variablen abgefragt werden.
Bitte sehen Sie sich dazu das obige Kapitel über Variablen an.

GUI und OS Funktionen von Caruh
-------------------------------
Sowohl Bildschirm Modus als auch Bildschirm Format können durch den Anwender in
Caruh eingestellt werden. Dies geschieht unter Optionen. Diese Einstellungen
können aus folgenden RAM-Variablen gelesen werden:

- Speicheradresse &000E enthält den Bildschirm Modus (0-3) der vom Benutzer
 eingestellt wurde.
 Jeder Task kann den gewünschten Bildschirm-Modus aus diesem Byte lesen, falls
 der Task in den Vordergrund geschalten wird.

- Speicheradresse &000F enthält das Bildschirm Format (0 für 80x25, 1 für 68x30
 und 3 für 64x32 Format) das vom Benutzer eingestellt wurde.
 Jeder Task kann das gewünschte Bildschirm-Format aus diesem Byte lesen, falls
 der Task in den Vordergrund geschalten wird.

- MENÜ AUFRUFEN
 Das von CBM her bekannte Menu-System 'M_DISP2' kann durch den Befehl 'RST 1'
 aufgerufen werden. Parameterübergabe siehe Source Code. #######

- RAHMEN / FENSTER ZEICHNEN
 Der von CBM her bekannte Fenster-Zeichner 'DR_WIN' kann durch 'CALL &000B'
 aufgerufen werden.
 Parameterübergabe beim Aufruf:
 HL = Zeiger auf Start des Parameter- und Text-Blocks
 Aufbau eines derartigen Blocks:

DB LOCATE_YY ;Oberste Zeile
DB LOCATE_XX ;Erste Spalte links
;
DB ZEILEN ;Anzahl der Zeilen innerhalb des Rahmens/Fensters
DB SPALTEN ;Anzahl der Spalten nebeneinander
;
DB "Beispiel Text",&00 ;Text der ersten Zeile, mit Byte &00 abgeschlossen
;
;... Nun folgt der Text der weiteren Zeilen...
; Jede Zeile muss mit Byte &00 beendet werden!
; Der Text darf Kontrollkodes für Bildschirm MODE 2 enthalten
; Zum Beispiel den LOCATE Kontrollkode für das 80x25 Format:
; DB &1F,YY,XX,"Text Probe",&00

ACHTUNG: DR_WIN an &000B schaltet die Interrupts AUS.
-------- Der aufrufende Task muss die Interrupts selbst wieder einschalten.

- BELIEBIGES BILDSCHIRM-AREAL RESERVIEREN
 Der Aufruf der Funktion 'SAOMS' an Adresse &0003 erlaubt es dem Anwender ein
 Stück des Allgemeinen Multi-Bilschirms (normale Ansicht) zu reservieren.
 Aufgerufen muss diese OS Funktion dabei von einem Task werden.
 Parameterübergabe siehe 'CAR-SUB2.MAX':
 - Task-Nummer in TTNS3 = &BE03
 (Ein Task kann seine Nummer aus Adresse TNUME = &7FFD lesen)
 - YL = Anzahl aller Spalten der zu reservierenden Fläche (Breite, MODE 2)
 - YH = Anzahl aller Zeilen der zu reservierenden Fläche (Höhe)
 Rücksprung der Funktion:
 Return from function:
 Zuerst sollte man das Z-Flag analysieren, dann in Register XL und XH schauen:
 - Z-Flag gesetzt -> OS Funktion wurde durch Druck auf ESC abgebrochen!
 Die Werte in IX sind ohne Bedeutung!
 - Z-Flag geleert -> Alles ist gut!
 -> Siehe Daten in den Registern XL und XH:
 - XL = Oberste Zeile / Y Position des Rahmens (0-24)
 - XH = Spalte links / X Position des Rahmens (0-79)

- DEFINIERTES BILDSCHIRM-AREAL BEANTRAGEN
 Ruft man die Funktion 'RFMSA' mittels des Befehls 'CALL &0013' an Adresse
 &0013 auf so kann sich ein Task damit ein Stück des gemeinsamen Bildschirms
 reservieren.
 Die benötigten Parameter sind dabei folgende:
 Rücksprung der Funktion:
 - XL = Oberste Zeile / Y Position des Rahmens (0-24)
 - XH = Spalte links / X Position des Rahmens (0-79)
 - YL = Anzahl aller Spalten des Bereichs (1-80)
 - YH = Anzahl aller Zeilen des Bereichs (1-25)
 - Adresse (TTNS3=&BE03) = Nummer des beantragenden Tasks
 Beim Rücksprung gibt das Zero-Flag über den Erfolg Auskunft:
 - Z-Flag auf '0' gelöscht -> Bereiche überlappen! Kann nicht genutzt werden!
 - Z-Flag auf '1' gesetzt --> Bereich ist frei und kann genutzt werden!

####### Beide folgenden Funktionen bitte noch einbauen, sowohl in Caruh-RSTs als auch in die Doku hier #######

- VON TASK BELEGTEN BILDSCHIRMBEREICH WIEDER FREIGEBEN
 Die Funktion 'COAST' wird genutzt, um einen Teil des Multi-Bildschirms wieder
 frei zu geben. Die Funktion kann jedoch auch genutzt werden, um einen Teil
 des Bildschirms für einen Task mit definierter Nummer zu reservieren.
 Parameter:
 XL = Oberste Zeile / Y Position des Rahmens (0-24)
 XH = Spalte links / X Position des Rahmens (0-79)
 YL = Spaltenanzahl des Rahmens (1-80)
 YH = Zeilenanzahl des Rahmens (1-25)
 RAM Variable TTNS3 an Adresse &BE03 = Nummer des anfordernden Tasks

- TASK AUS VRAM TABELLE LÖSCHEN
 Die Funktion 'DTFMT' löscht alle belegten Bereiche eines Tasks in der VRAM /
 Multi-Bildschirm Tabelle. Dabei wird die zu löschende Task-Nummer im Register
 E übergeben.

- PRIORITÄT EINES TASKS ÄNDERRN
 Ruft man die Funktion 'SEPRI' mittels des Z80 Befehls 'RST 2' an Adresse
 &0010 auf so kann ein Task seine Priorität ändern (Neue Priorität in A).
 Jeder Task wird nach dem Laden mit der höchsten Priorität '1' gestartet.
 Oft muss ein Task allerdings nicht so oft aufgerufen werden (z.B Uhrzeit oder
 Temperatur anzeigen, Daten zum Drucker schicken etc.). In so einem Fall kann
 die Priorität herabgesetzt werden. Die neue Priorität wird im Akku übergeben,
 es sind Werte von 1 bis 255 zulässig. Kleinere Werte haben höhere Priorität.

- Hat ein Task aktuell nichts zu tun, so kann er aktiv zum nächsten Task weiter
 schalten. Die geschieht mittels der Befehle:

 DI ;Interrupts ausschalen (Befehl vor jedem 'RST 7' zwingend nötig!)
 RST 7 ;Task-Manager bzw. nächsten Task aufrufen

- Das Testen des Inhalts von Adresse &7FFB auf &7x erlaubt Integritätstest
 Da hier der E-RAM Status (High-Byte) gelesen wird muss das obere Nibble '7'
 sein. Ist es ungleich der '7', so wurde das Task E-RAM korrumpiert!

------------------
- VII. Beispiele -
------------------

Einen regulären Hingergrund-Task zum Vordergrund-Task schalten
--------------------------------------------------------------
Wenn ein beliebiger Hintergrund-Task zum einzigen Vordergrund-Task geschalgen
wird, dann wird die Kontrolle über den Bildschirm und die Tastatur an diesen
Task übergeben.

Dies geschieht entweder mittels der Task-Funktion 'Schalten <a>uf' oder durch
Anklicken eines der vier Task Namen in der Task-Zeile (ganz unten auf dem
Bildschirm).

Dieser Vorgang kann vom Task selbst nicht angestoßen werden. Will der Anwender
jedoch einen Task in den Vordergrund schalten, so muss dieser Task auch darauf
reagieren können!

Ablauf-Protokoll: Ein Hintergrund-Task wird ein Vordergrund-Task
----------------------------------------------------------------
-> Caruh liest und wertet Byte an Speicherstelle &7FF8 (TCON8) des Tasks aus:
 - Ist das Bit 1 gelöscht, dann kann der Task kein Vordergrund-Task werden!
 - Ist das Bit 1 allerdings gesetzt, so darf der Task als Vordergrund-Task
 geschalten werden

-> Nun wird von Caruh das Bit 0 der Speicherstelle &7FF8 (TCON8) im Task E-RAM
 auf '1' gesetzt.
 Dadurch wird dem Task mitgeteilt, dass er jetzt der Vordergrund-Task ist.
 -> Der Task muss nun die Kontrolle über den Bildschirm und die Tastatur
 übernehmen.

-> Um Caruh mitzuteilen, daß der Task die Bildschirm-Kontrolle übernommen hat,
 muß der Task das Bit 0 in der Speicherstelle &BE02 (CCON2) setzen.
 Sobald dieses Bit gesetzt ist wird Caruh die Bildschirm-Kontrolle abgeben.

=> An dieser Stelle wartet Caruh nun darauf, dass an Adresse &BE02 (CCON2) das
 Bit 0 auf '1' gesetzt wird!
 Sollte das nicht passieren, dann wird Caruh nach einiger Zeit (90* DI:RST 7)
 die Kontrolle wieder übernehmen, da der Task unfähig dazu erscheint.

=> Sobald das Bit 0 an Adresse &BE02 (CCON2) auf '1' gesetzt ist wartet Caruh
 darauf, dass es zurück gesetzt wird um die Kontrolle von neuem zu übernehmen
 => Siehe nächsten Absatz

-> Dem neu gebackenen Vordergrund-Task stehen jetzt Bildschirm und Tastatur zur
 Verfügung!
 -> Sinnvoll ist es den Bildschirm erst mal zu löschen, den Bildschirm-MODE
 einzustellen und eventuell das Bildschirm-Format.

-> Der Vordergrund-Task nimmt seinen Verlauf...
 Dabei ist es essenziell auf die Taste 'ESCape' zu testen und bei Druck von
 'ESCape' die Kontrolle an Caruh zurück zu geben.
 Wie geht das?
 Weiterlesen ... ;-)

Wie kann nun ein Vordergrund-Task die Kontrolle an Caruh zurückgeben?
---------------------------------------------------------------------
Wenn ein Task die Kontrolle über Bildschirm und Tastatur übernommen hat, dann
muss er auch testen ob die ESC Taste gedrückt wird. Ist dies der Fall, so ist
die Kontrolle wieder an Caruh zurück zu geben.
Das selbe gilt auch falls der Task die Kontrolle einfach so zurückgeben will.

-> Der Task löscht das Bit 0 an Adresse &7FF8 (TCON8) in seinem eigenen E-RAM.
 Dadurch wird der Task zum Hintergrund-Task (Normalzustand).
 Aber der Task muss das ebenfalls Caruh mitteilen! Dies geschieht so...

-> Der Vordergrund-Task löscht ebenfalls das Bit 0 an Adresse &BE02 (CCON2)!

-> Sobald das Bit 0 an Adresse &BE02 (CCON2) gelöscht ist übernimmt Caruh die
 Kontrolle von Bildschirm und Tastatur (wie zuvor gehabt).
 Der ehemalige Vordergrund-Task ist nun wieder im Hintergrund tätig.

-> Caruh ist wieder im Vordergrund :-)

Beachte: Wenn der neu ernannte Fordergrund-Task nicht in der Lage ist das Bit 0
-------- der Speicheradresse &BE02 (CCON2) auf 1 zu setzen, dann wird ihm nach
192 Zyklen (192 mal 'DI:RST 7') der Vordergrund-Status entzogen!
Das heißt nichts anderes als daß Caruh wieder die Kontrolle übernimmt.

Reservieren von Teilen des gemeinsamen Bildschirms
--------------------------------------------------
Es ist einem jeden Task möglich bestimmte Teile des Allgemeinen Bildschirms zu
beanspruchen. Dabei werden Position und Ausdehnung des beanspruchten Bereichs
übergeben. Dieses Ansinnen kann genehmigt oder abgelehnt werden, jeh nachdem ob
der beanspruchte Bereich zur Verfügung steht.
Auf diese Weise ist es möglich, dass jeder Task immer die selben Abschnitte für
sich reserviert, da er sich die Koordinaten der ersten Auswahl merken kann.
Entweder durch Sichern des Tasks, mittels nvRAM oder Konfigurations-Datei.

Der Bildschirm ist in 80 Spalten (0-79) und 25 Zeilen (0-24) eingeteilt.
Die Tabelle beginnt mit dem Zeichen ganz links in der obersten Zeile.

Beim System-Start von Caruh reserviert sich Caruh die ersten vier Zeilen (0-3)
und die unterste Zeile (24).

So kann sich ein Task einen Teil des Allgemeinen Bildschirms reservieren:

Einsprung (vom Task aus) an Adresse &0003
Parameter:
- Die Nummer des reservierenden Tasks ist in TTNS3 = Adresse &BE03 abgelegt
- Die Anzahl der MODE 2 Spalten wird in Register YL übergeben
- Die Anzahl der Zeilen wird in Register YH übergeben
 Der Befehl 'LD IY,&0309' würde also 3 Zeilen und 9 Spalten anzeigen

-> Nun wird die aktuelle Tabelle grafisch auf dem Bildschirm angezeigt
 Dabei kann jeder 'leere' Positon nur belegt werden
 Ein Kästchen - bestehend aus Linien - kann nun mittels der Cursor-Tasten
 bewegt werden und der Drück auf Copy reserviert den entsprechenden Bereich
 des Bildschirms und trägt die Position in die Multi-Bildschirm-Tabelle ein.

-> Wenn der Rahmen nicht an der aktueller Position gesetzt werden kann, so wird
 der BORDER in Orange (15) dargestellt. Entweder es wird ein gültiger Bereich
 gefunden oder durch 'ESC' abgebrochen.

-> Dem Task wird schließlich mitgeteilt, ob das Absetzen des Rahmens von
 Erfolg war.
 - Weiterhin werden X (0-79 in XL) und Y (4-23 in XH) Koordinaten übergeben,
 diese entsprechen der linken(XL), oberen(XH) Ecke im Bildschirm.
 Register IX enthält diese beiden Werte.
 - Zusätzlich wird die entsprechende Adresse der linken oberen Ecke innerhalb
 des Bildschirmes übergeben (in RAM-Variable C_POS).