Power-Programmierung/CD2.mdf/c/library/dos/window/winedit/winedit.txt

Text File | 1993-07-28 | 108.6 KB | 3,068 lines

******************************************************************
******************************************************************
****                   W I N E D I T                          ****
******************************************************************
******************************************************************

Universeller Menü- und Maskengenerator


******************************************************************
0. INHALT
******************************************************************
1.   Kurzbeschreibung
2.   Konzept
3.   Leistungsmerkmale
4.   Technische Daten
5.   Installation
6.   Maskengenerator
6.1    Arbeitsfläche
6.2    Untermenüs
6.2.1    Datei
6.2.2    Schirm
6.2.3    Block
6.2.4    Text
6.2.5    Attribut
6.2.6    Maske
6.2.7    Feld
6.2.8    Vorgaben
6.3    Maskenerstellung
6.3.1    Einfache Textmaske
6.3.2    Ein/Ausgabemaske
6.3.3    Menümaske
7.   Interface
7.1    Basisroutinen
7.2    Tastaur und Maus
7.3    Freie Ein- und Ausgabe
7.4    Feldtyp-Gebundene Ein- und Ausgabe
7.5    Menü-Verwaltung
7.6    Abruf von Maskeninformationen
7.7    Maus-Routinen
7.8    Bildschirmroutinen (allgemein)
7.9    MICROSOFT-Maus-Interfaceroutinen
8.  Zu den Beispielprogrammen
9.  Urheberrechtsschutz-Erklärung
10. Haftungsausschluß


******************************************************************
1. KURZBESCHREIBUNG
******************************************************************

WINEDIT steht für ein Hilfsmittel zur Programmierung voll
mausunterstützter Benutzeroberflächen unter MS-DOS (PC-DOS) für
IBM PC/XT- kompatible Rechner



Das Programm ist unter dem Betriebssystem PC-DOS bzw. MS-DOS
ab Version 2.0 auf dem IBM-PC/AT und kompatiblen Rechnern mit
mindestens 256K Hauptspeicher, einem Disketten-Laufwerk und einer
im 80*25-Zeichen-Modus arbeitenden Bildschirmkarte lauffähig.
Optional kann eine MICROSOFT-kompatible Maus eingesetzt werden.
Schnittstellen zu den Programmiersprachen TURBO-C (ab 1.0) und
TURBO-Pascal (ab4.0) von BORLAND sind verfügbar.


******************************************************************
2. KONZEPT
******************************************************************

Im folgenden soll erläutert werden, warum die Programmierung
einer Text- und Semigrafik-orientierten
Benutzeroberfläche für ein stark eingeschränktes Spektrum von
Rechnern im Zeitalter der standardisierten grafikorientierten
Benutzeroberflächen kein Anachronismus ist.
Es existieren derzeit wohl mehrere Millionen Rechner, auf welche
die Merkmale IBM-kompatibel, 80*25 Zeichen- Textbildschirm,
Betriebssystem MS-DOS (PC-DOS) zutreffen. Den meißten dieser
Rechner ist gemein, daß sie von ihren Resourcen her kaum fähig
sind, dem Trend zu immer rechenaufwendigeren grafikorientierten
Programmsystemen zu folgen. Wenn diese Rechner auch nicht mehr
den Stoff bieten, der die Computerzeitschriften füllt, so ist in
ihnen doch noch eine enorme Rechenleistung manifestiert, die diese
Rechner auch in Zukunft noch eine gewichtige Rolle spielen läßt.
Auch unter einem anderen Aspekt macht die Einschränkung auf ein
enges Spektrum von Rechnern Sinn. Statt einer universellen,
rechnerunabhängigen Lösung kann hier eine spezielle, dafür aber
stark optimierte Lösung angeboten werden.
Das Softwareangebot in der angesprochenen Rechnersparte ist
riesig und unüberschaubar. Trotzdem wird es auch in Zukunft
notwendig sein, für die ja real existierenden Rechner Software zu
entwickeln. Der Schwerpunkt dieser Softwareentwicklung wird nicht
in großen Standardprogrammen mit mehreren hundert Menschjahren
Arbeitaufwand liegen.
Vielmehr sind es kleine, spezielle Lösungen manchmal begrenzter
Lebensdauer, welche zum Einsatz der PC-Veteranen zu
programmieren sind. Beispiele sind der Einsatz von PC's als Mess-
Steuer- oder Reglungsrechner. PC's werden oft zu Testzwecken
programmiert, PC's stellen die Schnittstellen von Transputernetzen
zur Außenwelt dar.
Gemein ist solchen kleinen und speziellen Lösungen, daß der
investierbare Entwicklungsaufwand meist recht begrenzt ist. Für
die Programmierung einer zeitgemäßen Benutzerschnittstelle mit
beispielsweise einem voll mausunterstützten Menüsystem ist in der
Regel keine Zeit. Hier nun beginnt das Konzept WINEDIT.
WINEDIT bietet alle notwendigen Funktionen zur Realisierung eines
zeitgemäßen Benutzerinterfaces. Mit wenigen Befehlen und einem
sehr einfachen und schnell zu handhabenden Maskengenerator kann
ohne erwähnbarem Lernaufwand in kurzer Zeit eine absolut
professionelle Bedienoberfläche. Die Hilfsmittel sind so programmiert,
daß dem Anwender keine neuartige Programmstruktur aufgezwungen
wird. Vielmehr fügen sich die Funktionen derartig gut in gewohnte
Strukturen ein, daß selbst der nachträgliche Einbau in bestehende
Programme einfach vollziehbar ist.
 Grundsatz der Programmierung der Hilfsfunktion war eine
minimierte Fehlerträchtigkeit. Falsche Anwendung der Funktionen
führt oft zu merkwürdigen, selten aber zu fatalen Ergebnissen.


******************************************************************
3. LEISTUNGSMERKMALE
******************************************************************

Mit Hilfe des Menü- und Maskengenerators WINEDIT, welcher ohne
Programmierkenntnisse bedienbar ist, können interaktiv beliebige
Bildschirmmasken entworfen werden.
Diese Masken können beispielsweise Menüs, Ein u. Ausgabemasken
oder auch Hilfstexte sein. Innerhalb des Generators wird Text,
Farbe Attribut (Farbe) und Größe der Masken festgelegt.
Ferner besteht die Möglichkeit der Definition von Feldern. Felder
sind frei definierbare Unterbereiche einer Maske, welchen im
Generator eine Reihe von Eigenschaften (Farben für Eingabe,
Ausgabe, Menüs, Formate, Datentypen, Wertebereiche usw. )
zugeordnet werden können.
Auf Basis der Felddefinitionen können innerhalb des Programms mit
Hilfe der Schnittstellen-Funktionen komplexe Operationen zur Ein-
und Ausgabe wie auch zur Anwahl von Menüpunkten automatisiert
werden. Die komplette Maskenbeschreibung wird in einer
Maskendatei abgespeichert, diese wird dann zur Laufzeit vom
Anwenderprogramm geladen. Das Erscheinungsbild eines Programmes
kann somit ohne erneute Compilierung verändert werden.
Die Masken eines Programms können mit Hilfe des
Bibliotheksverwalters WINLIB zu einer Maskenbibliothek
zusammengefaßt werden.
Innerhalb der Programms erfolgt der Bezug auf Masken sowie deren
Felder über Referenznummern.
Schon mit Kenntniss weniger Grundfunktionen lassen sich
erstaunliche Ergebnisse erzielen. Weitere Funktionen dienen der
Konfiguration von Grundfunktionen, sind also im ersten Ansatz
nicht relevant.
Insgesamt stehen Funktionen zur Verwaltung von Bildschirm,
Tastaur und Maus zur Verfügung. Einfach erzielbare Ergebnisse
sind beispielsweise:


-     Windowing mit automatischer Rücksicherung des
   Bildhintergrundes
-     Menüs jeglicher Ausprägung
-     Menü-Hirachien, in denen über mehrere Ebenen hinweg mit der
   Maus Anwahlen vollzogen werden können
-     Hilfstextsysteme, in denen man sich durch Anwahl von
   Stichworten weiterbewegen kann (die Anwahl ist
   selbstverständlich mit Maus oder Cursortasten möglich)
-     Markieren von Blöcken durch Aufziehen dieser mit der Maus
-     Stringeingaben mittels Zeileneditor
-     Verschiedene Ein-und Ausgabefunktionen, unter anderem auch
   eine Maskenversion des altbekannten printf(...)
-     Komplexe Ein-und Ausgabefunktionen zum automatiserten
   Einlesen und Ausgeben von Datenstrukturen
-     Verwaltung virtueller Bildschirme zur optimierten Ausgabe


******************************************************************
4. TECHNISCHE DATEN
******************************************************************

-     Es werden maximal 256 Masken verwaltet (Erweiterung
   verfügbar)
-     Die Schachtelungstiefe von geöffneten Masken auf dem
   Bildschirm ist lediglich durch die Größe des Hauptspeichers
   des Rechners begrenzt.
-     Maximal 2KByte des Programm-Stacks werden beansprucht
-     Der Speicherbedarf einer Maske ist abhängig vom Zustand
   dieser. Mit

          n = Zeilen*Spalten*2  (der Maske)  und
          d = Maskendateigröße

      ergeben sich folgende Werte [Byte] :

    -     Nach dem Laden (w_load(..)) :
              a) Ohne virtuelles Bild : d
              b) Mit virtuellem Bild  : d + n

    -     Nach dem Öffen (w_open(..)) :
              a) Ohne virtuelles Bild : d + n
              b) Mit virtuellem Bild  : d + n + n

    -     Nach dem Schließen (w_close(..)) :
              a) Ohne virtuelles Bild : d
              b) Mit virtuellem Bild  : d + n

    -     Nach dem Löschen (w_erase(..)) :
              0 Bytes


******************************************************************
5. INSTALLATION
******************************************************************

Grundsätzlich läßt sich des Programmpaketes WINEDIT in zwei
unabhängige Teile gliedern (logisch wie gegebenfalls nacher auch
physikalisch auf Disketten !): Diese Teile sind einerseits der
schnittstellenunabhängige Maskengenerator WINEDIT und der
Bibliotheks-Verwalter WINLIB und andererseits die
schnittstellenspezifischen Funktionsbibliotheken (W_TBC_LM.LIB,
W_TBP_55.TPU, usw.) mit den einzelnen WINEDIT-Hilfsroutinen.


Eine spezielle Installationsprozedur ist zur Inbetriebnahme des
Maskengenerators sowie der Schnittstellen nicht notwendig. Es
empfiehlt sich, auf der Festplatte ein Verzeichnis mit dem Namen
WINEDIT einzurichten und die Dateien der gelieferten Disketten in
dieses Verzeichnis zu kopieren: z.B.
              MD C:\WINEDIT
              (*DISKETTE 1 einlegen*)
              COPY A:\WINEDIT\*.* C:\WINEDIT
              (*DISKETTE 2 einlegen*)
              COPY A:\WINEDIT\*.* C:\WINEDIT
              (*DISKETTE 3 einlegen*)
              COPY A:\WINEDIT\*.* C:\WINEDIT

Der Maskengenerator kann aber auch direkt von der Diskette
gestartet werden.
Steht keine Festplatte zur Verfügung, so empfiehlt es sich, die
schon angedeutete Zweiteilung vorzunehmen:

Zu Generierung, Editierung und Verwaltung von Masken wird eine
Diskette mit mindestens den Dateien WINEDIT.EXE, WINEDIT.LIB und
WINLIB.EXE angelegt.

Die Programmerstellung notwendigen Dateien, also W_DEF.H und
W_TBC_LM.LIB für die TURBO-C-Schnittstelle bzw.
W_TBP_40/50/55.TPU für TURBO-Pascal-4/5-Schnittstelle sind auf die
entsprechende Compilerdiskette zu kopieren.


Soll der Maskengenerator (die Dateien WINEDIT.EXE und
WINEDIT.LIB) aus jedem beliebigen Pfad aufgerufen werden können,
so ist die PATH-Anweisung in der Datei \autoexec.bat um den Pfad
zu ergänzen, in dem sich die genannten zwei Dateien befinden.
Befinden sich die Dateien beispielsweise auf der Festplatte C im
Pfad winedit, so ist die PATH-Anweisung um  ;C:\winedit zu
ergänzen. Sie könnte dann beispielsweise wie folgt aussehen:

                          PATH=C:\TC;C:\TURBO;C:\SW5;C:\WINEDIT

Es besteht die Möglichkeit, den Maskengenerator derart zu
konfigurieren, daß die direkten Bildspeicherzugriffe durch deutlich
langsamere BIOS-Aufrufe ersetzt werden, so daß eine
Maskenabänderung auch auf einem nicht voll kompatiblen Rechner
möglich ist. Dazu ist die Environment-Variable WINEDIT wie folgt zu
setzen:

                          SET WINEDIT=1

Der Normalzustand wird mit

                          SET WINEDIT=0

wieder hergestellt.


Für die verschiedenen Entwicklungsumgebungen sind entsprechende
Konfigurations und Projektdateien verfügbar. Die Pfadangaben
müssen eventuell den speziellen Gegebenheiten angepasst werden,
so daß die WINEDIT-Interfacedateien auch gefunden werden.
Näheres dazu findet sich in den Handbüchern der Compiler (->
Directories).

******************************************************************
6. MASKENGENERATOR
******************************************************************

Der Maskengenerator WINEDIT arbeitet als eigenständiges Programm
unabhängig von der einzusetzenden Schnittstelle zur
Programmiersprache. Er ist unter Verwendung der WINEDIT-
Hilfsfunktionen programmiert worden; somit kann sein Aussehen
jederzeit durch Veränderung der zugehörigen Masken in der
Maskenbibliothek WINEDIT.LIB den individuellen Erfordernissen
angepaßt werden.


Mit Hilfe des Maskengenerators erzeugt der Anwender interaktiv die
gewünschten Bildschirmmasken und versieht diese mit den
erforderlichen Merkmalen wie Menüs oder Ein-und Ausgabekanälen
in Gestalt von Feldern. Die komplette Maskenbeschreibung wird
anschließend in einer Maskendatei gespeichert. Diese Datei wird
dann später vom Anwender-Programm gelesen, die Maske ist damit
verfügbar.

Der Maskengenerator ist ohne Programmierkenntnisse bedienbar.
Der Abbruch einer Aktion erfolgt grundsätzlich mit ESC oder
rechter Maustaste, eine Anwahl wird mit ENTER oder linker
Maustaste durchgeführt. Über die Funktionstaste F1 sind
verschiedene kontextbezogene (Arbeitsfläche, Untermenüs..)
Hilfstexte abrufbar, welche die Möglichkeiten des Vorgehens
verdeutlichen.
Alternativ zu den Menüs können Befehle auch über
Tastenkombinationen, welche in den Untermenüs angegeben sind,
eingegeben werden.
Die Tastenkombination [ALT][F1] bringt die Belegung der
Funktionstasten zur Anzeige.

Um den Einstieg zu erleichtern, empfiehlt sich das Laden schon
vorhandener Masken ( aus dem Beispiel oder aus der
Maskenbibliothek WINEDIT.LIB ), deren Funktion schon erfahren
wurde. Die einzelnen Merkmale einer Maske können in eine
Protokolldatei ausgegeben werden.

