Power-Programmierung/CD1.mdf/pascal/library/dos/delite/delite.doc

Text File | 1992-04-01 | 265KB | 5,909 lines

deLite-Programmierhandbuch

Version 2.0     Juli 1991

1. Auflage      (C) BrainLab 1991






                rarely, rarely comest thou, spirit of delight
                                (Shelley, 1821)

















































                               - 1 -


Inhalt

1       Einführung.......................................................4
Eigenschaften von deLite.................................................4
Voraussetzungen..........................................................4
Über dieses Handbuch.....................................................4
Der Aufbau von deLite....................................................5
Die Programmentwicklung mit deLite.......................................5

2       Das deLite-Programmiermodell.....................................6
Botschaften und Ereignisse...............................................6
Callback-Prozeduren......................................................6
Die Anmeldung der Empfangsprozedur.......................................6
Der Botschaftenfluß......................................................7
Interaktive Hilfsfunktionen..............................................8
Die allgemeine Hilfe.....................................................8
Die kontextabhängige Hilfe...............................................8
Menüs und Dialoge........................................................8
Die Maus-Schnittstelle...................................................9
Die Tastatur-Schnittstelle...............................................9
Konventionen der Datei-Benennung........................................10
Die Initialisierungs-Datei..............................................10
Konventionen der Maus- und Tastaturbedienung............................10

3       Die Verwendung von Menüs........................................12
Die Definition von Menüs mit dem Menü-Compiler..........................12
Die Behandlung von Menü-Meldungen.......................................12
Die Modifikation von Menüpunkten........................................13
Menüpunkte mit einer Überprüfungsmarke versehen.........................13
Menüpunkte sperren......................................................13
Ermitteln des Zustandes des Menüpunktes.................................13
Ermitteln des Menütextes................................................14
Austauschen eines Menüpunktes...........................................14

4       Die Dialoge.....................................................15
Objektorientierte Programmierung........................................15
Ein modaler Dialog......................................................15
Welche Dialogelemente gibt es?..........................................18
CheckBox................................................................18
Button..................................................................18
UserButton..............................................................18
RadioButtons............................................................18
RadioButton.............................................................18
SelectBox...............................................................19
ListBox.................................................................19
EditField...............................................................19
Slider..................................................................19
UserRadioButtons........................................................19
UserRadioButton.........................................................20
LabelText...............................................................20
LabelFrame..............................................................20
FileRequester...........................................................20
Die Behandlung von Dialogereignissen....................................21

5       Die Verwendung von Fenstern.....................................22
Von Fenstern, Viewports und Klienten....................................22
Viewports...............................................................22
Fenster.................................................................22
Klienten................................................................22
Der Dispatcher..........................................................23
Die Benutzung von Fenstern..............................................24

                               - 2 -


Dialogfenster...........................................................24
Die Anmeldung weiterer Klienten.........................................25
Nicht-modale Dialoge....................................................26

6       Die graphischen Operationen.....................................29
Elementare Zeichenoperationen...........................................29
Setzen eines Pixels.....................................................29
Zeichnen einer Linie....................................................29
Zeichnen eines Rechtecks................................................29
Zeichnen einer rechteckigen Fläche......................................29
Zeichnen eines Kreises..................................................29
Zeichnen eines Kreissegmentes...........................................29
Verändern des Linienstils...............................................29
Der Grafikcursor........................................................30
Der Standard-Zeichensatz................................................30
Ausgabe eines Textes im Standardzeichensatz.............................30
Ermitteln der Größe eines Zeichens......................................30
Der skalierbare Zeichensatz.............................................31
Zeichenrichtung und Textstyles..........................................31
Weitere Funktionen......................................................31
Zeichnen von Ikonen.....................................................31

7       Die Initialisierungsdatei.......................................33
Aufbau der Initialisierungsdatei........................................33
Systemabschnitte........................................................34
Datentypen der Initialisierungsdatei....................................34
Der Name................................................................34
Der geschützte String...................................................34
Der Longint.............................................................34
Listen in der Initialisierungsdatei.....................................35
Benutzung der Initialisierungsdatei.....................................35
Zugriff auf Namen.......................................................35
Zugriff auf geschützte Strings..........................................36
Zugriff auf Longints....................................................36
Benutzung von Listen....................................................37

8       Die Verwendung von Systemtimern.................................39
Setzen eines Systemtimers...............................................39
Stoppen eines Systemtimers..............................................39

9       Referenz........................................................41

10      Verzeichnis der Objekte.........................................71
Die Objekthierarchie....................................................71
Konventionen............................................................71
Bitkodierte Informationen...............................................71

Anhang A Konfigurationsmöglichkeiten....................................85
Der Abschnitt Paths.....................................................85
Der Abschnitt Hardware..................................................85
Der Abschnitt memory....................................................85
Der Abschnitt colors....................................................86

Anhang B Fehlermeldungen................................................87

Anhang C Kompatibilität zu deLite 1.X-Applikationen.....................91






                               - 3 -


1 Einführung

Eigenschaften von deLite

Mit  dem  deLite  Toolkit  für Turbo-Pascal  verleihen  Sie Ihren
Programmen  ein ansprechendes  Äußeres,  ohne das Rad ein zweites
Mal  erfinden  zu  müssen.   Unter  deLite  erstellte   Programme
profitieren von einer Vielzahl nützlicher Eigenschaften:

        -Pulldown-Menüs, die zur Laufzeit modifiziert
         werden können
        -Mausbedienung mit Ereignissteuerung
        -kontextsensitive Hilfsfunktionen
        -Treiber für eine Vielzahl von Grafikkarten, auch mit 256 Farben
        -objektorientierte Dialoge
        -Komfortabler Zugriff auf eine Initialisierungsdatei

Der  Preis,  den  Sie für diese  Vorteile  bezahlen,  ist gering:
deLite  macht  Ihre  Programme  nur  um  etwa  70k  länger;  eine
intelligente  Speicherverwaltung  sorgt dafür, daß Ihnen auch bei
einem  Dutzend  sich  überlappender  Fenster  der Arbeitsspeicher
nicht  knapp  wird.  Das deLite-Programmiermodell  ist leicht  zu
verstehen  und  orientiert   sich  an  den  Paradigmen   moderner
Oberflächen wie Microsoft Windows oder OS/2 Presentation Manager.
Eine Reihe von Beispielprogrammen  erleichtert Ihnen den Einstieg
in den Umgang mit deLite.

Voraussetzungen

DeLite ist in Turbo-Pascal  6.0 geschrieben  und besteht aus zwei
Units, die von Ihrem Programm importiert werden müssen. Eine Maus
ist nicht unbedingt notwendig, aber doch sehr empfehlenswert.  Da
die  Speicherverwaltung  von  deLite  unter  Umständen  auf  Ihre
Festplatte    zurückgreifen    muß,    um   Bildschirmausschnitte
auszulagern,  ist etwa ein MByte freier Speicherplatz  notwendig.
Noch  besser  ist  es,  wenn  Sie über  EMS verfügen.   Natürlich
benötigen  Sie einen grafikfähigen  Bildschirmadapter,  um deLite
verwenden zu können.  Für die Verwendung  der Dialoge sollten Sie
zumindest    über    Grundkenntnisse    der    objektorientierten
Programmierung unter Turbo-Pascal 6.0 verfügen.

Über dieses Handbuch

Dieses  Handbuch  informiert  Sie  über  die  Programmierung  mit
deLite.   Das  zweite  Kapitel  erläutert  in  groben  Zügen  die
Konzeption  von  deLite  und macht  Sie mit dem zugrundeliegenden
Programmiermodell  vertraut.  Das  Kapitel  enthält  ein  kleines
Beispielprogramm.   Im dritten  Kapitel  wird die Erstellung  und
Benutzung von Menüs erläutert. Hier erfahren Sie, wie Sie mit dem
Menücompiler  arbeiten  und wie Sie das Aussehen  von Menüpunkten
ändern können.  Das vierte Kapitel  erläutert  den Umgang mit dem
Dialogmanager von deLite. Der Dialogmanager erlaubt es Ihnen, aus
vielen vorhandenen  und ggf.  neu von Ihnen erstellten  Elementen
beliebige  Dialogfelder  zu erstellen,  über  die  Sie  beliebige
Interaktionen  mit  dem  Anwender  Ihres  Programmes  realisieren
können.   Das  fünfte  Kapitel  behandelt   die  Aufteilung   des
Bildschirms in mehrere Teile, die getrennt verwaltet werden.  Ein
Beispielprogramm zeigt, wie die Bildschirmaufteilung zur Laufzeit
geändert  werden  kann.  Außerdem  wird  in  diesem  Kapitel  der
Mechanismus  der  Botschaftenverteilung  erläutert.  Im  sechsten
Kapitel erfahren  Sie, welche graphischen  Primitive  Ihnen unter

                               - 4 -


deLite  zur Verfügung  stehen.   Das sind  elementare  graphische
Funktionen  wie etwa das Zeichnen  einer  Linie  oder  das Setzen
eines  Punktes.   Im siebten  Kapitel  wird  der Zugriff  auf die
Initialisierungsdatei   behandelt.    Die   Initialisierungsdatei
enthält  die  zur  Konfiguration   Ihres  Programmes   benötigten
Einstellungen  und wird  von deLite  benutzt,  um den verwendeten
Grafiktreiber  und  einiges  mehr  zu  spezifizieren.  Das  achte
Kapitel beschreibt die Verwendung  von Timerevents.   TimerEvents
sind  ab  deLite   Version   2.0  verfügbar   und  erlauben   die
Realisierung  von reproduzierbar  zeitabhängigen  Funktionen  auf
unterschiedlich  schnellen  Rechnern.  Das neunte Kapitel enthält
eine vollständige  Referenz aller Funktionen  und Prozeduren  von
deLite.   Dieser  Teil ist alphabetisch  geordnet  und dient  als
Nachschlagewerk. Alle Funktionen und Prozeduren von deLite werden
mit ihrer vollständigen Deklaration erläutert. Das zehnte Kapitel
enthält  eine Liste aller  von deLite  deklarierten  Objekte  und
ihrer  Methoden.  Hier  finden  Sie  auch  eine  Darstellung  der
Objekthierarchie. Im Anhang finden Sie neben einem Index Hinweise
zur Konfiguration  und Installation von deLite.  Anwender älterer
deLite-Versionen  erfahren  hier, welche  Änderungen  nötig sind,
damit Ihre Programme unter deLite 2.0 laufen.

Der Aufbau von deLite

Das deLite-Toolkit  besteht aus zwei Units, vielen Grafiktreibern
und  einigen  Hilfsprogrammen.    Das  Unit  Kernel  enthält  die
Schnittstelle  zu den dynamisch nachgeladenen Grafiktreibern  und
stellt   alle   elementaren   Grafikbefehle,    die   sogenannten
graphischen  Primitive,  zur Verfügung.   Außerdem enthält es die
Routinen  für den Zugriff auf die Initialisierungsdatei.   Kernel
und Grafiktreiber  können  als Ersatz  für das Unit Graph und die
BGI-Treiber  von Borland's Turbo-Pascal  verstanden  werden, auch
wenn  der Funktionsumfang  nicht  identisch  ist.  Gegenüber  den
BGI-Treibern  bietet  der  deLite-Kernel  den Vorteil,  in vielen
Belangen  schneller  zu sein und den Zugriff auf wesentlich  mehr
Grafiktreiber  zu bieten.  Andere, seltener benötigte  Funktionen
des Unit Graph werden  Sie bei deLite  nicht finden;  dazu zählen
zum Beispiel alle Operationen  zum Füllen von Flächen.   Das Unit
API setzt auf dem Kernel  auf und stellt  eine Fensterverwaltung,
einen Menümanager  und Dialoge zur Verfügung.   Das API verwendet
als weitere  Units  eine Speicherverwaltung  und eine  Liste  der
sprachabhängigen  Zeichenketten.  Das API stellt komplexe, bequem
anzuwendende Mechanismen für die Maussteuerung und die Verwaltung
der Fenster  zur Verfügung,  die sich der elementaren  Prozeduren
des Kernel bedienen.  Kernel-Funktionen,  die ausschließlich  für
das API von Bedeutung  sind, werden im Referenzteil  im Kapitel 8
nicht aufgeführt.

Die Programmentwicklung mit deLite

DeLite  verwendet  eine eigene Exit-Prozedur,  die Laufzeitfehler
des  Programms  abfängt  und  in  den  Textmodus  zurückschaltet.
Während  der Programmentwicklung  ist es allerdings  praktischer,
Laufzeitfehler  von  der  integrierten  Entwicklungsumgebung  von
Turbo-Pascal abfangen zu lassen.  Zu diesem Zweck sollten Sie die
Prozedur  DebugOn  zu Beginn  Ihres Programms  aufrufen,  die die
ursprüngliche Exit-Prozedur wieder aktiviert.





                               - 5 -


2 Das deLite-Programmiermodell

Die Programmierung  unter  deLite  unterscheidet  sich in einigen
Belangen deutlich von der gewohnten sequentiellen Programmierung.
Unter einer graphischen  Oberfläche hat der Programmierer  keinen
direkten  Zugang  mehr zu den Systemressourcen  wie der Maus, der
Tastatur oder dem Bildschirm.   Besonders  drastisch  wird dieser
Unterschied  bei der Bearbeitung  von Eingaben.  Botschaften  und
Ereignisse Anstatt die Eingabegeräte  periodisch abzufragen, wird
in  einem  ereignisgesteuerten   System  eine  Nachricht  an  die
Empfangsprozedur   des  Hauptprogramms   gesendet,   sobald  eine
entsprechende  Aktion des Benutzers  geschehen  ist.  Botschaften
sind elementar für das Verständnis des deLite Programmiermodells.
Eine Botschaft  enthält  die Information  über ein Ereignis,  das
stattgefunden  hat.  Ereignisse  in diesem  Sinne  sind vor allem
Eingaben  über die Tastatur  oder die Maus, aber auch abstraktere
Ereignisse   wie  das  Auswählen   eines  Menüpunktes   oder  die
Aufforderung,   den  Bildschirminhalt   neu  zu  zeichnen.   Eine
Botschaft   wird   durch   den  varianten   Verbundtyp   EventTyp
repräsentiert.

        EventTyp = RECORD
                     TimeStamp  : Word;
                     Case Class : EventTypes of
                       TimerEvent  : (
                            ClientID     : Integer;
                            TimerChannel : Integer;
                                     );
                       DialogEvent : (
                            ID,MSG       : integer;
                            DlgAdr       : Pointer;
                                     );
                       Menu         : (MenuItemID : Integer);
                       LeMouse, DoubleClick, MouseUnNormalized,
                       NormKey, AltKey, CtrlKey, FKey,
                       DoRedraw, Terminate,
                       UserEvent
                       Void        : (
                            Attrib       : CHAR;
                            x,y          : INTEGER;
                                     );
                   End; { Case & Record }

Der Aufzählungstyp  Class gibt an, um welche Art von Ereignis  es
sich handelt.   Dabei  wird grob unterschieden  zwischen  Timer-,
Dialog- und einer Reihe weiterer Events.

Callback-Prozeduren

Um das Hauptprogramm  von einem Ereignis  in Kenntnis  zu setzen,
wird  dessen  Hauptempfangsprozedur  aufgerufen.   Das  ist  eine
Prozedur  vom  vordefinierten   Typ  EventReceiveProc,   der  das
Ereignis  in Form einer Variable  vom Typ Event,  der sogenannten
Botschaft,  übergeben wird.  Diese Art von Prozeduren  bezeichnet
man auch als Callback-Prozeduren,  da eine übergeordnete  Instanz
sie  bei Bedarf  aufruft.   Vorher  allerdings  ist es notwendig,
dieser   übergeordneten    Instanz,    in   unserem    Fall   dem
deLite-Toolkit,  den  Namen  der  Callback-Prozedur  mitzuteilen.
Diesen Vorgang bezeichnet  man als Anmeldung.

Die  Anmeldung  der Empfangsprozedur

                               - 6 -



Der komplette Initialisierungsvorgang von deLite wird nach Aufruf
der Prozedur OpenMainApplication  durchgeführt.   Dieser Prozedur
werden   drei   Variablen   übergeben,   von   denen   eine   die
Empfangsprozedur selbst ist.

        TYPE EventReceiveProc = Procedure(MyMessage: EventTyp);
        Function OpenMainApplication(EventHandler: EventReceiveProc;
                                 modus: integer;
                                 Name: NameString): integer;

Daneben  wird  der Name des Programms  und in modus  ein Flag für
einige  optionale  Eigenschaften  übergeben.   Der Name dient als
Dateiname  zum  Einlesen  der Resourcen  wie der Menüs  oder  der
Hilfetexte.  Üblicherweise besteht die Empfangsprozedur aus einem
Case-Konstrukt,    innerhalb   dessen   auf   die   verschiedenen
Ereignistypen   reagiert   wird.    Allerdings   ist   es   nicht
erforderlich,  auf alle Ereignisse  wirklich zu reagieren;  viele
Ereignisse  wie  z.B.  Menüereignisse  können  zunächst  durchaus
ignoriert   werden   und  erst   zu  einem   späteren   Zeitpunkt
implementiert  werden.   Auf diese Weise unterstützt  deLite  den
Top-Down Entwurf Ihres Programms.

Der Botschaftenfluß

Prinzipiell   wäre   es   möglich,   nach   der   Anmeldung   der
Empfangsprozedur  die Kontrolle  vollständig  an deLite abzugeben
und  erst  nach   der  Beendigung   des  Programms   wieder   zum
Hauptprogramm zurückzukehren.   DeLite geht einen anderen Weg, um
Ihnen  die  Möglichkeit  offenzuhalten,  in  den  Botschaftenfluß
einzugreifen.  Das wäre z.B.  dann notwendig, wenn Sie den Wunsch
hätten,   weitere   Ereignisse   zu  generieren,   um  etwa   ein
rudimentäres Multitasking zu realisieren.  Nach der erfolgreichen
Ausführung    der   Prozedur    OpenMainApplication    wird   das
Hauptprogramm   in  eine  Schleife  einsteigen,   die  erst  nach
Beendigung  des  Programms  wieder  verlassen  wird.   In  dieser
Schleife   wird  jeweils  mit  GetEvent  ein  Ereignis   aus  der
Warteschlange  geholt  und  mit  DispatchMessage  dem System  zur
Weiterverarbeitung   übergeben.    Das  kleine  Beispiel  "hello"
illustriert diesen Vorgang:

        PROGRAM hello;
        USES Kernel, API;
        VAR  MyEvent           : EventTyp;
             StillRunning      : boolean;

        {$F+ }
        Procedure HandleMsg(MyMessage: EventTyp);
        Begin
          With MyMessage Do
            Case Class Of
              Menu    : Case MenuItemID of
                             0  : StillRunning := false;
                             10 : ErrWindow(30,30,'Hello world');
                        End;
            End;
        End;
        {$F- }

        Begin
          StillRunning := true;

                               - 7 -


          If OpenMainApplication(HandleMsg,APP_NOFONT,'hello') = 0 then
            while StillRunning Do
              begin
               GetEvent(MyEvent);
               DispatchMessage(MyEvent);
              end;
          CloseMainApplication;
        End.

In  diesem   Beispiel   wird   die   Empfangsprozedur   HandleMsg
angemeldet.   Der  Parameter  APP_NOFONT  zeigt  an, daß es nicht
notwendig  ist, einen skalierbaren  Zeichensatz  zur Verfügung zu
stellen.  Die Menübeschreibung  zu diesem Programm definiert zwei
Menüpunkte mit den Identifikationsnummern 0 und 10, von denen die
erste   zum   Beenden   des   Programms   dient.   Die   Prozedur
DispatchMessage  steuert  den  Fluß  der  Botschaften  durch  das
System.   Sie entscheidet,  ob die Nachricht  unmittelbar  an die
Empfangsprozedur  des Hauptprogramms  zu senden ist oder zunächst
vom Menümanager  zu verarbeiten  ist.   Der Menümanager  ist eine
Empfangsprozedur  innerhalb von deLite, die für die Menüsteuerung
zuständig ist.  Sie generiert Meldungen der Klasse Menu, die dann
über   DispatchMessage   wieder   an  die  Empfangsschleife   des
Hauptprogramms geschickt werden.

Interaktive Hilfsfunktionen

Unter  deLite  stehen  Ihnen  automatisch   zwei  leistungsfähige
Mechanismen   zur  Hilfestellung   zur  Verfügung.   Neben  einer
allgemeinen  Hilfsfunktion  mit einem  Index  bietet  deLite  die
Möglichkeit,    in   Abhängigkeit   vom   Programmzustand    eine
kontextabhängige Hilfe aufzurufen.

Die allgemeine Hilfe

DeLite fügt automatisch  ganz rechts am Menübalken  einen Eintrag
"F1=Hilfe" ein.  Wird dieser Menüpunkt ausgewählt,  oder wird die
Funktionstaste   F1  betätigt,  ohne  daß  ein  Kontext  für  die
interaktive  Hilfe  erkannt  wird, erscheint  ein Index,  aus dem
einzelne Stichworte ausgewählt werden können. Diese Hilfsfunktion
sollte ganz allgemein die Bedienung des Programms erläutern.

Die kontextabhängige Hilfe

Wird  die Taste  F1 betätigt,  wenn ein Menü offen  ist oder  ein
Dialog  aktiv  ist,  wird  der Name des Menüpunktes  bzw.  ein im
Dialog definiertes  Stichwort  dazu verwendet,  aus einer zweiten
Hilfsdatei  einen Text zu suchen und in einem Fenster anzuzeigen.
Der  Hilfetext   sollte   konkrete   Informationen   zum  jeweils
ausgewählten Menüpunkt bzw.  zum gerade aktiven Dialog geben.  Es
ist  möglich,   für  die  Dialoge  auf  diese  Hilfsfunktion   zu
verzichten.    Die  Hilfetexte  sind  vom  Programm  getrennt  in
ASCII-Dateien  abgelegt  und können deshalb  leicht  ausgetauscht
werden, ohne das Programm  neu übersetzen  zu müssen.  Sie nehmen
keinen  Platz  im Arbeitsspeicher  in Anspruch,  da sie immer nur
kurzzeitig eingeladen werden.

Menüs und Dialoge

DeLite verfügt über einen leistungsfähigen Menümanager, der Ihnen
die  Verwaltung  der  Menüsteuerung  vollständig  abnimmt.  Menüs
werden in einer ASCII-Datei  definiert,  mit dem Menücompiler  in

                               - 8 -


ein  binäres  Format  konvertiert   und  zur  Laufzeit  dynamisch
eingeladen.   Menüs können  sowohl  mit der Maus als auch mit der
Tastatur  bedient  werden;  für  jeden  Eintrag  kann  ein Hotkey
definiert  werden,  mit dessen  Hilfe die Auswahl  auch ohne Maus
besonders  schnell erfolgt.  Das Erscheinungsbild  der Menüs kann
jederzeit verändert werden.  Menüeinträge  können gesperrt werden
oder mit einer Überprüfungsmarke versehen werden.  Der Name eines
Eintrags  kann vom Programm  geändert  werden.  Jeder Menüeintrag
wird bei der Definition mit einer Identifikationsnummer versehen.
Diese Nummer wird der Empfangsprozedur  mitgeteilt, wenn ein Menü
ausgewählt wurde, und muß bei jeder Modifikation  des zugehörigen
Menüpunktes  angegeben  werden.  DeLite verwendet Pulldown-Menüs,
wie  sie  heute  in  vielen  Programmen  verwendet  werden.   Ein
Menübalken  ist  stets  sichtbar  und erlaubt  die Auswahl  eines
Untermenüs,  aus dem dann  der eigentliche  Menüpunkt  ausgewählt
wird.   Die  Anzahl  der  Einträge  im Menübalken  oder  in einem
Untermenü  ist  nur  durch  die Größe  des Bildschirms  begrenzt.
Komplexere Interaktionen werden über Dialoge realisiert.  Dialoge
bestehen aus beliebig zu kombinierenden graphischen Elementen wie
Schaltern,  Eingabefeldern,  Listen  und  Schiebereglern.  DeLite
bietet viele vordefinierte  Dialogelemente  und erlaubt  es Ihnen
auch, neue Dialogelemente zu definieren. Einzelne Elemente können
zu Gruppen zusammengefasst  werden und bilden so neue, komplexere
Dialogelemente,  die  genauso  einfach  wie die Grundelemente  zu
verwenden sind.

Die Maus-Schnittstelle

Da die Maus als asynchrones  Gerät jederzeit bedient werden kann,
werden  Mausereignisse  in einer  Warteschlange,  der Eventqueue,
zwischengespeichert, um dann bei Bedarf abgerufen und verarbeitet
zu werden.  In dieser Warteschlange werden die Mausereignisse  in
ihrer  ursprünglichen   Form  gespeichert,  das  heißt,  daß  die
Mauskoordinaten  sich  auf die linke  obere  Ecke des Bildschirms
beziehen.  Später, nachdem die Mausereignisse von DispatchMessage
verarbeitet worden sind, werden die Mauskoordinaten normalisiert,
bevor sie an den Empfänger weitergeleitet  werden.  Das bedeutet,
daß sich Mausereignisse, wenn sie der Empfangsprozedur  übergeben
werden,  auf  die  linke  obere  Ecke  des  aktuellen   Viewports
beziehen.   Unter einem Viewport  versteht man einen rechteckigen
Bildschirmausschnitt,  auf den sich alle graphischen  Operationen
beziehen.   Beachten Sie, daß es immer mindestens  zwei Viewports
gibt:   Der  Menübalken  nimmt  am  oberen  Bildschirmrand  einen
schmalen Streifen in Anspruch,  während dem Hauptprogramm  in der
Regel   der  restliche   Teil   des  Bildschirms   gehört.    Die
Normalisierung der Mauskoordinaten  ist notwendig, damit sich Ihr
Programm nicht um die Bildschirmaufteilung kümmern muß.

Die Tastatur-Schnittstelle

Tastaturereignisse werden wie Mausereignisse in der Warteschlange
zwischengespeichert.  Da die PC-Tastaturen in der Lage sind, mehr
als 256 verschiedene  Tastencodes  zu generieren,  werden mehrere
Klassen von Tastaturereignissen unterschieden. Der Eintrag Attrib
eines Events enthält  die Taste selbst,  während  Class die Werte
ALTKEY, CTRLKEY, FKEY oder NORMKEY annehmen kann. Auf diese Weise
wird unterschieden, ob eine Taste in Verbindung mit ALT oder CTRL
betätigt  wurde oder ob eine Funktionstaste  gedrückt  wurde.  Zu
beachten ist, daß die ENTER-Taste in die Klasse CTRLKEY fällt. In
vielen Fällen wird es nicht nötig sein, auf Tastaturereignisse zu
reagieren. Tastaturereignisse, die sich auf die Menüs oder aktive

                               - 9 -


Dialoge   beziehen,   werden   vom  System   automatisch   selbst
verarbeitet.

Konventionen der Datei-Benennung

Unter deLite gelten eine Reihe von Konventionen für die Benennung
der Dateien,  an die Sie sich  halten  müssen,  wenn Ihr Programm
funktionieren  soll.  Eine lauffähige Anwendung besteht neben der
ausführbaren EXE-Datei noch aus mindestens fünf weiteren Dateien:
Die  Initialisierungsdatei   enthält   Informationen   über   die
verwendete Grafikkarte und einiges mehr und hat die Endung ".ini"
Die Menübeschreibung  in kompilierter Form befindet sich in einer
Datei mit der Endung ".rsc"  Die allgemeine  Hilfetexte  befinden
sich in einer Datei mit der Endung  ".hlp"  Die kontextabhängigen
Hilfetexte   befindet   sich  in  einer   Datei   mit  dem  Namen
"online.hlp" Der Grafiktreiber  trägt die Endung ".vdi".  Er muss
sich allerdings nicht im gleichen Verzeichnis wie das ausführbare
Programm befinden.  Daneben können noch skalierbare  Zeichensätze
vorhanden  sein, die die Dateiendung  ".fnt" tragen.  Sollten Sie
über die Bedeutung  einer Datei im unklaren  sein, können Sie sie
einfach  mit  dem  DOS-Befehl  TYPE  ansehen.   Alle  vom  System
verwendeten binären Dateien tragen einen druckbaren Vorspann, der
weitere Informationen gibt.

Die Initialisierungs-Datei

Die   Initialisierungsdatei   enthält   die   Informationen   zur
Konfiguration  Ihres Programmes.   Sie ist in einzelne Abschnitte
unterteilt,  deren Titel jeweils in eckigen Klammern  geschrieben
ist.  Einige Abschnitte sind bereits vom System belegt und dienen
der   Konfiguration   des   Grafiktreibers,    der   skalierbaren
Zeichensätze,  der  Farben  und der Speicherverwaltung.   Darüber
hinaus  können  Sie  eigene  Abschnitte  hinzufügen  und in Ihrem
Programm verwenden;  deLite stellt einen Satz von Prozeduren  zur
Verfügung,   die  den  Zugriff  auf  die  Informationen   in  der
Initialisierungsdatei   ermöglichen.    Beachten   Sie,  daß  das
Vorhandensein  einiger Einträge notwendig ist, um Ihr Programm zu
starten.   Ohne  die Angabe  des Videotreibers  wird die Prozedur
OpenMainApplication einen Fehler zurückliefern.  Andere Einträge,
wie etwa die Farbzuordnung, sind fakultativ und werden vom System
durch  Standardwerte   ersetzt,   falls  keine  Angaben   in  der
Initialisierungsdatei      gemacht      werden.       Da      die
Initialisierungsdatei  im ASCII-Format  abgelegt  ist,  kann  sie
leicht mit einem herkömmlichen Texteditor modifiziert werden. Wir
empfehlen,  von  dieser  Möglichkeit  der Konfiguration  in Ihrem
Programm Gebrauch zu machen.

Konventionen der Maus- und Tastaturbedienung

Bei der Definition  der Bedienung der Menüs und der Dialoge haben
wir eine Reihe von Konventionen  aufgestellt, die sich an gängige
Standards anlehnen.  -Die linke Maustaste wählt Elemente aus -Die
rechte   Maustaste   schliesst   das  gerade  offene   Menü  -Die
ESCAPE-Taste  schließt offene Menüs oder Dialoge -Die ENTER-Taste
wählt markierte  Elemente aus Die Einträge  im Menübalken  können
über  die  Tastatur  erreicht  werden,  indem  die  ALT-Taste  in
Verbindung  mit dem jeweiligen Hotkey betätigt wird Innerhalb der
Menüs  kann  die Menümarkierung  mit den Cursortasten  verschoben
werden  Die  Funktionstaste  F1 aktiviert  die Hilfefunktion  Wir
empfehlen, diese Konventionen  auch bei der Programmierung  Ihrer
eigenen Programmteile zu beachten.  Insbesondere die Belegung der

                               - 10 -


Maustasten und die Verwendung der ESCAPE/ENTER-Tasten sollte auch
von Ihnen in dieser Form eingehalten werden.




























































                               - 11 -


3 Die Verwendung von Menüs

Die Definition von Menüs mit dem Menü-Compiler

Der  erste  Schritt  bei  der  Definition  eines  Menüs  ist  die
Erstellung  einer  Menübeschreibung  mit Hilfe eines Texteditors.
Sie können dafür den Editor  von Turbo-Pascal  verwenden.   Diese
Menübeschreibung  wird anschließend mit dem Menücompiler  in eine
binäre  Form übersetzt.   Die dabei entstehende  Datei  trägt die
Endung ".rsc". Die Syntax der Menübeschreibungssprache lehnt sich
an  den  Ressource-Compiler   für  Microsoft  Windows  an.   Eine
Menübeschreibung beginnt mit dem Schlüsselwort MENU, dem der Name
der zu erzeugenden  Datei  folgt.   Dieser  Name  entspricht  dem
Projektnamen,    der    OpenMainApplication    übergeben    wird.
Anschließend  folgt eine Anzahl von Untermenübeschreibungen,  die
jeweils   mit   dem   Schlüsselwort   POPUP   beginnen   und   in
BEGIN/END-Konstrukten   eine  Aufzählung  der  Menüeinträge   mit
MENUITEM enthalten.  Jeder Menübeschreibung und jedem Menüeintrag
müssen drei Argumente folgen:  Der in doppelten Anführungszeichen
geklammerte  Text enthält das Stichwort;  danach folgt der Hotkey
und die Identifikationsnummer. Im Stichwort sollte dem Hotkey ein
Ampersand-Symbol   (kaufmännisches   Und)   vorausgehen,   um  zu
kennzeichnen,    daß   der   folgende   Buchstabe   unterstrichen
dargestellt  werden soll.  Innerhalb  der Untermenübeschreibungen
können     Separatorlinien      zur     optischen      Abgrenzung
zusammengehörender  Gruppen von Menüeinträgen  eingefügt  werden.
Optional     kann     den     MENUITEM-Einträgen     nach     der
Identifikationsnummer  das Schlüsselwort  INACTIVE  oder  CHECKED
folgen, um anzuzeigen,  daß der entsprechende  Menüpunkt  inaktiv
oder   mit   einer   Überprüfungsmarke   versehen   ist.    Beide
Schlüsselworte  können auch kombiniert werden.  Beachten Sie, daß
MENUITEM-Zeilen  mit  einem  Semikolon  enden  müssen.  Nach  dem
letzten  POPUP-Block  muß  ein abschliessendes  END stehen.   Ein
Beispiel    zeigt   die   Menübeschreibung    für   das   "hello,
world"-Programm aus dem zweiten Kapitel.

        MENU hello
        POPUP "&Hello" H 100
        BEGIN
          MENUITEM "&Hi there!" H 101;
          MENUITEM "SEPARATOR"
          MENUITEM "&Goodbye" G 0;
        END
        END

