
===========================================================================
= Handbuch fr Caruh - den Multitasking-Manager fr FutureOS - 2021.12.10 =
===========================================================================

----------------------
- 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 <B>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
	Einsprnge 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 fr Tasks
	GUI und OS Funktionen von Caruh

 VII.	Beispiele
	Einen regulren Hingergrund-Task zum Vordergrund-Task schalten
	Wie kann nun ein Vordergrund-Task die Kontrolle an Caruh zurckgeben?
	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' knnen 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 lsst sich also so wie die
  meisten anderen FutureOS Applikationen bedienen.

- Zustzlich zu den Pull-Down Mens 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 Oberflche von Caruh bietet Funktionen um einen oder mehrere Tasks zu
  laden, speichern, lschen oder seine Prioritt einzustellen.

- Die maximale Anzahl verschiedener Tasks betrgt 255 (bei 4 MB RAM Ausbau)

- Ein Task kann eine maximale Gre von 15,75 KB erreichen

- Die Tasks werden dynamisch verwaltet. Task-Nummern knnen sich also ndern.
  Beim Lschen eines Tasks beispielsweise werden die hheren Nummern angepasst

- Jede Task hat sein eigenes 16 KB groes 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 zurck
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) gelscht 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 zurck geben knnen 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 knnen 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 geprft. 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 ld und startet einen Task. Seine Datei darf maximal 16 KB gro
sein (inklusive des Headers).

Task s<p>ei.	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 spter 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 ld und started mehrere markierte Dateien auf einmal. Sie werden
als Tasks eingebunden.
Normalerweise wrde man die entsprechenden Dateien zuerst im FutureOS Turbo
Destiop markieren. Anschlieend knnen sie alle mit dieser Funktion geladen und
gestartet werden.
Auf diese Art kann man seine persnliche 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 enthlt 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 / Gerte auswhlen und anschlieend ihre DIRs
(Inhaltsverzeichnisse) einlesen. Dadurch kann von diesen Medien geladen und auf
sie gespeichert werden.

S<c>hlieen	Hotkey: c oder C - Beende alle Tasks und Caruh selbst
---------------------------------------------------------------------
Diese Funktion beendet und lscht 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.

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


II.2. Submenue <B>earbeiten
---------------------------
<L>oeschen	Hotkey: l oder L - Lsche Task = '<B>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
mglich ist.

<A>ufruf OS	Hotkey: a oder A - Desktop aufrufen, Rckkehr mit OK Icon
-------------------------------------------------------------------------
Mit dieser Funktion kann der Anwender das Turbo Desktop des FutureOS temporr
aufrufen.
Im Desktop knnen nun beliebige Aufgaben erfllt werden, z.B. Dateien markieren
Aber man mu das 'OK' Icon benutzen um zum Task Manager Caruh zurck zu kehren!


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

<F>arben	Hotkey: f oder F - Whle Farben fr BORDER, PAPER und PENs
--------------------------------------------------------------------------
Die Farbe fr BORDER, PAPER und die PENs 0-15 kann hier gewhlt werden.
Diese Auswahl gilt fr Caruh und alle aktiven Tasks.

F<o>rmat	Hotkey: o oder O - Whle das Bildschirm-Format (80x25, 64x32)
-----------------------------------------------------------------------------
Fr aktive Tasks kann hier ein Bildschirm-Format ausgewhlt werden.
Diese Auswahl hat jedoch keinen Einflu auf das Interface von Caruh's selbst.

<S>prache	Hotkey: s oder S - Selektiere eine Sprache fr die Tasks
------------------------------------------------------------------------
Dieser Punkt erlaubt es die Sprache von FutureOS einzustellen. Die so gewhlte
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 wrde 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

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

<P>rioritaet	Hotkey: p oder P - Setze die Prioritt eines Task auf 1-255
---------------------------------------------------------------------------
Diese Funktion setzt die Prioritt eines Tasks auf einen Wert von 1 bis 255.
Je kleiner die Nummer ist, desto hher ist die Prioritt 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.

<I>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 fr dieses Projekt spenden
------------------------------------------------------------------
Niemand hat auch nur einen Pfennig fr meine Arbeit gespendet.
Also lassen wir das ... ;-)

