delphi 5 - entwicklerhandbuch

2-28Eine Behandlungsroutine für das Standardereignis einer Komponente erstellen.. 46-2 Ereignisse in einem Kapitel 47 Automatisierungsserver erstellen 47-1 Automatisierungsobjekte für ei

Copyright © 1998, 1999 Inprise, Inc Alle Rechte vorbehalten Alle Produktnamen von Inprise sind eingetragene Warenzeichen der Inprise, Inc

Deutsche Ausgabe © 1999 Inprise GmbH, Robert-Bosch-Straße 11, D-63225 Langen, Telefon 06103/979-0, Fax 06103/979-290

Update/Übertragung ins Deutsche: Krieger, Zander & Partner GmbH, München

Satz: Krieger, Zander & Partner GmbH, München

Hauptsitz: 100 Enterprise Way, P.O Box 660001, Scotts Valley, CA 95067-0001, +1-(408)431-1000

Niederlassungen in: Australien, Deutschland, Frankreich, Großbritannien, Hong Kong, Japan, Kanada, Lateinamerika, Mexiko, den Niederlanden und Taiwan

HDA1350GE21001

Was ist ein Objekt? 2-2

Ein Delphi-Objekt untersuchen 2-3

Daten und Quelltext von einem Objekt erben 2-5

Objekte, Komponenten und

Steuer-elemente 2-6

Gültigkeitsbereich und Qualifizierer 2-6

private-, protected-, public- und

Eigenschaften von Komponenten festlegen 2-26

Den Objektinspektor verwenden 2-27

Eigenschaften zur Laufzeit festlegen 2-27

Methoden aufrufen 2-28

Mit Ereignissen und Ereignisbehandlungsroutinen arbeiten 2-28Eine neue Ereignisbehandlungsroutine erstellen 2-28Eine Behandlungsroutine für das

Standardereignis einer Komponente erstellen 2-29Ereignisbehandlungsroutinen suchen 2-29Ereignissen eine vorhandene

Behandlungsroutine zuordnen 2-29Menüereignissen eine Behandlungsroutine zuordnen 2-30Ereignisbehandlungsroutinen löschen 2-31Hilfsobjekte verwenden 2-31Mit Listen arbeiten 2-32Mit Stringlisten arbeiten 2-32Stringlisten laden und speichern 2-33Eine neue Stringliste erstellen 2-33Mit den Strings in einer Liste arbeiten 2-35Einer Stringliste Objekte zuordnen 2-37Mit Registrierung und INI-Dateien arbeiten 2-38Streams verwenden 2-38Datenmodule und Remote-Datenmodule

verwenden 2-38Datenmodule erstellen und bearbeiten 2-39Business Rules in einem Datenmodul erstellen 2-39

In einem Formular auf ein Datenmodul zugreifen 2-40Ein Remote-Datenmodul einem

Anwendungsserver hinzufügen 2-40Die Objektablage verwenden 2-40Elemente in einem Projekt gemeinsam

verwenden 2-41Elemente in die Objektablage aufnehmen 2-41Objekte in einer Team-Umgebung gemeinsam verwenden 2-41Ein Element der Objektablage in einem

Projekt verwenden 2-42Ein Objekt kopieren 2-42Ein Objekt vererben 2-42Ein Objekt verwenden 2-42Projektvorlagen verwenden 2-42Freigegebene Objekte ändern 2-43Ein Standardelement für neue Projekte,

Formulare und Hauptformulare angeben 2-43

Inhalt

Auf Exceptions reagieren 3-2

Exceptions und die Ablaufsteuerung 3-3

Schnittstellen als Sprachmerkmal 3-16

Schnittstellen in mehreren Klassen

Keine Referenzzählung einsetzen 3-24

Schnittstellen in verteilten Anwendungen einsetzen 3-24Mit Strings arbeiten 3-25Zeichentypen 3-25String-Typen 3-26Kurze Strings 3-26Lange Strings 3-27WideString 3-28PChar-Typen 3-28OpenString 3-28Routinen der Laufzeitbibliothek zur String-Verarbeitung 3-29Wide-Zeichenroutinen 3-29Gebräuchliche Routinen für lange

Strings 3-30Strings deklarieren und initialisieren 3-32String-Typen mischen und konvertieren 3-33Konvertierungen von String in PChar 3-33String-Abhängigkeiten 3-34Lokale PChar-Variable zurückgeben 3-34Lokale Variable als PChar übergeben 3-34Compiler-Direktiven für Strings 3-35Strings und Zeichen: Verwandte Themen 3-36Mit Dateien arbeiten 3-36Dateien bearbeiten 3-37Datei löschen 3-37Datei suchen 3-37Dateiattribute ändern 3-39Datei umbenennen 3-39Datums-/Zeit-Routinen 3-40Datei kopieren 3-40Dateitypen mit Datei-E/A 3-40Datei-Streams verwenden 3-41Dateien erstellen und öffnen 3-42Datei-Handle verwenden 3-42Dateien lesen und schreiben 3-43Strings lesen und schreiben 3-43Datei durchsuchen 3-44Dateiposition und -größe 3-44Kopieren 3-45Neue Datentypen definieren 3-45

Kapitel 4

Anwendungen, Komponenten und

Anwendungen erstellen 4-1Windows-Anwendungen 4-1Benutzeroberflächen 4-2

Packages und DLLs erstellen 4-9

Unterschiede zwischen Packages und DLLs 4-9

Datenbankanwendungen erstellen 4-9

Verteilte Anwendungen erstellen 4-10

Verteilte TCP/IP-Anwendungen erstellen 4-10

Sockets in Anwendungen verwenden 4-11

Verteilte CORBA-Anwendungen erstellen 4-12

Verteilte Datenbankanwendungen erstellen 4-13

Kapitel 5

Die Benutzeroberfläche erstellen 5-1

Die Klassen TApplication, TScreen und TForm 5-1

Das Hauptformular 5-1

Weitere Formulare hinzufügen 5-2

Formulare verknüpfen 5-2

Auf Anwendungsebene arbeiten 5-3

Mit dem Bildschirm arbeiten 5-3

Das Layout festlegen 5-3

Mit Botschaften arbeiten 5-5

Weitere Informationen zu Formularen 5-5

Die Formularerstellung im Speicher steuern 5-5

Automatisch erstellte Formulare anzeigen 5-6

Formulare dynamisch erstellen 5-6

Nichtmodale Formulare erstellen 5-7

Formularinstanzen mit lokalen Variablen

erstellen 5-7

Zusätzliche Argumente an Formulare

übergeben 5-8

Daten aus Formularen abrufen 5-9

Daten aus nichtmodalen Formularen

abrufen 5-9

Daten aus modalen Formularen abrufen 5-10

Komponenten und Komponentengruppen wieder

verwenden 5-12

Komponentenvorlagen 5-12

Frames 5-13

Frames erstellen 5-14Frames in die Komponentenpalette

einfügen 5-14Frames verwenden und ändern 5-14Frames freigeben 5-16Menüs erstellen und verwalten 5-16Den Menü-Designer öffnen 5-17Menüs entwerfen 5-18Menüs benennen 5-19Menüeinträge benennen 5-19Menüeinträge hinzufügen, einfügen und entfernen 5-20Untermenüs erstellen 5-21Das Menü anzeigen 5-23Menüeinträge im Objektinspektor

bearbeiten 5-24Das lokale Menü des Menü-Designers

verwenden 5-24Die Befehle des lokalen Menüs 5-25Zur Entwurfszeit zwischen Menüs

wechseln 5-25Menüvorlagen verwenden 5-26Ein Menü als Vorlage speichern 5-27Namenskonventionen für Menüeinträge und Ereignisbehandlungsroutinen in Vorlagen 5-28Menüeinträge zur Laufzeit bearbeiten 5-29Menüs kombinieren 5-29Das aktive Menü festlegen: die Eigenschaft Menu 5-29Die Reihenfolge der kombinierten

Menüeinträge festlegen: die Eigenschaft GroupIndex 5-29Ressourcen-Dateien importieren 5-30ToolBar- und CoolBar-Komponenten erstellen 5-31Eine Panel-Komponente als Symbolleiste hinzufügen 5-32Einer Symbolleiste (TPanel) eine

SpeedButton-Komponente hinzufügen 5-32Einer SpeedButton-Komponente eine Grafik zuweisen 5-33Die Anfangseinstellungen einer

SpeedButton-Komponente festlegen 5-33Eine Gruppe von SpeedButton-

Komponenten erstellen 5-33Eine SpeedButton-Komponente als Ein-/Ausschalter verwenden 5-34Eine ToolBar-Komponente als Symbolleiste hinzufügen 5-34

Eine CoolBar-Komponente hinzufügen 5-36

Die Anfangseinstellungen einer

CoolBar-Komponente festlegen 5-37

Auf Mausklicks reagieren 5-37

Einer ToolButton-Komponente ein Menü

zuweisen 5-38

Verborgene Symbolleisten hinzufügen 5-38

Symbolleisten ein- und ausblenden 5-38

Eine Drag-Operation beginnen 6-1

Gezogene Elemente akzeptieren 6-2

Elemente ablegen 6-3

Eine Drag-Operation beenden 6-3

Drag&Drop-Operationen durch ein

Drag-Objekt anpassen 6-3

Den Drag-Mauszeiger ändern 6-4

Drag&Dock in Steuerelementen implementieren6-4

Ein fensterorientiertes Steuerelement als Ziel einer Andock-Operation definieren 6-5Ein Steuerelement als andockbares

Steuerelement definieren 6-5Andock-Operationen von Steuerelementen steuern 6-6Steuerelemente vom Ziel einer Andock-