Übersetzt wird die Menübeschreibung  unter Angabe des Dateinamens
als Kommandozeilenparameter. In den Beispielprogrammen enden alle
Menübeschreibungen mit ".rc", hier wäre also mit compile hello.rc
die  Übersetzung   vorzunehmen.    Der  Menücompiler   wird   bei
erfolgreicher  Übersetzung  die Meldung OK ausgeben, anderenfalls
weist er unter Angabe der Zeilennummer auf den Fehler hin.

Die Behandlung von Menü-Meldungen

Die    Behandlung    von   Menümeldungen    geschieht    in   der
Empfangsprozedur des Hauptprogrammes.  Menümeldungen besitzen die
Klasse Menu und enthalten im Element MenuItemID der Botschaft vom
Typ   EventTyp   die   Identifikationsnummer   des  dazugehörigen
Menüeintrages.   Eine  Meldung  wird erst dann abgeschickt,  wenn
wirklich  ein Menüpunkt  ausgewählt  worden ist, das Öffnen eines
Menüs  und  anschließende   Verlassen   oder  die  Benutzung  der

                               - 12 -


interaktiven Hilfe zieht keine Meldung an das Hauptprogramm  nach
sich.    Üblicherweise   wird  die  Empfangsprozedur   aus  einem
Case-Konstrukt bestehen, dessen Selektoren wieder Case-Konstrukte
sind. Es ist empfehlenswert, die einzelnen Identifikationsnummern
der Menüpunkte nicht direkt als Selektoren  zu verwenden, sondern
zu Beginn  als Konstante  zu deklarieren,  um symbolisch  auf die
Menüpunkte   zugreifen   zu  können.   Anderenfalls   leidet  bei
umfangreichen Menübäumen die Lesbarkeit des Quelltextes.

Die Modifikation von Menüpunkten

Zur Modifikation des Aussehens von Menüpunkten existiert ein Satz
von Prozeduren und eine vordefinierte  Liste von Konstanten.  Der
Zugriff  auf die Menüpunkte  geschieht  nicht  über ihren  Namen,
sondern  grundsätzlich  über  die  Identifikationsnummer.  DeLite
besitzt  die Fähigkeit,  mehrere Menübäume  verwalten  zu können,
daher muß zusätzlich ein Handle auf das betroffene Menü übergeben
werden. Das Handle auf das Menü ist nichts anderes als ein Zeiger
auf  die Wurzel  des Menübaums,  für den ein spezieller  Datentyp
definiert   wurde.    Das  Handle  auf  das  Hauptmenü   ist  dem
Hauptprogramm  zunächst  nicht  bekannt,  es  muß  erst  mit  der
Funktion GetMenu erzeugt werden.

Menüpunkte mit einer Überprüfungsmarke versehen

Die   Prozedur    CheckMenuItem    setzt   oder   entfernt    die
Überprüfungsmarke vor dem Menüeintrag.  Die Überprüfungsmarke ist
als Häkchen links neben dem Menüeintrag sichtbar.

        Procedure CheckMenuItem(Menu:   hmenu;
                                ID:     MenuID;
                                wCheck: MenuFlags);
Die Variable wCheck kann einen der folgenden Werte annehmen:
MF_CHECKED                      setzt die Überprüfungsmarke
MF_UNCHECKED                    entfernt die Überprüfungsmarke

Menüpunkte sperren

Die Prozedur EnableMenuItem  sperrt einen Menüpunkt oder gibt ihn
frei.  Gesperrte  Menüpunkte  werden grau dargestellt  und können
nicht ausgewählt  werden.   Die Hilfsfunktion  bleibt  allerdings
weiterhin funktionsfähig.

        Procedure EnableMenuItem(Menu:    hmenu;
                                 ID:      MenuID;
                                 wEnable: MenuFlags);
Die Variable wEnable kann einen der folgenden Werte annehmen:
MF_ENABLED                      erlaubt die Auswahl des Menüpunktes
MF_DISABLED                     sperrt den Menüpunkt

Ermitteln des Zustandes des Menüpunktes

Mit  Hilfe  der  Funktion  GetMenuFlags  kann  der Zustand  eines
Menüpunktes  erfragt werden.  Der Zustand ist bitkodiert  und muß
deshalb   durch   UND-Verknüpfung   mit   den   zu   ermittelnden
Zustandsflags ermittelt werden.

        Function GetMenuFlags(Menu: hMenu;
                              ID  : MenuID):MenuFlags;

        If GetMenuFlags(GetMenu,101) and MF_CHECKED = MF_CHECKED then ...

                               - 13 -




Ermitteln des Menütextes

Die Prozedur  GetMenuString  belegt  eine Stringvariable  mit dem
Text eines Menüpunktes.   Diese Prozedur ist nützlich, um vor dem
Ersetzen eines Menüpunktes den alten Eintrag zu retten.

        Procedure GetMenuString(Menu: hmenu;
                                ID:   MenuID;
                                Var   StrPtr: String);

Austauschen eines Menüpunktes

Die Prozedur ReplaceMenuItem  ersetzt einen Menüpunkt durch einen
anderen.  Dazu sind neben dem Text die Identifikationsnummer  und
der Hotkey des neuen Menüpunktes anzugeben.

        Procedure ReplaceMenuItem(Menu     :hMenu;
                                  ID       :MenuID;
                                  NewItem  : String;
                                  IDNewItem:MenuID;
                                  NewHotKey:char);







































                               - 14 -


4 Dialoge

Dialoge  sind neben den Menüs  die wichtigste  Möglichkeit  unter
deLite, mit dem Anwender eines Programmes zu kommunizieren.   Ein
Dialog   ist  eigentlich   eine   aus  mehreren   Dialogelementen
zusammengesetzte Eingabemaske.  Eine Vielzahl von Dialogelementen
wird von deLite bereits zur Verfügung gestellt,  dazu zählen z.B.
Schalter, Texteingabefelder  und Schieberegler.   Die vorhandenen
Dialogelemente  können modifiziert werden, weitere Dialogelemente
können  definiert  werden,  und Dialogelemente  können zu Gruppen
zusammengefasst    werden,    die   dann   als   neue,   komplexe
Dialogelemente  eingesetzt  werden  können.   Normalerweise  sind
Dialoge modal, das heißt, während ein Dialog aktiv ist, erhält er
alle  Ereignisse  und  läßt  Ereignisse   für  andere  Teile  des
Programmes unberücksichtigt.   Solange ein Dialog offen ist, wird
es also  in der  Regel  nicht  möglich  sein,  die  Menüzeile  zu
aktivieren.   In Verbindung mit Klienten (die im nächsten Kapitel
behandelt  werden) ist es allerdings  auch möglich,  nicht-modale
Dialoge  zu erzeugen.   Auf diese  Weise  kann zum Beispiel  eine
Schalterleiste implementiert werden, die einen Streifen am linken
oder rechten Bildrand  einnimmt  und darauf mehrere Schalter  zur
Verfügung stellt.

Objektorientierte Programmierung

Dialoge und Dialogelemente  sind als Objekte deklariert.  Sollten
Sie mit der objektorientierten Programmierung noch nicht vertraut
sein,  empfehlen  wir,  das Kapitel  I im Buch "Objektorientierte
Programmierung   und   Turbo-Vision"   Ihrer   Dokumentation   zu
Turbo-Pascal  zu lesen.  Für den Anfang genügt es, zu wissen, daß
ein Objekt nichts anderes als ein Record ist, der neben Variablen
auch  Prozeduren  und  Funktionen,   die  sogenannten   Methoden,
enthält.    Innerhalb   dieser  Methoden   sind  alle  im  Objekt
deklarierten  Variablen  und anderen Methoden sichtbar, als hätte
man eine WITH-Anweisung  verwendet.   Objekte  können von anderen
Objekten abgeleitet  werden und so eine Objekthierarchie  bilden.
Abgeleitete   Objekte   erben   dabei   alle  Eigenschaften   des
ursprünglichen   Objektes,   besitzen  also  alle  Variablen  und
Methoden, die auch im usprünglichen Objekt deklariert wurden. Das
abgeleitete Objekt deklariert nur die Methoden und Variablen, die
entweder zu den geerbten hinzukommen oder aber modifiziert werden
müssen.    Letzteres    wird    als    Polymorphie    bezeichnet:
Unterschiedliche  Objekte verwenden für ähnliche Aufgaben gleiche
Bezeichner,  und  Turbo-Pascal  wählt  automatisch  die  korrekte
Methode.   So besitzt jedes Dialogelement  von deLite eine eigene
Methode  mit dem Namen  Draw, die das Element  auf dem Bildschirm
zeichnet.   Der Dialogmanager  muß sich nicht darum kümmern,  mit
welchem  Typ von Objekt  er es zu tun hat; ein Aufruf der Methode
Draw wird stets die gewünschte  Methode aufrufen.  Vererbung  und
Polymorphie  können  Sie  sich  zunutze  machen,  wenn  Sie  neue
Dialogelemente kreieren möchten.  Leiten Sie Ihr neues Objekt von
dem  Dialogelement  ab,  das  mit Ihrem  Wunschobjekt  die meiste
Ähnlichkeit hat, und deklarieren Sie die eine oder andere Methode
neu.  Damit  überschreiben  Sie  die  gleichnamigen  Methoden  im
Ursprungsobjekt,   und  schon   verfügen   Sie  über   ein  neues
Dialogelement.

Ein modaler Dialog

Nichts ist so anschaulich  wie ein Beispiel:  Die Abbildung zeigt
einen modalen  Dialog, der zur Eingabe  eines Dateinamens  dienen

                               - 15 -


soll.   Er besteht  aus zwei Knöpfen,  einem Texteingabefeld  und
einer   Überprüfungsbox.    Außerdem   enthält   er   noch   eine
Beschriftung.   Der Anwender  kann den Dateinamen  im Editierfeld
eingeben, auf Wunsch die Überprüfungsbox Read Only anklicken, und
bestätigt  seine  Eingaben  durch  die  Betätigung   des  mit  OK
beschrifteten Schaltknopfes.  Betätigt er alternativ dazu den mit
Abbruch  beschrifteten  Knopf, wird der Dialog beendet  und seine
Eingaben werden verworfen.


Der  Programmcode  zur Erzeugung  und Bedienung  dieses  Dialoges
besteht aus zwei Prozeduren. Die Prozedur DlgEventHandler ist die
Botschaftenempfangsprozedur,  die  alle  Meldungen  des  Dialoges
entgegennimmt.   Sie  muß  wie alle  Callback-Prozeduren  mit der
FAR-Direktive  übersetzt  werden und wird in der ersten Anweisung
der Funktion GetFileName angemeldet.  Jedes Dialogelement erzeugt
Botschaften,  wenn es betätigt  wird:   Ein Knopf meldet,  daß er
gedrückt wurde; ein Dialogfeld  meldet, daß sein Inhalt verändert
wurde.  Nicht immer muß jede Meldung beachtet werden:  In unserem
Beispiel  wird  nur  auf  die  Meldungen  DLG_OK  und  DLG_CANCEL
geachtet,   die   von  den  beiden   Knöpfen   gesendet   werden.
Dialogelemente  merken sich ihren Zustand  bis zum Schließen  des
Dialoges, so daß es oft genügt, kurz vor Beendigung  des Dialoges
den Zustand der Elemente zu erfragen.

procedure DlgEventHandler(TheEvent: EventTyp); far;
var MYDLG: PDLG;
begin
  MYDLG := TheEvent.DlgAdr;
  If TheEvent.Class = DialogEvent then
    Case TheEvent.MSG of
      DLG_OK     :  MYDLG^.DestroyDialog;
      DLG_CANCEL :  begin
                      MYDLG^.flags := MYDLG^.flags or MF_CANCELLED;
                      MYDLG^.DestroyDialog;
                    end;
      end;
end;

Die Prozedur  DlgEventHandler  reagiert  auf die beiden Meldungen
DLG_OK  und DLG_CANCEL  in ähnlicher  Weise.   In jedem Fall wird
durch einen Aufruf  von DestroyDialog  der Dialog  beendet.   Der
Schaltknopf  mit der Aufschrift Abbruch sendet bei Betätigung die
Nachricht  DLG_CANCEL,  in diesem  Fall wird zusätzlich  das Flag
MF_CANCELLED  im Dialog  gesetzt,  damit  der Dialog  feststellen
kann, daß er abgebrochen  wurde.  Beachten Sie, daß die Botschaft
vom Typ EventTyp  ein Feld  mit der Bezeichnung  DlgAdr  enthält.
Dieses  Feld  enthält  einen  Zeiger  auf den Dialog.   So ist es
möglich, innerhalb  einer Botschaftenempfangsprozedur  bequem auf
Methoden und Variablen des betroffenen Dialoges zuzugreifen,  und
zudem kann so eine Empfangsprozedur  für viele Dialoge  verwendet
werden.       Tatsächlich       deklariert       deLite      eine
Botschaftenempfangsprozedur mit der Bezeichnung DefEventProc, die
exakt   der  Prozedur   DlgEventHandler   aus  unserem   Beispiel
entspricht  und  die daher  hätte  verwendet  werden  können.Die
Funktion  GetFileName  ist die eigentliche  Dialogprozedur.   Sie
liefert  als  unmittelbares  Ergebnis  TRUE  zurück,  sofern  der
Anwender den Dialog mit OK beendet hat.  In diesem Fall enthalten
die   Variablenparameter   name   und  readonly   die  im  Dialog
ausgewählten  Werte.  Die Variable  MyDialog ist eine Instanz des
Objektes   Dialog.   Dazu  wird  für  jede  Art  von  verwendetem

                               - 16 -


Dialogelement  ein  Zeiger  deklariert.   Hier  lernen  Sie  eine
Konvention  von deLite kennen:   Die Bezeichner  von Zeigern  auf
Dialogelemente  bestehen  aus dem Namen  des Dialogelementes  und
einem  vorangestellten  P.  Ein  Zeiger  auf ein Objekt  vom  Typ
Checkbox  ist  demnach  vom Typ PCheckBox.   Die erste  Anweisung
MyDialog.Init  initialisiert  ein Dialogfenster der Größe 300x100
Pixel  und ordnet  ihm die Empfangsprozedur  DlgEventHandler  zu.
Anschließend   werden   nacheinander   Dialogelemente   vom   Typ
LabelText,  EditField,  CheckBox  und  zwei  mal Button  erzeugt,
initialisiert und jeweils mit AddItem dem Dialog hinzugefügt. Die
new-Anweisungen  enthalten jeweils Konstruktoraufrufe,  die unter
deLite  stets  Init  heißen  und  für  jedes  Dialogelement   die
Koordinaten, eine ID-Nummer und ggf. weitere Parameter enthalten.
Die   beiden   Schaltknöpfe   zeigen   eine   Besonderheit:   Mit
MakeDefaultItem  bzw.  MakeCancelItem  werden die Knöpfe  mit den
Tasten ENTER bzw.  ESC verbunden  und senden anstelle der Meldung
DLG_BUTTON, die Knöpfe normalerweise  bei Betätigung zusammen mit
Ihrer ID-Nummer senden, die Meldungen DLG_OK bzw. DLG_CANCEL.

function GetFileName(var name: string; var readonly: boolean):boolean;
Var MyDialog   : Dialog;
    MyCheckBox : PCheckbox;
    MyEditField: PEditField;
    MyButton   : PButton;
    MyLabelText: PLabelText;
begin
  MyDialog.Init(300,100, 0, DlgEventHandler);

  new(MyLabelText, Init(10,10, 101, 'Dateiname:'));    { ID 101 }
  MyDialog.AddItem(MyLabelText);

  new(MyEditField, Init(10,30, 20, 20, 102, ''));      { ID 102 }
  MyDialog.AddItem(MyEditField);

  new(MyCheckBox, Init(10,60, 103, 'Read Only'));      { ID 103 }
  MyDialog.AddItem(MyCheckBox);

  new(MyButton, Init(200,10, 80,30, 104, 'OK'));       { ID 104 }
  MyDialog.AddItem(MyButton);
  MyButton^.MakeDefaultItem;

  new(MyButton, Init(200,50, 80, 30, 105, 'Abbruch')); { ID 105 }
  MyDialog.AddItem(MyButton);
  MyButton^.MakeCancelItem;

  MyDialog.Show;            { Dialog zeichnen  }
  MyDialog.DoDialog;        { Dialog ausführen }

  if (MyDialog.flags and MF_CANCELLED) = 0 then
    begin
      GetFileName := true;
      MyEditField := MyDialog.FindDlgItem(101);
      name        := MyEditField^.GetString;

      MyCheckBox  := MyDialog.FindDlgItem(103);
      ReadOnly    := MyCheckBox^.IsChecked;
    end
  else GetFileName := false;
  MyDialog.Done;
end;


                               - 17 -


Nach  dem  Zeichnen  des  Dialoges  mit Show  ruft  die Anweisung
DoDialog   den  Dialogmanager   auf.   Er  enthält   eine  eigene
GetEvent/DispatchMessage-Schleife und beendet diese erst, nachdem
die Methode DestroyDialog aufgerufen wurde.  Danach werden, falls
der Dialog  mit OK abgeschlossen  wurde,  die Parameter  name und
readonly mit den Werten der Dialogelemente belegt.  Done schließt
den Dialog.

Welche Dialogelemente gibt es?

Einige  Dialogelemente  haben  Sie  bereits  kennengelernt.    Im
folgenden   finden  Sie  eine  Liste  aller  Dialogelemente   mit
Abbildungen  Ihres Aussehens und der für die Anwendung  wichtigen
Methoden.  Kapitel 9 enthält ein vollständiges  Verzeichnis aller
von deLite deklarierten Objekte, dem auch die Objekthierarchie zu
entnehmen  ist.  Für die Anwendung der Dialogelemente  sind diese
zusätzlichen  Informationen  nicht wichtig,  wohl aber, falls Sie
eigene Elemente erzeugen möchten.

CheckBox
Konstruktor:    Init(x1,y1,TheID: Integer; TheText: LabelStr)
Methoden:       Function IsChecked: Boolean
                Procedure Check
                Procedure UnCheck
Botschaften:    DLG_CHECKED
                DLG_UNCHECKED

Die  Checkbox  ist  eine  quadratische  Schaltfläche,   die  eine
boolesche   Information   trägt,   die  beim  Auswählen   jeweils
invertiert wird.  Der Initialzustand ist FALSE und kann mit Hilfe
der Prozedur Check auf TRUE gesetzt werden. Der Beschriftungstext
ist fester  Bestandteil  der CheckBox.   Bei jeder  Änderung  des
Zustands wird eine entsprechende Botschaft gesendet.

Button
Konstruktor:    Init(x1, y1, dx, dy, TheID: Integer; TheText: LabelStr)
Botschaften:    DLG_BUTTON

Der Button ist eine quadratische Schaltfläche, die bei Betätigung
eine Botschaft sendet.

UserButton
Konstruktor:    Init(x1, y1, dx, dy, xb, yb, TheID:   Integer;
                TheHK:   char; TheIcon:   Pointer)
Botschaften:    DLG_BUTTON

Der UserButton ist eine quadratische Schaltfläche wie der Button,
enthält allerdings  anstelle  der Beschriftung  eine Grafikikone.
Die  Parameter  xb und yb enthalten  die  Größe  der Grafikikone,
TheIcon ist ein Zeiger auf die Ikone.

RadioButtons
Konstruktor:    Init(x1, y1, dx, dy, TheId: Integer; TheText:
                LabelStr; nextB: PRadioButton)
Methoden:       function WhosChecked: Integer
                procedure CheckButton(TheID: Integer)
Botschaften:    DLG_RADIO

RadioButtons sind Gruppen von Schaltflächen,  von denen immer nur
eine gedrückt sein kann.  Wird ein RadioButton  gesetzt, wird der
zuvor gesetzte gelöscht.   Das Objekt RadioButtons  trägt nur den

                               - 18 -


Rahmen  und die Beschriftung,  die Schaltflächen  selbst sind vom
Typ  RadioButton  und müssen  einzeln  in Form  eines  rekursiven
Aufrufs definiert werden.

RadioButton
Konstruktor:    Init(x1, y1, TheID:  Integer;  TheText:  LabelStr;
                nextB:  PRadioButton)

Ein  RadioButton  ist eine  einzelne  Schaltfläche,  die zu einem
Objekt vom Typ RadioButtons  gehört.  Der Aufruf erfolgt rekursiv
innerhalb des Konstruktors von RadioButtons.

SelectBox
Konstruktor:    Init(x1, y1, wid, TheID: Integer; GetFirst,
                GetNext: ListProc)
Methoden:       Procedure Update
                Function GetSelected: ListString
                Procedure Select(TheString: ListStr)
Botschaften:    DLG_BOXSELECT
                DLG_BOXCHANGE

Die SelectBox erlaubt die Auswahl eines Elementes aus einer Liste
von  Elementen.   Mit Hilfe  der beiden  Schaltflächen  kann  das
jeweils  nächste bzw.  vorherige  Element in der Liste ausgewählt
werden.   Die Liste wird mit Hilfe  der Prozeduren  GetFirst  und
GetNext eingelesen.   Der Parameter wid gibt an, wieviele Zeichen
im Anzeigefeld Platz finden.

ListBox
Konstruktor:    Init(x1, y1, wid, len, TheID: Integer; GetFirst,
                GetNext: GetListProc)
Methoden:       procedure Update
                Function GetSelected: GetListString
Botschaften:    DLG_LISTSELECT

Die Listbox erlaubt wie die SelectBox die Auswahl eines Elementes
aus einer  Liste  von Elementen,  allerdings  sind  hier  mehrere
Elemente gleichzeitig sichtbar.  Der Parameter len gibt dabei an,
wieviele  Elemente  sichtbar  sind.  Die Liste wird mit Hilfe der
Prozeduren GetFirst und GetNext eingelesen.

EditField
Konstruktor:            Init(x, y, len, max, TheID: Integer;
                        deflt: String)
Methoden:               procedure SetString(TheStr: string)
                        function GetString: string
                        function IsInteger: boolean
                        function GetValue: Integer
Botschaften:            DLG_EDITCHGD

Das EditField dient der Eingabe einer Zeichenkette. Der Parameter
len gibt an, wievielen  Zeichen innerhalb  des Fensters  sichtbar
sein  sollen.   Der  Parameter  max  gibt  die  Maximallänge  der
Zeichenkette an.  Sollte max größer sein als len, wird der Inhalt
des Editierfeldes  entsprechend  in der Anzeige verschoben.   Der
Inhalt  kann  auch  als  Integerwert  interpretiert  werden.  Die
Methode  IsInteger  stellt  fest,  ob  der  Inhalt  eine  gültige
Integerzahl darstellt.

Slider
Konstruktor:            Init(x1, y1, len, TheID, pmin,

                               - 19 -


                        pmax: Integer; dir: dirtype)
Methoden:               function GetPos: Integer
                        procedure SetPos(ThePos: Integer)
Botschaften:            DLG_SLIDERMOVED
                        DLG_SLIDERRLSD

Ein Slider ist ein Schieberegler,  dessen tatsächliche Ausdehnung
in Pixeln  im Parameter  len angegeben  wird.   Proportional  zur
Position  des Schiebereglers  wird eine  Integergröße  verändert,
deren Grenzen in den Parametern  pmin und pmax definiert  werden.
Für  den  Parameter  dir  ist  zur  Zeit  nur  die Konstante  hor
zugelassen. Später wird es auch vertikale Slider geben.

UserRadioButtons

Konstruktor:    Init(x1, y1, dx, dy, TheId: Integer;
                TheText: LabelStr; nextB:PRadioButton)
Methoden:       function WhosChecked: Integer
                procedure CheckButton(TheID: Integer)
Botschaften:    DLG_RADIO

UserRadioButtons  sind Gruppen von Schaltflächen, von denen immer
nur eine gedrückt  sein kann.  Wird ein UserRadioButton  gesetzt,
wird der zuvor gesetzte  gelöscht.   Das Objekt  UserRadioButtons
trägt  nur  den  Rahmen  und die Beschriftung,  die Schaltflächen
selbst  sind vom Typ UserRadioButton  und müssen einzeln  in Form
eines rekursiven  Aufrufs definiert  werden.  Im Unterschied  zum
RadioButton  besteht  der  UserRadioButton   aus  einer  beliebig
großen, mit einer Grafikikone beschrifteten Schaltfläche.

UserRadioButton
Konstruktor:    Init(x1, y1, TheID: Integer; TheText: LabelStr;
                nextB:PRadioButton)

Ein  RadioButton  ist eine  einzelne  Schaltfläche,  die zu einem
Objekt vom Typ RadioButtons  gehört.  Der Aufruf erfolgt rekursiv
innerhalb des Konstruktors von RadioButtons.

LabelText
Konstruktor:    Init(x1, y1, TheID: Integer; TheText: LabelStr)
Methoden:       procedure SetLabel(TheText: LabelStr)

Ein Labeltext ist ein einfacher  Text innerhalb des Dialoges, der
sich völlig passiv verhält.   Er kann nicht betätigt  werden  und
sendet keine Botschaften.

LabelFrame
Konstruktor:    Init(x1, y1, dx, dy, TheID: integer; TheText: LabelStr)

Ein LabelFrame  ist ein Rahmen mit Beschriftung,  wie er auch für
RadioButtons  verwendet wird.  Mit Hilfe des LabelFrame  kann die
logische   Zusammengehörigkeit    von   Dialogelementen   optisch
dargestellt werden.

FileRequester
Konstruktor:    Init(x,y,lin,TheID: Integer; ThePath, TheMask: String)
Methoden:       Function GetSelected: String
                Function GetPath: String
Botschaften:    DLG_FILEREQ

Der   Filerequester   ist  eine   aus  mehreren   Dialogelementen

                               - 20 -


zusammengesetzte Gruppe zur Ermittlung eines Dateinamens. Jeweils
eine ListBox  wird zur Auswahl  der Datei  und des Verzeichnisses
verwendet.

Die Behandlung von Dialogereignissen

Bei der Verwendung eines Dialoges müssen Sie im Init-Aufruf  eine
Empfangsprozedur  angeben,  die die von den Dialogen  gelieferten
Meldungen bearbeitet.   Dialoge liefern grundsätzlich  Ereignisse
der Klasse DialogEvent  und übergeben im Feld MSG die eigentliche
Botschaft  als  Integerwert,  für  den  entsprechende  Konstanten
definiert   sind.   Das  Feld  ID  enthält   die  ID-Nummer   des
Dialogelemente:   Falls Sie mehrere Dialogelemente  gleichen Typs
verwenden,  müssen Sie anhand der ID-Nummer entscheiden,  welches
Element  der Urheber der Botschaft  ist.  Das Feld DlgAdr enthält
einen Zeiger auf den Dialog,  zu dem die Dialogelemente  gehören.
Über diesen  Zeiger können Sie Methoden  und Felder  des Dialoges
referenzieren.












































                               - 21 -


5 Die Verwendung von Fenstern

Von Fenstern, Viewports und Klienten

Im zweiten Kapitel haben Sie bereits erfahren, daß der Bildschirm
im  Normalfall  in  zwei  Bereiche  aufgeteilt  ist.   Am  oberen
Bildschirmrand  wird ein Streifen  für die Menüs  verwendet,  der
Rest des Bildschirms gehört Ihrem Programm. In vielen Fällen wird
diese Aufteilung ausreichend  sein, aber es gibt Situationen,  in
denen es wünschenswert  ist, daß die verfügbare  Bildschirmfläche
in  weitere  Segmente  aufgeteilt  wird.  Unter  deLite  gibt  es
grundsätzlich zwei Möglichkeiten, den Bildschirm aufzuteilen. Für
das Verständnis  dieser  Möglichkeiten  ist es notwendig,  einige
Begriffe zu klären.

Viewports

Unter  einem  Viewport  versteht  man eine beliebige  rechteckige
Fläche auf dem Bildschirm, die so angesteuert  wird, als wäre sie
ein eigenständiger  Bildschirm.   Das heißt,  daß die linke obere
Ecke eines Viewports  stets die logischen Koordinaten  (0,0) hat,
unabhängig  von der tatsächlichen  Position des Viewports auf dem
Bildschirm.  Graphische Operationen,  die die logische Fläche des
Viewports überschreiten  würden, werden vom System an den Grenzen
des Viewports abgeschnitten.   Diesen Vorgang bezeichnet  man als
Clipping.   Zu einem Zeitpunkt  kann immer nur ein Viewport aktiv
sein.   Es  ist  möglich,  die  Größe  des  Viewports  und  seine
tatsächlichen Eckkoordinaten zu erfragen.

Fenster

Ein Fenster ist eine rechteckige  Fläche auf dem Bildschirm,  die
mit   einem   Rahmen    versehen    ist   und   eine   definierte
Hintergrundfarbe  besitzt.   Beim Öffnen eines Fensters  wird vom
System  automatisch  ein  Viewport  auf  das Innere  des Fensters
gesetzt.  Vorher wird der vom Fenster verdeckte  Bildschirminhalt
gerettet,  um beim Schließen  des Fensters  wieder  rekonstruiert
werden  zu  können.    Fenster  werden  in  einer  Stapelstruktur
verwaltet.    Das  bedeutet,  daß  es  möglich  ist,  über  einem
geöffneten  Fenster  weitere  Fenster  zu öffnen,  ohne das erste
Fenster  zu schließen.   Die Fenster  werden  in der  umgekehrten
Reihenfolge  geschlossen,  daher  der Ausdruck  Stapel.   Nur das
oberste Fenster ist jeweils aktiv, die darunter liegenden Fenster
können nicht beschrieben  werden.  Beim Schließen  eines Fensters
wird das jeweils darunterliegende Fenster aktiviert. Da immer nur
das oberste  Fenster  aktiv  ist,  eignen  sich  Fenster  nur zur
Darstellung  von  temporären  Informationen.   Für die permanente
Aufteilung der Bildschirmfläche sind sie ungeeignet.

Klienten

Zur dauerhaften Aufteilung des Bildschirms  dienen Klienten.  Ein
Klient     besteht     aus    einem     Viewport     und    einer
Botschaften-Empfangsprozedur.    Im  Normalfall  existieren  zwei
Klienten:  Der Menümanager ist ein systeminterner Klient, dem als
Viewport der schmale Streifen am oberen Bildschirmrand zugeordnet
ist,   und   die   Hauptapplikation,   die   mit   der   Prozedur
OpenMainApplication   angemeldet  wurde,  besitzt  die  restliche
Bildschirmfläche.    Eine  wichtige  Einschränkung  unterscheidet
Klienten  von Fenstern:   Es ist nicht möglich, daß die Viewports
der Klienten  sich überlappen.   Jeder Klient besitzt eine eigene

                               - 22 -