.w<w>w.		Hotkey: w oder W - Wo man Untersttzung im Internet findet
--------------------------------------------------------------------------
Dies ist Dein Weg zur FutuerOS Heimseit und damit auch zur Hilfe fr 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 fr zuknftige Erweiterungen von Caruh zur
Verfgung.
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 fr den Programmierer und seine Tasks interessanten
Einsprnge.

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

- Speicheradresse &000F enthlt das Bildschirm Format, das der Anwender mittels
  Caruh eingestellt hat (0 fr 80x25, 1 fr 68x30 und 3 fr 64x32 Format).
  Jeder Task kann das gewnschte Bildschirm-Format aus diesem Byte lesen, falls
  der Task in den Vordergrund geschalten wird.

Einsprnge in Caruh
-------------------
- An der RAM Adresse &0003 kann die Funktion 'SAOMS' aufgerufen werden.
  Sie erlaubt es dem Anwender ein Stck 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 Prioritt ndern.
  Jeder Task wird nach dem Laden mit der hchsten Prioritt '1' gestartet.
  Es sind Werte von 1 bis 255 zulssig. Kleinere Werte haben hhere Prioritt.

- An Adresse &0013 ruft man die Funktion 'RFMSA' mittels des Befehls
  'CALL &0013' auf. 'RFMSA' dient dazu einem Task ein Stck 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 enthlt ein Element fr 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 enthlt die Anzahl aller vorhandenen Tasks

- &4002(DIS_A_T): Dies Byte enthlt 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 wre das 'TT_START + T_T_E_L'.
	 Wobei sich TT_START(=&4000) + T_T_E_L(=&0010) = &4010 ergibt!


