TopWare Tools

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

/ TopWare Tools / TOOLS.iso / tools / top1309 / twizard.doc < prev next >

Wrap

Text File | 1994-02-21 | 85.0 KB | 2,689 lines

Turbo Wizard Version 1.xx Dokumentation der Sharewareversion Copyright (c) 1994 by Ulrich Albrecht - 2 - Inhalt Vorbemerkung...........................................................3 Rechtliches............................................................5 Einführung.............................................................6 Installation...........................................................8 EMS Unterstützung....................................................8 Das Arbeiten mit dem Wizard............................................9 Elemente der Arbeitsumgebung.........................................9 Projekte anlegen und öffnen..........................................9 Objekte einfügen und bearbeiten......................................9 Bearbeitung von Dialogobjekten......................................11 Die Quelltexterzeugung..............................................13 Der Testmodus.......................................................13 Turbo Vision 1.0 oder 2.0 ?.........................................14 Der Ressourceneditor..................................................15 Das Hilfekonzept von Turbo Vision und Turbo Wizard....................16 Der Hilfekontext eines Objektes.....................................16 Festlegung des Hilfekontext.........................................16 Die Funktion TStatusLine.Hint(AHelpCtx): String;....................17 Der Hilfecompiler TVHC.EXE..........................................17 Der Hilfeeditor des Turbo Wizard....................................18 Die Prozedur ShowHelp...............................................20 Statuszeilen..........................................................22 Reihenfolge und Auswertung der Statuszeilen.........................22 Grenzen und Probleme bei Statuszeilen...............................24 Der Quelltext einer Statuszeile.....................................24 Menübalken............................................................25 Der Quelltext eines Menübalkens.....................................26 Dialoge...............................................................27 Grundsätzliche Optionen.............................................27 Ressourcendateien verwenden.........................................28 Stack schonen.......................................................28 Record auf dem Stack oder Heap anlegen..............................28 Recordtyp lokal oder global deklarieren.............................29 Zentrierung in X- oder Y-Richtung...................................29 Der Typ TWDialog....................................................29 Reihenfolge der Dialogelemente......................................29 Die HandleEvent-Methode eines abgeleiteten Dialogtypen..............30 Verschiedene Möglichkeiten der Befehlauswertung.....................31 Der Datenrecord.......................................................32 Bedeutung der Dialogelementnamen....................................32 Globale oder lokale Deklaration.....................................32 Records auf dem Heap einrichten.....................................32 Initialisierung des Records.........................................33 Prozedurbezeichner....................................................34 Die TWApplication.HandleEvent-Methode...............................35 Die Schnittstelle zu eigenen Prozeduren und Funktionen..............37 Einbinden eigener Units und externer Prozeduren.......................38 Anhang A: Dateischlüssel..............................................39 Anhang B: Coming Attractions..........................................42 - 3 - Vorbemerkung Turbo Wizard ist Shareware. Sie dürfen dieses Programm 30 Tage kostenfrei ausprobieren und auf seine Tauglichkeit testen. Wenn Sie Turbo Wizard danach weiterhin nutzen wollen, sollten Sie sich registrieren lassen. Wenn Sie sich nicht registrieren lassen, sollten Sie nach dieser Zeitspanne aufhören, mit dem Programm zu arbeiten. Es klingt zugegebenermaßen unglaubwürdig, aber die Gefahr, von einem Blitz erschlagen zu werden steigt proportional zur Anzahl der unregistrierten Programme auf Ihrer Festplatte. Die auffällige Häufung von Naturkatastrophen in den letzten Jahren ist ein eindrucksvoller Beweis. Für all diejenigen, die Wind und Wetter nicht fürchten, gibt es allerdings noch ein paar andere Gründe, sich registrieren zu lassen: ■ Eine Vollversion, die im 286er Protected Mode läuft, die Einbindung eines Compilers und Debuggers möglich macht und einige weitere Features von Turbo Vision 2.0 unterstützt. In dieser erweiterten Version können Sie Prototypen direkt aus dem Wizard heraus compilieren, ausführen und (wenn Sie einen Debugger haben) sogar debuggen. Außerdem verfügt dieses Programm über eine ausgefeiltere Fehlerbehandlung und über die Möglichkeit, für alle Menübefehle eigene Hotkeys zu definieren. ■ Sie erhalten eine erweiterte Dokumentation (auf Diskette). ■ Sie erhalten das Recht auf telefonischen oder schriftlichen Support. Ich rufe allerdings in der Regel nicht zurück. ■ Sie können als registrierter Anwender sicher sein, daßz ich Ihre Verbesserungsvorschläge und Änderungswünsche bedeutend wohlwollender behandle, als dumme Ratschläge von Trittbrettfahrern. Je mehr Registrierungen ich erhalte desto größer ist der Anreiz, Turbo Wizard zu einem mächtigeren Programmgenerator auszubauen. Und Sie wären dann der erste, der davon erfährt. ■ Es kostet nur 50 DM. Wenn Sie die Arbeitszeit, die Sie mit dem Wizard bei der Programmierung sparen können, bezahlen müßten, käme Sie das sicherlich teurer. Natürlich bin ich auch an Fehlerreports und Hinweisen nichtregistrierter Anwender interessiert. Shareware lebt davon, daß die Anwender ihre Wünsche direkt an den/die Entwickler übermitteln, die wiederum schneller auf solche Wünsche reagieren können als große Softwarehäuser mit starreren Strukturen. Sharewareautoren leben allerdings auch davon, daß sich ab und zu mal ein Anwender registrieren läßt. - 4 - Wenn Sie Turbo Wizard also geprüft und für gut (oder zumindest brauchbar) befunden haben und weiterhin nutzen möchten senden Sie einen Verrechnungsscheck über DM 50 an folgende Adresse: Ulrich Albrecht ThomashofStraße 23 52070 Aachen Tel. 0241/153824 Geben Sie bitte deutlich und lesbar Namen bzw. Firmennamen, Anschrift und Diskettenformat an. Die Lieferung erfolgt frei Haus auf dem Postwege. Der Preis versteht sich als Gebühr für eine Einzelplatzlizenz. - 5 - Rechtliches Ich übernehme keinerlei Haftung oder Gewährleistung für die Funktionsfähigkeit dieses Programms oder für Schäden irgendwelcher Art, Datenverluste eingeschlossen, die bei der Arbeit mit diesem Programm entstehen. Das Programm und diese Dokumentation unterliegen den jeweils gültigen urheberrechtlichen Bestimmungen. Für die Weitergabe gelten folgende Regeln: Privatpersonen dürfen die Sharewareversion von Turbo Wizard frei kopieren und weitergeben, solange diese Dokumentation, die Hilfedatei TWIZARD.HLP und die Dateien XHELP60.TPU, XHELP70.TPU und XHELP70.TPP mit weitergegeben werden. Händler dürfen Turbo Wizard kopieren und (wiederum nur in Verbindung mit den genannten Dateien) für eine angemessene Aufwandsentschädigung weitergeben. Sie müssen ihre Kunden dabei darauf hinweisen, daß mit diesem Betrag keineswegs ein Erwerb der Nutzungsrechte an diesem Programm verbunden ist, sondern daß es sich dabei um eine Art Kopiergebühr handelt. Die Weitergabe des Wizard zusammen mit handbuchähnlichen Druckerzeugnissen ("Bookware") bedarf meiner ausdrücklichen, schriftlichen Genehmigung. Die Bezeichnungen Turbo Pascal, Borland Pascal mit Objekten und Turbo Vision sind geschützte Warenzeichen der Firma Borland International. Rücksicht auf ihre freie Verwendbarkeit benutzt. Turbo Wizard wurde geschrieben und erzeugt mit Borland Pascal für Objekte 7.0 unter Benutzung von Turbo Vision Copyright (c) 1994 by Ulrich Albrecht Die Programmdatei TWIZARD.EXE wurde mit dem Exe-Komprimierer LZEXE 0.91 von Fabrice Bellard behandelt, einem bemerkenswerten Programm, das dessen Autor dankenswerterweise als Public Domain veröffentlicht hat. - 6 - Einführung Turbo Wizard ist ein Programm, das Sie bei der Programmierung mit Turbo Vision unterstützt, der objektorientierten Bibliothek von Bildschirmelementen, die mit den Pascalcompilern der Firma Borland ab der Version 6.0 mitgeliefert wird. Turbo Wizard erzeugt den Quelltext zu Bildschirmelementen wie Menüs und Dialogen, die Sie einfach mit der Maus am Bildschirm "zusammenklicken". Sie können mit Turbo Wizard auf einfache Weise: ■ Menübalken erstellen. ■ Statuszeilen für unterschiedliche Programmkontexte bereitstellen. ■ Modale und nichtmodale Dialoge entwerfen, die (beinahe) alle Standardelemente enthalten können, die in Turbo Vision vorgesehen sind. Zusätzlich können Sie die Quelltexterzeugung so steuern, daß auch von Ihnen selbst abgeleitete Objekte in der Regel einfach einzubinden sind. Turbo Wizard deklariert für Sie auch die passenden Datenrecords zum einfachen Datenaustausch mit diesen Schnittstellenobjekten. Sie können Standard-Dialogtypen verwenden, aber auch die neu entworfenen Dialoge als eigene, von TDialog abgeleitete Objekttypen deklarieren. In diesem Fall implementiert der Wizard für Sie einen passenden Constructor Load oder Init, eine Methode Store, eine Methode HandleEvent und legt einen individuellen TStreamRec an, um diesen neuen Typen direkt in einem Stream verwenden zu können. ■ Ein komplexes Online-Hilfesystem inklusive alphabetisch sortiertem Index und Hinweisen in der Statuszeile erstellen. Erstellen Sie die Programmdokumentation gleich mit der Oberfläche! ■ Sofort lauffähige Prototypen erstellen. Bevor Sie eine einzige Zeile Programmcode eingetippt haben, läßt sich die Oberfläche und die mit der Oberfläche verbundene Programmlogik bereits überprüfen und vorführen. In der Vollversion können Sie dazu sogar die Kommandozeilenversion des Compilers aufrufen und den Prototypen testen, ohne den Wizard verlassen zu müssen. (Die Vollversion läuft im 286-Protected Mode und erfordert einen DPMI-Server. Die Möglichkeit der Weitergabe der entsprechenden von Borland mitgelieferten Programme innerhalb eines Sharewarepaketes erscheint mir rechtlich zumindest zweifelhaft. Daher die Einschränkung.) ■ Das Stream-Konzept von Turbo Vision und die Verwendung von Ressourcendateien, die bisher mit nicht unbeträchtlichem zusätzlichen Arbeitsaufwand verbunden war, nutzen, ohne dafür eine einzige Zeile Quelltext mehr schreiben zu müssen. Sie erhalten automatisch kürzere, besser lesbare und besser zu wartende Programme, die zudem auch noch über mehr Arbeitsspeicher verfügen können. - 7 - Turbo Wizard kann Ihnen eine ganze Menge Arbeit abnehmen. Trotzdem sollten Sie mit den grundlegenden Konzepten von Turbo Vision vertraut sein und OOP von Ooops! zu unterscheiden wissen, denn erstens ist die Kommentierung des vom Wizard erzeugten Quelltextes spärlich (eine Verbesserung steht im Pflichtenheft für spätere Updates), zweitens erzeugt der Wizard ja nur die Benutzeroberfläche eines Programmes, das Sie selbst noch mit Funktionalität auszustatten haben und drittens sollten Sie eh nicht alles glauben, was irgendein Programm Ihnen erzählt. Auf eine ausführliche Vorstellung der in Turbo Vision vorgesehenen Objekte und Prinzipien möchte ich bewußt verzichten. Die Handbücher von Borland sind ausgezeichnete Wegweiser in die Materie. Andere "Fachbücher" der einschlägigen Verlage sind manchmal ganz brauchbar (häufig auch von schlichter Dämlichkeit und eine gerechte Strafe für Raubkopierer), zumindest aber zahlreich. Um den Ausführungen dieser Dokumentation folgen zu können sollten Sie... ■ wissen, was Units sind und wie Includedateien vom Pascalcompiler behandelt werden; ■ die wichtigsten Elemente einer Turbo Vision Applikation (Desktop, Menü, Statuszeile, Dialoge etc.) erkennen, wenn Sie sie sehen; ■ wissen, was man unter einem Ereignis (Event) versteht und was die Methode HandleEvent der Turbo Vision Objekte macht; ■ wissen, was ein Objekt ist, wie man Objekte ableitet, was eine virtuelle Methode ist und welche Regeln für das Überschreiben virtueller Methoden gelten; ■ eine zumindest vage Ahnung davon haben, was ein Stream ist. Turbo Wizard verfügt über eine umfangreiche Onlinehilfe, die ihnen einen schnellen Einstieg ermöglichen sollte. Ich möchte Ihnen außerdem das Programm THELP.COM empfehlen, ein speicherresidentes Programm, das Borland seinen Pascalcompilern beilegt, und das ihnen zusätzlich die Onlinehilfe aus dem Hause Borland zur Verfügung stellt. - 8 - Installation Sie werden Turbo Wizard vermutlich in einer "gepackten" Datei erhalten haben, sei diese nun selbstentpackend oder nicht. Die Installation von Turbo Wizard ist in jedem Falle einfach: ■ Legen Sie ein eigenes Unterverzeichnises (z.B. C:\TWIZARD) an; ■ Dekomprimieren Sie das gepackten Archives in das gewünschte Verzeichnis. Da selbstentpackende Archive manchmal keine Angaben über ein Zielverzeichnis verstehen, ist es sicherer, die Archivdatei vorher in dieses Verzeichnis zu kopieren. Da der Wizard mehrere Dateien gleichzeitig geöffnet hält, ist es bei Problemen angebracht, den Eintrag FILES=?? in der Datei CONFIG.SYS zu erhöhen. Turbo Wizard scheint unter Windows keine Probleme zu bereiten. Die Netzwerkfähigkeit ist nicht überprüft worden, es bestehen allerdings gewisse Zweifel, da die Dateibehandlungsmethoden von Borland Pascal nicht 100% "netzwerksicher" sind. EMS Unterstützung Da Turbo Wizard EMS-Speicher nutzen kann, um seine Overlays und Ressourcen schneller laden zu können, kann es (vor allem bei etwas träger Festplatte) sinnvoll sein, 256 kb EMS zu konfigurieren. - 9 - Das Arbeiten mit dem Wizard Elemente der Arbeitsumgebung Die Elemente, aus denen sich die Oberfläche des Wizard zusammensetzt (Fenster, Rollbalken Buttons etc.) sind größtenteils Standardelemente aus Turbo Vision. Die Bedienung dürfte Ihnen daher von der Arbeit in der Turbo bzw. Borland Pascal IDE bekannt sein. (Tatsächlich wurde die Oberfläche des Wizard mit einigen Vorversionen entworfen) Eine erweiterte Funktionalität bieten die Listboxen, in denen der Wizard Konstanten und Bezeichner anzeigt. Mit der Taste ENTF können Sie hier zumeist einzelne Bezeichner (nach Rückfrage) löschen. Bei Listboxen, zu denen eine Eingabezeile gehört, können Sie einen zu editierenden Begriff in der Listbox anwählen, um ihn in die Eingabezeile zu laden. Eine Änderung müssen Sie immer mit der Eingabetaste bestätigen. Projekte anlegen und öffnen Viele Eingaben, die Sie während der Arbeit an einem Prototypen oder auch nur an einzelnen Dialogobjekten vornehmen, werden vom Wizard in einer Projektdatei (Standarddateiendung .PRJ) verwaltet. Sie stellt somit den Bezugsrahmen her, innerhalb dessen der Quelltext sinnvoll erzeugt und letztendlich zu einem lauffähigen Prototypen verbunden werden kann. Die Dateinamen der Quelltextdateien werden folgerichtig vom Namen dieser Projektdatei abgeleitet (einen Schlüssel zu Namen und Inhalt der einzelnen Dateien finden Sie im Anhang A bzw. in der Onlinehilfe des Wizard). Vor Ihrer ersten Arbeitssitzung sollten Sie ein eigenes Unterverzeichnis für ein Projekt anlegen. Wenn Sie nun den Wizard starten können Sie im Menüpunk "Datei│Projekt öffnen..." den Namen eines neu anzulegenden Projektes eingeben. Der Wizard speichert bei Programmende den Namen des zuletzt bearbeiteten Projektes und den gesamten Desktop in einer Konfigurationsdatei (TWIZARD.CFG und TWIZARD.DSK) und lädt diese Einstellungen automatisch beim nächsten Programmstart. Sie können immer nur ein Projekt zugleich bearbeiten. Objekte einfügen und bearbeiten Wenn Sie eine Projektdatei öffnen bzw. neu anlegen wird das Menü um einige Punkte erweitert. Die größte Bedeutung hat dabei das Menü "Objekte". In ihm finden Sie alle Befehle, um Dialoge, Dialogelemente, Menüs und Statuszeilen in die Arbeitsfläche einzufügen. Wenn Sie einen Menübalken oder eine Statuszeile einfügen, erscheinen diese an einem festgelegten Ort. Bei Dialogen und Dialogelementen erscheint auf der Arbeitsfläche zunächst ein türkisfarbenes Viereck, das Sie mit der Maus über den Bildschirm bewegen und dessen Abmessungen Sie wie bei einem Fenster ändern können, indem Sie an seiner rechten unteren Ecke ziehen. Plazieren Sie dieses Rechteck an der gewünschten Stelle, - 10 - indem Sie die rechte Maustaste drücken. ESC bricht den Vorgang ab. Achten Sie darauf, daß Sie Dialogelemente nur in den obersten Dialog einfügen können und daß ein solches Element vollständig innerhalb des Dialoges liegen muß. Die Größe eines bereits eingefügten Dialoges können Sie ebenfalls durch Ziehen an der unteren rechten Ecke ändern (eine Eigenschaft, die diese Dialoge im späteren Programm natürlich nicht mehr haben). Anzahl der einzufügenden Schaltfelder direkt aus der Höhe des Feldes bestimmt. Wenn Sie allerdings beim Drücken der Maustaste die STRG-Taste niederhalten, können Sie diese Voreinstellung ändern. Dies ist sinnvoll, wenn Sie eine größere Anzahl von Schaltern in diesem Feld unterbringen möchten: Turbo Vision ist so freundlich, in einem solchen Fall die Schalter nebeneinander darzustellen. - 11 - Bearbeitung von Dialogobjekten Für die Bearbeitung bereits eingefügter Objekte gelten ein paar einfache Regeln: Wenn Sie ein Objekt in einem Dialog mit der linken Maustaste anklicken und zugleich die STRG-Taste drücken, können Sie es mit der Maus einfach über den Bildschirm ziehen. Wenn Sie ein Objekt (auch Menüs und Statuszeilen) auf dem Bildschirm mit der rechten Maustaste (im weiteren RMB: Right Mouse Button) anklicken, so öffnet sich ein Dialog, in dem Sie die für dieses Objekt spezifischen Eigenschaften bestimmen können. Im allgemeinen handelt es sich dabei um die Parameter, die im Quelltext dem Constructor des Objektes übergeben werden. Diese Eigenschaften sind natürlich von Objekt zu Objekt verschieden, und genauere Erläuterungen zur Bedeutung der einzelnen Felder erhalten Sie in der Onlinehilfe und in Ihrer Turbo Vision Dokumentation. Wenn Sie einen Menübalken mit dem RMB anklicken, können Sie weitere Untermenüs in den Menübalken eintragen. Klicken Sie auf einen bereits vorhandenen Eintrag, so können Sie Menübefehle und Trennlinien in dieses Untermenü eintragen und konfigurieren. Auch bei Statuszeilen öffnet der RMB einen Dialog, über den Sie neue Befehle eintragen, aber auch ganze Statuszeilen (TStatusDef) für andere Programmkontexte (s.u) neu erstellen können. Im Eigenschaftendialog von Dialogelementen können Sie zusätzlich bestimmen, unter welchem Namen die Variableninstanz des jeweiligen Objektes auftauchen soll. Bestimmte Objekte wie Label oder Button bleiben allerdings unbenannt, sie werden direkt z.B. mit "Dialog^.Insert(New(PLabel, Init(...)));" eingefügt. Wenn Sie einen Dialog als neuen Objekttypen deklarieren wollen, so können Sie über die Namensfelder seiner Elemente bestimmen, ob Zeiger auf diese Objekte als Feldelemente des Dialogtypen auftauchen sollen. Dazu müssen Sie deren Namen lediglich ein ausrufezeichen voranstellen. Die so gekennzeichneten SubViews werden dann in die Typendeklaration aufgenommen und außerdem in den Load- und Store-Methoden des neuen Dialogtypen durch Aufruf der Methoden "GetSubViewPtr()" und "PutSubViewPtr()" berücksichtigt. Bei den meisten Objekten können Sie in diesem Dialog den Typ des Objektes nachträglich verändern. Wenn Sie z.B. einen selbstimplementierten Eingabezeilentyp "TDatumseingabe" verwenden wollen, so ersetzen Sie im entsprechenden Feld den Eintrag "PInputLine" durch "PDatumseingabe" (vorausgesetzt der Zeigertyp auf TDatumseingabe heißt so). Der Wizard wird dann im Quelltext statt "New(PInputLine, Init(R, <EingabeLänge>))" den Ausdruck "New(PDatumsEingabe, Init(R, <EingabeLänge>))" verwenden. Dieses Beispiel zeigt auch, wo die praktische Beschränkung dieses Konzeptes liegt: alle Bezugnahmen auf die entsprechende Variable werden zwar mit dem richtigen Typ vorgenommen, die Syntax des - 12 - Constructors wird allerdings vom Vorgänger übernommen, was eine Nachbearbeitung erforderlich machen kann. Beachten Sie auch die Bemerkungen zu diesem Thema in den Abschnitten über den Ressourceneditor und den Datenrecord. Der Eigenschaftendialog enthält außerdem einen "Löschen"-Knopf, um das Objekt wieder zu entfernen, Dialoge, Menübalken und Statuszeilen auch einen "Quelltext schreiben"-Knopf, um die Produktion des jeweiligen Codes auszulösen. - 13 - Die Quelltexterzeugung Wenn Sie den "Quelltext schreiben"-Knopf betätigen, erzeugt der Wizard den Code, der ein Objekt in den Bildschirm einfügen würde, das genau das gleiche Layout aufweist wie das von Ihnen gestaltete Objekt. Wenn Sie einen Dialog auf diese Weise niederschreiben, legen Sie zugleich den Namen der Prozedur fest, die diesen Dialog in Ihrem Programm in den Desktop einfügen soll. Diesen Prozedurnamen können Sie einem Menübefehl oder einem Button in einem anderen Dialog zuordnen. Der Wizard wird dann in der HandleEvent-Methode der Application bzw. an der Stelle, an der der Buttonbefehl ausgewertet werden soll, dafür sorgen, daß diese Prozedur aufgerufen und der Dialog eingefügt wird. Es ist auch möglich, Befehlen Prozedurnamen zuzuordnen, bevor diese Prozeduren durch den Quelltext für einen Dialog implementiert wurden. Der Wizard führt eine Liste der Prozedurbezeichner mit und kann somit solche "Forward" Deklarationen auflösen. Für alle Prozeduren, die nicht auf die beschriebene Weise mit Leben gefüllt wurden, erzeugt der Wizard eine Dummy-Funktion, sobald Sie einen Prototypen vorbereiten, so daß Sie diesen Prototypen kompilieren und problemlos starten können. Der Testmodus Turbo Wizard verfügt für die Quelltexterzeugung über einen Testmodus, der es Ihnen erlaubt, den Code zu überpfüfen bevor die tatsächichen Dateien erzeugt werden. Alle Ausgaben erfolgen in diesem Testmodus nicht in Dateien, sondern in ein Textfenster. Dies macht es einfacher, Fehler wie z.B. falsch benannte Objekte aufzuspüren, bevor Ihre Festplatte unnötigerweise zu digitalem Krautsalat fragmentiert wird. Die Umschaltung erfolgt durch den Menübefehl "Optionen│Ziel". Dieser Menübefehl zeigt Ihnen auch an, in welchem Modus Sie sich gerade befinden: "SCREEN" signalisiert den Testmodus, "DISK" den "realen" Arbeitsmodus. Die Sharewareversion von Turbo Wizard beinhaltet eine gewisse Einschränkung, die allerdings nur für Anwender von Turbo Vision 2.0 ärgerlich ist: Die Nachkommen von TValidator (Objekten, die die Eingaben in einer InputLine überprüfen können) erzeugen nur im Testmodus Quelltext. Sie können sich den Quelltext also durchaus ansehen und auf seine Qualität überprüfen, um diese Objekte allerdings in einem Programm zu benutzen, müssen Sie den entsprechenden Text entweder abtippen, oder sich registrieren lassen. - 14 - Turbo Vision 1.0 oder 2.0 ? Der Menübefehl "Optionen│Turbo Vision" läßt Sie wählen, für welche Version von Turbo Vision der Wizard Quelltext erzeugen soll. Es existieren folgende Unterschiede: Version 2.0 erlaubt den Gebrauch von TMultiCheckBoxes und (mit der gerade genannten Einschränkung) Validierungsobjekten. In der Schalterstellung "Version 1.0" werden die entsprechenden Befehle gesperrt. Modale Dialoge werden in der Version 2.0 nicht mit dem Befehl "Desktop^.ExecView(Dialog)", sondern mit "Application^.ExecuteDialog(Dialog, <Recordaddresse>)", nichtmodale Dialoge nicht mit "Desktop^.Insert(Dialog)" sondern mit "Application^.InsertWindow(Dialog)" eingefügt. Diese in Turbo Vision 2.0 neu implementierten Methoden des Objektes TApplication erlauben einen kürzeren Quelltext und übernehmen zudem die Fehlerbehandlung, über einen internen Aufruf von "Validview". Die Methode "ExecuteDialog" entfernt zudem das Dialogobjekt selbständig vom Heap und organisiert den Datenaustausch mit dem Transferrecord. Prinzipiell leistet der vom Wizard für die Version 1.0 erzeugte Quelltext das gleiche wie der für Turbo Vision 2.0, ist aber etwas länger. Da ich davon ausgehe, daß wer Turbo Vision 2.0 besitzt auch über einen Turbo oder Borland Pascal Compiler der Version 7.xx verfügt, wird in den Methoden Store, Load, Init und HandleEvent, die der Wizard für abgeleitete Dialoge implementiert, die geerbte Methode mit dem Schlüsselwort "inherited" aufgerufen. Dies macht es einfacher, Dialoge nicht von TDialog, sondern von einem späteren Dialogtypen abzuleiten. Der Wizard erzeugt IMMER Quelltext für einen von TDialog abgeleiteten Typen. Durch den Gebrauch von "inherited" brauchen Sie den Typbezeichner des direkten Vorfahren nur noch in der Deklaration zu ändern statt in jeder überschriebenen Methode. - 15 - Der Ressourceneditor Auch wenn es vielleicht naheliegt, das Programm Turbo Wizard selbst als Ressourceneditor aufzufassen: im weiteren wird diese Bezeichnung ausschließlich für ein bestimmtes Programm benutzt, dessen Quelltext der Wizard während der Arbeit an einem Projekt erzeugt. In diesem Quelltext finden sich Prozeduren, die Dialoge, Menübalken und Statuszeilen erzeugen und in einer Ressourcendatei speichern. Im eigentlichen Zielprogramm, dem Prototypen, werden diese Objekte dann aus dieser Ressource geladen und in die Arbeitsfläche eingefügt. Wenn Ihnen das Konzept der Ressourcendateien vom Typ TResourceFile noch fremd ist, sollten Sie sich in ihrer Compilerdokumentation informieren. Einen gewissen Einstieg gibt auch die Onlinehilfe des Wizard. Kurz und knapp gesagt besteht das Prinzip darin, Objekte nicht zur Laufzeit des Programmes zu erzeugen sondern ihre Datenfeldern und eine spezielle Identifikationsnummer, die die Interpretation dieser Daten ermöglicht, in einer Datei zu speichern und die Objekte später aus dieser Datei zu laden. Der Code, den die im Programm benötigten Prozeduren zum Laden eines Dialoges aus einer Datei einnehmen, ist meist bedeutend kürzer als der Code, der den Dialog erstellt. Außerdem ist es auf diese Weise häufig möglich, z.B. sprachspezifische Anpassungen vorzunehmen, ohne das Programm ändern und neu kompilieren zu müssen. Damit dieses Konzept funktionieren kann, muß gewährleistet sein, daß nur mit der Prozedur RegisterType() registrierte Objekttypen in die Ressourcendatei geschrieben werden. Diese Prozedur ermöglicht nämlich durch die Zuordnung der eindeutigen Identifikationsnummer den Aufruf der richtigen Speicher- und Laderoutinen. Die Registrierung aller Standardobjekte und aller Dialogtypen, die Sie innerhalb des Wizard neu deklarieren, wird automatisch vorgenommen. Wenn Sie allerdings innerhalb eines Dialoges einen Objekttypen verwenden, der von "außerhalb" des Wizard kommt, müssen Sie selbst dafür sorgen, daß dieser Typ sowohl im Ressourceneditor als auch in dem Programm, das die Ressource verwendet, registriert wird. Mehr zu den Möglichkeiten, die Quelltexterzeugung zu beeinflussen und zu steuern, erfahren Sie in den Kapiteln über Statuszeilen, Menübalken und Dialoge. - 16 - Das Hilfekonzept von Turbo Vision und Turbo Wizard Der Hilfekontext eines Objektes Eine der Hauptstärken von Turbo Wizard ist die umfangreiche Unterstützung des in Turbo Vision implementierten Konzeptes der kontextsensitiven Hilfe. Die Grundlage dieses Konzeptes ist einfach: Jedes Objekt, das auf dem Bildschirm erscheint, verfügt über ein Feld "HelpCtx", das einen Wert vom Typ Word aufnimmt. Das Programmobjekt TApplication ermittelt über seine Methode "GetHelpCtx", welches Bildschirmelement gerade fokussiert ist und bestimmt den Inhalt dessen HelpCtx-Feldes. Wenn der ermittelte Wert ungleich der Konstanten "hcNoContext=0" ist, so stellt dieser Wert den aktuellen Kontext dar. Ist er gleich Null, so prüft TApplication das entsprechende Feld des Gruppenobjektes, zu dem das fokussierte Objekt gehört (zum Beispiel das des Dialoges, in dem sich eine gerade fokussierte Eingabezeile befindet), ist auch dieses gleich Null geht es weiter mit der Gruppe "DeskTop", zu der der Dialog gehört usw. Wird auf diesem Wege durch den Abhängigkeitsbaum kein Wert unterschiedlich hcNoContext gefunden so ist der aktuelle Programmkontext gleich hcNoContext. Die Methode TApplication.GetHelpCtx kann explizit aufgerufen werden, wenn das Befehlsereignis "cmHelp" eintrifft, um in Zusammenarbeit mit einem THelpfile-Objekt eine Hilfetafel zum gerade fokussierten Objekt anzuzeigen. Der Programmkontext wird außerdem in der Methode TStatusLine.Update ermittelt, die immer dann, wenn gerade kein Ereignis zur Bearbeitung ansteht, die Statuszeile auf ihre Zuständigkeit für den aktuellen Kontext überprüft und wenn nötig die Darstellung einer anderen Statuszeile mit anderen Befehlen veranlasst. Festlegung des Hilfekontext Für die allermeisten Objekten, mit denen Sie im Wizard umgehen, können Sie explizit einen Hilfekontext angeben. Üblicherweise arbeiten Sie dabei mit Konstantenbezeichnern, deren erste zwei Buchstaben zu besseren Identifikation "hc" lauten. Sie brauchen nur irgendwelche sinnvollen Namen eizugeben, der Wizard deklariert die Konstanten automatisch. Den Wertebereich neuer Hilfekonstanten können Sie bestimmen, indem Sie im Menü "Optionen│Einstellungen" die untere Grenze bestimmen. Jeder weitere Kontext erhält dann einen um eins inkrementierten Wert zugewiesen. Um Überschneidungen zu vermeiden können Sie diese Basis während der Arbeit an einem Projekt nur erhöhen, nicht verringern. Bei Schalterfeldern wie TCheckBoxes und TRadioButtons bestimmt sich der tatsächlich von GetHelpCtx ermittelte Hilfekontext aus der Summe des Wertes im Feld HelpCtx und der Nummer des gerade fokussierten Schalters, wobei die Zählung bei Null beginnt. Das - 17 - macht es möglich, jedem Schalter eine eigene Hilfe zuzuweisen, gleichzeitig ist es aber auch notwendig, eine entsprechende Anzahl an Kontexten zu reservieren, um zu verhindern, daß ein Schalter den gleichen Kontext ermittelt wie ein Objekt, das kurz nach ihm eingefügt wurde. Auch diese Aufgabe übernimmt der Wizard automatisch. Die Funktion TStatusLine.Hint(AHelpCtx): String; Diese Funktion liefert ebenfalls Ergebnisse, die vom aktuellen Programmkontext abhängig sind. Wenn ihr Ergebnis ungleich einem Leerstring ist, wird der zurückgegebene Ausdruck in der Statuszeile ausgegeben, durch ein Trennzeichen von den Befehlseinträgen abgegrenzt. Im Original gibt sie immer einen leeren String zurück, der Wizard überschreibt Sie für seine Statuszeile vom Typ TWStatusLine so, daß das Ergebnis zu jedem Programmkontext einen anderen Hinweis (engl. "hint") liefern kann. Der Hilfecompiler TVHC.EXE Das Programm TVHC.EXE, das den Turbo und Borland Pascal Compilern ab Version 6.0 im Quelltext beiliegt, kompiliert eine speziell vorbereitete ASCII-Textdatei zu einer Hilfedatei, auf die über ein Objekt vom Typ THelpFile zugegriffen werden kann, um Hilfetafeln zu bestimmten Programmkontexten anzuzeigen. Die einzelnen Abschnitte werden dabei mit dem Schlüsselwort ".Topic" (der Punkt ist wichtig) eingeleitet, dem ein Wort bis zu einer Länge von zwanzig Buchstaben folgen kann. Diesem Bezeichner wird vom Hilfecompiler TVHC ein Index zugeordnet, über den auch Querverweise von anderen Stellen des Textes aus zu diesem Eintrag ermöglicht werden. Um einen Querverweis zu einem Topic im Text zu markieren, muß man das Schlüsselwort in geschweifte Klammern einfassen. Man kann diesem Schlüsselwort auch eine andere Textstelle zuordnen, indem man die beiden Ausdrücke mit einem Doppelpunkt zuordnet. So verzweigen beispielsweise die Ausdrücke {Inhalt} und {Inhaltsverzeichnis des Textes:Inhalt} beide zu einem Topic unter dem Bezeichner Inhalt. Alle Schlüsselwörter werden von TVHC, um die Buchstaben "hc" ergänzt, als Konstantenbezeichner in einer Unit deklariert. Dabei erfolgt die Wertezuweisung genau wie innerhalb des Wizard: Beginnend bei einem bestimmten Wert, der explizit zugewiesen werden muß, ansonsten gleich eins ist, wird dieser Wert mit jedem neuen Topic inkrementiert. Sie können, wie z.B. in der Anweisung ".Topic ANewLevel=1000", diese Basis innerhalb des Textes ändern. Beachten Sie bitte, daß sich das Format der Hilfedateien, die TVHC erzeugt, mit der Turbo Vision Version 2.0 gegenüber der Version 1.0 geändert hat. Ein Programm, daß die Unit HelpFile aus Version 2.0 einbindet kann daher Hilfedateien, die mit TVHC 1.0 erzeugt wurden, nicht lesen. - 18 - Der Hilfeeditor des Turbo Wizard Immer, wenn Sie einem Objekt im Wizard einen neuen Hilfekontext zuweisen, erzeugt dieser in der Projektdatei einen "Hilfetextrumpf". Dieser beinhaltet eine Überschrift, die an die Art des Objektes angepaßt ist, dem der Hilfekontext zugeordnet wurde, sowie provisorische Einträge in das Inhaltsverzeichnis und in den Index der Hilfe. Sie können diese Einträge entweder sofort für jeden neuen Hilfekontext oder aber später bearbeiten (Sie können das Verhalten über den Menübefehl "Optionen│Einstellungen" einstellen). Um einen vorhandenen Hilfetext zu bearbeiten lassen Sie sich über "Projekt│Deklarationen..." eine Liste der gültigen Hilfekontexte anzeigen. Wenn Sie auf einen der Eintrage doppelklicken öffnet sich der Hilfeeditor (die Liste enthält allerdings auch einige reservierte Einträge wie "hcNoContext" oder "hcDragging", die Sie nicht editieren können). Im Hilfeeditor können Sie: ■ Einen Eintrag ins Inhaltsverzeichnis vornehmen. Das Inhaltsverzeichnis ist die Hilfetafel, die in mit Turbo Wizard erzeugten Programmen angezeigt wird, wenn kein spezieller Hilfekontext vorliegt. ■ Einen oder mehrere Einträge in den Index vornehmen. Der Index wird vom Wizard als alphabetisch sortierte Liste all dieser Einträge angelegt. Ein Eintrag in den Index stellt dabei einen Querverweis auf diesen Hilfekontext dar. Das Inhaltsverzeichnis verweist in seinem ersten Eintrag auf diesen Index. Um für einen Kontext mehrere Einträge in den Index vorzunehmen, müssen Sie die entsprechenden Worte mit einem Schrägstrich ("/") trennen. ■ Den Text der anzuzeigenden Hilfetafel eingeben. Machen Sie sich um die Textbreite keine Sorgen: alle Zeilen, die nicht mit einem Leerzeichen beginnen, werden automatisch auf die jeweils für die Hilfetafel richtige Breite umgebrochen. ■ Neue, zusätzliche Hilfekontexte definieren. Über einen Button "Querverweis erstellen" können Sie direkt eine weitere Version des Hilfeeditors aufrufen und einen Querverweis erstellen. Beachten Sie die oben beschriebenen Syntaxregeln für Querverweise im Hilfetext. Die Überschrift ".Topic <topicname>" müssen Sie übrigens in keinem Fall eingeben, das erledigt der Wizard für Sie. ■ Den "Hint" (s.o.) für den jeweiligen Hilfekontext angeben. Bei der Vorbereitung eines Prototypen über den Menübefehl "Projekt│Prototyp vorbereiten" erzeugt der Wizard aus all diesen Eingaben einen Hilfetext, der den Anforderungen von TVHC genügt. Die Hilfekontextbezeichner werden allerdings nicht über die Unit, die TVHC erzeugt, sondern über eine vom Wizard erstellte Includedatei ins Programm eingebunden, um einen Test des Prototypen schon zu ermöglichen, bevor der Hilfetext kompiliert - 19 - wird. Wenn Sie keine Änderungen an der vom Wizard erzeugten Textdatei vorgenommen haben, ist die Wertezuweisung sowieso vollständig identisch. Falls Sie durch Einfügen weiterer Topics in einem Editor außerhalb des Wizard neue Hilfekontexte erzeugen oder (was nicht empfehlenswert ist) die numerische Ordnung der Konstanten ändern, müssen Sie die entsprechende Includeanweisung löschen und dafür die von TVHC erzeugte Unit mit "uses" einbinden. Generell ist es immer empfehlenswert, derartig importierte Topics an das Ende der Datei anzuhängen. Bei sehr komplexen Texten mit langen Indexlisten kann es übrigens vorkommen, daß sich TVHC verschluckt und den Rechner aufhängt. Außerdem sollten Sie leere geschweifte Klammern "{}" unbedingt vermeiden. Da TVHC mit dynamischen Strings arbeitet, aber an einigen Stellen nicht überprüft, ob auch tatsächlich Speicher alloziert wurde, führt eine solche Textstelle zu Unsinn, im Protected Mode zu einem Ausnahmefehler und häufig auch zu einem saftigen Absturz mit optionaler Beschädigung der Dateizuordnungstabelle... - 20 - Die Prozedur ShowHelp Mit dem Wizard erhalten Sie die Units XHelp60.tpu für die Verwendung mit Turbo Pascal 6.0 sowie XHelp70.tpu und XHelp70.tpp für die Verwendung mit Turbo bzw. Borland Pascal 7.0. Diese Units stellen ein Hilfefenster zur Verfügung, das gegenüber derm Fenster THelpWindow aus der Unit HelpFile einige Verbesserungen aufweist: ■ Die Farbpalette wurde angepaßt, so daß das Hilfefenster das gleiche Aussehen erhält wie die Hilfefenster in der Pascal-IDE. ■ Das Fenster reagiert auf Tastatureingaben, wie Sie es aus dem Index des Pascal-Hilfesystems gewöhnt sind: Unter den Querverweisen wird nach dem gerade eingegebenen Buchstaben gesucht. Wird ein Begriff gefunden, der mit diesem Buchstaben beginnt, so springt der Cursor zu diesem Begriff, bei der nächsten Tastatureingabe wird auf das Vorkommen des Buchstaben als zweiter Buchstabe im Schlüsselwort getestet u.s.w. ■ Das Fenster verfügt über eine ringförmige Liste von dreissig Hilfekontexten. In dieser Liste wird die "Geschichte" eines Hilfefensters, also alle Hilfekontexte, die in diesem Fenster betrachtet wurden, gespeichert. Wenn ein Hilfefenster den Befehl "cmLastTopic=201" erhält, so geht es in dieser Liste jeweils einen Schritt zurück und zeigt die entsprechende Tafel an. Sie können also wieder zurück zum ursprünglichen Thema, nachdem Sie sich einen Querverweis angesehen haben. ■ Wenn Sie ein Hilfefenster öffnen, können Sie ihm nicht nur mitteilen, welche Hilfetafel es direkt anzuzeigen hat, Sie können ihm auch einen Hilfekontext übergeben, zu dem es wechseln soll, wenn es erneut den Befehl "cmHelp" erhält. In den Prototypen, die der Wizard erzeugt, wird dann zum Inhaltsverzeichnis gewechselt (es könnte aber auch direkt zum Index gehen). Das Einfügen dieses verbesserten Hilfefensters geschieht über die Prozedur ShowHelp, und hier liegt eine Einschränkung der Sharewareversion: Da Typ und Name des Hilfefensters nicht exportiert werden, haben Sie keine Möglichkeit, die Titelzeile des Fensters zu ändern. Die lautet nämlich immer "Turbo Wizard-Hilfe". Wenn Sie sich allerdings registrieren lassen erhalten Sie eine andere Unit, die Ihnen die Angabe einer eigenen Titelzeile und auch die Ableitung eigener Hilfefensterobjekte erlaubt. Die Syntax von ShowHelp lautet: Procedure ShowHelp(aHelpFile: PathStr; AHelpCtx, ADefaultTopic: Word); Dabei sind ▌AHelpFile: der Name der Hilfedatei, - 21 - ▌AHelpCtx: der Hilfekontext, zu dem die erste Tafel angezeigt werden soll, ▌ADefaultTopic: der Hilfekontext, zu dem gesprungen werden soll, wenn das Fenster den Befehl cmHelp erhält. Der Hilfekontext des Hilfefensters selbst ist "hcHelpWindow=4999". Sie sollten in Ihrem Programm eine Statuszeile vorsehen, die nur für hcHelpWindow gilt und die Befehle cmHelp, cmLastTopic und cmZoom enthält. - 22 - Statuszeilen Wenn Sie mit dem Befehl "Objekte│StatusLine" eine Statuszeile einfügen, so erscheint zunächst eine leere, neue Statuszeile im unteren Viertel des Bildschirms. Wenn Sie diese Zeile mit dem RMB anklicken öffnet sich ein Dialog, der die Eingabe des minimalen und des maximalen Programmkontextes erlaubt, in dem diese Zeile angezeigt werden soll. In der Voreinstellung sind diese Grenzen "hcNoContext=0" und "hcEveryContext=65535", diese Statuszeile kann also zu jedem Zeitpunkt des Programmes gültig sein. Sie finden in diesem Dialog auch Knöpfe, um Befehlseinträge in diese Zeile vorzunehmen ("Eintrag"), die Statuszeile auf Platte zwischenzuspeichern, ("Speichern"), ihren Quelltext erzeugen zu lassen ("Schreiben"), ein weitere Statuszeile für einen anderen Zuständigkeitsbereich anzulegen ("Neue Zeile"), zwischen den einzelnen Statuszeilen zu blättern ("Nächste") oder die Statuszeile zu löschen. Reihenfolge und Auswertung der Statuszeilen Das Viewobjekt TStatusLine und seine Nachfahren verwalten eine einfach verkettete Liste von Records des Typs TStatusDef. Ein TStatusDef-Record enthält die Felder Min und Max für die Grenzen der kontextabhängigen Zuständigkeit, einen Zeiger auf den nächsten TStatusDef in der Liste und einen Zeiger auf eine Liste von Befehlseinträgen. TStatusLine verfügt außerdem noch über das Feld Item, das ebenfalls einen Zeiger auf eine Liste von Befehlseinträgen enthält. Wenn sich der Programmkontext ändert, überprüft TStatusLine, welches TStatusDef zuständig ist, indem es sich an der Liste von TStatusDefs "entlanghangelt" bis der aktuelle Programmkontext zwischen den ermittelten Min- und Max-Werten liegt oder das Ende der Liste erreicht ist. Wird ein passender TStatusDef-Record gefunden, so wird dessen Befehlsliste in das Feld Item übertragen und genau diese Liste von Befehlen dargestellt. Sie brauchen diese Vorgehensweise nicht in allen Einzelheiten verstanden zu haben, wichtig ist allein folgendes Ergebnis: Wenn eine Statuszeile, deren Kontextbereich nur eine Teilmenge des Kontextbereiches einer zweiten Statuszeile ist, in der TStatusDef-Liste vor dieser zweiten steht, so wird sie dargestellt, sobald der Programmkontext in ihren Zuständigkeitsbereich fällt. Steht sie aber hinter dieser zweiten Statuszeile, so wird sie niemals dargestellt werden. Der Wizard baut nun die Liste von TStatusDef derartig auf, daß jede neue Statuszeile VOR allen bereits bestehenden TStatusDef eingefügt wird. Sie müssen daher zuallererst die allgemeinste Statuszeile entwerfen, z.B. indem Sie in die leere Statuszeile mit ihrem Kontextbereich von hcNoContext bis hcEveryContext lediglich den Befehl "Hilfe", cmHelp eintragen. Damit können Sie sicher sein, - 23 - daß zu jedem Programmzeitpunkt, für den keine eigene, speziellere Statuszeile gebraucht wird, die Hilfefunktion verfügbar ist. Legen Sie nun eine zweite, zunächst leere Statuszeile für einen eingeschränkteren Hilfekontextbereich an. Stellen Sie sich z.B. vor, Sie würden den Dialog "Compiler-Optionen" der Pascal-IDE neu entwerfen. Die meisten Programmierer wechseln hier zwischen zwei verschiedenen Einstellungsarten: Größtmögliche Sicherheit während der Programmentwicklung (inklusive Erzeugung von Informationen für den Debugger) und größtmögliche Geschwindigkeit bzw. kleinstmögliche EXE-Datei für das fertige Programm. Wenn Sie zwischen diesen Einstellungen wählen möchten, müssen Sie normalerweise eine ganze Menge Schalter umstellen. Wenn Sie dagegen eine Statuszeile entwerfen, die genau auf den Kontextbereich dieses Dialoges mit all seinen verschiedenen Schaltfeldern zugeschnitten ist, können Sie in diese Zeile zwei Schalter aufnehmen, die dem Dialog jeweils den Befehl schicken, eine dieser beiden Standardeinstellungen durchzuführen und sich dann neu darzustellen, um vielleicht noch ein "Feintuning" vorzunehmen (es sei nicht verschwiegen, daß Sie dafür natürlich auch die HandleEvent-Methode des Dialoges überschreiben müssen). Zuletzt legen Sie eine Statuszeile für den Gebrauch des Hilfefensters an. Setzen Sie dafür sowohl die untere wie auch die obere Grenze des Zuständigkeitsbereiches auf hcHelpWindow und fügen Sie die Befehle "cmHelp", "cmLastTopic" und "cmZoom" ein. Wenn Sie nun die Quelltexterzeugung auslösen, indem Sie im Eigenschaftendialog der Statuszeile den entsprechenden Knopf drücken, konstruiert der Wizard die gesamte Statuszeile so, daß zuerst die spezielleren, zum Schluß die allgemeineren Statuszeilen eingefügt werden. Es ist übrigens möglich, Befehle in die Statuszeile einzufügen, ohne dafür einen Texteintrag vorzusehen. Turbo Wizard selbst enthält in der Statuszeile immer den Befehl "cmNext", der durch die Taste F6 ausgelöst wird und (wenn möglich) das jeweils nächste Fenster selektiert. Der Vorteil eines solchen "versteckten" Befehls ist, daß in der Statuszeile mehr Platz für die Hinweise der Funktion Hint bleibt. andererseits sollte man so etwas natürlich nur mit Befehlen machen, deren Hotkeys aus irgendeinem "Industriestandard" gut bekannt sind und auch keinen Schaden anrichten. Die Taste F1 mit dem versteckten Befehl "Festplatte formatieren" zu verbinden wäre beispielweise keine gute Idee. - 24 - Grenzen und Probleme bei Statuszeilen Sie können weder einen einmal eingefügten Befehl, noch eine einzelne Statuszeile vom Typ TStatusDef löschen. Der Wizard löscht immer die gesamte Konstruktion. Da Ihnen aber der Quelltext zur Verfügung steht, werden Sie diesen Mangel hoffentlich verschmerzen können. Der Quelltext einer Statuszeile Der Wizard überschreibt in der Datei <ProjectName>STL.INC die Methode TApplication.InitStatusLine. Wenn Sie bestimmt haben, daß die Statuszeile aus einer Ressource geladen werden soll, wird hier die Methode ResFile.Get('STATUSLINE') aufgerufen, ansonsten finden Sie hier die Anweisungen, die die Statuszeile erstellen. Bei Ressourcenobjekten wird diese Konstruktion in der Datei MAKESTAT.INR vorgenommen, und das so zusammengestellte Objekt unter dem Namen "STATUSLINE" in der Ressource <ProjectName>.RES gespeichert. Die Prozedur, die dies tut heißt "MakeStatusLine". - 25 - Menübalken Der Befehl "Objekte│MenuBar" fügt im oberen Drittel des Bildschirms einen zunächst leeren Menübalken ein. Wenn Sie diesen mit dem RMB anklicken öffnet sich ein Dialog, der Ihnen den Eintrag eines Menüs erlaubt und zugleich auch Knöpfe enthält, um die Quellteterzeugung auszulösen, die Menükonstruktion in einer Datei zu speichern oder zu löschen. Wenn Sie einen Eintrag ins Menü vorgenommen haben können Sie diesen wiederum mit dem RMB anklicken um einen anderen Dialog zu öffnen, der den Eintrag von Menübefehlen und Trennlinien sowie das Löschen des Menüs erlaubt. Die Markierung der Taste, die den Menübefehl aktiviert erfolgt (wie auch bei Buttons oder Labels) durch das Einfassen des entsprechenden Buchstabens in Tildezeichen (~). Der Eintrag eines Untermenüs ist (noch) nicht, bzw. nur "manuell" im Quelltext möglich. Mit jedem Menübefehl können Sie den Namen einer Prozedur verknüpfen. Diese Prozedurnamen werden vom Wizard gesammelt und bei der Vorbereitung eines Prototyps in der HandleEvent-Methode der Application dem entsprechenden Befehl zugeordnet (mehr über die Implementation dieser Methode erfahren Sie weiter unten). Diese Zuordnung ist allerdings nicht mit einem bestimmten Menübalken verbunden. Wenn Sie also in irgendeiner Menükonstruktion Zuordnungen vorgenommen haben, den Balken dann aber wieder verwerfen und löschen und ein anderes Menü implementieren, werden in die HandleEvent-Methode ALLE Zuordnungen aufgenommen. Dies kann natürlich unerwartete und auch unerwünschte Ergebnisse mit sich bringen, es macht es aber auch möglich, so wie Turbo Wizard selbst mit mehreren verschiedenen Menübalken zu arbeiten, die abhängig vom Programmkontext aus einer Ressource geladen werden. Im Kapitel "Die Methode Application.HandleEvent" erfahren Sie mehr über die Bearbeitung von Befehls/Prozedurzuordnungen. - 26 - Der Quelltext eines Menübalkens Der Wizard überschreibt in der Datei <ProjectName>MNU.INC die Methode TApplication.InitMenuBar. Wenn Sie bestimmt haben, daß der Menübalken aus einer Ressource geladen werden soll, wird hier die Methode ResFile.Get('MENUBAR') aufgerufen, ansonsten finden Sie hier die Anweisungen, die den Menübalken zusammenstellen. Bei Ressourcenobjekten wird diese Konstruktion dagegen in der Datei MAKEMENU.INR vorgenommen und das so zusammengestellte Objekt unter dem Namen "MENUBAR" in der Ressource <ProjectName>.RES gespeichert. Die Prozedur, die dies tut heißt "MakeMenuBar". Die Prozedur TApplication.HandleEvent wird in der Includedatei <ProjectName>EVH.INC implementiert, allerdings erst, wenn Sie den Menübefehl "Projekt│Prototyp vorbereiten" wählen. - 27 - Dialoge Grundsätzliche Optionen Sie können einen Dialog in ganz unterschiedlicher Weise Quelltext erzeugen lassen. Die Einstellung der im folgenden besprochenen Optionen geschieht direkt vor der Codeproduktion in einem Dialog, der erscheint wenn Sie im Eigenschaftendialog den Knopf "Quelltext erzeugen" drücken. Die hauptsächlichen Möglichkeiten sind: ■ Prozedur zum Einfügen erzeugen. Wenn diese Option gewählt ist erzeugt der Wizard im Prototypen eine Prozedur, die den Dialog in den Desktop einfügt und nimmt diese Prozedur in die Liste der Prozeduren auf, die Sie einem Menübefehl oder einem Buttonbefehl zuordnen können. Die Art der Prozedur ist davon abhängig, ob Sie einen modalen oder einen nichtmodalen Dialog erzeugen möchten. Im ersten Fall wird der Dialog mir der Anweisung "Result:=DeskTop^.ExecView(Dialog)" bzw. (für Turbo Vision 2.0) "Result:=application^.ExecuteDialog(Dialog)", im zweiten Fall mit "DeskTop^.Insert(Dialog)" bzw "application^.InsertWindow(Dialog)" eingefügt. Die Prozedur wird in der Includedatei <ProjectName>PRC.INC implementiert. ■ Objekttypen deklarieren. Wenn diese Option gewählt ist (sie kann natürlich mit der Erzeugung einer Prozedur kombiniert werden), deklariert der Wizard den Dialog als einen neuen, von TDialog abgeleiteten Typen. Der Name dieses Typen wird zuvor im Eigenschaftendialog festgelegt, die mehrfache Verwendung des gleichen Bezeichners wird vom Wizard angemeckert, ist prinzipiell erlaubt und verursacht bei Compilierung des unveränderten Quelltextes natürlich einen Compilerfehler. Die Deklaration eines Dialogtypen umfaßt folgende Vorgänge: 1.Deklaration des Zeigertyps. Hierzu wird dem angegebenen Typbezeichner ein "P" vorangestellt. 2.Deklaration des Objektes. Hierzu wird dem angegebenen Typbezeichner ein "T" vorangestellt. Der Wizard überschreibt die Methoden Load, Store und HandleEvent, wenn dies gewünscht wird auch den Constructor Init. Diese Methoden werden in der Includedatei <ProjectName>PRC.INC implementiert. Alle Elemente des Dialoges, deren Namen Sie ein Ausrufezeichen vorangestellt haben, werden als Felder (Zeigertypen) in den Dialog aufgenommen und in den Methoden Load und Store mit GetSubViewPtr bzw PutSubViewPtr richtig zugewiesen. 3.Die Deklaration eines TStreamRec zur Registrierung dieses Objekttypen und die Aufnahme des Typen in die Liste der Dialoge, die vom Prototypen zur Verwendung in einem Stream registriert werden. Diese Vorkehrung erlaubt es, ohne weitere Vorkehrungen und Eingriffe in den Quelltext auch solche selbstdefinierten Objekte in einer Ressourcendatei zu speichern, solange in ihnen keine abgeleiteten Dialogelemente enthalten sind. Die Typen-ID, - 28 - die dabei verwendet wird, können Sie unter "Optionen│Einstellungen" vorgeben. Sie wird für jeden neuen Typen automatisch um eins inkrementiert. Folgende Einstellungen beeinflussen weiterhin die Art des Quelltext: ■ Dialog im Constructor oder in der Prozedur zusammenstellen: Im allgemeinen ist es üblich, abgeleiteten Dialogobjekten einen Constructor mitzugeben, der sämtliche Elemente des Dialoges einfügt. Diese Vorgehensweise ist unter den Aspekten der Wartung bestehenden Codes und der Datenkapselung günstig, denn sie entspricht am ehesten dem Prinzip, daß die Felder eines Objekt vorzugsweise von eigenen Methoden modifiziert werden sollten. Die andere Vorgehensweise besteht darin, dem Dialog keinen eigenen Constructor Init zu geben sondern den geerbten Constructor aufzurufen und in diesen "leeren" Dialog innerhalb der Prozedur, die den Dialog einfügt oder in einer Ressource speichert, mit Elementen zu füllen (so wie es geschieht, wenn kein neuer Dialogtyp abgeleitet , sondern nur eine Prozedur geschrieben wird). Dies ist nicht die empfohlene Methode, und eigentlich nur selten sinnvoll. Ein Vorteil besteht meist nur darin, daß der Quelltext des Programms zusätzlich verkürzt wird, wenn ein solcher Dialog im Ressourceneditor erzeugt wird. Die Größe der EXE-Datei und der verfügbare Arbeitsspeicher werden durch einen Constructor Init, der nicht aufgerufen wird, weil der Dialog stattdessen aus einer Ressource geladen wird, nicht negativ beeinflußt, denn der Linker von Pascal entfernt diesen toten Code automatisch. Eine andere Anwendung dieser Technik läge darin, von einem so gestalteten Dialog einen Nachfahren abzuleiten, der einige Methoden übernehmen, aber ein anderes Erscheinungsbild aufweisen soll. Der geerbte Constructor würde diese Absicht natürlich unterlaufen. Hier ist es aber oft sinnvoller, zunächst einen abstrakten Vorfahren ohne definiertes Erscheinungsbild zu deklarieren und von diesem dann beide Dialoge abzuleiten. Ressourcendateien verwenden Wenn diese Option gewählt ist, wird im Ressourceneditor eine Prozedur erzeugt, die den Dialog in der Ressource speichert, im Programm wird dieser Dialog dann aus der Datei geladen. Stack schonen Wenn diese Option gewählt ist, werden alle Elemente des Dialoges in einer einzigen Zeigervariablen vom Typ PView namens "Control" initialisiert, ansonsten verwendet der Wizard für jedes Objekt einen eigenen Zeiger, der unter den lokalen Variablen der Prozedur bzw. des Constructors unter dem Namen des jeweiligen Objektes auftaucht. Von dieser Regelung ausgenommen sind natürlich Feldelemente des Dialoges, Objekte also, deren Namen Sie ein Ausrufezeichen vorangestellt haben. Wenn Sie bewirken möchten, daß beim Einfügen des Dialoges ein anderes Objekt als das zuerst in den Dialog eingefügte fokussiert wird, müssen Sie diese Option deaktivieren und vor dem Schreiben des Quelltextes das gewünschte Objekt selektieren. - 29 - Record auf dem Stack oder Heap anlegen Wenn dieser Schalter auf "Stack" steht wird der Datenrecord als lokale Variable auf dem Stack angelegt, ansonsten mit der Funktion New auf dem Heap. Die Aufrufe der Methoden GetData, SetData und ExecuteDialog werden dementsprechend angepaßt, ein Record auf dem Heap am Ende der Prozedur wieder entfernt. Recordtyp lokal oder global deklarieren Wenn dieser Schalter auf lokal steht, so wird der Typ des Datenrecords innerhalb der Prozedur, die den Dialog einfügt deklariert, ansonsten global in der Includedatei <ProjectName>TYP.INC. Lokal deklarierte Records machen das Programm etwas übersichtlicher. Um das Prototyping zu erleichtern legt der Wizard den Datenrecord immer als lokale Variable an. In der Praxis werden Sie die abzufragenden Daten vermutlich häufig als Variablenparameter an die Prozedur übergeben wollen. In diesem Fall sollten Sie den Recordtyp natürlich global deklarieren. Sie müssen dann außerdem noch die lokale Variable NewData aus der Variablenliste löschen und statt dessen in die Parameterliste der Prozedur aufnehmen. Zentrierung in X- oder Y-Richtung Diese Schalter im Eigenschaftendialog eines Dialogobjektes bestimmen, ob die Bits "ofCenterX" und "ofCenterY" im Feld Options gesetzt werden sollen. Ist dies der Fall werden die absoluten Koordinaten des Dialoges beim Einfügen entsprechend geändert (auf die Darstellung des Dialoges innerhalb des Wizard hat dies keinen Einfluß). Der Typ TWDialog Turbo Wizard gibt den Typ eines neuen zu editierenden Dialoges mit TWDialog vor. Dieser direkte Nachfahre von TDialog überschreibt die Methode HandleEvent derartig, daß jedes Befehlsereignis die Methode "EndModal(<Befehl>)" aufruft, die dafür sorgt, daß der Dialog geschlossen wird und die Funktionen ExecView bzw. ExecuteDialog den Wert des Befehlsereignisses zurückgeben. Dieser Dialogtyp reicht für viele Anwendungen modaler Dialoge aus (es handelt sich sozusagen um ein "ReadLn-Object"). Sie sollten einen TWDialog aber nicht als nichtmodalen Dialog einfügen, EndModal würde dann nämlich das Programm beenden. Reihenfolge der Dialogelemente Alle Elemente, die Sie in einen Dialog einfügen können, sind Standardelemente aus Turbo Vision Es gibt allerdings zwei kleine Erleichterungen: Wenn Sie ein THistory-Objekt einfügen, so wird zugleich auch eine Eingabezeile eingefügt und mit diesem Objekt verknüpft, und Sie brauchen sich um das Einfügen von Rollbalken für Listboxen und Memofelder nicht - 30 - zu kümmern, sondern müssen nur deren Anzahl und Ausrichtung angeben. Sie sollten alle Elemente in der gleichen Reihenfolge einfügen, in der der Anwender Sie später vermutlich nutzen wird, i.a. also von links oben nach rechts unten, denn diese Reihenfolge entspricht genau der Reihenfolge, in der der Zieldialog tatsächlich zusammengesetzt wird. Von dieser Regel ausgenommen sind lediglich Objekte vom Typ TLabel. Diese werden vom Wizard immer direkt hinter dem Objekt eingefügt, das sie referenzieren. Sie können allerdings ein Label nur mit einem Objekt verbinden, das vor ihm entstanden ist. Um zu vermeiden, daß das zuletzt in den Dialog eingefügte Objekt beim Erscheinen des Dialoges auf dem Bildschirm fokussiert wird fügt der Wizard am Ende der Dialogerzeugung noch den Befehl SelectNext(False) ein, der den Focus auf das zuerst eingefügte Element setzt. Die HandleEvent-Methode eines abgeleiteten Dialogtypen Wenn Sie in einen Dialog einen Button einfügen, können Sie in dessen Eigenschaftendialog bestimmen, welche Instanz den von diesem Button abgesetzten Befehl bearbeiten und welche Aktion dabei ausgelöst werden soll. Um die Aktion festzulegen geben Sie einen Prozedurnamen an. Die bearbeitende Instanz kann entweder die HandleEvent Methode eines abgeleiteten Objektypen oder die Prozedur sein, die einen modalen Dialog einfügt. Wenn die HandleEvent-Methode des Dialogs den Befehl bearbeiten soll, wird nun die Kombination "Befehlskonstante: Aktions-Prozedur" in die Case-anweisung dieser Methode aufgenommen. Soll die einfügende Prozedur das Ereignis bearbeiten, so wird in die HandleEvent-Methode die Zuordnung "Befehlskonstante: EndModal(Befehlskonstante)" übernommen. Diese Prozedur gibt den Wert des Befehlsereignisses an die Funktionen ExecView bzw ExecuteDialog (Turbo Vision 2.0) weiter, deren Ergebnis in der Variablen "Result" abgespeichert wird. Result wird nun nach dem Schließen des Dialoges (ebenfalls in einer Case-anweisung) mit der vorbestimmten Aktion verbunden. Wenn Sie den Dialog nichtmodal einfügen, werden allerdings alle Buttons, die diese Einstellung aufweisen, schlicht und einfach ignoriert. Sie müssen dann selbst dafür sorgen, daß die HandleEvent-Methode der Application, an die der Befehl dann weitergegeben wird, um einen entsprechenden Eintrag ergänzt wird. Auch Buttons, deren Flag bfBroadcast gesetzt ist, werden nicht erfaßt. Für ihre Bearbeitung ist im Allgemeinen ein im Dialog enthaltenes, überschriebenes View-Objekt zuständig. Die Bearbeitung des Ereignisses durch die einfügende Prozedur statt durch die Dialog.HandleEvent-Methode ist eigentlich immer dann sinnvoll, wenn der Dialog nach dem Eintreffen des Befehls nicht mehr benötigt wird. - 31 - Im Eigenschaftendialog eines Dialogobjektes finden Sie eine Schaltfläche, über die Sie unabhängig von irgendwelchen Knöpfen Befehls/Prozedurzuordnungen in die HandleEvent-Methode des Dialoges bzw. in die Auswertung des Ergebnisses von ExecView aufnehmen oder auch löschen können. Dieses Verfahren bietet sich an, wenn Sie den Dialog auf Befehlsereignisse reagieren lassen wollen, die von der Statuszeile oder (bei nichtmodalen Dialogen) von Menübefehlen generiert wurden. Verschiedene Möglichkeiten der Befehlauswertung Unabhängig davon, ob Sie einen Befehl durch die HandleEvent-Methode des Dialoges oder durch die einfügende Prozedur bearbeiten lassen möchten, können Sie bei abgeleiteten Dialogen bestimmen, zu welchem Zeitpunkt innerhalb der HandleEvent-Methode die Zuordnung vorgenommen werden soll. Vorgabegemäß wird der Befehl bearbeitet, nachdem die geerbte HandleEvent-Methode aufgerufen wurde. Wenn Sie allerdings die Reaktion auf einen Befehl modifizieren möchten, der von der geerbten HandleEvent-Methode abgefangen würde (z.B. cmOk oder cmClose), können Sie bestimmen, ob dieser Befehl ausschließlich vor oder sowohl vor als auch durch die geerbte HandleEvent-Methode bearbeitet werden soll. Im ersten Fall wird nach Aufruf der mit dem Befehl verknüpften Prozedur die Prozedur ClearEvent(Event) aufgerufen, die den Eventrecord als bereits bearbeitet markiert und so eine weitere Bearbeitung unterbindet. - 32 - Der Datenrecord Der Datenaustausch mit den Elementen eines Dialoges sollte niemals direkt, sondern immer unter Benutzung der Methoden GetData bzw. SetData über einen Record erfolgen, dessen Einträge allerdings in Reihenfolge und Größe genau auf die Elemente des Dialoges abgestimmt sein müssen. Turbo Wizard erstellt diesen Datenrecord selbständig, in Abhängigkeit von der Eigenschaft "RecordEntry" eines jeden Dialogelementes. Bei dieser Eigenschaft handelt es sich schlicht um den Ausdruck, der im Quellcode für ein Dialogelement in diesem Record vorgesehen ist. Dieser wird z.B. für ein RadioButton-Feld "Word" lauten, er ist aber bei TInputLine-Objekten je nach erlaubter Eingabelänge variabel. (Hier lautet er nämlich "String[<erlaubte Länge>]") Bei abgeleiteten Objekten, deren Get/SetData-Methoden von denen ihrer Vorfahren abweichen, können Sie im Eigenschaftendialog neben dem Typ auch das Feld "RecordEntry" ändern. Wenn Sie das Feld RecordEntry im Eigenschaftendialog löschen, so unterbleibt ein Eintrag. Stellen Sie aber bitte sicher, daß die Get/SetData- und die DataSize-Methoden zu den modifizierten Einträgen passen. Bedeutung der Dialogelementnamen Die Einträge im Datenrecord werden unter den gleichen Namen vorgenommen, die die Dialogelemente selbst tragen. Es ist daher wichtig, für die einzelnen Dialogelemente möglichst "sprechende" Namen zu finden, um die Lesbarkeit des Quelltextes zu verbessern. Ein Eintrag wie "InputLine13: String[30]" ist insbesondere dann vollständig unleserlich, wenn Sie den Dialog aus einer Ressource laden oder mit dem Schalter "Stack schonen" bestimmt haben, daß alle Dialogelemente in der Variablen "Control" initialisiert werden sollen. Globale oder lokale Deklaration Turbo Wizard gibt Ihnen die Möglichkeit, den Recordtyp wahlweise lokal oder global zu deklarieren. Bei lokaler Deklaration findet sich eine "TYPE <Name der Prozedur>Rec=Record ... End;" Anweisung direkt in der Prozedur, die den Dialog aufruft. Bei globaler Deklaration wird der Recordtyp in der Datei "<ProjectName>REC.INC" deklariert. Die Instanz, die in der Prozedur benutzt wird, heißt NewData. Die lokale Deklaration, die natürlich nur dann sinnvoll ist, wenn die Daten, die man durch den Dialog abfragt, keinen zwingenden inneren Zusammenhang haben und daher besser als globale Recordvariable im Programm bekannt sein sollten, macht die Initialisierung des Records etwas einfacher, da man im Quelltext der Prozedur sofort Informationen über die Feldnamen erhält. Records auf dem Heap einrichten Es besteht außerdem die Möglichkeit, NewData nicht als lokale Variable auf dem Stack, sondern dynamisch in einer lokalen Zeigervariablen auf dem Heap einzurichten. Wenn Sie umfangreiche - 33 - Dialoge oder gar Memofelder nutzen sollten Sie von dieser Möglichkeit Gebrauch machen, um die Gefahr eines Stacküberlaufes zu vermindern. Initialisierung des Records Der Wizard fügt, bevor er mit Dialog^.SetData(NewData) bzw. ExecuteDialog(Dialog, @NewData) (Turbo Vision 2.0) die Daten aus dem Record in den Dialog überträgt, die Zeile "Fillchar(NewData, SizeOf(NewData), #0)" ein. Diese Anweisung stellt sicher, daß kein Datenmüll angezeigt wird. An dieser Stelle können Sie den Datenrecord mit den Werten vorbelegen, die beim Einfügen des Dialoges angezeigt werden sollen. ▌Warnung Wenn keine Initialisierung erfolgt und Sie dennoch diese "FillChar(...)"-anweisung löschen, kann es passieren, daß sich Ihr Programm aufhängt. Die SetData-Methode von TMemo z.B. verläßt sich (zumindest in ihrer Implementierung in Turbo Vision 2.0) darauf, daß der Record eine korrekte Längenangabe enthält und kopiert ohne Überprüfung genau diese Anzahl von Byte aus dem Record in den eigenen Datenbereich. Dies ist ein echter Bug und steht im Widerspruch sowohl zur Dokumentation als auch zum eigentlichen Konzept des Transfers! Sie können entsprechende Fehler natürlich aufspüren und korrigieren, bei sauberer Programmierung sollte dieser Fehler allerdings niemals auftreten, denn es ist natürlich sinnlos, zufällige Daten anzuzeigen. Mit sehr großer Wahrscheinlichkeit führt auch der Aufruf der TListBox.SetData-Methode mit einem nichtinitialisierten Record zu blankem Unsinn oder eher noch einem saftigen Systemabsturz. Diese Methode überprüft einen übergebenen Zeiger auf eine vermeintliche ListBox nur, ob er von Nil ($0000:$0000) verschieden ist, bevor er ihn als gültig akzeptiert. - 34 - Prozedurbezeichner Sie können Button- und Menübefehlen einen Prozedurnamen zuweisen, ohne sich darum kümmern zu müssen, ob diese Prozeduren schon irgendwo implementiert und dem Prototypen bekannt sind. Wenn Sie den Befehl "Projekt│Prototyp erzeugen" wählen, überprüft der Wizard, welche dieser Prozeduren bereits implementiert wurden um einen Dialog einzufügen. Für alle anderen erzeugt er einen "Dummy", eine Prozedur, die einfach nur ihren Namen in einer Messagebox ausgibt. Der Rückgabewert der Funktion MessageBox wird dabei allerdings nicht "verbraucht", so daß diese Prozeduren nur mit dem Compilerschalter $X+ (Extended Syntax) compiliert werden können. Die Deklarationen (für das Interface der Unit <ProjectName>RUN.PAS) der bereits implementierten Prozeduren befinden sich in der Includedatei <ProjectName>PDC.INC, die der Dummys in der Includedatei <ProjectName>DDC.INC. Die Implementierungen der Dummyfunktion finden Sie in <ProjectName>DMY.INC. Dies werden i.a. die tatsächlich "funktionellen" Elemente Ihres Programmes sein, in denen die Auswertung der eingegebenen Daten erfolgt. - 35 - Die TWApplication.HandleEvent-Methode Im Kapitel über die Konstruktion eines Menübalkens konnten Sie nachlesen, daß die dort vorgenommenen Kommando/Prozedurverknüpfungen zu einem Eintrag in die kommandoauswertende Case-Anweisung der HandleEvent-Methode des Application-Objektes führen. Durch den Menübefehl "Objekte│Application" haben Sie die Möglichkeit, weitere Einträge vorzunehmen oder Eintragungen zu löschen, wenn Sie einen Menübalken verworfen haben sollten. Dies ist z.B. nötig, wenn Sie Befehle in die Statuszeile aufgenommen haben, die Sie durch das Applikations-Objekt bearbeiten lassen möchten. Analog zu den Möglichkeiten, die Sie bei Dialogobjekten haben, um die Bearbeitung eines Kommandos zu steuern, können Sie auch hier bestimmen, ob ein Befehl NACH der geerbten, ausschließlich vor oder vor UND durch die geerbte HandleEvent-Methode bearbeitet werden soll. In der Standardeinstellung wird zunächst die geerbte Methode aufgerufen. Die Notwendigkeit für eine Änderung dieses voreingestellten Verhaltens ist am Beispiel des Befehls "cmQuit" ersichtlich. Dieser führt in der geerbten HandleEvent-Methode dazu, daß das Programm ohne weitere Rückfrage verlassen wird. Wenn Sie nun irgendwelche Aufräumarbeiten vornehmen müssen oder Grund dazu haben, an der ernsthaften Absicht des Anwenders zu zweifeln, haben Sie mehrere Möglichkeiten, dieses Verhalten zu ändern (in der Reihenfolge absteigender Eleganz): ■ Wenn die vorzunehmenden Arbeiten mit Viewobjekten wie Fenstern oder nichtmodalen Dialogen zusammenhängen, überschreiben Sie deren Methode Valid. Ein Beispiel dafür sind die Editorfenster in Turbo Vision, die vor Progammende nachfragen, ob man geänderte Dateien gesichert haben möchte. Dieses Vorgehen ist sehr empfehlenswert, da solche Objekte dieses Verhalten schließlich in jeder Application aufweisen und somit gut wiederzuverwenden sind. ■ Sie überschreiben die Valid-Methode der Application so, daß diese nur dann TRUE zurückgibt, wenn die geforderten Bedingungen vorliegen. Beispiel: Function TestApp.Valid(Command: Word): Boolean; Var ok: Boolean; Begin ok:=TApplication.Valid(Command); if ok and (Command=cmQuit) Then Valid:=ok and (MessageBox('Wirklich beenden?', nil, mfYesNoCancel+mfConfirmation)=cmYes) Else Valid:=ok; End; Diese Vorgehensweise ist empfehlenswert, wenn Sie (aus welchem Grunde auch immer) eine Möglichkeit vorsehen müssen, das Programmende zu verhindern. - 36 - ■ Sie fangen das Kommando cmQuit ab, bevor es von der geerbten HandleEvent-Methode bearbeitet wird, tun, was Sie nicht lassen können und geben das Kommando dann an die geerbte Methode weiter. Diese Vorgehensweise ist z.B. dann sinnvoll, wenn Sie alle zu erledigenden Arbeiten automatisch durchführen können und dem Anwender keine Möglichkeit zur Einflußnahme zu geben brauchen. ■ Sie überschreiben den Destructor Done des Applikations-Objektes. Diese Vorgehensweise ist der eben genannten sehr ähnlich, erfordert allerdings ein wenig mehr Schreibarbeit. Kommen Sie aber nicht auf die Idee, dieses Verfahren einzusetzen, wenn Sie das Programmende möglicherweise doch noch verhindern müssen - wenn Sie erst einmal bis zum Destructor gekommen sind, führt kein Weg mehr zurück. Welches dieser Verfahren Sie wählen hängt von den Erfordernissen und vom persönlichen Stilempfinden ab. - 37 - Die Schnittstelle zu eigenen Prozeduren und Funktionen Die Verbindung des vom Wizard erzeugten Quellcodes zu "eigenen" Prozeduren (die ja schließlich die Datenauswertung vornehmen sollen) ist primitiv, aber dafür einfach zu verstehen: Überall dort, wo Sie einer Befehlskonstanten den Namen einer Prozedur zugeordnet haben, ohne diesen Namen irgendwo für eine Prozedur benutzt zu haben, die einen Dialog in die Arbeitsfläche einfügt, erzeugt der Wizard eine parameterlose "Dummyprozedur", die im Prototypen in einer Messagebox ihren Namen ausgibt. Diese Dummyprozedur müssen Sie selbst "überschreiben", dann die Deklaration des Dummys in der Datei <ProjectName>DDC.INC und die Implementation in der Datei <ProjectName>DMY.INC löschen, und wenn nötig den Aufruf der Prozedur im Quelltext um etwaige Parameter ergänzen. Selbst wenn Ihre Prozedur die gleichen Parameter (nämlich keine) benutzt wie der Dummy sollten Sie Deklaration und Implementation an einer anderen Stelle vornehmen als in den genannten Dateien, da diese sonst später wieder überschrieben werden könnten. Am sichersten, bequemsten und häufig auch am effektivsten ist es, die Prozeduren entweder als Methode eines abgeleiteten Dialogobjektes oder als lokale Prozeduren innerhalb der einen modalen Dialog einfügenden Prozedur zu implementieren. Eine Vereinfachung ergibt sich für den Fall, daß Sie die einzubindenden Prozeduren aus einer eigenen Unit übernehmen. Die Vorgehensweise wird im nächsten Abschnitt beschrieben. - 38 - Einbinden eigener Units und externer Prozeduren Um Prozeduren, die der Wizard als Dummy deklarieren würde, aus externen Units einzubinden (und so den Code des Prototypen mit Leben zu erfüllen) oder um Objekttypen verwenden zu können, die Sie in eigenen Turbo Vision Bibliotheken deklariert haben, können Sie folgendermaßen vorgehen: Der Menübefehl "Projekt│Units..." öffnet einen Dialog, der Ihnen die Eingabe der zusätzlich einzubindenden Units, getrennt nach der Unit <ProjectName>RUN und dem Programm <ProjectName>, erlaubt. In der Zeile für die Unit <ProjectName>RUN würden Sie z.B. Units aufführen, die die Deklarationen für abgeleitete Objekte beinhalten, die Sie in Dialogen verwenden möchten. Hierhin gehören auch Units, die Prozeduren enthalten, die nicht durch die Application.HandleEvent-Methode, sondern im Zusammenhang mit Dialogen aufgerufen werden sollen. In der Zeile für das Programm führen Sie Units auf, die Prozeduren enthalten, die in der Application.HandleEvent-Methode aufgerufen werden. Wenn Sie nun über den Menübefehl "Projekt│Deklarationen..." die Liste der bisher deklarierten Prozedurbezeichner anzeigen lassen, können Sie in dieser Liste einzelne Prozeduren, die Sie aus einer eigenen Unit importieren möchten, als extern deklarieren, indem Sie den Bezeichner anwählen und dann die Tastenkombination ALT-Leertaste betätigen. Für derartig als extern deklarierte Prozeduren unterbleibt in Zukunft eine Dummydeklaration, sie werden in der Prozedurliste mit der Silbe "EXT" gekennzeichnet. Eine bereits als extern deklarierte Prozedur können Sie durch die gleiche Tastenkombination wieder in die Liste der Dummys aufnehmen. Die Änderung wird natürlich erst mit einem erneuten Aufruf des Menübefehls "Projekt│Prototyp vorbereiten" wirksam. - 39 - Anhang A, Dateischlüssel Die Quelltextdateien, die der Wizard während der Arbeit an einem Projekt erzeugt, werden nach dem folgendem Schema benannt. Für Dialoge, deren Quelltext mit der Option "Eigene Dateien anlegen" erzeugt wurde, ist die Dateiendung von Bedeutung: ▌".INP" signalisiert eine Datei, die die Implementation einer Prozedur enthält, die im Prototypen einen Dialog in den Desktop einfügt. Der Name der Datei bildet sich aus den ersten acht Buchstaben des Prozedurnamens. ▌".INR" signalisiert eine Datei, die die Implementation einer Prozedur enthält, welche im Ressourceneditor einen Dialog zusammenstellt und in der Ressourcendatei speichert. Der Name der Datei bildet sich aus den ersten acht Buchstabens des Namens der Prozedur, die diese Ressource verwendet. ▌".INT" signalisiert eine Datei, die die Deklaration eines neuen Dialogtypen enthält, also den Programmteil, der im Interface der Unit auftauchen wird. Der Name der Datei bildet sich aus den ersten acht Buchstaben des Typenbezeichners. ▌".INO" signalisiert eine Datei, die die Imlementation von Objektmethoden (Store, Load, Init, HandleEvent) enthält. der Name der Datei bildet sich aus den ersten acht Buchstaben des Typbezeichners. Folgende Dateien werden vom Wizard für alle Prozeduren/Objekte, bei denen auf die Erzeugung eines eigenen Satzes von Dateien verzichtet wurde, und bei der Vorbereitung eines Prototypen angelegt. Der Ausdruck <Name> bezeichnet im weiteren die ersten fünf Buchstaben des Namens der Projektdatei. ▌<ProjectName>.PAS: Die eigentliche Programmdatei. Sie enthält die Typendeklaration für den TApplication-Nachfahren "TWApplication", dessen Methoden InitMenubar, InitStatusline und HandleEvent überschrieben werden. ▌<Name>RUN.PAS: Diese Unit enthält die Deklaration und Implementation des Dialogtyps TWDialog (s.o.), der Statuszeile "TWStatusLine", deren Methode Hint durch den Wizard überschrieben wird, die TStreamRec-Records dieser Objekte sowie Includeanweisungen für die Deklarationen aller von Ihnen gestalteten Dialoge und Prozeduren. ▌<Name>RES.PAS: Dies ist die Programmdatei des Ressourceneditors, der die Objekte, die aus einer Ressourcendatei ins Programm geladen werden sollen, erzeugt. ▌<ProjektName>.INT: Diese Datei enthält die Typendeklarationen - 40 - von Objekten, deren Zeigertypen und TStreamRecs. ▌<Name>PDC.INC: Diese Datei enthält die Vorausdeklarationen von Prozeduren, die einen mit dem Wizard gestalteten Dialog einfügen. ▌<Name>DDC.INC: Diese Datei enthält die Deklarationen von Prozeduren die durch Menü- oder Buttonbefehle aufgerufen werden, aber noch nicht implementiert wurden. ▌<ProjektName>.INP: Diese Datei enthält den Code der Prozeduren, die Dialoge einfügen. ▌<ProjektName>.INO: Diese Datei enthält die die Constructor-, HandleEvent-, Load- und Store-Methoden von Dialogobjekten. ▌<Name>DMY.INC: Diese Datei enthält vorläufige Implementationen von Prozeduren, die einem Befehlerereignis zugeordnet, aber nicht als Dialog implementiert wurden ("Dummys"). Diese Prozeduren geben in einer MessageBox ihren eigenen Namen aus. ▌<Name>CMX.INC: Diese Datei enthält die Deklarationen der Kommandokonstanten. ▌<Name>HCX.INC: Diese Datei enthält die Deklarationen der Hilfekontextkonstanten. Wenn Sie die Onlinehilfe vollständig mit dem Wizard erstellt haben, so ist diese Datei konsistent mit der Unit, die der Hilfecompiler TVHC erzeugt. Wenn Sie den Hilfetext außerhalb des Wizard um neue Topics erweitert haben, müssen Sie die Include-anweisungen für diese Datei löschen und statt dessen die von TVHC erzeugte Unit <Name>HLP.PAS mit "uses" einbinden. Sie sollten neue Topics allerdings IMMER am Ende der Hilfedatei anfügen, um eine größtmögliche Übereinstimmung zu erhalten. ▌<Name>HNT.INC: Die Funktion TWStatusLine.Hint. ▌<Name>EVH.INC: Die Methode TWApplication.HandleEvent. ▌<Name>MNU.INC: Die Methode TWApplication.InitMenuBar. ▌<Name>STL.INC: Die Methode TWApplication.InitStatusLine. ▌<ProjektName>.INR: Die Prozeduren zur Erzeugung von Objekten in Ressourcen. ▌<Name>RRN.INC: Der Aufruf dieser Prozeduren in der Prozedur Run. - 41 - ▌<Name>REG.INC: Diese Datei enthält die Implementation der Prozedur, die über den Aufruf der Prozedur RegisterType() jeden während eines Projektes deklarierten Dialogobjekt-Typen registriert. Diese Methode wird sowohl im Prototypen als auch im Ressourceneditor benutzt. ▌<Name>HLP.TXT: Die Textdatei, in der die Hilfetexte niedergeschrieben werden. Sie muß mit dem Turbo Vision Hilfecompiler TVHC zu einer verwendbaren Hilfedatei compiliert werden, um im Programm benutzt werden zu können. ▌<Name>REC.INC: Diese Datei enthält die Deklarationen global deklarierter Datenrecords. - 42 - Anhang B: Coming Attractions... Folgende Erweiterungen und Verbesserungen sind mehr oder weniger kurzfristig geplant - die letztendliche Entscheidung hängt natürlich von der Anwenderresonanz ab: ■ Optionales Einfügen von Kommentaren in den Quelltext. ■ Verbesserung der Integration abgeleiteter Dialogelement-Objekte durch die Möglichkeit, diesen Objekten einen eigenen Constructor mitzugeben. ■ Einführung von Standardelementen wie OK/Cancel-Buttons, kompletten Standardmenüs und Statuszeilen. ■ Die Einbindung von benutzerdefinierten Dialogelementen in das Objektmenü. Solche Objekte sollten ähnlich einfach zu benutzen sein wie ihre Vorfahren. ■ Die Möglichkeit zur Deklaration globaler oder lokaler Variablen, die auch die Übergabe von Parametern an Prozeduren erlauben würden.