Empfangsprozedur  für Botschaften.   Die Prozedur DispatchMessage
verteilt  Mausereignisse  anhang  der  den Klienten  zugeordneten
Viewports.   So ist gewährleistet,  daß die Empfangsprozedur  des
Hauptprogramms  niemals  ein Mausereignis  erhält, das im Bereich
des  Menübalkens  stattgefunden  hat.  Es  ist  möglich,  weitere
Klienten   anzumelden   und  ihnen   Teile   des  Viewports   der
Hauptapplikation  zuzuteilen.  Das Beispielprogramm DXFView macht
von dieser Möglichkeit  Gebrauch  und teilt die Arbeitsfläche  in
vier  kleine  Bereiche  ein, in denen  getrennt  voneinander  die
Möglichkeit  besteht,  Grafiken  zu  betrachten.  Diese  Klienten
bekommen  nur  die Mausereignisse  zugesandt,  die sich  in ihren
Viewports abgespielt  haben.  Das Beispielprogramm  DXFView nutzt
diese Eigenschaft,  um mit der Maus den jeweils  aktiven Klienten
auswählen zu können.  Die zusätzlich angemeldeten Klienten können
wieder abgemeldet  werden.  Allerdings  ist es nicht möglich, die
Hauptapplikation  abzumelden,  ohne das Programm zu beenden.  Das
ist notwendig, da die Empfangsprozedur der Hauptapplikation stets
die Menümeldungen zugesandt bekommt. Da die zusätzlichen Klienten
die Arbeitsfläche der Hauptapplikation  überlagern, gibt es einen
Konflikt  bei der Zuordnung  der Mausereignisse  zu den Klienten:
Die immer  noch aktive  Hauptapplikation  würde  alle  Ereignisse
bekommen,  da ihr Viewport  die gesamte  Arbeitsfläche  einnimmt.
Deshalb  muß  in diesem  Fall  die  Hauptapplikation  suspendiert
werden.  Suspendieren bedeutet, daß der Dispatcher sie nicht mehr
bei der Zuteilung von Mausereignissen berücksichtigt.  Ereignisse
anderer  Klassen  (Menüs,  Tastatur)  werden  nach wie vor an die
Hauptapplikation  gesendet.  Nach der Reaktivierung  empfängt die
Hauptapplikation  wieder  alle  Arten  von  Ereignissen.  Um  die
Klienten  voneinander  zu unterscheiden,  trägt jeder Klient eine
Identifikationsnummer,  die ID.  Die ID der Hauptapplikation kann
mit  der  Prozedur   GetMainID   erfragt  werden,  die  ID's  der
zusätzlich angemeldeten Klienten werden bei der Anmeldung mit der
Prozedur OpenSubApplication  zurückgeliefert.  Die Prozeduren zum
An-  oder  Abmelden  von  Klienten  und  zur  Modifikation  ihrer
Arbeitsweise und ihres Aussehens erfordern alle die Angabe der ID
des jeweiligen Klienten. Im Gegensatz zu Fenstern retten Klienten
nicht  den  von ihrem  Viewport  überlagerten  Bildschirmbereich.
Deshalb muß jeder Klient in der Lage sein, seinen Viewport neu zu
zeichnen,  wenn er die Botschaft  DoRedraw erhält.  Es existieren
Prozeduren,  mit denen einem  Klienten  eine Botschaft  geschickt
werden kann.  In der nächsten  Version von deLite wird es möglich
sein,  einem  Klienten  Streifen  an einem  der  Bildschirmränder
zuzuteilen    und   damit   die   Grösse   des   Viewports    der
Hauptapplikation dynamisch zu reduzieren.  Nach der Neuaufteilung
der  Viewports   unter  den  Klienten  ist  der  Bildschirminhalt
ungültig, er muß neu gezeichnet  werden.  DeLite würde dann jedem
der Klienten ein Redraw senden.

Der Dispatcher

Es wurde bereits erwähnt, daß der Dispatcher  die Verteilung  der
Botschaften  anhand  der  den  Klienten  zugeordneten   Viewports
vornimmt.   Allerdings  gibt es Situationen,  in denen ein Klient
alle Ereignisse zugesandt bekommen möchte. Das ist z.B. der Fall,
wenn ein Menü aufgeklappt wurde und anschließend ein Mausereignis
im Viewport  der Hauptapplikation  stattgefunden  hat.  In diesem
Fall hat der Benutzer  des Programms  seine  Entscheidung,  einen
Menüpunkt auszuwählen, geändert: Das Menü muß geschlossen werden,
bevor das Hauptprogramm seine Arbeit wieder aufnimmt.  Für solche
Situationen besteht die Möglichkeit, die Prozedur DispatchMessage
vorübergehend  außer  Kraft  zu setzen  und die  Zuteilung  aller

                               - 23 -


Ereignisse  zu verlangen.  Die Prozeduren  ReceiveExclusive  bzw.
ContinueToDispatch   steuern  diesen  Mechanismus.Der  Empfänger
einer Botschaft kann davon ausgehen, daß sein Viewport aktiv ist.
Seine   Zeichenoperationen   würden   also   in  seinem   eigenen
Bildschirmsegment   stattfinden.    Es  besteht  allerdings   die
Möglichkeit,  den Viewport eines anderen Klienten zu erfragen und
zu setzen. Die dazugehörigen Prozeduren heißen SetTheViewPort und
GetTheViewPort  und erfordern  die Angabe  der ID des betroffenen
Viewports.

Die Benutzung von Fenstern

Fenster  können geöffnet,  benutzt und wieder geschlossen  werden
und besitzen  einen Rahmen  und eine in der Initialisierungsdatei
definierte Farbe. Sie retten selbständig den von ihnen verdeckten
Bildschirminhalt   und  rekonstruieren  ihn  nach  dem  Schließen
wieder.   Da dabei zum Teil recht beachtliche  Mengen an Speicher
umgeschichtet   werden   müssen,   verwendet   eine  intelligente
Speicherverwaltung  bei Bedarf EMS-Speicher  und lagert Teile auf
Festplatte  aus.  Beim Öffnen eines Fensters muß dessen Größe und
Position in Pixeln angegeben  werden.  Möchte man ein Fenster zur
Ausgabe  von  Text  verwenden  und dabei  den Standardzeichensatz
benutzen,   ist  es  notwendig,   die  Größe  eines  Fensters  in
Abhängigkeit   von   der  Grösse   der  Zeichen   des  jeweiligen
Zeichensatzes  zu  dimensionieren.  Da  die  deLite-Grafiktreiber
unterschiedliche Zeichensätze für jede Grafikkarte verwenden, muß
diese Information  zur Laufzeit  erfragt werden.  Zu diesem Zweck
existieren  eine  Reihe  von  Funktionen,   mit  denen  man  alle
wichtigen Parameter erfragen kann. Mit Hilfe der Funktionen FontX
und FontY  kann  die Größe  eines  Zeichens  in Pixeln  ermittelt
werden.  Die Funktionen  PortMaxX  und PortMaxY liefern die Größe
des  zu dem  Fenster  gehörenden  Viewports  und  können  benutzt
werden,  um  graphische   Ausgaben  an  die  Größe  des  Fensters
anzupassen.     Ein   Beispiel   zeigt   die   Anwendung   dieser
Möglichkeiten. Das Programmfragment öffnet ein Fenster, das Platz
für 10 Textzeilen  mit 40 Spalten bietet, schreibt  mit Hilfe der
Prozedur  WriteWin  einen Text in die oberste  Zeile und zeichnet
Linien in die Diagonalen des Fensters.

        Procedure Demo;
        Begin
          OpenWindow(25,25,25+40*FontX,25+10*FontY);
          WriteWin('Guten Tag',0,0,0);
          Line(0,0,PortMaxX,PortMaxY,0);
          Line(0,PortMaxY,PortMaxX,0,0);
          WaitConfirm; { Warten auf eine Bestätigung }
          CloseWindow;
        End;

Nach  dem Schließen  des Fensters  mit CloseWindow  ist der zuvor
verwendete  Viewport  wieder aktiv.  Es ist wichtig,  daß vor dem
Befehl zum Schließen  des Fensters ein WaitConfirm  steht.  Diese
Prozedur zieht alle Ereignisse an sich und endet, sobald eine der
Maustasten gedrückt wurde oder ESCAPE bzw.  ENTER betätigt wurde.
So werden alle Ereignisse geschluckt,  und es ist sichergestellt,
daß kein Klient zwischenzeitlich aktiv wird.  Während ein Fenster
offen ist, kann auf diese Weise kein anderer  Programmteil  tätig
werden.

Dialogfenster


                               - 24 -


Noch  eleganter  ist  es,  für  diese  Aufgabe  einen  Dialog  zu
verwenden,  der  einen  einzigen  Schaltknopf  zum Schließen  des
Dialogfensters     beinhaltet.     Die     dazu     erforderliche
Botschaftenempfangsprozedur  ist in deLite bereits enthalten  und
trägt den Namen DefEventproc. Sie wertet nur die beiden Meldungen
DLG_OK und DLG_CANCEL  aus und schließt beim Empfang einer dieser
Meldungen den Dialog. Nach der Darstellung des Dialoges mit Hilfe
der Methode Show haben Sie Gelegenheit,  selbst das Dialogfenster
zu   beschreiben.     Anschließend    wird   mit   DoDialog   die
Ereignisabarbeitung begonnen.

        procedure Demo2;
        var MyDialog : Dialog;
            MyButton : PButton;
        begin
          MyDialog.Init(40*FontX, 12*FontY, 0, DefEventProc);
          MyDialog.Move(25, 25);

          new(MyButton, Init(2*FontX, 9*FontY, 36*FontX, 2*FontY, 100, 'OK'));
          MyDialog.AddItem(MyButton);
          MyButton^.MakeDefaultItem;

          MyDialog.Show;
          WriteWin('Guten Tag', 1, 1, black);
          Line(0,0, PortMaxX,  PortMaxY-4*FontY, black);
          Line(PortMaxX, 0, 0, PortMaxY-4*FontY, black);

          MyDialog.DoDialog;
          MyDialog.Done;
        end;

Die Anmeldung weiterer Klienten

In einem Beispiel  werden wir zeigen, wie der Bildschirm  in vier
gleichgroße Segmente aufgeteilt wird.  Die Hauptapplikation  wird
zu diesem Zweck suspendiert.

        Procedure VierFenster;
        Var ThePort: ViewPortType;
            XSize  : integer;
            YSize  : integer;
            XOrg   : integer;
            YOrg   : integer;
            XEnd   : integer;
            YEnd   : integer;
            Msg    : EventTyp;
        begin
          ClearViewPort;                   { Fenster löschen }
          GetViewSettings(ThePort);
          With ThePort Do
            begin
              XSize := (x2-x1) div 2 - 2;  { Ausdehnung in x-Richtung }
              YSize := (y2-y1) div 2 - 4;  { dito in y-Richtung }
              XOrg  := x1;
              YOrg  := y1 + 3;
              XEND  := x2;
              YEnd  := y2;
            end;

          ID1 := OpenSubApplication(Fenster1,0,'Fenster 1',
                                    XOrg,YOrg,Xorg+XSize,YOrg+YSize);

                               - 25 -



          ID2 := OpenSubApplication(Fenster2,0,'Fenster 2',
                                    XEND-XSize,YOrg,XEND,YOrg+YSize);

          ID3 := OpenSubApplication(Fenster3,0,'Fenster 3',
                                    XOrg,YEnd-YSize,Xorg+XSize,YEnd);

          ID4 := OpenSubApplication(Fenster4,0,'Fenster 4',
                                    XEnd-XSize,YEnd-YSize,XEnd,YEnd);

          SuspendApplication(MyID);    { Hauptfenster deaktivieren }

          MSG.Class := DoRedraw;

          PostMessage(MSG, ID1);       { alle Fenster neu zeichnen }
          PostMessage(MSG, ID2);
          PostMessage(MSG, ID3);
          PostMessage(MSG, ID4);
        end;

Beachten   Sie,  daß  die  von  der  Prozedur  OpenSubApplication
zurückgelieferten  IDs  gespeichert  werden,  da sie später  noch
benötigt  werden.  Die Prozedur PostMessage  dient dazu, den vier
neuen  Klienten  eine  Botschaft  vom  Typ  DoRedraw  zu  senden.
Daraufhin zeichnen die Klienten in ihren Viewport eine Grafik.

Nicht-modale Dialoge

Im Gegensatz  zu den  modalen  Dialogen  hält  ein  nicht-modaler
Dialog die Ausführung  der anderen  Teile eines Programmes  nicht
an.   Findet  innerhalb  seines  Viewports  ein  Ereignis  statt,
arbeitet  er  es wie  jeder  andere  Dialog  ab,  finden  dagegen
Ereignisse  über den Viewports anderer Klienten statt, übernehmen
diese  deren  Bearbeitung.   Damit ist klar, wie ein nichtmodaler
Dialog  zu realisieren  ist und warum wir seine  Erstellung  erst
jetzt  beschreiben:    Ein  nichtmodaler   Dialog  erfordert  die
Kombination  eines Klienten  mit einem Dialog.  Wir haben bereits
erwähnt, daß es unter deLite nicht möglich ist, Klienten mit sich
überlappenden Viewports zu verwalten.  Trotzdem gibt es sinnvolle
Anwendungen für nichtmodale Dialoge.  Das Beispielprogramm  teilt
die Bildschirmfläche in zwei Bereiche auf. Neben der eigentlichen
Arbeitsfläche  befindet  sich  am rechten  Bildrand  ein schmaler
Streifen,  auf dem vier Schaltflächen  installiert  werden.  Dazu
verwenden   wir   das   Dialogelement   UserRadioButtons-    jede
Schaltfläche  soll  hier  für  eine  Betriebsart  des  Programmes
stehen, es kann also stets nur eine Schaltlfläche  gedrückt sein.
Bei  einem  modalen  Dialog  hätte  man nach  der Definition  der
Dialogelemente die Methode DoDialog aufgerufen.  Da DoDialog eine
eigene GetEvent/DispatchMessage-Schleife  besitzt, lässt es keine
anderen  Klienten  mehr  zum Zuge  kommen.   Für die nichtmodalen
Dialoge  wird deshalb anstelle  eines Aufrufs  von DoDIalog  eine
Empfangsprozedur  dem Dispatcher  bekanntgemacht,  die ihrerseits
die Empfangsprozedur des Objektes Dialog aufruft.

        Program exampl01;
        Uses API, Kernel;

        CONST ProjektName  = 'exampl01';

        VAR   LaunchResult      : integer;
              MyEvent           : EventTyp;

                               - 26 -


              StillRunning      : boolean;
              WorkID,
              IconBarID         : integer;                   { 2 Klienten }
              IconBar           : Dialog;
              MyID              : integer;
              PrintColor        : byte;  { Bestückungsdruck }


        Procedure HandleMsg(MyMessage: EventTyp); far;
        var xx,yy : integer;
        { Hier werden die Botschaften behandelt. }
        Begin
          With MyMessage Do
            Case Class Of
              Menu    : begin
                          Case x of
                             0       : StillRunning := false;
                          end;
                        end;
            end; { Case Class }
        End;

        procedure IconBarEventHandler(TheEvent: EventTyp); far;
        begin
          With TheEvent Do
            If Class = DialogEvent then
              begin

              end;
        end;

        procedure IconBarClient(TheEvent: EventTyp); far;
        begin
          IconBar.HandleEvent(TheEvent);    { Der Client leitet nur weiter }
        end;


        Procedure IconBarAn;
        Var ThePort: ViewPortType;
            XSize  : integer;
            YSize  : integer;
            XOrg   : integer;
            YOrg   : integer;
            XEnd   : integer;
            YEnd   : integer;
            Msg    : EventTyp;
            MyUserRadios: PUserRadios;
        begin
          ClearViewPort;                       { Fenster löschen }
          GetViewSettings(ThePort);
          With ThePort Do
            begin
              XSize := x2-x1;
              YSize := y2-y1;
              XOrg  := x1;
              YOrg  := y1;
              XEND  := x2;
              YEnd  := y1+ySize;
            end;

          IconBar.Init(50,ysize, 0, IconBarEventHandler);

                               - 27 -


          IconBar.Move(xend-50,0);
          new(MyUserRadios, Init(0,0,50,ysize,411,
                new(PUserRadio, Init(0,0,48,48,39,39,412,nil,
                 new(PUserRadio, Init(0,50,48,48,39,39,413,nil,
                  new(PUserRadio, Init(0,100,48,48,39,39,414,nil,
                   new(PUserRadio, Init(0,150,48,48,39,39,415,
                                    nil,nil))))))))));
          IconBar.AddItem(MyUserRadios);
          MyUserRadios^.CheckButton(412);

          IconBarID:= OpenSubApplication(IconBarClient, 0, 'Iconbar',
                             xend-50,yorg,xend,yorg+ysize);
          SetTheViewPort(IconBarID);
          IconBar.Show;

          WorkID   := OpenSubApplication(HandleMsg,APP_NOFRAME,'Editor',
                             XOrg,YOrg,XEND-51,Yend);


          SuspendApplication(MyID);           { Hauptfenster deaktivieren }

        end;

        Begin
          StillRunning := true;
          LaunchResult := OpenMainApplication(HandleMsg,
                                               APP_NOFONT,
                                               ProjektName);

          If LaunchResult = 0 then
          begin
            MyId := GetMainID;
            IconBarAn;
            while StillRunning Do
              begin
                GetEvent(MyEvent);
                DispatchMessage(MyEvent);
              end;
            IconBar.Done;
            CloseMainApplication;
          end
          Else
            Writeln('Programm kann nicht gestartet werden. Fehler: ',
                     LaunchResult);
        End.

Beachten Sie, daß vor dem Aufruf von CloseMainApplication am Ende
des Programmes  der Destruktor  IconBar.Done  aufgerufen wird, um
den Speicherplatz  des Dialoges  freizugeben.   Sie finden dieses
Beispiel auch auf Ihrem Diskettensatz.












                               - 28 -


6 Die graphischen Operationen

Die von deLite zur Verfügung gestellten  graphischen  Operationen
umfassen   neben   bitorientierten    Funktionen   zum   Zeichnen
elementarer  Symbole auch Funktionen zum Zeichnen und Verschieben
von Bitmaps.   Neben einem Zeichensatz  fester  Größe unterstützt
deLite auch skalierbare  Zeichensätze,  die ohne Qualitätsverlust
nahezu  beliebig  vergrößert  werden können.   Für alle in diesem
Abschnitt  beschriebenen  Operationen  gilt, daß sie sich auf den
aktuell gesetzten Viewport beziehen.  Alle Operationen  verwenden
einen   Clipping-Algorithmus,   der   sicherstellt,   daß   keine
Bildschirmbereiche  außerhalb  des aktiven Viewports  beschrieben
werden.

Elementare Zeichenoperationen

Die   elementaren   Zeichenoperationen    dienen   dem   Zeichnen
sogenannter  graphischer  Primitive.  Durch Kombination  mehrerer
Primitive können komplexere Grafiken erstellt werden.

Setzen eines Pixels

Die  Prozedur  SetPoint  setzt  ein  einzelnes   Pixel  in  einer
beliebigen Farbe.

        Procedure SetPoint(x,y: Integer; color: Byte)

Zeichnen einer Linie

Die Prozedur Line zeichnet eine Linie zwischen zwei Punkten.

        Procedure Line(x1,y1,x2,y2: Integer; color: Byte)

Zeichnen eines Rechtecks

Die Prozedur Rectangle zeichnet ein nicht ausgefülltes Rechteck.

        Procedure Rectangle(x1,y1,x2,y2: Integer; color: Byte)

Zeichnen einer rechteckigen Fläche

Die Prozedur Bar zeichnet eine ausgefüllte rechteckige Fläche.

        Procedure Bar(x1,y1,x2,y2: Integer; color: Byte)

Zeichnen eines Kreises

Die Prozedur Circle zeichnet  einen Kreis.  Anzugeben  sind neben
der Farbe die Koordinaten des Mittelpunktes und der Radius.

        Procedure Circle(mx,my,radiud: Integer; color: Byte)

Zeichnen eines Kreissegmentes

Die Prozedur Arc zeichnet ein Kreissegment.  Anzugeben sind neben
der Farbe die Koordinaten des Mittelpunktes  und der Anfangs- und
Endwinkel des Kreissegmentes.

        Procedure Arc(mx,my,phia,phib,radius: Integer; color: Byte)

Verändern des Linienstils

                               - 29 -



Mit Hilfe der Prozeduren SetLinePattern bzw.  GetLinePattern kann
das Linienmuster gesetzt bzw.  ermittelt werden.  Die Vorbelegung
des Linienmusters ist die durchgezogene Linie SolidLn.

        Procedure SetLinePattern(Pattern: Word)
        Function GetLinePattern:Word

Der Grafikcursor

DeLite definiert einen Grafikcursor, der die Position der jeweils
nächsten Ausgabe bestimmt.  Der Grafikcursor bleibt immer auf dem
Punkt der letzten  Ausgabe stehen und wird bei der Überschreitung
von Fenstergrenzen  nicht beeinflusst.  Folgende Befehle arbeiten
mit dem Grafikcursor bzw.  beeinflussen dessen Position:

        Function GetX :  Integer
        Function GetY :  Integer
        Procedure LineRel(X,Y  : Integer)
        Procedure LineTo(X,Y :  Integer)
        Procedure MoveRel(X,Y : Integer)
        Procedure MoveTo(X,Y :  Integer)
        Procedure OutText(Str : String)
        Procedure OutTextXY(X,Y : Integer; Str : String)

Alle  Prozeduren,  die mit dem Grafikcursor  arbeiten,  verwenden
eine vorher zu setzende Zeichenfarbe.   Die Zeichenfarbe kann mit
der Prozedur SetColor gesetzt werden.

        Procedure SetColor(Color : Byte)

Der Standard-Zeichensatz

Der Standard-Zeichensatz  wird von deLite  für Menüs  und Dialoge
verwendet.    Seine  Auflösung  richtet  sich  nach  dem  jeweils
verwendeten Grafiktreiber  und beträgt für VGA-Karten 8x16 Pixel.
Die Kopplung  des Zeichensatzes  an den Grafiktreiber  bietet den
Vorteil,  daß die Zeichen  auch bei hochauflösenden  Grafikkarten
lesbar  bleiben.   Damit  sich  Ihr  Programm   unterschiedlichen
Zeichengrößen anpassen kann, stehen Funktionen zur Verfügung, die
Ihnen Informationen  über die Größe des verwendeten Zeichensatzes
geben.  Ausgabe  eines Textes im Standardzeichensatz  Zur Ausgabe
eines  Textes  stehen   zwei  Prozeduren   zur  Verfügung.    Sie
unterscheiden sich in der Art der Angabe der Position, an der der
Text  auszugeben  ist.   Während  die  Prozedur  OutTextAPI   die
Koordinaten  in Pixeln erwartet, müssen bei der Prozedur WriteWin
die gewünschte Zeile und Spalte angegeben werden.

        Procedure OutTextAPI(x,y: Integer; InString: String; color,
                             attrib: Byte)
        Procedure WriteWin(str: string; x,y: integer; color: Byte)

Ermittlung der Größe eines Zeichens

Die Funktionen GetFontX und GetFontY liefern die Ausdehnung eines
Zeichens  in Pixeln  zurück.   In Verbindung  mit  der Länge  des
auszugebenden  Textes  können  diese  Funktionen  dazu  verwendet
werden,  die  von einem  Text  eingenommene  Bildschirmfläche  zu
berechnen.  Auf  diese  Weise  kann  die  benötigte  Größe  eines
Fensters zur Textausgabe berechnet werden oder ein Text innerhalb
eines Fensters zentriert werden.

                               - 30 -



        Function GetFontX: Byte
        Function GetFontY: Byte

Der skalierbare Zeichensatz

Der skalierbare  Zeichensatz  wird beim Start  Ihrer  Applikation
eingeladen, kostet also zusätzlichen Speicherplatz. Sie haben die
Wahl zwischen vier verschiedenen Zeichensätzen  und müssen in der
Initialisierungsdatei  angeben, welchen Zeichensatz Sie verwenden
möchten.  Zur  Zeit  stehen  die  Zeichensätze  SIMPLEX,  DUPLEX,
TRIPLEX  und GOTHIC zur Verfügung,  weitere Zeichensätze  sind in
Vorbereitung.   Falls   Sie   keinen   skalierbaren   Zeichensatz
benötigen,  sollten  Sie beim Aufruf von OpenMainApplication  als
modus die Konstante  APP_NOFONT  übergeben.   In diesem Fall wird
kein  Zeichensatz  eingeladen,   und  Sie  sparen  Speicherplatz.
Sollten  Sie  trotzdem   versuchen,   die  Prozedur  zur  Ausgabe
skalierbarer  Texte  zu verwenden,  wird  Ihr Programm  mit einem
Laufzeitfehler  abbrechen.   Die Prozedur DrawText zeichnet einen
Text unter Verwendung des skalierbaren Zeichensatzes.

        Procedure DrawText(x0,y0,fakx,faky: Integer;
                           var str: string; color: Byte)

Die Parameter  FakX und FakY erlauben die unabhängige  Skalierung
der Zeichen in beiden Koordinatenachsen.

Zeichenrichtung und Textstyles

Durch  die neuen Prozeduren  OutText  und OutTextXY  ist es jetzt
möglich, den skalierbaren  Zeichensatz nicht nur in horizontaler,
sondern auch in vertikaler  Richtung,  sowie in unterschiedlichen
Ausrichtungen auszugeben.

Weitere Funktionen

Neben  diesen  allgemein  verwendbaren   graphischen  Operationen
stellt  der deLite-Kernel  noch einige sehr spezielle  Funktionen
zur  Verfügung,  die  in erster  Linie  vom  deLite-API  benötigt
werden. Diese meisten dieser Funktionen werden Sie nur benötigen,
wenn Sie den Leistungsumfang des API erweitern möchten.

Zeichnen von Ikonen

Ikonen sind vordefinierte  Bitmaps, die graphische  Informationen
enthalten. Dabei unterscheidet deLite zwei verschiedene Arten von
Ikonen.  Systemikonen sind innerhalb des Grafiktreibers definiert
und  enthalten  die  vom  API  benötigten  Symbole.  Dazu  zählen
beispielsweise  die  stilisierten  Pfeile,  die  innerhalb  eines
Listendialoges    die   Schaltflächen    zum   Verschieben    der
Auswahlmarkierung   kennzeichnen.    Mit   Hilfe   der   Prozedur
DrawSysIcon können solche Ikonen zur Anzeige gebracht werden.

        Procedure DrawSysIcon(ScrX,ScrY: Integer; Nr, Attrib: Byte)

Sie benötigen Systemikonen nur, wenn Sie den Leistungsumfang  des
API erweitern  möchten.   Es ist nicht  möglich,  von Pascal  aus
weitere Systemikonen zu definieren.  Im Gegensatz dazu stehen die
anwenderdefinierten Ikonen zu Ihrer Verfügung. Anwenderdefinierte
Ikonen  können  mit Hilfe der Prozedur  DrawNormIcon  zur Anzeige
gebracht werden.

                               - 31 -



        Procedure DrawNormIcon(ScrX,ScrY: Integer; Dx,Dy: Integer;
        Typ, Color: Byte; Storage: Pointer)

Ein Beispiel  soll zeigen,  wie Sie eigene Ikonen in Ihr Programm
aufnehmen können.  Die Beispielprozedur öffnet ein Fenster in der
Mitte   des  Bildschirmes   und  zeichnet   darin  das  Logo  der
Technischen Universität Berlin.  Das Fenster verschwindet wieder,
nachdem es duch WaitConfirm bestätigt wurde.

        Type  IcoArray = Record
                           DeltaX : Integer;
                           DeltaY : Integer;
                           IcoArr : Array[0..199] of Byte;
                         End;

        Const TuB : IcoArray = (DeltaX : 39; DeltaY : 39; { Das TU Logo }
        IcoArr : $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,
                 $00,$00,$00,$00,$00,$1f,$ff,$ff,$e0,$00,$3f,$ff,$ff,$f1,$ff,
                 $7f,$ff,$ff,$f9,$f9,$7f,$ff,$ff,$f9,$f7,$7f,$ff,$ff,$f9,$f1,
                 $3f,$ff,$ff,$f9,$ff,$1f,$ff,$ff,$f9,$d1,$00,$00,$0f,$f9,$ff,
                 $00,$7f,$8f,$f3,$82,$00,$7f,$8f,$f3,$fe,$00,$7f,$8f,$f3,$ee,
                 $00,$7f,$8f,$f3,$e2,$00,$7f,$8f,$f3,$fe,$00,$7f,$8f,$f3,$ce,
                 $00,$7f,$8f,$f3,$d6,$00,$ff,$9f,$f3,$c6,$00,$ff,$1f,$e7,$fc,
                 $00,$ff,$1f,$e7,$e4,$00,$ff,$1f,$e7,$d4,$00,$ff,$1f,$e7,$04,
                 $00,$ff,$1f,$e7,$fc,$00,$ff,$1f,$e7,$fc,$00,$ff,$1f,$e7,$fc,
                 $01,$ff,$1f,$e7,$fc,$01,$fe,$3f,$e7,$fc,$01,$fe,$3f,$cf,$fc,
                 $01,$fe,$3f,$cf,$f8,$01,$fe,$3f,$cf,$f8,$01,$fe,$3f,$cf,$f8,
                 $01,$fe,$3f,$cf,$f0,$01,$fe,$1f,$cf,$f0,$01,$fe,$0f,$cf,$e0,
                 $00,$00,$07,$cf,$c0,$00,$00,$03,$cf,$00,$00,$00,$00,$00,$00,
                 $00,$00,$00,$00,$00));

        Procedure ZeigeTuBLogo;
        Begin
          OpenWindow((GetMaxX+1) div 2,(GetMaxY+1) div 2,
                     (GetMaxX+1) div 2 +50,(GetMaxX+1) div 2 + 50);
          DrawNormIcon(5,5,TuB.DeltaX,TuB.DeltaY,1,0,@Tub40.IcoArr);
          WaitConfirm;
          CloseWindow;
        End;






















                               - 32 -


7 Die Initialisierungsdatei

Die Initialisierungsdatei enthält Informationen zur Konfiguration
Ihrer   Applikation   und   wird   beim   Start   des   Programms
interpretiert.   So kann Ihre Applikation  bequem vom Anwender an
unterschiedliche  Umgebungen  angepaßt werden, ohne neu übersetzt
werden zu müssen. DeLite entnimmt der Initialisierungsdatei unter
anderem die Information,  welcher Grafiktreiber  zu verwenden ist
und   wo  er  sich   befindet.    Ein   komfortabler   Satz   von
Zugriffsprozeduren  erlaubt  es Ihnen,  der Initialisierungsdatei
weitere  Informationen  hinzuzufügen  und  von Ihrer  Applikation
einlesen  zu lassen.   Die Initialisierungsdatei  trägt den Namen
Ihrer Applikation,  gefolgt  von der Endung  '.INI'.   Sie ist im
ASCII-Format   abgelegt   und  kann   daher   leicht   mit  einem
gewöhnlichen Editor modifiziert werden. Sie können den Editor von
Turbo-Pascal dafür verwenden.

Aufbau der Initialisierungsdatei

Die  Initialisierungsdatei  ist  in  Abschnitte  gegliedert,  die
jeweils durch einen Blockbezeichner  voneinander  getrennt  sind.
Der  Blockbezeichner  muß  in  eckige  Klammern  eingefaßt  sein.
Innerhalb der Abschnitte werden Schlüsselwörter  definiert, denen
ohne  Leerschritte   ein  Gleichheitszeichen   folgen  muß.   Dem
Gleichheitszeichen  folgt  der diesem  Schlüsselwort  zugewiesene
Parameter.  Ein Semikolon kennzeichnet einen Kommentar.  Der Rest
der Zeile hinter  einem Semikolon  wird nicht mehr interpretiert.
Steht das Semikolon  am Beginn  einer Zeile,  so wird die gesamte
Zeile ignoriert. Die vom Kernel gestellten Zugriffsprozeduren auf
die   Initialisierungsdatei    unterscheiden    weder   bei   den
Abschnittsbezeichnern,  noch  bei  den Schlüsselwörtern  zwischen
Groß-     und    Kleinschreibung.      Die    Erweiterung     der
Initialisierungsdatei  um eigene  Abschnitte  und Schlüsselwörter
unterliegt keinen Einschränkungen. Sie dürfen auch den vom System
verwendeten Abschnitten weitere Schlüsselwörter  hinzufügen.  Der
folgende  Ausschnitt  einer  Initialisierungsdatei  soll  für die
Beschreibung der weiteren Abschnitte als Beispiel dienen:

        ;Beispiel einer Initialisierungsdatei

        [paths]
        VDIDir=C:\TURBO\DELITE\DRIVER           ;Verzeichnis der Treiber
        FontDir=C:\TURBO\DELITE                 ;Verzeichnis der Zeichensätze

        [hardware]
        Video=VGA                               ;Wählt den Grafiktreiber aus
        Font=Simplex                            ;Der skalierbare Zeichensatz

        [Farbtabelle]
        ;       Name    Farbe   Linientyp
        LAYER=  0       15      CONTINUOUS
        LAYER=  1       2       CONTINUOUS
        LAYER=  2       3       CONTINUOUS
        LAYER=  3       15      CONTINUOUS
        LAYER=  4       5       CONTINUOUS
        LAYER=  5       6       CONTINUOUS
        LAYER=  6       14      CONTINUOUS
        LAYER=  7       7       CONTINUOUS

        [User]
        WelcomeText="Hallo Frank, schön dich zu sehen"  ;ein String

                               - 33 -


        MaxOpenFiles=10                                 ;ein LongInt


Systemabschnitte