- &7FE4-&7FFF: Dieser Bereich wird fr Caruh selbst (als Task #1) bentigt!


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 gelscht
		werden, sobald der die Kontrolle ber den Bildschirm wieder an
		Caruh zurckgibt. 
		Beim Drck auf die ESC-Taste muss der Task den Bildschirm etc.
		wieder an Caruh zurckgeben. Dazu wird Bit 0 an &BE02 gelscht.

- 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 Mens dargestellt, Dateien oder Optionen ausgewhlt etc.
		-> Die Tasks drfen NICHTS am Bildschirm darstellen!

- &BE03 (TTNS3): Temprrer Task-Nummern-Speicher an &BE03
		 Speichert die Nummer eines Tasks (2-255) fr 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 fr die
Task Variablen (Siehe oben unter 'Task-Variablen') zur Verfgung.

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

Jedes Element besteht aus 16 Bytes:

0...: Task-Nummer (= Nummer des Tasks der durch diesen Eintrag verwalted wird)
1...: Priritt: 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 hher ist die Task-Prioritt.
2...: Wiederlade-Wert fr das Prioritts-Byte, sobald das Prioritts-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 fr Task #2, am &4030 fr Task #3, an &4040
fr Task #4 und so weiter...


Die VRAM / Multi-Bildschirm Tabelle
-----------------------------------
Solange Caruh als Vordergrund Task aktiv ist knnen andere Tasks lediglich
Teile des Allgemeinen Bildschirms nutzen. Das ist der Bildschirm, der nach dem
Start von Caruh mit seinem Mensystem angezeigt wird.
Solange der 'Allgemeine Bildschirm' genutzt wird ist folgendes mglich:

- Jeder Task kann sich Teile des VRAMs / Allgemeinen Bildschirms reservieren
- Jeder Task darf auf fr 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 mglich, 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.
Anschlieend folgen Zeile fr Zeile von oben nach unten.

Welche Bedeutung haben die Bytes in der VRAM Tabelle?
-----------------------------------------------------
Ein Null-Byte in der Tabelle definiert dabei eine verfgbare Bildschirmposition
und ist somit fr Tasks verfgbar.

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 fr sein
Men-System und die untere Task-Bar.



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

Jeder Task belegt einen 16 KB Block (E-RAM Block) von &4000 bis &7EFF.
Aktuell werden dafr 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 - --> Applikationslnge 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-/Prioritts Variable der Task-
	       Tabelle kopiert wird (bei nderung der Priritt)
               (Also wie viele 1/300 Sekunden vor Task-Aufruf gewartet wird)
               Es handelt sich um das Prioritts-Byte
-------------------------------------------------------------------------------
- &7FFD......: (TNUME) Nummer des Tasks &01-&FF (255 mgliche Tasks).
	       Die Tasks sind dynamisch! (Variablen-Name in Caruh: TNUME)
-------------------------------------------------------------------------------
- &7FFE-&7FFF: (TSPSE) Puffer fr 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 Rcksprung-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 gelscht 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 Lschung!
		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 zurck 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 luft...
	 = 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 fr zuknftige 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 spter unter VI.


Task Konventionen: Anforderungen an Tasks
-----------------------------------------
- Tasks mssen 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
  durchgefhrt werden, so sind hierfr die Interrupts abzuschalten.

- Tasks mssen den ROM/RAM Status beibehalten (Das obere ROM ist immer ein).
  Mssen z.B. Daten aus dem Bildschirmspeicher gelesen werden, so sind hierfr
  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 bentigen keinen Header, das sie immer an Adresse &4000 geladen werden
  Tasks, die einen Header besitzen drfen inclusive des Headers nicht grer
  als 16 KB sein.

- Tasks / Dateien grer als 16 KB werden von Caruh NICHT geladen / gestartet

- Whrend des Aufruf von OS Funktionen die auf die Hardware zugreifen mssen
  die Interrupts AUS und anschlieend wieder EINgeschaltern werden.
  Selbiges gilt auch fr den direkten Zugriff auf I/O Adressen.

- Whrend des Aufruf von OS Funktionen die den Stackpointer SP nutzen mssen
  die Interrupts AUS und anschlieend wieder EINgeschaltern werden. Beispiel:

	DI		;Interrupts ausschalten
	CALL CUR_CPY	;OS Funktion aufrufen, die SP verndert
	EI		;Anschlieend 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 fr die aktuelle Textausgabe zu setzen (dann Text ausgeben) und
  anschlieend ist C_POS wieder zu restaurieren. Whrend dieser Zeit mssen die
  Interrupts natrlich 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		;Anschlieend Interrupts einschalten

- Das OS ROM A muss immer eingeblendet bleiben!
  Wird das ROM gendert oder eine OS Funktion in den anderen OS ROMs B, C, D
  aufgerufen so mssen die Interrupts AUS und anschlieend 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		;Anschlieend Interrupts einschalten

- Kooperative Tasks knnen zum nchsten 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 ntig, um einem zeitgleich auftretendem Interrupt
  entgegen zu wirken. Ohne 'DI' knnte 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-fhige Tasks sind fhig, den gesamten Bildschirm nutzen knnen.
  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
  lschen.
  Jeder Vollschirm-Task sollte das Bit 0 (Foreground-Bit) an der Adresse &7FF8
  regelmig lesen. Denn wenn es gesetzt ist, dann steht dem Task der gesamte
  Bildschirm zur Verfgung.
  Sollte die Taste 'ESC' gedrckt werden, dann sollte sich der Task wieder in
  den Hintergrund schalten. Dies geschieht durch das Lschen 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 lschen.
  --> Konkret heit das der Task schreibt den Wert &08 an Adresse &7FF8 und
      kann denn den Task Manger aufrufen mittels 'DI:RST 7'.
      Anschlieend solle ein Sprung auf den vorigen 'DI' Befehl folgen:

      LOOP	DI		;Interrupts aus, das ist vor JEDEM RST 7 ntig!
		RST 7		;Caruh (bzw. nchsten 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 selbststndig das Bit 4
  (Storable-Bit) an der Adresse &7FF8 in seinem eigenen E-RAM.
  Tasks die keinen Wert darauf legen gespeicher werden zu knnen sollten bei
  ihrem Aufruf einmal dieses Bit 4 lschen.
  Ein Speicherbarer Task sollte regelmig berprfen, 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
  ntigen 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.
  Anschlieend findet das Speichern des Tasks statt, darm kmmert 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' zurcksetzten 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 fr Tasks -
-------------------------------
Der Tasker Caruh stellt Tasks mehrere OS Funktionen zur Verfgung.
Weiterhin knnen 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 knnen durch den Anwender in	
Caruh eingestellt werden. Dies geschieht unter Optionen. Diese Einstellungen
knnen aus folgenden RAM-Variablen gelesen werden:

- Speicheradresse &000E enthlt den Bildschirm Modus (0-3) der vom Benutzer
  eingestellt wurde.
  Jeder Task kann den gewnschten Bildschirm-Modus aus diesem Byte lesen, falls
  der Task in den Vordergrund geschalten wird.

- Speicheradresse &000F enthlt das Bildschirm Format (0 fr 80x25, 1 fr 68x30
  und 3 fr 64x32 Format) das vom Benutzer eingestellt wurde.
  Jeder Task kann das gewnschte 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. Parameterbergabe siehe Source Code. #######

- RAHMEN / FENSTER ZEICHNEN
  Der von CBM her bekannte Fenster-Zeichner 'DR_WIN' kann durch 'CALL &000B'
  aufgerufen werden.
  Parameterbergabe 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 fr Bildschirm MODE 2 enthalten
;    Zum Beispiel den LOCATE Kontrollkode fr 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
  Stck des Allgemeinen Multi-Bilschirms (normale Ansicht) zu reservieren.
  Aufgerufen muss diese OS Funktion dabei von einem Task werden.
  Parameterbergabe 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 Flche (Breite, MODE 2)
  - YH = Anzahl aller Zeilen  der zu reservierenden Flche (Hhe)
  Rcksprung 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 Stck des gemeinsamen Bildschirms
  reservieren.
  Die bentigten Parameter sind dabei folgende:
  Rcksprung 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 Rcksprung gibt das Zero-Flag ber den Erfolg Auskunft:
  - Z-Flag auf '0' gelscht -> 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 fr 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 LSCHEN
  Die Funktion 'DTFMT' lscht alle belegten Bereiche eines Tasks in der VRAM /
  Multi-Bildschirm Tabelle. Dabei wird die zu lschende Task-Nummer im Register
  E bergeben.



- PRIORITT EINES TASKS NDERRN
  Ruft man die Funktion 'SEPRI' mittels des Z80 Befehls 'RST 2' an Adresse
  &0010 auf so kann ein Task seine Prioritt ndern (Neue Prioritt in A).
  Jeder Task wird nach dem Laden mit der hchsten Prioritt '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 Prioritt herabgesetzt werden. Die neue Prioritt wird im Akku bergeben,
  es sind Werte von 1 bis 255 zulssig. Kleinere Werte haben hhere Prioritt.

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

  DI	;Interrupts ausschalen (Befehl vor jedem 'RST 7' zwingend ntig!)
  RST 7	;Task-Manager bzw. nchsten Task aufrufen

- Das Testen des Inhalts von Adresse &7FFB auf &7x erlaubt Integrittstest
  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 regulren 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 angestoen werden. Will der Anwender
jedoch einen Task in den Vordergrund schalten, so muss dieser Task auch darauf
reagieren knnen!

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 gelscht, 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 unfhig dazu erscheint.

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


-> Dem neu gebackenen Vordergrund-Task stehen jetzt Bildschirm und Tastatur zur
   Verfgung!
   -> Sinnvoll ist es den Bildschirm erst mal zu lschen, 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 zurck zu geben.
   Wie geht das?
   Weiterlesen ... ;-)


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

-> Der Task lscht 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 lscht ebenfalls das Bit 0 an Adresse &BE02 (CCON2)!

-> Sobald das Bit 0 an Adresse &BE02 (CCON2) gelscht ist bernimmt Caruh die
   Kontrolle von Bildschirm und Tastatur (wie zuvor gehabt). 
   Der ehemalige Vordergrund-Task ist nun wieder im Hintergrund ttig.

-> 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 heit nichts anderes als da Caruh wieder die Kontrolle bernimmt.


Reservieren von Teilen des gemeinsamen Bildschirms
--------------------------------------------------
Es ist einem jeden Task mglich 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 Verfgung steht.
Auf diese Weise ist es mglich, dass jeder Task immer die selben Abschnitte fr
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' wrde 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 Kstchen - bestehend aus Linien - kann nun mittels der Cursor-Tasten
   bewegt werden und der Drck auf Copy reserviert den entsprechenden Bereich
   des Bildschirms und trgt 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 gltiger Bereich
   gefunden oder durch 'ESC' abgebrochen.

-> Dem Task wird schlielich 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 enthlt diese beiden Werte.
   - Zustzlich wird die entsprechende Adresse der linken oberen Ecke innerhalb
     des Bildschirmes bergeben (in RAM-Variable C_POS).


