Operation trennen 6-6Die Behandlung von Drag&Dock-Operationen durch Steuerelemente festlegen 6-7Text in Steuerelementen bearbeiten 6-7Die Textausrichtung festlegen 6-8Bildlaufleisten zur Laufzeit hinzufügen 6-8Das Clipboard-Objekt hinzufügen 6-9Text markieren 6-9Den gesamten Text markieren 6-10Text ausschneiden, kopieren und einfügen 6-10Markierten Text löschen 6-11Menüeinträge deaktivieren 6-11Ein Popup-Menü bereitstellen 6-12Das Ereignis OnPopup 6-12Grafiken zu Steuerelementen hinzufügen 6-13Den Owner-Draw-Stil festlegen 6-13Grafikobjekte zu einer Stringliste

hinzufügen 6-14Grafiken zu einer Anwendung

hinzufügen 6-14Grafiken zu einer Stringliste hinzufügen 6-14Owner-Draw-Elemente anzeigen 6-15Größe von Owner-Draw-Elementen

festlegen 6-15Alle Owner-Draw-Elemente anzeigen 6-16

Kapitel 7

Mit Grafiken und Multimedia arbeiten 7-1

Grafikprogrammierung im Überblick 7-1Den Bildschirm aktualisieren 7-2Grafikobjekt-Typen 7-3Häufig verwendete Eigenschaften und

Methoden des Objekts Canvas 7-4Eigenschaften des Objekts Canvas

verwenden 7-5Stifte verwenden 7-5Pinsel verwenden 7-8Pixel lesen und setzen 7-10Grafikobjekte zeichnen 7-10Linien und Linienzüge zeichnen 7-10Formen zeichnen 7-11

Behandlung mehrerer Zeichenobjekte in einer

Anwendung 7-13

Benötigte Zeichenwerkzeuge ermitteln 7-13

Werkzeuge mit Hilfe von

Grafikdateien laden und speichern 7-20

Bilder aus Dateien laden 7-21

Bilder in Dateien speichern 7-21

Bilder ersetzen 7-22

Die Zwischenablage und Grafiken 7-23

Grafiken in die Zwischenablage

Der Gummiband-Effekt: Beispiel 7-24

Auf Mausaktionen reagieren 7-25

Felder einem Formularobjekt

hinzufügen 7-28

Verbesserte Liniendarstellung 7-29

Mit Multimedia arbeiten 7-31

Einer Anwendung Videoclips ohne Ton

Den Thread initialisieren 8-3

Eine Standard-Priorität zuweisen 8-3

Den Freigabezeitpunkt von Threads

festlegen 8-3

Die Thread-Funktion schreiben 8-4

Der VCL-Haupt-Thread 8-4

Lokale Thread-Variablen verwenden 8-5

Die Beendigung mit anderen Threads

prüfen 8-6

Clean-up-Quelltext schreiben 8-6

Threads koordinieren 8-7Gleichzeitigen Zugriff vermeiden 8-7Objekte sperren 8-7Kritische Abschnitte 8-7TMultiReadExclusiveWriteSynchronizer-Objekte 8-8Weitere Techniken für die gemeinsame Nutzung von Speicher 8-9Die Ausführung anderer Threads abwarten 8-9Warten, bis ein Thread vollständig

ausgeführt ist 8-9Warten, bis eine Aufgabe ausgeführt ist 8-10Thread-Objekte ausführen 8-11Die Standard-Priorität überschreiben 8-11Threads starten und stoppen 8-12Threads in verteilten Anwendungen 8-12Threads und botschaftsbasierte Server 8-13Threads und verteilte Objekte 8-13Anwendungen (EXE-Dateien) schreiben 8-13Bibliotheken schreiben 8-14Fehlersuche in Multithread-Anwendungen 8-15

Kapitel 9

Packages sinnvoll einsetzen 9-2Packages und Standard-DLLs 9-2Laufzeit-Packages 9-3Laufzeit-Packages in Anwendungen 9-3Packages dynamisch laden 9-4Benötigte Laufzeit-Packages auswählen 9-4Benutzerdefinierte Packages 9-5Entwurfszeit-Packages 9-6Komponenten-Packages installieren 9-6Packages erstellen und bearbeiten 9-8Ein Package erstellen 9-8Ein bestehendes Package bearbeiten 9-9Quelldateien von Packages manuell

bearbeiten 9-9Die Struktur eines Package 9-10Packages benennen 9-10Die requires-Klausel 9-10Die contains-Klausel 9-11Packages compilieren 9-11Spezielle Compiler-Direktiven für

Packages 9-12Der Befehlszeilen-Compiler und -Linker 9-14Package-Dateien nach erfolgreicher

Compilierung 9-14Packages weitergeben 9-15

Anwendungen mit Packages weitergeben 9-15

Packages anderen Entwicklern zur Verfügung

Die Datenbank-Engine bereitstellen 11-5

Borland Database Engine 11-5

Datenbank-Engines von

Fremd-herstellern 11-6

SQL Links 11-6MIDAS (Multi-tiered Distributed Application Services) 11-7Web-Anwendungen weitergeben 11-8Unterschiedliche Host-Umgebungen

berücksichtigen 11-8Bildschirmauflösung und Farbtiefe 11-9Anwendungen ohne dynamische

Größenanpassung 11-9Anwendungen mit dynamischer

Größenanpassung der Formulare und Steuerelemente 11-9Unterschiedliche Farbtiefen 11-11Schriften 11-11Windows-Version 11-12Software-Lizenzvereinbarungen .11-12DEPLOY.TXT .11-13README.TXT 11-13Lizenzvereinbarungen 11-13Dokumentation zu Produkten von

Grundlagen der MIDAS-Technologie 14-3

Struktur einer mehrschichtigen Anwendung 14-3Die Struktur der Client-Anwendung 14-4Die Struktur des Anwendungsservers 14-5MTS verwenden 14-6Remote-Datenmodule verwalten 14-8Schnittstelle IAppServer verwenden 14-8Verbindungsprotokoll wählen 14-9DCOM-Verbindungen einsetzen 14-9Socket-Verbindungen einsetzen 14-10Web-Verbindungen einsetzen .14-11OLEnterprise verwenden 14-11CORBA-Verbindungen einsetzen 14-12Mehrschichtige Anwendungen erstellen 14-12Anwendungsserver erstellen 14-13Remote-Datenmodul einrichten 14-15TRemoteDataModule konfigurieren 14-15TMTSDataModule konfigurieren 14-16TCorbaDataModule konfigurieren 14-17Daten-Provider für Anwendungsserver erstellen 14-18Schnittstelle des Anwendungsservers

MIDAS-erweitern 14-19Callbacks der Schnittstelle des

Anwendungsservers hinzufügen 14-20Schnittstelle des Anwendungsservers unter MTS erweitern 14-20Client-Anwendung erstellen 14-20Verbindung zum Anwendungsserver

einrichten 14-21Verbindung über DCOM angeben 14-22Verbindung über Sockets angeben 14-23Verbindung über HTTP angeben 14-24Verbindung über OLEnterprise

angeben 14-24Verbindung über CORBA angeben 14-25Broker-Verbindungen 14-25Server-Verbindungen verwalten 14-26Verbindung zum Server einrichten 14-26Server-Verbindung schließen oder

ändern 14-27Serverschnittstellen aufrufen 14-27Transaktionen in mehrschichtigen Anwendungen verwalten 14-28Haupt/Detail-Beziehungen unterstützen 14-29Statusinformationen in Remote-Datenmodulen unterstützen 14-30Web-basierte MIDAS-Anwendungen erstellen14-32

Felder für Datenpakete festlegen 15-3

Optionen für Datenpakete einstellen 15-3

Datenpaketen benutzerdefinierte Daten

hinzufügen 15-4

Auf Datenanforderungen des Client reagieren 15-5

Auf Aktualisierungsanforderungen des Client

reagieren 15-6

Delta-Pakete vor dem Aktualisieren der

Datenbank bearbeiten 15-7

Die Art der Aktualisierung steuern 15-8

Bestimmte Aktualisierungen überwachen 15-9

Datenbankverbindungen festlegen 16-6Datenbankverbindungen erzeugen, öffnen und schließen 16-7Eine einzelne Datenbankverbindung schließen 16-7Alle Datenbankverbindungen schließen 16-8Temporäre Datenbankverbindungen

trennen 16-8Nach einer Datenbankverbindung suchen 16-9Informationen über eine Sitzung abrufen 16-9BDE-Aliase 16-10Die Sichtbarkeit von Aliasen festlegen .16-11Sitzungs-Aliase für andere Sitzungen und Anwendungen sichtbar machen 16-11Bekannte Aliase, Treiber und Parameter festlegen .16-11Aliase erzeugen, ändern und löschen 16-12Durch die Datenbank-Komponenten einer Sitzung iterieren 16-13Paradox-Verzeichnisse angeben 16-14Das Verzeichnis der Steuerdatei

festlegen 16-14Ein Verzeichnis für temporäre Dateien festlegen 16-14Kennwortgeschützte Paradox- und dBase-Tabellen 16-15Die Methode AddPassword verwenden 16-15Die Methoden RemovePassword und RemoveAllPasswords verwenden 16-16Die Methode GetPassword und das

Ereignis OnPassword verwenden 16-16Mehrere Sitzungen verwalten 16-17Sitzungskomponenten in Datenmodulen

Datenbank-erstellen 17-3Verbindungen steuern 17-4

Mit einem Datenbankserver verbinden 17-7

Besonderheiten beim Verbinden mit einem

Die Komponente TDataSet 18-2

Arten von Datenmengen 18-3

Datenmengen öffnen und schließen 18-3

Den Status von Datenmengen bestimmen und

Durch Datenmengen navigieren 18-11

Die Methoden First und Last 18-12

Die Methoden Next und Prior 18-12

Die Methode MoveBy 18-13Die Eigenschaften EOF und BOF 18-13EOF 18-14BOF 18-15Datensätze markieren und dorthin