Der Maskengenerator WINEDIT kann zu einem Demolauf veranlaßt
werden. Näheres dazu findet sich in der Datei LIESMICH.


==================================================================
6.1 ARBEITSFLÄCHE
==================================================================
Zu unterscheiden sind jederzeit Arbeitsfläche und Menü des
Generators. Die Arbeitsfläche dient der Gestaltung der einzelnen
Masken, indem der Bildschirm wie in einem
Textverarbeitungsprogramm beschrieben werden kann. Der Cursor,
also die Schreibmarke, kann hierbei mit den Pfeiltasten bewegt
werden oder durch Druck auf die linke Maustaste auf dem
Mauscursor positioniert werden.

Mit der Funktionstaste 10 (F10), der ESC-Taste oder der rechten
Maustaste wird das Menü aktiviert. Mit einem weiteren ESC oder
dem Drücken der rechten Maustaste gelangt man vom Menü zurück
in die Arbeitsfläche.

Hilfstexte sind zur Arbeitsfläche und zu jedem Untermenü mit der
Taste F1 oder der mittleren (bzw. beiden) Maustaste(n) abrufbar.
Durch Halten der ALT-Taste und drücken von F1 (°F1) wird die
Belegung der Funktionstasten zur Anzeige gebracht.

Mit linker Maustaste oder ENTER-Taste werden positive Quittungen
gegeben (z.B. wird etwas angewählt ), rechte Maustaste und ESC-
Taste werden allgemein als negative Eingabe (Abbruch) gewertet.

Hält man in der Arbeitsfläche die linke Maustaste gedrückt und
bewegt dabei die Maus, so wird ein rechteckiger Bildschirmbereich,
ein Block, markiert. Mit diesem markierten Block teilt man
bestimmten Menüfunktionen mit, auf welchen Bildschirmbereich sie
wirken sollen. Beispielsweise wird bei einer Farbänderung immer
nur die Farbe des markierten Blocks geändert. Wird Text gelöscht,
so nur der Text im markierten Block !

Wird die linke Maustaste gedrückt, während sich der Mauscursor
auf einem Feld befindet, so wird Information zu dem jeweiligen Feld
ausgegeben.

==================================================================
6.2 UNTERMENÜS
==================================================================
Im folgen wird eine Beschreibung zu jedem einzelnen Menüpunkt,
nach Untermenüs geordnet, gegeben. Diese Beschreibung ist
ausführlicher als die Hilfstexte im Maskengenerator, von der
Struktur her jedoch identisch. Somit wird das Verständnis für die
Hilfstexte gefördert.


------------------------------------------------------------------
6.2.1 DATEI

LADEN: Eine irgendwann zuvor geschriebene Maskendatei kann zur
   Weiterverarbeitung wieder in den Generator geladen werden.
   Die aktuelle Maske im Generator wird hierbei überschrieben.
SCHREIBEN: Eine im Maskengenerator erzeugte oder veränderte
   Maske wird in eine Datei geschrieben. Somit steht diese Maske
   auch nach Beendigung des Maskengenerators noch zur
   Verfügung.
PROTOKOLL: Eine Protokoll-Datei zur aktuell geladenen Maske des
   Generators wird unter einem anzugebenden Namen erzeugt.
   Diese Datei wird in einem ausdruckbaren ASCII-Format
   geschrieben und kann Dokumentationzwecken dienen. Inhalt
   des Protokolls sind alle wesentlichen Merkmale der Maske wie
   z.B. Größe, Text, Felddefinitionen usw. .
ASCII: Eine ASCII-Datei, welche beispielsweise mit einem
   Textverarbeitungsprogramm erzeugt wurde, kann in den
   Maskengenerator importiert und somit Bestandteil der Maske
   werden. Die Cursor-Position gibt Startzeile und Startspalte an,
   ab der der Text in die Maske zu schreiben ist.
DOS-Shell: Will man den Maskengenerator kurzzeitig verlassen, um
   z.B. DOS-Befehle einzugeben, so ist dieser Menüpunkt
   anzuwählen. Mit dem DOS-Befehl EXIT gelangt man zurück in
   den Generator, die aktuelle Arbeitskontext ist dabei erhalten
   geblieben.
BEENDEN: WINEDIT wird endgültig verlassen. Eine letzte Abfrage
   vor dem Beenden ermöglicht ein abschließendes Sichern der
   aktuellen Maske.


------------------------------------------------------------------
6.2.2 SCHIRM

Unter dem Hauptmenüpunkt SCHIRM verbergen sich
Einstellmöglichkeiten, die weniger der Gestaltung der Maske als
vielmehr der Veränderung des Bildschirmaussehens wärend der
Maskenerstellung dienen.

MASKENGRÖSSE AN/AUS bestimmt, ob der nicht zur Maske
   gehörende Bildschirmteil mit ░░ ausgeblendet wird oder
   sichtbar ist. Auch wenn der Bereich ausgeblendet wird, kann
   der nicht zur Maske gehörende Bildschirmteil beschrieben
   werden. Beipielsweise können dort Maskenteile
   zwischengespeichert werden.
ATTRIBUTE AN/AUS bestimmt, ob die Attribute des Bildschirms
   angezeigt werden oder nicht. Ein Ausschalten kann sinnvoll
   sein, wenn z.B. Block und zu markierender Text das gleiche
   Attribut haben, so daß der markierte Block nicht erkennbar
   ist.
FELDER AN/AUS bestimmt, ob die Felder oder die darüber
   liegenden Texte der Maske sichtbar sind. Sobald
   Feldoperationen unternommen werden, wird dieser Schalter
   automatisch auf AN gestellt, daß Schreiben von Text schaltet
   die Felder automatisch wieder aus. Ob Felder sichtbar sind
   oder nicht, hat Einfluß auf den Wirkungsbereich von
   Maskenoperationen : Nur sichtbare Felder werden in Masken-
   Operationen (Kopieren, Verschieben..) miteinbezogen.
NORMALATTRIBUT ermöglicht eine Farbwahl für die Arbeitsfläche,
   sofern dort keine anderen Farben gesetzt wurden. Werden
   Farben gelöscht, so bedeutet dies nichts anderes, als das die
   Farben durch das NORMALATTRIBUT ersetzt werden.
REVERSATTRIBUT ermöglicht eine Auswahl der Farbe, in der ein
   markierter Block dargestellt wird. Eine Änderung ist sinnvoll,
   wenn die Blockfarbe mit der Maskenfarbe übereinstimmmt.
SCHATTENATTRIBUT legt die Farbe zum Schattieren von Masken
   fest. Siehe auch Untermenü Maske/Schattieren !
KONFIGURATION SICHERN sichert die Einstellungen dieses Menüs,
   die Vorgaben für die Feld-Definition sowie die Namensvorgabe
   zum Laden einer Maskendatei dauerhaft. Somit steht die gleiche
   Einstellung nach jedem Start Maskengenerators zur Verfügung
INITIALEINSTELLUNG überschreibt die gesicherte Konfiguration mit
   der Initialeinstellung.


------------------------------------------------------------------
6.2.3 BLOCK

Ein Block markiert einen rechteckigen Bereich auf dem Bildschirm,
dieser wird revers dargestellt wird. Dieser Block bezeichnet einen
Bildschirmbereich, auf den nachfolgende Operationen dann wirken:
Beim Löschen von Text wird beispielsweise nur der Text im Block
gelöscht !
DEFINIEREN: Ein Block als Teil des Bildschirms wird festgelegt:
   Eine Ecke des Blockes liegt an der aktuellen Cursorposition,
   die Ausmaße können mit den Cursortasten, PGUP,PGDOWN,HOME,
   END oder dem Mauscursor verändert werde. Die Größe wird mit
   ENTER oder linker Maustaste festgesetzt. Bequemer läßt sich
   ein Block durch Halten der linken Maustaste und Bewegen des
   Mauscursors definieren. Bei Loßlassen der Maustaste ist dabei
   die Blockdefinition abgeschlossen.
FÜLLEN füllt den markierten Block mit einem Zeichen aus der
   erscheinenden ASCII-Tabelle.
RAHMEN umrahmt einen Block auf dessen äußersten Rand mit dem
   im erscheinenden Menü angewählten Rahmentyp.
   Kreuzungspunkte werden entsprechen den überschriebenen
   Rahmenzeichen automatisch angepaßt. Alte Rahmen lassen sich
   durch Umrahmung mit Leerzeichen löschen !


------------------------------------------------------------------
6.2.4 TEXT

KOPIEREN: Der Text im markierten Block wird kopiert. Dabei kann
   die Textkopie mit Cursortasten oder Maus über den Schirm an
   den Zielort bewegt und dort durch ENTER oder linke Maustaste
   abgelegt werden.
VERSCHIEBEN verschiebt den markierten Text in gleicher Weise wie
   beim KOPIEREN, der Quellblock wird jedoch mit Leerzeichen
   überschrieben.
LÖSCHEN: Der Text des markierten Blocks wird mit Leerzeichen
   überschrieben.
TABELLE: Eine ASCII-Tabelle wird ausgegeben, aus der ein Zeichen
   ausgewählt werden kann. Dieses wird dann an die aktuelle
   Cursor-Positiong geschrieben, als sei dieses Zeichen von der
   Tastatur erzeugt worden.
ATTRIBUT ermöglicht die Anwahl eines Attributes, mit dem dann
   der Text im markierten Block versehen wird.


------------------------------------------------------------------
6.2.5 ATTRIBUT

Das Attribut eines Zeichens ist ein diesem zugeordneter Zahlwerte,
welcher das Erscheinungsbild des Zeichen (also Farbe, blinkend
oder nicht usw.) bestimmt. Die folgenden Aktionen beziehen sich
nur auf die Attribute, lassen den Text unberührt:

KOPIEREN kopiert die Attribute des markierten Blockes. Dabei kann
   die Attributkopie mit Cursortasten oder Maus über den Schirm
   an den Zielort bewegt und dort durch ENTER oder linke
   Maustaste abgelegt werden.
VERSCHIEBEN verschiebt die Attribute des markierten Blockes. Der
   Quellblock erhält hierbei das Normalattribut der Arbeitsfläche.
   Siehe auch Menüpunkt SCHIRM.
LÖSCHEN löscht die Attribute im markierten Block, überschreibt
   diese also mit dem Normalattribut der Arbeitsfläche. Siehe auch
   Menüpunkt SCHIRM.


------------------------------------------------------------------
6.2.6 MASKE

Die Operationen KOPIEREN, VERSCHIEBEN und LÖSCHEN beziehen
sich auf Text, Attribut und sichtbare Felder des Blockes. Zu
beachten ist, daß Felder ausserhalb der Maske automatisch gelöscht
werden und das Felder nicht übereinander liegen können (siehe
auch Menüpunkt FELDER).

Eine Besonderheit ergibt sich für die Funktion VERSCHIEBEN, wenn
kein Block markiert ist: Dann wird die komplette Maske mit Feldern
(auch wenn diese nicht sichtbar sind) verschoben. Der
Maskenbereich wird hierbei entsprechend angepaßt. Somit kann mit
einer einzigen Operation die Position einer Maske auf dem
Bildschirm verändert werden.

GRÖSSE SETZEN setzt die Maskengröße entsprechen dem markierten
   Block, denn nicht jede Maske soll den ganzen Bildschirm
   füllen. Alle Felder außerhalb der neuen Maskengröße werden
   damit gelöscht.
SCHATTIEREN schattiert die Maske. Der Schatten liegt rechts und
   unten  i n n e r h a l b  des Bereichs der Maske. Das
   Schattenattribut kann unter Menüpunkt SCHIRM eingestellt
   werden. Die manuelle Definition eines Schattens ist möglich:
   Dazu ist der rechten oberen Ecke innerhalb der Maske
   entsprechend der Größe des Schattenversatzes das Attribut mit
   der Nummer 0hex zu geben. Dem eigentlichen Schatten ist dann
   in üblicher Weise eine geeignete Schattenfarbe (Textattribut !)
   zuzuordnen.
INFO gibt eine Information zur aktuellen Maske des Generators aus
   (Name, Größe, Anzahl der Felder..)


------------------------------------------------------------------
6.2.7 FELD

Felder sind Unterbereiche einer Maske, welche durch Feldnummern
unterschieden werden. Ihre Position und länge ist beliebig, die
Höhe ist auf genau eine Zeile festgelegt.
Feldern können bestimmte Merkmale zugeordnet werden (Untermenü
VORGABEN). In einem Anwenderprogramm werden Felder dann auf
zwei unterschiedliche Arten genutzt: Ein Feld kann eine Stelle der
Maske angeben, an der Ein-und Ausgaben gemacht werden. Eine
Gruppe von Feldern kann ein Menü bilden. Die Felder sind dann
die anwählbaren Positionen des Menüs.

Bei Feld-Operationen ist zu beachten, daß Felder nur innerhalb
einer Maske existieren können. Wird beispielsweise ein Feld aus dem
Maskenbereich rausgeschoben, so wird dieses Feld automatisch
gelöscht.
Ausserdem können niemals zwei Felder übereinander liegen. Würde
bei dem KOPIEREN eines Feldes ein anderes Feld überschrieben
werden, so würde diese Kopieraktion nicht ausgeführt werden.

ANLEGEN füllt den markierten Block mit Feldern, sofern sich dort
   keine alten Felder befinden. Hierbei wird pro Zeile des Blockes
   ein Feld erzeugt.
GRÖSSE ÄNDERN ändert die Breite der durch den markierten Block
   berührten Felder auf Blockbreite.
KOPIEREN kopiert die Felder im Block an die aktuelle
   Cursorposition.
VERSCHIEBEN verschiebt die Felder im markierten Block zur
   aktuellen Cursorposition.
LÖSCHEN: Alle Felder im markierten Block werden gelöscht.
NUMMERIEREN BELIEBIG nummeriert alle Felder mit Nummer 0
   beginnend und jeweils aufwärts zählend so, wie sie mit der
   linken Maustaste oder ENTER (wenn der Cursor drauf ist)
   angklickt werden.
ZEILENWEISE NUMMERIEREN nummeriert zeilenweise von links nach
   rechts alle Felder mit 0 beginnend.
SPALTENWEISE NUMMERIEREN nummeriert spaltenweise von oben
   nach unten mit 0 beginnend.
INFO gibt Information des durch den Cursor markierten Feldes
   aus. Durch Anklicken mit der linken Maustaste wird das
   gleiche Ergebnis erreicht. Angezeigt wird die komplette
   Beschreibung des Feldes, diese kann direkt geändert werden.



---------------------------------------------------------------
6.2.8 VORGABEN (für Felder)

Vorgaben sind die Feldmerkmale, die jedem neu erzeugtem Feld als
Grundeinstellung zugewiesen werden. Auch können einzelne
Vorgaben nachträglich in Feldern gesetzt werden. Die Vorgaben
können verändert werden.

EDITIEREN ermöglicht die Veränderung der Vorgaben.
LESEN ließt die Feldmerkmale des durch den Cursor markierten
   Feldes ein und macht diese zur neuen Vorgabe.