Einige Abschnitte  und Schlüsselwörter  der Initialisierungsdatei
werden vom System selbst zur Konfiguration verwendet. Während die
meisten der Einträge  auch fehlen dürfen und in diesem Fall durch
sinnvolle Voreinstellungen ersetzt werden, ist es zum Starten der
deLite-Applikation   zwingend  erforderlich,  daß  der  Abschnitt
[hardware]  vorhanden  ist.   In ihm muß das Schlüsselwort  Video
enthalten   sein,   das   den   zu   verwendenden   Grafiktreiber
spezifiziert.   Beachten  Sie, daß die Endung  '.VDI'  nicht  mit
angegeben  werden darf.  Wird im Abschnitt  [paths] mit Hilfe des
Schlüsselwortes  VDIDir kein anderer Pfad definiert, sucht deLite
den  Grafiktreiber   im  aktuellen   Verzeichnis.    Falls   Ihre
deLite-Applikation einen skalierbaren Zeichensatz benutzt, so muß
dieser  im Abschnitt  [hardware]  hinter  dem Schlüsselwort  Font
angegeben werden.  Wie bei den Grafiktreibern ist es auch für die
Zeichensätze  möglich,  im Abschnitt  [paths] ein anderes als das
aktuelle  Verzeichnis  anzugeben.   Der Pfad wird dazu hinter dem
Schlüsselwort  FontDir  eingetragen.   Das System sucht weiterhin
nach  dem  Abschnitt  [colors],  der  die vom System  verwendeten
Farben  definiert.   Fehlt dieser  Abschnitt,  werden  vom System
geeignete Voreinstellungen verwendet.  Die Speicherverwaltung von
deLite    ist    ebenfalls    über    die   Initialisierungsdatei
konfigurierbar.   Im Abschnitt  [memory]  kann definiert  werden,
unter welchen Randbedingungen  anstelle des Heap-Speichers andere
Speichermedien verwendet werden sollen. Eine Auflistung aller vom
System  verwendeten  Abschnitte  und Schlüsselwörter  sowie deren
Voreinstellungen findet sich im Anhang A wieder.

Datentypen der Initialisierungsdatei

Für die dem Schlüsselwort  folgenden Parameter stellt deLite drei
Datentypen zur Verfügung. Zu jedem Datentyp existiert eine eigene
Zugriffsprozedur.

Der Name

Namen sind Zeichenketten, die ein einzelnes Wort darstellen.  Der
Name darf keine Leerzeichen  oder Tabulatoren  enthalten.  In der
deLite Terminologie  wird der Name auch als ungeschützter  String
bezeichnet.  Die Länge eines Namens ist auf 255 Zeichen begrenzt.
In der Beispieldatei findet sich die folgende Namensdefinition:

        VDIDir=C:\DELITE\DRIVER


Der  geschützte String

Strings sind Zeichenketten, die auch Leerschritte und Tabulatoren
enthalten dürfen.  Sie sind in doppelte Hochkommas eingerahmt und
dürfen  selbst kein doppeltes  Hochkomma  enthalten.   Die deLite
Terminologie verwendet dafür den Begriff geschützter String.  Die
Beispieldatei enthält die Stringdefinition:

        WelcomeText="Hallo Frank, schön Dich zu sehen."


Der LongInt

                               - 34 -



Der  LongInt  ist  ein ganzzahliger,  numerischer  Wert.   Er ist
identisch zum gleichnamigen Turbo Pascal Typ und umfaßt damit den
Wertebereich von -2147483648 bis 2147483647. Unsere Beispieldatei
verwendet die LongInt Definition:

        MaxFiles=10



Listen in der Initialisierungsdatei

Die  bisher  behandelten  Einträge  in der  Initialisierungsdatei
dienten  jeweils  der Spezifikation  eines einzelnen  Parameters.
Darüber  hinaus  bietet  deLite die Möglichkeit,  beliebig  viele
Parameter gleichen Typs in Form einer Liste zu spezifizieren. Zur
Definition  einer Liste ist das gleiche  Schlüsselwort  innerhalb
eines Abschnittes  mehrmals hintereinander  zu verwenden.   Jedes
Auftreten dieses Schlüsselwortes  definiert jeweils einen Eintrag
in der Liste.   Zudem  darf jeder  Eintrag  in der Liste  mehrere
Parameter  enthalten,  die auch unterschiedlichen  Datentyps sein
dürfen.  Dementsprechend  stellt deLite Prozeduren zur Verfügung,
mit  denen  auf  die  einzelnen  Elemente  eines  Listeneintrages
zugegriffen  werden kann.  Die Beispieldatei  definiert unter dem
Abschnitt  [Farbtabelle]  eine  Liste  mit  acht  Einträgen,  die
jeweils  drei  Parameter  enthalten.   Die  Parameter  sind  duch
Leerzeichen oder Tabulatoren voneinander getrennt.

Benutzung der Initialisierungsdatei

Zur  Benutzung  der  Initialisierungsdatei  stehen  dem  Anwender
insgesamt drei Funktionen zur Verfügung.  Zwei weitere Funktionen
erlauben  den Umgang mit Listen und werden im nächsten  Abschnitt
beschrieben. Die Zugriffsprozeduren für die Initialisierungsdatei
sind   alle  als  boolsche   Funktionen   deklariert.    Ist  das
Funktionsergebnis TRUE, so war die Zugriffsaktion erfolgreich und
der   gesuchte    Parameter    befindet    sich    in   der   als
Variablenparameter übergebenen Variable.  Bei nicht erfolgreichem
Zugriff  auf die Initialisierungsdatei  ist das Funktionsergebnis
FALSE.  In diesem Fall kann eine genauere Analyse des Fehlers mit
der Funktion KernelError erfolgen. Sie liefert ein Byte, das eine
Fehlernummer  enthält.  Die  Deklaration  kann  dem  Referenzteil
entnommen  werden.   Im Anhang  B befindet  sich eine Liste aller
deLite Fehlernummern. Die Fehlernummern des Kernel reihen sich in
diese Liste ein.

Zugriff auf Namen

Für   den  Zugriff   auf  Namen   ist  im  Kernel   die  Funktion
GetInitFileName deklariert:

        Function GetInitFileName(Block: BlockIDString; KeyWord: KeyString;
        Var OutVal: ValueString):Boolean;

Sie    sucht    in    der    Initialisierungsdatei    nach    dem
Abschnittsbezeicher Block und dem Schlüsselwort KeyWord.  War der
Zugriff  erfolgreich,   befindet   sich  der  dem  Schhlüsselwort
folgende  Name in der als OutVal übergebenen  Variable.   Mit der
schon bekannten Beispieldatei  und dem folgenden Programmfragment
läßt sich der zu verwendende skalierbare Zeichensatz erfragen:


                               - 35 -


        Procedure WriteFontName;
        Var TheFontName : String;
        Begin
          If GetInitFileName('hardware','Font',TheFontName) Then
            Begin
              OpenWindow(0,0,GetFontX*50,GetFontY*4)
              WriteWin('Der verwendete Font heißt:',0,1);
              WriteWin(TheFontName,0,2);
              WaitConfirm;
              CloseWindow
          Else
            ErrWindow(0,0,'Der Font wurde nicht spezifiziert');
        End

Zugriff auf geschützte Strings

Die Funktion  für den Zugriff auf geschützte  Strings ist der für
den Zugriff auf Namen sehr ähnlich.  Beachten Sie allerdings, daß
die   doppelten   Hochkommas   des  geschützten   Strings   nicht
Bestandteil der in Outval übergebenen Zeichenkette sind:

        Function GetInitFileString(Block: BlockIDString; KeyWord: KeyString;
        Var OutVal: ValueString):Boolean;


        Procedure WriteWelcomeText;
        Var WelcomeText : String;
        Begin
          If GetInitFileString('User','WelcomeText',WelcomeText) Then
            Begin
              OpenWindow(0,0,GetFontX*Length(WelcomeText),GetFontY*3);
              WriteWin(WelcomeText,0,1);
              WaitConfirm;
              CloseWindow;
            End
          Else
            ErrWindow(0,0,'WelcomeText wurde nicht spezifiziert');
        End;


Zugriff auf LongInts

Die Funktion für den Zugriff auf LongInts  folgt in der Logik den
beiden    vorangegangenen.    Auch    sie    sucht    nach    dem
Abschnittsbezeichner Block und dem Schlüsselwort KeyWord.  Der in
OutVal übergebene Parameter allerdings ist ein LongInt, wie er in
Turbo Pascal deklariert  wird.  Das folgende  Beispiel  zeigt die
Verwendung von GetInitFileInteger:

        Function GetInitFileName(Block: BlockIDString; KeyWord: KeyString;
        Var OutVal: ValueString):Boolean;


        Procedure WriteMaxFiles;
        Var MaxFiles : LongInt
        Begin
          If GetInitFileInteger('User','MaxFiles',MaxFiles) Then
              OpenWindow(0,0,GetFontX*50,GetFontY*5)
              WriteWin('Es dürfen maximal',0,1);
              WriteWin(MaxFiles,0,2);
              WriteWin('Files geöffnet werden',0,3);

                               - 36 -


              WaitConfirm;
              CloseWindow
          Else
            ErrWindow(0,0,'MaxFiles wurde nicht spezifiziert');
        End;


Benutzung von Listen

Die  Benutzung  von  Listen  in  der  Initialisierungsdatei   ist
schwieriger, da nicht von vornherein feststeht, wieviele Einträge
die Liste besitzt.  Da zudem ein Listeneintrag  mehrere Parameter
unterschiedlichen Datentyps enthalten kann, muß der Programmierer
vereinbaren, in welcher Reihenfolge die Parameter angeordnet sein
müssen.   Der  Zugriff  auf die Elemente  einer  Liste  geschieht
deshalb  in zwei Schritten.   Im ersten Schritt  wird die jeweils
nächste  Zeile  der  Liste  vollständig  eingelesen.  Im  zweiten
Schritt wird die Zeile in einzelnen Parameter  zerlegt.  Da jeder
Parameter  von einem der drei Grunddatentypen  sein kann,  stehen
hierfür drei Hilfsfunktionen zur Verfügung.

        Function GetParaName(Var Line,OutVal: String):Boolean;
        Function GetParaString(Var Line,OutVal: String):Boolean;
        Function GetParaInteger(Var Line: String; Var OutVal: LongInt):Boolean;


        Function GetInitFileListFirst(Block: BlockIDString; KeyWord: KeyString;
        Var OutVal  : ValueString) : Boolean;

        Function GetInitFileListNext(KeyWord: KeyString;
        Var OutVal: ValueString):Boolean;

GetInitFileListFirst liest die erste Zeile im Abschnitt Block mit
dem Schlüsselwort  KeyWord.   Alle weiteren  Zeilen  können durch
wiederholten Aufruf von GetInitFileListNext  gelesen werden.  Das
Ende der Liste ist erreicht,  sobald die Funktion  den Wert FALSE
zurückliefert.    Beachten   Sie,   daß   beide   Funktionen   im
Variablenparameter  OutVal  den gesamten  nach  dem Schlüsselwort
verbleibenden Rest der Zeile zurückliefern.  Diese Zeile kann mit
den Hilfsfunktionen GetParaName, GetParaString und GetParaInteger
in einzelne  Parameter  der drei Grunddatentypen  zerlegt werden.
Der auf diese Weise  gewonnene  Parameter  wird dabei verbraucht.
Durch mehrmaligen  Aufruf der Hilfsfunktionen  lassen sich so aus
einer Zeile mehrere Parameter beliebigen  Datentyps  extrahieren.
Das   folgende   Programmbeispiel   zeigt,   wie  ein  Feld   von
Verbundtypen  mit Werten aus der Initialisierungsdatei  vorbelegt
werden kann.  Gleichzeitig soll demonstriert werden, wie sich die
Syntax der vorher vereinbarten  Listeneinträge  prüfen läßt.  Der
diesem  Programmfragment   zugrunde  liegende   Abschnitt   einer
Initialisierungsdatei  ist unserer Beispieldatei  entnommen.  Der
Abschnitt ist dort unter [Farbtabelle] zu finden.

        Type FarbEintrag = Record
                             LayerName  : String[15];
                             LayerFarbe : Byte;
                             LayerTyp   : String[15];
                           End;
        Type Farbtabelle = Array[0..7] of FarbEintrag;

        Var  DieFarbtabelle : Farbtabelle;
             EingabeZeile   : String;

                               - 37 -


             LayerName      : String;
             LayerFarbe     : LongInt;
             LayerTyp       : String;

        Procedure LiesFarbtabelle;
        Var I : Integer;
        Begin
          I := 0;
          If GetInitFileListFirst('Farbtabelle','Layer',EingabeZeile) Then
            Begin
              Repeat
                If GetParaName(EingabeZeile,LayerName) Then
                  Begin
                    If GetParaInteger(EingabeZeile,LayerFarbe) Then
                      Begin
                        If GetParaName(EingabeZeile,LayerTyp) Then
                          Begin
                            DieFarbTabelle[i].LayerName  := LayerName;
                            DieFarbtabelle[i].LayerFarbe := LayerFarbe;
                            DieFarbtabelle[i].LayerTyp   := LayerTyp;
                          End
                        Else ErrWindow(0,0,
                             'LayerTyp falsch oder nicht angegeben.');
                      End
                    Else ErrWindow(0,0,
                         'LayerFarbe falsch oder nicht angegeben.');
                  End
                Else ErrWindow(0,0,'LayerName falsch oder nicht angegeben');
                I := I+1;
              Until (Not GetInitFileListNext('Layer',EingabeZeile)) or (I > 7);
            End
          Else ErrWindow(0,0,'Abschnitt oder Schlüsselwort nicht gefunden');
        End;





























                               - 38 -


8 Die Verwendung von Systemtimern

Ab Version 2.0 ist deLite in der Lage, Timerevents zu generieren.
Dafür stehen bis zu 15 voneinander  unabhängige  Systemtimer  zur
Verfügung.  Nach dem Ablauf eines Systemtimers wird ein Event mit
der Klasse TimerEvent erzeugt.  Das Feld ClientID des Timerevents
enthält     die    beim    Setzen    des    Timers    vereinbarte
Identifikationsnummer.   Das Feld Channel enthält die Kanalnummer
des Timers und liegt im Bereich von 2 bis 16.  Zwei weitere Timer
mit den Kananlnummern 0 und 1 werden von deLite selbst verwendet.

Setzen eines Systemtimers

Das Setzen eines Systemtimers geschieht mit der Funktion

        Function SetTimer(ClientID : Integer; Mode,
                          MiliSecs : Word) : Integer

Der Parameter ClientID ist eine frei wählbare, positive Zahl, die
größer   als  eins  sein  muss.   Anhand  dieser  Zahl  kann  die
Empfangsprozedur  eines  Anwenderprogrammes   nach  Erhalt  eines
Timerevents erkennen, wem dieses Timerevent gehört. Wir empfehlen
als  ClientID  die  ID zu verwenden,  die  durch  GetMainID  oder
OpenSubApplication   zurückgeliefert   wird.    Mit   Mode   wird
festgesetzt, in welchem Modus der Timer startet. DeLite definiert
die Konstanten SingleShot und ContinuousShots  zur Moduswahl.  Im
Modus  SingleShot   generiert   der  Systemtimer   ein  einzelnes
Timerevent  , das nach Ablauf  der durch MiliSecs  spezifizierten
Zeitdauer ausgelöst wird. Danach stoppt der Timer selbsttätig und
gibt sich wieder  frei.  Ein mit diesen  Modus gestarteter  Timer
kann  vorzeitig  mit  der  Prozedur  StopTimer   angehalten   und
freigegeben werden. Der Modus SingleShot kann z.B. dazu verwendet
werden, um bei einer Benutzereingabe  zusätzlich einen Timeout zu
überwachen.     Im   Modus   ContinuousShots    werden    jeweils
kontinuierlich  nach  Ablauf  des durch  MiliSecs  spezifizierten
Zeitintervalls  Timerevents  ausgelöst.   DeLite macht von diesem
Modus  z.B.   beim  Blinken  des  Cursors  in  Texteingabefeldern
Gebrauch. Ein mit diesem Modus initialisierter Timer stoppt nicht
von selbst und muss daher explizit  durch die Prozedur  StopTimer
angehalten  und  freigegeben   werden.   Der  Parameter  MiliSecs
spezifiziert  die Zeitdauer,  nach  der ein Timerevent  ausgelöst
wird.  Die Angabe  erfolgt  in Millisekunden.   Ein Wert von 1000
würde nach einer Sekunde ein Event auslösen.  Beachten Sie bitte,
daß die Auflösung des Timers aus hardwaretechnichen  Gründen 18.2
ms beträgt.  Das heißt, daß der angegebene Zeitwert immer auf ein
ganzzahliges Vielfach von 18.2 ms gerundet wird. Der Rückgabewert
der Funktion  SetTimer  liefert  die Kanalnummer  des verwendeten
Timers.   Damit  hat  ein  Anwenderprogramm   grundsätzlich   die
Möglichkeit,  mehrere Timer mit der selben ID zu verwenden und zu
unterscheiden.   Wird die Kanalnummer -1 zurückgeliefert,  konnte
kein weiterer Timer mehr gestartet werden.

Stoppen eines Systemtimers

Um einen  aktiven  Timer  zu stoppen,  verwenden  Sie  bitte  die
Prozedur

        Procedure StopTimer(ClientID, TimerChannel : Integer)

Geben Sie dazu als ClientID  den selben Wert an, der beim Starten
des Timers verwendet wurde.  Als TimerChannel muß die Kanalnummer

                               - 39 -


des Timers angegeben werden.  Sie wurde als Rückgabewert  von der
Funktion SetTimer geliefert.  Der Timer wird durch diese Prozedur
sofort angehalten und freigegeben.



























































                               - 40 -


9 Referenz

Dieses Kapitel enthält eine alphabetische  Liste aller Funktionen
und Prozeduren des deLite-Toolkits.  Es ist jeweils angegeben, in
welchem  Unit die Prozedur  deklariert  ist, wie die vollständige
Deklaration lautet und welche Bedeutung die übergebenen Parameter
haben.  In vielen Fällen erläutert ein Beispiel die Anwendung der
Prozedur.  Beachten Sie bitte auch die Objektreferenz  in Kapitel
10.


ActivateApplication                                                     API

Deklaration     Procedure ActivateApplication(ID: Integer)
Funktion        Reaktiviert den Viewport eines Klienten
Parameter       ID              Identifikationsnummer des Klienten
Hinweis         Mausereignisse werden einem Klienten zugeschickt, wenn
                sie innerhalb seiner Viewports stattgefunden haben.
                Mit der Prozedur SuspendApplication kann der
                Dispatcher angewiesen werden, den Viewport eines
                Klienten bei der Verteilung von Mausereignissen nicht
                zu berücksichtigen. ActivateApplication hebt die Wirkung
                eines Aufrufs von SuspendApplication wieder auf.
Siehe auch      SuspendApplication, GetMainID


Arc                                                                     Kernel

Deklaration     Procedure Arc(Mx,My: Integer; PhiA, PhiB,
                radius: Integer; Color: Byte)
Funktion        Zeichnet ein Kreissegment
Parameter       Mx,My   Koordinaten des Mittelpunktes
                PhiA,PhiB       Anfangs- und Endwinkel
                radius  Radius
                Color   Farbe
Hinweis         Die Zeichnung erfolgt im mathematisch positiven Sinn.
Beispiel                Arc(100,100,180,0,100,15)
                zeichnet die untere Hälfte eines weißen Kreises an der
                Position (100,100) mit dem Radius 100. Um die obere Hälfte
                eines Kreises zu zeichnen, müßten Anfangs- und Endwinkel
                vertauscht werden.
Siehe auch      Circle


Bar                                                                     Kernel

Deklaration     Procedure Bar(x1,y1,x2,y2 : Integer; Color : Byte);
Funktion        Zeichnet eine ausgefüllte rechteckige Fläche
Parameter       x1,y1   Koordinaten der linken oberen Ecke
                x2,y2   Koordinaten der rechten unteren Ecke
                Color   Farbe
Hinweis         Die Koordinaten der Ecken können vertauscht werden


CheckMenuItem                                                           API

Deklaration     Procedure CheckMenuItem(Menu: hmenu; ID: MenueID;
                                        wCheck: MenueFlags)
Funktion        Setzt oder entfernt eine Überprüfungsmarke vor einem
                Menüeintrag
Parameter       Menu    Zeiger auf den Menübaum

                               - 41 -


                ID      Identifikationsnummer des Menüeintrages
                wCheck  MF_CHECKED oder MF_UNCHECKED
Hinweis         Die Angabe von MF_CHECKED bewirkt das Setzen einer
                Überprüfungsmarke, während MF_UNCHECKED die Überprüfungs-
                marke entfernt. Die Überprüfungsmarke ist als Häkchen
                links neben dem Menütext sichtbar.
Beispiel                CheckMenuItem(GetMenu,101,MF_CHECKED)
                setzt eine Überprüfungsmarke vor den Menüeintrag 101 im
                Hauptmenü
Siehe auch      EnableMenuItem, GetMenuFlags, GetMenuString, GetSubMenu,
                GetMenu, ReplaceMenuItem


Circle                                                                  Kernel

Deklaration     Procedure Circle(Mx,My : Integer; radius : Integer;
                                 Color : Byte)
Funktion        Zeichnet einen Kreis
Parameter       My,My   Koordinaten des Mittelpunktes
                radius  Radius
                Color   Farbe
Hinweis         Verzerrungen durch das vom Monitor abweichende Höhen/
                Breitenverhältnis der Grafikkarte werden korrigiert.
Siehe auch      Arc


ClearWindow                                                             API

Deklaration     Procedure ClearWindow
Funktion        Löscht das aktuelle Fenster
Hinweis         Einige Grafiktreiber erlauben die Vereinbarung einer anderen
                Hintergrundfarbe als Schwarz. In diesem Fall bewirkt ein
                Löschen des Viewports die Belegung des Viewports mit der in
                der Initialisierungsdatei angegebenen Hintergrundfarbe.
Siehe auch      ClearViewPort


CloseMainApplication                                                    API

Deklaration     Procedure CloseMainApplication
Funktion        Beendet die laufende Anwendung und schaltet zurück in den
                Textmodus.
Hinweis         Alle erforderlichen Deinstallationen werden durchgeführt. Ein
                Aufruf von CloseMainApplication ist üblicherweise die letzte
                Anweisung einer deLite-Applikation.
Siehe auch      OpenMainApplication


CloseSubApplication                                                     API

Deklaration     Procedure CloseSubApplication(ID: Integer)
Funktion        Schließt eine Subapplikation. Der entsprechende Klient wird
                aus der Klientenliste entfernt.
Parameter       ID              Identifikationsnummer des Klienten
Hinweis         Der vom Viewport des Klienten zuvor belegte Bildschirmbereich
                wird nicht wiederhergestellt.
Siehe auch      OpenSubApplication


CloseWindow                                                             API


                               - 42 -


Deklaration     Procedure CloseWindow
Funktion        Schließt ein mit OpenWindow geöffnetes Fenster
Hinweis         Da auch alle Dialogfunktionen ihre Fenster mit OpenWindow
                öffnen, würde CloseWindow auch einen gerade offenen Dialog
                schließen. Tatsächlich bestehen die Prozeduren zum Schließen
                von Dialogen lediglich aus einem Aufruf von CloseWindow.
                Es wird immer das oberste Fenster geschlossen. Dabei wird
                der zuvor verdeckte Bildschirminhalt wiederhergestellt.
Siehe auch      OpenWindow

ContinueToDispatch                                                      API

Deklaration     Procedure ContinueToDispatch
Funktion        Beendet den exklusiven Empfang von Botschaften
Hinweis         Die Prozedur ContinueToDispatch macht einen vorherigen Aufruf
                von ReceiveExclusive rückgängig. Danach nimmt der Dispatcher
                seine Arbeit wieder auf und verteilt die Botschaften an die
                jeweils zuständigen Klienten.
Siehe auch      ReceiveExclusive


DispatchMessage                                                         API

Deklaration     Procedure DispatchMessage(TheMessage: EventTyp)
Funktion        Schickt eine zuvor mit GetEvent geholte Botschaft zur
                Weiterleitung an den Dispatcher
Parameter       TheMessage              Die Botschaft
Hinweis         Der  Dispatcher   wird  die  Botschaft   an  den  dafür
                zuständigen Klienten senden, indem dessen Empfangsprozedur
                mit der  Botschaft als übergebenem  Parameter  aufgerufen
                wird. Mausereignisse werden  dem  Klienten  übermittelt,
                in  dessen Viewport  sie stattgefunden  haben.   In diesem
                Fall werden  die Koordinaten auf Werte relativ  zur linken
                oberen  Ecke  des Viewports    umgerechnet. Andere Ereignisse
                werden der Empfangsprozedur der Hauptapplikation  zugeschickt.
                Sollte ein Klient sich als exclusiver Klient angemeldet haben,
                erhält er auch Mausereignisse, die sich nicht innerhalb seines
                Viewports abgespielt  haben.  Solche  Ereignisse  können
                nicht  auf  die Koordinaten  des Viewports  bezogen werden und
                erhalten  anstelle der Klasse LeMouse die Klasse
                MouseUnnormalized.

Beispiel
        Procedure EventHandler(TheEvent: EventTyp);
        Begin
          If TheEvent.Class = MouseUnnormalized then
            begin
              TheEvent.Class := LeMouse;
              ContinueToDispatch;
              DispatchMessage(TheEvent);
            end;

        Das Programmfragment entstammt einer Botschaftenempfangsprozedur,
        die sich kurzzeitig als exclusiver Klient angemeldet  hat Nachdem
        eine Botschaft empfangen wird, die nicht normalisiert werden kann
        und daher eigentlich  einem anderen Klienten gehört, wird der Typ
        der Botschaft  wieder auf LeMouse  zurückgesetzt  und erneut  dem
        Dispatcher  gegeben,  nachdem  er mit  ContinueToDispatch  wieder
        aktiviert  wurde.  So ist sichergestellt,  daß die Botschaft doch
        noch  beim richtigen  Empfänger  ankommt.
Siehe auch      GetEvent, PostMessage

                               - 43 -




DrawNormIcon                                                            Kernel

Deklaration     Procedure DrawNormIcon(ScrX,ScrY, Dx, Dy : Integer;
                Typ, Color: Byte; Storage: Pointer)
Funktion        Zeichnet ein anwenderdefiniertes Icon
Parameter       ScrX, ScrY      Position der linken oberen Ecke
                Dx, Dy  Ausmasse des Icons in Pixeln
                Typ             Zur Zeit wird nur der Typ 1 verwendet
                Color   Zeichenfarbe des Icons
                Storage Zeiger auf die Bitmap des Icons
Hinweis         Icons sind bitweise abgelegte, monochrome Grafiken, deren
                einzelnen Zeilen immer auf Byte-Grenzen enden. Der Parameter
                Typ ist für zukünftige Erweiterungen vorgesehen. Es wird zur
                Zeit nur der Typ 1 verwendet. Dieser Typ gibt an, daß das Icon
                mit der Zeichenfarbe Color in die Grafik geschrieben wird.
                Das Beispiel zeigt eine Prozedur, die das Logo der Technischen
                Universität Berlin in ein Fenster in die Mitte des Bildschirms
                zeichnet und danach auf Bestätigung wartet. Die Konstanten-
                definition TuB enthält die Bitmap des Logos.
Beispiel
        Type  IcoArray = Record
                           DeltaX : Integer;
                           DeltaY : Integer;
                           IcoArr : Array[0..199] of Byte;
                         End;

        Const TuB : IcoArray = (DeltaX : 39; DeltaY : 39; { Das TU Berlin
                                                            Logo }
        IcoArr : $00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,$00,
                 $00,$00,$00,$00,$00,$1f,$ff,$ff,$e0,$00,$3f,$ff,$ff,$f1,$ff,
                 $7f,$ff,$ff,$f9,$f9,$7f,$ff,$ff,$f9,$f7,$7f,$ff,$ff,$f9,$f1,
                 $3f,$ff,$ff,$f9,$ff,$1f,$ff,$ff,$f9,$d1,$00,$00,$0f,$f9,$ff,
                 $00,$7f,$8f,$f3,$82,$00,$7f,$8f,$f3,$fe,$00,$7f,$8f,$f3,$ee,
                 $00,$7f,$8f,$f3,$e2,$00,$7f,$8f,$f3,$fe,$00,$7f,$8f,$f3,$ce,
                 $00,$7f,$8f,$f3,$d6,$00,$ff,$9f,$f3,$c6,$00,$ff,$1f,$e7,$fc,
                 $00,$ff,$1f,$e7,$e4,$00,$ff,$1f,$e7,$d4,$00,$ff,$1f,$e7,$04,
                 $00,$ff,$1f,$e7,$fc,$00,$ff,$1f,$e7,$fc,$00,$ff,$1f,$e7,$fc,
                 $01,$ff,$1f,$e7,$fc,$01,$fe,$3f,$e7,$fc,$01,$fe,$3f,$cf,$fc,
                 $01,$fe,$3f,$cf,$f8,$01,$fe,$3f,$cf,$f8,$01,$fe,$3f,$cf,$f8,
                 $01,$fe,$3f,$cf,$f0,$01,$fe,$1f,$cf,$f0,$01,$fe,$0f,$cf,$e0,
                 $00,$00,$07,$cf,$c0,$00,$00,$03,$cf,$00,$00,$00,$00,$00,$00,
                 $00,$00,$00,$00,$00));

        Procedure ZeigeTuBLogo;
        Begin
          OpenWindow((GetMaxX+1) div 2,(GetMaxY+1) div 2,
                     (GetMaxX+1) div 2 +50,(GetMaxX+1) div 2 + 50);
          DrawNormIcon(5,5,TuB.DeltaX,TuB.DeltaY,1,0,@Tub40.IcoArr);
          WaitConfirm;
          CloseWindow;
        End;


DrawText                                                                Kernel

Deklaration     Procedure DrawText(X0, Y0, FakX, FakY: Integer;
                Var Str: String; color: Byte)
Funktion        Zeichnet einen Text mit Hilfe eines skalierbaren Zeichensatzes
Parameter       X0, Y0  Startposition

                               - 44 -


                FakX, FakY      Skalierungsfaktoren für die Ausgabe der
                                Buchstaben
                Str             Der zu zeichnende Text
                color   Die Farbe des Textes
Hinweis         Die von deLite verwendeten skalierbaren Zeichensätze können
                durch die Angabe von FakX und FakY in den Richtungen der
                beiden Hauptachsen unabhängig voneinander skaliert werden.
                Die Faktoren geben dabei die Höhe und Breite der Buchstaben in
                Pixeln auf dem Bildschirm an. Der Wertebereich dieser Faktoren
                muss innerhalb der Grenzen von 1 - 512 liegen.

                Das Beispiel gibt den Text 'Hello, world' in der Farbe weiß in
                der linken oberen Ecke des aktuellen ViewPort aus. Die Höhe
                der Zeichen beträgt 32 Pixel auf dem Bildschirm.
                Ab deLite Version 1.1 steht für die Ausgabe von Texten mit
                Hilfe des skalierbaren Zeichensatzes die wesentlich
                mächtigeren Prozeduren OutText und OutTextXY zur Verfügung.
                DrawText sollte deshalb nicht mehr verwendet werden.
Beispiel                DrawText(0,0,32,32,'Hello, world',15)
Siehe auch      InitFont, OutText, OutTextXY


EnableMenuItem                                                          API

Deklaration     Procedure EnableMenuItem(Menu: hMenu; ID: MenuID;
                wEnable: MenuFlags)
Funktion        Sperrt oder erlaubt die Auswahl eines Menüeintrages
Parameter       Menu    Zeiger auf das Menü
                ID              ID des Menüeintrages
                wEnable kann einen der folgenden Werte annehmen
                        MF_ENABLED      erlaubt die Auswahl des Eintrags
                        MF_DISABLED     sperrt die Auswahl des Eintrags
Hinweis         Gesperrte Menüeinträge werden optisch entsprechend
                gekennzeichnet. Die kontextabhängige Hilfe bleibt auch für
                gesperrte Menüeinträge funktionsfähig.
Beispiel                EnableMenuItem(GetMenu,101,MF_DISABLED);
                sperrt den Eintrag 101 im Hauptmenü
Siehe auch      GetMenu, GetMenuFlags,CheckMenuItem


ErrWindow                                                               API

Deklaration     Procedure ErrWindow(x,y: Integer; errtext: String)
Funktion        Gibt einen Text in einem Fenster als Fehlermeldung aus
Parameter       x,y             Position des Fensters
                errtext Die Fehlermeldung
Hinweis         Fehlermeldungen werden von dieser Prozedur in einem Fenster
                mit der Hintergrundfarbe ErrBkColor ausgegeben. Diese Farbe
                ist standardmässig rot, kann aber in der Initialisierungsdatei
                umdefiniert werden.
Siehe auch      OpenWindow, WriteWin, SysWindow


FlushQueue                                                              Kernel

Deklaration     Procedure FlushQueue
Funktion        Verwirft alle Einträge der Botschaftenwarteschlange
Hinweis         Während der Ausführung zeitaufwendiger Programmteile, in
                denen längere Zeit keine Botschaften mit GetEvent geholt
                werden, kann es sein, daß die Botschaftenwarteschlange
                komplett gefüllt wird. Ohne einen Aufruf von FlushQueue

                               - 45 -


                würden die zwischenzeitlich angefallenen Botschaften danach
                abgearbeitet werden. In Situationen, in denen das unerwünscht
                ist, kann ein Aufruf von FlushQueue die Warteschlange
                vollständig löschen