zurückkehren 18-15Datenmengen durchsuchen 18-17Die Methode Locate 18-17Die Methode Lookup 18-18Teilmengen von Daten mit Hilfe von Filtern anzeigen und bearbeiten 18-19Filter aktivieren und deaktivieren 18-19Filter erzeugen 18-20Die Eigenschaft Filter festlegen 18-20Eine Behandlungsroutine für das Ereignis OnFilterRecord schreiben 18-21Filterbehandlungsroutinen zur Laufzeit wechseln 18-22Filteroptionen festlegen 18-22Durch Datensätze einer gefilterten Datenmenge navigieren 18-23Daten bearbeiten 18-24Datensätze bearbeiten 18-24Neue Datensätze hinzufügen 18-25Datensätze einfügen 18-26Datensätze anhängen 18-26Datensätze löschen 18-27Daten in die Datenbank eintragen 18-27Änderungen rückgängig machen 18-28Komplette Datensätze bearbeiten 18-28Ereignisse für Datenmengen behandeln 18-30Eine Methode abbrechen 18-30Das Ereignis OnCalcFields 18-30BDE-Datenmengen 18-31BDE-Datenmengen im Überblick 18-32Datenbank- und Sitzungsverbindungen verwalten 18-32Die Eigenschaften DatabaseName und SessionName 18-33BDE-Handle-Eigenschaften 18-34Zwischengespeicherte Aktualisierungen 18-34BLOBs zwischenspeichern 18-35

Kapitel 19

Was sind Feldkomponenten? 19-2Dynamische Feldkomponenten 19-3Persistente Feldkomponenten 19-4Persistente Felder erstellen 19-6

Persistente Felder anordnen 19-7

Neue persistente Felder erstellen 19-7

Datenfelder definieren 19-8

Berechnete Felder definieren 19-9

Berechnete Felder programmieren 19-10

Lookup-Felder definieren 19-11

Aggregatfelder definieren 19-13

Persistente Feldkomponenten löschen 19-13

Eigenschaften und Ereignisse persistenter

Mit der Standard-Datenmengeneigenschaft

auf Werte zugreifen 19-22

Mit der Datenmengeneigenschaft Fields auf

Werte zugreifen 19-23

Mit der Datenmengenmethode FieldByName

auf Werte zugreifen 19-23

Den aktuellen Wert eines Feldes überprüfen 19-24

Einen Standardwert für ein Feld festlegen 19-24

zugreifen 19-31

Kapitel 20

Tabellenkomponenten 20-1Tabellenkomponenten erstellen 20-2Datenbankposition angeben 20-2Tabellennamen festlegen 20-3Tabellentypen für lokale Tabellen festlegen 20-4Tabellen öffnen und schließen 20-4Zugriff auf Tabellen steuern 20-5Datensätze suchen 20-6Datensätze über indizierte Felder suchen 20-6Datensätze mit Goto-Methoden suchen 20-7Datensätze mit Find-Methoden suchen 20-8Aktuellen Datensatz nach einer erfolgreichen Suche bestimmen 20-8Datensätze über Teilschlüssel suchen 20-9Datensätze über Sekundärindizes suchen 20-9Suchoperationen wiederholen oder

erweitern 20-9Datensätze sortieren 20-10Verfügbare Indizes mit GetIndexNames abrufen 20-10Sekundärindizes in IndexName festlegen 20-10dBASE-Indexdateien angeben 20-11Sortierreihenfolge für SQL-Tabellen .20-11Felder in IndexFieldNames angeben .20-11Feldlisten nach einem Index durchsuchen 20-12Mit Teilmengen der Daten arbeiten 20-12Unterschiede zwischen Bereichen und

Filtern 20-12Bereiche erstellen und zuweisen 20-13Bereichsanfang festlegen 20-13Bereichsende festlegen 20-14Bereichsanfang und -ende festlegen 20-15Bereiche mit Teilschlüsseln festlegen 20-15Datensätze ein- oder ausschließen, die mit Bereichsgrenzen übereinstimmen 20-16Bereiche zuweisen 20-16Bereiche entfernen 20-16Bereiche ändern 20-17Bereichsanfang ändern 20-17Bereichsende ändern 20-17

Datenbanken, auf die mit einer

Abfragekomponente zugegriffen werden

kann 21-4

Abfragekomponenten im Überblick 21-4

Die Eigenschaft SQL setzen 21-6

Die Eigenschaft SQL zur Entwurfszeit setzen

21-7

Die Eigenschaft SQL zur Laufzeit setzen 21-7

Die Eigenschaft SQL direkt setzen 21-8

Die Eigenschaft SQL aus einer Datei

laden 21-8

Die Eigenschaft SQL aus einem

Stringlisten-Objekt laden 21-9

Parameter setzen 21-9

Parameter zur Entwurfszeit setzen 21-10

Parameter zur Laufzeit setzen 21-11

Datenquellen für die Parameterbindung 21-11

Abfragen ausführen 21-13

Abfragen zur Entwurfszeit ausführen 21-13

Abfragen zur Laufzeit ausführen 21-14

Abfragen ausführen, die Ergebnismengen liefern 21-14Abfragen ausführen, die keine

Ergebnismengen liefern 21-15Abfragen vorbereiten 21-15Abfragen zur Freigabe von Ressourcen

zurücksetzen 21-15Heterogene Abfragen erstellen 21-16Die Ausführungsgeschwindigkeit von Abfragen erhöhen 21-17Bidirektionale Cursor deaktivieren 21-17Mit Ergebnismengen arbeiten 21-18Die Bearbeitung einer Ergebnismenge

ermöglichen 21-18Local SQL-Syntax für aktualisierbare

Ergebnismengen 21-18Einschränkungen für Abfragen mit

aktualisierbaren Ergebnismengen 21-18Remote-Server-SQL für aktualisierbare

Ergebnismengen 21-19Einschränkungen bei der Bearbeitung von aktualisierbaren Ergebnismengen 21-19Nur-Lesen-Ergebnismengen aktualisieren 21-19

Kapitel 22

Stored Procedures verwenden 22-2Mit Stored Procedures arbeiten 22-3Stored-Procedure-Komponenten erstellen 22-3Stored Procedures erstellen 22-4Stored Procedures vorbereiten und

ausführen 22-5Stored Procedures, die Ergebnismengen zurückgeben 22-6Ergebnismengen mit einer TQuery-

Komponente abrufen 22-6Ergebnismengen mit einer TStoredProc-Komponente abrufen 22-7Stored Procedures, die Daten mit Hilfe von Parametern zurückliefern 22-7Einzelne Werte mit einer TQuery-

Komponente abrufen 22-7Einzelne Werte mit einer TStoredProc-Komponente abrufen 22-8Stored Procedures, die Aktionen an Daten vornehmen 22-9Stored Procedures, die Aktionen ausführen, mit einer TQuery-Komponente

aufrufen 22-9

Stored Procedures, die Aktionen ausführen,

mit einer TStoredProc-Komponente

Zur Entwurfszeit auf Parameter zugreifen 22-14

Parameter während des Entwurfs

Mit TADOConnection eine Verbindung zu

einem Datenspeicher einrichten 23-3

TADOConnection im Vergleich mit der

Eigenschaft ConnectionString einer

Datenmenge 23-4

Verbindungen festlegen 23-4

Auf das Verbindungsobjekt zugreifen 23-5

Verbindungen aktivieren und

Tabellen und Stored Procedures abrufen 23-9

Auf die Datenmengen einer Verbindung

zugreifen 23-9

Auf die Befehle einer Verbindung

zugreifen 23-10

Verfügbare Tabellen abrufen 23-11

Verfügbare Stored Procedures abrufen 23-12

Mit Verbindungstransaktionen arbeiten 23-12

ADO-In Datenmengen navigieren 23-14Visuelle datensensitive Steuerelemente verwenden 23-15Mit ADO-Datenmengenkomponenten Verbindungen zu Datenspeichern herstellen 23-15Mit Datensatzmengen arbeiten 23-16Batch-Aktualisierungen verwenden 23-17Daten aus Dateien laden und in Dateien speichern 23-19Parameter in Befehlen verwenden 23-20TADODataSet verwenden 23-21Mit Befehlen auf Datenmengen

zugreifen 23-22TADOTable verwenden 23-22

Zu verwendende Tabellen festlegen 23-23TADOQuery verwenden 23-24SQL-Anweisungen festlegen 23-24SQL-Anweisungen ausführen 23-25TADOStoredProc verwenden 23-25Stored Procedures festlegen 23-26Stored Procedures ausführen 23-27Parameter mit Stored Procedures

verwenden 23-27Befehle ausführen 23-30Befehle festlegen 23-30Die Methode Execute verwenden 23-31Befehle abbrechen 23-31Mit Befehlen auf Ergebnismengen

zugreifen 23-32Befehlsparameter verarbeiten 23-32

Kapitel 24

Client-Datenmengen 24-2Durch die Daten einer Client-Datenmenge navigieren 24-2Datensätze einschränken 24-2Haupt/Detail-Beziehungen 24-3Datenwerte beschränken 24-4Daten das Attribut Nur-Lesen zuweisen 24-4Daten bearbeiten 24-5Änderungen rückgängig machen 24-5Änderungen speichern 24-6Sortieren und Indizieren 24-6Einen neuen Index hinzufügen 24-7

Indizes entfernen und wechseln 24-8

Daten mit Indizes gruppieren 24-8

Bei Bedarf indizieren 24-9

Berechnete Felder hinzufügen 24-9

Intern berechnete Felder in

den Daten hinzufügen 24-13

Daten aus einer anderen Datenmenge kopieren

Einen Daten-Provider festlegen 24-16

Parameter vom Anwendungsserver

Eine neue Datenmenge erstellen 24-27

Daten aus einer Datei oder einem Stream

laden 24-27

Änderungen in die Daten schreiben 24-27

Daten in einer Datei oder einem Stream

speichern 24-28

Kapitel 25

Zwischengespeicherte Aktualisierungen 25-1

Wann werden zwischengespeicherte Aktualisierungen eingesetzt? 25-1Die Realisierung im Überblick 25-2Die Zwischenspeicherung aktivieren und deaktivieren 25-3Datensätze abrufen 25-4Zwischengespeicherte Aktualisierungen zurückschreiben 25-4Aktualisierungen mit Datenbank-

Komponenten eintragen 25-5Zurückschreiben bei Datenmengen-