KOPIEREN ordnet den Feldern im markierten Block nachträglich
   das gesamte Bündel an Vorgaben zu.

Die verbleibenden Funktionen ordnen den Feldern im markierten
Block jeweil einzelne Vorgaben zu:

REVERS-ATTRIBUT  setzt das Reversattribut
EINGABE-ATTRIBUT setzt das Attribut für Eingaben
AUSGABE-ATTRIBUT setzt das Attribut für Ausgaben
INITIALISIERUNG bestimmt, ob ein Feld vor Beschreiben komplett
   gelöscht werden oder der nicbt überschriebene Teil des Feldes
   erhalten bleiben soll, falls die Ausgabe kürzer als das Feld ist.
   Diese Einstellung ist beispielsweise wichtig, wenn Felder
   gleichzeitig Menüpunkt als auch Ein/Ausgabefeld sein sollen:
   z.B.links im Feld die anwählbare Position, rechts im Feld der
   Ort der Eingabe.
FORMAT EINGABE (=1) erzeugt eine rechtsbündige Eingabe,
   ansonsten erfolgt die Eingabe linksbündig.
FORMAT AUSGABE (=1) erzeugt eine rechtsbündige Ausgabe,
   ansonsten erfolgt die Ausgabe linksbündig.
UEBERSCHREIBEN (=1) Eingabe-Editor arbeitet im Überschreib-
   Modus, ansonsten im Einfüge-Modus.
DATENTYP übernimmt für die Felder im Block Datentyp und
   Wertebereich der Vorgabe.


==================================================================
6.3 MASKENERSTELLUNG
==================================================================


---------------------------------------
6.3.1 Einfache Textmaske

Folgend findet sich eine kurze Beschreibung der Arbeitsschritte,
die zur Erstellung einer einfachen Textmaske erforderlich sind.

-     Zunächst ist der Masken- und Menügenerator WINEDIT zu
   starten.
-     Einmal auf der WINEDIT-Arbeitsfläche angekommen, beginnt man
   mit der textlichen Gestaltung der Maske:
    -     Man bewegt also jeweils die Schreibmarke mit den
       Pfeiltasten an die gewünschte Bildschirmposition.
    -     Dort schreibt man dann jeweils die Texte, die nachher Teil
       der Maske sein sollen.
-     Nun möchte man vielleicht den Text umrahmen, dazu
    -     geht man mit ESC oder F10 in das Untermenü BLOCK und
       wählt dort DEFINIEREN mit ENTER an;
    -     verändert nun mit den Pfeiltasten die Blockgröße so, daß
       der Block den zu umrahmenden Bereich markiert und
    -     schließt die Blockdefinition mit ENTER ab;
    -     geht man wieder mit ESC in das Untermenü BLOCK und
       wählt dort Umrahmen an.
    -     Im erscheinenden Rahmenmenü wählt man den
       gewünschten Rahmentyp mit den Pfeiltasten an und
       Bestätigt mit ENTER. Der Rahmen ist fertig.
-     Die Farbe der ganzen oder von Teilen der Maske soll
   verändert werden. Dazu
    -     legt man wie schon beschrieben den Bereich fest, indem
       man einen entsprechenden Block definiert;
    -     geht dann mit ESC oder F10 ins Untermenü TEXT und
       wählt dort ATTRIBUT an.
    -     sucht sich in der Farbtabelle etwas Hübsches aus und
       Bestätigt mit ENTER. Der ehemals markierte Block hat nun
       die gewünschte Farbe.
-     Soll die Maske später nicht den ganzen Bildschirm überdecken,
   so ist
    -     der eigentliche Teil der Maske (eben ohne Ränder) mit
       einem Block zu markieren und
    -     im Untermenü Maske die Maskengrösse entsprechen dem
       Block zu setzen.
-     Vor Beendigung des Maskengenerators sollte die Maske
   gesichert werden, indem man im Untermenü DATEI die Funktion
   SICHERN aufruft. Den angebotenen Standardnamen kann man
   durch einen beliebigen eigenen Namen ersetzen.

Die erzeugte Maske kann nun von einem Anwenderprogramm geladen
und benutzt werden. Mann kann sich nach Verlassen des
Maskengenerators das Ergebnis noch einmal anschauen, indem man
das Beispielprogramm MENUE mit dem Maskennamen als Parameter
aufruft (z.B. MENUE TEST.MSK).


------------------------------------------
6.3.2 EIN/AUSGABEMASKE

Die Rahmenhandlungen zur Erstellung einer Maske mit
Ein/Ausgabefeld gleichen denen wie in 6.3.1 beschrieben. Eine Stelle
der Maske, an der Ein- und Ausgaben gemacht werden können,
wird durch ein Feld gekennzeichnet. Es sind also lediglich
Arbeitsschritte zur Definition eines Feldes hinzuzufügen:

-     Durch Markieren eines Blockes ist der Ort der Ein/Ausgabe
   festzulegen. Geht dieser Block über mehrere Zeilen, so wird
   pro Zeile ein Feld in der Breite des Blockes angelegt.
-     Mit ESC und Pfeiltasten bewegt man sich in das Untermenü
   VORGABEN und wählt dort EDITIEREN an.
-     Die Feldvorgaben können nun wie gewünscht eingestellt
   werden:
    -     Beispielsweise läßt sich für Eingabe und Ausgabe getrennt
       Farbe und Format festlegen.
    -     Weiter kann vorgegeben werden, ob der Editor bei
       Eingaben im Einfüge- oder Überschreibmodus arbeitet.
    -     Es kann festgelegt werden, ob ein Feld vor Schreib- bzw.
       Leseaktionen komplett gelöscht werden soll oder ob nur
       der jeweils neu überschriebene Teil verändert wird.
    -     Jedem Feld kann ein Datentyp zugeordnet werden. Ferner
       kann der Wertebereich innerhalb dieses Datentyps pro
       Feld definiert werden.
-     Im Untermenü FELD wählt man nun die Position ANLEGEN: Im
   markierten Block werden nun Felder mit den gewählten
   Vorgaben angelegt. Die Felder werden mit Karos dargestellt.
-     Zur Kontrolle kann man nun in der Arbeitsfläche den Cursor
   auf eines der angelegten Felder bewegen.
-     Dann wählt man im Untermenü FELD INFO an: Eine Information
   zu angewählten Feld wird ausgegeben. Die eingestellten
   Vorgaben sind nun zu Merkmalen des Feldes geworden. Durch
   Betätigen der ENTER-Taste kann man die Feld-Merkmale auch
   direkt verändern, mit ESC gelangt man zurück in die
   Arbeitsfläche.
-     Die Feld-Information zeigt auch an, welche Nummer einem Feld
   zugeordnet ist. Die Nummer ist wichtig, da über sie das Feld
   im Programm angesprochen wird. Entspricht die
   Feldnummerierung nicht den Wünschen, so hat man im
   Untermenü FELD die Möglichkeit zur Umnummerierung.

Der Datentyp eines Feldes ist keine zwingende Vorgabe. Es gibt
programmtechnisch immer die Möglichkeit, ein Feld beispielsweise
als String-Feld und gleichzeitig auch als Datums-Feld zu benutzen.


------------------------------------------
6.3.3  MENÜMASKE

So wie Ein/Ausgabeorte der Maske als Felder definiert werden, wird
auch jede einzelne Position eines Menüs als Feld definiert. Somit ist
die Struktur der Menüs beispielsweise hinsichtlich der Lage der
einzelnen anwählbaren Positionen auf dem Bildschirm völlig wahlfrei.
Im Gegensatz zu den Ein/Ausgabefeldern interressiert für ein
Menüfeld lediglich die Vorgabe des Reversattributs. Dies ist die
Farbe, mit der eine ausgewählte Menüposition dargestellt wird.
Diese Farbe sollte sich somit möglichst vom Hintergrund abheben.
Ansonsten sind die gleichen Arbeitsschritte wie in 6.3.2
auszuführen.
Zu beachten ist, daß für ein sinnvolles Menü mindestens zwei
Felder notwendig sind, denn man sollte ja zwischen etwas
auswählen können.
Die Feldnummern haben folgende Bedeutung: die Menü-Funktion
W_SWITCH liefert jeweils die Nummer des angewählten Feldes als
Ergebnis zurück.

Natürlich kann ein Feld gleichzeitig Menüfeld als auch
Ein/Ausgabefeld sein, z.b. wenn die anwählbaren Aktionen variieren!



******************************************************************
7. INTERFACE
******************************************************************

Den einzelnen Routinenbeschreibungen ist jeweils der Funktionskopf
in C und Pascal-Syntax vorangestellt.


==================================================================
7.1  Basisroutinen
==================================================================

Die folgenden stellen die Basisroutinen der WINEDIT-Schnittstelle
dar und sind mithin für jegliche Maskenoperationen unverzichtbar.
Es lassen sich zwei Standard-Sequenzen zur Ausgabe einer Maske
angeben:

a) w_init->w_load    ->w_open->w_close             ->w_deinit
b) w_init    ->w_load->w_open->w_close->w_erase    ->w_deinit

Sequenz a) ist zu verwenden, wenn die Maskendateien am
Programmanfang einmalig geladen werden.
Sequenz b) ermöglicht ein Laden von Masken im Bedarfsfall, nach
Abbrauch der Maske wird diese dann wieder aus dem Speicher
entfernt.



-------------------------------------------------------
int w_init(int bios)
function  w_init(bios:integer):integer;

w_init führt die Initialisierung zur Verwendung der WINEDIT-
Routinen durch und ist damit grundsätzlich als erste der WINEDIT-
Routinen aufzurufen. In w_init wird die Mausinitialisierungsroutine
w_mous_init() aufgerufen. Der Parameter <bios> bestimmt, ob ein
direkter Zugriff auf den Bildspeicher erfolgt oder die wesentlich
langsameren Bios-Routinen verwendet werden. Eine Standard-
Attribut-Umsetztabelle wird aktiviert. Diese führt bei Farbmonitoren
zu keiner Umsetzung, bei Monochrom-Monitoren werden die
Attribute 71hex bis 7fhex auf 70hex (Revers!) abgebildet.

Parameter

bios= 0        : Direkter Zugriff;
bios<>0;       : Bios-Routinen;

Ergebnis

1    : Maus konnte in Betrieb genommen werden
0    : Maus fehlerhaft oder nicht vorhanden



-------------------------------------------------------
void w_deinit(void)
function  w_deinit:integer;

W_deinit schließt die Verwendung der WINEDIT-Routinen ab und ist
somit grundsätzlich vor Beendigung eines Programms aufzurufen.
Eventuell noch geöffnete Masken werden geschlossen, der allokierte
Speicherbereich wird wieder freigegeben. Bei angeschlossener Maus
muß diese Funktion u n b e d i n g t vor Verlassen des Programms
aufgerufen werden, ansonsten führen nachfolgende Mausaktionen
unweigerlich zum Systemabsturz.



-------------------------------------------------------
int w_error(void)
function  w_error:integer;

w_error liefert die Nummer des seit dem vorletzten Aufruf von
w_error zuletzt aufgetretenen Fehlers zurück. Die interne
Fehlervariable wird also zurückgesetzt, so daß ein zweimaliges
Aufrufen mit dem zweiten Aufruf den Returnwert 0 liefert.

Ergebnis

 0,   : kein Fehler
 1   : Kein Speicher verfügbar
 2   : Masken-Maximalzahl erreicht
 3   : Maskendatei nicht gefunden
 4   : Masken datei nicht gefunden in der Bibliothek
 5   : Maskendatei ist fehlerhaft
 6   : Maskendatei ist fehlerhaft in der Bibliothek
10   : Maskennummer ist unzulässig
11   : Feldnummer ist unzulässig
13   : Libary-Datei nicht gefunden
14   : Libary-Datei ist fehlerhaft
15   : Maske hat kein virtuelles Bild


-------------------------------------------------------
int w_load(char *filename,int mode)
function  w_load(filename:string; mode:integer):integer;

w_load lädt eine Maskendatei, also eine kodierte Beschreibung der
Bildschirmmaske, in den Arbeitsspeicher. Die Maske erscheint nicht
auf dem Bildschirm.
 Mit dem Parameter mode wird festgelegt, ob der Maske ein
virtueller Bildschirm im Arbeitsspeicher des Rechners zugeordnet
werden soll. Die Zuordnung eines virtuellen Schirms erfordert
Zeilen*Spalten*2 zusätzliche Bytes an Speicher.
 Nicht erforderlich ist ein virtueller Schirm, wenn lediglich immer
die ursprügliche Bildschirmmaske, wie sie im Maskengenerator
erstellt wurde, ausgegeben werden soll. Irgendwelche
Veränderungen auf der Bildschirmmaske, beispielsweise durch Ein-
und Ausgaben würden nach Schließen und erneutem Öffnen der
Maske verloren gehen und müßten gegebenenfalls nachgeschrieben
werden .
 Erforderlich ist der virtuelle Schirm, wenn beim Schließen einer
Maske der aktuelle Maskeninhalt erhalten bleiben soll. Auch ist
seine Verwendung sinnvoll, wenn eine Vielzahl von Ausgaben auf
eine Maske auszuführen sind. Die Ausgaben können dann auf den
virtuellen Schirm erfolgen, mit dem Öffnen der Maske erscheinen
das komplette Bild. Ist das Ergebnis der Funktion 0 oder positiv,
so ist dies die Masken(referenz)nummer, mit der die Maske
adressiert wird.
Ein negatives Ergebnis erhält man im Fehlerfall, die Fehlernummer
ist dann mit w_error() zu ermitteln.

Parameter

mode = 0: Virtuelles Bild wird eingerichtet
mode = 1: Kein virtuelles Bild

Ergebnis

  0-255   : Maskennummer (wnum)
< 0       : Fehler



-------------------------------------------------------
int w_open(int wnum)
function  w_open(wnum:integer):integer;

w_open gibt eine Maske auf den Bildschirm aus. Existiert zur Maske
ein virtueller Schirm, so wird dessen Inhalt sichtbar. Andernfalls
wird ein temporärer virtueller Schirm eingerichtet. Das Maskenbild
wird aus der kodierten Maskenbeschreibung erzeugt und
ausgegeben, der temporäre Schirm wird wieder verworfen. Der
Hintergrund der Maske wird gesichert, so daß er beim Schließen
der Maske wiederhergestellt werden kann.

Ergebis

1   : Erfolgreiche Ausführung
0   : Fehler



-------------------------------------------------------
int w_close(void)
function  w_close:integer;

w_close nimmt die zuletzt geöffnete Maske vom Bildschirm, der
ursprüngliche Bildinhalt wird wiederhergestellt. Existiert zur Maske
ein virtueller Schirm, so wird die zu schließende Maske mit ihrem
aktuellen Inhalt auf diesen geschrieben.

Ergebnis

1    : Eine Maske konnte geschlossen werden
0    : Es war keine Maske mehr geöffnet


-------------------------------------------------------
int w_erase(int wnum)
function  w_erase(wnum:integer):integer;