Siehe auch      GetEvent, PutEvent


FrameSubApplication                                                     API

Deklaration     Procedure FrameSubApplication(ID, color: Integer)
Funktion        Zeichnet einen Rahmen um den Viewport eines Klienten
Parameter       ID              Identifikationsnummer des Klienten
                color   Farbe des Rahmens
Hinweis         Bei der Aufteilung der Bildschirmfläche auf mehrere Klienten
                kann es sinnvoll sein, den jeweils aktiven Klienten zu
                kennzeichnen. Mit Hilfe von FrameSubApplication kann die
                Farbe der Rahmen um die Viewports der einzelnen Klienten
                individuell gesetzt werden. Ein Aufruf von FrameSubApplication
                bleibt wirkungslos, falls bei der Anmeldung des Klienten mit
                OpenSubApplication als Filter APP_NOFRAME angegeben wurde.
Siehe auch      OpenSubApplication


GetDriverName                                                           Kernel

Deklaration     Function GetDriverName: String
Funktion        Liefert den Namen des benutzten Grafiktreibers
Ergebnis        Der Name des Grafiktreibers wird als String zurückgeliefert
Hinweis         Für die Standardgrafikadapter sind die Namen EGA, VGA und HGC
                definiert worden, Grafikkarten mit höherer Auflösung enthalten
                in der Regel zusätzlich einen Hinweis auf die Auflösung und
                die Anzahl der verfügbaren Farben.


GetEvent                                                                Kernel

Deklaration     Procedure GetEvent(Var Event : EventTyp)
Funktion        Liefert das nächste Ereignis aus der Ereigniswarteschlange
Parameter       Event   Das Ereignis
Hinweis         Der Verbundtyp EventTyp beschreibt die innerhalb des Systems
                auftretenden Ereignisse und Botschaften. Während Ereignisse
                unmittelbar von der Hardware erzeugt werden, dienen
                Botschaften dem Austausch von Informationen zwischen den
                einzelnen Klienten und dem deLite API. Botschaften werden
                z.B. erzeugt, wenn ein Menüpunkt ausgewählt wird.
                EventTyp = RECORD
                             TimeStamp  : Word;
                             Case Class : EventTypes of
                               TimerEvent  : (
                                        ClientID     : Integer;
                                            TimerChannel : Integer;
                                     );
                       DialogEvent : (
                            ID,MSG       : integer;
                            DlgAdr       : Pointer;
                                     );
                       Menu         : (MenuItemID : Integer);
                       LeMouse, DoubleClick, MouseUnNormalized,
                       NormKey, AltKey, CtrlKey, FKey,
                       DoRedraw, Terminate,
                       UserEvent

                               - 46 -


                       Void        : (
                            Attrib       : CHAR;
                            x,y          : INTEGER;
                                     );
                   End; { Case & Record }

Die Verbundkomponente  Class enthält die Art des Ereignisses oder
der Botschaft.   Abhängig  von ihrem Inhalt werden  die folgenden
drei Verbundkomponenten  unterschiedlich  interpretiert.  Hat das
Ereignis   etwa   eine   räumliche   Bedeutung,    wie   es   bei
Mausereignissen der Fall ist, so geben die Felder x und y den Ort
des  Ereignisses  an.  Die  folgende  Auflistung  beschreibt  die
Bedeutung  der einzelnen Verbundkomponenten  in Abhängigkeit  von
Class.  Die jeweils nicht beschriebenen Verbundkomponenten  haben
keine Bedeutung.

LeMouse                 Ein Mausereignis ist aufgetreten. Attrib enthält
                        bitweise kodiert den Status der Maustasten. Die
                        Verbundkomponenten x und y enthalten die Position des
                        Mausereignisses. Die Mausereignisse vom Typ LeMouse
                        sind normalisiert, das heißt, sie sind relativ zur
                        linken oberen Ecke des Viewports des empfangenden
                        Klienten. Die einzelnen Bits der Verbundkomponente
                        Attrib haben die folgende Bedeutung:

                                $01 = Die Maus hat sich bewegt
                                $02 = Linke Maustaste wurde gedrückt
                                $04 = Linke Maustaste wurde losgelassen
                                $08 = Rechte Maustaste wurde gedrückt
                                $10 = Rechte Maustaste wurde losgelassen
                                $20 = Mittlere Maustaste wurde gedrückt
                                $40 = Mittlere Maustaste wurde losgelassen

MouseUnnormalized       Ein Mausereignis ist aufgetreten. Für die Verbund-
                        komponente Attrib gilt das gleiche wie bei LeMouse.
                        Die Verbundkomponenten x und y enthalten die Position
                        des Mausereignisses. Das Ereignis konnte nicht
                        normalisiert werden, fand also außerhalb des Viewports
                        des empfangenden Klienten statt.
NormKey                 Ein normale Taste wurde gedrückt. Die Verbund-
                        komponente Attrib enthält den ASCII Wert der
                        gedrückten Taste.
AltKey                  Ein Taste wurde in Verbindung mit der Taste Alt
                        gedrückt. Attrib enthält den ASCII Wert der
                        gedrückten Taste.
CtrlKey                 Eine Taste wurde in Verbindung mit der Taste Ctrl
                        gedrückt. Attrib enthält den ASCII Wert der gedrückten
                        Taste. Beachten Sie, daß die Taste RETURN  als CtrlKey
                        mit Attrib=m übergeben wird.
Fkey                    Eine Funktionstaste wurde gedrückt. Attrib enthält den
                        Scan Code der gedrückten Funktionstaste.
Menu                    Ein Menüpunkt wurde ausgewählt. Die Verbundkomponente
                        MenuItemID enthält die in der Menüressource
                        vereinbarte Nummer.
DoRedraw                Der Viewport des Klienten ist zerstört worden, er muß
                        vom Klienten erneut gezeichnet werden.
DialogEvent             Ein Dialogelement wurde betätigt. MSG enthält die
                        Nachricht, ID enthält die ID-Nummer des betätigten
                        Dialogelementes. In DlgAdr wird die Adresse des
                        Dialoges, zu dem das Element gehört, übergeben.
TimerEvent              Ein Timer ist abgelaufen. ClientID enthält die beim

                               - 47 -


                        Starten des Timers mittels SetTimer vereinbarte
                        ID-Nummer. In TimerChannel wird die interne
                        Kanalnummer übergeben.
void                    Die Ereigniswarteschlange ist leer.
Siehe auch      DispatchMessage, FlushQueue, PostMessage, PutEvent


GetFirstTopic                                                           API

Deklaration     Procedure GetFirstTopic(Var Name: NameString: var eol: boolean)
Funktion        Liefert das erste Hilfestichwort aus der allgemeinen Hilfedatei
Parameter       Name            enthält nach der Ausführung das Stichwort
                eol             wird TRUE, falls keine weiteren Stichworte
                                enthalten sind
Hinweis         Diese Prozedur wird als Callback-Prozedur von der allgemeinen
                Hilfe verwendet. Die Prozedur kann einem Listendialog zur
                Ermittlung der Liste der Einträge dienen. Die allgemeine
                Hilfedatei trägt den Namen des Hauptprogramms, der bei
                OpenMainApplication angegeben wurde, und endet auf '.hlp'.
Siehe auch      GetNextTopic


GetFontX                                                                Kernel

Deklaration     Function GetFontX: Byte
Funktion        Liefert die Breite eines Zeichens des Standardzeichensatzes in
                Pixeln
Ergebnis        Das Ergebnis vom Typ Byte wird bei Standard-EGA und VGA-Karten
                8 Pixel und bei der Hercules-Karte 9 Pixel betragen. Bei
                Karten mit sehr hoher Auflösung sind die Zeichen größer, um
                die Lesbarkeit zu gewährleisten.
Hinweis         Diese Funktion wird vorteilhaft eingesetzt, wenn die Größe
                eines Textausgabefensters zu berechnen ist. Es ist nicht zu
                empfehlen, die Größe solcher Fenster fest zu dimensionieren,
                da dann unter Umständen auf Grafikkarten mit sehr hoher
                Auflösung nicht alle Zeichen im Fenster Platz finden
Siehe auch      GetFontY, WriteWin


GetFontY                                                                Kernel

Deklaration     Function GetFontY: Byte
Funktion        Liefert die Höhe eines Zeichens des Standardzeichensatzes in
                Pixeln
Ergebnis        Das Ergebnis vom Typ Byte wird bei EGA-Karten 14 und bei
                VGA-Karten 16 Pixel betragen. Bei Karten mit höherer Auflösung
                sind die Zeichen größer, um die Lesbarkeit zu gewährleisten.
Hinweis         Diese Funktion wird vorteilhaft eingesetzt, wenn die Größe
                eines Textausgabefensters zu berechnen ist. Anstatt die Größe
                des Fensters fest zu dimensionieren, sollte sie aus der Anzahl
                der Zeilen und FontY bzw. der Anzahl der Spalten und FontX
                berechnet werden.
Siehe auch      GetFontX, WriteWin


GetInitFileInteger                                                      Kernel

Deklaration     Function GetInitFileInteger(Block: BlockIDString;
                KeyWord: KeyString; Var OutVal: LongInt):Boolean
Funktion        Liefert einen LongInt aus der Initialisierungsdatei.
Parameter       Block   Name des Abschnitts, in dem das Schlüsselwort gesucht

                               - 48 -


                        wird.
                KeyWord Name des gesuchten Schlüsselwortes.
                OutVal  Enthält nach der Ausführung den gesuchten LongInt Wert
Ergebnis        Das Funktionsergebnis teilt Erfolg (TRUE) oder Mißerfolg
                (FALSE) der Suche mit.
Beispiel
                Das Programmbeispiel entnimmt der Initialisierungsdatei einen
                vom Benutzer  festgelegten  Wert für die maximal offenenen
                Files der Applikation.  Für das Beispiel sei folgender
                Ausschnitt aus einer Initialisierungsdatei angenommen:

        [User]
        WelcomeText="Hallo Frank, schön dich zu sehen"  ;ein String
        MaxOpenFiles=10                                 ;ein LongInt

        Funktion GiveMaxOpenFiles : Byte;
        Var OpenFiles : LongInt;
        Begin
          MaxOpenFile := 0;
          If GetInitFileInteger('User','MaxOpenFiles',OpenFiles) Then
            If (OpenFiles > 0) and (OpenFiles < 30) Then
              MaxOpenFiles := OpenFiles;
        End;
Siehe auch      GetInitFileName, GetInitFileString, GetInitFileListFirst,
                GetInitFileListNext, GetParaInteger, GetParaName, GetParaString


GetInitFileListFirst                                                    Kernel

Deklaration     Function GetInitFileListFirst(Block: BlockIDString;
                KeyWord: KeyString; Var OutVal: ValueString):Boolean
Funktion        Liefert den Rest der Zeile nach dem Schlüsselworte KeyWord.
Parameter       Block   Name des Abschnitts, in dem das Schlüsselwort gesucht
                        wird.
                KeyWord Name des gesuchten Schlüsselwortes.
                OutVal  Enthält nach der Ausführung den Rest der Zeile nach
                        dem ersten Vorkommen des Schlüsselwortes KeyWord.
Ergebnis        Das Funktionsergebnis teilt Erfolg (TRUE) oder Mißerfolg
                (FALSE) der Suche mit.
Hinweis         Um aus der durch GetInitFileListFirst gewonnenen Eingabezeile
                einzelne Parameter zu extrahieren, benutzen Sie bitte die
                Funktionen GetParaInteger, GetParaName  oder  GetParaString.
Beispiel
                Das Programmierbeispiel belegt ein Feld von Verbunden mit
                Werten aus der Initialisierungsdatei vor. Die
                Initialisierungsdatei enthalte folgenden Abschnitt:

        [Farbtabelle]
        ;       Name    Farbe   Linientyp
        LAYER=  0       15      CONTINUOUS
        LAYER=  1       2       CONTINUOUS
        LAYER=  2       3       CONTINUOUS
        LAYER=  3       15      CONTINUOUS
        LAYER=  4       5       CONTINUOUS
        LAYER=  5       6       CONTINUOUS
        LAYER=  6       14      CONTINUOUS
        LAYER=  7       7       CONTINUOUS


        Type FarbEintrag = Record
                             LayerName  : String[15];

                               - 49 -


                             LayerFarbe : Byte;
                             LayerTyp   : String[15];
                           End;
        Type Farbtabelle = Array[0..7] of FarbEintrag;

        Var  DieFarbtabelle : Farbtabelle;
             EingabeZeile   : String;
             LayerName      : String;
             LayerFarbe     : LongInt;
             LayerTyp       : String;

        Procedure LiesFarbtabelle;
        Var I : Integer;
        Begin
          I := 0;
          If GetInitFileListFirst('Farbtabelle','Layer',EingabeZeile) Then
            Begin
              Repeat
                If GetParaName(EingabeZeile,LayerName) Then
                  Begin
                    If GetParaInteger(EingabeZeile,LayerFarbe) Then
                      Begin
                        If GetParaName(EingabeZeile,LayerTyp) Then
                          Begin
                            DieFarbTabelle[i].LayerName  := LayerName;
                            DieFarbtabelle[i].LayerFarbe := LayerFarbe;
                            DieFarbtabelle[i].LayerTyp   := LayerTyp;
                          End
                        Else ErrWindow(0,0,
                             'LayerTyp falsch oder nicht angegeben.');
                      End
                    Else ErrWindow(0,0,
                         'LayerFarbe falsch oder nicht angegeben.');
                  End
                Else ErrWindow(0,0,'LayerName falsch oder nicht angegeben');
                I := I+1;
              Until (Not GetInitFileListNext('Layer',EingabeZeile)) or (I > 7);
            End
          Else ErrWindow(0,0,'Abschnitt oder Schlüsselwort nicht gefunden');
        End;
Siehe auch      GetInitFileInteger, GetInitFileName, GetInitFileString,
                GetInitFileListNext, GetParaInteger, GetParaName, GetParaString


GetInitFileListNext                                                     Kernel

Deklaration     Function GetInitFileListNext(KeyWord: KeyString;
                Var OutVal: ValueString):Boolean
Funktion        Liefert bei wiederholtem Aufruf jeweils eine neue Zeile nach
                dem Schlüsselwort KeyWord. Die Suche muß zuvor mit
                GetInitFileListFirst eingeleitet worden sein.
Parameter       KeyWord Name des gesuchten Schlüsselwortes.
                OutVal  Enthält nach der Ausführung den Rest der Zeile nach
                        dem ersten Vorkommen des Schlüsselwortes KeyWord.
Ergebnis        Das Funktionsergebnis teilt mit, ob noch eine weitere Zeile
                gefunden wurde (TRUE), oder ob kein weiteres Schlüsselwort
                mehr gefunden wurde (FALSE).
Hinweis         Um aus der durch GetInitFileListNext gewonnenen Eingabezeile
                einzelne Parameter zu extrahieren, benutzen Sie bitte die
                Funktionen GetParaInteger, GetParaName oder GetParaString.
                Ein umfangreiches Programmierbeispiel finden Sie bei

                               - 50 -


                GetInitFileListFirst.
Siehe auch      GetInitFileInteger, GetInitFileName, GetInitFileString,
                GetInitFileListFirst, GetParaInteger, GetParaName,
                GetParaString


GetInitFileName                                                         Kernel

Deklaration     Function GetInitFileName(Block: BlockIDString;
                KeyWord: KeyString; Var OutVal: ValueString):Boolean
Funktion        Liefert einen Namen (ungeschützten String) aus der
                Initialisierungsdatei.
Parameter       Block   Name des Abschnitts, in dem das Schlüsselwort gesucht
                        wird.
                KeyWord Name des gesuchten Schlüsselwortes.
                OutVal  Enthält nach der Ausführung den gesuchten Namen
Ergebnis        Das Funktionsergebnis teilt Erfolg (TRUE) oder Mißerfolg
                (FALSE) der Suche mit.
Beispiel
                Das Beispiel entnimmt der Initialisierungsdatei den Namen
                VDIDir. Angegeben ist ein Auszug aus der Initialisierungsdatei
                und das dazugehörige Programmfragment.

        [paths]
        VDIDir=C:\TURBO\DELITE\DRIVER           ;Verzeichnis der Treiber


        Funktion GetPath : String;
        Begin
          If GetInitFileString('paths','VDIDir',ThePath) Then
            GetPath := ThePath
          Else GetPath := 'NONE';
        End;
Siehe auch      GetInitFileInteger, GetInitFileString, GetInitFileListFirst,
                GetInitFileListNext, GetParaInteger, GetParaName,
                GetParaString


GetInitFileString                                                       Kernel

Deklaration     Function GetInitFileString(Block: BlockIDString;
                KeyWord: KeyString; Var OutVal: ValueString): Boolean

Funktion        Liefert einen String (geschützten String) aus der
                Initialisierungsdatei.
Parameter       Block   Name des Abschnitts, in dem das Schlüsselwort gesucht
                        wird.
                KeyWord Name des gesuchten Schlüsselwortes.
                OutVal  Enthält nach der Ausführung den gesuchten String
Ergebnis        Das Funktionsergebnis teilt Erfolg (TRUE) oder Mißerfolg
                (FALSE) der Suche mit.
Beispiel
                Das Beispiel zeigt einen Ausschnitt aus der
                Initialisierungsdatei und ein Programmfragment zur Ausgabe
                eines geschützten Strings.

        [User]
        WelcomeText="Hallo Frank, schön dich zu sehen"  ;ein String

        Procedure WelcomeUser;
        Var TheUser : String;

                               - 51 -


        Begin
          If GetInitFileString('User','WelcomeText',TheUser) Then
            Begin
              OpenWindow(0,0,GetFontX*Length(TheUser),GetFontY*3);
              WriteWin(TheUser,0,1,15);
              WaitConfirm;
              CloseWindow;
            End
          Else ErrWindow(0,0,'Keine Begrüßung angegeben.');
        End;
Siehe auch      GetInitFileInteger, GetInitFileName, GetInitFileListFirst,
                GetInitFileListNext, GetParaInteger, GetParaName, GetParaString


GetLinePattern                                                          Kernel

Deklaration     Function GetLinePattern: Word
Funktion        Liefert den aktuell gesetzten Linienstil
Ergebnis        Das niederwertigste Byte des Ergebnisses enthält den Linienstil
Siehe auch      SetLinePattern


GetMainID                                                               API

Deklaration     Function GetMainID: Integer
Funktion        Liefert die Identifikationsnummer der Hauptapplikation
Ergebnis        Das Ergebnis ist eine positive Integerzahl
Hinweis         Die Angabe der Identifikationsnummer eines Klienten ist bei
                einer Reihe von Operationen notwendig. Im Gegensatz zu
                Subapplikationen, bei denen die Identifikationsnummer beim
                Anmelden zurückgeliefert wird, muß die Identifikationsnummer
                der Hauptapplikation mit dieser Prozedur erst in Erfahrung
                gebracht werden. Die meisten Operationen mit Klienten sind
                allerdings nur dann wichtig, wenn die Bildschirmfläche auf
                mehrere Klienten verteilt werden soll.
Beispiel                SuspendApplication(GetMainID)
                veranlaßt den Dispatcher, den Viewport der Hauptapplikation
                bei der Verteilung von Botschaften unberücksichtigt zu lassen.
Siehe auch      SuspendApplication, ActivateApplication, OpenMainApplication,
                OpenSubApplication, FrameSubApplication, PostMessage,
                DispatchMessage


GetMaxColors                                                            Kernel

Deklaration     Function GetMaxColors: Byte
Funktion        Liefert die Anzahl der darstellbaren Farben des verwendeten
                Grafiktreibers
Ergebnis        Das Ergebnis vom Typ Byte liefert den Wert der höchsten
                darzustellenden Farbe. Bei einer Karte mit 16 Farben wäre das
                15. Bei monochromen Karten wird hier eine 1 zurückgeliefert.


GetMaxX                                                                 Kernel

Deklaration     Function GetMaxX: Integer
Funktion        Liefert die horizontale Grösse der Grafikseite
Ergebnis        Das Ergebnis vom Typ Integer entspricht der grössten
                Koordinate in X-Richtung auf der Grafikseite. Die kleinste
                Koordinate hat den Wert 0.
Hinweis         Ein gesetzter Viewport hat keinen Einfluß auf das Resultat

                               - 52 -


                dieser Funktion.
Siehe auch      GetMaxY, PortMaxX, PortMaxY


GetMaxY                                                                 Kernel

Deklaration     Function GetMaxY: Integer
Funktion        Liefert die vertikale Grösse der Grafikseite
Ergebnis        Das Ergebnis vom Typ Integer entspricht der größten Koordinate
                in Y-Richtung auf der Grafikseite. Die kleinste Koordinate hat
                den Wert 0.
Hinweis         Ein gesetzter Viewport hat keinen Einfluß auf das Resultat
                dieser Funktion.
Siehe auch      GetMaxX, PortMaxX, PortMaxY


GetMenu                                                                 API

Deklaration     Function GetMenu: hMenu
Funktion        Liefert den Zeiger auf das Menü
Ergebnis        Der Typ hMenu ist als Zeiger definiert und ist NIL, solange
                kein Menü geladen worden ist
Hinweis         Der Zeiger auf das Menü muß bei allen Funktionen zur
                Modifikation der Menüs angegeben werden. Diese Konvention
                wurde eingeführt, damit es in einer späteren Version möglich
                ist, mehrere Menüs zu verwalten.
Siehe auch      EnableMenuItem, CheckMenuItem, GetMenuFlags


GetMenuFlags                                                            API

Deklaration     Function GetMenuFlags(Menu: hMenu; ID: MenuID):MenuFlags
Funktion        Liefert die Attribute eines Menüeintrages
Parameter       Menu    Zeiger auf das Menü
                ID              Identifikationsnummer des Menüeintrages
Ergebnis        Der Typ MenuFlags ist als Byte definiert und enthält bit-
                kodiert die Attribute des Menüeintrages
Hinweis         Um festzustellen, ob ein bestimmtes Attribut gesetzt ist,
                muß der Ergebniswert mit den Konstanten MF_CHECKED oder
                MF_DISABLED UND-verknüpft werden.
Beispiel        If GetMenuFlags(GetMenu, 101) and MF_CHECKED then ...
Siehe auch      EnableMenuItem, CheckMenuItem, GetMenu


GetMenuString                                                           API

Deklaration     Procedure GetMenuString(Menu: hmenu; ID: MenueID;
                Var StrPrt: String)
Funktion        Liefert den Text eines Menüeintrages
Parameter       Menu            Zeiger auf das Menü
                ID              Identifikationsnummer des Menüeintrages
                StrPtr          enthält nach der Ausführung den Menütext
Hinweis         Der Menütext enthält in der Regel ein Ampersandsymbol ("&") zur
                optischen Kennzeichnung der Abkürzungstaste (Hotkey) des Menüs.
Siehe auch      GetMenu, ReplaceMenu


GetNextTopic                                                            API

Deklaration     Procedure GetNextTopic(Var Name: NameString; Var eol: boolean)
Funktion        Liefert das nächste Hilfestichwort aus der allgemeinen Hilfe-

                               - 53 -


                datei
Parameter       Name            enthält nach der Ausführung das Stichwort
                eol             wird TRUE, falls keine weiteren Stichworte
                                enthalten sind
Hinweis         Diese Prozedur wird als Callback-Prozedur von der allgemeinen
                Hilfe verwendet. Die Prozedur kann einem Listendialog zur
                Ermittlung der Liste der Einträge dienen. Die allgemeine Hilfe-
                datei trägt den Namen des Hauptprogramms, der bei
                OpenMainApplication angegeben wurde, und endet auf '.hlp'.
Siehe auch      GetFirstTopic


GetPalette                                                              Kernel

Deklaration     Procedure GetPalette(ThePalette: Byte; Var R,G,B: Byte)
Funktion        Liefert den Eintrag der Farbpalette als RGB Wert.
Parameter       ThePalette      Index des Paletteneintrages
                R, G, B         enthalten nach dem Aufruf die Anteile an den
                                Grundfarben
Hinweis         Bei Grafikkarten ohne Farbpalette wie z.B. der Hercules
                Monochrom Karte liefert GetPalette eine  Null für die
                Farbanteile.
Siehe auch      SetPalette, GetMaxColors


GetParaInteger                                                          Kernel

Deklaration     Function GetParaInteger(Var Line: String; Var OutVal:
                LongInt): Boolean
Funktion        Extrahiert einen LongInt aus dem in Line übergebenen String.
Parameter       Line            Enthält die Eingabezeile
                OutVal          Enthält nach der Ausführung den extrahierten
                                LongInt
Ergebnis        Zeigt an, ob aus der Eingabezeile ein LongInt extrahiert
                werden konnte (TRUE)
Hinweis         Durch die Ausführung von GetParaInteger wird der extrahierte
                Parameter verbraucht. Mit wiederholten Aufrufen können daher
                mehrere Parameter extrahiert werden.
                Die Verwendung von GetParaInteger ist nur in Verbindung mit
                den Funktionen GetInitFileListFirst und GetInitFileListNext
                sinnvoll. Ein  Programmierbeispiel findet sich dort.
Siehe auch      GetParaName, GetParaString, GetInitFileListFirst,
                GetInitFileListNext


GetParaName                                                             Kernel

Deklaration     Function GetParaName(Var Line: String; Var OutVal:
                ValueString): Boolean
Funktion        Extrahiert einen Namen aus dem in Line übergebenen String.
Parameter       Line            Enthält die Eingabezeile
                OutVal          Enthält nach der Ausführung den extrahierten
                                Namen
Ergebnis        Zeigt an, ob aus der Eingabezeile ein Name extrahiert werden
                konnte (TRUE)
Hinweis         Durch die Ausführung von GetParaName wird der extrahierte
                Parameter verbraucht. Mit wiederholten Aufrufen können daher
                mehrere Parameter extrahiert werden.
                Die Verwendung von GetParaName ist nur in Verbindung mit den
                Funktionen GetInitFileListFirst und GetInitFileListNext
                sinnvoll. Ein  Programmierbeispiel findet sich dort.

                               - 54 -


Siehe auch      GetParaInteger, GetParaString, GetInitFileListFirst,
                GetInitFileListNext


GetParaString                                                           Kernel

Deklaration     Function GetParaString(Var Line: String;
                Var OutVal: ValueString): Boolean
Funktion        Extrahiert einen geschützten String aus dem in Line
                übergebenen String.
Parameter       Line            Enthält die Eingabezeile
                OutVal          Enthält nach der Ausführung den geschützen
                                String
Ergebnis        Zeigt an, ob aus der Eingabezeile ein geschützter String
                extrahiert werden konnte (TRUE)
Hinweis         Durch die Ausführung von GetParaString wird der extrahierte
                Parameter verbraucht. Mit wiederholten Aufrufen können daher
                mehrere Parameter extrahiert werden.
                Die Verwendung von GetParaString ist nur in Verbindung mit den
                Funktionen GetInitFileListFirst und GetInitFileListNext
                sinnvoll. Ein  Programmierbeispiel findet sich dort.
Siehe auch      GetParaInteger, GetParaName, GetInitFileListFirst,
                GetInitFileListNext


GetTextLength                                                           Kernel

Deklaration     Function GetTextLength(InString: String):Integer
Funktion        Liefert die Länge in Pixeln, die ein Text auf dem
                Bildschirm einnehmen würde.
Parameter       InString        Der Text, dessen Länge ermittelt werden soll
Ergebnis        Liefert die Länge in Pixeln, die der Text InString auf dem
                Bildschirm einehmen würde.
Hinweis         Während die Höhe der Zeichen des skalierbaren Zeichensatzes
                direkt in Pixeln angegeben werden kann, ist es bei einem
                Proportionalzeichensatz nicht möglich, die Länge eines Textes
                vorher festzulegen. Sollte es trotzdem nötig sein, den
                Platzbedarf eines Textes zu ermitteln, kann diese Funktion
                verwendet werden.


GetTextSettings                                                         Kernel

Deklaration     Procedure GetTextSettings(Var Textinfo : TextSettingsType)
Funktion        Liefert Informationen über die Formatierung des skalierbaren
                Zeichensatzes
Parameter       Textinfo        Enthält nach der Ausführung Informationen
                                über die Formatierung des skalierbaren
                                Zeichensatzes.
Hinweis         Die Prozedur GetTextSettings liefert die Informationen über
                die aktuelle Formatierung des skalierbaren Zeichensatzes in
                Form eines Verbundtyps TextSettingsType. Die Informationen,
                die dieser Typ enthält, werden von den Prozeduren OutText
                und OutTextXY beachtet. Der Typ TextSettingsType ist im Kernel
                deklariert:
        TextSettingsType = Record
                             TheFont      :Word;
                             TheDirection : Word;
                             TheCharSizeX : Word;
                             TheCharSizeY : Word;
                             TheHoriz     : Word;

                               - 55 -


                             TheVert      : Word;
                           End;
                Die einzelnen Komponenten dieses Verbundtyps haben die
                Bedeutung:
                TheFont         Der aktuell benutzte Font. In der vorliegenden
                                Version von deLite kann nur ein einziger Font
                                während der Ausführung des Programmes geladen
                                werden. Dieser wird immer die Nummer Null
                                tragen. Der Eintrag Font wird durch die
                                prozedur SetTextStyle gesetzt. Auch dort kann
                                als Font nur eine Null angegeben werden. Die
                                Fontnummer Null kann auch als vordefinierte
                                Konstante DefaultFont angegeben werden.
                TheDirection    Gibt an, ob bei Textausgabe mittels OutText
                                und OutTextXY horizontal oder vertikal
                                geschrieben wird. Der Eintrag wird durch
                                SetTextDirection und SetTextStyle beeinflusst.
                CharSizeX       siehe CharSizeY
                CharSizeY       Gibt die Höhe eines Großbuchstaben des skalier-
                                baren ZeiChensatzes in Pixeln an. Der Wert
                                CharSizeX ist ein Verhältnisfaktor zu diesem
                                Wert. Ist CharSizeX kleiner als CharSizeY,
                                wird der Zeichensatz gestaucht ausgegeben. Ist
                                CharSizeX größer, wird der Zeichensatz
                                gestreckt. Hat CharSizeX den gleichen Wert wie
                                CharSizeY, wird der Zeichensatz als normaler
                                Proportionalzeichensatz ausgegeben. Der Eintrag
                                wird durch SetTextUserScale, SetTextHeight und
                                SetTextStyle beeinflusst.
                TheHoriz        Enthält die Ausrichtung des sklaierbaren
                                Zeichensatzes in horizontaler Richtung. Der
                                Eintrag kann die Werte LeftText (0),
                                CenterText (1) und RightText (2) annehmen. Zur
                                Erklärung der Bedeutung dieser Werte sei auf
                                SetTextJustify verwiesen. Der Eintrag wird
                                durch SetTextJustify beeinflusst.
                TheVert         Enthält die Ausrichtung des skalierbaren
                                Zeichensatzes in vertikaler Richtung. Der
                                Eintrag kann die Werte BottomText (0),
                                CenterText (1) und BottomText (2) annehmen.
                                Zur Erklärung der Bedeutung dieser Werte sei
                                auf SetTextJustify verwiesen. Der Eintrag wird
                                durch SetTextJustify beeinflusst.
Siehe auch      OutText, OutTextXY, SetTextDirection, SetTextHeight,
                SetTextJustify, SetTextUserScale, GetTextLength


GetTheViewPort                                                          API

Deklaration     Procedure GetTheViewPort(ID: Integer;
                Var Viewport: ViewPortType)
Funktion        Liefert den Viewport eines Klienten
Parameter       ID              Die ID des Klienten
                Viewport        enthält nach der Ausführung den Viewport
                Der Typ ViewPortType ist im Kernel wie folgt definiert:

        TYPE ViewPortType = RECORD
                              x1,y1,x2,y2: integer;
                            End;

Siehe auch      SetTheViewPort

                               - 56 -




GetX                                                                    Kernel

Deklaration     Function GetX: Integer
Funktion        Liefert die X-Koordinate des Grafikcursors
Siehe auch      GetY, MoveTo, MoveRel, LineTo, LineRel


GetY                                                                    Kernel

Deklaration     Function GetY: Integer
Funktion        Liefert die Y-Koordinate des Grafikcursors
Siehe auch      GetX, MoveTo, MoveRel, LineTo, LineRel


HideMouse                                                               Kernel

Deklaration     Procedure HideMouse
Funktion        Versteckt die Maus
Hinweis         Während Grafikoperationen muß die Maus vor dem Überschreiben
                geschützt werden. Zu diesem Zweck wird vor jeder
                Grafikoperation automatisch der Mauszeiger entfernt und
                anschließend neu gezeichnet. Möchte man sehr viele Grafik-
                operationen hintereinander ausführen, kann es sein, daß das
                Retten des Mauszeigers mehr Zeit in Anspruch nimmt als die
                eigentlichen Grafikoperationen. Dann empfiehlt es sich, die
                Maus vor Beginn der ersten Grafikoperation mit HideMouse zu
                verstecken und hinterher wieder mit ShowMouse sichtbar zu
                machen.