komponenten 25-6Haupt/Detailtabellen aktualisieren 25-7Anstehende Aktualisierungen verwerfen 25-8Anstehende Aktualisierungen verwerfen und die Zwischenspeicherung

deaktivieren 25-8Nur anstehende Aktualisierungen

verwerfen 25-8Aktualisierungen am aktuellen Datensatz verwerfen 25-9Gelöschte Datensätze wiederherstellen 25-9Die Datensatztypen für die Datenmenge festlegen 25-10Aktualisierungsstatus prüfen .25-11Update-Objekte 25-12Die Eigenschaft UpdateObject einer

Datenmenge 25-12Ein einzelnes Update-Objekt verwenden 25-13

Mehrere Update-Objekte verwenden 25-13SQL-Anweisungen für Update-Komponenten erstellen 25-14SQL-Anweisungen zur Entwurfszeit erstellen 25-15Parameterersetzung in SQL-

Anweisungen 25-16SQL-Anweisungen schreiben 25-17Die Eigenschaft Query einer Update-Komponente 25-18Die Eigenschaften DeleteSQL, InsertSQL und ModifySQL 25-19Update-Anweisungen ausführen 25-20Die Methode Apply 25-20Die Methode SetParams 25-21Die Methode ExecSQL 25-21

Den Aktualisierungsvorgang steuern 25-24

Wann muß der Aktualisierungsprozeß

überwacht werden? 25-24

Eine Ereignisbehandlungsroutine für

OnUpdateRecord erzeugen 25-25

Fehlerbehandlung 25-26

Referenz auf die betroffene Datenmenge 25-27

Feststellen, wie der aktuelle Datensatz

geändert wurde 25-27

Die durchzuführende Aktion festlegen 25-28

Eine Fehlermeldung definieren 25-29

Die Feldeigenschaften OldValue, NewValue

und CurValue 25-29

Kapitel 26

Datensensitive Steuerelemente 26-1

Datensensitive Steuerelemente im Überblick 26-1

Datensensitive Steuerelemente einer

Datenmenge zuordnen 26-3

Daten bearbeiten und aktualisieren 26-3

Den Bearbeitungsmodus aktivieren 26-3

Daten in einem Steuerelement bearbeiten26-4

Die Datenanzeige aktivieren und

Eigenschaft DataSet einstellen 26-7

Eigenschaft Name einstellen 26-7

Eigenschaft Enabled einstellen 26-8

Eigenschaft AutoEdit einstellen 26-8

TDataSource-Ereignisse verwenden 26-8

Ereignis OnDataChange verwenden 26-8

Ereignis OnUpdateData verwenden 26-9

Ereignis OnStateChange verwenden 26-9

Steuerelemente zur Darstellung eines einzelnen

Feldes 26-10

Felder als Beschriftung anzeigen 26-10

Feldinhalte in Eingabefeldern anzeigen und

bearbeiten 26-10

Textfelder in einem Memo-Steuerelement

anzeigen und bearbeiten 26-11

Text in einem RTF-Eingabefeld anzeigen und

bearbeiten 26-12

Grafikfelder in einem Bild-Steuerelement anzeigen und bearbeiten 26-12Daten in Listen- und Kombinationsfeldern anzeigen und bearbeiten 26-13Daten in Listenfeldern anzeigen und bearbeiten 26-13Daten in Kombinationsfeldern anzeigen und bearbeiten 26-14Daten in Lookup-Listen und -

Kombinationsfeldern anzeigen und bearbeiten 26-15Listen, die auf Lookup-Feldern basieren26-15Listen, die auf einer sekundären Datenquelle basieren 26-16Eigenschaften von Lookup-Listen und Lookup-Kombinationsfeldern 26-17Inkrementelle Suche in Listen 26-17Boolesche Feldwerte und Kontrollfelder 26-18Feldwerte mit Optionsfeldern

einschränken 26-19Daten mit TDBGrid anzeigen und bearbeiten 26-20Gitter im Standardstatus verwenden 26-21Angepaßte Gitter erstellen 26-21Persistente Spalten – Grundlagen 26-22Quelle einer Spalteneigenschaft zur Laufzeit festlegen 26-23Persistente Spalten erstellen 26-23Persistente Spalten löschen 26-24Reihenfolge persistenter Spalten ändern26-24Lookup-Spalte definieren 26-25Auswahllistenspalte definieren 26-25Schaltfläche in Spalte einfügen 26-25Spalteneigenschaften beim Entwurf

einstellen 26-26Standardwerte einer Spalte

wiederherstellen 26-27ADT- und Array-Felder anzeigen 26-27Gitteroptionen einstellen 26-29Daten im Gitter bearbeiten 26-30Spaltenreihenfolge beim Entwurf ändern 26-31Spaltenreihenfolge zur Laufzeit ändern 26-31Gitterdarstellung steuern 26-31Zur Laufzeit auf Benutzeraktionen

reagieren 26-32Gitter mit anderen datensensitiven

Steuerelementen erstellen 26-33Navigation und Bearbeitung von

Datenmengen 26-34

Navigator-Schaltflächen ein- und

ausblenden 26-35

Navigator-Schaltflächen zur Entwurfszeit

ein- und ausblenden 26-35

Navigator-Schaltflächen zur Laufzeit ein-

Entscheidungsdatenmengen mit TQuery

oder TTable erzeugen 27-6

Entscheidungsdatenmengen mit dem

Entscheidungsabfragen-Editor erzeugen 27-6

Der Editor für Entscheidungsabfragen 27-6

Eigenschaften von TDecisionQuery 27-7

Mit Entscheidungswürfeln arbeiten 27-8

Eigenschaften und Ereignisse 27-8

Der Editor für den Entscheidungswürfel 27-8

Dimensionseinstellungen anzeigen und

Mit Entscheidungsquellen arbeiten 27-10

Eigenschaften und Ereignisse 27-10

Mit Entscheidungspivots arbeiten 27-11

Eigenschaften von Entscheidungspivots 27-11

Entscheidungsgitter erstellen und verwenden 27-12

Entscheidungsgitter erstellen 27-12

Mit Entscheidungsgittern arbeiten 27-12

Felder im Entscheidungsgitter öffnen und

Eigenschaften von Entscheidungsgittern 27-14

Entscheidungsgraphen erstellen und verwenden 27-15Entscheidungsgraphen erstellen 27-15Mit Entscheidungsgraphen arbeiten 27-15Der Informationsgehalt von Entscheidungs-graphen 27-17Entscheidungsgraphen gestalten 27-17Standardwerte für Entscheidungsgraphen als Schablonen 27-18Reihen in Entscheidungsgraphen

gestalten 27-19Entscheidungskomponenten zur Laufzeit 27-20Entscheidungspivots zur Laufzeit 27-20Entscheidungsgitter zur Laufzeit 27-21Entscheidungsgraphen zur Laufzeit 27-21Entscheidungskomponenten und Speicher-verwaltung 27-22Maximalwerte für Dimensionen,

Zusammenfassungen und Zellen 27-22Den Status der Dimensionen einstellen 27-22Permanent ausgelagerte Dimensionen 27-23

aufrufen 28-4CORBA-Server schreiben 28-5CORBA-Experten 28-5Objektschnittstellen definieren 28-6Automatisch generierter Code 28-8Server-Schnittstellen registrieren 28-9Schnittstellen bei der Schnittstellenablage registrieren 28-9Schnittstellen beim Object Activation Daemon registrieren 28-11CORBA-Clients schreiben 28-13Stubs verwenden 28-13Die dynamische Aufrufschnittstelle

verwenden 28-14Schnittstelle abrufen 28-15Schnittstellen mit der DII aufrufen 28-15CORBA-Anwendungen anpassen 28-17

Smart Agents konfigurieren 28-19

Einen Smart Agent starten 28-20

Terminologie und Standards 29-1

Bestandteile einer URL 29-2

URI und URL 29-3

Informationen in den Headern von

Arten von Web-Server-Anwendungen 29-6

ISAPI und NSAPI 29-6

Ein Standard-Aktionselement festlegen 29-13

Mit Aktionselementen auf

Anforderungsbotschaften antworten 29-13

Die Antwort senden 29-14

Mehrere Aktionselemente verwenden 29-14

Auf Client-Anforderungsinformationen zugreifen 29-14Eigenschaften, die Header-Informationen zur Anforderung enthalten 29-15Eigenschaften, die das Ziel bezeichnen 29-15Eigenschaften, die den Web-Client

beschreiben 29-15Eigenschaften, die auf den Zweck der Anforderung hinweisen 29-16Eigenschaften, die die erwartete Antwort beschreiben 29-16Eigenschaften, die den Inhalt

beschreiben 29-16Der Inhalt von HTTP-Anforderungs-

botschaften 29-17HTTP-Anwortbotschaften erzeugen 29-17Den Antwort-Header füllen 29-17Den Antwortstatus anzeigen 29-18Auf eine erforderliche Client-Aktion hinweisen 29-18Die Server-Anwendung beschreiben 29-18Den Inhalt beschreiben 29-19Den Antwortinhalt festlegen 29-19Die Antwort senden 29-19Den Inhalt von Antwortbotschaften

generieren 29-20Seitengeneratoren einsetzen 29-20HTML-Vorlagen 29-20Vordefinierte HTML-transparente Tag-Namen verwenden 29-21Die HTML-Vorlage definieren 29-22HTML-transparente Tags konvertieren 29-22Seitengeneratoren und Aktions-

elemente 29-22Seitengeneratoren verketten 29-23Datenbankinformationen in Antworten

integrieren 29-24Eine Sitzung zum Web-Modul hinzufügen 29-25Datenbankinformationen in HTML

darstellen 29-25Datenmengen-Seitengeneratoren

verwenden 29-25Tabellengeneratoren verwenden 29-26Die Tabellenattribute festlegen 29-26Die Zeilenattribute festlegen 29-27Die Spalten festlegen 29-27Tabellen in HTML-Dokumente

einbetten 29-27

ISAPI- und NSAPI-Anwendungen testen 29-29

Unter Windows NT testen 29-29