w_erase löscht die kodierte Maskenbeschreibung im Speicher, die
Maskennummer <wnum> verliert ihre Gültigkeit.
Vor erneuter Verwendung der Maske muß diese mit w_load(..) erst
wieder geladen werden. w_erase darf nur auf geschlossene Masken
angewendet werden.
Sinnvoll ist die Verwendung von w_erase, wenn beispielsweise
Hilfstextmasken aus Speicherplatzgründen erst bei Bedarf zugeladen
und anschließend komplett aus dem Speicher beseitigt werden
sollen.

Ergebnis

1    : Fehlerfreie Ausführung
2    : Fehler (ungültige Maskennummer)



-------------------------------------------------------
int w_lib_open(char *lib_name)
function  w_lib_open(name:string):integer;

w_lib_open eröffnet eine Maskenbibliothek. Nachfolgende Aufrufe
von w_load beziehen sich dann auf die in <lib_name> angegebene
Maskenbibliothek, die Maskendateien werden ausschließlich in dieser
gesucht. Es können nicht mehrere Maskenbibliotheken zur gleichen
Zeit geöffnet sein.
Zum Anlegen einer Maskenbibliothek ist das Hilfsprogramm WINLIB
zu verwenden.

Ergebnis

1    : Die Maskenbibliothek konnte eröffnet werden
0    : Fehler


-------------------------------------------------------
int w_lib_close(void)
function  w_lib_close:integer;

w_lib_close schließt eine zuvor geöffnete Maskenbibliothek, w_load
sucht anschließend die Maskendateien wieder als eigenständige
Dateien.

Ergebnis

1    : Die Maskenbibliothek konnte geschlossen werden
0    : Fehler


-------------------------------------------------------
void w_setcolors(byte colortable[256]);
procedure w_setcolors(colortable:pointer);

Mit dieser Funktion wird eine Attribut-Umsetztabelle geladen. Jedes
Attribut i wird nachfolgend durch das Attribut <colortable[i]>
ersetzt. Da w_init eine Standard-Umsetztabelle erzeugt, ist ein
Aufruf von w_setcolors nur nach w_init sinnvoll, muß jedoch vor
dem Laden (mit w_load) einer umzusetzenden Maske erfolgen.



-------------------------------------------------------
byte *w_getcolortable(void);
function  w_getcolortable:pointer;

Liefert einen Zeiger auf die interne Attribut-Umsetztabelle, in der
die jeweils zuletzt gesetzte Tabelle gespeichert ist.

Ergebnis: Zeiger auf die Attribut-Tabelle



==================================================================
7.2 Tastatur und Maus
==================================================================
Die folgenden zwei Routinen verwalten Maus und Tastatur, wobei
Mausaktionen benutzerseitig als erweiterte Tastaturcodes
erscheinen. Genaugenommen liefern die Funktionen als Ergebnis
Zahlwerte, welche entsprechend den Definitionen in W_DEF.H bzw.
W_TBP_XX.IFC bzw. dem ASCII-Code zu interpretieren sind.


-------------------------------------------------------
int w_kbd(int mode)
function  w_kbd(mode:integer):integer;

w_kbd liefert Zeichen von der Tastatur. In der Betriebsart
REQUEST ( <mode> = 1 ) wird auf ein einlaufendes Zeichen
gewartet, dieses wird dann als Ergebnis zurückgeliefert. In der
Betriebsart SAMPLE ( <mode> = 0 ) wird nach einem eventuell
vorhandenen Zeichen der Tastatur abgefragt. Ist ein Zeichen
vorhanden, so wird dieses als Ergebnis zurückgeliefert. Ansonsten
ist das Ergebnis 0. Der Tastaturcode ist den Definitionen der
Header-Datei W_DEF.H (TURBO-C) bzw. der Datei W_TBP_XX.IFC
(TURBO-Pascal) zu entnehmen.


Parameter

mode = 0 : SAMPLE-Mode
mode = 1 : REQUEST-Mode


Ergebnis

0     : Kein Zeichen vorhanden ( Nur SAMPLE-Mode )
sonst : Tastencode



-------------------------------------------------------
int w_mousekbd(int mode)
function  w_mousekbd(mode:integer):integer;

w_mousekbd arbeitet bezogen auf Tastaturaktionen genau wie
w_kbd, zusätzlich werden den verschiedenen Mausaktionen
Zahlwerte zugeordnet. Eine mögliche Mausaktion ist das kurze
Anklicken einer Maustaste, genaugenommen das Drücken und
Loßlassen der Taste ohne die Maus zu bewegen, . Man erhält dann
die unter den Definitionen MOUSE_R_B (rechter Knopf), MOUSE_L_B
(linker Knopf) oder MOUSE_M_B (mittlerer Knopf) verborgenen
Zahlwerte. Wird die Maustaste länger gedrückt, so erhält man statt
dessen die Werte MOUSE_R_B_P, MOUSE_L_B_P oder MOUSE_M_B_P,
das .._P steht für 'Pressed'. Wenn Tasten gedrückt werden, so
werden sie auch irgendwann wieder losgelassen. Das Loslassen wird
mit den Zeichen MOUSE_R_B_R, MOUSE_L_B_R oder MOUSE_M_B_R
mitgeteilt, das .._R steht für 'Released'. Wird die Maus bewegt, so
empfängt man über w_mousekbd das Zeichen MOUSE_MOVE. Mit der
Funktion w_mousekbd zusammenwirkende Funktionen, z.B zum
Ermitteln von Mauskoordinaten, finden sich im Kapitel Maus-
Routinen.



==================================================================
7.3  Freie Ein- und Ausgabe
==================================================================

Die hier beschriebenen Routinen dienen der Ein- und Ausgabe
unter Vernachlässigung der feldspezifischen Datentypen und
Wertebereiche. Im Maskengenerator lassen sich folgende
Feldeigenschaften definieren: Ausgabeformat (links oder
rechtsbündig), Attribut, Löschen des Feldes vor Verwendung,
Einfüg oder Überschreib-Modus bei Eingaben, Datentypen und
Wertebereiche.
Die Basis-Ausgabefunktion ist w_out_str, die entsprechende Basis-
Eingabefuntion ist w_in_str. Mit Hilfe dieser Basis-Funktionen
werden alle weiteren Ein- und Ausgabefunktionen realisiert. Die bei
den Basis-Funktionen gemachten Angaben haben also für weitere
Funktionen Gültigkeit, so sind beispielsweise die Returnwerte der
Ein-Ausgaberoutinen einheitlicht wie folgt festgelegt: 1 steht für
erfolgreiche Ausführung, -1 steht für einen Abruch durch ESC. Mit
-3 werden Fehler angezeigt, -2 weist auf einen Abbruch durch eine
Fremdtaste hin.



-------------------------------------------------------
int w_out_str(int wnum,int field,char *s)
function w_out_str(wnum,field:integer;s:string):integer;

w_out_str gibt den String <s> auf das Feld <field> der Maske
<wnum> aus. Existiert die angegebene Masken- bzw. Kanalnummer
nicht, so erfolgt die Ausgabe an der aktuellen Cursor-Position. Die
Ausgabe erfolgt direkt auf den Bildschirm.

Ergebnis

1    : Erfolgreiche Ausführung
-3   : Ausgabe an aktueller Position



-------------------------------------------------------
int w_vout_str(int wnum,int field,char *s)
function w_vout_str(wnum,field:integer;s:string):integer;

w_vout_str gleicht im wesentlichen w_out_str, die Ausgabe erfolgt
auf den virtuellen Schirm.

Ergebnis

1    : Erfolgreiche Ausführung
-3   : Fehler



-------------------------------------------------------
int w_printf(int wnum, int field,va_list arg_list, ...)
Im Pascal-Interface nicht verfügbar

w_printf führt eine formatierte Ausgabe auf den Feld <field> der
Maske <wnum> aus. Die Parameterliste va_list arg_list (!),.. ist in
gleicher Weise wie bei der Standard-C-Funktion printf anzugeben,
also erst der Formatstring und dann folgend eventuelle Variablen.
Die Ausgabe erfolgt direkt auf den Bildschirm. Diese Funktion ist
nicht im Pascal-Interface verfügbar!


-------------------------------------------------------
int w_vprintf(int wnum, int field,va_list arg_list, ...)
Im Pascal-Interface nicht verfügbar

w_vprintf gleicht im wesentlichen w_printf, die Ausgabe erfolgt auf
den virtuellen Schirm. Diese Funktion ist nicht im Pascal-Interface
verfügbar!


-------------------------------------------------------
void w_out_temp_attribute(uchar attribute)
procedure w_out_temp_attribute(attribute:byte);

w_out_temp_attribute überschreibt das Feld-Attribut mit dem
Parameter <attribute>. Die nächste Ausgabeoperation auf Bildschirm
oder virtuellem Schirm erfolgt also in der 'Farbe' <attribute>



-------------------------------------------------------
void w_out_temp_format(int format);
procedure w_out_temp_format(format:integer);

w_out_temp_format überschreibt das Feld-Format mit dem Parameter
<format>. Die nächste Ausgabeoperation auf Bildschirm oder
virtuellem Schirm erfolgt also in dem angegebenen Format.

Parameter:

format = 0: Ausgabe linksbündig
format = 1: Ausgabe rechtsbündig



----------------------------------------------
int w_vout(int wnum)
function  w_vout(wnum:integer):integer;

w_out gibt das virtuelle Bild einer mit <wnum> zu spezifizierenden
Maske auf den Bildschirm aus. Der Hintergrund wird nicht
gesichert. In der Regel ist diese Funktion zu verwenden, wenn das
Bild einer schon geöffneten Maske mit dem im Hintergrund
aufgebauten virtuellen Bild zu überschreiben ist.

Ergebnis

1    : Fehlerfreie Ausführung



----------------------------------------------
int  w_out_byte(int wnum,int fnum,byte b);
function  w_out_byte(wnum,fnum:integer;b:byte):integer;


w_out_byte gibt das Byte <b> auf das Feld <field> der Maske
<wnum> unter Verwendung der Funktion w_out_str aus. Alle
Angaben zu w_out_str haben entsprechen Gültigkeit.


----------------------------------------------
int  w_vout_byte(int wnum,int fnum,byte b);
function  w_vout_str(wnum,field:integer;s:string):integer;

Virtuelle Version zu w_vout_byte;


----------------------------------------------
int  w_out_char(int wnum,int fnum,char c);
function  w_out_char(wnum,fnum:integer;c:char):integer;

Siehe w_out_byte !


----------------------------------------------
int  w_vout_char(int wnum,int fnum,char c);
function  w_vout_char(wnum,fnum:integer;c:char):integer;

Siehe w_vout_byte !



----------------------------------------------
int  w_out_int(int wnum,int fnum,int i);
function  w_out_int(wnum,fnum,i:integer):integer;

Siehe w_out_byte !


----------------------------------------------
int  w_vout_int(int wnum,int fnum,int i);
function  w_vout_int(wnum,fnum,i:integer):integer;

Siehe w_vout_byte !


----------------------------------------------
int  w_out_word(int wnum,int fnum,word w);
function  w_out_word(wnum,fnum:integer;w:word):integer;

Siehe w_out_byte !


----------------------------------------------
int  w_vout_word(int wnum,int fnum,word w);
function  w_vout_word(wnum,fnum:integer;w:word):integer;

Siehe w_vout_byte !


----------------------------------------------
int  w_out_long(int wnum,int fnum,long l);
function  w_out_longint(wnum,fnum:integer;l:longint):integer;

Siehe w_out_byte !


----------------------------------------------
int  w_vout_long(int wnum,int fnum,long l);
function  w_vout_longint(wnum,fnum:integer;l:longint):integer;

Siehe w_vout_byte !


----------------------------------------------
int  w_out_double(int wnum,int fnum,double *d);
function  w_out_double(wnum,fnum:integer;var d:double):integer;

Siehe w_out_byte !


----------------------------------------------
int  w_vout_double(int wnum,int fnum,double *d);
function  w_vout_double(wnum,fnum:integer;var d:double):integer;

Siehe w_vout_byte !


----------------------------------------------
int  w_out_date(int wnum,int fnum,DAte *d);
function  w_out_date(wnum,fnum:integer;var d:DAte):integer;

Der Datums-Datentyp DAte findet sich in den Schnittstellen-
Beschreibungen. Siehe auch w_out_byte !


----------------------------------------------
int  w_vout_date(int wnum,int fnum,DAte *d);
function  w_vout_date(wnum,fnum:integer;var d:DAte):integer;

Virtuelle Version zu w_out_date.
Siehe w_vout_byte !


----------------------------------------------
int  w_out_time(int wnum,int fnum,TIme *d);
function  w_out_time(wnum,fnum:integer;var t:time):integer;

Der Uhrzeit-Datentyp TIme findet sich in den Schnittstellen-
Beschreibungen. Siehe w_out_byte !


----------------------------------------------
int  w_vout_time(int wnum,int fnum,TIme *d);
function  w_vout_time(wnum,fnum:integer;var t:time):integer;

Virtuelle Version zu w_out_time.
Siehe w_vout_byte !


----------------------------------------------
int  w_out_dmark(int wnum,int fnum,DMark *d);
function  w_out_dmark(wnum,fnum:integer;var d:DMark):integer;

Der Währungs-Datentyp DMark findet sich in den Schnittstellen-
Beschreibungen. Siehe w_out_byte !


----------------------------------------------
int  w_vout_dmark(int wnum,int fnum,DMark *d);
function  w_vout_dmark(wnum,fnum:integer;var d:DMark):integer;

Virtuelle Version zu w_out_dmark.
Siehe w_vout_byte !


-------------------------------------------------------
int w_in_str(int wnum,int field,int strlen,char *s,char *legal)
function  w_in_str(wnum,field,stringlen:integer;var
s:string;legal:string):integer;

