Power-Programmierung

home *** CD-ROM | disk | FTP | other *** search

/ Power-Programmierung / CD1.mdf / pascal / library / dos / delite / ver1 / delite.doc < prev next >

Wrap

Text File | 1991-03-01 | 264.1 KB | 5,969 lines

deLite-Programmierhandbuch Seite 1 __________________________________________________________________ Version 1.0 Februar 1991 (C) BrainLab '91 deLite-Programmierhandbuch Seite 2 Inhalt 1 Einführung.....................................................4 Eigenschaften von deLite.....................................4 Voraussetzungen..............................................4 Über dieses Handbuch.........................................4 Der Aufbau von deLite........................................5 2 Das deLite-Programmiermodell...................................7 Botschaften und Ereignisse...................................7 Callback-Prozeduren..........................................7 Die Anmeldung der Empfangsprozedur...........................8 Der Botschaftenfluss.........................................8 Interaktive Hilfsfunktionen..................................9 Die allgemeine Hilfe......................................10 Die kontextabhängige Hilfe................................10 Menüs und Dialoge...........................................10 Die Maus-Schnittstelle......................................11 Die Tastatur-Schnittstelle..................................11 Konventionen der Datei-Benennung............................12 Die Initialisierungs-Datei..................................12 Konventionen der Maus-und Tastaturbedienung.................13 3 Die Verwendung von Menüs......................................14 Die Definition von Menüs mit dem Menü-Compiler..............14 Die Behandlung von Menü-Meldungen...........................15 Die Modifikation von Menüpunkten............................15 Menüpunkte mit einer Überprüfungsmarke versehen...........15 Menüpunkte sperren........................................16 Ermitteln des Zustandes des Menüpunktes...................16 Ermitteln des Menütextes..................................16 Austauschen eines Menüpunktes.............................16 4 Die Benutzung der Dialoge.....................................17 Der boolesche Dialog........................................18 Der kleine Dialog...........................................18 Der doppelte Dialog.........................................19 Der Listendialog............................................20 Meldungsfenster.............................................23 Eine Meldung ausgeben.....................................23 Eine Fehlermeldung ausgeben...............................23 5 Die Verwendung von Fenstern...................................24 Von Fenstern, Viewports und Klienten........................24 Viewports.................................................24 Fenster...................................................24 Klienten..................................................24 Der Dispatcher............................................26 Die Benutzung von Fenstern..................................26 Die Anmeldung weiterer Klienten.............................27 Klienten mit Fenstern.......................................28 (C) BrainLab '91 deLite-Programmierhandbuch Seite 3 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.............................30 Der Standard-Zeichensatz....................................30 Ausgabe eines Textes im Standardzeichensatz...............30 Ermitteln der Größe eines Zeichens........................30 Der skalierbare Zeichensatz.................................30 Weitere Funktionen..........................................31 Manipulieren von Bitmaps..................................31 Zeichnen von Ikonen.......................................31 7 Die Initialisierungsdatei.....................................33 Aufbau der Initialisierungsdatei............................33 Systemabschnitte............................................34 Datentypen der Initialisierungsdatei........................34 Der Name..................................................35 Der geschützte String.....................................35 Der Longint...............................................35 Listen in der Initialisierungsdatei.........................35 Benutzung der Initialisierungsdatei.........................35 Zugriff auf Namen.........................................36 Zugriff auf geschützte Strings............................36 Zugriff auf Longints......................................37 Benutzung von Listen........................................38 8 Referenz......................................................40 Anhang A Konfigurationsmöglichkeiten........................83 Der Abschnitt Paths.......................................83 Der Abschnitt Hardware....................................83 Der Abschnitt memory......................................83 Der Abschnitt colors......................................84 Anhang B Fehlermeldungen....................................86 (C) BrainLab '91 deLite-Programmierhandbuch Seite 4 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 von nützlichen 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 - Dialoge mit überlappenden Fenstern - Komfortabler Zugriff auf eine Initialisierungsdatei Der Preis, den Sie für diese Vorteile bezahlen, ist gering: deLite macht Ihre Programme nur um etwa 50k länger; eine intelligente Speicherverwaltung sorgt dafür, daß Ihnen auch bei einem Dutzend sich überlappender Fenster der Arbeits- speicher 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 5.5 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 Bild- schirmausschnitte auszulagern, ist etwa ein MByte freier Speicherplatz notwendig. Natürlich benötigen Sie einen grafikfähigen Bildschirmadapter, um deLite verwenden zu können. Ü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. (C) BrainLab '91 deLite-Programmierhandbuch Seite 5 Das vierte Kapitel erläutert die Dialoge, die unter deLite zur Verfügung stehen. Dialoge sind parametrisierbare Ein- gabemasken, über die Sie mit dem Anwender Ihres Programmes kommunizieren. Das fünfte Kapitel behandelt die Aufteilung des Bildschirms in mehrere Teile, die getrennt verwaltet werden. Ein Bei- spielprogramm 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 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 Initiali- sierungsdatei behandelt. Die Initialisierungsdatei enthält die zur Konfiguration Ihres Programmes benötigten Ein- stellungen und wird von deLite benutzt, um den verwendeten Grafiktreiber und einiges mehr zu spezifizieren. Das achte 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 voll- ständigen Deklaration erläutert. Im Anhang finden Sie neben einem Index Hinweise zur Konfiguration und Installation von deLite. Der Aufbau von deLite Das deLite-Toolkit besteht aus zwei Units, vielen Grafik- treibern 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. Ausserdem 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 Ver- fügung. Das API verwendet als weitere Units eine Speicher- verwaltung und eine Liste der sprachabhängigen Zeichenketten. (C) BrainLab '91 deLite-Programmierhandbuch Seite 6 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. So werden Sie, wenn Sie das API verwenden, nie in die Verlegenheit kommen, eine Prozedur zum Umschalten in den Grafikmodus verwenden zu müssen. Im Referenzteil im Kapitel 8 ist zu jeder Prozedur angegeben, zu welchem Unit sie gehört und ob sie zu der Klasse von Funktionen zählt, die eigentlich nur vom API benötigt werden. (C) BrainLab '91 deLite-Programmierhandbuch Seite 7 2 Das deLite-Programmiermodell Die Programmierung unter deLite unterscheidet sich in einigen Belangen deutlich von der gewohnten sequentiellen Program- mierung. Unter einer graphischen Oberfläche hat der Program- mierer 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 Program- miermodells. 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 Verbundtyp Event repräsentiert. TYPE Event = RECORD Class: EventTypes; Attrib: char; x,y: Integer; END; Der Aufzählungstyp Class gibt an, um welche Art von Ereignis es sich handelt. Hier wird grob unterschieden zwischen Maus, Tastatur und einer Reihe von anderen Klassen, die im Anhang genauer aufgelistet sind. Attrib spezifiziert das Ereignis genauer; seine Bedeutung hängt von der Klasse des Ereignisses ab. Bei einem Tastaturereignis wird man hier das Zeichen finden, bei Mausereignissen wird hier angegeben, ob eine der Maustasten betätigt worden ist oder die Maus bewegt wurde. Die Werte X und Y geben bei Mausereignissen die Koordinaten an, an denen das Ereignis stattgefunden hat. Bei Menü- ereignissen wird man in X die Identifikationsnummer des ausgewählten Menüeintrages vorfinden. 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 Proze- duren bezeichnet man auch als Callback-Prozeduren, da eine übergeordnete Instanz sie bei Bedarf aufruft. Vorher aller- dings ist es notwendig, dieser übergeordneten Instanz, in unserem Fall dem deLite-Toolkit, den Namen der Callback- Prozedur mitzuteilen. Diesen Vorgang bezeichnet man als Anmeldung. (C) BrainLab '91 deLite-Programmierhandbuch Seite 8 Die Anmeldung der Empfangsprozedur Der komplette Initialisierungsvorgang von deLite wird nach Aufruf der Prozedur OpenMainApplication durchgeführt. DieserProzedur 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 Ereignis- typen 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 Botschaftenfluss Prinzipiell wäre es möglich, nach der Anmeldung der Empfangs- prozedur die Kontrolle vollständig an deLite abzugeben und erst nach der Beendigung des Programms wieder zum Haupt- programm zurückzukehren. DeLite geht einen anderen Weg, um Ihnen die Möglichkeit offenzuhalten, in den Botschaftenfluss einzugreifen. Das wäre z.B. dann notwendig, wenn Sie den Wunsch hätten, weitere Ereignisse zu generieren, um etwa auf den Systemtimer zu reagieren oder ein rudimentäres Multi- tasking 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: (C) BrainLab '91 deLite-Programmierhandbuch Seite 9 PROGRAM hello; USES Kernel, API; VAR MyEvent : EventTyp; StillRunning : boolean; {$F+ } Procedure HandleMsg(MyMessage: EventTyp); Begin With MyMessage Do Case Class Of Menu : Case x of 0 : StillRunning := false; 10 : ErrWindow(30,30,'Hello world'); End; End; End; {$F- } Begin StillRunning := true; 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 Fluss der Bot- schaften 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 Haupt- programms 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 anzuzeigen. (C) BrainLab '91 deLite-Programmierhandbuch Seite 10 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 Hilfs- funktion 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 kurz- zeitig 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 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össe des Bildschirms begrenzt. Eine weitere Möglichkeit der Kommunikation mit dem Anwender bieten die von deLite zur Verfügung gestellten Dialoge. Hierkönnen Texte eingegeben werden, einfache Ja/Nein-Fragen beantwortet werden, und Auswahlen aus Listen getroffen werden. Zur Zeit gibt es keine Möglichkeit, mit Hilfe eines Dialogeditors eigene, komplexere Dialoge zu entwickeln. (C) BrainLab '91 deLite-Programmierhandbuch Seite 11 Allerdings kann durch die Kombination mehrerer Dialoge, die dann in übereinanderliegenden Fenstern dargestellt werden, eine vergleichbare Interaktion mit dem Anwender durchgeführt werden. 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 heisst, 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 Bildschirm- ausschnitt, 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 Warte- schlange 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 unter- schieden, 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 Tastatur- ereignisse zu reagieren. Tastaturereignisse, die sich auf die Menüs oder aktive Dialoge beziehen, werden vom System automatisch selbst verarbeitet. (C) BrainLab '91 deLite-Programmierhandbuch Seite 12 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 aus- fü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 ver- wendeten binären Dateien tragen einen druckbaren Vorspann, der weitere Informationen gibt. Die Initialisierungs-Datei Die Initialisierungsdatei enthält die Informationen zur Konfiguration Ihres Programms. 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 Speicher- verwaltung. 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 not- wendig 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 Farb- zuordnung, 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. (C) BrainLab '91 deLite-Programmierhandbuch Seite 13 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ü oder den aktiven Dialog - Die ESCAPE-Taste entspricht der rechten Maustaste - Die ENTER-Taste entspricht der linken Maustaste - 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 Maustasten und die alternative Verwendung der ESCAPE/ENTER-Taste sollte auch von Ihnen in dieser Form eingehalten werden. (C) BrainLab '91 deLite-Programmierhandbuch Seite 14 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 Text- editors. Sie können dafür den Editor von Turbo-Pascal ver- wenden. Diese Menübeschreibung wird anschliessend 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 Resource-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 MENUEITEM 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 (kauf- männisches Und) vorausgehen, um zu kennzeichnen, daß der folgende Buchstabe unterstrichen dargestellt werden soll. Optional kann den MENUEITEM-Einträgen nach der Identi- fikationsnummer 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ß MENUEITEM-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 MENUEITEM "&Hi there!" H 101; MENUEITEM "&Goodbye" G 0; END END Übersetzt wird die Menübeschreibung unter Angabe des Datei- namens 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. (C) BrainLab '91 deLite-Programmierhandbuch Seite 15 Die Behandlung von Menü-Meldungen Die Behandlung von Menümeldungen geschieht in der Empfangs- prozedur des Hauptprogramms. Menümeldungen besitzen die Klasse Menu und enthalten im Element X der Botschaft vom Typ Event 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 anschliessende Verlassen oder die Benutzung der 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 Identi- fikationsnummern 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 16 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 ... 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 Identi- fikationsnummer und der Hotkey des neuen Menüpunktes anzu- geben. Procedure ReplaceMenuItem(Menu :hMenu; ID :MenuID; NewItem : String; IDNewItem:MenuID; NewHotKey:char); (C) BrainLab '91 deLite-Programmierhandbuch Seite 17 4 Die Benutzung der Dialoge Dialoge sind wie Menüs eine Möglichkeit, mit dem Anwender eines Programmes zu kommunizieren. Unter deLite reichen die vorgefertigten Dialoge von der Beantwortung einer Ja/Nein- Frage über die Möglichkeit der Texteingabe bis zur Auswahl eines Elementes aus einer Liste. Durch die Kombination dieser elementaren Dialoge lassen sich leistungsfähige Interaktionen aufbauen, wie wir anhand einiger Beispiele zeigen werden. Dialoge sind parametrisierbar. Ihr Aussehen kann mit Hilfe sogenannter Ressourcen verändert werden. Ressourcen sind Verbund-Datentypen (RECORDS), deren Elemente die Infor- mationen über das Erscheinungsbild eines Dialoges tragen. Die Elemente der Ressource müssen vor der Benutzung eines Dialoges belegt werden. Alle Dialogressourcen bieten die Möglichkeit, die Koordinaten des Dialoges auf dem Bildschirm festzulegen und mit mindestens einem Text auf die Bedeutung des Dialoges auf- merksam zu machen. Ausserdem besitzt jede Dialogressource einen Eintrag mit dem Namen topic, der das Stichwort für die kontextabhängige Hilfe enthält. Wird dieses Stichwort mit einem leeren String belegt, wird die F1-Taste ignoriert. Mit Ausnahme des booleschen Dialoges besitzen alle Dialoge getrennte Prozeduren zum Öffnen, Ausführen und Schließen und liefern als unmittelbares Ergebnis eine Information über den Erfolg des Dialoges. Der zurückgelieferte Wert ist vom Typ DlgSet und ist als ein Aufzählungstyp definiert: Type DlgSet = (escaped, success, empty); Die Bedeutung der Werte: escaped Der Dialog wurde mit ESCAPE verlassen success Der Dialog wurde erfolgreich beendet empty Der Dialog wurde mit einer leeren Eingabe beendet So kann bereits vorab ohne eine Analyse des zurückgelieferten Textes entschieden werden, ob die Eingabe ggf. wiederholt werden muß. (C) BrainLab '91 deLite-Programmierhandbuch Seite 18 Der boolesche Dialog Der boolesche Dialog liefert eine Antwort auf eine Ja/Nein -Frage. YesNoDialog = record text: DlgStr; xorg: integer; yorg: integer; topic: namestring; NoSpot: HotSpot; YesSpot: HotSpot; end; function DoYesNoDialog(rsc:YesNoDialog):boolean; Die Elemente NoSpot und YesSpot werden vom System belegt. Der Dialog zeigt zwei Schaltflächen, die mit der Maus ausgewählt werden können. Der kleine Dialog Der kleine Dialog dient dem Einlesen einer Textzeile. Die Prozedur InitSmallDlg öffnet den Dialog an der in der Dialogressource bezeichneten Position. Es können zwei Texte angegeben werden, von denen der erste über und der zweite unterhalb des Eingabefeldes erscheint. Die Länge des Eingabefeldes kann mit der Variablen len in der Ressource vorgegeben werden. Es ist nicht möglich, Texte einzugeben, die länger sind als das in der Dialogressource angegebene Maximum. SmallDialog = record text1: Dlgstr; text2: DlgStr; deflt: DlgStr; xorg: integer; yorg: integer; len: byte; topic: namestring; end; procedure InitSmallDlg(rsc: SmallDialog); function DoSmallDlg(var rsc: SmallDialog; var res:DlgStr): DlgSet; procedure CloseSmallDlg; (C) BrainLab '91 deLite-Programmierhandbuch Seite 19 Der doppelte Dialog Der doppelte Dialog besteht aus zwei Texteingabefeldern und sollte verwendet werden, wenn logisch zusammengehörende Ein- gaben zu machen sind. TwinDialog = record text1: Dlgstr; text2: DlgStr; text3: DlgStr; deflt1: DlgStr; deflt2: DlgStr; xorg: integer; yorg: integer; len: byte; topic1: NameString; topic2: NameString; end; procedure InitTwinDlg(rsc: TwinDialog); function DoTwinDlg1(var rsc:TwinDialog; var res: DlgStr):DlgSet; function DoTwinDlg2(var rsc: TwinDialog; var res: DlgStr):DlgSet; procedure CloseTwinDlg; Die mit deflt1 und deflt2 bezeichneten Werte sind Vorgaben, die in der Regel leer sind. Anderenfalls erscheinen die hier angegebenen Texte in den Texteingabefeldern und können editiert werden. Mit len wird die Länge der Texteingabefelder auf ein Maximum beschränkt. Mit drei Texten wird der Dialog gekennzeichnet; der erste Text erscheint als Titel, während die anderen beiden unter den Texteingabefeldern erscheinen. Für jedes Texteingabefeld kann ein eigenes Hilfestichwort angegeben werden. Da der doppelte Dialog im Grunde genommen aus zwei kleinen Dialogen besteht, muß das den Dialog benutzende Programm selbst sicherstellen, daß die beiden Dialogteile in der richtigen Reihenfolge abgearbeitet werden. Es sollte gewähr- leistet werden, daß man mit ESCAPE vom zweiten Eingabefeld wieder in das erste kommt, bevor der Dialog ganz geschlossen wird. (C) BrainLab '91 deLite-Programmierhandbuch Seite 20 Ein Beispiel zeigt die Anwendung dieses Dialoges. In diesem Fall geht es darum, Anfangs- und Endwert eines Intervalls einzulesen. Nachdem die Dialogressource initialisiert ist und der Dialog mit InitTwinDlg geöffnet wurde, werden in einer repeat-Schleife solange die Dialoge ausgeführt, bis entweder der erste Dialog mit ESCAPE verlassen wurde oder der zweite erfolgreich abgeschlossen wurde. Die Zustandsvariable level gewährleistet, daß man vom zweiten Dialog mit ESCAPE in den ersten zurückgelangt. Beachten Sie, daß in diesem Beispiel die Vorbelegungen deflt1 und deflt2 mit '0' initialisiert wurden. MyRsc.text1 := 'Wertebereich eingeben:'; MyRsc.text2 := 'Anfangswert [Volt]'; MyRsc.text3 := 'Endwert [Volt]'; MyRsc.deflt1 := '0'; MyRsc.deflt2 := '0'; MyRsc.topic1 := 'Spannung A'; MyRsc.topic2 := 'Spannung E'; MyRsc.xorg := 220; MyRsc.yorg := 80; MyRsc.len := 18; InitTwinDlg(MyRsc); level := 0; repeat if level = 0 then If DoTwinDialog1(MyRsc,v1a)=success then level := 1 else level := -1; if Level = 1 then If DoTwinDialog2(MyRsc,v1e)=success then level := 2 else level := 0; until (Level = 2) or (level = -1); CloseTwinDlg; if level = 2 then { ... Dialog erfolgreich durchgeführt } Der Listendialog Der Listendialog erlaubt die Auswahl eines Elementes aus einer Liste von Elementen. Da unter Umständen nicht alle Elemente gleichzeitig auf dem Bildschirm sichtbar gemacht werden können, zeigt das Fenster nur jeweils einen Aus- schnitt, der mit den Cursortasten über die gesamte Liste verschoben werden kann. Dieser Dialog eignet sich besonders gut zur Auswahl einer Datei, kann aber bei geeigneter Programmierung auch für andere Listen verwendet werden. Für den Aufbau der Liste werden zwei Callback-Prozeduren verwendet, deren Typ vordefiniert ist. Mit der Prozedur GetFirst fordert der Listendialog das erste Element an, mit der Prozedur GetNext alle weiteren. Das geschieht solange, bis die Variable eol den logischen wert TRUE annimmt. Ähnliche Funktionen stellt Turbo-Pascal für das Lesen eines Diskettenverzeichnisses zur Verfügung, und wir werden in einem Beispiel zeigen, wie eine Datei aus einem Verzeichnis ausgewählt werden kann. (C) BrainLab '91 deLite-Programmierhandbuch Seite 21 Die eigentliche Liste wird, da sie sehr viel Speicherplatz in Anspruch nimmt, auf dem Heap gespeichert. Es ist Ihre Aufgabe, den Speicher vor der Benutzung zu alloziieren und hinterher wieder freizugeben. Die Listeneinträge sind immer Zeichenketten; numerische Werte müssen also ggf. erst konver- tiert werden. Die Dialogressource des Listendialoges ist umfangreicher als die der anderen Dialoge. Der Ausschnitt aus der Liste, der am Bildschirm in einem Fenster dargestellt wird, kann vollständig parametrisiert werden; die Breite und die Länge des Fensters kann frei gewählt werden. Es empfiehlt sich, die Anzahl der gleichzeitig sichtbaren Einträge nicht zu groß zu wählen, da sonst bei langsamen Rechnern das Verschieben des Ausschnitts unter Umständen nicht schnell genug verläuft. Die Variable PoppedUp wird vom System belegt und für interne Zwecke verwendet. ListDialog = record text: DlgStr; Itemwidth: integer; ListLength: integer; xorg,yorg: integer; GetFirst: ListProc; GetNext: ListProc; PoppedUp: boolean; topic: NameString; end; procedure InitListDialog(rsc: ListDialog; var ThisList: TheList); function DoListDialog(rsc: ListDialog; var res: NameString; var ThisList: TheList):DlgSet; procedure UpdateListDialog(rsc: ListDialog; var ThisList: TheList; JustRedraw: boolean); procedure CloseListDialog; Die Variable vom Typ TheList wird ausschließlich vom System verwendet. Ein Beispiel zeigt die Anwendung des Listen- dialoges bei der Auswahl eines Dateinamens. Die Callback- Prozeduren GetFirstGIF und GetNextGIF werden in die Dialog- ressource eingetragen und verwenden die Turbo-Pascal Prozeduren FindFirst und FindNext zum Ermitteln der Datei- namen. {$F+ } Procedure GetFirstGIF(Var Item: NameString; Var eol: boolean); begin MyRec.Name := ''; FindFirst(WorkDirectory+'\'+'*.gif',ReadOnly,MyRec); If DosError = 0 then eol := false else eol := true; Item := MyRec.Name; end; (C) BrainLab '91 deLite-Programmierhandbuch Seite 22 Procedure GetNextGIF(Var Item: NameString; Var eol: boolean); begin FindNext(MyRec); If DosError = 0 then eol := false else eol := true; Item := MyRec.Name; end; {$F- } procedure DisplayGIFPicture; Var MyRsc : ListDialog; LaList : TheList; LFNAme : DlgStr; result : DlgSet; begin MyRsc.text := 'GIF-Bild auswählen:'; MyRsc.ItemWidth := 10; MyRsc.ListLength := 12; MyRsc.xorg := 70; MyRsc.yorg := 30; MyRsc.topic := 'GIF auswählen'; MyRsc.GetFirst := GetFirstGIF; MyRsc.GetNext := GetNextGIF; result := empty; new(LaList); InitListDialog(MyRsc,LaList); repeat result := DoListDialog(MyRsc,LFname,LaList); if result = success then { ... erfolgreich } until (result = empty) or (result = escaped) CloseListDialog; dispose(LaList); end; Eine Besonderheit des Listendialoges ist die Möglichkeit, die Liste bei bereits geöffnetem Dialog neu einzulesen und die Bildschirmanzeige zu aktualisieren. Das geschieht mit Hilfe der Prozedur UpdateListDialog und wird vorteilhaft bei Dialogen eingesetzt, mit denen ein Element aus einer Liste entfernt werden soll. In diesem Fall wird nach der Auswahl des zu löschenden Elementes durch den Aufruf von UpdateListDialog die Liste erneut erzeugt. In allen anderen Fällen wird die Liste nur ein einziges Mal eingelesen, nämlich beim Aufruf von InitListDialog. Beachten Sie, daß die Callback-Prozeduren mit der Far- Deklaration übersetzt werden müssen. Anderenfalls meldet der Compiler den Fehler illegal procedure or function reference. (C) BrainLab '91 deLite-Programmierhandbuch Seite 23 Meldungsfenster Meldungsfenster sind eine bequeme Möglichkeit, eine einzelne Textausgabe durchzuführen, um den Anwender auf etwas hinzuweisen, ohne selbst ein Fenster öffnen und danach wieder schließen zu müssen. Unter deLite stehen zwei Typen von Meldungsfenstern zur Verfügung, die selbst ein Fenster an einer von Ihnen zu bestimmenden Position öffnen, eine einzelne Zeichenkette ausgeben, auf eine Bestätigung des Benutzers warten und anschließend das Fenster wieder entfernen. Als Bestätigung werden die Tasten ESCAPE/ENTER bzw. die beiden Maustasten akzeptiert. Die beiden Meldungsfenster unterscheiden sich lediglich in der Farbgebung. Das Systemfenster sollte für Hinweise verwendet werden, während das Fehlerfenster auf Fehler aufmerksam machen sollte. Eine Meldung ausgeben Die Prozedur SysWindow gibt eine Zeichenkette in einem Fenster aus. Die Position wird in Pixeln angegeben, die Größe des Fensters richtet sich nach der Länge der Zeichenkette. procedure SysWindow(x,y: integer; errtext: string); Eine Fehlermeldung ausgeben Die Prozedur ErrWindow gibt eine Zeichenkette in einem Fehlerfenster aus. Ein Fehlerfenster hat in der Standard- einstellung eine rote Hintergrundfarbe. procedure ErrWindow(x,y: integer; errtext: string); Die Farbe des Fehlerfensters kann, wie alle anderen Farben auch, in der Initialisierungsdatei spezifiziert werden. (C) BrainLab '91 deLite-Programmierhandbuch Seite 24 5 Die Verwendung von Fenstern Von Fenstern, Viewports und Klienten Im zweiten Kapitel haben Sie bereits erfahren, daß der Bild- schirm im Normalfall in zwei Bereiche aufgeteilt ist. Amoberen 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 ver- fü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öglich- keiten 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 heisst, 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 Schliessen 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 schliessen. 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 Schliessen 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 25 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 Empfangsprozedur für Botschaften. Die Prozedur DispatchMessage verteilt Maus- ereignisse anhang der den Klienten zugeordneten Viewports. So ist gewährleistet, daß die Empfangsprozedur des Haupt- programms 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 Beispiel- programm 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 Beispiel- programm 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. (C) BrainLab '91 deLite-Programmierhandbuch Seite 26 In der nächsten Version von deLite wird es möglich sein, einem Klienten Streifen an einem der Bildschirmränder zuzu- teilen und damit die Grösse des Viewports der Haupt- applikation 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 anschliessend ein Mausereignis im Viewport der Haupt- applikation stattgefunden hat. In diesem Fall hat der Benut- zer 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 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 heissen 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 selb- ständig den von ihnen verdeckten Bildschirminhalt und rekonstruieren ihn nach dem Schliessen 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. (C) BrainLab '91 deLite-Programmierhandbuch Seite 27 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össe 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 Schliessen des Fensters mit CloseWindow ist der zuvor verwendete Viewport wieder aktiv. Es ist wichtig, daß vor dem Befehl zum Schliessen 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. Die Anmeldung weiterer Klienten In einem Beispiel werden wir zeigen, wie der Bildschirm in vier gleichgrosse Segmente aufgeteilt wird. Die Haupt- applikation 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; (C) BrainLab '91 deLite-Programmierhandbuch Seite 28 XEND := x2; YEnd := y2; end; ID1 := OpenSubApplication(Fenster1,0,'Fenster 1', XOrg,YOrg,Xorg+XSize, YOrg+YSize); 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 ID's 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. Klienten mit Fenstern In manchen Fällen möchte man ein Fenster mit den Eigen- schaften eines Klienten öffnen. Das ist immer dann der Fall, wenn das Fenster dazu verwendet werden soll, graphische Operationen in Abhängigkeit von der Maus auszuführen, bzw. wenn ein Klient nur temporär benötigt wird und der von ihm überdeckte Bildschirminhalt gerettet werden soll. Immer dann, wenn ein Fenster Mausereignisse auswerten soll, ist es notwendig, Fenster und Klient zu kombinieren. Ein kleines Zeichenprogramm, das in einem Fenster laufen soll, oder ein selbsterstellter Dialog mit Schaltflächen für die Maus würde zu dieser Kategorie zählen. In diesem Fall ist einfach zunächst ein Fenster zu öffnen und dann ein Klient auf den gleichen Koordinaten anzumelden. Nachdem der Klient mit ReceiveExclusive den Dispatcher deaktiviert hat, empfängt er normalisierte Mausereignisse. (C) BrainLab '91 deLite-Programmierhandbuch Seite 29 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) (C) BrainLab '91 deLite-Programmierhandbuch Seite 30 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) 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. 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 zwei verschiedenen Zeichensätzen und müssen in der Initialisierungsdatei angeben, welchen Zeichensatz Sie verwenden möchten. Zur Zeit stehen die Zeichensätze SIMPLEX 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 31 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 Skalie- rung der Zeichen in beiden Koordinatenachsen. 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. Manipulieren von Bitmaps Bitmaps sind rechteckige Bildschirmausschnitte. Mit der Prozedur BitBlit kann eine Kopie einer Bitmap an eine beliebige Position auf dem Bildschirm gezeichnet werden. Die Ursprungs- und Zielfläche dürfen sich dabei auch überlappen. 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 Auswahl- markierung 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. 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. (C) BrainLab '91 deLite-Programmierhandbuch Seite 32 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; (C) BrainLab '91 deLite-Programmierhandbuch Seite 33 7 Die Initialisierungsdatei Die Initialisierungsdatei enthält Informationen zur Konfi- guration Ihrer Applikation und wird beim Start des Programms interpretiert. So kann Ihre Applikation bequem vom Anwender an unterschiedliche Umgebungen angepasst 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 Infor- mationen 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 eingefasst 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 Abschnitts- bezeichnern, noch bei den Schlüsselwörtern zwischen Groß- und Kleinschreibung. Die Erweiterung der Initialisierungsdatei um eigene Abschnitte und Schlüsselwörter unterliegt keinen Ein- schrä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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 34 [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 MaxOpenFiles=10 ;ein LongInt Systemabschnitte Einige Abschnitte und Schlüsselwörter der Initiali- sierungsdatei 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 Grafik- treibern 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. (C) BrainLab '91 deLite-Programmierhandbuch Seite 35 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 Der LongInt ist ein ganzzahliger, numerischer Wert. Er ist identisch zum gleichnamigen Turbo Pascal Typ und umfasst 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 ver- wenden. 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 36 alle als boolsche Funktionen deklariert. Ist das Funktions- ergebnis TRUE, so war die Zugriffsaktion erfolgreich und der gesuchte Parameter befindet sich in der als Variablen- parameter ü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. Warder 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ässt sich der zu verwendende skalierbare Zeichensatz erfragen: 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: (C) BrainLab '91 deLite-Programmierhandbuch Seite 37 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 Begin 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); WaitConfirm; CloseWindow End Else ErrWindow(0,0, 'MaxFiles wurde nicht spezifiziert'); End; (C) BrainLab '91 deLite-Programmierhandbuch Seite 38 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ässt. Der diesem Programmfragment zugrunde liegende Abschnitt einer Initialisierungsdatei ist unserer Beispiel- datei entnommen. Der Abschnitt ist dort unter [Farbtabelle] zu finden. (C) BrainLab '91 deLite-Programmierhandbuch Seite 39 Type FarbEintrag = Record LayerName : String[15]; 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üsselwortnicht gefunden'); End; (C) BrainLab '91 deLite-Programmierhandbuch Seite 40 8 Referenz Dieses Kapitel enthält eine alphabetische Liste aller Funktionen und Prozeduren des deLite-Toolkit. 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. __________________________________________________________________ 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 Dis- patcher 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 weissen Kreises an der Position (100,100) mit dem Radius 100. Um die obere Hälfte eines Kreises zu zeichnen, müssten Anfangs- und Endwinkel vertauscht werden. Siehe auch Circle __________________________________________________________________ Bar Kernel Deklaration Procedure Bar(x1,y1,x2,y2 : Integer; Color : Byte); (C) BrainLab '91 deLite-Programmierhandbuch Seite 41 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 __________________________________________________________________ BitBlit Kernel Deklaration Procedure BitBlit(x1,y1,x2,y2, DeltaX,DeltaY : Integer); Funktion Kopiert einen rechteckigen Bildschirmausschnitt an eine neue Position Parameter x1,y1 linke obere Ecke der Ursprungsfläche x2,y2 linke obere Ecke der Zielfläche DeltaX, DeltaY Grösse der Fläche Hinweis Ursprungs- und Zielfläche dürfen sich überlappen. __________________________________________________________________ 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 ID Identifikationsnummer des Menüeintrages wCheck MF_CHECKED oder MF_UNCHECKED Hinweis Die Konstanten MF_CHECKED und MF_UNCHECKED sind im Unit API definiert. Die Angabe von MF_CHECKED bewirkt das Setzen einer Überprüfungsmarke, während MF_UNCHECKED die Überprüfungsmarke 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; (C) BrainLab '91 deLite-Programmierhandbuch Seite 42 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 __________________________________________________________________ CloseListDialog API Deklaration Procedure CloseListDialog Funktion Schliesst den geöffneten Listendialog Hinweis Die Prozedur überprüft nicht, ob tatsächlich ein Listendialog geöffnet war. Jeder andere, ebenfalls offene Dialog würde genauso geschlossen werden. Siehe auch InitListDialog, DoListDialog, UpdateListDialog __________________________________________________________________ CloseMainApplication API Deklaration Procedure CloseMainApplication Funktion Beendet die laufende Anwendung und schaltet zurück in den Textmodus. Hinweis Alle erforderlichen Deinstallationen wie die Ent- fernung des Maus- und des Grafiktreibers und die Frei- gabe allen belegten Speicherplatzes werden durch- geführt. Ein Aufruf von CloseMainApplication ist üblicherweise die letzte Anweisung einer deLite- Applikation. Siehe auch OpenMainApplication (C) BrainLab '91 deLite-Programmierhandbuch Seite 43 __________________________________________________________________ CloseSmallDlg API Deklaration Procedure CloseSmallDlg Funktion Schliesst einen offen kleinen Dialog Hinweis Die Prozedur CloseSmallDlg prüft nicht, ob tatsächlich ein kleiner Dialog offen ist. Jeder andere offene Dialog würde ebenfalls geschlossen werden. Siehe auch InitSmallDlg, DoSmallDlg __________________________________________________________________ CloseSubApplication API Deklaration Procedure CloseSubApplication(ID: Integer) Funktion Schliesst eine Subapplikation. Der entsprechende Klient wird aus der Klientenliste entfernt. Parameter ID Identifikationsnummer des Klienten Hinweis Der vom Viewport des Klienten zuvor belegte Bild- schirmbereich wird nicht wiederhergestellt. Siehe auch OpenSubApplication __________________________________________________________________ CloseTwinDlg API Deklaration Procedure CloseTwinDlg Funktion Schliesst einen geöffneten doppelten Dialog Hinweis Die Prozedur CloseTwinDlg überprüft nicht, ob tat- sächlich ein doppelter Dialog geöffnet war. Jeder andere geöffnete Dialog würde ebenfalls geschlossen werden. Siehe auch InitTwinDlg, DoTwinDlg1, DoTwinDlg2 __________________________________________________________________ CloseWindow API Deklaration Procedure CloseWindow Funktion Schliesst ein mit OpenWindow geöffnetes Fenster Hinweis Da auch alle Dialogfunktionen ihre Fenster mit OpenWindow öffnen, würde CloseWindow auch einen gerade offenen Dialog schliessen. Tatsächlich bestehen die Prozeduren zum Schliessen 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 __________________________________________________________________ DisableMoveDetect Kernel (C) BrainLab '91 deLite-Programmierhandbuch Seite 44 Deklaration Procedure DisableMoveDetect Funktion Verbietet die Übermittlung von Mausbewegungen Hinweis Normalerweise führen nicht nur Betätigungen der Maustasten, sondern auch die Bewegung der Maus zu Mausereignissen. Die Detektion von Mausbewegungen ist nur dann notwendig, wenn ein Programm die Möglichkeit bieten soll, Objekte am Bildschirm mit der Maus zu bewegen. In Programmen, die diese Eigenschaft nicht ausnutzen, kann die Übermittlung von Bewegungs- informationen der Maus mit dieser Prozedur verboten werden. Ob eine Mausbewegung stattgefunden hat oder eine Taste betätigt wurde, ist bitkodiert im Feld Attrib einer Botschaft vermerkt. Siehe auch EnableMoveDetect __________________________________________________________________ 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 Empfangs- prozedur 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 Empfangs- prozedur der Hauptapplikation zugeschickt. Sollte ein Klient sich als exclusiver Klient angemeldet haben, erhält er auch Mausereignisse, die sich nicht inner- halb 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 Botschaften- empfangsprozedur, 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. Soist sichergestellt, daß die Botschaft doch noch beim (C) BrainLab '91 deLite-Programmierhandbuch Seite 45 richtigen Empfänger ankommt. Siehe auch GetEvent, PostMessage __________________________________________________________________ DoListDialog API Deklaration Function DoListDialog(rsc: ListDialog; var res: NameString; var ThisList: TheList): DlgSet Funktion Führt den durch rsc und ThisList definierten Listen- dialog aus, der zuvor mit InitListDialog geöffnet wurde. Parameter rsc Der Verbundtyp ListDialog res enthält nach der Ausführung den ausge- wählten Eintrag ThisList Ein Zeiger auf einen Verbund vom Typ TheListType Die Variable rsc muß vor dem Öffnen des Listendialoges mit InitListDialog initialisiert werden. Die Zeiger- variable ThisList muß vor dem Öffnen des Listen- dialoges mit new erzeugt werden und nach dem Schlie- ßen mit dispose freigegeben werden. Die dazugehörige Verbundvariable wird von InitListDialog belegt und enthält unter anderem die Liste der Einträge. Ergebnis Der zurückgelieferte Wert vom Typ DlgSet gibt an, ob die Ausführung des Listendialoges erfolgreich war. Der Typ DlgSet ist als Aufzählungstyp deklariert und kann folgende Werte annehmen: success Es wurde ein Element ausgewählt. escaped Der Dialog wurde mit ESCAPE verlassen empty Es wurde ein leeres Element ausgewählt Hinweis Falls das Ergebnis des Dialoges den Wert escaped hat, ist der in res zurückgelieferte String ungültig. Beispiel {$F+ } Procedure GetFirstReport(Var Item: NameString; Var eol: boolean); begin MyRec.Name := ''; FindFirst(WorkDirectory+'\'+'*.rpt',ReadOnly,MyRec); If DosError = 0 then eol := false else eol := true; Item := MyRec.Name; end; Procedure GetNextReport(Var Item: NameString; Var eol: boolean); begin FindNext(MyRec); Item := MyRec.Name; If DosError = 0 then eol := false else eol := true; (C) BrainLab '91 deLite-Programmierhandbuch Seite 46 end; {$F- } procedure ViewReport; Var MyRsc : ListDialog; LaList : TheList; LFname : NameString; result : DlgSet; n : integer; f : text; TheString:string; begin MyRsc.text := 'Report auswählen:'; MyRsc.ItemWidth := 10; MyRsc.ListLength := 12; MyRsc.xorg := 20; MyRsc.yorg := 20; MyRsc.topic := 'Report'; MyRsc.GetFirst := GetFirstReport; MyRsc.GetNext := GetNextReport; new(LaList); InitListDialog(MyRsc,LaList); repeat result := DoListDialog(MyRsc,LFname,LaList); if result = success then begin OpenWindow(60,30,60+68*FontX,30 + 16*FontY); n := -1; assign(f,WorkDirectory + '\'+ LFname+REPSuffix); reset(f); repeat n := succ(n); readln(f,TheString); WriteWin(TheString,1,n,DialogStat); until eof(f); close(f); WaitConfirm; CloseWindow; end; until (result = empty) or (result = escaped); CloseListDialog; dispose(LaList); end; Die Prozedur ViewReport öffnet einen Listendialog, der mit Hilfe der Callback-Prozeduren GetFirstReport und GetNext- Report eine Liste aller Dateien mit der Endung '.rpt' an- zeigt. Bei erfolgreicher Auswahl eines Eintrages wird die Datei in einem Fenster angezeigt. Siehe auch InitListDialog, CloseListDialog, UpdateListDialog __________________________________________________________________ DoSmallDlg API Deklaration Function DoSmallDlg(var rsc: SmallDialog; var res: DlgStr):DlgSet Funktion Führt den durch rsc spezifizierten, bereits geöffneten (C) BrainLab '91 deLite-Programmierhandbuch Seite 47 kleinen Dialog aus Parameter rsc Der Verbundtyp SmallDialog res enthält nach der Ausführung das Ergebnis Ergebnis Der zurückgelieferte Wert vom Typ DlgSet gibt an, ob die Ausführung des Dialoges erfolgreich war. Der Typ DlgSet ist als Aufzählungstyp deklariert und kann folgende Werte annehmen: success Der Dialog wurde erfolgreich ausgeführt escaped Der Dialog wurde mit ESCAPE beendet empty Es wurde ein leerer String eingegeben Hinweis Der Verbundtyp rsc muß vor der Öffnung des Dialoges initialisiert worden sein. Falls das Ergebnis des Dialoges den Wert escaped hat, ist der in res zurückgelieferte String ungültig. Der Wert deflt in der Dialogressource wird aktualisiert. Beispiel procedure WorkDir; Var MyRsc : SmallDialog; Fname : DlgStr; OldDir: String; ready : boolean; result: DlgSet; begin ready := false; MyRsc.text1 := 'Arbeitsverzeichnis wechseln:'; MyRsc.text2 := ''; MyRsc.xorg := 250; MyRsc.yorg := 120; MyRsc.len := 32; MyRsc.topic := 'Arbeitsverzeichnis'; MyRsc.deflt := WorkDirectory; GetDir(0,OldDir); InitSmallDlg(MyRsc); repeat result := DoSmallDlg(MyRsc, fname); if result = success then begin (*$i- *) ChDir(Fname); (*$i+ *) if ioresult = 0 then Begin ready := true; WorkDirectory := Fname; UpString(WorkDirectory); End else ErrWindow(MyRsc.xorg+10, MyRsc.yorg+32,'Falscher Pfad'); ChDir(OldDIr); end; until ready or (result = escaped); CloseSmallDlg; end; (C) BrainLab '91 deLite-Programmierhandbuch Seite 48 Das Beispielprogramm belegt die globale Variable Work- Directory mit einer neuen, mit Hilfe eines kleinen Dialoges einzulesenden Pfadangabe. Der Dialog wird solange aufge- rufen, bis ein gültiger Pfad eingegeben wurde oder der Dialog mit ESCAPE abgebrochen wurde. Ein Fehlerfenster weist ggf. auf eine ungültige Ein- gabe hin. Getestet wird der neu eingegebene Pfad, indem mit Hilfe der Turbo-Pascal Prozedur ChDir ver- sucht wird, das aktuelle Verzeichnis auf den Pfad zu setzen. Das vorher gesetzte Verzeichnis wird zuvor geholt und am Ende wieder gesetzt. Siehe auch InitSmallDlg, CloseSmallDlg __________________________________________________________________ DoTwinDlg1 API Deklaration Function DoTwinDlg1(var rsc: TwinDialog; var res: DlgStr):DlgSet Funktion Führt den ersten Teil eines durch rsc spezifizierten, zuvor geöffneten doppelten Dialoges aus Parameter rsc Der Verbundtyp TwinDialog res enthält nach der Ausführung das Ergebnis Ergebnis Der zurückgelieferte Wert vom Typ DlgSet gibt an, ob die Ausführung des Dialoges erfolgreich war. Der Typ DlgSet ist als Aufzählungstyp deklariert und kann folgende Werte annehmen: success Der Dialog wurde erfolgreich ausgeführt escaped Der Dialog wurde mit ESCAPE beendet empty Es wurde ein leerer String eingegeben Hinweis Der Verbundtyp rsc muß vor der Öffnung des Dialoges initialisiert worden sein. Falls das Ergebnis des Dialoges den Wert escaped hat, ist der in res zurückgelieferte String ungültig. Beispiel MyRsc.text1 := 'Wertebereich eingeben:'; MyRsc.text2 := 'Anfangswert [Volt]'; MyRsc.text3 := 'Endwert [Volt]'; MyRsc.deflt1 := '0'; MyRsc.deflt2 := '0'; MyRsc.topic1 := 'Spannung A'; MyRsc.topic2 := 'Spannung E'; MyRsc.xorg := 220; MyRsc.yorg := 80; MyRsc.len := 18; InitTwinDlg(MyRsc2); level := 0; repeat if level = 0 then If DoTwinDlg1(MyRsc,va) then level := 1 else level := -1; if Level = 1 then If DoTwinDlg2(MyRsc,ve) then (C) BrainLab '91 deLite-Programmierhandbuch Seite 49 begin level := 2; result := success; end else level := 0; until (level = 2) or (level = -1); CloseTwinDlg; if level = 2 then { ... } Das Beispiel zeigt die Anwendung des doppelten Dialoges für die Eingabe eines Intervalls. Da der doppelte Dialog eigentlich aus zwei kleinen Dialogen in einem einzigen Fenster besteht, muß der Programmierer selbst sicherstellen daß die Dialoge in der richtigen Reihenfolge aufgerufen werden und daß es möglich ist, mit ESCAPE vom zweiten Dia- log in den ersten zurückzuwechseln. Siehe auch InitTwinDlg, DoTwinDlg2, CloseTwinDlg __________________________________________________________________ DoTwinDlg2 API Deklaration Function DoTwinDlg2(var rsc: TwinDialog; var res: DlgStr):DlgSet Funktion Führt den zweiten Teil eines durch rsc spezifizierten, zuvor geöffneten doppelten Dialoges aus Parameter rsc Der Verbundtyp TwinDialog res enthält nach der Ausführung das Ergebnis Ergebnis Der zurückgelieferte Wert vom Typ DlgSet gibt an, ob die Ausführung des Dialoges erfolgreich war. Der Typ DlgSet ist als Aufzählungstyp deklariert und kann folgende Werte annehmen: success Der Dialog wurde erfolgreich ausgeführt escaped Der Dialog wurde mit ESCAPE beendet empty Es wurde ein leerer String eingegeben Hinweis Der Verbundtyp rsc muß vor der Öffnung des Dialoges initialisiert worden sein. Falls das Ergebnis des Dialoges den Wert escaped hat, ist der in res zurückgelieferte String ungültig. Siehe auch InitTwinDlg, DoTwinDlg1, CloseTwinDlg __________________________________________________________________ DoYesNoDialog API Deklaration Function DoYesNoDialog(rsc: YesNoDialog):boolean Funktion Führt einen booleschen Dialog aus Parameter rsc Der Verbundtyp YesNoDialog Der Typ YesNoDialog ist im API wie folgt definiert: (C) BrainLab '91 deLite-Programmierhandbuch Seite 50 TYPE YesNoDialog = record text : DlgStr; xorg : integer; yorg : integer; topic : namestring; NoSpot : HotSpot; YesSpot: HotSpot; end; Die Bedeutung der zu belegenden Einträge lautet text Titel des Dialoges xorg,yorg Position der linken oberen Ecke des Dialoges topic Das Stichwort für die Hilfsfunktion Die Einträge NoSpot und YesSpot werden vom System belegt. Der Titel des Dialoges erscheint oberhalb der Schaltflächen und sollte die mit Ja oder Nein zu beantwortende Frage beinhalten. Ergebnis Das Ergebnis des Dialoges wird unmittelbar als boolescher Wert mitgeteilt Hinweis Die Funktion DoYesNoDialog bietet dem Anwender in einem Fenster zwei Schaltflächen mit der Beschriftung Ja und Nein an, aus denen er eine Auswahl mit der Maus oder der Tastatur treffen kann. Wird der Dialog mit ESCAPE verlassen, entspricht das der Auswahl der Schaltfläche Nein. Dieser Dialog muß nicht manuell geöffnet oder geschlossen werden, sondern führt diese Funktionen selbst aus. Beispiel Procedure DoQuit Var MyRsc : YesNoDialog; Begin MyRsc.text := 'Programm beenden?'; MyRsc.xorg := 100; MyRsc.yorg := 100; MyRsc.topic := 'Quit'; If DoYesNoDialog(MyRsc) then quit := true; End; __________________________________________________________________ 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 ver- wendet Color Zeichenfarbe des Icons (C) BrainLab '91 deLite-Programmierhandbuch Seite 51 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 Tech- nischen Universität Berlin in ein Fenster in die Mitte des Bildschirms zeichnet und danach auf Bestätigung wartet. Die Konstantendefinition 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; Siehe auch DrawSysIcon __________________________________________________________________ DrawSysIcon Kernel Deklaration Procedure DrawSysIcon(ScrX, ScrY : Integer; Nr, Attrib: Byte) (C) BrainLab '91 deLite-Programmierhandbuch Seite 52 Funktion Zeichnet eines der Systemicons Parameter ScrX, ScrY Position der linken oberen Ecke Nr Nummer des Systemicons Attrib Attribut des Systemicons Hinweis deLite besitzt ein Reihe vordefinierter Systemicons, die in erster Linie vom API selbst benutzt werden. Ein Beispiel für die Verwendung der Systemicons sind z.B. die Pfeile am Scrollbar des Listdialoges. Für das Attribut werden derzeit nur die Werte 0 und 1 verwendet. Dabei beteudet Attrib=0 Systemicon wird in der Farbe Schwarz auf weissen Hintergrund gezeichnet. Attrib=1 Systemicon wird in der Farbe Weiss auf schwarzem Hintergrund gezeichnet (inverse Darstellung). Das Beispiel zeichnet das Systemicon Nummer 0 (den Pfeil nach oben) in die linke, obere Ecke des aktuellen ViewPort. Das Icon wird dabei mit dem Attribut 0, also Schwarz auf weissem Hintergrund gezeichnet. Beispiel DrawSysIcon(0,0,0,0); Siehe auch DrawNormIcon __________________________________________________________________ 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 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 von- einander 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 Weiss in der linken oberen Ecke des aktuellen ViewPort aus. Die Höhe der Zeichen beträgt 32 Pixel auf dem Bildschirm. (C) BrainLab '91 deLite-Programmierhandbuch Seite 53 Beispiel DrawText(0,0,32,32,'Hello, world',15) Siehe auch InitFont __________________________________________________________________ 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 __________________________________________________________________ EnableMoveDetect Kernel Deklaration Procedure EnableMoveDetect Funktion erlaubt die Meldung von Mausbewegungen Hinweis Hebt die Wirkung von DisableMoveDetect auf. Danach werden Bewegungen der Maus wieder gemeldet. Siehe auch DisableMoveDetect, GetEvent __________________________________________________________________ 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 ausge- geben. Diese Farbe ist standardmässig rot, kann aber in der Initialisierungsdatei umdefiniert werden. Die Prozedur ErrWindow wartet nach dem Öffnen des Fensters und der Ausgabe des Textes auf eine Bestätigung des Benutzers. Mit einer der Maustasten bzw. ENTER oder (C) BrainLab '91 deLite-Programmierhandbuch Seite 54 ESCAPE kann das Fenster entfernt 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 Botschaften- warteschlange komplett gefüllt wird. Ohne einen Aufruf von FlushQueue würden die zwischenzeitlich ange- fallenen 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 __________________________________________________________________ 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 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ück- geliefert Hinweis Jeder Grafiktreiber ist mit einem Namen versehen. 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 55 Deklaration Procedure GetEvent(Var Event : EventTyp) Funktion liefert das nächste Ereignis aus der Ereigniswarte- schlange 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. Type EventTypes = (LeMouse, MouseUnNormalized, NormKey, AltKey, CtrlKey, FKey, Menu, DoRedraw, void); EventTyp = Record Class : EventTypes; { Art des Events } Attrib : char; x,y : integer; { wo ist es passiert } End; Die Verbundkomponente Class enthält die Art des Erei- gnisses oder der Botschaft. Abhängig von ihrem Inhalt werden die folgenden drei Verbundkomponenten unter- schiedlich 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 beschrie- benen 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 Mausereig- nisses. Die Mausereignisse vom Typ LeMouse sind normaliesiert, 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 = Mittl. Maustaste wurde gedrückt $40 = Mittl. Maustaste wurde losgelassen MouseUnnormalized Ein Mausereignis ist aufge- treten. Für die Verbundkomponente Attrib gilt das gleiche wie bei LeMouse. Die (C) BrainLab '91 deLite-Programmierhandbuch Seite 56 Verbundkomponenten x und y enthalten die Position des Mausereignisses. Das Ereig- nis konnte nicht normalisiert werden, fand also außerhalb des Viewports des empfangenden Klienten statt. NormKey Ein normale Taste wurde gedrückt. Die Verbundkomponente 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 x 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. void Die Ereigniswarteschlange ist leer. Siehe auch DispatchMessage, FlushQueue, PostMessage __________________________________________________________________ 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 Stich- worte 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 57 Deklaration Function GetFontX: Byte Funktion liefert die Breite eines Zeichens des Standard- zeichensatzes 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 Standard- zeichensatzes 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üs- selwort gesucht 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 Initialisierungs- datei einen vom Benutzer festgelegten Wert für die (C) BrainLab '91 deLite-Programmierhandbuch Seite 58 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üs- selwort 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 59 LAYER= 5 6 CONTINUOUS LAYER= 6 14 CONTINUOUS LAYER= 7 7 CONTINUOUS Type FarbEintrag = Record LayerName : String[15]; 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 60 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 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üs- selwort 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 Initialsierungsdatei einen vom Anwender definierten Namen, in diesem Fall eine Pfadangabe. Die Initialisierungsdatei enthalte folgenden Abschnitt: [paths] VDIDir=C:\TURBO\DELITE\DRIVER ;Verzeichnis der Treiber (C) BrainLab '91 deLite-Programmierhandbuch Seite 61 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üs- selwort 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 entnimmt der Initialisierungsdatei einen geschützen String und gibt ihn in einem Fenster aus in der linken oberen Ecke aus. Die Initialisierungsdatei enthalte den folgenden Abschnitt: [User] WelcomeText="Hallo Frank, schön dich zu sehen" ;ein String Procedure WelcomeUser; Var TheUser : String; 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 __________________________________________________________________ (C) BrainLab '91 deLite-Programmierhandbuch Seite 62 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 Haupt- applikation mit dieser Prozedur erst in Erfahrung gebracht werden. Die meisten Operationen mit Klienten sind allerdings nur dann wichtig, wenn die Bild- schirmfläche auf mehrere Klienten verteilt werden soll. Beispiel SuspendApplication(GetMainID) veranlasst den Dispatcher, den Viewport der Haupt- applikation bei der Verteilung von Botschaften unbe- rü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 ver- wendeten 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 dieser Funktion. Siehe auch GetMaxY, PortMaxX, PortMaxY __________________________________________________________________ GetMaxY Kernel (C) BrainLab '91 deLite-Programmierhandbuch Seite 63 Deklaration Function GetMaxY: Integer Funktion liefert die vertikale Grösse der Grafikseite Ergebnis Das Ergebnis vom Typ Integer entspricht der grössten 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 bitkodiert 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 64 Parameter Menu Zeiger auf das Menü ID Identifikationsnummer des Menüeintrages StrPtr enthält nach der Ausführung des 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 Hilfedatei Parameter Name enthält nach der Ausführung das Stichwort eol wird TRUE, falls keine weiteren Stich- worte 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 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 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 übergenen (C) BrainLab '91 deLite-Programmierhandbuch Seite 65 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 übergenen 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. Siehe auch GetParaInteger, GetParaString, GetInitFileListFirst, GetInitFileListNext __________________________________________________________________ GetParaString Kernel Deklaration Function GetParaString(Var Line: String; Var OutVal: ValueString): Boolean Funktion Extrahiert einen geschüzten String aus dem in Line übergenen String. Parameter Line Enthält die Eingabezeile OutVal Enthält nach der Ausführung den geschützen String (C) BrainLab '91 deLite-Programmierhandbuch Seite 66 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(Var Str: String): Integer Funktion liefert die tatsächliche Länge eines Menütextes Parameter Str Der Menütext Ergebnis Die tatsächliche Länge ist die Länge abzüglich der Anzahl der im Text enthaltenen Ampersand-Symbole ("&"), die kennzeichnen, daß der folgende Buchstabe zu unterstreichen ist __________________________________________________________________ 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: Hinweis Existiert unter der angegebenen ID kein Klient, haben alle Parameter des zurückgelieferten Viewports den Wert 0. Siehe auch SetTheViewPort __________________________________________________________________ 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 anschliessend neu gezeichnet. Möchte man sehr viele Grafikoperationen hintereinander ausführen, (C) BrainLab '91 deLite-Programmierhandbuch Seite 67 kann es sein, daß das Retten des Mauszeigers mehr Zeit in Anspruch nimmt als die eigentlichen Grafik- operationen. 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 __________________________________________________________________ InitListDialog API Deklaration Procedure InitListDialog(rsc: ListDialog; var ThisList: TheList) Funktion Öffnet den durch rsc spezifizierten Listendialog Parameter rsc Der Verbundtyp ListDialog ThisList Ein Zeicher auf einen Verbund vom Typ TheListType Die Variable rsc ist wie folgt definiert: ListDialog = record text : DlgStr; Itemwidth : integer; ListLength: integer; xorg,yorg : integer; GetFirst : ListProc; GetNext : ListProc; PoppedUp : boolean; topic : NameString; end; Die Einträge müssen vor dem Aufruf von InitListDialog initialisiert werden. Die Bedeutung der einzelnen Einträge lautet text Der Titel des Dialoges Itemwidth Die Anzahl der Spalten der angezeigten Liste ListLength Die Anzahl der Zeilen der Liste. Dieser Wert entspricht der Anzahl der gleich- zeitig dargestellten Einträge xorg,yorg Die Koordinate der linken oberen Ecke des Dialoges GetFirst Callback-Prozedur zum Holen des ersten Elementes der Liste GetNext Callback-Prozedur zum Holen des nächsten Elementes der Liste PoppedUp gibt an, ob der Dialog bereits offen ist, und wird vom System belegt topic Das Stichwort für die Hilfsfunktion (C) BrainLab '91 deLite-Programmierhandbuch Seite 68 Die Callback-Prozeduren GetFirst und GetNext vom Typ ListProc sind folgendermassen definiert: Type ListProc=Procedure(Var Item: NameString; Var eol: Boolean) Dabei wird in Item der Name des Listenelementes übergeben und in der booleschen Variable eol angezeigt, ob das Ende der Liste bereits erreicht ist. Bei Öffnen des Listendia- loges wird die Liste solange durch Aufrufe der Callback- Prozeduren erweitert, bis die Variable eol den Wert TRUE annimmt. Die Callback-Prozeduren müssen mit der Compiler- direktive FAR {$F+ } übersetzt werden, anderenfalls meldet der Compiler den Fehler illegal procedure or function reference. Die Variable ThisList ist wie folgt definiert TheListType = record NItems : integer; eol : boolean; Item : NameString; ItemStr: NameString; Items : array[1..MaxItems] of nameString; ListPtr: integer; TOLW : integer; Spots : array[1..MaxListSpot] of HotSpot; UpSpot : HotSpot; DwnSpot: HotSpot; Elevate: HotSpot; end; TheList = ^TheListType; Die Zeigervariable ThisList muß vor dem Öffnen des Listendialoges mit new erzeugt werden und nach dem Schliessen mit dispose freigegeben werden. Die dazugehörige Verbundvariable wird beim Aufruf von InitListDialog vom System belegt und enthält unter anderem die Liste der Einträge. Hinweis Der Listendialog zeigt in einem Fenster die Liste der Elemente an. Falls nicht alle Elemente gleichzeitig dargestellt werden können, kann der angezeigte Ausschnitt verschoben werden (scrolling). Die maximale Anzahl von Einträgen der Liste ist von der Konstanten MaxItems begrenzt. Siehe auch DoListDialog, UpdateListDialog, CloseListDialog __________________________________________________________________ InitSmallDlg API Deklaration Procedure InitSmallDlg(rsc: SmallDialog) Funktion Öffnet den durch rsc spezifizierten kleinen Dialog Parameter rsc Der Verbundtyp SmallDialog (C) BrainLab '91 deLite-Programmierhandbuch Seite 69 Die Variable rsc ist wie folgt definiert: SmallDialog = record text1: Dlgstr; text2: DlgStr; deflt: DlgStr; xorg : integer; yorg : integer; len : byte; topic: namestring; end; Die Einträge müssen vor dem Aufruf von InitSmallDialog initialisiert werden. Die Bedeutung der einzelnen Einträge lautet text1 Der Titel des Dialoges text2 Der Untertitel des Eingabefeldes deflt Die Vorbelegung des Eingabefeldes xorg,yorg Die Koordinate der linken oberen Ecke des Dialoges len Die Länge des Eingabefeldes topic Das Stichwort für die Hilfsfunktion Die Vorbelegung deflt muß mit einem Leerstring belegt werden, falls das Eingabefeld initial leer sein soll. Hinweis Der kleine Dialog bietet in einem Texteingabefeld die Möglichkeit der Texteingabe. Die Anzahl der ein- gegebenen Zeichen ist auf die Länge des Eingabefeldes begrenzt. Der in text1 angegebene Text erscheint oberhalb des Eingabefeldes, der in text2 angegebene unterhalb. Siehe auch DoSmallDlg, CloseSmallDlg __________________________________________________________________ InitTwinDlg API Deklaration Procedure InitTwinDlg(rsc: TwinDialog) Funktion Öffnet den durch rsc spezifizierten doppelten Dialog Parameter rsc Der Verbundtyp TwinDialog Die Variable rsc ist wie folgt definiert: TwinDialog = record text1 : Dlgstr; text2 : DlgStr; text3 : DlgStr; deflt1: DlgStr; deflt2: DlgStr; xorg : integer; yorg : integer; len : byte; (C) BrainLab '91 deLite-Programmierhandbuch Seite 70 topic1: NameString; topic2: NameString; end; Die Einträge müssen vor dem Aufruf von InitTwinDialog initialisiert werden. Die Bedeutung der einzelnen Einträge lautet text1 Der Titel des Dialoges text2 Der Untertitel des ersten Eingabefeldes text3 Der Untertitel des zweiten Eingabefeldes deflt1 Die Vorbelegung des ersten Eingabefeldes deflt2 Die Vorbelegung des zweiten Eingabefeldes xorg,yorg Die Koordinate der linken oberen Ecke des Dialoges len Die Länge des Eingabefeldes topic1 Das Stichwort für die Hilfsfunktion für das erste Eingabefeld topic2 Das Stichwort für die Hilfsfunktion für das zweite Eingabefeld Die Vorbelegungen deflt1 und deflt2 müssen mit einem Leerstring belegt werden, falls die entsprechenden Eingabefelder initial leer sein soll. Hinweis Der doppelte Dialog bietet in zwei Texteingabefeldern die Möglichkeit der Texteingabe. Die Anzahl der eingegebenen Zeichen ist auf die Länge der Eingabe- felder begrenzt. Siehe auch DoTwinDlg, CloseTwinDlg __________________________________________________________________ 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 weisse diagonale Linie von links oben nach rechts unten. __________________________________________________________________ OnLineHelp API Deklaration Procedure OnLineHelp(topic: String) (C) BrainLab '91 deLite-Programmierhandbuch Seite 71 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. Solltedie 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. 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 erfolg- reich 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. Anschliessend wird die Initialisierungsdatei geöffnet und der Eintrag für den verwendeten Grafiktreiber (C) BrainLab '91 deLite-Programmierhandbuch Seite 72 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 begin Write('Programm kann nicht gestartet werden.') WriteLn(' Fehler:',LaunchResult); end; 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 __________________________________________________________________ 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 zur Zeit nicht verwendet, 0 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 73 Hauptapplikation, der nach wie vor aktiv ist, überlappen. Deshalb muß der Viewport der Haupt- applikation 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 Schliessen 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 Schliessen 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 1 Text unterstrichen Hinweis Es wird der (nicht skalierbare) Standardzeichensatz verwendet. Siehe auch FontX, FontY __________________________________________________________________ (C) BrainLab '91 deLite-Programmierhandbuch Seite 74 PortMaxX Kernel Deklaration Function PortMaxX : Integer Funktion liefert die horizontale Grösse des aktuellen Viewports Ergebnis Das Ergebnis vom Typ Integer entspricht der grössten 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össe des aktuellen Viewports Ergebnis Das Ergebnis vom Typ Integer entspricht der grössten 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) 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 __________________________________________________________________ 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 75 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. __________________________________________________________________ SetMousePos Kernel Deklaration Procedure SetMousePos(x,y : Integer) Funktion setzt die Koordinaten der Maus Parameter x,y absolute Koordinaten der neuen Maus- position Hinweis Die Koordinaten beziehen sich nicht auf den aktuell gesetzten Viewport. Siehe auch SetMouseRange __________________________________________________________________ (C) BrainLab '91 deLite-Programmierhandbuch Seite 76 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 Bewegungs- bereich 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 _________________________________________________________________ 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 77 SetProjectName bekannt gemacht werden. Diese Prozedur kann auch dazu verwendet werden, auf fremde Initialisierungsdateien zuzugreifen. Siehe auch OpenMainApplication __________________________________________________________________ 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 __________________________________________________________________ ShowMouse Kernel Deklaration Procedure ShowMouse Funktion Macht den Mauszeiger wieder sichtbar Hinweis Nachdem der Mauszeiger durch einen Aufruf von HideMouse etwa während häufiger Grafikoperationen 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 __________________________________________________________________ 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 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 78 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. Mit einer der Maustasten bzw. ENTER oder ESCAPE kann das Fenster entfernt werden. Bis auf die andere Hintergrundfarbe unterscheidet sich diese Prozedur nicht von ErrWindow. Siehe auch OpenWindow, WriteWin, ErrWindow __________________________________________________________________ TheHelp API Deklaration Procedure TheHelp Funktion Ruft die allgemeine Hilfe auf Hinweis Die allgemeine Hilfe wird vom System aufgerufen, wenn im Menübalken die Hilfeoption ausgewählt wurde oder die Taste F1 betätigt wurde, ohne daß ein Kontext für die kontextabhängige Hilfe aktiv war. Die allgemeine Hilfe zeigt in einem Listendialog eine Liste von Stichworten, die einer Datei mit dem Namen des Projektes und der Endung '.hlp' entnommen wurden. Aus dieser Liste können Stichworte ausgewählt werden. Siehe auch OnlineHelp __________________________________________________________________ UpCase Kernel Deklaration Function UpCase(InChar: Char): Char; Funktion liefert zu einem Zeichen den entsprechenden Gross- buchstaben Parameter InChar Das Zeichen Ergebnis Zurückgeliefert wird der Grossbuchstabe. Bei Zahlen und Symbolen wird keine Wandlung vorgenommen 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 __________________________________________________________________ UpdateListDialog API Deklaration Procedure UpdateListDialog(rsc: ListDialog; var ThisList: TheList; JustRedraw: Boolean) (C) BrainLab '91 deLite-Programmierhandbuch Seite 79 Funktion Zeichnet einen Listendialog neu und liest ggf. die Liste neu ein Parameter rsc Der Verbundtyp ListDialog ThisList Ein Zeiger auf einen Verbund vom Typ TheListType JustRedraw Der Wert FALSE gibt an, daß die Liste neu eingelesen werden soll Die Variable rsc muß vor dem Öffnen des Listendialoges mit InitListDialog initialisiert werden. Die Zeigervariable ThisList muß vor dem Öffnen des Listendialoges mit new erzeugt werden und nach dem Schliessen mit dispose freigegeben werden. Die dazugehörige Verbundvariable wird von InitListDialog belegt und enthält unter anderem die Liste der Einträge. Hinweis Diese Funktion kann vorteilhaft dazu verwendet werden, Dialoge zu schreiben, die es erlauben, aus einer Liste Elemente zu entfernen. Nach der Auswahl eines Elementes mit DoListDialog kann das Element gelöscht werden; nach einem Aufruf von UpdateListDialog wird die aktualisierte Liste angezeigt, ohne daß der Dialog erst geschlossen und wieder geöffnet werden muß. Beispiel procedure DelKontrastKurve; Var MyRsc : ListDialog; LaList : TheList; result : DlgSet; LFname : NameString; begin MyRsc.text := 'Datei auswählen:'; MyRsc.ItemWidth := 20; MyRsc.ListLength := 6; MyRsc.xorg := 160; MyRsc.yorg := 50; MyRsc.topic := 'Kontrast löschen'; MyRsc.GetFirst := GetFirstKontrast; MyRsc.GetNext := GetNextKontrast; result := empty; new(LaList); InitListDialog(MyRsc,LaList); repeat result := DoListDialog(MyRsc,LFname,LaList); if result = success then begin DelKontrast(LFname); UpdateListDialog(MyRsc,LaList,false); end; until (result = empty) or (result = escaped); CloseListDialog; dispose(LaList); end; Das Beispielprogramm erlaubt die Auswahl eines Elementes aus der Liste, löscht das entsprechende Element, und aktualisiert mit UpdateListDialog die angezeigte Liste. Es können solange Elemente gelöscht werden, bis der Dialog abgebrochen wird oder ein leeres Element ausgewählt wird. (C) BrainLab '91 deLite-Programmierhandbuch Seite 80 Siehe auch InitListDialog, DoListDialog, CloseListDialog __________________________________________________________________ UpString Kernel Deklaration Procedure UpString(Var TheString: String) Funktion Wandelt einen String in Grossbuchstaben 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 wurde 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 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 weisser Farbe in die erste Zeile des Viewports. Siehe auch OutTextAPI __________________________________________________________________ XORBAR Kernel Deklaration Procedure XORBar(x1,y1,x2,y2: Integer) (C) BrainLab '91 deLite-Programmierhandbuch Seite 81 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 recheckige 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 Recheck in der Graphik. Dazu wird eine Exklusiv-Oder Verknüpfung verwendet. Wird XORRectangle 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. (C) BrainLab '91 deLite-Programmierhandbuch Seite 82 Beispiel XORRectangle(0,0,100,100); {Recheck invertieren } WaitConfirm; XORRectangle(0,0,100,100); {Invertierung wieder aufheben } Siehe auch Rectangle, XORBar, XORLine (C) BrainLab '91 deLite-Programmierhandbuch Seite 83 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 Ver- zeichnis zu lesen. Dieser Abschnitt ist nützlich, falls Sie mehrere deLite-Applikationen einsetzen und die Videotreiber und Zeichensatzdateien nur ein einziges Mal auf Ihrer Fest- platte 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 Zeichen- satz 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 84 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 Vor- belegung verwendet deLite den Wert 4. Wenn Sie hier einen unrealistisch hohen Wert angeben, verwendet deLite niemals EMS-Speicher zum Aus- lagern. 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 Um- stä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 Laufzeit- fehler 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 Bild- schirmdarstellung 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 Bildschirmhinter- grundes. 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 Dialog- feldern DlgFrame definiert die Farbe der Umrahmung von Dialog- feldern DlgMsg definiert die Farbe von Statusmeldungen in Dialogfeldern DlgText definiert die Farbe von Texten in Editier- (C) BrainLab '91 deLite-Programmierhandbuch Seite 85 feldern DlgEditBkGnd definiert die Hintergrundfarbe von Editier- feldern DlgListText definiert die Farbe von Texten in Listen- auswahlfeldern DlgListBkGnd definiert die Hintergrundfarbe von Listen- auswahlfeldern DlgListHiText definiert die Farbe markierter Einträge in Listenauswahlfeldern DlgListHiBkGnd definiert die Hintergrundfarbe markierer Einträge in Listenauswahlfeldern ErrorText definiert die Farbe von Texten in Fehler- fenstern ErrorBkGnd definiert die Hintergrundfarbe von Fehler- fenstern SystemText definiert die Farbe von Texten in Meldungs- fenstern 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 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 spezi- fiziert. 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 spezi- fiziert. 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 an- gegeben. 6 Block nicht gefunden (C) BrainLab '91 deLite-Programmierhandbuch Seite 87 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 Ver- zeichnis. Oder, Sie haben einen Videotreiber angegeben, der nicht existiert. 11 Kein gültiger Videotreiber Der angegebene Videotreiber ist funktionsunfähig. Wahr- scheinlich ist die Datei zerstört worden. 12 Falsche Videotreiberversion Die Version des angegeben Videotreibers ist veraltet. Benutzen Sie bitte eine neuere Version. Mit dem Hilfs- programm 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 Ver- zeichnis 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 funktions- unfä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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 88 Während des Ladevorgangs der Menüressource ist ein Fehler aufgetreten. Unter Umständen reichte der Arbeits- speicher 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 gelassen. 41 Zu wenig Speicherplatz zum Auslagern auf Festplatte Ihre Festplatte hat zu wenig Speicherplatz, um die Aus- lagerungsdateien 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, aller- dings 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. (C) BrainLab '91 deLite-Programmierhandbuch Seite 89 44 Speicherblock nicht wiedergefunden Die Speicherverwaltung kann einen Speicherblock nicht wiederfinden. Unter dem angegebenen Handle existiert kein Eintrag in der Seitentabelle der Speicher- verwaltung. 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 ver- wenden, 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 schwer- wiegenden 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. 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 (C) BrainLab '91 deLite-Programmierhandbuch Seite 90 des Programms. Versuchen Sie, einige Programme aus der Datei CONFIG.SYS oder AUTOEXEC.BAT auszutragen und starten Sie das Programm erneut.