Mit einem Microsoft IIS-Server testen 29-29

Unter MTS testen 29-30

Mit einem Windows 95 Personal-Web-Server

testen 29-31

Mit Netscape Server 2.0 testen 29-32

CGI- und Win-CGI-Anwendungen testen 29-33

Den Server simulieren 29-33

Als DLL testen 29-33

Kapitel 30

Dienste implementieren 30-1

Was sind Dienstprotokolle? 30-2

Mit Anwendungen kommunizieren 30-2

Dienste und Schnittstellen 30-2

Typen von Socket-Verbindungen 30-3

Client-Verbindungen 30-3

Empfangende Verbindungen 30-3

Server-Verbindungen 30-3

Die Sockets beschreiben 30-4

Den Host beschreiben 30-4

Zwischen einem Host-Namen und einer

IP-Adresse wählen 30-5

Schnittstellen verwenden 30-5

Socket-Komponenten 30-6

Client-Sockets 30-6

Den gewünschten Server angeben 30-6

Die Verbindung aufbauen 30-7

Informationen über die Verbindung

Verbindungen zu Clients aufbauen 30-8

Informationen über Verbindungen

ermitteln 30-8

Die Server-Verbindung beenden 30-9

Auf Socket-Ereignisse antworten 30-9

Teil IV

Benutzerdefinierte Komponenten erzeugen

Komponente 31-13Die Komponente registrieren 31-13Komponenten vor der Installation testen 31-14

Kapitel 32

Objektorientierte Programmierung für

Neue Klassen definieren 32-2

Neue Klassen ableiten 32-2

Ändern der Voreinstellungen einer Klasse

zur Vermeidung von Wiederholung 32-2

Einer Klasse neue Fähigkeiten

hinzufügen 32-3

Eine neue Komponentenklasse deklarieren 32-3

Vorfahren, Nachkommen und

Die Laufzeit-Schnittstelle definieren 32-7

Die Entwurfszeit-Schnittstelle definieren 32-7

Wozu dienen Eigenschaften? 33-1

Typen von Eigenschaften 33-2

Geerbte Eigenschaften als published

Die Methode read 33-7

Die Methode write 33-7

Standardwerte für Eigenschaften 33-8

Keinen Standardwert angeben 33-8

Array-Eigenschaften erstellen 33-9

Eigenschaften speichern und laden 33-10

Der Speicher- und Lademechanismus 33-10

Standardwerte festlegen 33-11

Was soll gespeichert werden? 33-12

Initialisieren nach dem Laden 33-12

Nicht als published deklarierte Eigenschaften speichern und laden 33-13Methoden zum Speichern und Laden von Eigenschaftswerten erstellen 33-13Die Methode DefineProperties

Prozeduren 34-3Ereignisbehandlungsroutinen sind optional 34-4Die Standardereignisse implementieren 34-5Standardereignisse identifizieren 34-5Standardereignisse für alle

Steuerelemente 34-5Standardereignisse für Standard-

Steuerelemente 34-6Ereignisse sichtbar machen 34-6Die Standard-Ereignisbehandlung ändern 34-6Eigene Ereignisse definieren 34-7Ereignisse auslösen 34-7Zwei Arten von Ereignissen 34-8Den Typ der Behandlungsroutine definieren34-8Einfache Benachrichtigungen 34-8Ereignisspezifische Behandlungs-

routinen 34-8Informationen von der Behandlungsroutine zurückliefern 34-9Ereignisse deklarieren 34-9Ereignisnamen beginnen mit »On« 34-9Ereignisse aufrufen 34-9

Kapitel 35

Abhängigkeiten vermeiden 35-1Methoden benennen 35-2Methoden schützen 35-3Methoden, die als public deklariert sein sollten 35-3Methoden, die als protected deklariert sein sollten 35-3Abstrakte Methoden 35-4Methoden virtuell machen 35-4Methoden deklarieren 35-4

Mit Bildern arbeiten 36-3

Mit einem Bild, einer Grafik oder einer

Den Botschaftsfluß verfolgen 37-3

Die Behandlung von Botschaften ändern 37-3

Die Behandlungsmethode überschreiben 37-4

Botschaftsparameter verwenden 37-4

Botschaften abfangen 37-4

Neue Routinen zur Botschaftsbehandlung

erstellen 37-5

Eigene Botschaften definieren 37-5

Einen Botschaftsbezeichner deklarieren 37-6

Einen Botschafts-Record-Typ deklarieren 37-6

Eine neue Botschaftsbehandlungsmethode

Die Register-Prozedur deklarieren 38-2

Die Prozedur Register implementieren 38-2

Die Komponenten angeben 38-3

Die Palettenseite angeben 38-3

Die Prozedur RegisterComponents

aufrufen 38-3

Paletten-Bitmaps hinzufügen 38-4

Hilfe für Komponenten bereitstellen 38-4

Die Hilfedatei erstellen 38-4

Einträge erstellen 38-5

Kontextsensitive Hilfe erstellen 38-6Hilfedateien für Komponenten

hinzufügen 38-7Eigenschaftseditoren hinzufügen 38-7Ableiten einer Eigenschaftseditor-Klasse 38-7Die Eigenschaft als Text bearbeiten 38-8Den Eigenschaftswert anzeigen 38-9Den Eigenschaftswert angeben 38-9Die Eigenschaft als Einheit bearbeiten 38-10Editorattribute festlegen 38-11Den Eigenschaftseditor registrieren 38-12Komponenteneditoren hinzufügen 38-13Einträge in das lokale Menü einfügen 38-13Menüeinträge angeben 38-14Befehle implementieren 38-14Das Doppelklickverhalten ändern 38-15Zwischenablageformate hinzufügen 38-15Den Komponenteneditor registrieren 38-16Eigenschaftskategorien 38-16Eine Eigenschaft registrieren 38-17Mehrere Eigenschaften gleichzeitig

registrieren 38-18Eigenschaftskategorieklassen 38-18Integrierte Eigenschaftskategorien 38-18Neue Eigenschaftskategorien ableiten 38-19Die Funktion IsPropertyInCategory 38-20Komponenten in Packages compilieren 38-20Fehlerbeseitigung für benutzerdefinierte

Kapitel 40

Grafische Komponenten erzeugen 40-1

Die Komponente erzeugen und registrieren 40-1Geerbte Eigenschaften als published

deklarieren 40-2Grafische Funktionen hinzufügen 40-3Was soll gezeichnet werden? 40-3Den Eigenschaftstyp deklarieren 40-3Die Eigenschaft deklarieren 40-4

Stift und Pinsel als published deklarieren 40-5

Die Klassenfelder deklarieren 40-6

Die Zugriffseigenschaften deklarieren 40-6

Untergeordnete Klassen initialisieren 40-7

Eigenschaften untergeordneter Klassen

Die Komponente erzeugen und registrieren 41-1

Geerbte Eigenschaften als published

deklarieren 41-2

Die Initialisierungswerte ändern 41-3

Die Größe der Zellen ändern 41-4

Die Zellen füllen 41-5

Das Datum festlegen 41-5

Das interne Datum speichern 41-6

Auf den Tag, den Monat und das Jahr

zugreifen 41-6

Die Anzahl der Tage im Monat

generieren 41-8

Den aktuellen Tag auswählen 41-10

Durch Monate und Jahre navigieren 41-10

Durch die Tage navigieren 41-11

Die Markierung bewegen 41-11

Das Ereignis OnChange hinzufügen 41-12

Bewegung zu leeren Zellen verhindern 41-13

Kapitel 42

Datensensitive Steuerelemente

Ein Steuerelement zur Datensuche erzeugen 42-2

Die Komponente erstellen und registrieren 42-2

Den Kalender als Nur-Lesen-Steuerelement

definieren 42-3

Die Eigenschaft ReadOnly hinzufügen 42-3

Erforderliche Aktualisierungen zulassen 42-4

Die Datenverknüpfung hinzufügen 42-5

Das Klassenfeld deklarieren 42-5

Die Zugriffseigenschaften deklarieren 42-5

Beispiel für die Deklaration von

Zugriffseigenschaften 42-6

Die Datenverknüpfung initialisieren 42-6Auf Datenänderungen antworten 42-7Ein Bearbeitungselement erstellen 42-8Den Standardwert von FReadOnly ändern 42-9Maustasten- und Tastendruckbotschaften behandeln 42-9Auf Maustastenbotschaften antworten 42-9Auf Tastendruckbotschaften antworten 42-10Die Datenverknüpfungsklasse des Feldes aktualisieren 42-11Die Methode Change ändern 42-12Die Datenmenge aktualisieren 42-12

Kapitel 43

Die Komponentenschnittstelle definieren 43-2Die Komponente erstellen und registrieren 43-2Die Komponentenschnittstelle erstellen 43-3Die Unit des Formulars einfügen 43-3Die Schnittstelleneigenschaften hinzufügen 43-3Die Methode Execute hinzufügen 43-5Die Komponente testen 43-6

(Marshaling) 44-8COM-Clients 44-9COM-Erweiterungen 44-9Automatisierungsserver und -Controller 44-12ActiveX-Steuerelemente 44-13Typbibliotheken 44-13

Der Inhalt der Typbibliotheken 44-14

Erzeugen von Typbibliotheken 44-14

Wann werden Typbibliotheken

eingesetzt? 44-15

Zugriff auf Typbibliotheken 44-15

Die Vorteile von Typbibliotheken 44-16

Tools für Typbibliotheken 44-16

Active-Server-Seiten 44-17

Active-Dokumente 44-17

Visuelle prozeßübergreifende Objekte 44-18

Implementieren von COM-Objekten mit Hilfe der

Experten 44-18

Kapitel 45

Ein einfaches COM-Objekt erstellen 45-1

Das Erstellen eines COM-Objekts im Überblick 45-1

Ein COM-Objekt entwerfen 45-2

Ein COM-Objekt mit dem COM-Objekt-Experten

entwerfen 45-2

Instantiierungstypen für COM-Objekte 45-3

Ein Threading-Modell auswählen 45-3