Siehe auch      ShowMouse


KernelError                                                             Kernel

Deklaration     Function KernelError : Integer
Funktion        Liefert den Fehlerstatus der letzten Kernel-Operation
Ergebnis        Der zurückgelieferte Integerwert hat die im Anhang B
                aufgelistete Bedeutung
Hinweis         Der Fehlerstatus wird nach dem Aufruf von KernelError gelöscht


Line                                                                    Kernel

Deklaration     Procedure Line(x1,y1,x2,y2 : Integer; Color : Byte)
Funktion        Zeichnet eine Linie
Beispiel                Line(0 ,0 ,PortMaxX ,PortMaxY,15);
                zeichnet eine weiße diagonale Linie von links oben nach
                rechts unten.
Siehe auch      GetLinePattern, SetLinePattern


LineRel                                                                 Kernel

Deklaration     Procedure LineRel(X, Y: Integer)
Funktion        Zeichnet eine Linie relativ zur aktuellen Position
                des Grafikcursors
Parameter       X, Y    Die relative Differenz zur Cursorposition
Hinweis         LineRel verwendet den durch SetLinePattern gesetzten
                Linienstil und die durch SetColor gesetzte Farbe. Der
                Grafikcursor wird auf den Endpunkt der Linie gesetzt.

                               - 57 -


Siehe auch      GetX, GetY, LineTo, MoveRel, MoveTo, SetColor, SetLinePattern


LineTo                                                                  Kernel

Deklaration     Procedure LineTo(X, Y: Integer)
Funktion        Zeichnet eine Linie von der aktuellen Position des
                Grafikcursors zum angegebenen Punkt
Parameter       X, Y    Die Koordinaten des Zielpunktes
Hinweis         LineTo verwendet den durch SetLinePattern gesetzten Linienstil
                und die durch SetColor gesetzte Farbe. Der Grafikcursor wird
                auf den Endpunkt der Linie gesetzt.
Siehe auch      GetX, GetY, LineRel, MoveRel, MoveTo, SetColor, SetLinePattern


MoveRel                                                                 Kernel

Deklaration     Procedure MoveRel(X, Y: Integer)
Funktion        Bewegt den Grafikcursor relativ zur aktuellen Position
Parameter       X, Y    Die Koordinatendifferenz
Hinweis         Die Position des Grafikcursors bezieht sich immer auf den
                aktuellen Viewport. Der Grafikcursor selbst unterliegt nicht
                dem Clipping.
Siehe auch      GetX, GetY, LineRel, LineTo, MoveTo, SetColor


MoveTo                                                                  Kernel

Deklaration     Procedure MoveTo(X, Y: Integer)
Funktion        Setzt den Grafikcursor auf die angegebene Position
Parameter       X, Y    Die neuen Koordinaten
Hinweis         Die Position des Grafikcursors bezieht sich immer auf den
                aktuellen Viewport
Siehe auch      GetX, GetY, LineRel, LineTo, MoveRel, SetColor


OnLineHelp                                                              API

Deklaration     Procedure OnLineHelp(topic: String)
Funktion        Ruft die interaktive Hilfe auf
Parameter       topic   Das Hilfestichwort
Hinweis         Die Menüsteuerung und die Dialoge bedienen sich dieser
                Funktion zur Realisierung der kontextabhängigen Hilfe. Das
                Hilfestichwort wird in der Datei online.hlp gesucht und ggf.
                der nach dem Stichwort folgende Text ausgegeben. Sollte die
                Datei nicht existieren oder das Stichwort nicht gefunden
                werden, wird eine entsprechende Fehlermeldung ausgegeben.
                Das Stichwort muß in der Hilfedatei in eckigen Klammern
                geschrieben werden. Stichworte werden vor dem Aufruf der
                Hilfsfunktion von evtl. vorhandenen Ampersand-Symbolen befreit.
Beispiel
        [Load File]
        Mit dieser Funktion laden Sie
        eine neue Datei zur Bearbeitung.
        Gegebenenfalls werden Sie darauf
        hingewiesen, daß die alte Datei
        überschrieben wird

        [Save File]
        Speichert die im Speicher
        befindliche Datei.

                               - 58 -



        Dieser Auszug aus der Hilfedatei online.hlp enthält Informationen zu
        den Stichworten Load File und Save File. Die Texte sollten nicht mehr
        als 34 Spalten und 12 Zeilen enthalten.


OpenMainApplication                                                     API

Deklaration     Function OpenMainApplication(EventHandler: EventReceiveProc;
                modus: Integer; Name: NameString): Integer
Funktion        Öffnet die Hauptapplikation
Parameter       EventHandler    Die Empfangsprozedur
                modus           Modus der Hauptapplikation. Wird hier anstatt
                                0 der Wert APP_NOFONT angegeben, wird kein
                                skalierbarer Zeichensatz geladen
                Name            Der Name der Applikation
Ergebnis        Das Ergebnis ist 0, falls die Hauptapplikation erfolgreich
                geöffnet werden konnte, und ungleich Null, wenn ein Fehler
                auftrat. Die möglichen Fehler sind im Anhang spezifiziert
Hinweis         Der angegebene Name wird verwendet, um die Dateinamen für die
                Initialisierungsdatei, die Menübeschreibung und die allgemeine
                Hilfe zu erzeugen. Daher stehen diese Funktionen erst nach dem
                Öffnen der Hauptapplikation zur Verfügung.
                OpenMainApplication prüft zunächst, ob es zum ersten Mal
                ausgeführt wird. Danach wird versucht, die Menübeschreibung
                einzulesen. Anschließend wird die Initialisierungsdatei
                geöffnet und der Eintrag für den verwendeten Grafiktreiber
                gesucht. Falls als modus nicht APP_NOFONT angegeben wurde,
                wird zusätzlich nach dem Eintrag für den skalierbaren
                Zeichensatz gesucht und der Zeichensatz geladen. Sollte bis
                hierhin kein Fehler aufgetreten sein, wird in den Grafikmodus
                geschaltet und der Menübalken angezeigt.