w_in_str ließt einen String der maximalen Laenge <strlen> im Feld
<field> der Maske <wnum> ein, wobei lediglich die in <legal>
angegebenen Zeichen akzeptiert werden.
Die Länge des einzulesenden Strings <strlen> kann größer als die
Länge des Feldes sein, das notwendige  Scrollen wird automatisch
ausgeführt. Ist <strlen> mit 0 angegeben, so wird ein String mit
maximal der Feldlänge + 1 eingelesen. Eingabe-Attribut und Format
sowie Schreib-Modus werden durch die Felddefinitionen der Maske
bestimmt. Das Eingabeformat kann links- als auch rechtsbündig
erfolgen.
Wird nacheinander der gleiche String editiert, so bleibt der Cursor
an der jeweils zuletzt aktuellen Position stehen.
Der Initial-Schreib-Modus (Überschreiben oder Einfügen ) ist an
der Cursor-Gestalt erkennbar. Während des Einlesens stehen die
üblichen Tasten zum Editieren zur Verfügung ([Home], [End], [->],
[<-], [Backspace], [Insert]. Die Eingabe wird mit [CR] bestätigt, ein
Abbruch erfolgt mit [ESC]. Ein Abbruch bei Fremd-Tasten ist mit
der Funktion w_in_break_on_key einstellbar . Die erste Taste des
Editors kann vorgegeben , die letzte Taste abgefragt werden.


Ergebnis:

1    : Eingabe wurde mit [CR] abgeschlossen
-1   : Eingabe wurde mit [ESC] abgebrochen
-2   : Eingabe wurde durch Fremdtaste abgebrochen
-3   : Fehler


-------------------------------------------------------
int  w_in_break_on_key(int mode);
function  w_in_break_on_key(mode:integer):integer;

Bewirkt, das der Zeileneditor w_in_str und alle Eingabe-Funktionen,
die diesen benutzen, bei Fremdtasten abbrechen. Die jeweilige Taste
ist mit w_in_last_key ermittelbar.

Parameter:

mode = 0 : Kein Abbruch
mode = 1 : Abbruch bei Fremdtasten ausser MOUSE_MOVE
mode = 2 : Abbruch bei Fremdtasten einschließlich MOUSE_MOVE
mode = -1: Keine Veränderung, zb. zur Abfrage !

Ergebnis:

Zuletzt eingestellter mode-Wert


-------------------------------------------------------
int  w_in_last_key(void);
function  w_in_last_key:integer;

Liefert unbedingt die zuletzt in w_in_str (und w_in_str benutzende
Funktionen) verwendete Taste !

Ergebnis:

Letzte Taste


-------------------------------------------------------
void w_in_first_key(int key);
function  w_in_last_key:integer;

Gibt die erste Taste für den Zeileneditor w_in_str vor. So  würde
dieser beispielsweise bei einem vorgegebenen KEY_ESC sofort
wieder abbrechen.

Parameter:

key : Erste Taste im Zeileneditor


-------------------------------------------------------
void w_in_reset_curpos(void);
procedure w_in_reset_curpos;

w_in_str behält die aktuelle Cursorposition bei, wenn nacheinander
der gleiche String editiert wird. Dies läßt sich durch Aufruf von
w_in_reset_curpos für den folgenden Aufruf von w_in_str
unterbinden.




-------------------------------------------------------
int w_in_long(int wnum,int field,long *destin,long min,long max)
function w_in_longint(wnum,field:integer;var destin:longint;
                      min,max:longint):integer;

w_in_long ließt einen 'long' im Wertebereich von <min> bis <max>
ein. <destin> ist ein Zeiger auf die Zielvariable, in die der Wert
geschrieben werden soll. Intern ruft w_in_long die Funktion
w_in_str auf, so daß die Angaben über Tastenfunktionen von dort
zu übernehmen sind. Die Programmierung weiterer solcher
Funktionen unter Verwendung von w_in_str ist denkbar.



-------------------------------------------------------
int w_in_word(int wnum,int field,word *destin,word min,word max)
function  w_in_word(wnum,field:integer;var destin:word;min,
                    max:word):integer;

Eigabe im Format Word, ansonsten wie w_in_long


-------------------------------------------------------
int w_in_int(int wnum,int field,int *destin,int min,int max)
function w_in_int(wnum,field:integer;var destin:integer;
                 min,max:integer):integer;

Eigabe im Format Integer, ansonsten wie w_in_long



-------------------------------------------------------
int w_in_int(int wnum,int field,int *destin,int min,int max)
function w_in_int(wnum,field:integer;var destin:integer;
                 min,max:integer):integer;

Eigabe im Format Integer, ansonsten wie w_in_long



-------------------------------------------------------
int  w_in_double(int wnum,int fnum,double *destin,double
*min,double *max);
function  w_in_double(wnum,fnum:integer;var
destin,min,max:double):integer;

Eigabe im Format Double, ansonsten wie w_in_long. Der Double-Wert
kann in beliebigem Double-Format ( Exponential oder Festpunkt-
Darstellung usw. ).


-------------------------------------------------------
int  w_in_date(int wnum,int fnum,DAte *destin,DAte *min,DAte *max);
function  w_in_date(wnum,fnum:integer;var
destin,min,max:DAte):integer;

Eigabe im Format DAte, ansonsten wie w_in_long. Die Eingabe muß
im Format Tag.Monat.Jahr (z.B., 25.3.1997) erfolgen, wobei die
Jahreszahl vollständig anzugegeben ist. Schaltjahre werden
berücksichtigt, so daß z.B. die Eingabe vom 29.2.91 nicht akzeptiert
werden würde.


-------------------------------------------------------
int  w_in_time(int wnum,int fnum,TIme *destin,TIme *min,TIme *max);
function  w_in_time(wnum,fnum:integer;var
destin,min,max:TIme):integer;

Eigabe im Format TIme, ansonsten wie w_in_long. Die Eingabe muß
im Format Stunde:Minute:Sekunde  (z.B., 23:11:00) erfolgen.


-------------------------------------------------------
int  w_in_dmark(int wnum,int fnum,DMark *destin,DMark *min,DMark
*max);
function  w_in_dmark(wnum,fnum:integer;var
destin,min,max:DMark):integer;

Eigabe im Format DMark, ansonsten wie w_in_long. Das DMark-
Format setzt sich aus eine Mark und einen Pfennig-Anteil, getrennt
durch ein Komma, zusammen. Für fehlende Anteile kann ein -
angegeben werden. (z.B. -,90  -,-  12  23,99)



==================================================================
7.4 Feldtyp-Gebundene Ein- und Ausgabe
==================================================================

Die folgenden Routinen berücksichtigen im Gegensatz zu denen der
freien Ein-und Ausgabe den jedem Feld zugeordneten Datentyp und
dessen Wertebereich. Dadurch lassen sich sehr komfortable
vollautomatisierte komplexe Ein- und Ausgabeoperationen mit
beispielsweise nur einem Funktionsaufruf realisieren. Ansonsten
sind alle über die freie Ein-und Ausgabe gemachten Aussagen auch
hier gültig.


-----------------------------------------------------------
int w_in_struct(int wnum,int first,int last,void *destin);
function  w_in_struct(wnum,first,last:integer;var destin):integer;

w_in_struct ließt in einer Eingabeschleife Werte der Felder <first>
bis <last> der Maske vollautomatisch ein. Dabei werden die den
Feldern zugeordneten Datentypen sowie deren Wertebereiche
berücksichtigt. Die Ergebisse werden in der Reihenfolge der
Feldnummern an die durch <destin> bezeichnete Speicherstelle
geschrieben. Die Speicherstelle sollte einer Datenstruktur
zugeordnet sein, die den Felddefinitionen entspricht.
Zur Vermeidung von Fehlern kann mit der Funktion w_struct_sizeof
die Größe des zu beschreibenden Speicherbereichs ermittelt werden.

w_in_struct wird gebildet aus einer Kombination der jeweiligen
Eingabefunktionen des Datentyps mit der Funktion w_switch zur
menüartigen Anwahl des jeweils zu bearbeitenden Feldes.
Der Feldzugriff erfolgt also nicht in einer Sequenz sondern
vielmehr wahlfrei.

Entscheident für die Arbeitsweise sind die Einstellungen, die vor
Aufruf von w_in_struct an den Funktionen w_in_str und w_switch
bezüglich der break_on_key-Funktionen vorgenommen wurden.

Führt keine der beiden Funktionen einen Abbruch bei Fremdtasten
aus, so gilt folgendes: Die Anwahl eines Feldes zum Beschreiben
erfolgt mit Enter-Taste bzw. linker Maustaste, zur Menü-Ebene
gelangt man mit den gleichen Tasten oder ESC bzw. rechter
Maustaste zurück.

Bricht beispielsweise die Eingabe mit einer Fremdtaste ab, so wird
diese Fremdtaste an w_switch weitergereicht und kann z.b. dort
schon ein Anspringen des nächsten Feldes bewirken.
Umgekehrt würde ein Abbruch von w_switch bei z.B. einer
Buchstabentaste dazu führen, daß diese Taste in w_in_.. schon zum
Beschreiben eines Feldes verwendet werden würde.
Nur wenn beide beide Funktionen (w_in.. und w_switch) bei
Fremdtasten abbrechen, bricht auch w_in_struct bei einer
Fremdtaste ab. Ansonsten würde die Fremdtaste beim Weiterreichen
von w_in.. zu w_switch (oder umgekehrt) hängenbleiben.


Parameter:

wnum  : Maskennummer
first : Nummer des ersten zu bearbeitenden Feldes
last  : Nummer des letzten zu bearbeitenden Feldes
destin: Zeiger auf Zielstruktur

Ergebnis:

siehe w_in_str bzw.  w_switch


-------------------------------------------------------
int  w_struct_sizeof(int wnum,int first,int last);
function  w_struct_sizeof(wnum,first,last:integer):integer;

Ermittelt den durch die von <first> bis <last> bezeichnete
Feldsequenz belegten Speicherplatz in Bytes. Die Größe von String-
Typen ist durch die Länge des Feldes + einem weiteren Byte
festgelegt. Ist <first> = <last>, so ermittelt man die Größe des
Datentyps eines Feldes. (siehe auch w_in_struct). Sollte die Größe
wiederholt differieren, so könnte in der Entwicklunsumgebung
WORD-ALIGNMENT (Ausrichtung auf Wortgrenzen des Speichers !)
eingestellt sein, so daß Strukturen u.U. Lücken enthalten.


wnum  : Maskennummer
first : Nummer des ersten zu zählenden Feldes
last  : Nummer des letzten zu zählenden Feldes

Ergebnis:

>=0  :  Anzahl der Bytes
sonst:  Fehler


-------------------------------------------------------
int w_struct_init(int wnum,int first,int last,void *destin,int max);
function  w_struct_init(wnum,first,last:integer;var
destin;max:integer):integer;

Initialisert eine Datenstruktur mit den Minimal oder Maximalwerten,
die jedem Feld zugeordnet sind. String-Typen werden mit
Leerzeichen belegt. Siehe auch w_in_struct !

Parameter:

wnum  : Maskennummer
first : Nummer des ersten zu bearbeitenden Feldes
last  : Nummer des letzten zu bearbeitenden Feldes
destin: Zeiger auf Zielstruktur


-------------------------------------------------------
int  w_out_struct(int wnum,int first,int last,void *source);
function  w_out_struct(wnum,first,last:integer;var source):integer;

Gibt eine Datenstruktur auf zuzuordnende Maskenfelder aus. Siehe
auch w_in_struct.

Parameter:

wnum  : Maskennummer
first : Nummer des ersten zu bearbeitenden Feldes
last  : Nummer des letzten zu bearbeitenden Feldes
source: Zeiger auf die Quelldaten


-------------------------------------------------------
int  w_vout_struct(int wnum,int first,int last,void *source);
function  w_vout_struct(wnum,first,last:integer;var source):integer;

Virtuelle Version von w_out_struct.



-------------------------------------------------------
int w_in_field(int wnum,int fnum,void *destin);
function  w_in_field(wnum,fnum:integer;var buffer):integer;

Ließt einen der Feldefinition von <fnum> entsprechenden Wert mit
Hilfe von w_in_str(..) ein und schreibt diesen an die durch <destin>
gekennzeichnete Speicherstelle.

Ergebnis

1  : OK
-1 : ESC
-2 : Fremdtaste
-3 : Fehler

-------------------------------------------------------
int w_out_field(int wnum,int fnum,void *source);
function  w_out_field(wnum,fnum:integer;var buffer):integer;

Gibt einen Wert auf das Feld <fnum> aus. Die durch <source>
angegebene Speicherstelle wird dabei entsprechend der
Feldefinition von <fnum> interpretiert.

Ergebnis

1  : OK
-3 : Fehler


-------------------------------------------------------
int w_vout_field(int wnum,int fnum,void *source);
function  w_vout_field(wnum,fnum:integer;var buffer):integer;

Virtuelle Version von w_out_field(..).


==================================================================
7.5  Menü-Verwaltung
==================================================================

Folgende Routinen dienen dem Aufbau von Menüs nahezu jeglicher
Ausprägung. Sie adaptieren sich den jeweiligen Feld-Definitionen
der Masken.


-------------------------------------------------------
int w_switch(int wnum)
function  w_switch(wnum:integer):integer;

w_switch ist eine Funktion zum Aufbau vollständig
mausunterstützter Menüs beliebiger Ausprägung. Das Konzept ist
folgendes: Im Maskengenerator WINEDIT werden die einzelnen
Schirmbilder, welche die Menüs ausmachen, erstellt. Die anwählbaren
Positionen des Menüs, also Worte oder Wortgruppen einer Zeile,
werden im Maskengenerator als Felder definiert und nummeriert.
Diese Information ist in der mit w_load geladenen
Maskenbeschreibung enthalten und wird bei Aufruf von w_switch
gelesen. w_switch veranlasst nun, daß eine Auswahl zwischen den
Feldern der Maske <wnum> getroffen werden kann. Das jeweils
angewählte Feld wird mit einer im Maskengenerator frei wählbaren
Farbe, dem Revers-Attribut, markiert. Der Anwender kann nun
mittels Cursortasten oder Mauszeiger die Markierung auf den
Feldern wandern lassen. In der Standardkonfiguration wird eine
Bestätigung der Anwahl mit einem [CR] oder der linken Maustaste
erzielt, ein Abbruch erfolgt bei [ESC] oder rechter Maustaste. Die
Reihenfolge des Feldmarkierens bei Benutzung der Cursortasten
erfolgt nicht nach den Nummern der Felder, vielmehr wird so
Verfahren, daß in der Regel die vom Anwender visuell als
naheliegendst empfundene Veränderung ausgeführt wird. Es sind
also beispielsweise auch in einer Hilfstextmaske diffus verteilt
liegende Felder sinnvoll anwählbar.
Über nachfolgend beschriebene Funktionen ist w_switch vielfältig
konfigurierbar, die Konfiguration ist maskenspezifisch, w_switch
kann also bei jeder Maske anders agieren. Der problemlose Aufbau
hirachischer Menüs ist möglich, selbst die Bewegung des
Mauszeigers auf Felder zuvor geöffneter Masken wird erkannt. Die
dazu notwendige Programmstruktur ist dem Beispiel, dort
insbesondere der Routine MENUE, zu entnehmen.


Ergebnis

0 - 255 Feldnummer des angewählten Ortes
-1      Abbruch
-2      Fremde Taste ( siehe w_switch_break_on_key() )
-3      Fehler



-------------------------------------------------------
int w_switch_pos(int wnum,int position)
function  w_switch_pos(wnum,position:integer):integer;

w_switch_pos setzt, wenn <position> eine gültige Feldnummer der
Maske <wnum> darstellt, die Nummer des markierten Feldes für den
nächsten Aufruf von w_switch auf eben <position>.
Das Ergebnis der Funktion ist die aktuell markierte Feldnummer,
ein Aufruf wie w_switch_pos(wnum,-1) liefert also die aktuelle
Position, ändert sonst nichts.

Ergebnis

0 - 255 : Aktuell markierte Position
< 0     : Fehler ( Ungültige Maskennummer <wnum> )


-------------------------------------------------------
int w_switch_first_key(int wnum,int key)
function w_switch_first_key(wnum,key:integer):integer;

w_switch_first_key gibt die erste Taste in w_switch vor; d.h. das
die erste Taste nicht von Tastatur oder Maus gelesen wird. Somit
kann man z.B. durch vorrangehendes Positionieren (w_switch_pos)
und Vorgeben der ENTER-Taste ein automatisches Ausführen von
Menüs erzeugen.Siehe auch w_switch_visible_cr ..


-------------------------------------------------------
int w_switch_last_key(int wnum)
function  w_switch_last_key(wnum:integer):integer;

w_switch_last_key liefert den Wert der in w_switch bei Anwendung
auf Maske <wnum> zuletzt gedrückten Taste als Ergebnis. Aktionen
der Maus werden auch als Tasten ausgewertet. Ein Abbruch kann
erfolgt sein durch KEY_ESC oder rechter Maustaste (MOUSE_L_B),
wenn w_switch_mouse_esc(..,1) eingestellt war kann auch ein
MOUSE_MOVE die letzte Taste gewesen sein.
Soll w_switch mit jeder Fremdtaste abbrechen, ist also
w_switch_break_on_key(..,1) eingestellt, so kann mit
w_switch_last_key diese Fremdtaste ermittelt werden.
Der Tastaturcode ist den Definitionen der Header-Datei W_DEF.H
(TURBO-C) bzw. der Datei W_TBP_XX.IFC (TURBO-Pascal) zu
entnehmen.

Ergebnis

0     : Maskennummer ungültig
sonst : Tastaturcode der zuletzt gedrückten Taste



-------------------------------------------------------
int w_switch_visible_cr(int wnum)
function  w_switch_visible_cr(wnum:integer):integer;

w_switch_visible_cr bewirkt, das w_switch bei Aufruf mit der
Maskennummer <wnum> lediglich das aktuelle Feld markiert und
ohne Aktionen des Anwenders entgegenzunehmen wie bei einem
KEY_CR des Anwenders beendet, wobei ein Abfragen der letzten
Taste jedoch eine 0 zum Ergebnis haben würde. w_switch liefert die
Nummer des zuletzt markierten Feldes zurück. Dieser kann zuvor
mit w_switch_pos eingestellt werden, so das die Verzweigung
steuerbar ist. Diese Betriebsart ist sinnvoll, wenn die Anwahl der
Menüpunkte zusetzlich mittels 'Hotkeys' möglich sein und durch das
zusätzliche Aufklappen der Menüs die Hirachie dieser
veranachaulicht werden soll. Diese Betriebsart ist nur für den
nächsten Aufruf von w_switch mit der Maskennummer <wnum>
gültig und wird dann selbsttätig zurückgesetzt.


Ergebnis

1    : Betriebsart konnte eingestellt werden
0    : Fehler (ungültige Maskennummer)



-------------------------------------------------------
int w_switch_unvisible_cr(int wnum)
function  w_switch_unvisible_cr(wnum:integer):integer;

w_switch_visible_cr bewirkt, das sich w_switch bei Aufruf mit der
Maskennummer sofort und ohne Aktionen des Anwenders
entgegenzunehmen wie bei einem KEY_CR beendet,  ein Abfragen
der letzten Taste würde jedoch eine 0 zum Ergebnis haben.
w_switch liefert die Nummer des zuletzt markierten Feldes zurück,
dieser kann mit w_switch_pos eingestellt werden. Diese Betriebsart
ist sinnvoll, wenn die Anwahl der Menüpunkte ohne Erscheinen der
Menüs zusetzlich mittels 'Hotkeys' möglich sein soll. Diese
Betriebsart ist nur für den nächsten Aufruf von w_switch mit der
Maskennummer <wnum> gültig und wird dann sebsttätig
zurückgesetzt.


Ergebnis

1    : Betriebsart konnte eingestellt werden
0    : Fehler (ungültige Maskennummer)



-------------------------------------------------------
int w_switch_auto_esc(int wnum)
function  w_switch_auto_esc(wnum:integer):integer;

w_switch_auto_esc veranlaßt, daß sich w_switch bei Aufruf mit
<wnum> ohne Aktionen des Anwenders entgegenzunehmen sofort wie
bei einem KEY_ESC beendet,  ein Abfragen der letzten Taste würde
jedoch eine 0 zum Ergebnis haben.
Sinnvoll ist diese Funktion dann anzuwenden, wenn beispielsweise
nach Ausführung einer zuvor angewählten Aktion der Rückweg
über die Menüleiste übersprungen werden soll. Diese Betriebsart ist
nur für den folgenden Aufruf von w_switch mit der Maskennummer
<wnum> gültig, sie wird dann selbsttätig zurückgesetzt.

Ergebnis

1    : Betriebsart konnte eingestellt werden
0    : Fehler (ungültige Maskennummer)



-------------------------------------------------------
int w_switch_range(int wnum,int first,int last)
function  w_switch_number_of_places(wnum,first,last:integer):integer;

w_switch_range begrenzt den Bereich der Menü-Felder einer Maske:
Normalerweise werden alle Felder einer Maske in eine Menüauswahl
miteinbezogen. Unter Verwendung von w_switch_range wird die
Anzahl der verwendeten Felder auf <last>-<first>+1 eingeschränkt.
Sinnvolle Anwendungen ergeben sich, wenn die Anzahl der
anwählbaren Objekte ( z.B. Dateien) variabel ist.

Ergebnis

1    : Anzahl konnte eingestellt werden
0    : Fehler



-------------------------------------------------------
int w_switch_mouse_esc(int wnum,int mode)
function  w_switch_mouse_esc(wnum,mode:integer):integer;

w_switch_mouse_esc ermöglicht den Aufbau einer Menü-Hirachie aus
verschiedenen Masken, in der durch Positionierung des
Mauscursors auch sichtbare Felder von zuvor geöffneten Masken
angewählt werden können. Die geöffneten Masken werden intern in
einem Maskenstapel verwaltet, notwendigerweise ist dieser
Maskenstapel ein Abbild der auf dem Bildschirm gestapelten Masken.
Ist diese Betriebsart für die Maske eines Untermenüs beliebiger
Tiefe eingestellt, und wird aus diesem Untermenü mit dem
Mauscursor ein sichtbares Feld zB. der Hauptmenüzeile angewählt,
so veranlasst w_switch ein auto_esc (siehe w_switch_auto_esc) für
alle alle Zwischenmenüs auf dem Weg zum Hauptmenü, das
Hauptmenü wird entsprechend positioniert (siehe w_switch_pos).
Vorraussetzung zum Funktionieren ist natürlich eine gewisse
Programmstruktur, die den Beispielen entnommen werden kann.

Parameter

mode=1 : Betriebsart an
mode=0 : Betriebsart aus

Ergebnis

1    : Betriebsart konnte eingestellt werden
0    : Fehler (ungültige Maskennummer)



-------------------------------------------------------
int w_switch_mouse_cr(int wnum,int mode)
function  w_switch_mouse_cr(wnum,mode:integer):integer;

w_switch_mouse_cr stellt eine Betriebsart ein, in der bei
Anwendung von w_switch auf die Maske der Nummer <wnum> schon
das Positionieren des Mauscursors auf ein Feld als Anwahl diese
Feldes interpretiert wird. Programmtechnisch stellt sich diese
Betriebsart so da, als wenn tatsächlich eine Anwahl durch Drücken
der linken Maustaste erfolgt wäre. Eine sinnvolle Anwendugen wäre
die Programmierung bei Mausanwahl selbsttätig aufklappender
Untermenüs.

Parameter

mode=1 : Betriebsart an
mode=0 : Betriebsart aus

Ergebnis

1    : Betriebsart konnte eingestellt werden
0    : Fehler (ungültige Maskennummer)



-------------------------------------------------------
int w_switch_mark_mode(int wnum,int mode)
function  w_switch_mark_mode(wnum,mode:integer):integer;

w_switch_mark_mode verändert die Art, in der bei Anwendung von
w_switch auf Maske <wnum> das angewählten Feld markiert wird.
Die erste Möglichkeit der Markierung besteht in der Veränderung
des Attributs, die zweite darin, jeweils Pfeile auf der ersten und
letzten Stelle des Feldes zu plazieren.
Dort sollten dann möglicht keine wichtigen Zeichen stehen. Die
dritte Möglichkeit besteht darin, die ersten Beiden zu kombinieren.
<mode> = 3,4,5 entspricht den Möglichkeiten 0,1,2 mit dem
Unterschied, daß bei Markierungswechsel durch Cursortasten der
Mauscursor nachgeführt wird.

Parameter

mode=0 : Attribut
mode=1 : Pfeile
mode=2 : Attribut + Pfeile
mode=4 : Attribut + Mauscursornachführung
mode=5 : Pfeile + Mauscursornachführung
mode=6 : Attribut + Pfeile + Mauscursornachführung


Ergebnis

1    : Betriebsart konnte eingestellt werden
0    : Fehler (ungültige Maskennummer)



-------------------------------------------------------
int w_switch_break_on_key(int wnum,int mode)
function  w_switch_break_on_key(wnum,mode:integer):integer;

w_switch_break_on_key veranlaßt w_switch bei Anwendung auf
Maske <wnum> mit jeder fremden Taste abzubrechen. Ein solcher
Abbruch ist durch das Ergebnis -2 der Funktion w_switch
erkennbar, die Fremdtaste läßt sich mittels w_switch_last_key
ermitteln. Fremdtasten sind alle Tasten, die nicht der Menueauswahl
dienen. Keine Fremdtasten
sind also die Cursortasten (KEY_C_L, KEY_C_R, KEY_C_U, KEY_C_D),
Escape-Taste (KEY_ESC) und rechte Maustaste (MOUSE_R_B) sowie
Return-Taste (KEY_CR) und linke Maustaste (MOUSE_L_B). Für
<mode> = 2 führt auch ein MOUSE_R_B zum Abbruch, wenn sich der
Mauscursor zum Zeitpunkt des Tastendrucks nicht auf einem Feld
der Maske befindet.


Parameter

mode= 0 : Kein Abbruch
mode= 1 : Abbruch bei Fremdtasten
mode= 2 : Abbruch bei Fremdtasten und MOUSE_R_B außerhalb
mode=-1 : Keine Veränderung

Ergebnis

-1    : Fehler (ungültige Maskennummer)
sonst : aktueller Modus


-------------------------------------------------------
int w_switch_matrix(int wnum,int mode,int left,int right,int
                          top,int bottom)
function w_switch_matrix(wnum,mode,left,right,top,
                          bottom:integer):integer;

w_switch_matrix erwartet eine rechteckige ,symmetrische und
zeilenweise nummerierte Anordnung der Felder. Mit <mode> =1 wird
erreicht, daß ein wegen der Symmetrien deutlich vereinfachter
Markieralgorithmus eingesetzt wird. Dies vermindert den
anfänglichen Zeitverzug bei Anwendung von w_switch auf Masken
mit einer großen Anzahl (zB. > 30) von Feldern. Die vier Parameter
<left>, <right>, <top> und <bottom> dienen der Realisierung eines
Scrollbetriebs. Sie bezeichnen die vier Seiten eines Rechtecks. Wird
beispielsweise der Parameter <right> auf 1 gesetzt, so würde
w_switch abbrechen, wenn ein Feld am rechten Rand der Matrix
markiert ist und die Taste KEY_C_R gedrückt werden würde. So hat
der Programmierer die Möglichkeit, die Texte der Felder zu ändern,
um ein Scrollen zu erzeugen. Gleiches gilt natürlich für die
anderen drei Seiten. Ist auch nur einer dieser vier Parameter
ungleich 1, so wird intern <mode>=1 gesetzt.

Parameter

mode=0 : Komlexer Markieralgotithmus, wenn alle Parameter 0
mode=1 : Vereinfachter Makieralgorithmus

right=1: Abbruch bei KEY_C_R am rechten Rand
right=0: Kein Abbruch

Ergebnis

1    : Betriebsart konnte eingestellt werden
0    : Fehler (ungültige Maskennummer)




==================================================================
7.6  Abruf von Maskeninformationen
==================================================================

Die folgenden Funktionen dienen dem Abruf von
Maskeninformaationen. Diese können Verwendung zur
Programmierung eigener Hilfsfunktionen finden.



-------------------------------------------------------
int w_xyon_field(int mnum,int x,int y)
function  w_xyon_field(wnum,x,y:integer):integer;

w_xyon_field gibt an, ob sich die in <x> und <y> angegebenen
Koordinaten im Bereich eines Feldes der über <wnum> adressierten
Maske befindet. Der sinnvolle Wertebereich der Koordinaten liegt im
Bereich des 80*25-Textbilschirms, also (1 <= x <= 80) und (1 <= y
<= 25).

Ergebnis

-1      : Kein entsprechendes Feld vorhanden
-2      : Die Maskennummer ist fehlerhaft
sonst   : Feld-Nummer, auf dem die Koordinaten liegen



-------------------------------------------------------
int w_xyon_win(int mnum,int x,int y)
function  w_xyon_win(wnum,x,y:integer):integer;

w_xyon_win prüft ob die angegebenen Koordinaten im Bereich der
mit <wnum> adressierten Maske liegen.


1       : Die Koordinaten liegen innerhalb der Maske
0       : Die Koordinaten liegen außerhalb
-1      : Die Maskennummer ist fehlerhaft




-------------------------------------------------------
int w_is_wnum(int wnum)
function  w_is_wnum(wnum:integer):integer;

w_is_wnum prüft, ob  <wnum> eine gültige Maskennummer ist

Ergebnis

1    : Ist gültig
0    : Ist ungültig



-------------------------------------------------------
int w_is_field(int wnum,int field)
function  w_is_field(wnum,field:integer):integer;

w_is_field prüft, ob <field> eine gültige Feldnummer der Maske
<wnum> ist.

Ergebnis

1    : <field> gültig
0    : <field> oder <wnum> ist ungültig



-------------------------------------------------------
char *w_info_vscreen(int wnum)
function  w_info_vscreen(wnum:integer):pointer;

w_info_vscreen liefert einen Zeiger auf das virtuelle Bild einer mit
w_load(..,0) geladenen Maske.

Ergebnis

NULL  : Maske hat kein virtuelles Bild
sonst : Zeiger auf das virtuelle Bild


-------------------------------------------------------
char *w_info_bscreen(int wnum)
function  w_info_bscreen(wnum:integer):pointer;

w_info_bscreen liefert einen Zeiger auf den gesicherten Hintergrund
einer geöffneten Maske.

Ergebnis

NULL  : Maske nicht geöffnet
sonst : Zeiger auf den Hintergrund


-------------------------------------------------------
int w_info_win_left(int wnum)
function  w_info_win_left(wnum:integer):integer;

w_info_win_left liefert die Nummer der ersten zur Maske <wnum>
gehörenden Spalte. Die Gültigkeit der Maskennummer <wnum> wird
nicht überprüft.

Ergebnis

1 - 80 : Nummer der ersten Spalte



-------------------------------------------------------
int w_info_win_right(int wnum)
function  w_info_win_right(wnum:integer):integer;

w_info_win_right liefert die Nummer der letzten zur Maske <wnum>
gehörenden Spalte. Die Gültigkeit der Maskennummer <wnum> wird
nicht überprüft.

Ergebnis

1 - 80 : Nummer der letzten Spalte



-------------------------------------------------------
int w_info_win_top(int wnum)
function  w_info_win_top(wnum:integer):integer;

w_info_win_top liefert die Nummer der ersten zur Maske <wnum>
gehörenden Zeile. Die Gültigkeit der Maskennummer <wnum> wird
nicht überprüft.

Ergebnis

1 - 25 : Nummer der ersten Zeile



-------------------------------------------------------
int w_info_win_bottom(int wnum)
function  w_info_win_bottom(wnum:integer):integer;

w_info_win_bottom liefert die Nummer der letzten zur Maske <wnum>
gehörenden Zeile. Die Gültigkeit der Maskennummer <wnum> wird
nicht überprüft.

Ergebnis

1 - 25 : Nummer der letzten Zeile


-------------------------------------------------------
int w_info_field_num(int wnum)
function  w_info_field_num(wnum:integer):integer;

w_info_field_num liefert die Anzahl der Felder der Maske
<wnum>. Die Gültigkeit der Maskennummer <wnum> wird nicht
überprüft.

Ergebnis

Anzahl der Felder



-------------------------------------------------------
int w_info_field_x(int wnum,int field)
function  w_info_field_x(wnum,field:integer):integer;

w_info_field_x liefert die Startspalte des Feldes <field> der Maske
<wnum>. Die Gültigkeit der Maskennummer <wnum> und der
Feldnummer <field> wird nicht überprüft.

Ergebnis

Startspalte des Feldes



-------------------------------------------------------
int w_info_field_y(int wnum,int field)
function  w_info_field_y(wnum,field:integer):integer;

w_info_field_y liefert die Startzeile des Feldes <field> der Maske
<wnum>. Die Gültigkeit der Maskennummer <wnum> und der IO-
Kanalnummer <field> wird nicht überprüft.

Ergebnis

Startzeile des Felds



-------------------------------------------------------
int w_info_field_width(int wnum,int field)
function  w_info_field_width(wnum,field:integer):integer;

w_info_field_width liefert die Länge des Felds <field> der Maske
<wnum>. Die Gültigkeit der Maskennummer <wnum> und der IO-
Kanalnummer <field> wird nicht überprüft.

Ergebnis

Länge des Felds



-------------------------------------------------------
int w_info_field_rev_attrib(int wnum,int field)
function  w_info_field_rev_attrib(wnum,field:integer):integer;

w_info_field_rev_attrib liefert das Revers-Attribut des Felds <field>
der Maske <wnum>. Die Gültigkeit der Maskennummer <wnum> und
der Feldnummer <field> wird nicht überprüft.

Ergebnis

Revers-Attribut des Felds


-------------------------------------------------------
int   w_info_field_out_attrib(int wnum,int fnum);
function  w_info_field_out_attrib(wnum,fnum:integer):integer;

Siehe w_info_field_rev_attr ..

Ergebnis

Ausgabe-Attribut des Felds



-------------------------------------------------------
int   w_info_field_in_attrib(int wnum,int fnum);
function  w_info_field_in_attrib(wnum,fnum:integer):integer;

Siehe w_info_field_rev_attr ..

Ergebnis

Eingabe-Attribut des Felds


-------------------------------------------------------
int   w_info_field_in_right(int wnum,int fnum);
function  w_info_field_in_right(wnum,fnum:integer):integer;

Liefert das Eingabe-Format des Feldes

Ergebnis:

0 : linksbündig
1 : rechtsbündig



-------------------------------------------------------
int   w_info_field_out_right(int wnum,int fnum);
function  w_info_field_out_right(wnum,fnum:integer):integer;

Liefert das Ausgabe-Format des Feldes

Ergebnis:

0 : linksbündig
1 : rechtsbündig


-------------------------------------------------------
int   w_info_field_in_owrite(int wnum,int fnum);
function  w_info_field_in_owrite(wnum,fnum:integer):integer;

Liefert den Schreibmodus des Editors für dieses Feld

Ergebnis:

0 : Einfügen
1 : Überschreiben


-------------------------------------------------------
int   w_info_field_del(int wnum,int fnum);
function  w_info_field_del(wnum,fnum:integer):integer;

Sagt aus, ob eine Feld vor einer Aktion immer komplett gelöscht
wird.

Ergebnis:

0 : nicht löschen
1 : löschen


-------------------------------------------------------
int   w_info_field_type(int wnum,int fnum);
function  w_info_field_type(wnum,fnum:integer):integer;

Liefert eine Angabe über den Datentyp eines Feldes. Dazu sind
folgende Konstanten definiert:

ISSTRING     0
ISCHAR       1
ISBYTE       2
ISINT        3
ISWORD       4
ISLONG       5
ISDOUBLE     6
ISDATE       7
ISTIME       8
ISDMARK      9

Ergebnis:

Datentyp

-------------------------------------------------------
void *w_info_field_min(int wnum,int fnum,void *min);
function  w_info_field_min(wnum,fnum:integer;min:pointer):pointer;

Liefert die untere Wertebereichsgrenze des Feldes. Der Wert wird
an die durch <destin> bezeichnete Stelle des Speichers geschrieben
und ist entsprechend des Datentyps des Feldes zu interpretieren .


-------------------------------------------------------
void *w_info_field_max(int wnum,int fnum,void *max);
function  w_info_field_max(wnum,fnum:integer;max:pointer):pointer;

Liefert die obere Wertebereichsgrenze des Feldes. Der Wert wird an
die durch <destin> bezeichnete Stelle des Speichers geschrieben
und ist entsprechend des Datentyps des Feldes zu interpretieren .



==================================================================
7.7  Maus-Routinen
==================================================================

Die folgenden Mausfunktionen interpretieren die Maus als
Bestandteil der Tastatur. Vorraussetzung zur Verwendung der
folgenden Funktionen ist, daß alle Tastaturabfragen mit der
Funktion w_mousekbd ausgeführt werden. Die virtuellen
Mauskoordinaten werden intern auf Schirmkoordinaten des 80*25
Zeichen-Textschirms umgerechnet.


-------------------------------------------------------
int w_mouse_init(void)
function  w_mouse_init:integer;

w_mouse_init initialisiert die folgenden w_mouse_.. -Funktionen.
Wird w_init verwendet, so kann ein seperater Aufruf von
w_mouse_init entfallen.

Ergebnis

1    : Initialisierung konnte erfolgen
0    : Maus nicht vorhanden oder fehlerhaft



-------------------------------------------------------
int w_mouse_deinit(void)
function  w_mouse_deinit:integer;

w_mouse_deinit deinitialisiert die Maus. Sie wird für den Anwender
unsichtbar. Um die Maus wieder zu aktivieren, ist w_mouse_init
aufzurufen. Auf diesem Wege läßt sich beispielsweise für bestimmte
Programmteile die Mausaktivität unterdrücken.

Ergebnis

1    : Deinitialisierung konnte erfolgen
0    : Maus war nicht initialisiert


-------------------------------------------------------
int w_mouse_exist(void)
function  w_mouse_exist:integer;

w_mouse_exist sucht im Speicher des Rechners nach einem
geladenen Maustreiber

Ergebnis
1    : Treiber gefunden
0    : Kein Treiber gefunden



-------------------------------------------------------
void w_mouse_gotoxy(int x,int y)
procedure w_mouse_gotoxy(x,y:integer);

w_mouse_gotoxy bewegt den Mauscursor an die durch Spalte <x>
und Zeile <y> bezeichnete Stelle des 80*25-Zeichen Textbildschirms



-------------------------------------------------------
int w_mouse_cur_x(void)
function  w_mouse_cur_x:integer;

w_mouse_cur_x liefert die aktuelle (current) x-Koordinate des
Mauscursors. Eine Abfrage dieser Funktion ist  sinnvoll, wenn
zuvor ein MOUSE_MOVE von w_mousekbd empfangen wurde

Ergebnis

Aktuelle x-Koordinate (Spalte)



-------------------------------------------------------
int w_mouse_cur_y(void)
function  w_mouse_cur_y:integer;

w_mouse_cur_y liefert die aktuelle (current) y-Koordinate des
Mauscursors. Eine Abfrage dieser Funktion ist  sinnvoll, wenn
zuvor ein MOUSE_MOVE von w_mousekbd empfangen wurde

Ergebnis

Aktuelle y-Koordinate (Spalte)


-------------------------------------------------------
int w_mouse_pre_x(void)
function  w_mouse_pre_x:integer;

w_mouse_pre_x liefert die x-Koordinate des Mauscursors zur Zeit
des letzten Tastenniederdrucks. Eine Abfrage dieser Funktion ist
z.B. sinnvoll, wenn zuvor ein MOUSE_R_B_P von w_mousekbd
empfangen wurde

Ergebnis

x-Koordinate während des Tastendrucks



-------------------------------------------------------
int w_mouse_pre_y(void)
function  w_mouse_pre_y:integer;

w_mouse_pre_y liefert die y-Koordinate des Mauscursors zur Zeit
des letzten Tastenniederdrucks. Eine Abfrage dieser Funktion ist
z.B. sinnvoll, wenn zuvor ein MOUSE_R_B_P von w_mousekbd
empfangen wurde

Ergebnis

y-Koordinate während des Tastendrucks



-------------------------------------------------------
int w_mouse_rel_x(void)
function  w_mouse_rel_x:integer;

w_mouse_pre_x liefert die x-Koordinate des Mauscursors zur Zeit
des letzten Tastenhubs. Eine Abfrage dieser Funktion ist z.B.
sinnvoll, wenn zuvor ein MOUSE_L_B_R von w_mousekbd empfangen
wurde

Ergebnis

x-Koordinate während des Tastenhubs



------------------------------------------------------
int w_mouse_rel_y(void)
function  w_mouse_rel_y:integer;

w_mouse_pre_y liefert die y-Koordinate des Mauscursors zur Zeit
des letzten Tastenhubs. Eine Abfrage dieser Funktion ist z.B.
sinnvoll, wenn zuvor ein MOUSE_L_B_R von w_mousekbd empfangen
wurde

Ergebnis

y-Koordinate während des Tastenhubs




==================================================================
7.8  Bildschirmroutinen (allgemein)
==================================================================

Über die folgenden Routinen wickeln die bisher beschriebenen
Routinen die Bildschirmverwaltung ab. Sie werden vom Anwender im
Normalfall nicht benötigt, können aber zur Programmierung einiger
Spezialitäten recht nützlich sein.



-------------------------------------------------------
void v_init(int bios);
procedure v_init(bios:integer);

Initialisiert die Bildschirmroutinen. Der Parameter <bios> legt fest,
ob der Bildschirmzugriff direkt auf den Bildspeicher oder über die
langsamen BIOS-Routinen erfolgen soll. V_init wird von w_init
aufgerufen.

Parameter

bios= 0        : Direkter Zugriff;
bios<>0;       : Bios-Routinen;


-------------------------------------------------------
int v_mono(void);
function v_mono:integer;

Testet auf Monochrom-Monitor;

Ergebnis:

0 : Color
1: Mono



-------------------------------------------------------
int  v_getwin (int left, int top, int right, int bottom, void *buffer);
function  v_getwin(left,top,right,bottom:integer;var buffer):integer;

v_getwin liest den Inhalt (Text und Attribute !) des mit <left>,
<top>, <right> und <bottom> bezeichneten Bildschirmrechtecks und
schreibt diesen an die durch <destin> spezifizierte Speicherstelle.
Wenn eine Maus installiert ist, so wird der Mauscursor vor dem
direkten Bildspeicherzugriff verdeckt und anschließend wieder
hergestellt. Der unter <destin> verfügbare Speicherplatz muß
eine Größe von (right-left+1)*(bottom-top+1)*2 Bytes haben. Es wird
abwechselnd je ein Bildschirmzeichen und ein Attribut gelesen.

Ergebnis

1    : Fehlerfreie Ausführung
0    : Fehler (Koordinaten ausserhalb des Bildschirms)



-------------------------------------------------------
int  v_putwin (int left, int top, int right, int bottom, void *buffer);
function  v_putwin(left,top,right,bottom:integer;var buffer):integer;

v_putwin beschreibt den durch <left>, <top>, <right>
und <bottom> bezeichneten Bildschirmausschnitts mit der unter
<destin> gespeicherten Bildinformation (Text und Attribute). Wenn
eine Maus installiert ist, so wird der Mauscursor vor dem direkten
Bildspeicherzugriff verdeckt und anschließend wieder hergestellt.
Siehe auch v_getwin.

Ergebnis

1    : Fehlerfreie Ausführung
0    : Fehler, z.B. Koordinaten ausserhalb des Bildschirms




-------------------------------------------------------
int  v_gettext (int left, int top, int right, int bottom, void *buffer);
function  v_gettext(left,top,right,bottom:integer;var buffer):integer;

v_gettext liest den Text des mit <left>, <top>, <right> und <bottom>
bezeichneten Bildschirmrechtecks und schreibt diesen an die durch
<destin> spezifizierte Speicherstelle. Wenn eine Maus installiert ist,
so wird der Mauscursor vor dem direkten Bildspeicherzugriff
verdeckt und anschließend wieder hergestellt. Der unter <destin>
verfügbare Speicherplatz muß eine Größe von (right-left+1)*(bottom-
top+1) Bytes haben.

Ergebnis

1    : Fehlerfreie Ausführung
0    : Fehler (Koordinaten ausserhalb des Bildschirms)



-------------------------------------------------------
int  v_puttext (int left, int top, int right, int bottom, void *buffer);
function  v_puttext(left,top,right,bottom:integer;var buffer):integer;

v_puttext beschreibt den durch <left>, <top>, <right>
und <bottom> bezeichneten Bildschirmausschnitts mit der unter
<destin> gespeicherten Textinformation. Wenn eine Maus installiert
ist, so wird der Mauscursor vor dem direkten Bildspeicherzugriff
verdeckt und anschließend wieder hergestellt. Siehe auch v_gettext.

Ergebnis

1    : Fehlerfreie Ausführung
0    : Fehler, z.B. Koordinaten ausserhalb des Bildschirms



-------------------------------------------------------
int  v_getattr (int left, int top, int right, int bottom, void *buffer);
function  v_getattr(left,top,right,bottom:integer;var buffer):integer;

v_getattr liest die Attribute des mit <left>, <top>, <right> und
<bottom> bezeichneten Bildschirmrechtecks und schreibt diese an
die durch <destin> spezifizierte Speicherstelle. Wenn eine Maus
installiert ist, so wird der Mauscursor vor dem direkten
Bildspeicherzugriff verdeckt und anschließend wieder hergestellt.
Der unter <destin> verfügbare Speicherplatz muß eine Größe von
(right-left+1)*(bottom-top+1) Bytes haben.

Ergebnis

1    : Fehlerfreie Ausführung
0    : Fehler (Koordinaten ausserhalb des Bildschirms)



-------------------------------------------------------
int  v_putattr (int left, int top, int right, int bottom, void *buffer);
function  v_putattr(left,top,right,bottom:integer;var buffer):integer;

v_putattr beschreibt den durch <left>, <top>, <right>
und <bottom> bezeichneten Bildschirmausschnitts mit den unter
<destin> gespeicherten Attributen. Wenn eine Maus installiert ist, so
wird der Mauscursor vor dem direkten Bildspeicherzugriff verdeckt
und anschließend wieder hergestellt. Siehe auch v_getattr.

Ergebnis

1    : Fehlerfreie Ausführung
0    : Fehler, z.B. Koordinaten ausserhalb des Bildschirms



-------------------------------------------------------
int  v_movewin(int sx1, int sy1, int sx2, int sy2, int dx1, int dy1);
function  v_movewin(sx1,sy1,sx2,sy2,dx1,dy1:integer):integer;

v_movewin verschiebt den Inhalt (Text und Attribute !) des mit
<sx1>, <sy1>, <sx2> und <sy2> bezeichneten Bildschirmrechtecks um
<dx1> bzw. <dy1>. Wenn eine Maus installiert ist, so wird der
Mauscursor vor dem direkten Bildspeicherzugriff verdeckt und
anschließend wieder hergestellt.

Ergebnis

1    : Fehlerfreie Ausführung
0    : Fehler (Koordinaten ausserhalb des Bildschirms)



-------------------------------------------------------
void v_gotoxy(int x, int y);
procedure v_gotoxy(x,y:integer);

Der Textcursor wird auf die durch Zeile <y> und Spalte <x>
gekennzeichnete Bildschirmposition gesetzt.

Ergebnis

1    : Fehlerfreie Ausführung
0    : Fehler (Koordinaten ausserhalb des Bildschirms)


-------------------------------------------------------
word v_wherexy(void);
function  v_wherexy:word;

Die aktuelle Position des Textcursor wird ermittelt, wobei die Zeile
im High-Byte und die Spalte im Low-Byte des Ergebniswortes
angegeben wird.

Ergebnis

High-Byte : Zeile
Low -Byte : Spalte


-------------------------------------------------------
int  v_wherex(void);
function  v_wherex:integer;

Die Spalte der aktuelle Position des Textcursor wird ermittelt.

Ergebnis

Spalte des Textcursors



-------------------------------------------------------
int  v_wherey(void);
function  v_wherey:integer;

Die Zeile der aktuelle Position des Textcursor wird ermittelt.

Ergebnis

Zeile des Textcursors


-------------------------------------------------------
word v_getcursor(void);
function  v_getcursor:word;

Liefert einen dem Aussehen des Cursors entsprechenden Wert. Das
High-Byte des Ergebniswortes enthält die Startzeile und das Low-
Byte die Endzeile des Cursorblocks (in Bildpunkten !).

Ergebnis

High-Byte : Startzeile
Low -Byte : Endzeile



-------------------------------------------------------
void v_setcursor(word shape);
procedure v_setcursor(shape:word);

Setzt das Aussehen des Textcursors. Das High-Byte von <shape>
enthält die Startzeile, das Low-Byte die Endzeile des Cursorblocks
(in Bildpunkten !).


-------------------------------------------------------
void v_hidecursor(void);
procedure v_hidecursor;

Der Textcursor wird dunkel geschaltet.



-------------------------------------------------------
void v_showcursor(void);
procedure v_showcursor;

Der Textcursor wird auf den ursprünglichen Wert vor dem
Verdunkeln durch v_hidecursor gesetzt.



-------------------------------------------------------
void v_clrscr(void);
procedure v_clrscr;

Der Textbildschirm wird gelöscht.



==================================================================
7.9 MICROSOFT-MAUS-INTERFACEFUNKTIONEN
==================================================================

Die folgenden 17 Funktionen sind die Grundfunktionen eines
Microsoft-kompatiblen Maustreibers. Über die kurze Beschreibung
hinausgehende Informationen  entnehmen sie bitte ihrem Maus-
Handbuch. Es sollte vor Aufruf einer dieser 17 Funktionen
sichergestellt sein, daß auch tatsächlich ein Maustreiber geladen
wurde.


-------------------------------------------------------
int  mouse_init(word *buttons)
function  mouse_init(var buttons:word):integer;

mouse_init initialisiert die Soft- und Hardware der Maus, die Anzahl
der Mausknöpfe wird in buttons zurückgeliefert.
Die Maus ist noch unsichtbar und muß mit mouse_show_cursor()
zur Anzeige gebracht werden.

Ergebnis

-1    : Maus betriebsbereit
0     : Maus nicht betriebsbereit



-------------------------------------------------------
void mouse_show_cursor(void)
procedure mouse_show_cursor;

Der interne Cursorzähler wird um 1, jedoch maximal auf 0, erhöht.
Hat der interne Cursorzähler den Wert 0, so wird der Mauscursor
zur Anzeige gebracht.



-------------------------------------------------------
void mouse_hide_cursor(void)
procedure mouse_hide_cursor;

Der interne Cursorzähler wird um 1 heruntergezählt, der
Mauscursor verschwindet vom Bildschirm. Dies ist sinnvoll, wenn
beispielsweise ein direkter Zugriff auf den Bildspeicher erfolgen
soll.



-------------------------------------------------------
word mouse_get_status(word *buttons,int *xpos,int *ypos)
function  mouse_get_status(var buttons,xpos,ypos:integer):word;

mouse_get_status liefert in <*xpos> und <*ypos> die aktuellen
Mauskoordinaten, in <*buttons> findet sich Information über die
jeweils gedrückten Maustasten.
Bit 0 entspricht der linken, Bit 1 der rechten und, wenn
vorhanden, Bit 2 der mittleren Maustaste.


Ergebnis

*buttons



-------------------------------------------------------
void mouse_set_pos(int xpos,int ypos)
procedure mouse_set_pos(xpos,ypos:integer);

mouse_set_pos setzt den Mauscursor auf die virtuellen
Mauskoordinaten xpos und ypos



-------------------------------------------------------
word mouse_get_press_status(word button,word *status,int
                           *presses,int *xppos,int *yppos)
function  mouse_get_press_status(button:word;var status,presses
                               :word;var xppos,yppos:integer):word;

mouse_get_press_status liefert die Anzahl der Tastendrücke
(presses) der über <buttons> adressierten Maustaste seit dem
letzten Aufruf dieser Funktion. In <*xppos> und <*yppos> werden
die Cursorkoordinaten während des letzten Tastendrucks
übergeben. Das Ergebnis der Funktion liefert ein Bild der aktuell
gedrückten Maustasten. Bei der Adressierung der abzufragenden
Maustaste ist statt der üblichen Bitzuordnung 0 für Links, 1 für
Rechts und 2 für die mittlere Taste anzugeben. Bei dem
Funktionsergebnis gilt wieder folgende Zuordnung: Bit 0
entspricht der linken, Bit 1 der rechten und, wenn vorhanden, Bit
2 der mittleren Maustaste.

Ergebnis

Aktuell gedrückte Maustasten



-------------------------------------------------------
word mouse_get_release_status(word button,word *status,int
                             *releases,int *xrpos,int *yrpos)
function  mouse_get_release_status(button:word;var status,releases
                             :word;var xrpos,yrpos:integer):word;

mouse_get_realease_status liefert die Anzahl der Tastenhübe
(realeases) der über <buttons> adressierten Maustaste seit dem
letzten Aufruf dieser Funktion. In <*xrpos> und <*yrpos> werden
die Cursorkoordinaten während des letzten Tastendrucks
übergeben. Das Ergebnis der Funktion liefert ein Bild der aktuell
gedrückten Maustasten. Bei der Adressierung der abzufragenden
Maustaste ist statt der üblichen Bitzuordnung 0 für Links, 1 für
Rechts und 2 für die mittlere Taste anzugeben. Bei dem
Funktionsergebnis gilt wieder folgende Zuordnung: Bit 0 entspricht
der linken, Bit 1 der rechten und, wenn vorhanden, Bit 2 der
mittleren Maustaste.

Ergebnis

Aktuell gedrückte Maustasten



-------------------------------------------------------
void mouse_set_xrange(int xmin,int xmax)
procedure mouse_set_xrange(xmin,xmax:integer);

mouse_set_xrange schränkt die horizontale Bewegungsfreiheit
der Maus auf den in <xmin> und <xmax> angegebenen Bereich ein.



-------------------------------------------------------
void mouse_set_yrange(int ymin,int ymax)
procedure mouse_set_yrange(ymin,ymax:integer);

mouse_set_yrange schränkt die vertikale Bewegungsfreiheit der
Maus auf den in <ymin> und <ymax> angegebenen Bereich ein.



-------------------------------------------------------
void mouse_def_graphcursorblock(int xhotspot,int yhotspot,word
                                cursormaskpointer)
procedure mouse_def_graphcursorblock(xhotspot,yhotspot:
                                integer;cursormaskpointer:word);

mouse_def_graphcursorblock definiert das Aussehen des
Mauscursors im Grafikmode der Bildschirmkarte. Für
<cursormaskpointer> ist ein Intrasegmentzeiger (16 Bit)
auf einen Cursordefinitionblock einzusetzen. Der
Cursordefinitionsblock besteht aus einer 16*16 Bit großen
Schirmmaske gefolgt von einer 16*16 Bit großen Cursormaske. Die
Lage der Mauskoordinate (hot spot) innerhalb eines 16*16 Bit
großen Blockes wird mit <xhotspot> und <yhotspot> angegeben, der
Wertebereich der Koordinaten liegt jeweils zwischen -16 und +16.


-------------------------------------------------------
void mouse_def_textcursor(word cursorselect,word screenmask,word
                          cursormask)
procedure mouse_def_textcursor(cursorselect,screenmask,
                          cursormask:word);

mouse_def_textcursor definiert das Aussehen des Mauscursors
im Textmode der Bildschirmkarte. Mit <cursorselect> = 0 wird
der Softwaretextcursor angewählt, sein Erscheinungsbild wird
durch <screenmask> und <cursormask> geprägt. Das niederwertige
Byte von <screenmask> und <cursormask> bezieht sich auf das
Symbol (ASCII-Code) des Cursors, das höherwertige Byte jeweils
auf das Attribut. <screenmask> wird mit dem ursprünglichen
Bildinhalt einer Und-Verknüpfung unterzogen, also können Teile
des ursprünglichen Bildinhaltes ausgeblendet werden. Das Ergebnis
dieser Operation wird mit <cursormask> einer Exclusiv-Oder-
Verküpfung unterzogen, Bits können also negiert oder belassen
werde. Mit <cursorselect> = 1 wird der Hardwaretextcursor
angewählt. Die Parameter <screenmask> und <cursormask> enthalten
nun die erste und letzte Abtastzeile des Cursors. Diese Werte sind
von der gewählten Video-Betriebsart abhängig, die Werte liegen
zwischen 0 und 7 bei farbiger sowie zwischen 0 und 11 bei
monochromer Darstellung.



-------------------------------------------------------
void mouse_get_motioncounter(int *xcount,int *ycount)
procedure mouse_get_motioncounter(var xcount,ycount:integer);

Mouse_get_motioncounter liefert die Anzahl der ausgeführten
Mausschritte seit dem letzten Aufruf dieser Funktion. Negative
Werte für <*xcount> bzw. <*ycount> entsprechen einer Bewegung
nach links bzw. nach oben, positive Werte entsprechen einer
Bewegung nach rechts bzw. nach unten.



-------------------------------------------------------
void mouse_def_eventhandler(word eventmask,void far *handler())
procedure mouse_def_eventhandler(eventmask:word;handler:pointer);

mouse_def_eventhandler ermöglicht das Betreiben einer eigenen
Maus-Interrupt-Routine <handler>, welche unter Beachtung der in
<eventmask> angegebenen Bedingungen aufgerufen wird.

Parameter <eventmask>:

Bit 0  : Mauscursor wurde bewegt
Bit 1  : Linke Taste wurde gedrückt
Bit 2  : Linke Taste wurde gehoben
Bit 3  : Rechte Taste wurde gedrückt
Bit 4  : Rechte Taste wurde gehoben
Bit 5  : Mittlere Taste wurde gedrückt
Bit 6  : Mittlere Taste wurde gehoben



-------------------------------------------------------
void mouse_ligthpen_emulation_on(void)
procedure mouse_ligthpen_emulation_on;

mouse_ligthpen_emulation_on schaltet die Lightpen-Emulation
an.


-------------------------------------------------------
void mouse_ligthpen_emulation_off(int xpos,int ypos)
procedure mouse_ligthpen_emulation_off(xpos,ypos:integer);

mouse_ligthpen_emulation_off schaltet die Lightpen-Emulation
aus.



-------------------------------------------------------
void mouse_set_motion_per_pixel_ratio(int xstep,int ystep)
procedure mouse_set_motion_per_pixel(xstep,ystep:integer);

mouse_set_motion_per_pixel_ratio set die Bewegungsfaktoren der
Maus in x- und y-Richtung.


-------------------------------------------------------
void mouse_conditional_hide_cursor(int left, int right, int top,
                                   int bottom)
procedure mouse_conditional_hide_cursor(left,right,top, Bottom:
                                   integer);

void mouse_conditional_hide_cursor erlaubt die definition eines
Rechtecks, in dem der Mauscursor nicht sichtbar ist. So kann
beispielsweise dieser Bildbereich in direktem Zugriff auf den
Bildspeicher verändert werden kann.




==================================================================
8. ZU DEN BEISPIELPROGRAMMEN
==================================================================

Nähere Information zur Ausführung erster Programmier-Schritte
sollten den Programmier-Beispielen entnommem werden. Durch
Übersetzung und Variation dieser lassen sich die notwendigen
Grundkenntnisse schnell erwerben. Insbesondere das Beispiel
MENUE.C (bzw. MENUE.PAS), welches eine Maskendatei zur Anzeige
bringt und (wenn vorhanden) ein Menü auf der Maske aktiviert,
verdeutlicht mit seinen wenigen Programmzeilen die notwendige
Elementarsequenz zur Maskenbehandlung. BEISPIEL.C (bzw.
BEISPIEL.EXE) enthält eher komplexere Programmteile.
LAGER.C zeigt, wie ganze Datensätze mit dem Aufruf nur einer
Funktion editiert werden können.


==================================================================
9. URHEBERRECHTSSCHUTZ-ERKLÄRUNG
==================================================================

ALLE RECHTE:

Dipl.Ing (FH) Michael Schmiech, Ring 14, 2257 Breklum

Alle Rechte an diesem Programm liegen bei M.Schmiech.
Mit dem Erwerb dieses Produkts wird dem Käufer ein einfaches
Recht zur Nutzung des Urheberrechts-geschützten Programms
eingeräumt. Dieses Recht zur Nutzung bezieht sich ausschließlich
darauf, das Produkt auf oder im Zusammenhang mit jeweils einem
Computer zu benutzen. Eine weitergehende Nutzung ist dem Käufer
nicht gestattet. Der Käufer kann seine Nutzungsrechte am Produkt
nicht an einen Dritten übertragen. Das Programm ist ein mit großem
Aufwand hergestelltes Qualitätsprodukt. Unerlaubte Kopierung,
Vervielfältigung, Verleih oder Vermietung stellt daher einen
Diebstahl geistigen Eigentums dar und wird von mir urheber-
rechtlich verfolgt. Die Veränderung des Programmcodes ist nicht
zulässig. Mit dem Kauf des Produkts erkennt der Käufer diese
Regelungen zum Schutz des Urheberrechts an.



==================================================================
10. HAFTUNGSAUSSCHLUß
==================================================================

Bei der Programmerstellung wurde mit großer Sorgfalt vorgegangen.
Trotzdem können Fehler nicht vollständig ausgeschlossen werden.
Für direkt oder indirekt entstandene Schäden, die aus der Nutzung
der Software entstanden sind, kann ich daher keine Haftung
übernehmen.