Ein Objekt schreiben, das das freie

Threading-Modell unterstützt 45-5

Ein Objekt schreiben, das das

Apartment-Threading-Modell unterstützt 45-6

Ein COM-Objekt registrieren 45-6

Ein COM-Objekt testen 45-7

Kapitel 46

Automatisierungs-Controller

Einen Automatisierungs-Controller durch

Importieren einer Typbibliothek erzeugen 46-2

Ereignisse in einem

Kapitel 47

Automatisierungsserver erstellen 47-1

Automatisierungsobjekte für eine Anwendung erstellen 47-1Ereignisse in Ihrem Automatisierungsobjekt verwalten 47-3Eigenschaften, Methoden und Ereignisse einer Anwendung für die Automatisierung bereitstellen 47-3Eine Eigenschaft für die Automatisierung bereitstellen 47-3Eine Methode für die Automatisierung

bereitstellen 47-4Ein Ereignis für die Automatisierung

bereitstellen 47-5Weitere Informationen 47-6Eine Anwendung als Automatisierungsserver registrieren 47-6Einen In-Process-Server registrieren 47-6Einen Out-of-Process-Server registrieren 47-6Die Anwendung testen und Fehler entfernen 47-7Automatisierungsschnittstellen 47-7Duale Schnittstellen 47-7Dispatch-Schnittstellen 47-8Benutzerdefinierte Schnittstellen 47-9Sequenzbildung für Daten (Marshaling) 47-10Automatisierungskompatible Typen 47-10Typeinschränkungen bei der automatischen Sequenzbildung 47-11Benutzerdefinierte Sequenzbildung 47-11

Kapitel 48

ActiveX-Steuerelemente erstellen 48-1

ActiveX-Steuerelemente erzeugen – Übersicht 48-1Elemente eines ActiveX-Steuerelements 48-2VCL-Steuerelement 48-2Typbibliothek 48-3Eigenschaften, Methoden und Ereignisse 48-3Eigenschaftenseite 48-3Ein ActiveX-Steuerelement entwerfen 48-3ActiveX-Steuerelemente aus VCL-Steuerelementen erstellen 48-4ActiveX-Steuerelemente lizensieren 48-7

So fügt Delphi Eigenschaften hinzu 48-11

So fügt Delphi Methoden hinzu 48-12

So fügt Delphi Ereignisse hinzu 48-12

Einfache Datenbindung mit der Typbibliothek

Eine neue Eigenschaftenseite erstellen 48-16

Steuerelemente zu einer Eigenschaftenseite

hinzufügen 48-17

Steuerelemente auf Eigenschaftenseiten mit

Eigenschaften von ActiveX-Steuerelementen

verbinden 48-17

Die Eigenschaftenseite aktualisieren 48-17

Das Objekt aktualisieren 48-18

Eine Eigenschaftenseite mit einem

Die Registerkarte Projekt 48-24

Die Registerkarte Packages 48-25

Von diesem Projekt verwendete

Packages 48-25

CAB-Optionen 48-25

VersionsInfo 48-25

Optionen für Verzeichnis und URL 48-25

Die Registerkarte Zusätzliche Dateien 48-26

Mit dem Projekt verbundene Dateien 48-26

CAB-Optionen 48-26

VersionsInfo 48-26

Optionen für Verzeichnis und URL 48-26

Kapitel 49

Eine Active-Server-Seite erstellen 49-1

Ein ASP-Objekt erstellen 49-2ASP-Objekte für In-Process- oder Out-of-Process-Server erstellen 49-3Eine Anwendung als ASP-Objekt registrieren 49-4Einen In-Process-Server registrieren 49-4Einen Out-of-Process-Server registrieren 49-4Die ASP-Anwendung testen 49-5

Kapitel 50

Der Typbibliothekseditor 50-3Die Werkzeugleiste 50-4Die Objektliste 50-5Die Statusleiste 50-6Registerkarten mit Typinformationen 50-6Die Registerkarte Attribute 50-6Die Registerkarte Text 50-7Die Registerkarte Flags 50-7Typbibliotheksinformationen 50-8Die Registerkarte Attribute für

Typbibliotheken 50-8Die Registerkarte Verwendet für

Typbibliotheken 50-9Die Registerkarte Flags für Typbibliotheken 50-9Schnittstelleninformationen 50-9Die Registerkarte Attribute für

Schnittstellen 50-9Die Registerkarte Flags für Schnittstellen 50-10Schnittstellenelemente 50-10Schnittstellenmethoden 50-11Schnittstelleneigenschaften 50-12Die Registerkarte Parameter für

Eigenschaften und Methoden 50-13Dispatch-Typinformationen 50-15Die Registerkarte Attribute für Dispatch-Schnittstellen 50-16Die Registerkarte Flags für Dispatch-

Schnittstellen 50-16Dispatch-Elemente 50-16CoClass-Typinformationen 50-17Die Registerkarte Attribute für CoClass-Objekte 50-17Die Registerkarte Implementierung für CoClass-Objekte 50-18Die Registerkarte Flags für CoClass-

Objekte 50-18Enumeration-Typinformationen 50-19

Eine neue Typbibliothek erstellen 50-33

Eine vorhandene Typbibliothek öffnen 50-33

Eine Schnittstelle hinzufügen 50-34

Eigenschaften und Methoden einer Schnittstelle

oder Dispatch-Schnittstelle hinzufügen 50-34

Ein CoClass-Objekt hinzufügen 50-35

Eine Aufzählung zur Typbibliothek

Eine Typbibliothek speichern 50-37

Eine Typbibliothek aktualisieren 50-37

Eine Typbibliothek registrieren 50-38

Eine IDL-Datei exportieren 50-38

Transaktionsattribut 51-9Statusbehaftete und statuslose Objekte 51-10Aktivieren multipler Objekte zum Unterstützen von Transaktionen 51-10MTS- oder client-gesteuerte Transaktionen.51-11Vorteile von Transaktionen 51-12Zeitüberschreitung bei Transaktionen 51-12Rollenbasierte Sicherheit 51-13Ressourcenspender 51-13BDE-Ressourcenspender 51-14Shared Property Manager 51-14Tips für die Verwendung des Shared Property Managers 51-15Basis-Clients und MTS-Komponenten 51-16Zugrundeliegende Technologien von MTS, COM und DCOM 51-17Übersicht über die Erstellung von MTS-

Objekten 51-17Den MTS-Objektexperten verwenden 51-17Auswahl eines Threading-Modells für ein MTS-Objekt 51-18MTS-Aktivitäten 51-19Setzen des Transaktionsattributs 51-20Objektreferenzen übergeben 51-21Die Methode SafeRef verwenden 51-21Callbacks 51-22Ein Transaktionsobjekt auf der Client-Seite einrichten 51-22Ein Transaktionsobjekt auf der Server-Seite einrichten 51-23Fehlersuche und Testen von MTS-Objekten 51-24

MTS-Objekte in einem MTS-Package

installieren 51-24MTS-Objekte mit dem MTS-Explorer

verwalten 51-25Die MTS-Dokumentation 51-26

Index

E i n f ü h r u n g 1-1

K a p i t e l

1

Kapitel 1Einführung

Das Entwicklerhandbuch enthält Informationen über mittelschwere und

fortgeschritte-ne Programmierthemen Dazu gehört das Erstellen von wendungen, das Entwickeln von benutzerdefinierten Komponenten, das Erstellen von Web-Server-Anwendungen und das Bereitstellen der Unterstützung von Stan-dardspezifikationen wie CORBA,TCP/IP, MTS, COM und ActiveX Die Arbeit mit diesem Handbuch setzt voraus, daß Sie mit der Entwicklungsumgebung von Delphi und den elementaren Programmiertechniken vertraut sind Eine Einführung in die Programmierung mit Delphi und einen Überblick über die IDE finden Sie in der On-line-Hilfe

Client/Server-Datenbankan-Inhalt dieses Handbuchs

Dieses Handbuch besteht aus folgenden Teilen:

• Teil I, »Programmieren mit Delphi«, enthält Informationen darüber, wie Sie mit

Delphi allgemeine Anwendungen erstellen können Sie finden hier Einzelheiten über Programmiertechniken, die in jeder Delphi-Anwendung zum Einsatz kom-men So wird beispielsweise beschrieben, wie mit Hilfe der allgemeinen VCL-Ob-jekte das Erstellen einer Benutzeroberfläche vereinfacht werden kann (z.B String-Behandlung, Textbearbeitung, Standard-Dialogfelder, ToolBar- und CoolBar-Komponenten) Dieser Teil enthält auch Kapitel über die Arbeit mit Grafiken, über Fehler- und Ereignisbehandlung, DLLs, OLE-Automatisierung und das Schreiben mehrsprachiger Anwendungen

Im Kapitel über das Weitergeben von Anwendungen wird beschrieben, wie Sie

Ih-re Anwendungen an den Endbenutzer weitergeben können Es enthält weise Informationen über Compiler-Optionen, InstallShield Express, die Lizenzie-rung und das Bestimmen der für die Anwendung benötigten Packages, DLLs und sonstigen Bibliotheken

beispiels-• Teil II, »Datenbankanwendungen entwickeln«, enthält Informationen, wie mit

Hilfe der Datenbank-Tools und -komponenten professionelle

Datenbankanwen-1-2 E n t w i c k l e r h a n d b u c h

I n h a l t d i e s e s H a n d b u c h s

dungen erstellt werden In Delphi können Sie auf viele verschiedene systeme zugreifen In Ihren Formularen und Reports können Sie lokale Datenban-ken wie Paradox und dBASE, SQL-Server wie InterBase und Sybase und jede mit einem ODBC-Treiber ausgestattete Datenquelle für den Datenzugriff verwenden Wenn Sie fortgeschrittene Client/Server-Datenbankanwendungen erstellen wol-len, benötigen Sie die Client/Server- oder Enterprise-Edition von Delphi

Datenbank-• Teil III, »Verteilte Anwendungen entwickeln«, beschreibt, wie Sie