Beispiel
        Begin
          StillRunning := true;
          LaunchResult := OpenMainApplication(HandleMsg,
                                              APP_NOFONT,
                                              ProjektName);

          If LaunchResult = 0 then        { erfolgreich gestartet }
          begin
            while StillRunning Do
              begin
                GetEvent(MyEvent);
                DispatchMessage(MyEvent);
              end;
            CloseMainApplication;
          end
          Else
            Writeln('Programm kann nicht gestartet werden.
                     Fehler:',LaunchResult);
        End.

        Das Beispiel zeigt ein typisches Hauptprogramm. Die Empfangsprozedur
        HandleMsg wurde angemeldet und das Flag APP_NOFONT wurde angegeben,
        um zu verhindern, daß ein skalierbarer Zeichensatz geladen wird. Nach
        der Anmeldung tritt das Programm in eine Schleife ein, die fortwährend
        Botschaften mit GetEvent holt und mit DispatchMessage weiterleitet.
Siehe auch      CloseMainApplication, GetEvent, DispatchMessage



                               - 59 -


OpenSubApplication                                                      API

Deklaration     Function  OpenSubApplication(EventHandler: EventReceiveProc;
                Filter: Integer; Name: NameString; x1,y1,x2,y2: Integer):
                Integer
Funktion        Meldet einen Klienten an und und weist ihm einen Viewport zu
Parameter       EventHandler    Die Empfangsprozedur des Klienten
                Filter          Wird hier anstatt 0 der Wert APP_NOFRAME
                                angegeben, wird um den Viewport des Klienten
                                kein Rahmen gezeichnet.
                Name            Der Name des Klienten
                x1,y1,x2,y2     Die Koordinaten des Viewports
Ergebnis        Zurückgeliefert wird die Identifikationsnummer des Klienten.
                Konnte der Klient nicht angemeldet werden, etwa weil die
                maximale Anzahl von Klienten bereits erreicht war, wird -1
                zurückgeliefert.
Hinweis         Der Viewport des Klienten wird den Viewport der
                Hauptapplikation, der nach wie vor aktiv ist, überlappen.
                Deshalb muß der Viewport der Hauptapplikation beim Einsatz
                weiterer Klienten deaktiviert werden.
Siehe auch      CloseSubApplication, SuspendApplication, DispatchMessage


OpenWindow                                                              API

Deklaration     Procedure OpenWindow(x1,y1,x2,y2 : integer)
Funktion        Öffnet ein Fenster
Parameter       x1,y1   Koordinaten der linken oberen Ecke
                x2,y2   Koordinaten der rechten unteren Ecke
Hinweis         Vor dem Öffnen des Fensters wird der vom Fenster zu
                verdeckende Bildschiminhalt gerettet. Nach dem Schließen
                mit CloseWindow wird der Bildschirminhalt rekonstruiert.
                Während das Fenster geöffnet ist, ist der aktuelle Viewport
                auf das Fenster gesetzt. Das Fenster besitzt einen Rahmen und
                eine in der Initialisierungsdatei festgelegte Hintergrundfarbe.
                Fenster sollten nur zur temporären Anzeige von Informationen
                dienen und grundsätzlich einen Aufruf der Prozedur WaitConfirm
                vor dem Befehl zum Schließen des Fensters enthalten.
                WaitConfirm empfängt alle Ereignisse und stellt so sicher,
                daß kein Klient aktiv werden kann, während das Fenster offen
                ist. Beim Empfang von ESCAPE, ENTER oder der Betätigung einer
                Maustaste kehrt WaitConfirm zurück.
Beispiel
                OpenWindow(10,10,200,200);
                Line(0,0,190,190,15);
                WaitConfirm;
                CloseWindow;

Siehe auch      WaitConfirm, CloseWindow


OutTextAPI                                                              Kernel

Deklaration     Procedure OutTextAPI(x,y : Integer; InString : String;
                Color, Attrib : Byte)
Funktion        Gibt einen Text im aktuell gesetzten Viewport aus
Parameter       x,y             Koordinaten
                InString        Der Text
                Color   Farbe
                Attrib  Das Attribut. Möglich sind folgende Werte
                        0       Textausgabe normal

                               - 60 -


                        1       Text unterstrichen
Hinweis         Es wird der (nicht skalierbare) Standardzeichensatz verwendet.
Siehe auch      FontX, FontY


OutText                                                                 Kernel

Deklaration     Procedure OutText(str: String)
Funktion        zeichnet einen Text mit Hilfe des skalierbaren Zeichensatzes
Parameter       str             Der auszugebende Text
Hinweis         Der Text wird ab der Cursorposition unter Berücksichtigung
                der gesetzten  Formatierung und Ausrichtung ausgegeben.
Siehe auch      OutTextXY, SetTextHeight, SetTextJustify, SetTextStyle,
                SetTextUserScale, GetTextSettings, GetTextLength


OutTextXY                                                               Kernel

Deklaration     Procedure OutTextXY(X, Y: Integer; str: String)
Funktion        zeichnet einen Text mit Hilfe des skalierbaren Zeichensatzes
Parameter       X,Y             Die Koordinaten
                str             Der auszugebende Text
Hinweis         Der Text wird unter Beachtung der Formatierung und der
                Textausrichtung durch die Prozeduren SetTextStyle und
                SetTextJustify ausgegeben. Der Grafikcursor wird hinter den
                letzten Buchstaben des Textes plaziert. Das passiert auch dann,
                wenn der Text den aktuellen Viewport überschreitet. Ein
                Zeilenumbruch findet nicht statt.
Siehe auch      SetTextDirection, SetTextHeight, SetTextJustify, SetTextStyle,
                SetTextUserScale, GetTextSettings, GetTextLength


PortMaxX                                                                Kernel

Deklaration     Function PortMaxX : Integer
Funktion        Liefert die horizontale Größe des aktuellen Viewports
Ergebnis        Das Ergebnis vom Typ Integer entspricht der größten Koordinate
                in X-Richtung des aktuellen Viewports. Die kleinste Koordinate
                ist stets 0.
Hinweis         Diese Funktion sollte für Zeichenoperationen innerhalb eines
                Fensters bzw. Viewports verwendet werden, die eine Anpassung
                erforderlich machen.
Siehe auch      PortMaxY, GetMaxX, GetMaxY


PortMaxY                                                                Kernel

Deklaration     Function PortMaxY : Integer
Funktion        Liefert die vertikale Größe des aktuellen Viewports
Ergebnis        Das Ergebnis vom Typ Integer entspricht der größten
                Koordinate in X-Richtung des aktuellen Viewports. Die kleinste
                Koordinate ist stets 0.
Hinweis         Diese Funktion sollte für Zeichenoperationen innerhalb eines
                Fensters bzw. Viewports verwendet werden, die eine Anpassung
                erforderlich machen.
Siehe auch      PortMaxX, GetMaxX, GetMaxY


PostMessage                                                             API

Deklaration     Procedure PostMessage(TheMessage: EventTyp; TheID: integer)

                               - 61 -


Funktion        Sendet eine Nachricht an einen bestimmten Klienten
Parameter       TheMessage      Die Nachricht
                TheID           Die ID des Klienten
Hinweis         Beim Einsatz mehrerer Klienten kann mit dieser Prozedur
                zwischen den Klienten kommuniziert werden, etwa um einem
                Klienten die Botschaft DoRedraw zum Neuzeichnen zu senden.
Siehe auch      GetEvent, DispatchMessage, OpenSubApplication,
                SuspendApplication


PutEvent                                                                Kernel

Deklaration     Procedure PutEvent(Event: EventTyp)
Funktion        schreibt ein Ereignis in die Ereigniswarteschlange
Parameter       Event           Die Nachricht
Hinweis         Mit PutEvent können maximal 16 Ereignisse in die Warteschlange
                geschrieben werden. Ein so in die Warteschlange aufgenommenes
                Ereignis wird in der Regel das nächste Ereignis sein, das von
                GetEvent geliefert wird.
Siehe auch      GetEvent


Rectangle                                                               Kernel

Deklaration     Procedure Rectangle(x1,y1,x2,y2 : Integer; Color : Byte)
Funktion        Zeichnet ein nicht ausgefülltes Rechteck
Parameter       x1,y1   Koordinaten der linken oberen Ecke
                x2,y2   Koordinaten der rechten unteren Ecke
                Color   Farbe des Rechtecks

ReplaceMenuItem                                                         API

Deklaration     ReplaceMenuItem(Menu: hMenu; ID: MenueID; NewItem: String;
                IDNewItem: MenueID; NewHotKey: char)
Funktion        Ersetzt einen Menüeintrag durch einen anderen
Parameter       Menu            Zeiger auf das Menü
                ID              Identifikationsnummer des zu ersetzenden
                                Menüeintrages
                NewItem         Titel des neuen Menüeintrages
                IDNewItem       Identifikationsnummer des neuen Menüeintrages
                NewHotKey       Abkürzungstaste (Hotkey) des neuen
                                Menüeintrages
Hinweis         Der Titel des neuen Menüeintrages sollte ein Ampersand-Symbol
                zur Kennzeichnung des zu unterstreichenden Buchstabens als
                Hinweis auf die Abkürzungstaste enthalten.
Beispiel        ReplaceMenuItem(GetMenu, 101, 'Zoom &Picture', 102, 'P');
                ersetzt den Eintrag 101 im Hauptmenü durch einen neuen
                Eintrag mit der gleichen Identifikationsnummer und der
                Abkürzungstaste "P".
Siehe auch      GetMenu, EnableMenuItem, CheckMenuItem


SetBackColor                                                            Kernel

Deklaration     Procedure SetBackColor(NewColor: Word)
Funktion        Setzt die Hintergrundfarbe
Parameter       NewColor        Die neue Hintergrundfarbe
Hinweis         Dieser Aufruf kann nur auf Karten mit Farbpalette
                funktionieren. Die Hintergrundfarbe wird dabei durch
                Vertauschen der Paletteneinträge erzeugt.


                               - 62 -



SetColor                                                                Kernel

Deklaration     Procedure SetColor(DieFarbe : Byte)
Funktion        Setzt die aktuelle Zeichenfarbe
Parameter       DieFarbe        Die aktuelle Zeichenfarbe
Hinweis         Diese Prozedur setzt die aktuelle Zeichenfarbe für die
                Prozeduren LineRel, LineTo, MoveRel, MoveTo, OutText und
                OutTextXY. Die Defaultfarbe ist auf jeder Grafikkarte weiss.
Siehe auch      LineRel, LineTo, OutText, OutTextXY


SetLinePattern                                                          Kernel

Deklaration     Procedure SetLinePattern(Pattern: Word)
Funktion        Setzt ein neues Linienmuster
Parameter       Das niederwertigste Byte enthält das Linienmuster.
                Vordefiniert sind die Muster
                SolidLn         durchgezogene Linie
                DottedLn        gepunktete Linie
                CenterLn        strichpunktierte Linie
                DashedLn        gestrichelte Linie
Hinweis         Vorbelegt ist das Muster SolidLn
Siehe auch      GetLinePattern, Line


SetMousePos                                                             Kernel

Deklaration     Procedure SetMousePos(x,y : Integer)
Funktion        Setzt die Koordinaten der Maus
Parameter       x,y     absolute Koordinaten der neuen Mausposition
Hinweis         Die Koordinaten beziehen sich nicht auf den aktuell
                gesetzten Viewport.
Siehe auch      SetMouseRange


SetMouseRange                                                           Kernel

Deklaration     Procedure SetMouseRange(x1,y1,x2,y2 : Integer)
Funktion        definiert den Bewegungsbereich der Maus
Parameter       x1,y1   Koordinaten der linken oberen Ecke des Bereiches
                x2,y2   Koordinaten der rechten unteren Ecke des Bereiches
Hinweis         Die Angabe der Koordinaten erfolgt absolut, wird also nicht
                auf den aktuell gesetzten Viewport bezogen.
Beispiel        SetMouseRange(0 ,0 ,GetMaxX , GetMaxY)
                definiert die gesamte Bildschirmfläche als Bewegungsbereich
                der Maus.
Siehe auch      SetMousePos


SetPalette                                                              Kernel

Deklaration     Procedure SetPalette(ThePalette,R,B,G: Byte)
Funktion        Setzt einen Paletteneintrag neu
Parameter       ThePalette              Index des Paletteneintrages
                R, G, B         Anteile der Grundfarbwerte
Hinweis         Bei Grafikkarten ohne Farbpalette bleibt ein Aufruf von
                SetPalette ohne Wirkung.
Siehe auch      GetPalette, GetMaxColors



                               - 63 -


SetPoint                                                                Kernel

Deklaration     Procedure SetPoint(x,y : Integer; Color: Byte)
Funktion        Zeichnet einen Punkt
Parameter       x,y     Koordinaten des Punktes
                color   Farbe des Punktes


SetProjectName                                                          Kernel

Deklaration     Procedure SetProjectName(TheName: String)
Funktion        Macht den Projektnamen dem System bekannt
Parameter       TheName         Der Projektname
Hinweis         Der Projektname wird verwendet, um die Dateinamen für die
                Initialisierungs-, Resource- und Hilfedateien zu erzeugen.
                Die Prozedur OpenMainApplication bedient sich dieser Prozedur,
                um den Projektnamen bekannt zu machen. Möchte man auf die
                Initialisierungsdatei zugreifen, bevor die Prozedur
                OpenMainApplication aufgerufen wurde, muß der Projektname
                explizit mit SetProjectName bekannt gemacht werden. Diese
                Prozedur kann auch dazu verwendet werden, auf fremde
                Initialisierungsdateien zuzugreifen.
Siehe auch      OpenMainApplication


SetTextDirection                                                        Kernel

Deklaration     Procedure SetTextDirection(Dir: Word)
Funktion        Legt fest, ob der skalierbare Zeichensatz über die Prozeduren
                OutText und OutTextXY horizontal (von links nach rechts) oder
                vertikal (von unten nach oben) ausgegeben werden soll.
Parameter       Dir     Richtungsangabe. Möglich sind folgende Werte
                                0       horizontale Richtung
                                1       vertikale Richtung
Hinweis         Der Parameter Dir legt fest, in welcher Richtung der skalier-
                bare Font ausgegeben werden soll. Dazu sind die zwei
                Konstanten HorizDir (0) und VertDir (1) vordefinert.
                HorizDir        Der Text wird in horizontaler Ausrichtung
                                (von links nach rechts) ausgebeben.
                VertDir         Der Text wird in verikaler Ausrichtung
                                (von unten nach oben) ausgegeben.
                Die Voreinstellung ist HorizDir (0).
Siehe auch      GetTextSettings, OutText, OutTextXY, SetTextHeight,
                SetTextJustify, SetTextUserScale, GetTextLength


SetTextHeight                                                           Kernel

Deklaration     Procedure SetTextHeight(CharSize : Word)
Funktion        Legt die Größe des skalierbaren Zeichensatzes für die Ausgabe
                mit den Prozeduren OutText und OutTextXY fest.
Parameter       CharSize                Größe der Zeichen
Hinweis         CharSize gibt die Größe eines Großbuchstabens des skalierbaren
                Zeichensatzes in Pixeln an. Wählt man für die Größe z.B. 32,
                wird ein großes 'M' 32 Pixel an Höhe auf dem Bildschirm ein-
                nehmen.
Siehe auch      GetTextSettings, OutText, OutTextXY, SetTextDirection,
                SetTextJustify, SetTextUserScale, GetTextLength


SetTextJustify                                                          Kernel

                               - 64 -



Deklaration     Procedure SetTextJustify(Horiz, Vert: Word)
Funktion        Legt die Ausrichtung eines Textes zu seiner Grundlinie für
                die Ausgabe mit den Prozeduren OutText und OutTextXY fest.
Parameter       Horiz   horizontale Ausrichtung
                        0       Linksbündige Ausgabe
                        1       Zentrierte Ausgabe
                        2       Rechtsbündige Ausgabe
                Vert    vertikale Ausrichtung
                        0       Ausgabe auf der Grundlinie
                        1       Ausgabe zentriert zur Grundlinie
                        2       Ausgabe unter der Grundlinie
Hinweis         Bei der Ausgabe eines Textes mit Hilfe der Prozeduren OutText
                und OutTextXY wird durch die Angabe der Koordinaten X und Y
                bzw. des Grafikcursors festgelegt, an welcher Stelle die
                Textausgabe erfolgen soll. Die Ausrichtung des Textes bestimmt
                dabei, wie die Koordinaten des Ausgabepunktes interpretiert
                werden. Für die horizontale Ausrichtung gilt:
                0       Der Text wird linksbündig, das heisst ab der Stelle
                        X,Y ausgegeben.
                1       Der Text wird zentriert ausgegeben, das heisst der
                        Punkt X,Y stellt den Mittelpunkt des Textes dar
                2       Der Text wird rechtsbündig ausgegeben, das heisst der
                        Punkt X,Y markiert das Ende des Textes.
                Die Grundlinie verläüft vom Punkt X,Y ausgehend in Schreib-
                richtung. Für die vertikale Ausrichtung gilt
                0       Normale Ausgabe. Die Buchstaben stehen auf der
                        Grundlinie.
                1       Zentrierte Ausgabe. Die Grundlinie geht durch die
                        Mitte der Großbuchstaben.
                2       Hängende Ausgabe. Die Großbuchstaben hängen an der
                        Grundlinie
                Es stehen die vordefinierten Konstanten LeftText (0),
                CenterText (1) und RightText (2) für die horizontale- und
                BottomText (0), CenterText (1) und TopText (2) für die
                vertikale Ausrichtung zur Verfügung. Die Voreinstellungen
                sind LeftText (horizontal) und BottomText (vertikal).
Siehe auch      GetTextSettings, OutText, OutTextXY, SetTextDirection,
                SetTextHeight, SetTextUserScale, GetTextLength


SetTextStyle                                                            Kernel

Deklaration     Procedure SetTextStyle(Font, Direction : Word; CharSize : Word)
Funktion        Setzt das Format für die Textausgabe über die Prozeduren
                OutText und OutTextXY.
Parameter       Font    Der Zeichensatz, für den die Formate gelten
                Direction       Die Ausgaberichtung
                CharSize        Die Größe des Zeichensatzes
Hinweis         Die aktuelle Version von deLite erlaubt nur einen einzigen
                Font zu laden und zu benutzen. Eine spätere Version soll
                dagegen mehrere Fonts gleichzeitig ermöglichen. Diesem
                Sachverhalt trägt der Parameter Font Rechnung. Verwenden Sie
                in der vorliegenden Version für diesen Parameter immer den
                vordefinierten Wert DefaultFont (0).
                Mit dem Parameter Direction können Sie bestimmen, in welcher
                Richtung der skalierbare Zeichensatz ausgegeben wird. Es
                können die vordefinierten Werte HorizDir (0) und VertDir (1)
                angegeben werden. Sehen Sie dazu auch die Erklärungen zu der
                Prozedur SetTextDirection.
                Mit CharSize bestimmen Sie, wie groß der Text auf dem

                               - 65 -


                Bildschirm ausgegeben wird. Die Angabe entspricht dabei der
                Pixelgröße eines Großbuchstaben. Beachten Sie bitte auch die
                Erklärungen zur Prozedur SetTextHeight.
Siehe auch      GetTextSettings, OutText, OutTextXY, SetTextHeight,
                SetTextJustify, SetTextUserScale, GetTextLength


SetTextUserScale                                                        Kernel

Deklaration     SetTextUserScale(CharSizeX, CharSizeY : Word)
Funktion        Setzt unabhängige Skalierungsfaktoren für die X- und
                Y-Ausdehnung des skalierbaren Zeichensatzes. Der Parameter
                wirkt sich auf die Prozeduren OutText und OutTextXY aus.
Parameter       CharSizeX               Breite der Buchstaben
                CharSizeY               Höhe der Buchstaben
Hinweis         Mit CharSizeY bestimmen Sie, wieviele Pixel ein Großbuchstabe
                des skalierbaren Zeichensatzes auf dem Bildschirm einnimmt.
                Da die mitgelieferten Zeichensätze Proportionalschriften sind,
                kann man den Parameter CharSizeX nicht direkt als Zeichenbreite
                interpretieren. Vielmehr stellt dieser Parameter einen
                Verhältnisfaktor zur Höhe der Zeichen dar. Möchten Sie, daß
                der Zeichensatz unverzerrt ausgegeben wird, wählen Sie den
                selben Wert wie CharSizeY (Dies entspricht einem Aufruf von
                SetTextHeight). Möchten Sie den Zeichensatz stauchen, muss
                der Wert CharSizeX kleiner sein als CharSizeY. Zum Dehnen
                wählen Sie CharSizeX größer als CharSizeY.
                Die Funktion GetTextLenght ermittelt die Länge in Pixeln,
                die ein String auf dem Bildschirm einnimmt.
Siehe auch      GetTextSettings, OutText, OutTextXY, SetTextDirection,
                SetTextHeight, SetTextJustify, GetTextLength


SetTheViewPort                                                          API

Deklaration     Procedure SetTheViewPort(ID: integer)
Funktion        Setzt den Viewport eines Klienten
Parameter       ID              Identifikationsnummer des Klienten
Hinweis         Vor dem Aufruf der Empfangsprozedur eines Klienten wird sein
                Viewport aktiviert. Mit Hilfe dieser Prozedur kann ein
                Klient auch den Viewport eines anderen Klienten beschreiben.
Siehe auch      GetTheViewPort

SetTimer                                                                Kernel

Deklaration     Function  SetTimer(ClientId : Integer; Mode,
                MiliSecs : Word) : Integer
Funktion        Startet einen Systemtimer
Parameter       ClientID        Identifikationsnummer zur Unterscheidung der
                                einzelnen Timer
                Mode            Modus, mit dem der Timer gestartet wird.
                                Möglich sind die Werte:
                                1       SingleShot Modus
                                2       ContinuousShots Modus
                MiliSecs        Zeitdauer in Milisekunden
Ergebnis        Das Ergebnis vom Typ Integer stellt die intern verwendetete
                Kanalnummer des Timers dar und liegt im Bereich von 2 bis 16.
                Falls der Rückgabewert -1 geliefert wird, sind alle Timer
                belegt und es konnte kein neuer Timer mehr gestartet werden.
                In diesem Fall müsen Sie warten, bis wieder ein Timer frei
                wird, oder Sie müssen explizit einen Timer mit StopTimer
                freigegen.

                               - 66 -


Hinweis         DeLite stellt dem Anwenderprogramm 15 voneinander unabhängige
                Systemtimer zur Verfügung. Nachdem ein Systemtimer mit
                SetTimer gestartet wurde und die Zeitdauer MiliSecs vergangen
                ist, wird ein Event mit der Klasse TimerEvent generiert. Der
                Selektor ClientID des Timerevents enhält dann die bei SetTimer
                vereinbarte Ientifikationsnummer. Werden mehrere Timer von
                verschiedenen Klienten gestartet, können die generierten
                Events anhand der Idendifikation unterschieden werden. Der
                Selektor TimerChannel des Events enhält die Kanalnummer des
                Timers, eine Zahl zwischen 2 und 16. Damit können sogar
                Timer unterschieden werden, die von dem selben Klienten
                gestartet wurden. Die Kanalnummer ist dieselbe, die als
                Rückgabewert der Funktion geliefert wird. Sie wird auch zum
                Stoppen des Timers mit StopTimer benötigt.
                Die Systemtimer von deLite arbeiten in zwei Modi. Im Modus
                SingleShot generiert der Timer nach Ablauf der Zeitspanne
                MiliSecs ein einzelnes Timerevent und gibt sich danach
                selbstätig frei. Sie können den Timer allerdings vor Ablauf
                seiner Zeit mit StopTimer freigeben. Das kann für die
                Überwachung eines Timeout sinvoll sein.
                Im Modus ContinuousShots generiert der Timer in periodischen
                Zeitabständen Timervents. Die Zeitdauer zwischen zwei Events
                beträgt den in MiliSecs übergebenen Wert in Milisekunden.
                Ein mit diesem Modus gestarteter Timer muß mit StopTimer
                explizit freigegeben werden.
Siehe auch      StopTimer, GetEvent


ShowMouse                                                               Kernel

Deklaration     Procedure ShowMouse
Funktion        Macht den Mauszeiger wieder sichtbar
Hinweis         Nachdem der Mauszeiger durch einen Aufruf von HideMouse
                versteckt wurde, kann der Mauszeiger durch ShowMouse wieder
                sichtbar gemacht werden.
                Beachten Sie, daß mehrere Aufrufe von HideMouse genauso
                viele Aufrufe von ShowMouse erforden, um den Mauszeiger
                wieder erscheinen zu lassen.
Siehe auch      HideMouse


StopTimer                                                               Kernel

Deklaration     Procedure StopTimer(ClientID, TimerChannel : Integer)
Funktion        Stoppt einen zuvor mit SetTimer gestarteten Systemtimer
Parameter       ClientID        Die beim Starten des Timers mit SetTimer
                                vereinbarte Identifikationsnummer
                TimerChannel    Interne Kanalnummer des Timers. Dieser Wert
                                wurde Ihnen als Rückgabewert der Funktion
                                SetTimer geliefert
Siehe auch      SetTimer


SuspendApplication                                                      API

Deklaration     Procedure SuspendApplication(ID: integer)
Funktion        Deaktiviert den Viewport eines Klienten
Parameter       ID              Identifikationsnummer des Klienten
Hinweis         Mausereignisse werden einem Klienten zugeschickt, wenn sie
                innerhalb seines Viewports stattgefunden haben. Mit der
                Prozedur SuspendApplication kann der Dispatcher angewiesen

                               - 67 -


                werden, den Viewport eines Klienten bei der Verteilung von
                Mausereignissen nicht zu berücksichtigen. ActivateApplication
                hebt die Wirkung eines Aufrufs von SuspendApplication wieder
                auf.
Siehe auch      ActivateApplication, GetMainID


SysWindow                                                               API

Deklaration     Procedure SysWindow(x,y: integer; errtext: string)
Funktion        Gibt einen Text in einem Fenster aus
Parameter       x,y     Position des Fensters
                errtext Der Text
Hinweis         Die Prozedur SysWindow wartet nach dem Öffnen des Fensters
                und der Ausgabe des Textes auf eine Bestätigung des Benutzers.
                Bis auf die andere Hintergrundfarbe unterscheidet sich diese
                Prozedur nicht von ErrWindow.
Siehe auch      OpenWindow, WriteWin, ErrWindow


UpCase                                                                  Kernel

Deklaration     Function UpCase(InChar: Char): Char
Funktion        Liefert zu einem Zeichen den entsprechenden Großbuchstaben
Parameter       InChar  Das Zeichen
Ergebnis        Zurückgeliefert wird der Großbuchstabe.
Hinweis         Diese Funktion überlagert die Turbo-Pascal Funktion Upcase
                und besitzt zusätzlich die Fähigkeit, auch Umlaute und
                diakritische Zeichen konvertieren zu können.
Siehe auch      UpString


UpString                                                                Kernel

Deklaration     Procedure UpString(Var TheString: String)
Funktion        Wandelt einen String in Großbuchstaben
Parameter       TheString       enthält den zu wandelnden String
Hinweis         Diese Prozedur bedient sich der Funktion UpCase und ist daher
                auch in der Lage, Umlaute und diakrische Zeichen zu
                konvertieren.
Siehe auch      UpCase


WaitConfirm                                                             API

Deklaration     Procedure WaitConfirm
Funktion        Liest solange Ereignisse, bis ENTER, ESCAPE oder eine
                Maustaste betätigt werde
Hinweis         Diese Prozedur wird dazu verwendet, bei einem geöffneten
                Fenster auf eine Bestätigung des Anwenders zu warten, bevor
                das Fenster geschlossen wird. Die Verwendung von WaitConfirm
                stellt sicher, daß keine Klienten aktiv werden können,
                während das Fenster geöffnet ist.
Siehe auch      OpenWindow


WriteWin                                                                API

Deklaration     Procedure WriteWin(str: string; x,y: integer; Color: Byte)
Funktion        Gibt einen Text im aktuell gesetzten Viewport aus
Parameter       str             Der Text

                               - 68 -


                x,y             Position
                Color   Farbe
Hinweis         Die Position wird hier nicht in Pixelkoordinaten, sondern in
                Cursorkoordinaten angegeben. X und Y geben also Spalte und
                Zeile an.
Beispiel                WriteWin('hello world',1,1,15)
                druckt den angegebenen Text in weißer Farbe in die erste
                Zeile des Viewports.
Siehe auch      OutTextAPI


XORBAR                                                                  Kernel

Deklaration     Procedure XORBar(x1,y1,x2,y2: Integer)
Funktion        Invertiert eine ausgefüllte rechteckige Fläche
Parameter       x1,y1           Koordinaten der linken oberen Ecke
                x2,y2           Koordinaten der rechten unteren Ecke
Hinweis         XORBar invertiert eine ausgefüllte rechteckige Fläche in
                der Graphik. Dazu wird eine Exklusiv-Oder Verknüpfung
                verwendet. Wird XORBar noch einmal mit den gleichen
                Parametern aufgerufen, wird durch die doppelte Invertierung
                der Ausgangszustand der Graphik wieder hergestellt. Dieser
                Effekt kann z.B. zur Selektierung eines Objektes benutzt
                werden.
Beispiel
                XORBar(0,0,100,100); {Recheck invertiert}
                WaitConfirm;
                XORBar(0,0,100,100); {Invertierung wieder aufgeheben }

Siehe auch      Bar, XORLine, XORRectangle


XORLine                                                                 Kernel

Deklaration     Procedure XORLine(x1,y1,x2,y2 : Integer; Thickness : Byte)
Funktion        Invertiert eine Linie
Parameter       x1,y1           Startpunkt der Linie
                x2,y2           Endpunkt der Linie
Hinweis         XORLine invertiert eine Linie in der Graphik. Dazu wird eine
                Exklusiv-Oder Verknüpfung verwendet. Wird XORLine noch einmal
                mit den gleichen Parametern aufgerufen, wird durch die
                doppelte Invertierung der Ausgangszustand der Graphik wieder
                hergestellt. Dieser Effekt kann z.B. zur Selektierung eines
                Objektes benutzt werden.
Beispiel
                XORLine(0,0,100,100); {Linie invertieren }
                WaitConfirm;
                XORLine(0,0,100,100); {Invertierung wieder aufheben }

Siehe auch      Line, XORBar, XORRectangle


XORRectangle                                                            Kernel

Deklaration     Procedure XORRectangle(x1,y1,x2,y2 : Integer; Thickness : Byte)
Funktion        Invertiert ein nicht ausgefülltes Rechteck
Parameter       x1,y1           linke obere Ecke des Rechteckes
                x2,y2           rechte untere Ecke des Rechteckes
Hinweis         XORRectangle invertiert ein nicht ausgefülltes Rechteck in
                der Graphik. Dazu wird eine Exklusiv-Oder Verknüpfung
                verwendet. Wird XORRectangle noch einmal mit den gleichen

                               - 69 -


                Parametern aufgerufen, wird durch die doppelte Invertierung
                der Ausgangszustand der Graphik wieder hergestellt. Dieser
                Effekt kann z.B. zur Selektierung eines Objektes benutzt
                werden.
Beispiel
                XORRectangle(0,0,100,100); {Recheck invertieren }
                WaitConfirm;
                XORRectangle(0,0,100,100); {Invertierung wieder aufheben }

Siehe auch      Rectangle, XORBar, XORLine




















































                               - 70 -


10 Verzeichnis der Objekte

Dieses Kapitel  enthält  eine alphabetisch  geordnete  Auflistung
aller von deLite definierten  Objekte.  Beachten Sie, daß wir bei
der   Darstellung    eines   Objektes   nur   die   jeweils   neu
hinzugekommenen   oder  modifizierten   Variablen   und  Methoden
beschreiben.   Da ein abgeleitetes Objekt auch alle Variablen und
Methoden  seiner  Vorfahren  erbt,  kann  es sein,  daß Sie  eine
Information  über  ein bestimmtes  Feld  nicht  in dem jeweiligen
Objekt,   sondern   in  einem  seiner  Vorfahren   finden.    Der
unmittelbare  Vorfahre  - sofern  es einen  gibt- ist jeweils  in
kursiver Schrift rechts neben dem Objektnamen angegeben.

Die Objekthierarchie

Die Objekthierarchie finden Sie im gedruckten Handbuch. Die ent-
sprechende Grafik kann hier nicht wiedergegeben werden.

Konventionen

Bei  der  Vergabe  von Namen  für Methoden  und Konstanten  folgt
deLite  einer  Reihe von Konventionen.   Bei der Erweiterung  der
Objekte  sollten Sie sich diesen Konventionen  anschließen.   Der
Name eines  Zeigers  auf ein Objekt  bildet  sich sich stets  aus
einem P und dem nachgestellten Namen Objektnamen: PObject=^Object
Die   von  Dialogelementen   im  Feld   MSG  des  Records   Event
übermittelten  Botschaften  sind  als Konstanten  definiert,  die
stets mit dem Präfix DLG_ beginnen. Die Flags des Objektes DIALOG
beginnen  stets  mit dem Präfix  MF_ Die Statusinformationen  von
Dialogelementen  beginnen  stets mit Präfix sf Konstruktoraufrufe
tragen   die  Bezeichnung   Init  Destruktoraufrufe   tragen  die
Bezeichnung Done

Bitkodierte Informationen

Die Objekte  verwenden  an vielen Stellen  bitkodierte  Werte zur
Speicherung von Statusinformationen.  Der Zugriff auf diese Werte
erfolgt über logische Verknüpfungen:  So verwenden Sie zum Setzen
eines Bits den OR-Operator.

        flags := flags or sfNoFocus

Weitere  Informationen  zu diesem Thema finden Sie im Kapitel  11
des Buches  "Objektorientierte  Programmierung  und Turbo-Vision"
Ihrer Turbo-Pascal Dokumentation.


Button                                                                  DlgItem

Ein  Button   ist  eine   rechteckige   Schaltfläche   mit  einer
Beschriftung,   die  bei  Betätigung  eine  Botschaft  DLG_BUTTON
erzeugt.  Der Button trägt keine Statusinformation  und verändert
demnach seinen Zustand nicht nach Betätigung; er funktioniert wie
ein Taster,  der immer wieder betätigt  werden  kann und jedesmal
die gleiche Botschaft erzeugt.

Felder
TheLabel        TheLabel: LabelStr
                Enthält die Beschriftung der Schaltfläche
Methoden
Init            constructor Init(x1, y1, dx, dy, TheID: Integer;

                               - 71 -


                TheText: LabelStr)
                Die Parameter x1 und y1 enthalten die Position des
                Buttons innerhalb des Dialogfensters, dx und dy
                geben die horizontale und vertikale Ausdehnung an.
                Die Beschriftung TheText wird zentriert auf der
                Schaltfläche gezeichnet. TheID ist die Identifi-
                kationsnummer des Buttons.
Draw            procedure Draw
                Die Methode zum Zeichnen des Buttons.
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur des Buttons.

CheckBox                                                                DlgItem

Eine  CheckBox  ist  eine  quadratische  Schaltfläche,  die  eine
boolesche  Information  trägt  und ihren  Zustand  bei Betätigung
ändert.    Je  nach  erreichtem   Zustand   wird  eine  Botschaft
DLG_CHECKED oder DLG_UNCHECKED erzeugt. Beachten Sie die Methoden
Check,    Uncheck    und   IsChecked,    die   Bestandteil    des
Ursprungsobjektes DlgItem sind.

Felder
TheLabel        TheLabel: LabelStr
                enthält die Beschriftung der Checkbox, die rechts neben der
                Schaltfläche gezeichnet wird
Methoden
Init            constructor Init(x1, y1, TheID: Integer; TheText: LabelStr)
                Anzugeben sind die Position und die ID-Nummer der Checkbox
                sowie die Beschriftung
Draw            procedure Draw
                Die Methode zum Zeichnen der CheckBox
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur der CheckBox


Dialog

Dialog  ist  das  Basisobjekt,  das  Sie für jedes  Dialogfenster
benötigen.   Es  enthält  die  Methoden  und  Informationen   zur
Verwaltung  des  Dialogfensters  und  zur  Steuerung  der mit dem
Dialog verbundenen Dialogelemente.

Felder
Origin          Origin: DPoint
                Origin enthält die Koordinaten der linken oberen Ecke des
                Dialogfensters
Size            Size: DPoint
                Size enthält die Größe des Dialogfensters.
Caption         Caption: LabelStr
                Sofern beim Init-Aufruf das Flag MF_CAPTION übergeben wurde,
                enthält das Dialogfenster am oberen Rand eine Titelzeile.
                Die Variable Caption enthält die Beschriftung der Titelzeile,
                die mit Hilfe der Methode SetCaption gesetzt wurde.
topic           topic: LabelStr
                Topic enthält das mit Hilfe der Methode SetTopic gesetzte
                Hilfestichwort, das für die Online-Hilfe verwendet wird. Wird
                kein Hilfestichwort gesetzt, bleibt eine Hilfeanforderung
                über die Taste F1 wirkungslos.
Flags           Flags: Word
                In Flags werden bitkodiert Statusinformationen des Dialoges
                abgelegt. Dazu sind folgende Konstanten definiert:

                               - 72 -


                MF_CAPTION              Der Dialog besitzt eine Titelzeile
                MF_CANCELLED            Der Dialog wurde abgebrochen
                MF_POPPEDUP             Der Dialog ist bereits gezeichnet
rdy             rdy: boolean
                Die Methode DoDialog fordert so lange weitere Events an und
                arbeitet sie ab, bis die Variable rdy den Wert TRUE annimmt.
                Die Methode DestroyDialog bricht auf diese Weise den Dialog ab.
marked          marked: boolean
                Die Variable marked gibt an, ob das zur Zeit markierte
                Element bereits entsprechend gezeichnet wurde. Auf diese
                Weise wird verhindert, daß ein angeklicktes Dialogelement
                ständig neu gezeichnet wird, während die Maustaste gedrückt
                ist.
Focus           Focus: PDialog
                Focus ist ein Zeiger auf das aktuell fokussierte Dialogelement.
                Das fokussierte Element bekommt alle Ereignisse, die keine
                Positionsereignisse sind, also etwa alle Tastaturereignisse.
                Nicht immer ist ein Dialogelement fokussiert.
FirstItem       FirstItem: PDialog
                Die Dialogelemente werden in einer Baumstruktur mit dem
                Dialog verbunden. FirstItem ist ein Zeiger auf das erste
                Element dieses Baumes.
Port            Port: ViewPortType
                Port enthält den tatsächlichen Viewport des Dialogfensters,
                also die realen Koordinaten der Eckpunkte des Dialoges. Diese
                Werte unterscheiden sich von den in Origin abgelegten
                Koordinaten, da Origin den von der Menüzeile eingenommenen
                Platz nicht berücksichtigt.
DlgOwner        DlgOwner: EventReceiveProc
                DlgOwner ist ein Zeiger auf die Dialogempfangsprozedur, die
                beim Aufruf von Init angegeben wurde. Diese Prozedur bekommt
                alle von den Dialogelementen erzeugten Meldungen zugeschickt.
Methoden
Init            constructor Init(dx,dy: Integer; Flag: Word;
                TheProc: EventReceiveProc)
                Vor der Verwendung des Dialoges muß der Konstruktor Init
                aufgerufen werden. Er initialisiert alle Felder mit
                Initialwerten. Die Parameter dx und dy geben die Größe des
                Dialogfensters in Pixeln an und werden in Size abgelegt.
                Origin wird so berechnet, daß das Dialogfenster in der
                Bildschirmmitte zentriert erscheint. Als Flag kann eine der
                unter Flags angegebenen Konstanten übergeben werden; im
                Normalfall hat es den Wert 0. Die in TheProc übergebene
                Botschaftenempfangsprozedur muß mit der FAR-Direktive
                übersetzt werden.
Done            destructor Done
                Done gibt den von den mit dem Dialog verbunden Dialogelementen
                eingenommenen Speicher frei, indem es deren eigene Done-
                Methoden aufruft, und entfernt anschließend das Dialogfenster
                vom Bildschirm. Done geht davon aus, daß Ihre Instanz des
                Objektes Dialog selbst nicht als dynamische Variable erzeugt
                wurde, sondern als gewöhnliche Variable deklariert wurde.
                Hier erfolgt also keine Speicherplatzfreigabe.
Move            procedure Move(x,y: Integer)
                Move verschiebt das Dialogfenster an die angegebene Position.
SetCaption      procedure SetCaption(Capt: LabelStr)
                Belegt die Variable Caption mit dem angegebenen String. Die
                Titelzeile wird jedoch nur angezeigt, falls Init mit dem Flag
                MF_CAPTION aufgerufen wurde.
SetTopic        procedure SetTopic(top: LabelStr)
                Setzt das Hilfestichwort für den Dialog. Im Initialzustand

                               - 73 -


                ist das Hilfestichwort leer, so daß eine Betätigung der F1-
                Taste wirkungslos bliebe.
Show            procedure Show
                Öffnet das Dialogfenster und zeigt den Dialog, indem es die
                Draw-Methoden aller verbundenen Dialogelemente aufruft.
AddItem         procedure AddItem(TheItem: PDialog)
                AddItem fügt dem Dialog ein Dialogelement hinzu.
DestroyDialog   procedure DestroyDialog
                Beendet die Abarbeitung der Methode DoDialog, indem die
                Variable rdy auf den Wert TRUE gesetzt wird.
DoDialog        procedure DoDialog
                DoDialog führt den Dialog aus. Es fordert laufend Events an
                und verteilt sie an die jeweils zuständigen Dialogelemente,
                die ihrerseits Botschaften erzeugen und über HandleEvent an
                die in Init angegebene Empfangsprozedur senden. Sobald aus
                der Empfangsprozedur heraus DestroyDialog aufgerufen wurde,
                wird DoDialog abgebrochen.
HandleEvent     procedure HandleEvent(MyEvent: EventTyp)
                HandleEvent empfängt die von den Dialogelementen erzeugten
                Botschaften und leitet sie ggf. an die in Init angegebene
                Empfangsprozedur weiter. Einige Botschaften werden nicht
                weitergeleitet, sondern unmittelbar verarbeitet.
FindDlgItem     function FindDlgItem(ID: Integer):Pointer
                Über FindDlgItem wird ein generischer Zeiger auf das
                Dialogelement mit der angegebenen ID-Nummer angefordert.
                Existiert kein Element mit dieser Nummer, wird NIL zurück-
                geliefert.
SetTheFocus     procedure SetTheFocus(ID: Integer)
                Mit Hilfe von SetTheFocus kann ein bestimmtes Dialogelement
                gezielt fokussiert werden. Ein Beispiel illustriert die
                Anwendung dieser Prozedur: Nehmen wir an, Sie möchten in
                einem Dialogfeld zwei Zahlenwerte einlesen und erzeugen zu
                diesem Zweck einen Dialog mit den Schaltknöpfen OK und
                Abbruch und zwei Editierfeldern. In der
                Botschaftenempfangsprozedur empfangen Sie ein Event der
                Klasse DialogEvent, dessen Feld MSG den Inhalt DLG_OK trägt:
                Es wurde also der Schaltknopf OK betätigt. Sie  möchten den
                Dialog allerdings nur dann mit DestroyDialog schließen,
                falls die beiden Editierfelder auch wirklich gültige Zahlen
                enthalten. Sollten Sie feststellen, daß das nicht der Fall
                ist, verzichten Sie auf den Aufruf von DestroyDialog und
                setzen mit SetTheFocus den Fokus auf das erste fehlerhafte
                Editierfeld. Danach wird das Editierfeld markiert sein, und
                der Anwender kann den Inhalt des Editierfeldes sofort
                verändern.
GetEvent        procedure GetEvent(Var MyEvent: EventTyp)
                Die Dialoge verwenden diese überlagerte Version von GetEvent,
                die selbst die Normalisierung der Ereignisse auf den Viewport
                des Dialoges übernimmt.

DlgGroup                                                                DlgItem

DlgGroup  ist ein aus mehreren Dialogelementen  zusammengesetztes
Element.  Die einzelnen zu der Gruppe gehörenden  Elemente senden
ihre Nachrichten  an das übergeordnete  Objekt  vom Typ DlgGroup,
das diese Nachrichten  verarbeitet  und ggf.  Nachrichten  an die
Dialogempfangsprozedur sendet.

Felder
ItemGroup       ItemGroup: PDialog
                ein Zeiger auf die Kette von Dialogelementen, die zu der

                               - 74 -


                Gruppe gehören. Die hier eingebundenen Elemente können selbst
                wieder Gruppen sein.
Methoden
Init            constructor Init(x1, y1, TheID: Integer)
                Init ruft erst den Konstruktor von DlgItem auf und belegt
                anschließend das Feld ItemGroup mit NIL.
Done            destructor Done
                Gibt den von der Gruppe benötigten Speicherplatz frei.
AddItem         procedure AddItem(TheItem: PDialog)
                Fügt der Gruppe ein weiteres Dialogelement hinzu.
GetSuccessor    function GetSuccessor: PDialog
                liefert das erste zu der Gruppe gehörende Dialogelement zurück.
Draw            procedure Draw
                zeichnet die gesamte Gruppe, indem die Draw-Methoden aller
                Gruppenmitglieder aufgerufen werden.
FindGroupItem   function FindGroupItem(TheId: Integer):Pointer
                liefert einen Zeiger auf das angegebene Gruppenelement zurück.
GlueGroup       procedure GlueGroup
                Verbindet die einzelnen zu einer Gruppe gehörenden Elemente
                miteinander, indem die Felder owner und parent entsprechend
                belegt werden und die Koordinaten der einzelnen Elemente um
                die Koordinaten der Gruppe selbst korrigiert werden.

DlgItem

DlgItem  ist das Urobjekt  aller  Dialogelemente.   Es ist selbst
nicht funktionsfähig, sondern nur in Form seiner Nachkommen.

Felder
Origin          Origin: DPoint
                enthält die Koordinaten der linken oberen Ecke des Elementes
Area            Area: DRect
                enthält die aktive Fläche des Elementes. Diese Angabe wird
                bei der Zuordnung von Positionsereignissen verwendet.
Status          Status: Word
                Das Feld Status enthält bitkodiert Informationen, die das
                Verhalten des Dialogelementes modifizieren. Möglich sind
                folgende, als Konstanten definierte Werte:
                sfFocused       Das Dialogelement ist fokussiert
                sfMarked        Dialogelement ist markiert
                sfNoFocus       Das Dialogelement kann nicht fokussiert werden
                sfDefault       Das Dialogelement sendet bei Betätigung DLG_OK
                sfCancel        Das Dialogelement sendet bei Betätigung
                                DLG_CANCEL
                sfPhoenix       Nachdem das Element zum ersten Mal gezeichnet
                                wurde,wird dieses Flag gelöscht
                sfGroup         Das Dialogelement besteht aus mehreren
                                Elementen
                sfBlind         Das Dialogelement empfängt keine Botschaften
                sfChecked       Das Dialogelement ist mit einer Überprüfungs-
                                marke versehen (nur bei CheckBox)
                sfRepeat        Das Dialogelement möchte bei gedrückter
                                Maustaste wiederholt Botschaften erhalten.
                sfDisabled      Das Dialogelement ist vorübergehend passiv.
                                Dieses Flag muß in der HandleEvent-Methode
                                beachtet werden.
ID              ID: Integer
                Die Identifikationsnummer des Dialogelementes. Jedes
                Dialogelement muß eine einzigartige Identifikationsnummer
                tragen, die jeweils im Init-Aufruf angegeben wird. Beachten
                Sie, daß Identifikationsnummern ab 30000 für das System

                               - 75 -


                reserviert sind.
Next            Next: PDialog
                Next ist ein Zeiger auf das nächste Dialogelement. Die
                Methode AddItem des Objektes Dialog nimmt die Verkettung der
                Dialogelemente vor.
parent          parent: PDialog
                Dialogelemente, die zu einer Gruppe gehören, enthalten in
                diesem Feld einen Zeiger auf das DlgGroup-Objekt, zu dem sie
                gehören.
master          master: PDLG
                Master ist ein Zeiger auf den Dialog, zu dem die Dialog-
                elemente gehören.
owner           owner: EventReceiveProc
                Das Feld Owner zeigt auf die Empfangsprozedur, der die
                erzeugten Botschaften zu schicken sind.
Methoden
Init            constructor Init(x1, y1, TheID: Integer)
                Der Aufruf von Init belegt die Felder Origin und ID mit den
                angegebenen Werten und setzt alle anderen Felder auf Initial-
                werte. Von DlgItem abgeleitete Objekte müssen in ihrem
                eigenen Konstruktor zunächst den Konstruktor von DlgItem
                aufrufen.
Done            destructor Done
                Der virtuelle Destruktor Done gibt den vom Dialogelement
                benötigten Speicherplatz frei.
GetSuccessor    function GetSuccessor: PDialog
                liefert das nächste Dialogelement - also den Inhalt von Next.
SetFocus        procedure SetFocus
                Setzt das Flag sfFocused im Feld status.
ClearFocus      procedure ClearFocus
                Löscht das Flag sfFocused im Feld status.
SetMark         procedure SetMark
                Setzt das Flag sfMarked im Feld status.
ClearMark       procedure ClearMark
                Löscht das Flag sfMarked im Feld status.
EnableItem      procedure EnableItem
                Löscht das Flag sfDisabled im Feld status.
DisableItem     procedure DisableItem
                Setzt das Flag sfDisabled im Feld status.
ClearPhoenix    procedure ClearPhoenix
                Löscht das Flag sfPhoenix im Feld status.
SetPhoenix      procedure SetPhoenix
                Setzt das Flag sfPhoenix im Feld status.
Check           procedure Check
                Setzt das Flag sfChecked im Feld status.
Unchecked       procedure Uncheck
                Löscht das Flag sfChecked im Feld status.
SetRepeat       procedure SetRepeat
                Setzt das Flag sfRepeat im Feld status.
IsChecked       function IsChecked: Boolean
                liefert den Zustand des Flags sfChecked im Feld status.
Draw            procedure Draw
                Draw ist eine abstrakte, virtuelle Funktion zum Zeichnen
                des Dialogelementes, die von den Nachfolgern von DlgItem
                überlagert werden muß. Draw muß dabei die Flags sfChecked,
                sfFocused, sfMarked, sfPhoenix und sfChecked beachten und
                das Aussehen des Dialogelementes jeweils so zeichnen, daß
                sich der Zustand dieser Flags darin wiederspiegelt.
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                HandleEvent wird aufgerufen, sobald ein Ereignis für das
                Dialogelement vorliegt. Diese Methode ist virtuell und muß

                               - 76 -


                von den Nachfolgern von DlgItem überlagert werden.
                HandleEvent muß das Flag sfDisabled beachten.
SendMessage     procedure SendMessage(TheMsg: Integer)
                SendMessage wird von den Dialogelementen aus deren
                HandleEvent-Prozedur aufgerufen, um ein Ereignis an die
                in Dialog.Init angemeldete Empfangsprozedur zu senden.
                SendMessage sendet eine Nachricht der Klasse DialogEvent
                und belegt das Feld MSG des Event-Records mit dem übergebenen
                Wert. Zusätzlich belegt es das Feld ID mit der ID-Nummer
                des Dialogelementes und das Feld DlgAdr mit der Adresse des
                Dialoges, zu dem das Dialogelement gehört, also dem Inhalt
                des Feldes master. So ist es dem Empfänger der Nachricht
                möglich, über MyEvent^.DlgAdr auf Felder und Methoden des
                Dialoges zuzugreifen.
IsInRect        function IsInRect(TheEvent: EventTyp): boolean
                Sofern das übergebene Event zu der Klasse LeMouse gehört,
                wird geprüft, ob das Event innerhalb der durch das Feld Area
                gegebenen Fläche stattgefunden hat.
MakeDefaultItem procedure MakeDefaultItem
                Setzt das Flag sfDefault im Feld Status. Das so markierte
                Dialogelement sendet bei Betätigung die Botschaft DLG_OK.
                In der Regel enthält jeder Dialog einen Button mit der
                Beschriftung OK, dessen Flag sfDefault gesetzt ist.
MakeCancelItem  procedure MakeCancelItem
                Setzt das Flag sfCancel im Feld Status. Das so markierte
                Dialogelement sendet bei Betätigung die Botschaft DLG_CANCEL.
GimmeFocus      procedure GimmeFocus
                Fokussiert das betroffene Dialogelement. Dies geschieht,
                indem die Botschaft DLG_GIVEFOCUS an Dialog gesendet wird,
                der entsprechend reagiert. So können Dialogelemente selbst
                den Fokus beantragen.

DPoint

Felder
X, Y            X, Y: Integer
                enthalten eine Koordinate.
Methoden
Move            procedure Move(dx, dy: Integer)
                verschiebt die Koordinate um die angegebenen Werte.

DRect.

Felder
P1, P2          P1, P2: DPoint
                enthalten die Koordinaten der linken oberen und der rechten
                unteren Ecke eines Rechteckes.
Methoden
Assign          procedure Assign(x1, y1, x2, y2: Integer)
                Belegt die Koordinaten mit den angegebenen Werten.
Move            procedure Move(dx, dy: Integer)
                Verschiebt das Rechteck um die angegebenen Werte.

EditField                                                               DlgItem

EditField   ist   ein   einzeiliges   Feld   zur  Eingabe   einer
Zeichenkette,  die wahlweise  als String  oder  als Integer-Größe
interpretiert werden kann und deren Länge begrenzt werden kann.

Felder
thelen          thelen: Integer

                               - 77 -


                Die sichtbare Länge des Editierfeldes in Cursoreinheiten
maxlen          maxlen: Integer
                Die maximale Länge der zu editierenden Zeichenkette. Ist
                die tatsächliche Länge größer als die sichtbare Länge, wird
                der Ausschnitt des Editierfeldes entsprechend verschoben.
curpos          curpos: Integer
                Die relative Cursorposition innerhalb des Editierfeldes
abspos          abspos: Integer
                Die absolute Cursorposition innerhalb des Editierfeldes
                inklusive der eventuell nicht sichtbaren Zeichen.
cursor          cursor: boolean
                Gibt an, ob der Cursor zur Zeit sichtbar ist.
altered         altered: boolean
                Gibt an, ob der Inhalt der Zeichenkette seit des letzten
                Sendens einer Botschaft DLG_EDITCHGD modifiziert wurde.
TheString       TheString: String
                Der Inhalt des Editierfeldes
Methoden
Init            constructor Init(x, y, len, max, TheID: Integer; deflt: String)
                Anzugeben sind neben der Position und der ID die Breite des
                Editierfeldes in Cursoreinheiten und die maximale Länge der
                zu editierenden Zeichenkette. In deflt wird die Vorbelegung
                des Editierfeldes übergeben.

Draw            procedure Draw
                Zeichnet das Editierfeld
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur des Editierfeldes
ClearFocus      procedure ClearFocus
                Überlagert die gleichnamige Methode aus DlgItem. Das
                Editierfeld sendet beim Abgeben des Fokus, sofern die Variable
                altered den Wert TRUE hat, die Botschaft DLG_EDITCHGD.
SetString       procedure SetString: String
                Belegt den Inhalt des Editierfeldes mit dem angegebenen String.
GetString       function GetString: String
                liefert den Inhalt des Editierfeldes
IsInteger       function IsInteger: boolean
                liefert TRUE zurück, falls der Inhalt des Editierfeldes eine
                gültige Integerzahl darstellt.
GetValue        function GetValue: Integer
                liefert den Inhalt des Editierfeldes als Integerzahl.

FileRequester                                                   DlgGroup

FileRequester  ist  eine  aus mehreren  Gruppen  zusammengesetzte
Gruppe zur Ermittlung  eines Dateinamens.   Bei der Auswahl einer
Datei wird die Botschaft DLG_FILEREQ gesendet.

Felder
lines           lines: Integer
                Die Anzahl der gleichzeitig sichtbaren Verzeichniseinträge.
                Die Anzahl der sichtbaren Dateieinträge ist lines+2.
Methoden
Init            constructor Init(x,y,lin, TheID: Integer, ThePath: String;
                TheMask: string)
                Anzugeben sind neben den Koordinaten, der Zahl der gleichzeitig
                sichtbaren Verzeichniseinträge und der ID-Nummer der Pfad,
                von dem aus der FileRequester startet, und eine Dateimaske.
Done            destructor Done
                Gibt den vom FileRequester benötigten Speicherplatz wieder
                frei.

                               - 78 -


Draw            procedure Draw
                Zeichnet den FileRequester.
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur des Filerequesters.
GetSelected     function GetSelected: String
                liefert den ausgewählten Dateinamen zurück.
GetPath         function GetPath: String
                liefert das Verzeichnis der ausgewählten Datei zurück

LabelFrame                                                              DlgItem

LabelFrame ist ein passives Dialogelement.   Es besteht aus einem
Rahmen und einer Beschriftung und soll den logischen Zusammenhang
von Dialogelementen optisch unterstreichen.

Felder
TheLabel        TheLabel: LabelStr
                Enthält die Beschriftung.
Methoden
Init            constructor Init(x1, y1, dx, dy, TheID: Integer;
                TheText: LabelStr)
                Anzugeben sind Position und Größe des Rahmens, seine ID-
                Nummer und die zu verwendende Beschriftung. Die Beschriftung
                unterbricht das obere Segment des Rahmens.
Draw            procedure Draw
                Zeichnet den Rahmen.

LabelText                                                               DlgItem

Objekte des Typs LabelText dienen der Beschriftung von Dialogen.

Felder
TheLabel        TheLabel: LabelStr
                Enthält die Beschriftung.
Methoden
Init            constructor Init(x1, y1, TheID: Integer; TheText: LabelStr)
                Der Text wird an der angegebenen Position linksbündig
                gezeichnet.
Draw            procedure Draw
                Zeichnet den Text.
SetLabel        procedure SetLabel(TheText: LabelStr)
                Belegt den Text neu mit dem angegebenen Wert.

ListBox                                                         DlgGroup

Die ListBox  dient der Auswahl  eines Elementes  aus einer Liste.
Enthält  die Liste  mehr Elemente,  als gleichzeitig  dargestellt
werden  können,  kann  der  sichtbare   Ausschnitt   entsprechend
verschoben  werden.  Die Liste wird über zwei Prozeduren  vom Typ
GetListProc  eingelesen,  die  beim  Konstruktoraufruf  anzugeben
sind.  Sobald ein Element  selektiert  wurde,  wird die Botschaft
DLG_LISTSELECT gesendet.

Felder
Itemwidth       Itemwidth: Integer
                Die sichtbare Breite der Liste.
ListLength      ListLength: Integer
                Die Anzahl der gleichzeitig sichtbaren Einträge der Liste
ListPtr         ListPtr: Integer
                Die markierte Zeile innerhalb des sichtbaren Ausschnitts
                der Liste

                               - 79 -


select          select: ListStr
                Der zuletzt selektierte Eintrag der Liste
GetFirstProc    GetFirstProc: GetListProc
                Die Callback-Prozedur zur Ermittlung des ersten Eintrages
                der Liste.
                Zusammen mit GetNextProc wird so die Liste aufgebaut.
GetNextProc     GetNextProc: GetListProc
                Die Callback-Prozedur zur Ermittlung des jeweils nächsten
                Eintrages der Liste.
TheList         TheList: PTextListItem
                Die Liste ist als doppelt verkettete Liste abgelegt. TheList
                zeigt auf das erste Element der Liste
Current         Current: PTextListItem
                Current zeigt auf das aktuell markierte Element
Top             Top: PtextListItem
                Top zeigt auf das erste sichtbare Listenelement
Methoden
Init            constructor Init(x,y, wid, len, TheID: Integer;
                GetFirst, GetNext: GetListProc)
                Anzugeben sind Position, Größe und ID der ListBox und die
                beiden Callback-Prozeduren zum Aufbau der Liste.
Done            destructor Done
                Gibt den gesamten von der ListBox in Anspruch genommenen
                Speicherplatz inklusive der Liste selbst frei.
Draw            procedure Draw
                Zeichnet die ListBox.
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur der ListBox.
ReadList        procedure ReadList
                liest die Liste ein.
RemoveList      procedure RemoveList
                gibt die Liste frei.
Update          procedure Update
                verwirft die aktuelle Liste und liest sie neu ein.
GetSelected     function GetSelected: String
                liefert das zuletzt selektierte Element

RadioButton                                                             DlgItem

Mehrere  RadioButtons   bilden  zusammen   eine  Gruppe  vom  Typ
RadioButtons.  RadioButtons verhalten sich so wie Knöpfe an alten
Radios:  Betätigt man einen, springt der zuvor gedrückte  heraus.
Im  Unterschied   zu  den  meisten   anderen  Gruppen  steht  bei
RadioButtons  nicht von vornherein  fest, welche Elemente  zu der
Gruppe gehören. Daher erfolgt die Definition einer solchen Gruppe
in einem rekursiven Aufruf.

Felder
TheLabel        TheLabel: LabelStr
                Die Beschriftung des RadioButton erscheint rechts neben
                dem Element
MyGroup         MyGroup: PRadioButtons
                MyGroup ist ein Zeiger auf das übergeordnete Gruppenelement
                vom Typ RadioButtons.
Methoden
Init            constructor Init(x1,y1, TheID: Integer; TheText:
                LabelStr; nextB: PRadioButton)
                Neben der Position, der ID und der Beschriftung wird in
                nextB ein Zeiger auf den jeweils nächsten zu definierenden
                RadioButton übergeben. Der letzte RadioButton muß hier den
                Wert NIL übergeben.

                               - 80 -


Draw            procedure Draw
                Die Methode zum Zeichnen des RadioButton.
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur des RadioButton.

RadioButtons                                                    DlgGroup

RadioButtons ist die übergeordnete Gruppe, deren Elemente vom Typ
RadioButton  sind.  RadioButtons  selbst enthält lediglich  einen
Rahmen und eine Beschriftung.   Bei Betätigung  eines RadioButton
wird die Botschaft DLG_RADIO gesendet.

Felder
Title           Title: LabelStr
                Der Titel der RadioButtons-Gruppe. Er erscheint
                oberhalb der Gruppe und unterbricht das obere Segment des
                Rahmens um die Gruppe
Methoden
Init            constructor Init(x1, y1, dx, dy, TheID:
                Integer; TheText: LabelStr; nextB: RadioButton)
                Die Parameter des Konstruktors sind Position, Größe, ID und
                Titel der Gruppe und ein Zeiger auf das erste Element vom
                Typ RadioButton.
Draw            procedure Draw
                Die Methode zum Zeichnen der RadioButtons-Gruppe
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur von RadioButtons.
WhosChecked     function WhosChecked: Integer
                Liefert die ID des aktuell gedrückten RadioButton.
CheckButton     procedure CheckButton(TheId: Integer)
                Betätigt den RadioButton mit der angegebenen ID-Nummer.
Beispiel        Das Beispiel definiert eine RadioButtons-Gruppe mit vier
                Elementen vom Typ RadioButton und fügt sie dem Dialog
                MyDialog hinzu. Der RadioButton mit der ID 36 wird gesetzt.

    new(MyRadioButtons, Init(10,270,150,50,34,'Wählen Sie:',
        new(PRadioButton,Init(5,10,35,'Alt',
         new(PRadioButton, Init(5,30,36,'Kölsch',
          new(PRadioButton, Init(80,10,37,'Pils',
           new(PRadioButton, Init(80,30,38,'Weizen',nil))))))))));
    MyDialog.AddItem(MyRadioButtons);
    MyRadioButtons^.CheckButton(36); { Kölsch }

SelectBox                                                       DlgGroup

Die SelectBox  dient ähnlich  wie die ListBox  der Auswahl  eines
Elementes  aus einer Liste.   Allerdings  ist in diesem  Fall nur
jeweils ein Element sichtbar,  so daß mit der SelectBox  auch die
Aufgabe einer RadioButtons-Gruppe übernommen werden kann, bei der
immer genau ein Element aus einer Anzahl von Elementen aktiv ist.
Mit Hilfe zweier Schaltflächen kann das jeweils sichtbare Element
vor- bzw.  zurückgeschaltet  werden,  wobei jeweils die Botschaft
DLG_BOXCHANGE  gesendet  wird.  Bei der Auswahl  des selektierten
Elementes wird DLG_BOXSELECT gesendet.

Felder
Itemwidth       Itemwidth: Integer
                Die sichtbare Breite des Fensters in Cursoreinheiten
GetFirstProc    GetFirstProc: GetListProc
                Die Callback-Prozedur zur Ermittlung des ersten
                Eintrages der Liste. Zusammen mit GetNextProc wird

                               - 81 -


                so die Liste aufgebaut.
GetNextProc     GetNextProc: GetListProc
                Die Callback-Prozedur zur Ermittlung des jeweils
                nächsten Eintrages der Liste.
TheList         TheList: PTextListItem
                Die Liste ist als doppelt verkettete Liste abgelegt.
                TheList zeigt auf das erste Element der Liste
Current         Current: PTextListItem
                Current zeigt auf das aktuell markierte Element
Methoden
Init            constructor Init(x,y, wid, TheID: Integer;
                GetFirst, GetNext: GetListProc)
                Anzugeben sind Position, Breite und ID der SelectBox und die
                beiden Callback-Prozeduren zum Aufbau der Liste.
Done            destructor Done
                Gibt den gesamten von der SelectBox in Anspruch genommenen
                Speicherplatz inklusive der Liste selbst frei.
Draw            procedure Draw
                Zeichnet die SelectBox.
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur der SelectBox.
ReadList        procedure ReadList
                liest die Liste ein.
RemoveList      procedure RemoveList
                gibt die Liste frei.
Update          procedure Update
                verwirft die aktuelle Liste und liest sie neu ein.
GetSelected     function GetSelected: String
                liefert das zuletzt selektierte Element
Select          procedure Select(TheString: LabelStr)
                Selektiert das angegebene Element, sofern es existiert
ClearFocus      procedure ClearFocus
                überlagert die gleichnamige Methode aus DlgItem.

Slider                                                                  DlgItem

Der  Slider   ist  ein  Schieberegler,   dessen   Position   eine
Integergröße kontrolliert.   Der Slider sendet bei jeder Bewegung
die  Botschaft  DLG_SLIDERMOVED   und  nach  dem  Loslassen   die
Botschaft DLG_SLIDERRLSD.

Felder
min, max        min, max: Integer
                Die obere und untere Grenze der Integergröße, die
                proportional zur Position des Sliders verändert wird.
pos             pos: Integer
                Die aktuelle Position des Sliders in Pixeln.
Methoden
Init            constructor Init(x1, y1, len, TheID, pmin, pmax: Integer;
                dir: dirtype)
                In x1 und y1 wird die Koordinate des Sliders innerhalb des
                Dialoges angegeben. Len spezifiziert die tatsächliche
                Ausdehnung der Schiebereglerfläche in Pixeln, während pmin
                und pmax den Bereich der dem Slider zugeordneten Integergröße
                entsprechen. Dir steht für die Ausrichtung des Sliders, hier
                ist zur Zeit nur der Wert hor zulässig.
Draw            procedure Draw
                Die Zeichenmethode des Sliders.
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur des Sliders.
GetPos          function GetPos: Integer

                               - 82 -


                liefert eine der Position des Sliders proportionale
                Integergröße.
SetPos          procedure SetPos(thepos: integer)
                setzt die Position des Sliders neu.

UserButton                                                              DlgItem

Ein  UserButton  ist eine  rechteckige,  mit einer  Bitmap-Grafik
versehene  Schaltfläche,   die  bei  Betätigung   eine  Botschaft
DLG_BUTTON erzeugt.  Der UserButton trägt keine Statusinformation
und verändert  demnach seinen Zustand  nicht nach Betätigung;  er
funktioniert  wie ein Taster,  der immer wieder  betätigt  werden
kann und jedesmal die gleiche Botschaft erzeugt.

Felder
dxb, dyb        dxb, dyb: Integer
                Die Ausdehnung der Bitmap-Grafik in Pixeln.
hk              hk: char
                Ein Hotkey, der in Verbindung mit der ALT-Taste den
                UserButton betätigt. Diese Funktion wird zur Zeit noch
                nicht unterstützt.
IconPtr         IconPtr: Pointer
                Ein Zeiger auf die Bitmap-Grafik des UserButton.
Methoden
Init            constructor Init(x1, y1, dx, dy, xb, yb, TheID: Integer;
                TheHk: char;  TheIcon: Pointer)
                Die Parameter x1 und y1 enthalten die Position des
                UserButtons innerhalb des Dialogfensters, dy und dy geben
                die horizontale und vertikale Ausdehnung an. Xb und yb
                stehen für die Ausdehnung der Bitmap-Grafik; TheID ist die
                ID-Nummer des UserButtons. Zusätzlich wird noch ein Hotkey
                und ein Zeiger auf die Bitmap-Grafik übergeben.
Draw            procedure Draw
                Die Methode zum Zeichnen des UserButtons.
HandleEvent     procedure HandleEvent(TheEvent: EventTyp)
                Die Botschaftenempfangsprozedur des UserButtons.

UserRadioButton                                                 RadioButton

Mehrere  Elemente  vom Typ UserRadioButton  bilden zusammen  eine
Gruppe  vom  Typ  UserRadioButtons.    Im  Unterschied  zu  ihrem
Vorgänger   RadioButton    sind   UserRadioButtons    rechteckige
Schaltflächen  beliebiger  Größe,  die  mit  einer  Bitmap-Grafik
versehen sein können.

Felder
IconPtr         IconPtr: Pointer
                Der Zeiger auf die Bitmap-Grafik
dxb, dyb        dxb, dyb: Integer
                Die Größe der Bitmap-Grafik
Methoden
Init            constructor Init(x1, y1, dx, dy, xb, yb, TheID: Integer;
                TheIcon: Pointer; nextB: PUserRadioButton)
                Anzugeben sind in x1 und y1 die Position des UserRadioButton,
                in dx und dy seine Größe, und in xb und yb die Größe der
                Bitmap-Grafik. Neben der ID-Nummer wird zusätzlich ein
                Zeiger auf die Bitmap-Grafik und ein Zeiger auf das nächste
                Element vom Typ UserRadioButton übergeben. Das letzte so
                definierte Element übergibt in nextB den Wert NIL.
Draw            procedure Draw
                Die Methode zum Zeichnen des RadioButton.

                               - 83 -



UserRadioButtons                                                RadioButtons

UserRadioButtons  ist eine übergeordnete  Gruppe,  deren Elemente
vom  Typ  UserRadioButton  sind.  Im  Unterschied  zum  Vorgänger
RadioButtons  zeichnet  UserRadioButtons   selbst  keine  eigenen
Elemente.

Methoden
Init            constructor Init(x1, y1, dx, dy, TheID: Integer;
                nextB: PUserRadioButton)
                Die Parameter des Konstruktors sind Position, Größe, ID und
                Titel der Gruppe und ein Zeiger auf das erste Element vom
                Typ UserRadioButton.
Draw            procedure Draw
                Die Methode zum Zeichnen der UserRadioButtons-Gruppe.
Beispiel        Das Beispiel definiert eine Gruppe mit vier Elementen des
                Typs UserRadioButton und fügt sie dem Dialog MyDialog hinzu.
                Die Elemente tragen die ID-Nummern 412 bis 415, die Gruppe
                selbst hat die ID-Nummer 411.

    new(MyUserRadios, Init(400,250,60,60,411,
        new(PUserRadio, Init(0,0,30,30,30,30,412,nil,
         new(PUserRadio, Init(30,0,30,30,30,30,413,nil,
          new(PUserRadio, Init(0,30,30,30,30,30,414, nil,
           new(PUserRadio, Init(30,30,30,30,30,30,415, nil,nil))))))))));
    MyDialog.AddItem(MyUserRadios);



































                               - 84 -


Anhang A  Konfigurationsmöglichkeiten

Die folgende  Auflistung  beschreibt  die vom System  verwendeten
Einträge  in der Initialisierungsdatei.   Beachten  Sie,  daß mit
Ausnahme des Eintrages  Video im Abschnitt  Hardware alle Angaben
fakultativ sind. Fehlen diese Angaben, verwendet deLite sinnvolle
Vorbelegungen. Zur Deklaration eines Abschnittes ist der Name des
Abschnittes in eckigen Klammern zu schreiben.

Der Abschnitt Paths

Im Abschnitt Paths können Pfadangaben  auf eine Reihe von Dateien
definiert  werden.  Fehlen die Pfadangaben,  versucht deLite, die
jeweilige  Datei aus dem aktuell gesetzten Verzeichnis  zu lesen.
Dieser    Abschnitt    ist    nützlich,    falls    Sie   mehrere
deLite-Applikationen   einsetzen   und   die   Videotreiber   und
Zeichensatzdateien  nur  ein  einziges  Mal auf Ihrer  Festplatte
speichern möchten.

VDIDir          definiert den Pfad auf die Grafiktreiber
FontDir         definiert den Pfad auf die Zeichensatzdateien
SwapDir         definiert den Pfad für die vom Speichermanager
                temporär erzeugten Auslagerungsdateien. Alternativ
                können Sie auch mit Hilfe des DOS-Befehls SET eine
                Environment-Variable mit dem Namen TEMP erzeugen,
                die den Pfad für die Auslagerungsdateien definiert.
                Verwenden Sie niemals ein Diskettenlaufwerk zum
                Auslagern!

Der Abschnitt Hardware

Im Abschnitt Hardware wird der zu verwendende  Grafiktreiber  und
ggf.  der zu ladende skalierbare  Zeichensatz  definiert.  DeLite
nimmt keine automatische Erkennung der installierten  Grafikkarte
vor; diese Angabe ist also zwingend  notwendig.   Der skalierbare
Zeichensatz   wird  nicht  benötigt,   falls   Sie  der  Prozedur
OpenMainApplication als modus die Konstante APP_NOFONT übergeben.
Anderenfalls ist auch diese Angabe zwingend erforderlich.

Video           definiert den zu verwendenden Grafiktreiber
Font            definiert den zu verwendenden skalierbaren Zeichensatz

Der Abschnitt memory

Im  Abschnitt  memory  kann  die  Speicherverwaltung  von  deLite
parametrisiert  werden.   Hier können Sie angeben,  unter welchen
Bedingungen  die  Speicherverwaltung   EMS  oder  die  Festplatte
verwenden soll, anstatt den Heap zu benutzen.

HeapMin         definiert, wieviel Heap-Speicher mindestens freigelassen
                werden soll. Nachdem diese Grenze erreicht ist, versucht
                die Speicherverwaltung, EMS-Speicher zu verwenden.
                Als Vorbelegung verwendet deLite den Wert 262144,
                also 256kByte. Wenn Sie hier einen unrealistisch hohen
                Wert angeben, verwendet deLite niemals Heap-Speicher zum
                Auslagern.
EMSPagesMin     definiert, wie viele EMS-Seiten freigelassen werden sollen.
                Nachdem diese Grenze erreicht ist, versucht die
                Speicherverwaltung, Speicher auf die Festplatte auszulagern.
                Als Vorbelegung verwendet deLite den Wert 4. Wenn Sie hier
                einen unrealistisch hohen Wert angeben, verwendet deLite

                               - 85 -


                niemals EMS-Speicher zum Auslagern. Beachten Sie, daß deLite
                nur dann EMS verwenden kann, wenn ein 64kByte großer
                Page-Frame zur Verfügung steht. Der Page-Frame gibt die Größe
                des Fensters im Speicher an, das zur Einblendung von
                EMS-Seiten zur Verfügung steht. Auf älteren EMS-Karten,
                wie sie in XT-Rechnern eingesetzt wurden, steht unter
                Umständen nur ein 16KByte großer Page-Frame zur Verfügung.
DiskMin         definiert, wieviel Festplattenplatz von deLite freigelassen
                werden soll. Nachdem diese Grenze erreicht ist, bricht die
                Speicherverwaltung von deLite das Programm mit einem
                Laufzeitfehler ab. Als Vorbelegung verwendet deLite den Wert
                262144, das sind 256KByte.

Der Abschnitt colors

Im   Abschnitt   colors   können   die   von   deLite   für   die
Bildschirmdarstellung  verwendeten  Farben definiert werden.  Die
Angabe muß in numerischer Form erfolgen und den Möglichkeiten der
von Ihnen verwendeten  Grafikkarte  entsprechen.   Für VGA-Karten
sind bei einem 16-Farben Treiber die Werte 0 bis 15 erlaubt.

ScrnBkGnd       definiert die Farbe des Bildschirmhintergrundes.
                Die Vorbelegung ist 0 (schwarz)
MenueBkGnd      definiert die Hintergrundfarbe der Menüs
MenueText       definiert die Farbe der Menütexte
HighBkGnd       definiert die Hintergrundfarbe markierter Menüpunkte
HighText        definiert die Farbe markierter Menüpunkte
DisableText     definiert die Farbe inaktiver Menüpunkte
MenueFrame      definiert die Farbe der Umrahmung von Menüs
DlgBkGnd        definiert die Hintergrundfarbe von Dialogfeldern
DlgFrame        definiert die Farbe der Umrahmung von Dialogfeldern
DlgMsg          definiert die Farbe von Statusmeldungen in Dialogfeldern
DlgText         definiert die Farbe von Texten in Editierfeldern
DlgEditBkGnd    definiert die Hintergrundfarbe von Editierfeldern
DlgListText     definiert die Farbe von Texten in Listenauswahlfeldern
DlgListBkGnd    definiert die Hintergrundfarbe von Listenauswahlfeldern
DlgListHiText   definiert die Farbe markierter Einträge in Listenauswahlfeldern
DlgListHiBkGnd  definiert die Hintergrundfarbe markierer Einträge in
                Listenauswahlfeldern
Elevator        definiert die Farbe der Positionsmarkierung in Listendialogen
ErrorText       definiert die Farbe von Texten in Fehlerfenstern
ErrorBkGnd      definiert die Hintergrundfarbe von Fehlerfenstern
SystemText      definiert die Farbe von Texten in Meldungsfenstern
WinFrame        definiert die Rahmenfarbe von Subapplikationen

Die Tabelle enthält die Farbnummern einer EGA/VGA-Karte mit 16 Farben:

        0       schwarz         8       dunkelgrau
        1       blau            9       hellblau
        2       grün            10      hellgrün
        3       türkis          11      helles türkis
        4       rot             12      hellrot
        5       fuchsin         13      helles fuchsinrot
        6       braun           14      gelb
        7       hellgrau        15      weiss







                               - 86 -


Anhang B  Fehlermeldungen

Die nachfolgende  Tabelle beschreibt  die Ursachen  der möglichen
von deLite gemeldeten  Fehler.  Die Fehlernummern  werden an drei
verschiedenen Stellen verwendet: Die Prozedur OpenMainApplication
liefert als unmittelbares  Ergebnis eine Fehlernummer ungleich 0,
falls Ihre Applikation  nicht gestartet werden konnte.  Mit Hilfe
der  Funktion   KernelError   kann   nach   der  Ausführung   von
Kernel-Funktionen  der Fehlerstatus erfragt werden.  Die Prozedur
OpenMainApplication  bedient sich dieser Möglichkeit.   Sollte es
während der Ausführung Ihrer Applikation  zu einem fatalen Fehler
kommen,  gibt  das  deLite-Laufzeitsystem  nach  dem Abbruch  des
Programms   und  des  Zurückschaltens   in  den  Textmodus   eine
Fehlernummer aus. Falls Sie in Ihrer Applikation das Ergebnis von
OpenMainApplication im Klartext ausgeben möchten, können Sie sich
des Units  ERRORS  bedienen,  das die im folgenden  beschriebenen
Fehlertexte zusammen mit einer Ausgabeprozedur enthält.

1       Initialisierungsdatei nicht gefunden
        Die Initialisierungsdatei existiert nicht im aktuell
        gesetzten Verzeichnis. Falls Sie versucht haben, die
        Applikation aus der Entwicklungsumgebung von Turbo
        Pascal heraus zu starten, stellen Sie sicher, daß eine
        Kopie der Initialisierungsdatei im gleichen Verzeichnis
        existiert, in dem sich auch die Quelltexte zu Ihrer
        Applikation befinden.

2       Hardware-Block nicht gefunden
        Die Initialisierungsdatei existiert, aber der Abschnitt
        Hardware konnte nicht gefunden werden.

3       Videotreiber nicht spezifiziert
        In der Initialisierungsdatei wurden der Abschnitt Hardware
        und das Schlüsselwort Video gefunden, nach dem Schlüsselwort
        allerdings kein Grafiktreiber spezifiziert.

4       Zeichensatz nicht spezifiziert
        In der Initialisierungsdatei wurden der Abschnitt Hardware
        und das Schlüsselwort Font gefunden, nach dem Schlüsselwort ist
        allerdings kein Zeichensatz spezifiziert.

5       Schlüsselwort nicht gefunden, oder Parameter leer
        Bei der Suche nach einem anwenderdefinierten Eintrag wurde das
        angegebene Schlüsselwort nicht gefunden, oder es ist kein Parameter
        hinter dem Schlüsselwort angegeben.

6       Block nicht gefunden
        Bei der Suche nach einem anwenderdefinierten Eintrag konnte der
        angegebene Abschnitt nicht gefunden werden.

10      Videotreiber nicht gefunden
        Der in der Initialisierungsdatei angegebene Videotreiber konnte
        nicht gefunden werden. Das kann drei Gründe haben. Erstens,
        Sie haben im Abschnitt Paths hinter dem Schlüsselwort VDIDir
        ein falsches Verzeichnis angegeben. Zweitens, Sie haben kein
        Verzeichnis angegeben und der Videotreiber befindet sich nicht
        im aktuellen Verzeichnis. Oder, Sie haben einen Videotreiber
        angegeben, der nicht existiert.

11      Kein gültiger Videotreiber
        Der angegebene Videotreiber ist funktionsunfähig. Wahrscheinlich

                               - 87 -


        ist die Datei zerstört worden.

12      Falsche Videotreiberversion
        Die Version des angegeben Videotreibers ist veraltet. Benutzen
        Sie bitte eine neuere Version. Mit dem Hilfsprogramm WHATDRV
        können Sie die Versionsnummer des Treibers ermitteln.

13      Zeichensatz nicht gefunden
        Der in der Initialisierungsdatei angegebene skalierbare Zeichensatz
        konnte nicht gefunden werden. Das kann drei Gründe haben. Erstens,
        Sie haben im Abschnitt Paths hinter dem Schlüsselwort FontDir ein
        falsches Verzeichnis angegeben. Zweitens, Sie haben kein Verzeichnis
        angegeben und der skalierbare Zeichensatz befindet sich nicht im
        aktuellen Verzeichnis. Oder, Sie haben einen skalierbaren Zeichensatz
        angegeben, der nicht existiert.

14      Kein gültiger Zeichensatz
        Der angegebene skalierbare Zeichensatz ist funktionsunfähig.
        Wahrscheinlich ist die Datei zerstört worden.

15      Falsche Zeichensatzversion
        Die Version des angegebenen Zeichensatzes ist veraltet. Bitte
        benutzen Sie eine neuere Version.

20      Menü-Ressourcedatei nicht gefunden
        Die Menüressource existiert nicht oder befindet sich nicht im
        aktuellen Verzeichnis. Unter Umständen haben Sie vergessen, die
        Menübeschreibung zu übersetzen.

21      Menü-Ressourcedatei ist ungültig
        Die Menüressource hat nicht das richtige Format. Unter Umständen ist
        die Datei zerstört worden, oder Sie haben der Menübeschreibung im
        Textformat die Endung '.rsc' gegeben.

22      Fehler beim Laden der Menü-Ressourcedatei
        Während des Ladevorgangs der Menüressource ist ein Fehler aufgetreten.
        Unter Umständen reichte der Arbeitsspeicher nicht, um den Menübaum im
        Speicher aufzubauen, oder die Menüdatei ist nicht lesbar.

30      Hauptapplikation ist bereits gestartet
        Sie haben versucht, ein zweites Mal die Prozedur OpenMainApplication
        aufzurufen. Dies stellt einen schwerwiegenden Programmierfehler dar
        und führt zum sofortigen Abbruch des Programms.

31      Keine Applikation gestartet
        Sie haben versucht, die Dienste des API in Anspruch zu nehmen, ohne
        zuvor mit Hilfe der Prozedur OpenMainApplication die Empfangsprozedur
        anzumelden. Dies stellt einen Programmierfehler dar.

32      Dispatcher versagt: Event kann nicht zugeordnet werden
        Der Dispatcher konnte ein Event nicht weiterleiten. Sie haben einen
        Fehler in deLite entdeckt; bitte informieren Sie uns.

33      Dispatcher versagt: Ungültige Adresse
        Die beim Anmelden eines Klienten angegebene Adresse ist ungültig.
        Dies kann nur durch einen internen Fehler geschehen, bitte informieren
        Sie uns.

40      Zu wenig Heap-Speicher
        Die Speicherverwaltung benötigt bis zu 64K Heap-Speicher, um arbeiten
        zu können. Sie haben weniger als 64K Heap-Speicher für deLite übrig

                               - 88 -


        gelassen.

41      Zu wenig Speicherplatz zum Auslagern auf Festplatte
        Ihre Festplatte hat zu wenig Speicherplatz, um die Auslagerungs-
        dateien aufnehmen zu können. Unter Umständen haben Sie in der
        Initialisierungsdatei im Abschnitt memory den Parameter DiskMin auf
        einen zu hohen Wert gesetzt.

42      Auslagern auf Festplatte nicht möglich
        Der angegebene Pfad für die Auslagerungsdateien ist ungültig. Prüfen
        Sie die Environmentvariable TEMP und den Eintrag SwapPath im
        Abschnitt paths in der Initialisierungsdatei.

43      Fensterstack ist übergelaufen
        Sie haben versucht, mehr Fenster zu öffnen, als auf dem Fensterstack
        Platz finden. In der Standardversion hat der Fensterstack Platz für
        16 Fenstersegmente, allerdings kann ein Fenster je nach Größe mehrere
        Segmente benötigen. Falls Sie im Besitz der Quelltexte sind, ändern
        Sie die Konstante NWindows im API und übersetzen Sie deLite neu.

44      Speicherblock nicht wiedergefunden
        Die Speicherverwaltung kann einen Speicherblock nicht wiederfinden.
        Unter dem angegebenen Handle existiert kein Eintrag in der Seiten-
        tabelle der Speicherverwaltung. Sie haben einen internen Fehler von
        deLite festgestellt, bitte informieren Sie uns.

45      Auslagerungsdatei nicht wiedergefunden
        Die Speicherverwaltung kann eine Auslagerungsdatei nicht wiederfinden.
        Unter Umständen hat Ihr Programm eine der Auslagerungsdateien gelöscht.

46      EMS-Seite nicht wiedergefunden
        Die Speicherverwaltung kann eine Speicherseite nicht im EMS finden.
        Falls Sie selbst EMS verwenden, haben Sie unter Umständen eine Seite
        freigegeben, die Ihnen nicht gehörte.

47      Pageframe für EMS zu klein oder nicht vorhanden
        Die Speicherverwaltung von deLite kann EMS nur verwenden, wenn ein
        zusammenhängender Pageframe von 64k zur Verfügung steht.

48      Ungültiges Speicherhandle
        Die Speicherverwaltung hat eine Inkonsistenz in der Seitentabelle
        festgestellt. Bitte informieren Sie uns.

50      Grafiktreiber nicht geladen
        Sie haben versucht, den Grafiktreiber zu benutzen, ohne daß der
        Grafiktreiber zuvor von der Funktion OpenMainApplication geladen
        wurde. Dies stellt einen schwerwiegenden Programierfehler dar und
        führt zum sofortigen Abbruch des Programms.

51      Zeichensatz nicht geladen
        Sie haben versucht, den skalierbaren Zeichensatz zu benutzen, obwohl
        der Prozedur OpenMainApplication durch Angabe des Modus APP_NOFONT
        signalisiert wurde, daß kein Zeichensatz benötigt wird. Dies stellt
        einen schwerwiegenden Programmierfehler dar und führt zum sofortigen
        Abbruch des Programms.

52      Kein Speicher mehr zum Laden des Grafiktreibers
        Ihr DOS Speicher reicht nicht aus, um den Graphictreiber einzuladen.
        Dieser Fehler führt zum Abbruch des Programms. Versuchen Sie, einige
        Programme aus der Datei CONFIG.SYS oder AUTOEXEC.BAT auszutragen und
        starten Sie das Programm erneut.

                               - 89 -



53      Kein Speicher mehr zum Laden des Zeichensatzes
        Ihr DOS Speicher reicht nicht aus, um den skalierbaren Zeichensatz
        einzuladen. Dieser Fehler führt zum Abbruch des Programms. Versuchen
        Sie, einige Programme aus der Datei CONFIG.SYS oder AUTOEXEC.BAT
        auszutragen und starten Sie das Programm erneut.

54      Zeichensatz nicht vorhanden
        Sie haben der Prozedur SetTextStyle als Zeichensatz einen Wert
        ungleich 0 übergeben. DeLite unterstützt zur Zeit nur einen einzigen
        skalierbaren Zeichensatz - nämlich den in der Initialisierungsdatei
        spezifizierten.


















































                               - 90 -


Anhang C  Kompatibilität zu deLite1.X-Applikationen

Beim  Übergang   von  deLite  1.X  auf  deLite  2.0  sind  einige
wesentliche Änderungen eingetreten.  Dieser Anhang beschreibt die
Neuerungen, die zu Problemen führen können.

Neue Dialoge

DeLite  1.X kannte nur einige  vorgefertigte  Dialoge,  mit denen
durch  mehrfache  Anwendung  die  Kommunikation  mit dem Anwender
durchgeführt wurde. An die Stelle dieser Dialoge tritt ab Version
2.0 ein Dialogmanager.   Damit Ihre alten Applikationen weiterhin
übersetzt  werden  können,  müssen  Sie in die Uses-Anweisung  zu
Beginn Ihres Programmes das Unit DELITE1X aufnehmen. Dadurch wird
Ihr Programm zusätzlich um etwa 12K länger.

Neue Events

An Stelle des einfachen  Event-Records  von deLite  1.X verwendet
deLite   jetzt  einen  varianten   Record  mit  wesentlich   mehr
Elementen.   Das kann zu Konflikten  führen,  wenn  Sie mit einer
WITH-Anweisung   den  Gültigkeitsbereich   einer   Event-Variable
erweitern  und  im  gleichen  Gültigkeitsbereich   Variablennamen
verwenden, die jetzt im Event-Record definiert sind. Beachten Sie
im Zweifelsfall die Deklaration des Typs Event im Kapitel 8.  Vor
der Einführung  des varianten  Event-Records  wurde die ID-Nummer
von Meldungen  der Klasse  Menu im Feld X übergeben.   DeLite 2.0
verwendet hierfür jetzt das Feld MenuItemID.

Keine Ausmaskierung von Move-Events

DeLite      1.X      verfügte       über      die      Prozeduren
EnableMoveDetect/DisableMoveDetect,  mit  denen  die Übermittlung
von Mausbewegungen  verboten  werden  konnte.   Diese Möglichkeit
besteht  nicht mehr, stattdessen  müssen  Sie selbst das Move-Bit
ausmaskieren, falls Sie es nicht benötigen.

Timer-Events

DeLite  2.0 kennt zusätzlich  Timer-Events.   Das sind periodisch
auftretende   Events   der  Klasse  TimerEvent,   mit  denen  das
Cursorblinken innerhalb von Editierfeldern oder die Wiederholrate
von Ereignissen  gesteuert  wird.  Ältere Applikationen,  die die
Abfrage  der Eventklasse  in ihren  Botschaftenempfangsprozeduren
nicht  vollständig  durchführen,  können  jetzt  mit  Ereignissen
konfrontiert werden, mit denen sie nicht rechnen.

Neuer BitBlit

Die    deLite-Versionen     1.X    stellten    eine    allgemeine
BitBlit-Prozedur   zur  Verfügung.    Diese  Funktion  wurde  aus
Geschwindigkeitsgründen modifiziert und beherrscht jetzt nur noch
die von deLite benötigten Spezialfälle. Aus diesem Grund wird die
BitBlit-Funktion  nur  noch  für  interne  Zwecke  zur  Verfügung
gestellt und erscheint nicht mehr in der Dokumentation.