Anwendun-gen entwickeln, die über ein lokales Netzwerk verteilt werden Dazu gehören CORBA- und Web-Server-Anwendungen (z.B CGI-Anwendungen und NSAPI- und ISAPI-DLLs) Außerdem erfahren Sie hier, wie Sie mit Socket-Komponenten arbeiten, die sich bei TCP/IP und ähnlichen Protokollen um die Details der Kom-munikation kümmern Die Komponenten, die CORBA- und Web-Server-Anwen-dungen unterstützen, sind in den Client/Server- und Enterprise-Editionen von Delphi verfügbar Die Socket-Komponenten sind auch in der Professional-Edition enthalten

• Teil IV, »Benutzerdefinierte Komponenten erzeugen«, enthält Informationen, wie

Sie Ihre eigenen Komponenten entwerfen, implementieren und anschließend in der Komponentenpalette installieren können Als Komponente kann fast jedes Programmelement verwendet werden, das zur Laufzeit bearbeitet werden soll Beim Implementieren einer benutzerdefinierten Komponente wird eine neue Klas-

se von einem bereits in der VCL vorhandenen Typ abgeleitet

• Teil V, »COM-Anwendungen entwickeln«, enthält Informationen, wie

Anwen-dungen erstellt werden können, die mit anderen COM-basierten API-Objekten wie beispielsweise Win95-Shell-Erweiterungen oder Multimedia-Anwendungen interagieren Delphi stellt Komponenten zur Verfügung, die die COM-basierte ActiveX-Bibliothek für COM-Steuerelemente unterstützen Diese Steuerelemente können für allgemeine Anwendungen und für Web-Anwendungen verwendet werden Außerdem erfahren Sie hier, wie Server erstellt werden, die in der MTS-Laufzeitumgebung ausgeführt werden können MTS bietet erweiterte Laufzeitun-terstützung für Sicherheits- und Transaktionsfunktionen und für Ressourcen-Poo-ling

Die COM-Unterstützung ist in allen Editionen von Delphi verfügbar Wenn Sie ActiveX-Steuerelemente erstellen wollen, benötigen Sie die Professional-, Client/Server- oder Enterprise-Edition Um MTS-Server zu erstellen, benötigen Sie die Client/Server- oder die Enterprise-Edition

Inprise Developer Support Services

Um den Bedürfnissen der Delphi-Entwickler zu entsprechen, bietet Inprise eine Reihe zusätzlicher Service-Leistungen an Informationen über diese Leistungen finden Sie unter

Mehr Informationen erhalten Sie von unserem Kundendienst unter 0130 82 08 66

Schreibmaschinenschrift Text in Schreibmaschinenschrift steht für Delphi Quelltext oder für

Text, wie er auf dem Bildschirm erscheint Weiterhin kann es sich um Text handeln, den Sie in dieser Form eingeben müssen.

[ ] Eckige Klammern im Text oder in Syntax-Listings kennzeichnen optionale Elemente Bei der Eingabe dieser Elemente sind die Klam- mern wegzulassen.

Fettschrift Fettschrift kennzeichnet reservierte Schlüsselwörter von Delphi oder

Compiler-Optionen.

Variablen, Komponenten, Ereignisse, Methoden und Eigenschaften Kursivschrift dient auch zur Hervorhebung bestimmter Wörter, etwa neuer Begriffe.

Tasten Diese Schriftart bezeichnet eine Taste Beispiel: "Drücken Sie Esc, um das Menü zu verlassen."

P r o g r a m m i e r e n m i t D e l p h i

T e i l

I

Teil IProgrammieren mit Delphi

Die Kapitel im ersten Teil dieses Handbuchs beschreiben die grundlegenden

Konzepte der Anwendungsentwicklung mit einer beliebigen Delphi-Edition

Verschiedentlich werden auch die Konzepte angesprochen, die in den nachfolgenden Teilen dieses Handbuchs ausführlich erörtert werden

-2 O b j e c t P a s c a l L a n g u a g e G u i d e

Komponentenbiblio-Object Pascal und die VCL

Object Pascal, die Programmiersprache von Delphi, erweitert Standard-Pascal um objektorientierte Programmiertechniken Die VCL (Visual Component Library = Bi-bliothek visueller Komponenten) ist eine Hierarchie von Object-Pascal-Objekten Sie ist in die Delphi-IDE integriert und ermöglicht so das rasche Erstellen von Anwen-dungen Die Objekte können aus der Komponentenpalette in ein Formular eingefügt werden Ihre Eigenschaften und Ereignisse können dann mit Hilfe des Objektinspek-tors bearbeitet werden, ohne daß auch nur eine Zeile Quelltext geschrieben werden muß

Sämtliche VCL-Objekte sind von TObject abgeleitet Die Methoden dieser abstrakten

Klasse kapseln Grundfunktionen wie Erstellen, Freigeben und

Botschaftsbehand-lung TObject ist der direkte Vorfahr vieler einfacher Klassen.

Die Komponenten in der VCL sind von der abstrakten Klasse TComponent abgeleitet

Es handelt sich dabei um Objekte, die während des Entwurfs in Formularen plaziert und bearbeitet werden können Die visuellen Komponenten, die zur Laufzeit auf

dem Bildschirm zu sehen sind (z B TForm und TSpeedButton), heißen

Steuerelemen-te Sie sind von TControl abgeleitet.

Trotz ihres Namens besteht die VCL hauptsächlich aus nichtvisuellen Objekten

Eini-ge dieser Komponenten können ebenfalls aus der Palette in AnwendunEini-gen einEini-gefügt

werden So kann beispielsweise durch Plazieren einer TDataSource-Komponente in

einem Formular oder Datenmodul eine Verbindung mit einer Datenbank hergestellt werden Das Objekt wird dann im Dokument durch ein Symbol dargestellt, das zur

2-2 E n t w i c k l e r h a n d b u c h

D a s O b j e k t m o d e l l

Laufzeit nicht angezeigt wird Seine Eigenschaften und Ereignisse können wie bei nem visuellen Steuerelement mit Hilfe des Objektinspektors bearbeitet werden

ei-Wenn Sie in Object Pascal eigene Klassen erstellen, sollten Sie diese von TObject (oder

einem Nachfahr) ableiten Auf diese Weise ist sichergestellt, daß die neue Klasse über die wesentlichen Grundfunktionen verfügt und reibungslos mit der VCL zusammen-arbeitet

Das Objektmodell

Die Objektorientierung ist eine Erweiterung der strukturierten Programmierung Sie ermöglicht das einfache Wiederverwenden von Quelltext und kapselt Daten mit der entsprechenden Funktionalität Nachdem Sie ein Objekt (genauer: eine Klasse) er-stellt haben, wird es jederzeit in anderen Anwendungen verwendet werden Auf die-

se Weise wird die Entwicklungszeit verkürzt und die Produktivität erhöht

Wie Sie neue Komponenten erstellen und in die Komponentenpalette aufnehmen können wird in Kapitel 31, »Die Komponentenentwicklung im Überblick,«, beschrie-ben

Was ist ein Objekt?

Ein Objekt (eine Klasse) ist ein Datentyp, in dem Daten und die Datenoperationen zusammengefaßt sind Vor der Einführung der objektorientierten Programmierung wurden diese Elemente getrennt definiert

Das Verständnis von Objekten in Object Pascal wird erleichtert, wenn Sie sich genwärtigen, was ein Record ist Records (in C Strukturen) bestehen aus Feldern mit Daten Dabei kann jedes Feld einen anderen Datentyp haben Deshalb kann mit Hilfe von Records auf unterschiedliche Datenelemente zugegriffen werden

verge-Objekte sind ebenfalls Sammlungen von Datenelementen Sie enthalten aber lich Prozeduren und Funktionen zum Bearbeiten der Daten Diese Routinen heißen Methoden

zusätz-Auf die verschiedenen Datenelemente eines Objekts kann mit Hilfe seiner schaften zugegriffen werden Deren Werte können während des Entwurfs jederzeit visuell geändert werden Um sie zur Laufzeit zu ändern, müssen Sie entsprechenden Quelltext schreiben

Eigen-Das Zusammenfassen von Daten und Quelltext nennt man Kapselung Die beiden anderen Merkmale der objektorientierten Programmierung sind Vererbung und Po-lymorphie Vererbung bedeutet, daß Objekte ihre Funktionalität von anderen Objek-ten (ihren Vorfahren) erben Das geerbte Verhalten kann aber jederzeit geändert wer-den Polymorphie heißt, daß von demselben Vorfahr abgeleitete Objekte dieselben Methoden- und Eigenschaftsschnittstellen unterstützen, die oftmals austauschbar aufgerufen werden können

O b j e c t P a s c a l m i t d e r V C L v e r w e n d e n 2-3

D a s O b j e k t m o d e l l

Ein Delphi-Objekt untersuchen

Wenn Sie ein neues Projekt erstellen, wird automatisch ein neues Formular geöffnet, das Sie als Ausgangspunkt für die Anwendung verwenden können Im Quelltextedi-tor wird ein neuer Klassentyp für das Formular deklariert und Code eingefügt, um die Formularinstanz zu erzeugen Das folgende Beispiel zeigt den automatisch gene-rierten Quelltext:

end.{ Ende des Implementierungsabschnitts und der Unit}

Der neue Klassentyp TForm1 ist von der Klasse TForm abgeleitet.

Eine Klasse entspricht darin einem Record, daß beide Datenfelder enthalten Eine Klasse verfügt aber zusätzlich über Methoden (Quelltext), um die Daten zu bearbei-

ten TForm1 enthält bisher keine Felder oder Methoden, weil Sie noch keine

Kompo-nenten (die Felder des neuen Objekts) hinzugefügt oder nen (die Methoden des neuen Objekts) erstellt haben Es sind aber dennoch Felder und Methoden vorhanden, auch wenn sie nicht in der Typdeklaration aufgeführt sind

Ereignisbehandlungsrouti-In der folgenden Anweisung wird die Variable Form1 des neuen Typs TForm1

dekla-riert:

var

Form1: TForm1;

Form1 ist eine Instanz oder ein Objekt des Klassentyps TForm1 Es können auch

meh-rere Instanzen eines Typs deklariert werden, beispielsweise für die untergeordneten Fenster einer MDI-Anwendung (Multiple Document Interface) Jede Instanz verfügt dabei über eigene Datenfelder, die Methoden werden jedoch gemeinsam verwendet.Obwohl Sie bis jetzt noch keine Komponente in das Formular eingefügt und noch keine einzige Zeile Quelltext geschrieben haben, ist bereits ein vollständiges Delphi-Programm entstanden, das Sie kompilieren und starten können Es zeigt aber ledig-lich ein leeres Formular an

Wir werden daher eine Schaltfläche hinzufügen und eine Behandlungsroutine für

das Ereignis OnClick erstellen, mit der die Hintergrundfarbe des Formulars geändert

wird Das Ergebnis sieht dann folgendermaßen aus:

2-4 E n t w i c k l e r h a n d b u c h

D a s O b j e k t m o d e l l

Abbildung 2.1 Ein einfaches Formular

Sobald der Benutzer auf die Schaltfläche klickt, wird die Farbe des Formulars in Grün geändert Dies wird mit Hilfe der folgenden Behandlungsroutine für das Ereig-

nis OnClick der Schaltfläche erreicht:

procedure TForm1.Button1Click(Sender: TObject);

Button1: TButton; { Neues Datenfeld }

procedure Button1Click(Sender: TObject);{ Neue Methodendeklaration }

O b j e c t P a s c a l m i t d e r V C L v e r w e n d e n 2-5

D a s O b j e k t m o d e l l

Alle in Delphi erstellten Ereignisbehandlungsroutinen sind Methoden des objekts Daher wird für jede Routine eine neue Methodendeklaration in das Formu-

Formular-larobjekt eingefügt Die Deklaration von TForm1 enthält nun eine Methode, die

Pro-zedur Button1Click Der eigentliche Quelltext der Methode befindet sich im

imple-mentation-Abschnitt der Unit

Den Namen einer Komponente ändern

Ändern Sie den Namen einer Komponente immer mit dem Objektinspektor Ein

Bei-spiel: Sie möchten den Standardnamen Form1 in den aussagekräftigeren Namen ColorBox ändern Wenn Sie nun die Formulareigenschaft Name im Objektinspektor

ändern, werden alle Verweise auf das Formular in der DFM-Datei des Formulars (die normalerweise nicht manuell bearbeitet wird) und in dem von Delphi generierten Quelltext automatisch aktualisiert:

Beachten Sie, daß die OnClick-Ereignisbehandlungsroutine nicht aktualisiert wurde

In dem von Ihnen geschriebenen Quelltext müssen Sie die Änderungen selbst nehmen:

vor-procedure TColorBox.Button1Click(Sender: TObject);

begin

ColorBox.Color := clGreen;

end;

Daten und Quelltext von einem Objekt erben

Das auf Seite 2-3 im Abschnitt »Ein Delphi-Objekt untersuchen« beschriebene Objekt

TForm1 ist auf den ersten Blick sehr einfach Es enthält lediglich ein Feld (Button1),

ei-ne Methode (Button1Click) und keiei-ne Eigenschaften Dennoch könei-nen Sie es

anzei-gen, schließen oder seine Größe ändern, Standardschaltflächen zum Minimieren und

2-6 E n t w i c k l e r h a n d b u c h

D a s O b j e k t m o d e l l

Maximieren in der Titelleiste anzeigen und es zu einem Fenster einer dung machen Dies ist möglich, da es alle Eigenschaften und Methoden der VCL-

MDI-Anwen-Komponente TForm erbt Wenn Sie ein neues Formular in Ihr Projekt einfügen, wird

automatisch ein neues Objekt von TForm abgeleitet, das Sie anschließend durch zufügen von Komponenten, Ändern von Eigenschaftswerten und Schreiben von Er-eignisbehandlungsroutinen Ihren Wünschen entsprechend anpassen können Ver-wenden Sie diese Vorgehensweise für alle Objekte Leiten Sie das neue Objekt von ei-nem bereits vorhandenen ab, und nehmen Sie danach die gewünschten Änderungen vor Beim Hinzufügen eines Formulars wird folgende Anweisung in den Quelltext aufgenommen:

Hin-TForm1 = class(TForm)

Ein abgeleitetes Objekt (der Nachkomme) erbt alle Eigenschaften, Ereignisse und Methoden der Klasse, aus der es abgeleitet wird (seines Vorfahren) In der Online-

Hilfe finden Sie unter TForm eine Liste der Eigenschaften, Ereignisse und Methoden

dieser Klasse, einschließlich der von ihren Vorfahren geerbten Elemente Ein Objekt kann nur einen direkten Vorfahren, aber beliebig viele direkte Nachkommen haben

Objekte, Komponenten und Steuerelemente

Abbildung 2.2 Vereinfachte VCL-Hierarchie

Die Abbildung zeigt eine stark vereinfachte Darstellung der Vererbungshierarchie in

der VCL Jedes Objekt erbt von TObject Die Komponenten in der Hierarchie erben von TComponent Die von TControl abgeleiteten Objekte heißen Steuerelemente und können zur Laufzeit angezeigt werden So erbt beispielsweise TCheckBox alle Ele- mente der Klassen TObject, TComponent und TControl und verfügt über spezielle eige-

ne Fähigkeiten

Gültigkeitsbereich und Qualifizierer

Der Gültigkeitsbereich steuert den Zugriff auf die Felder, Eigenschaften und den eines Objekts Alle in einem Objekt deklarierten Elemente sind für dieses und seine Nachkommen verfügbar Bei Methoden ist die Position ihrer Deklaration ent-

Metho-TForm TButton TCheckBox TListBox

TObject

TComponent

TControl

O b j e c t P a s c a l m i t d e r V C L v e r w e n d e n 2-7

D a s O b j e k t m o d e l l

scheidend Auch wenn sich der Quelltext (die Implementierung) außerhalb der deklaration befindet, liegt die betreffende Methode dennoch im Gültigkeitsbereich des Objekts, in dem sie definiert ist

Typ-Wenn Sie in einer Ereignisbehandlungsroutine eines Objekts auf dessen ten, Methoden oder Felder zugreifen, müssen Sie die Objektvariable nicht vor dem

Eigenschaf-Elementbezeichner angeben Das folgende Beispiel zeigt die

OnClick-Ereignisbe-handlungsroutine einer Schaltfläche, die sich in einem Formular befindet:

procedure TForm1.Button1Click(Sender: TObject);

die Routine aufgerufen wird Mit der zweiten Anweisung wird die Farbe der fläche (nicht des Formulars, in dem die Routine deklariert ist) geändert, und daher muß das Objekt angegeben werden

Schalt-Für jedes Formular wird automatisch eine eigene Unit (Quelltextdatei) erstellt Um auf die Komponenten in einem bestimmten Formular in der Unit-Datei eines anderen Formulars zuzugreifen, müssen die Objektnamen in der folgenden Form qualifiziert werden:

Form2.Edit1.Color := clLime;

Auf die gleiche Weise können Methoden einer Komponente in einem anderen mular aufgerufen werden:

For-Form2.Edit1.Clear;

Die Voraussetzung für den Zugriff auf die Komponenten von Form2 ist aber, daß Sie

dessen Quelltextdatei (Unit) in die uses-Klausel der Unit von Form1 aufnehmen.

Der Gültigkeitsbereich eines Objekts erstreckt sich auch über seine Nachkommen Sie können jedoch in den abgeleiteten Objekten jederzeit ein Feld, eine Eigenschaft oder eine Methode erneut deklarieren und dadurch das geerbte Element verdecken oder überschreiben

Weitere Informationen zu Gültigkeitsbereich, Vererbung und uses-Klausel finden Sie

in der Object Pascal Sprachreferenz.

private-, protected-, public- und published-Deklarationen

Bei der Deklaration eines Feldes, einer Eigenschaft oder einer Methode kann die

Sichtbarkeit mit den Schlüsselwörtern private, protected, public und published

an-gegeben werden Sie bestimmt, ob auf das betreffende Element in anderen Objekten und Units zugegriffen werden kann

2-8 E n t w i c k l e r h a n d b u c h

D a s O b j e k t m o d e l l

• Auf private-Elemente kann nur in der Unit zugegriffen werden, in der sie

dekla-riert sind Sie werden häufig in einer Klasse verwendet, um andere Methoden

(public oder published) und Eigenschaften zu implementieren.

• Auf protected-Elemente kann in der Unit, in der ihre Klasse deklariert ist, sowie in

allen abgeleiteten Klassen unabhängig von deren Unit zugegriffen werden

• Auf public-Elemente kann überall zugegriffen werden, wo das Objekt sichtbar ist,

zu dem sie gehören (d h in der Unit, in der die Klasse deklariert ist, und in allen

Units, in der die Datei per uses-Klausel eingebunden ist).

• Die published-Elemente haben dieselbe Sichtbarkeit wie public-Elemente, für sie

werden aber vom Compiler Laufzeit-Typinformationen generiert Auf sie kann während des Entwurfs im Objektinspektor zugegriffen werden

Weitere Informationen zur Sichtbarkeit finden Sie in der Object Pascal Sprachreferenz.

Objektvariablen verwenden

Sie können Zuweisungen zwischen Objektvariablen durchführen, die denselben Typ haben oder zuweisungskompatibel sind Dies ist insbesondere möglich, wenn die Va-riable, der ein Wert zugewiesen wird, ein Vorfahr des zuzuweisenden Typs ist Im fol-

genden Beispiel werden der Typ TDataForm und die beiden Variablen AForm und DataForm deklariert:

Nehmen wir an, Sie erstellen eine Behandlungsroutine für das Ereignis OnClick einer

Schaltfläche Die Routine wird dann zur Laufzeit beim Klicken auf die Schaltfläche aufgerufen Jeder Ereignisbehandlungsroutine wird der Parameter Sender des Typs