RAD Studio - Benutzerbeiträge [de]

Methoden (Delphi)

2023-05-24T14:06:51Z

Rrivero: RS-114150. Added static to Binding Methods enumeration

{{Parent|Klassen und Objekte - Index}}
__TOC__
<ideTag id="reintroduce"></ideTag>
<ideTag id="overload"></ideTag>
<ideTag id="abstract"></ideTag>
<ideTag id="virtual"></ideTag>
<ideTag id="dynamic"></ideTag>
<ideTag id="register"></ideTag>
<ideTag id="pascal"></ideTag>
<ideTag id="cdecl"></ideTag>
<ideTag id="stdcall"></ideTag>
<ideTag id="safecall"></ideTag>
<ideTag id="platform"></ideTag>
<ideTag id="deprecated"></ideTag>
<ideTag id="library"></ideTag>
<ideTag id="inherited"></ideTag>
<ideTag id="Self"></ideTag>
<ideTag id="static"></ideTag>
<ideTag id="override"></ideTag>
<ideTag id="final"></ideTag>
<ideTag id="class"></ideTag>
<ideTag id="read"></ideTag>
<ideTag id="write"></ideTag>
<ideTag id="constructor"></ideTag>
<ideTag id="nill"></ideTag>
<ideTag id="if"></ideTag>
<ideTag id="destructor"></ideTag>
<ideTag id="message"></ideTag>
<ideTag id="DefaultHandler"></ideTag>
<ideTag id="Dispatch"></ideTag>
Eine Methode ist eine Prozedur oder Funktion, die zu einer bestimmten Klasse gehört. Daher wird beim Aufruf einer Methode das Objekt (bzw. bei einer Klassenmethode die Klasse) angegeben, mit dem die Operation durchgeführt werden soll. SomeObject.Free ruft beispielsweise die Methode Free in SomeObject auf.

In diesem Thema wird Folgendes behandelt:

* Methodendeklarationen und -implementierungen
* Methodenbindung
* Methoden überladen
* Konstruktoren und Destruktoren
* Botschaftsmethoden

==Allgemeines zu Methoden==

Methoden werden in der Deklaration einer Klasse als Prozedur- und Funktionsköpfe angegeben, die wie Vorwärtsdeklarationen ('''forward''') arbeiten. Die jeweilige Methode muss dann nach der Klassendefinition in demselben Modul durch eine definierende Deklaration implementiert werden. Die Deklaration der Klasse TMyClass im folgenden Beispiel enthält eine Methode mit dem Namen DoSomething:

<source lang="delphi">
type
TMyClass = class(TObject)
...
procedure DoSomething;
...
end;
</source>

Weiter unten in demselben Modul wird die definierende Deklaration für DoSomething implementiert:

<source lang="delphi">
procedure TMyClass.DoSomething;
begin
...
end;
</source>

Während eine Klasse im interface- oder implementation-Abschnitt einer Unit deklariert werden kann, müssen die definierenden Deklarationen ihrer Methoden im implementation-Abschnitt stehen.

Im Kopf einer definierenden Deklaration wird der Name der Methode immer mit der Klasse qualifiziert, zu der die Methode gehört. Optional kann auch die Parameterliste aus der Klassendeklaration wiederholt werden, doch müssen in diesem Fall Reihenfolge, Typ und Namen der Parameter genau übereinstimmen. Bei einer Funktion muss auch der Rückgabewert identisch sein.

Methodendeklarationen können spezielle Direktiven enthalten, die in anderen Funktionen oder Prozeduren nicht verwendet werden. Direktiven müssen in der Klassendeklaration enthalten sein (nicht in der definierenden Deklaration) und in der folgenden Reihenfolge angegeben werden:

'''reintroduce'''; '''overload'''; [[#Methodenbindung|Bindung]]; [[Prozeduren und Funktionen (Delphi)#Aufrufkonventionen|Aufrufkonvention]]; '''abstract'''; [[Deklarationen und Anweisungen (Delphi)#Hinweis-Direktiven|Warnung]]

Beschreibung:

* [[#Methodenbindung|Bindung]] ist '''static''', '''virtual''', '''dynamic''' oder '''override'''.
* Die [[Prozeduren und Funktionen (Delphi)#Aufrufkonventionen|Aufrufkonvention]] lautet '''register''', '''pascal''', '''cdecl''', '''stdcall''' oder '''safecall''';
* [[Deklarationen und Anweisungen (Delphi)#Hinweis-Direktiven|Warnung]] ist '''platform''', '''deprecated''' oder '''library'''. Weitere Informationen zu diesen Warnungs-Direktiven finden Sie unter [[Deklarationen und Anweisungen (Delphi)#Hinweis-Direktiven|Hinweis-Direktiven]].

Alle {{Delphi}}-Direktiven sind unter [[Grundlegende syntaktische Elemente (Delphi)#Direktiven|Direktiven]] aufgelistet.

===Inherited===

Das reservierte Wort '''inherited''' ist für die Implementierung von polymorphem Verhalten von großer Bedeutung. Es kann in Methodendefinitionen (mit oder ohne nachfolgendem Bezeichner) angegeben werden.

Folgt auf '''inherited''' ein Member-Name, entspricht dies einem normalen Methodenaufruf bzw. einer Referenz auf eine Eigenschaft oder ein Feld. Der einzige Unterschied besteht darin, dass die Suche nach dem referenzierten Member bei dem direkten Vorfahren der Klasse beginnt, zu der die Methode gehört. Wenn Sie beispielsweise

<source lang="delphi">
inherited Create(...);
</source>

in der Definition einer Methode angeben, wird die geerbte Methode Create aufgerufen.

'''inherited''' ohne Bezeichner verweist auf die geerbte Methode mit demselben Namen wie die aufrufende Methode. Handelt es sich bei der aufrufenden Methode um eine Botschaftsbehandlung, verweist diese auf die geerbte Botschaftsbehandlung für dieselbe Botschaft. In diesem Fall übernimmt '''inherited''' keine expliziten Parameter, sondern der geerbten Methode werden einfach die Parameter der aufrufenden Methode übergeben. Zum Beispiel wird

<source lang="delphi">
inherited;
</source>

häufig in der Implementierung von Konstruktoren verwendet. Der geerbte Konstruktor wird mit den Parametern aufgerufen, die an die abgeleitete Klasse übergeben wurden.

===Self===

Der Bezeichner '''Self''' verweist in der Implementierung einer Methode auf das Objekt, in dem die Methode aufgerufen wird. Das folgende Beispiel zeigt die Methode Add der Klasse TCollection in der Unit Classes:

<source lang="delphi">
function TCollection.Add: TCollectionItem;
begin
Result := FItemClass.Create(Self);
end;
</source>

Add ruft die Methode Create der Klasse auf, die das Feld FItemClass referenziert (ist immer ein Nachkomme von TCollectionItem). Da an TCollectionItem.Create ein einzelner Parameter des Typs TCollection übergeben wird, übergibt Add die Instanz von TCollection, in der Add aufgerufen wird. Der folgende Code veranschaulicht dies:

<source lang="delphi">
var MyCollection: TCollection;
...
MyCollection.Add // MyCollection is passed to the
// TCollectionItem.Create method
</source>

'''Self''' ist in vielen Situationen hilfreich. So kann beispielsweise ein Member-Bezeichner, der in einem Klassentyp deklariert ist, in einer Methode dieser Klasse erneut deklariert werden. In diesem Fall kann mit Self.Identifier auf den ursprünglichen Member-Bezeichner zugegriffen werden.

Informationen zu '''Self''' in Klassenmethoden finden Sie unter "Klassenoperatoren" in [[Klassenreferenzen|Klassenreferenzen]].

==Methodenbindung==

Methodenbindungen können '''static''' (statisch, Standard), '''virtual''' (virtuell) oder '''dynamic''' (dynamisch) sein. Virtuelle und dynamische Methoden können überschrieben werden, und sie können abstrakt sein. Diese Angaben spielen eine Rolle, wenn eine Variable eines bestimmten Klassentyps eine Instanz einer abgeleiteten Klasse enthält. Sie bestimmen dann, welche Implementierung beim Aufruf der Methode aktiviert wird.

===Statische Methoden===

Methoden sind standardmäßig statisch. Beim Aufruf bestimmt der deklarierte Typ (also der Typ zur Compilierzeit) der im Aufruf verwendeten Klassen- bzw. Objektvariable, welche Implementierung aktiviert wird. Die Draw-Methoden im folgenden Beispiel sind statisch:

<source lang="delphi">
type
TFigure = class
procedure Draw;
end;

TRectangle = class(TFigure)
procedure Draw;
end;
</source>

Ausgehend von diesen Deklarationen zeigt das folgende Beispiel, wie sich Aufrufe statischer Methoden auswirken. Im zweiten Aufruf von Figure.Draw referenziert die Variable Figure ein Objekt der Klasse TRectangle. Es wird jedoch die Draw-Implementierung in TFigure aufgerufen, weil Figure als TFigure deklariert ist:

<source lang="delphi">
var
Figure: TFigure;
Rectangle: TRectangle;

begin
Figure := TFigure.Create;
Figure.Draw; // calls TFigure.Draw
Figure.Destroy;
Figure := TRectangle.Create;
Figure.Draw; // calls TFigure.Draw

TRectangle(Figure).Draw; // calls TRectangle.Draw

Figure.Destroy;
Rectangle := TRectangle.Create;
Rectangle.Draw; // calls TRectangle.Draw
Rectangle.Destroy;
end;
</source>

===Virtuelle und dynamische Methoden===

Mithilfe der Direktiven '''virtual''' und '''dynamic''' können Methoden als '''virtual''' oder '''dynamic''' deklariert werden. Virtuelle und dynamische Methoden können im Gegensatz zu statischen Methoden in abgeleiteten Klassen überschrieben werden. Beim Aufrufen einer überschriebenen Methode bestimmt nicht der deklarierte, sondern der aktuelle Typ (also der Typ zur Laufzeit) der im Aufruf verwendeten Klassen- bzw. Objektvariable, welche Implementierung aktiviert wird.

Um eine Methode zu überschreiben, wird sie mit der Direktive '''override''' erneut deklariert. Bei einer '''override'''-Deklaration müssen Reihenfolge und Typ der Parameter sowie der Typ des Rückgabewertes (falls vorhanden) mit der Deklaration in der Vorfahrklasse übereinstimmen.

Im folgenden Beispiel wird die in der Klasse TFigure deklarierte Methode Draw in zwei abgeleiteten Klassen überschrieben:

<source lang="delphi">
type
TFigure = class
procedure Draw; virtual;
end;

TRectangle = class(TFigure)
procedure Draw; override;
end;

TEllipse = class(TFigure)
procedure Draw; override;
end;
</source>

Ausgehend von diesen Deklarationen zeigt der folgende Programmcode, wie sich der Aufruf einer virtuellen Methode durch eine Variable auswirkt, deren aktueller Typ zur Laufzeit geändert wird:

<source lang="delphi">
var
Figure: TFigure;

begin
Figure := TRectangle.Create;
Figure.Draw; // calls TRectangle.Draw
Figure.Destroy;
Figure := TEllipse.Create;
Figure.Draw; // calls TEllipse.Draw
Figure.Destroy;
end;
</source>

Nur '''virtuelle''' und '''dynamische''' Methoden können überschrieben werden. Alle Methoden können jedoch überladen werden (siehe [[#Methoden überladen|Methoden überladen]].

====Finale Methoden====

Der {{Delphi}}-Compiler unterstützt auch das Konzept der '''finalen''' virtuellen und dynamischen Methoden. Deklarationen der finalen Methoden haben die Form:

function|procedure FunctionName; virtual|dynamic; final;

Hier wird mit der Syntax <code>virtual|dynamic</code> (zwei Schlüsselwörter und das Pipe-Zeichen <code>|</code> dazwischen) festgelegt, dass nur eins der Schlüsselwörter '''virtual''' oder '''dynamic''' verwendet werden sollte. Nur die Schlüsselwörter '''virtual''' oder '''dynamic''' sind bedeutend; das Pipe-Zeichen selbst sollte gelöscht werden.

Durch das Schlüsselwort '''final''' bei einer virtuellen oder dynamischen Methode kann verhindert werden, dass diese von einer abgeleiteten Klasse überschrieben wird. Mit dem Schlüsselwort '''final''' wird gleichzeitig dokumentiert, auf welche Weise die Klasse verwendet werden soll. Außerdem ermöglicht es dem Compiler eine Optimierung des generierten Codes.

<blockquote>'''Hinweis:''' Die Schlüsselwörter '''virtual''' oder '''dynamic''' müssen vor dem Schlüsselwort '''final''' geschrieben werden.</blockquote>

'''Beispiel'''
<source lang="delphi">
type
Base = class
procedure TestProcedure; virtual;
procedure TestFinalProcedure; virtual; final;
end;

Derived = class(Base)
procedure TestProcedure; override;
//Ill-formed: E2352 Cannot override a final method
procedure TestFinalProcedure; override;
end;
</source>

====Unterschiede zwischen virtuellen und dynamischen Methoden====

In {{Delphi}} für Win32 sind virtuelle und dynamische Methoden von der Semantik her identisch. Sie unterscheiden sich aber bei der Implementierung der Aufrufweiterleitung zur Laufzeit: Virtuelle Methoden werden hinsichtlich der Geschwindigkeit, dynamische Methoden hinsichtlich der Codegröße optimiert.

Im Allgemeinen kann mit virtuellen Methoden polymorphes Verhalten am effizientesten implementiert werden. Dynamische Methoden sind hilfreich, wenn in einer Basisklasse eine große Anzahl überschreibbarer Methoden deklariert ist, die von vielen abgeleiteten Klassen geerbt, aber nur selten überschrieben werden.

<blockquote>'''Hinweis:''' Verwenden Sie dynamische Methoden nur, wenn sich daraus ein nachweisbarer Nutzen ergibt. Im Allgemein sollten Sie eher virtuelle Methoden verwenden.</blockquote>

====Unterschiede zwischen Überschreiben und Verdecken====

Wenn in einer Methodendeklaration dieselbe Bezeichner- und Parametersignatur wie bei einer geerbten Methode ohne die Anweisung '''override''' angegeben wird, wird die geerbte Methode durch die neue Deklaration nur verdeckt, nicht überschrieben. Beide Methoden sind jedoch in der abgeleiteten Klasse vorhanden, in der der Methodenname statisch gebunden wird. Zum Beispiel:

<source lang="delphi">
type
T1 = class(TObject)
procedure Act; virtual;
end;

T2 = class(T1)
procedure Act; // Act is redeclared, but not overridden
end;

var
SomeObject: T1;

begin
SomeObject := T2.Create;
SomeObject.Act; // calls T1.Act
end;
</source>

====Reintroduce====

Die Direktive '''reintroduce''' unterdrückt Compiler-Warnungen, wenn zuvor deklarierte virtuelle Methoden verdeckt werden. Zum Beispiel:

<source lang="delphi">
procedure DoSomething; reintroduce; // The ancestor class also
// has a DoSomething method
</source>

Verwenden Sie '''reintroduce''', wenn eine geerbte virtuelle Methode durch eine neue Deklaration verdeckt werden soll.

====Abstrakte Methoden====

Eine abstrakte Methode ist eine virtuelle oder dynamische Methode, die nicht in der Klasse implementiert ist, in der sie deklariert wird. Die Implementierung wird erst später in einer abgeleiteten Klasse durchgeführt. Bei der Deklaration abstrakter Methoden muss die Anweisung '''abstract''' nach '''virtual''' oder '''dynamic''' angegeben werden. Zum Beispiel:

<source lang="delphi">
procedure DoSomething; virtual; abstract;
</source>

Eine '''abstrakte''' Methode kann nur in einer Klasse oder Instanz einer Klasse aufgerufen werden, in der sie überschrieben wurde.

==Klassenmethoden==

Die meisten Methoden werden Instanzmethoden genannt, weil sie mit einer einzelnen Instanz eines Objekts arbeiten. Eine Klassenmethode ist eine Methode, die nicht mit Objekten, sondern mit Klassen arbeitet. Es gibt zwei Typen von Klassenmethoden: reguläre Klassenmethoden und klassenstatische Methoden.

===Reguläre Klassenmethoden===

Die Definition muss mit dem reservierten Wort '''class''' beginnen. Zum Beispiel:

<source lang="delphi">
type
TFigure = class
public
class function Supports(Operation: string): Boolean; virtual;
class procedure GetInfo(var Info: TFigureInfo); virtual;
...
end;
</source>

Auch die definierende Deklaration einer Klassenmethode muss mit '''class''' eingeleitet werden. Zum Beispiel:

<source lang="delphi">
class procedure TFigure.GetInfo(var Info: TFigureInfo);
begin
...
end;
</source>

In der definierenden Deklaration einer Klassenmethode kann mit dem Bezeichner '''Self''' auf die Klasse zugegriffen werden, in der die Methode aufgerufen wird (dies kann auch ein Nachkomme der Klasse sein, in der sie definiert ist). Wird die Methode beispielsweise in der Klasse C aufgerufen, hat '''Self''' den Typ class of C. Daher können mit '''Self''' nicht auf Instanzfelder, Instanzeigenschaften und normale (Objekt-)Methoden zugreifen, sondern '''Self''' kann nur für Aufrufe von Konstruktoren und anderen Klassenmethoden oder für den Zugriff auf Klasseneigenschaften und Klassenfelder verwendet werden.

Eine Klassenmethode kann über eine Klassenreferenz oder eine Objektreferenz aufgerufen werden. Bei einer Objektreferenz erhält '''Self''' als Wert die Klasse des betreffenden Objekts.

===Klassenstatische Methoden===

Auf klassenstatische Methoden kann, wie auf Klassenmethoden, ohne Objektreferenz zugegriffen werden. Im Gegensatz zu regulären Klassenmethoden haben klassenstatische Methoden keinen '''Self'''-Parameter. Sie können außerdem auf keine Instanz-Member zugreifen. (Sie können aber auf Klassenfelder, Klasseneigenschaften und Klassenmethoden zugreifen.) Wiederum im Gegensatz zu Klassenmethoden können klassenstatische Methoden nicht als '''virtual''' deklariert werden.

Um eine Methode als klassenstatisch zu deklarieren, fügen Sie das Wort '''static''' an die Deklaration an:

<source lang="delphi">
type
TMyClass = class
strict private
class var
FX: Integer;

strict protected
// Note: Accessors for class properties
// must be declared class static.
class function GetX: Integer; static;
class procedure SetX(val: Integer); static;

public
class property X: Integer read GetX write SetX;
class procedure StatProc(s: String); static;
end;
</source>

Wie eine Klassenmethode kann eine klassenstatische Methode über den Klassentyp (also ohne Objektreferenz) aufgerufen werden, z. B.:

<source lang="delphi">
TMyClass.X := 17;
TMyClass.StatProc('Hello');
</source>

==Methoden überladen==

Eine Methode kann mit der Direktive '''overload''' neu deklariert werden. Wenn sich die Parametersignatur von der ihres Vorfahren unterscheidet, wird die geerbte Methode überladen, ohne dass sie dadurch verdeckt wird. Bei einem Aufruf der Methode in einer abgeleiteten Klasse wird dann diejenige Implementierung aktiviert, bei der die Parameter übereinstimmen.

Verwenden Sie beim Überladen einer virtuellen Methode die Direktive '''reintroduce''', wenn die Methode in einer abgeleiteten Klasse neu deklariert wird. Zum Beispiel:

<source lang="delphi">
type
T1 = class(TObject)
procedure Test(I: Integer); overload; virtual;
end;

T2 = class(T1)
procedure Test(S: string); reintroduce; overload;
end;
...

SomeObject := T2.Create;
SomeObject.Test('Hello!'); // calls T2.Test
SomeObject.Test(7); // calls T1.Test
</source>

Innerhalb einer Klasse dürfen nicht mehrere überladene Methoden mit demselben Namen als published deklariert werden. Zur Pflege von Laufzeit-Typinformationen wird für jeden als '''published''' deklarierten Member ein eindeutiger Name benötigt:

<source lang="delphi">
type
TSomeClass = class
published
function Func(P: Integer): Integer;
function Func(P: Boolean): Integer; // error
...
</source>

Methoden, die als '''read'''- oder '''write'''-Bezeichner für Eigenschaften dienen, können nicht überladen werden.

Bei der Implementierung einer überladenen Methode muss die Parameterliste aus der Klassendeklaration wiederholt werden. Weitere Informationen zum Überladen finden Sie unter [[Prozeduren und Funktionen (Delphi)#Prozeduren und Funktionen überladen|Prozeduren und Funktionen überladen]] in [[Prozeduren und Funktionen (Delphi)|Prozeduren und Funktionen (Delphi)]].

==Konstruktoren==

Ein Konstruktor ist eine spezielle Methode, mit der Instanzobjekte erstellt und initialisiert werden. Die Deklaration gleicht einer normalen Prozedurdeklaration, beginnt aber mit dem Wort '''constructor'''. Beispiele:

<source lang="delphi">
constructor Create;
constructor Create(AOwner: TComponent);
</source>

Für Konstruktoren muss die Standard-Aufrufkonvention '''register''' verwendet werden. Obwohl die Deklaration keinen Rückgabewert enthält, gibt ein Konstruktor immer einen Verweis auf das Objekt zurück, das er erstellt bzw. in dem er aufgerufen wird.

Eine Klasse kann auch mehrere Konstruktoren haben. Im Normalfall ist jedoch nur einer vorhanden. Konstruktoren heißen normalerweise immer Create.

Das folgende Beispiel zeigt, wie Sie ein Objekt durch einen Aufruf des Konstruktors eines Klassentyps erstellen können:

<source lang="delphi">
MyObject := TMyClass.Create;
</source>

Diese Anweisung reserviert zuerst Speicher für das neue Objekt. Anschließend wird allen Ordinalfeldern der Wert null, allen Zeigern und Klassentypfeldern der Wert '''nil''' und allen String-Feldern ein leerer String zugewiesen. Danach werden die weiteren Aktionen in der Implementierung des Konstruktors ausgeführt (z. B. Initialisieren der Objekte mit den als Parameter übergebenen Werten). Am Ende gibt der Konstruktor eine Referenz auf das neu erstellte und initialisierte Objekt zurück. Der Typ entspricht dem im Aufruf angegebenen Klassentyp.

Tritt in einem mit einer Klassenreferenz aufgerufenen Konstruktor eine Exception auf, wird das unvollständige Objekt automatisch durch einen Aufruf des Destruktors Destroy freigegeben.

Wenn Sie einen Konstruktor mit einer Objektreferenz (anstatt mit einer Klassenreferenz) aufrufen, wird kein Objekt erstellt. Stattdessen werden, wie bei einer normalen Routine, die angegebenen Anweisungen mit dem Objekt ausgeführt, und es wird eine Referenz auf das Objekt zurückgegeben. Beim Aufruf mit einer Objektreferenz wird normalerweise der geerbte Konstruktor mit '''inherited''' ausgeführt.

Das folgende Beispiel zeigt einen Klassentyp und den zugehörigen Konstruktor:

<source lang="delphi">
type
TShape = class(TGraphicControl)
private
FPen: TPen;
FBrush: TBrush;
procedure PenChanged(Sender: TObject);
procedure BrushChanged(Sender: TObject);
public
constructor Create(Owner: TComponent); override;
destructor Destroy; override;
...
end;

constructor TShape.Create(Owner: TComponent);
begin
inherited Create(Owner); // Initialize inherited parts
Width := 65; // Change inherited properties
Height := 65;
FPen := TPen.Create; // Initialize new fields
FPen.OnChange := PenChanged;
FBrush := TBrush.Create;
FBrush.OnChange := BrushChanged;
end;
</source>

Als erste Anweisung wird in der Regel immer der geerbte Konstruktor aufgerufen, um die geerbten Felder zu initialisieren. Danach werden den in der abgeleiteten Klasse deklarierten Feldern Werte zugewiesen. Da der Konstruktor grundsätzlich den Speicherbereich bereinigt, der dem neuen Objekt zugewiesen wird, erhalten alle Felder automatisch den Anfangswert null (Ordinaltypen), '''nil''' (Zeiger und Klassentypen), einen leeren String (String-Typen) oder Unassigned (Varianten). Aus diesem Grund brauchen nur solche Felder explizit initialisiert zu werden, denen ein Anfangswert ungleich null (bzw. kein leerer String) zugewiesen werden soll.

Ein als '''virtual''' deklarierter Konstruktor, der mit einem Klassentypbezeichner aufgerufen wird, entspricht einem statischen Konstruktor. In Verbindung mit Klassenreferenztypen können jedoch durch virtuelle Konstruktoren Objekte polymorph erstellt werden (d. h. der Objekttyp ist beim Compilieren noch nicht bekannt). Weitere Informationen finden Sie unter [[Klassenreferenzen|Klassenreferenzen]].

==Destruktoren==

Ein Destruktor ist eine spezielle Methode, die ein Objekt im Speicher freigibt. Die Deklaration gleicht einer Prozedurdeklaration, beginnt aber mit dem Wort '''destructor'''. Beispiel:

<source lang="delphi">
destructor SpecialDestructor(SaveData: Boolean);
destructor Destroy; override;
</source>

In Win32 muss für Destruktoren die Standard-Aufrufkonvention '''register''' verwendet werden. Obwohl in einer Klasse mehrere Destruktoren implementiert werden können, ist es ratsam, nur die geerbte Methode Destroy zu überschreiben und keine weiteren Destruktoren zu deklarieren.

Ein Destruktor kann nur über ein Instanzobjekt aufgerufen werden. Zum Beispiel:

<source lang="delphi">
MyObject.Destroy;
</source>

Beim Aufruf eines Destruktors werden zuerst die in der Implementierung angegebenen Aktionen ausgeführt. Normalerweise werden hier untergeordnete Objekte und zugewiesene Ressourcen freigegeben. Danach wird der durch das Objekt belegte Speicherplatz freigegeben.

Das folgende Beispiel zeigt eine typische Destruktorimplementierung:

<source lang="delphi">
destructor TShape.Destroy;
begin
FBrush.Free;
FPen.Free;
inherited Destroy;
end;
</source>

Die letzte Anweisung ruft den geerbten Destruktor auf, der die geerbten Felder freigibt.

Wenn beim Erstellen eines Objekts eine Exception auftritt, wird das unvollständige Objekt automatisch durch einen Aufruf von Destroy freigegeben. Destroy muss daher auch in der Lage sein, Objekte freizugeben, die nur teilweise erstellt wurden. Da im Konstruktor alle Felder eines neuen Objekts zuerst mit null oder leeren Werten initialisiert werden, haben Klassen- und Zeigerfelder in einer unvollständigen Instanz immer den Wert '''nil'''. Testen Sie solche Felder im Destruktor immer auf den Wert '''nil''', bevor Sie Operationen mit ihnen durchführen. Wenn Sie Objekte nicht mit '''Destroy''', sondern mit der Methode '''Free''' (in TObject definiert) freigeben, wird diese Prüfung automatisch durchgeführt.

==Klassenkonstruktoren==

Ein Klassenkonstruktor ist eine spezielle Klassenmethode, auf die von Entwicklern nicht zugegriffen werden kann. Aufrufe von Klassenkonstruktoren werden automatisch vom Compiler in den initialization-Abschnitt der Unit eingefügt, in der die Klasse definiert ist. In der Regel werden mit Klassenkonstruktoren die statischen Felder der Klasse initialisiert oder Initialisierungen ausgeführt, die erforderlich sind, damit die Klasse oder eine Klasseninstanz ordnungsgemäß arbeiten kann. Dasselbe Ergebnis kann zwar auch durch Einfügen des Klasseninitialisierungscodes in den ''initialization''-Abschnitt erzielt werden, aber Klassenkonstruktoren unterstützen den Compiler bei der Entscheidung, welche Klassen in die endgültige Binärdatei aufgenommen und welche daraus entfernt werden sollen.

Das nächste Beispiel zeigt eine normale Initialisierung von Klassenfeldern:

<source lang="delphi">
type
TBox = class
private
class var FList: TList<Integer>;
end;

implementation

initialization
{ Initialize the static FList member }
TBox.FList := TList<Integer>.Create();

end.
</source>

Dieses Vorgehen hat einen entscheidenden Nachteil: Auch wenn eine Anwendung die Unit einbeziehen kann, in der '''TBox''' deklariert ist, kann es sein, dass die Klasse '''TBox''' tatsächlich nie verwendet wird. Im obigen Beispiel wird die Klasse TBox in die resultierende Binärdatei einbezogen, weil sie im initialization-Abschnitt referenziert wird. Mit Klassenkonstruktoren kann dieses Problem umgangen werden:

<source lang="delphi">
type
TBox = class
private
class var FList: TList<Integer>;
class constructor Create;
end;

implementation

class constructor TBox.Create;
begin
{ Initialize the static FList member }
FList := TList<Integer>.Create();
end;

end.
</source>

In diesem Beispiel überprüft der Compiler, ob TBox tatsächlich in der Anwendung verwendet wird. Falls ja, wird automatisch ein Aufruf des Klassenkonstruktors dem initialization-Abschnitt der Unit hinzugefügt.

'''Hinweis:''' In der Regel sorgt der Compiler für die richtige Reihenfolge der Initialisierung von Klassen, in einigen komplexen Szenarien könnte die Reihenfolge aber zufällig werden. Und zwar dann, wenn der Klassenkonstruktor einer Klasse vom Status einer anderen Klasse abhängig ist, der wiederum von der ersten Klasse abhängt.

'''Hinweis:''' Der Klassenkonstruktor für eine generische Klasse oder einen Record kann mehrfach ausgeführt werden. Die genaue Anzahl der Ausführungen des Klassenkonstruktors hängt in diesem Fall von der Anzahl der spezialisierten Versionen des generischen Typs ab. Der Klassenkonstruktor für eine spezialisierte ''TList<String>''-Klasse kann beispielsweise mehrfach in derselben Anwendung ausgeführt werden.

==Klassendestruktoren==

Klassendestruktoren sind das Gegenteil von Klassenkonstruktoren, und zwar weil sie die Finalisierung der Klasse vornehmen. Klassendestruktoren bieten dieselben Vorteile wie Klassenkonstruktoren, nur dass sie die ''Finalisierung'' vornehmen.

Das folgende Beispiel baut auf dem Beispiel für Klassenkonstruktoren auf und führt die Finalisierungsroutine ein:

<source lang="delphi">
type
TBox = class
private
class var FList: TList<Integer>;
class constructor Create;
class destructor Destroy;
end;

implementation

class constructor TBox.Create;
begin
{ Initialize the static FList member }
FList := TList<Integer>.Create();
end;

class destructor TBox.Destroy;
begin
{ Finalize the static FList member }
FList.Free;
end;

end.
</source>

'''Hinweis:''' Der Klassendestruktor für eine generische Klasse oder einen Record kann mehrfach ausgeführt werden. Die genaue Anzahl der Ausführungen des Klassendestruktors hängt in diesem Fall von der Anzahl der spezialisierten Versionen des generischen Typs ab. Der Klassendestruktor für eine spezialisierte ''TList<String>''-Klasse kann beispielsweise mehrfach in derselben Anwendung ausgeführt werden.

==Botschaftsmethoden==

In Botschaftsmethoden können Reaktionen auf dynamisch weitergeleitete Botschaften implementiert werden. Die Syntax für Botschaftsmethoden wird auf allen Plattformen unterstützt. <f s="vcl" t="span" /> In der VCL werden Botschaftsmethoden verwendet, um auf Windows-Botschaften zu antworten. <f e="vcl" t="span" />

Sie erstellen eine Botschaftsmethode, indem Sie die Direktive '''message''' gefolgt von einer Integer-Konstante von 1 bis 49151 (der sogenannten Botschafts-ID) in eine Methodendeklaration aufnehmen. <f s="vcl" t="span" /> In Botschaftsmethoden für VCL-Steuerelemente kann als Integer-Konstante eine der Botschafts-IDs von Win32 verwendet werden, die (zusammen mit den entsprechenden Record-Typen) in der Unit Messages definiert sind. <f e="vcl" t="span" /> Eine Botschaftsmethode muss eine Prozedur mit einem einzelnen '''var'''-Parameter sein.

Zum Beispiel:

<source lang="delphi">
type
TTextBox = class(TCustomControl)
private
procedure WMChar(var Message: TWMChar); message WM_CHAR;
...
end;
</source>

In einer Botschaftsmethode muss die Direktive '''override''' nicht angegeben werden, um eine geerbte Botschaftsmethode zu überschreiben. Es muss nicht einmal derselbe Methodenname oder Parametertyp wie bei der zu überschreibenden Methode verwendet werden. Allein die Botschafts-ID bestimmt, auf welche Botschaft die Methode reagiert, und ob die Methode überschrieben wird.

===Botschaftsmethoden implementieren===

In der Implementierung einer Botschaftsmethode kann die geerbte Botschaftsmethode wie im folgenden Beispiel aufgerufen werden:

<source lang="delphi">
procedure TTextBox.WMChar(var Message: TWMChar);
begin
if Message.CharCode = Ord(#13) then
ProcessEnter
else
inherited;
end;
</source>

Die Anweisung '''inherited''' durchsucht die Klassenhierarchie nach oben und ruft die erste Botschaftsmethode mit derselben ID wie die aktuelle Methode auf. Dabei wird automatisch der Botschafts-Record übergeben. Ist in keiner Vorfahrklasse eine Botschaftsmethode mit dieser ID implementiert, ruft '''inherited''' die ursprünglich in TObject definierte Methode DefaultHandler auf.

Die Implementierung von DefaultHandler in TObject gibt einfach die Steuerung zurück, ohne eine Aktion auszuführen. Durch Überschreiben von DefaultHandler kann in einer Klasse eine eigene Standardbehandlung für Botschaften implementiert werden. In Win32 ruft die DefaultHandler-Methode für Steuerelemente die DefWindowProc-Funktion der Win32-API auf.

===Botschaftsweiterleitung===

Botschaftsmethoden werden normalerweise nicht direkt aufgerufen. Stattdessen werden Botschaften mithilfe der von TObject geerbten Methode Dispatch an ein Objekt weitergeleitet:

<source lang="delphi">
procedure Dispatch(var Message);
</source>

Der an Dispatch übergebene Parameter Message muss ein Record sein, dessen erstes Element ein '''Word'''-Feld mit einer Botschafts-ID enthält.

Dispatch durchsucht die Klassenhierarchie nach oben (beginnend bei der Klasse des Objekts, in dem sie aufgerufen wird) und ruft die erste für die übergebene ID gefundene Botschaftsmethode auf. Wird keine solche Methode gefunden, ruft Dispatch die Methode DefaultHandler auf.

==Siehe auch==

*[[Klassen und Objekte (Delphi)|Klassen und Objekte (Delphi)]]
*[[Felder (Delphi)|Felder (Delphi)]]
*[[Eigenschaften (Delphi)|Eigenschaften (Delphi)]]
*[[Verschachtelte Typdeklarationen|Verschachtelte Typdeklarationen]]
*[[Klassenreferenzen|Klassenreferenzen]]
*[[Exceptions (Delphi)|Exceptions (Delphi)]]
*[[Überladene Operatoren (Delphi)|Überladene Operatoren (Delphi)]]
*[[Unterstützende Klassen und Records (Delphi)|Unterstützende Klassen und Records (Delphi)]]
* [[Prozeduren und Funktionen (Delphi)|Prozeduren und Funktionen (Delphi)]]
* [[Ablaufsteuerung (Delphi)|Ablaufsteuerung (Delphi)]]

[[Category:Delphi]]
[[Category:Delphi-Sprachreferenz]]
[[Category:AMMigrate]]

[[en:Methods (Delphi)]]
[[fr:Méthodes (Delphi)]]
[[ja:メソッド（Delphi）]]

Formular-Designer

2022-12-19T15:32:27Z

Rrivero: RS-115132. Removed HTML Designer Section

{{Parent|Einführung in RAD Studio}}

<f s="radstudio" />
Der '''Formular-Designer''' (oder Designer) wird automatisch angezeigt, wenn Sie ein Formular, wie z. B. eine {{f|radstudio|[[VCL-Formularanwendung|VCL-Formularanwendung]] oder eine}} [[Geräteübergreifende HD-Anwendung|geräteübergreifende HD-Anwendung]], erstellen oder bearbeiten.
Der '''Formular-Designer''' wird automatisch ausgeführt, wenn Sie eine grafische Anwendung erstellen, die auf einer Formulardatei (entweder <code>.dfm</code>- oder <code>.fmx</code>-Datei) beruht.
<f e="radstudio" />
<f s="appmethod" />
Der '''Formular-Designer''' (oder Designer) wird automatisch angezeigt, wenn Sie ein Formular, wie z. B. eine [[Geräteübergreifende HD-Anwendung|geräteübergreifende HD-Anwendung]], erstellen oder bearbeiten.
Der '''Formular-Designer''' wird automatisch ausgeführt, wenn Sie eine grafische Anwendung erstellen, die auf einer Formulardatei (<code>.fmx</code>-Datei) beruht.
<f e="appmethod" />
Um den Fokus für ein in der IDE geöffnetes visuelles Projekt in den '''Formular-Designer''' zu setzen, klicken Sie am unteren Rand des Hauptbearbeitungsfensters auf das Register '''Design''':
[[Image:CodeDesignHistoryTabs.jpg|link=|Registerkarten "Code", "Design" und "Historie"]]

{{Note|Sie können das Fenster des [[Quelltext-Editor|Quelltext-Editors]] und des Formular-Designers gleichzeitg für dieselbe Unit mit [[Neues Editierfenster|Neues Editierfenster]] öffnen. Wenn Sie im Objektinspektor ein Ereignis erstellen oder auf eine Ereignisbehandlungsroutine doppelklicken, wird der Inhalt des Quelltext-Editorfensters an die Position des Ereignisses verschoben und das Fenster des Formular-Designers verbleibt unverändert.}}

Der Typ des Formulars bestimmt das Aussehen und die Funktionalität des Designers. Wenn Sie beispielsweise ein HTML-Element verwenden, können Sie den [[Mit dem HTML-Tag-Editor arbeiten|HTML-Tag-Editor]] im Designer durch Auswahl von '''Ansicht > Tag-Editor''' anzeigen.

==Fenster des Formular-Designers==

<f s="radstudio" />
'''{{FM}} und die VCL verwenden unterschiedliche Formular-Designer und unterschiedliche Formulare: '''
Die folgende Abbildung zeigt das '''geräteübergreifende Formular (FireMonkey)''' und das '''VCL-Formular''', wie sie im '''Formular-Designer''' beim Erstellen einer [[Geräteübergreifende Anwendung|geräteübergreifenden Anwendung]] bzw. [[VCL-Formularanwendung|VCL-Formularanwendung]] erscheinen:

 

{| border="1" frame="hsides" rules="rows"
|- valign="top"
|
'''Geräteübergreifendes Formular'''
|
[[Image:multidevice form.png|link=|Geräteübergreifendes Formular]]
|- valign="top"
|
'''VCL-Formular'''   
|
[[Image:vcl form.png|link=|VCL-Formular]]
|}

Die beiden Formulare unterscheiden sich, weil ein VCL-Formular ein natives Windows-Formular ist, während ein geräteübergreifendes Formular plattformunabhängig ist und von den {{FM}}-Tools gezeichnet wird. In einem VCL-Formular werden beispielsweise die Windows-Standardschaltflächen für die Befehle "Minimieren", "Größe ändern" und "Schließen" angezeigt. Ein geräteübergreifendes Formular wird standardmäßig in der '''Master'''-Ansicht dargestellt, die plattformunabhängig ist. Eine geräteübergreifende Anwendung kann auf allen verfügbaren Plattformen ausgeführt werden, eine VCL-Anwendung dagegen nur auf Windows.

Trotz dieser visuellen Unterschiede arbeitet der '''Formular-Designer''' für {{FM}} und für die VCL fast auf dieselbe Weise. Ein Unterschied ist, dass einige unterschiedliche [[#Kontextmenü|Kontextmenübefehle]] für {{FM}} und die VCL unterstützt werden.
<f e="radstudio" />
<f s="appmethod" />
So wird ein '''geräteübergreifendes Formular''' im '''Formular-Designer''' angezeigt, wenn Sie eine [[Geräteübergreifende Anwendung|geräteübergreifende Anwendung]] erstellen:

{| border="1" frame="hsides" rules="rows"
|- valign="top"
|
'''Geräteübergreifendes Formular'''
|
[[Image:FireMonkeyForm.png|link=|Geräteübergreifendes Formular]]
|}

<f e="appmethod" />

==Stilauswahl==

[[File:Style selector.png|link=]]

Der geräteübergreifende Formular-Designer enthält eine '''Stilauswahl''' zur Auswahl des grundlegenden Plattformstils, der in der '''Master'''-Ansicht beim Entwurf verwendet wird. Die Stile basieren auf den Plattformen, auf denen eine geräteübergreifende Anwendung ausgeführt werden kann:

* Windows
* macOS
* iOS
* Android

Wählen Sie den Stil der '''Master'''-Ansicht zur Entwurfszeit aus, um alle Eigenschaften für den ausgewählten Stil/die ausgewählte Plattform anzuzeigen. Wenn Sie beispielsweise die Eigenschaft '''StyleLookup''' für [[lib_de:FMX.StdCtrls.TButton|TButton]] für ein Android-Gerät festlegen möchten, wählen Sie den Stil '''Android''' aus. Daraufhin enthält das Dropdown-Menü des '''[[Objektinspektor|Objektinspektors]]''' für die Eigenschaft '''StyleLookup''' die für das Android-Gerät verfügbaren Optionen.

==Ansichtsauswahl==

Der geräteübergreifende '''Formular-Designer''' enthält eine '''Ansichtsauswahl''', ein Dropdown-Menü, das alle '''verfügbaren''' Ansichten enthält, die verschiedene Geräte, wie spezielle iOS-, Android-, Windows- und OS X-Geräte, repräsentieren. Nach Auswahl von Ansichten aus der Liste '''Verfügbar''' für Ihr Projekt werden die Ansichten der Liste '''Erstellt''' hinzugefügt. Siehe '''[[Verwenden von FireMonkey-Ansichten|Verwenden von {{FM}}-Ansichten]]'''.

[[File:View selector.png|link=]]

Die '''Ansichtsauswahl''' enthält die folgenden Steuerelemente:

{| border="1" frame="hsides" rules="rows"
|-
! ''' Symbol '''
! ''' Beschreibung '''
|-
| style="text-align: left; vertical-align: top;" |
[[File:ViewSelectorMenu.png|link=]]
| style="text-align: left; vertical-align: top;" |
Wählt das aktuelle Ansicht aus einer Dropdown-Liste mit Ansichten aus.
Sie können Ihrem Projekt eine oder mehrere Ansichten hinzufügen, indem Sie einfach in der Liste '''Verfügbar''' auf die gewünschte Ansicht klicken. Siehe [[Hinzufügen von Ansichten zu einem geräteübergreifenden Projekt|Hinzufügen von Ansichten zu einem geräteübergreifenden Projekt]].
Sie können auch angepasste Ansichten erstellen und sie der '''Ansichtsauswahl''' hinzufügen. Siehe [[Hinzufügen einer angepassten Ansicht zur Ansichtsauswahl|Hinzufügen einer angepassten Ansicht zur Ansichtsauswahl]].
|-
| style="text-align: left; vertical-align: top;" |
[[File:RemoveViewIcon.png|link=]] '''Ansicht entfernen'''
| style="text-align: left; vertical-align: top;" |
Entfernt die aktuelle Ansicht. Das Dialogfeld '''Bestätigen''' wird angezeigt.
Die Ansicht wird aus dem Quelltext entfernt.
|-
| style="text-align: left; vertical-align: top;" |
[[File:RotateCurrentView.png|link=]] '''Aktuelle Ansicht drehen'''
| style="text-align: left; vertical-align: top;" |
Dreht die aktuelle Ansicht im Uhrzeigersinn um 90 Grad. Nur für mobile Ansichten (nicht für Desktop-Ansichten) verfügbar.
|-
| style="text-align: left; vertical-align: top;" |
[[File:HideShowFormFrame.png|link=]] '''Formularrahmen aus- oder einblenden'''
| style="text-align: left; vertical-align: top;" |
Blendet den Rahmen einer ausgewählten Ansicht aus (oder blendet einen zuvor ausgeblendeten Rahmen ein).
|}

==Visuelle Komponenten==

Sie können einem {{f|appmethod|geräteübergreifenden}} {{f|radstudio|geräteübergreifenden oder VCL-}}Formular visuelle Komponenten hinzufügen, indem Sie ausgewählte Komponenten aus der '''[[Tool-Palette|Tool-Palette]]''' unten rechts in der IDE in das Formular ziehen. Unter visuellen Komponenten versteht man die Elemente, die für den Endbenutzer zur Laufzeit sichtbar sind. Die in der '''Tool-Palette''' verfügbaren Objekte ändern sich dynamisch je nach dem Typ der erstellten Anwendung bzw. des erstellten Formulars.

Für jede der zahlreichen Tool-Kategorien enthält die '''[[Tool-Palette|Tool-Palette]]''' Steuerelemente, wie z. B. Schaltflächen, Beschriftungen, Symbolleisten und Listenfelder. Während der Arbeit auf Projektebene stehen verschiedene Anwendungstypen zur Auswahl (z. B. DLL-Experten und Konsolen- bzw. Logo-Anwendungen). Wenn Sie eine Webanwendung erstellen, sind Web-Steuerelemente, HTML-Elemente und Datenkomponenten verfügbar.

Eigenschaften und Ereignisse für visuelle und nicht-visuelle Komponenten können Sie im Formular-Designer mit dem '''[[Objektinspektor|Objektinspektor]]''' anzeigen und festlegen.

==Nicht-visuelle Komponenten==

Nicht-visuelle Komponenten, wie z. B. [[lib_de:FMX.Types.TCustomTouchManager.GestureManager|GestureManager]], werden dem Formular während des Entwurfs hinzugefügt, sind aber zur Laufzeit für den Endbenutzer nicht sichtbar. Die nicht-visuellen Komponenten lassen sich für die Wiederverwendung von Datenbankgruppen und Systemobjekten einsetzen, um jene Teile einer Anwendung zu isolieren, die die Datenbankverbindung und die Geschäftsregeln behandeln.

In der IDE können Sie nicht-visuelle Komponenten beim Entwurf [[Nicht-visuelle Komponenten ausblenden|ein- oder ausblenden]].

==Kontextmenü==

Wenn Sie im '''Formular-Designer''' mit der rechten Maustaste auf ein Formular klicken, wird das Kontextmenü angezeigt. {{f|radstudio|Sofern nicht anders in der Tabelle angegeben, sind die Kontextmenübefehle für die VCL und {{FM}} verfügbar.}}

{{Note|In diesem Abschnitt werden nur Kontextmenübefehle für das Bearbeiten von Formularen beschrieben. Informationen zum Kontextmenü von Datenmodulen finden Sie unter [[Standard-Datenmodule erstellen und bearbeiten#Kontextmenü für Datenmodule|Kontextmenü für Datenmodule]].}}

{| border="1" frame="hsides" rules="rows"
|-
! '''Element'''
! '''Beschreibung'''
|- valign="top"
|
Eintrags-Editor
(bestimmte {{FM}}-Komponenten)
|
Öffnet den '''Eintrags-Designer''' mit dem Fokus auf dem ausgewählten Steuerelement.
|- valign="top"
|
Eintrag hinzufügen
(bestimmte {{FM}}-Komponenten)
|
Ermöglicht das Hinzufügen eines Eintrags zu dem auf dem Formular ausgewählten Steuerelement. Wenn Sie z. B. einem geräteübergreifenden Formular ein [[lib_de:FMX.Edit.TEdit|TEdit]]-Steuerelement hinzufügen, können Sie mit der rechten Maustaste auf das TEdit-Steuerelement klicken, '''Eintrag hinzufügen''' auswählen, und eine eingebettete Glyphe, wie TPasswordEditButton, hinzufügen.
|- valign="top"
|
Bearbeiten
|
Das Untermenü enthält die folgenden Bearbeitungsbefehle:
* Rückgängig
* Ausschneiden
* Kopieren
* Einfügen
* Löschen
* Alles markieren
|- valign="top"
|
Element
|
Steuert die Hintergrund-/Vordergrundebenen des ausgewählten Steuerelements. Das Untermenü enthält die folgenden Befehle:
* [[Nach vorne setzen|Nach vorne setzen]]
* [[Nach hinten setzen|Nach hinten setzen]]
|- valign="top"
|
[[LiveBindings-Experte|LiveBindings-Experte]]
(nur wenn in '''Tools > Optionen > LiveBindings''' aktiviert)
|
Öffnet den '''[[LiveBindings-Experte|LiveBindings-Experten]]'''.
|- valign="top"
|
[[LiveBindings-Designer|Visuell binden...]]
|
Öffnet den '''[[LiveBindings-Designer|LiveBindings-Designer]]'''.
|- valign="top"
|
Position
|
Legt die Ausrichtung, Größe und Skalierung des ausgewählten Steuerelements fest. Das Untermenü enthält die folgenden Befehle:
* [[Am Raster ausrichten|Am Raster ausrichten]].
* Ausrichten. Öffnet das Dialogfeld [[Ausrichtung (Formular-Designer)|Ausrichtung]].
* Größe. Öffnet das Dialogfeld [[Größe|Größe]]. {{f|radstudio|
* Skalierung. Öffnet das Dialogfeld [[Skalierung|Skalierung]] (nur für VCL-Formulare verfügbar). }}
|- valign="top"
|
[[Untergeordnete Elemente vertauschen|Untergeordnete Elemente vertauschen]]
|
Vertauscht rechts und links. Das Untermenü enthält die folgenden Befehle:
* Alle – Vertauscht alle Elemente in dem Formular.
* Ausgewählte – Vertauscht nur die ausgewählten Elemente.
|- valign="top"
|
Tabulatorreihenfolge
|
Öffnet das Dialogfeld [[Tabulatorreihenfolge bearbeiten|Tabulatorreihenfolge bearbeiten]].
|- valign="top"
|
Erstellungsfolge
(nicht-visuelle Komponenten)
|
Öffnet das Dialogfeld [[Erstellungsfolge|Erstellungsfolge]].
|- valign="top"
|
[[Nicht-visuelle Komponenten ausblenden|Nicht-visuelle Komponenten ausblenden]]
|
Ermöglicht die [[Nicht-visuelle Komponenten ausblenden|Ein- oder Ausblendung]] der nicht-visuellen Komponenten beim Entwurf.
|- valign="top"
|
[[Geerbte Einstellungen wiederherstellen|Geerbte Einstellungen wiederherstellen]]
|
Setzt die Eigenschaften, Methoden und Ereignisse des ausgewählten Steuerelements auf die Werte der Basisklasse des Steuerelements zurück. Siehe [[Geerbte Einstellungen wiederherstellen|Geerbte Einstellungen wiederherstellen]].
|- valign="top"
|
Der Objektablage hinzufügen
|
Öffnet das Dialogfeld [[Der Objektablage hinzufügen|Der Objektablage hinzufügen]].
|- valign="top"
|
[[Ansicht als Text|Ansicht als Text]]
|
Öffnet die aktuelle Formulardatei im [[Quelltext-Editor|Quelltext-Editor]] als Text. Siehe [[Ansicht als Text|Ansicht als Text]].
|- valign="top"
|
[[Text-DFM oder Text-FMX|Text-FMX]]{{f|vcl| 
(geräteübergreifende Formulare) 
 
[[Text-DFM oder Text-FMX|Text-DFM]] 
(VCL-Formulare)}}
|
Speichert die Formulardatei entweder in der Textform (aktiviert) oder in der Binärform (deaktiviert). Siehe [[Text-DFM oder Text-FMX|Text-DFM oder Text-FMX]].
|- valign="top"
|
Standardstil bearbeiten
 
Benutzerdefinierten Stil bearbeiten
({{FM}}-Desktop-Steuerelemente)
|
Öffnet den '''[[FireMonkey-Stil-Designer|FireMonkey-Stil-Designer]].'''
Weitere Informationen dazu finden Sie unter [[Anpassen von FireMonkey-Anwendungen mit Stilen|Anpassen von FireMonkey-Anwendungen mit Stilen]].
|- valign="top" {{fr|vcl}}
|
Testdialog
(nur VCL)
|
Testet modale VCL-Dialogfelder. Wenn Sie im Formular-Designer mit der rechten Maustaste auf eine OpenDialog-Komponente klicken, und '''Testdialog''' auswählen, wird das Standarddialogfeld "Datei öffnen" angezeigt.
|}

==Tastenkombinationen im Formular-Designer==

Mit den folgenden Tastenkombinationen können Sie die Komponenten im Formular-Designer verschieben und deren Größe ändern.

{|
|-
!'''Tastenkombination'''
!'''Aktion'''
|-
|
<code>STRG + Mausauswahlbereich</code>
|
Markiert alle untergeordneten Steuerelemente eines übergeordneten Steuerelements, die innerhalb des mit der Maus ausgewählten Bereichs liegen.
|-
|
<code>UMSCHALT + Mausauwahl</code>
|
Markiert verschiedene Steuerelemente gleichzeitig. Halten Sie die Umschalt-Taste gedrückt, während Sie auf verschiedene Steuerelemente zur Auswahl klicken.
|-
|
<code>STRG+Pfeiltaste</code>
|
Verschiebt die markierte Komponente langsam
|-
|
<code>STRG+UMSCHALT+Pfeiltaste</code>
|
Verschiebt die Komponente schneller
|-
|
<code>TAB</code> oder <code>Pfeiltaste</code>
|
Verschiebt den Fokus zwischen den Komponenten
|-
|
<code>UMSCHALT+Pfeiltaste </code>
|
Ändert die Größe der Komponente
|-
|
<code>ESC </code>
|
Markiert die übergeordnete Komponente
|-
|
<code>STRG+TAB </code>
|
Wechselt zur nächsten Bearbeitungsregisterkarte
|-
|
<code>STRG+UMSCHALT+TAB</code>
|
Wechselt zur vorherigen Bearbeitungsregisterkarte
|}

==Neue Richtlinien und Funktionen==

Der '''FireMonkey-Stil-Designer''' erhielt in Olympus Richtlinien und andere Funktionen, die im VCL-Designer mit einer anderen Implementierung vorhanden sind. Dazu zählen:

1. Hinweise zu Komponenten werden angezeigt, wenn Sie diese verschieben oder deren Größe ändern.

[[File:Components olympus 1.png|300px]]

2. Für Steuerelemente sind Richtlinien für die seitliche Ausrichtung vorhanden (eine Basistextausrichtung ist nicht geplant, da die Textpositionierung für mit Stilen versehene Steuerelemente sehr komplex ist):

[[File:Components olympus 2.png|300px]]

3. Für Steuerelemente wird der Standardrandabstand mit einer Querlinie und einer Abstandsangabe angezeigt, wenn dies mit dem Rand- oder Innenabstand übereinstimmt:

[[File:Components olympus 3.png|200px]]

4. Die Steuerelemente für die Größenanpassung von Formularen und Komponenten (Griffe, wenn ein Steuerelement ausgewählt ist, und der Designrand des Formulars oder Frames, dessen Größe geändert werden soll) wurden so geändert, dass sie das gleiche Erscheinungsbild wie im VCL-Formular-Designer haben.

==Siehe auch==

* [[Optionen für den Formular-Designer|Optionen für den Formular-Designer]].
* [[High DPI|High DPI]]
* [[Mobile-Tutorial: Verwenden von Schaltflächen-Komponenten mit unterschiedlichen Stilen (iOS und Android)|Mobile-Tutorial: Verwenden von Schaltflächen-Komponenten mit unterschiedlichen Stilen (iOS und Android)]]

<f s="appmethod" />

* [[Ein erster Blick auf die IDE - Index (IDE-Tutorial)|Ein erster Blick auf die IDE]]
* [[Hinzufügen von Komponenten im Formular-Designer (IDE-Tutorial)|Komponenten in ein Formular einfügen]]
* [[Quelltext-Editor|Quelltext-Editor]]

<f e="appmethod" />

* [[Verwenden von FireMonkey-Ansichten|Verwenden von FireMonkey-Ansichten]]

<f s="radstudio" />

* [[Ein erster Blick auf die IDE|Ein erster Blick auf die IDE]]
* [[Quelltext-Editor|Quelltext-Editor]]
* [[Neues Editierfenster|Neues Editierfenster]]
* [[Ein Projekt starten - Überblick|Ein Projekt starten - Überblick]]
* [[Komponenten in ein Formular einfügen|Komponenten in ein Formular einfügen]]
* [[Eigenschaften und Ereignisse festlegen|Eigenschaften und Ereignisse festlegen]]
* [[Designrichtlinien (Nur VCL)|Designrichtlinien (Nur VCL)]]
* [[Designer-Richtlinien für VCL-Komponenten verwenden|Designer-Richtlinien für VCL-Komponenten verwenden]]
* [[Momentaufnahmen von Formularen erstellen (Nur VCL)|Momentaufnahmen von Formularen erstellen (Nur VCL)]]
* [[Formularvorschau|Formularvorschau]]

<f e="radstudio" />

* [[Geräteübergreifende Vorschau|Geräteübergreifende Vorschau]]
* [https://www.youtube.com/watch?v=XELph3rB25Y&index=8&list=PLwUPJvR9mZHikVu-FgmXg2ajAagF8OPgh YouTube: FireUI Multi-Device Designer (EN)]

[[Category:Delphi]]
[[Category:C++]]
[[Category:Mit RAD Studio arbeiten]]
[[Category:AMMigrate]]

[[en:Form Designer]]
[[fr:Concepteur de fiches]]
[[ja:フォームデザイナ]]

FireMonkey 3D

2022-09-30T19:28:54Z

Rrivero: RS-78784. Removed TVideo3D component

{{Parent|FireMonkey-Anwendungshandbuch}}

==3D-Einführung==

{{FM}} enthält 2D-Ansichten von Objekten im 3D-Raum. In einem [[lib_de:FMX.Viewport3D.TViewport3D|TViewport3D]] wird 3D-Inhalt in einem eigentlichen 2D-Formular angezeigt, wohingegen ein [[lib_de:FMX.Forms3D.TForm3D|TForm3D]] mit 3D-Inhalt beginnt. 2D und 3D können [[#Mischen von 2D und 3D|verschachtelt]] werden.

Für {{FM}} 3D werden die folgenden plattformspezifischen Bibliotheken verwendet:

* Für Windows die Bibliothek '''Direct3D''' (Bestandteil von DirectX; enthalten im Unit-Gültigkeitsbereich [[lib_de:Winapi|Winapi]])
* Für den Mac die Bibliothek '''OpenGL''' (enthalten im Unit-Gültigkeitsbereich Macapi)

===3D-Objekte===

{{FM}} stellt mehrere Arten von 3D-Objekten bereit:

* Grundlegende 3D-Formen wie [[lib_de:FMX.Objects3D.TCube|TCube]], [[lib_de:FMX.Objects3D.TSphere|TSphere]] und [[lib_de:FMX.Objects3D.TCone|TCone]].
* [[lib_de:FMX.Objects3D.TMesh|TMesh]] für komplexe 3D-Objekte.
* In 3D extrudierte 2D-Objekte, wie [[lib_de:FMX.Objects3D.TText3D|TText3D]]. Diese Objekte haben drei Seiten: Die Vorderseite mit der ursprünglichen 2D-Form, die Rückseite, ein Spiegelbild dieser Form und die ''Achse'' der Extrusion zwischen diesen beiden.
* Flache 2D-Objekte im 3D-Raum, wie [[lib_de:FMX.Layers3D.TImage3D|TImage3D]] und [[lib_de:FMX.Layers3D.TTextLayer3D|TTextLayer3D]].

Objekte werden mit den X-, Y- und Z-Koordinaten mithilfe von [[lib_de:FMX.Types3D.TPosition3D|TPosition3D]] im 3D-Raum positioniert. Zusätzlich zur Höhe (Height) und Breite (Width) verfügen diese Objekte auch über eine Tiefe ([[lib_de:FMX.Controls3D.TControl3D.Depth|Depth]]). Flache 2D-Objekte im 3D-Raum sind extrem dünn mit einer fest codierten Tiefe von 0,01. 3D-Objekte verfügen über eine [[lib_de:FMX.Controls3D.TControl3D.RotationAngle|3D-Drehung]] und [[lib_de:FMX.Controls3D.TControl3D.Scale|Skalierung]]. Position, Größe, Drehung und Skalierung beziehen sich auf den Mittelpunkt des Objekts.

Wie 2D-Steuerelemente können 3D-Steuerelemente in {{FM}} jedem beliebigen anderen 3D-Steuerelement übergeordnet sein. Die Position und Drehung eines untergeordneten Objekts sind relativ zu seinem übergeordneten Objekt. Durch Bewegen oder Drehen eines übergeordneten Objekts wird die Hierarchie seiner Komponenten neu angeordnet. [[lib_de:FMX.Layers3D.TLayout3D|TLayout3D]] kann als sonst funktionsloses übergeordnetes Objekt zum Anordnen anderer Objekte verwendet werden.

Auf einer 2D-Oberfläche angeordnete 2D-Objekte benötigen zur Festlegung ihrer Schichtung eine Z-Reihenfolge, Objekte im 3D-Raum sind dagegen inhärent angeordnet, so dass von einem gegebenen Punkt aus betrachtet nähere Objekte weiter entferntere in derselben Sichtlinie verdecken.

===Kameras===

Jede Ansicht des 3D-Raums wird von einer ''Kamera'' gesteuert. Die Position und Orientierung (3D-Drehung) der Kamera legt fest, was Sie sehen. Die ''Designkamera'' ist immer vorhanden; sie wird im Formular-Designer und standardmäßig zur Laufzeit verwendet. Sie befindet sich direkt über der negativen Z-Achse (in Richtung der negativen Y-Achse), senkrecht zur X-Z-Ebene, leicht nach unten abgewinkelt, so dass sich die Position 0,0,0 in der Mitte der Ansicht befindet. Setzen Sie für eine andere Kamera die Eigenschaft ''UsingDesignCamera'' von [[lib_de:FMX.Viewport3D.TViewport3D.UsingDesignCamera|TViewport3D]] oder [[lib_de:FMX.Forms3D.TCustomForm3D.UsingDesignCamera|TForm3D]] auf False, und weisen Sie der Eigenschaft ''Camera'' ein [[lib_de:FMX.Controls3D.TCamera|TCamera]]-Objekt zu. Eine Szene kann mehrere Kameras haben. Nach dem Zuweisen einer anderen Kamera zu der Eigenschaft ''Camera'' müssen Sie ''Repaint'' manuell aufrufen.

Der sichtbare Rauminhalt ist ein ''Pyramidenstumpf'' mit der vorderen Ebene kurz vor der Kamera. Alles zwischen der Kamera und dieser vorderen Ebene ist nicht in der Ansicht enthalten. Der Winkel des ''Sichtfeldes'' ist vertikal fest: durch Vergrößern der Höhe des Bildausschnitts/Formulars wird alles größer, durch Vergrößern der Breite wird dagegen mehr von den Seitenbereichen sichtbar. Die Einheiten für Position und Größe sind relativ zur Skalierung des Sichtfeldes.

====Bildschirmprojektion====

Zusätzlich zu der Ansicht eines Objekts (oder des Nichtvorhandenseins in der Ansicht), die durch die Kamera festgelgt wird, kann ein Objekt auch so eingerichtet werden, dass es unabhängig von den Kamerapunkten immer sichtbar ist, wie feste Statusindikatoren in 3D-Spielen. Dies erfolgt durch Ändern des Standardwerts '''Camera''' der Eigenschaft [[lib_de:FMX.Controls3D.TControl3D.Projection|Projection]] in '''Screen''' mit folgendem Ergebnis:

* An Position.Z null:
** XY 0,0 ist die linke obere Ecke, genau wie in 2D. (Die 3D-Position gibt weiterhin die Position der Mitte des Objekts wieder, nicht seine linke, obere Ecke wie in 2D.)
** Die Dimensionen Höhe (Height), Breite (Width) und Tiefe (Depth) sind – unabhängig von der Skalierung des Sichtfeldes – in Pixel angegeben.
** Weil die Einheiten als Pixel gerendert werden, müssen die Dimensionen eines Objekts mit Bildschirmprojektion deutlich größer sein als bei der Kameraprojektion, um in derselben Größe zu erscheinen.
** Das Objekt erscheint etwas hinter der vorderen Clipping-Ebene des Pyramidenstumpfs. Objekte, die die Kameraprojektion verwenden, haben eine schmale Lücke, in der sie vor auf dem Bildschirm projizierten Objekten erscheinen können, bevor sie durch die vordere Ebene abgeschnitten werden.
* An Position.Z größer als null (vom Betrachter weg):
** Die gerenderte Größe ist kleiner.
** Durch Verkleinern der Ansicht wird das Objekt weiter in den Hintergrund verlagert, und es erscheint noch kleiner.
** Durch Vergrößern der Ansicht wird das Objekt weiter in den Vordergrund verlagert, und es erscheint größer.
* An Position.Z kleiner als null (zum Betrachter hin):
** Die gerenderte Größe ist größer.
** Durch Verkleinern der Ansicht wird das Objekt weiter in den Vordergrund verlagert, und es erscheint noch größer.
** Durch eine zu weite Verlagerung des Objekts in den Vordergrund – entweder durch Verkleinerung der Ansicht oder direkte Angabe von Position.Z – wird das Objekt vor die vordere Ebene des Pyramidenstumpfs verlagert und verschwindet dadurch aus der Ansicht.
** Durch Vergrößern der Ansicht wird das Objekt weiter in den Hintergrund verlagert, und es erscheint kleiner.

Durch Ändern der Projektion eines Objekts im Formular-Designer wird dessen Position neu berechnet, damit es nicht verschoben wird, sowie dessen Größe angepasst.

====Kamerakran====

Das vom Benutzer gesteuerte Anzeigen eines Objekts oder einer Szene aus allen Richtungen ist eine häufige 3D-Anwendung. Obwohl Sie die Position und Ausrichtung für den korrekten Kamerawinkel berechnen können, ist es einfacher, einen virtuellen Kamerakran zu erstellen:

# Erstellen Sie an derselben Position wie das betreffende Objekt oder in der Mitte der Szene ein unsichtbares Objekt, wie z.B. ein [[lib_de:FMX.Objects3D.TDummy|TDummy]].
# Erstellen Sie ein TCamera-Objekt als untergeordnetes Element des Objekts.
## Setzen Sie dessen Position auf den gewünschten Abstand auf einer der Achsen.
## Setzen Sie bei Bedarf die Eigenschaft '''RotationAngle''', damit die Kamera entlang der Achse zurück auf die Position zeigt. Stellen Sie sicher, dass die Kamera nicht verkehrt herum aufgestellt ist.
# Jetzt können Sie durch einfaches Ändern der Eigenschaft '''RotationAngle''' des Dummy-Objekts die Kamera um das Objekt drehen. Die Kamera behält den exakten Abstand bei und zeigt automatisch direkt auf die Mitte.
# Durch Hinzufügen von Licht als untergeordnetes Element der Kamera wird der Abstand und die Ausrichtung des Lichtes beim Bewegen der Kamera beibehalten.

===Licht===

Im Allgemeinen ist ein 3D-Objekt eine strukturlose schwarze Masse, außer wenn es von Licht beschienen wird. Ein oder mehrere [[lib_de:FMX.Controls3D.TLight|TLight]]-Objekte definieren abhängig von ihrer Eigenschaft [[lib_de:FMX.Controls3D.TLight.LightType|LightType]] Licht im 3D-Raum:

; Directional
: Direktionales Licht ist aus einem gegebenen Winkel konstant. Licht von der Sonne ist eine allgemeine Analogie dazu: es kommt von sehr weit her, daher werden für jeden beliebigen festgelegten Ort auf der Erde – Meter im Durchmesser, nicht Kilometer – alle Elemente gleich beleuchtet. Die Position von direktionalem Licht ist für seinen Effekt irrelevant. (Seine Position ist relevant, wenn Sie versuchen, im Formular-Designer darauf zu klicken.) Wichtig ist die Richtung, in der das Licht scheint, was von seinem '''RotationAngle''' und dem '''RotationAngle''' des übergeordneten Objekts definiert wird.
; Point
: Punktlicht ist mit einer nackten Glühbirne vergleichbar. Es strahlt in alle Richtungen und nimmt mit der Entfernung ab. Sein '''RotationAngle''' hat keine Auswirkung. Wichtig ist seine Position, die von der Position und Drehung seiner übergeordneten Objekte beeinflusst wird.
; Spot
: Scheinwerferlicht ist von der Position und Drehung abhängig und nimmt mit der Entfernung ab.

Flache 2D-Objekte im 3D-Raum benötigen weder Licht noch werden sie von Licht beeinflusst. Sie werden in der Regel mit einer hinzugefügten 3D-Perspektive angezeigt.

===Materialien===

Die Oberfläche eines {{FM}}-3D-Objekts wird durch sein ''Material'' definiert. {{FM}}-3D-Materialien basieren auf Schattierern. Dies ermöglicht eine unbegrenzte Variation von Licht und Materialien in einer Anwendung. Die Liste der verfügbaren Materialien befindet sich in der [[Tool-Palette|Tool-Palette]] in der Kategorie '''Materialien'''. Jedes {{FM}}-3D-Objekt verfügt über die Eigenschaft [[lib_de:FMX.Objects3D.TShape3D.MaterialSource|MaterialSource]], die eine Materialquelle mit dem aktuellen Objekt verknüpft. Mit [[lib_de:FMX.MaterialSources.TMaterialBook|TMaterialBook]] können Sie eine Bibliothek mit Materialen erstellen und verwalten. Zur Verwendung eines Materials können Sie die Quelle mit beliebig vielen Objekten verknüpfen.

Extrudierte Objekte haben die zusätzlichen Eigenschaften [[lib_de:FMX.Objects3D.TExtrudedShape3D.MaterialShaftSource|MaterialShaftSource]] und [[lib_de:FMX.Objects3D.TExtrudedShape3D.MaterialBackSource|MaterialBackSource]]. Diese Eigenschaften haben den Typ [[lib_de:FMX.MaterialSources.TMaterialSource|TMaterialSource]].

Um zu steuern, wie ein Objekt unter dem Einfluss von Licht erscheint, verknüpfen Sie es mit einem [[lib_de:FMX.MaterialSources.TLightMaterialSource|TLightMaterialSource]]-Objekt:

* Eine [[lib_de:FMX.MaterialSources.TLightMaterialSource.Emissive|ausstrahlende (Emissive)]] Farbe bestimmt, ob eine Oberfläche eigenes Licht abgibt oder leuchtet. Der Standardwert ist null (keine Opazität, schwarz): Objekte leuchten normalerweise nicht und erfordern Licht, damit sie gesehen werden. Durch Setzen einer Farbe erscheinen Oberflächen ohne Licht in dieser Farbe. Wenn sie beleuchtet werden, wird die ausstrahlende Farbe mit den anderen aus dem Licht resultierenden Farben überblendet.
* Eine [[lib_de:FMX.MaterialSources.TLightMaterialSource.Ambient|umgebende (Ambient)]] Farbe soll eine Grundfarbe für Oberflächen bereitstellen, damit sie gesehen werden können. In der realen Welt wird Licht von vielen Richtungen auf eine Oberfläche reflektiert; aber in der 3D-Szene wäre es äußerst schwierig all dieses Licht zu definieren. Daher wird die umgebende Farbe von jedem beliebigen Licht im Raum aktiviert. (Ohne Licht hat sie keine Auswirkung.) Die Oberfläche wird völlig gleichförmig in dieser Farbe dargestellt. Mit direktionalem Licht – das nicht auf die Oberfläche gerichtet sein muss – würde alles flach aussehen. Mit Punkt- oder Scheinwerferlicht werden die Farben mit der Entfernung schwächer.
* Eine [[lib_de:FMX.MaterialSources.TLightMaterialSource.Diffuse|diffuse (Diffuse)]] Farbe interagiert direkt mit Licht und mit dem Einfallswinkel des Lichts. Ohne Licht hat sie keine Auswirkung. In der Regel werden '''Ambient''' und '''Diffuse''' auf dieselbe Farbe gesetzt.
* Eine [[lib_de:FMX.MaterialSources.TLightMaterialSource.Specular|reflektierende (Specular)]] Farbe simuliert eine glänzende Oberfläche, indem in einem bestimmten Winkel einfallendes Licht reflektiert wird, anstatt Licht in vielen Winkeln zu vermischen. Ohne Licht hat '''Specular''' keine Auswirkung. Die Vorgabe ist weiß, damit das Licht ohne Verändern seiner Farbe reflektiert werden kann.

==Mischen von 2D und 3D==

3D-Objekte müssen in einen 3D-Container platziert werden. Ein 3D-Objekt (wie TCube) wird nicht gerendert, wenn es direkt in einen 2D-Container (wie TForm) gesetzt wird, aber es wird in der [[Strukturansicht|Strukturansicht]] als untergeordnetes Steuerelement angezeigt. Umgekehrt werden 2D-Objekte (wie TButton) nicht gerendert, wenn sie direkt in einen 3D-Container (wie TForm3D) platziert werden, aber sie werden in der [[Strukturansicht|Strukturansicht]] als untergeordnete Steuerelemente angezeigt. Zwei Klassen ermöglichen ein verschachteltes Mischen von 2D- und 3D-Inhalt:

* [[lib_de:FMX.Layers3D.TLayer3D|TLayer3D]] ist ein 3D-Objekt mit 2D-Inhalt. Es entspricht einer rechteckigen Glasscheibe im 3D-Raum.
* [[lib_de:FMX.Viewport3D.TViewport3D|TViewport3D]] ist ein 2D-Objekt mit 3D-Inhalt. Wie TForm3D ist es ein "Fenster" in den 3D-Raum.

Sie können diese Container verschachteln. Sie können z.B. eine Objekthierarchie wie die folgende erstellen:

* TForm3D
** TCube
** TLayer3D
*** TButton
*** TViewport3D
**** TCube

Darüber hinaus gibt es einige 3D-Klassen, die 2D-Inhalt aufnehmen:

* TTextLayer3D zeigt Text an.
* TImage3D zeigt Bitmap-Bilder an.

==Importieren von 3D-Modellen==

Das {{FM}}-Framework unterstützt den Import von 3D-Modellen. 3D-Modelle können nur in 3D-Containern gerendert werden. Verwenden Sie zum Importieren eines 3D-Modells [[lib_de:FMX.Objects3D.TModel3D|TModel3D]]-Objekte. [[lib_de:FMX.Objects3D.TModel3D|TModel3D]] befindet sich in der [[Tool-Palette|Tool-Palette]]. Verwenden Sie zum Laden eines Objekts die Eigenschaft [[lib_de:FMX.Objects3D.TModel3D.MeshCollection|MeshCollection]] von [[lib_de:FMX.Objects3D.TModel3D|TModel3D]]. Folgende 3D-Dateien werden unterstützt: '''.obj''', '''.dae''' und '''.ase'''.

Die Modelle werden mit Textur importiert und angezeigt. Wenn in der Szene kein Licht vorhanden ist, ist die Textur nicht sichtbar. Grundlegende Merkmale von importierten Modellen können, wie bei jedem anderen 3D-Objekt, bearbeitet werden (drehen, verschieben, skalieren und Größe ändern).

Die korrekte Anzeige von geladenen Modellen hängt von der Beschaffenheit und Korrektur der geladenen Datei ab.

==Siehe auch==

* [[FireMonkey-Anwendungsdesign|FireMonkey-Anwendungsdesign]]
* [[Geräteübergreifende 3D-Anwendung|{{FM}} 3D-Anwendungsexperte]]
* [[Tutorial: Erstellen einer FireMonkey 3D-Anwendung|Tutorial: Erstellen einer FireMonkey 3D-Anwendung]]
* [[Tutorial: Verwenden von Kameras in einer FireMonkey 3D-Anwendung|Tutorial: Verwenden von Kameras in einer FireMonkey 3D-Anwendung]]
* [[Experten zum Erstellen von geräteübergreifenden FireMonkey-Anwendungen und -Komponenten|Experten zum Erstellen von geräteübergreifenden FireMonkey-Anwendungen und -Komponenten]]
* [[FireMonkey Quick Start - Erstellen von 3D-Anwendungen|FireMonkey Quick Start - Erstellen von 3D-Anwendungen]]

==Codebeispiele==

* [[samp_en:FMX.AnimationDemoHD Sample|{{FM}} HD Animation]] (Beispiel)
* [[samp_en:FMX.AnimationDemo3D Sample|{{FM}} 3D Animation]] (Beispiel)
* [[samp_en:FMX.Gyroscope Sample|{{FM}} Gyroscope]] (Beispiel)
* [[samp_en:FMX.Arrows3D Sample|{{FM}} 3D Arrows]] (Beispiel)
* [[samp_en:FMX.FirstApp3D Sample|{{FM}} First App3D]] (Beispiel)
* [[samp_en:OpenGL Multicolor Tetrahedron (C++)|OpenGL Multicolor Tetrahedron (C++)]] (Beispiel)

[[Category:XE3]]
[[Category:FMX]]
[[Category:AMMigrate]]

[[en:FireMonkey 3D]]
[[fr:FireMonkey 3D]]
[[ja:FireMonkey 3D]]

Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Windows-PC (iOS)

2022-08-17T20:28:37Z

Rrivero: RS-114036. Updated screenshots and path names (Aktualisierte Screenshots und Pfadnamen)

{{Parent|Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)}}

Bevor Sie mit diesem Tutorial beginnen, sollten Sie das folgende Tutorial durcharbeiten:

* '''[[Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Mac (iOS)|Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Mac (iOS)]]'''

__TOC__

{{FM}}-Anwendungen für die iOS-Zielplattform können mit dem '''iOS-Simulator''' auf dem Mac getestet werden. Im zweiten Teil des Tests wird die Zielplattform '''iOS-Gerät''' verwendet, für die aber ein Test-iOS-Gerät am Mac angeschlossen sein muss.

: {{Note| Auf iOS-Geräten können Sie {{Delphi}}- und C++-Anwendungen ausführen. Der '''iOS-Simulator''' wird allerdings nicht von '''BCCIOSARM''' unterstützt, daher werden nur iOS-Geräte für C++ unterstützt.}}

Für die Bereitstellung einer iOS-Anwendung auf einem iOS-Gerät oder dem iOS-Simulator zum Debuggen und Testen verwendet {{Product}} den '''[[PAServer: Die Platform Assistant Server-Anwendung|Platform Assistant]]''', den Sie auf dem Mac [[Installieren des Platform Assistant auf dem Mac|installieren]] und [[Ausführen des Platform Assistant auf dem Mac|ausführen]] müssen. Ihre Hardware- und Software-Entwicklungsumgebung sollte wie in der folgenden Abbildung dargestellt konfiguriert sein. {{Product}} wird auf einem Windows-PC ausgeführt. Ihr PC muss mit einem Mac verbunden sein, auf dem der '''[[PAServer: Die Platform Assistant Server-Anwendung|Platform Assistant]]''' ausgeführt wird und die geeigneten Versionen von '''[[Installieren von Xcode auf einem Mac|Xcode]]''' und dem iOS SDK (für die iOS-Entwicklung) installiert sind. Um iOS-Apps auf einem iOS-Gerät auszuführen, muss das iOS-Gerät über ein USB-Kabel an den Mac angeschlossen sein.

[[File:Win2Mac2iOSDevice.png|650px]]

In diesem Abschnitt werden die Schritte zum Einrichten der Entwicklungsumgebung '''nach''' der Konfiguration der Umgebung auf dem Mac beschrieben.

==Konfigurieren der {{Product}}-Umgebung==

Führen Sie die folgenden Konfigurationsschritte aus, um die iOS-Entwicklung mit {{Product}} vorzubereiten.

===[[Verbindungsprofil erstellen|Erstellen eines Verbindungsprofils]] für den Mac===

# Wählen Sie in der {{Product}}-IDE '''Tools > Optionen > Bereitstellung > [[Verbindungsprofil-Manager|Verbindungsprofil-Manager]]''' aus.
# Klicken Sie auf '''Hinzufügen''':
#:[[Datei:Connection profile manager.png|500px]] 
# Der Experte [[Verbindungsprofil erstellen|Verbindungsprofil erstellen]] wird angezeigt. Legen Sie einen Namen für das Verbindungsprofil fest, z. B. "My Mac". 
Wählen Sie als Plattform '''macOS''' aus, und klicken Sie dann auf '''Weiter''':
#: [[Datei:Create a connection profile.png|500px]] 
# Geben Sie auf der Seite '''Informationen zum Remote-Computer''' den Namen oder die IP-Adresse des Host-Macs, eine Port-Nummer (der Standard-Port 64211 funktioniert in der Regel) und ein optionales Passwort (wenn Sie eins verwenden möchten) an.
#: [[Datei:Remote machine information.png|500px]] 
# Klicken Sie auf '''Verbindung testen''', und überprüfen Sie, ob das Verbindungsprofil ohne Fehler ausgeführt wird (die Meldung '''"Verbindung zu <Hostname> auf Port <Portnummer> erfolgreich ausgeführt"''' sollte angezeigt werden).
# Wenn der '''Verbindungstest''' erfolgreich durchgeführt wurde, klicken Sie auf die Schaltfläche '''Fertig stellen'''. Falls nicht, überprüfen Sie die Einstellungen, und versuchen Sie es erneut. 

===[[Hinzufügen von SDKs für macOS oder iOS|Hinzufügen eines SDK]] zum Entwicklungssystem für das an den Mac angeschlossene iOS-Gerät===

# Öffnen Sie {{menu | Tools > Optionen > Bereitstellung > [[SDK-Manager|SDK-Manager]]}}:
#: [[Datei:Add sdk.png|500px]] 
# Klicken Sie auf '''Hinzufügen'''.
# Wählen Sie im Dialogfeld '''Neues SDK hinzufügen''' als Plattform '''iOS-Gerät - 32 Bit''' oder '''iOS-Gerät - 64 Bit''' aus.
#: [[Datei:Add new SDK.png]] 
# Nach der Plattformauswahl füllt die IDE ein Profil (wie z. B. "My Mac") und das Kombinationsfeld "SDK-Version" mit der Liste der auf dem Computer, auf dem der "Platform Assistant"-Server ausgeführt wird, verfügbaren SDK-Versionen:
#: [[Datei:SDK profile selection.png]] 
# Klicken Sie auf '''OK''', um die ausgewählte SDK-Version hinzuzufügen.
# Nachdem die Operation abgeschlossen wurde, klicken Sie auf '''Schließen''', um das Dialogfeld zu schließen.

==Siehe auch==

* [[Mobile-Tutorial: Erstellen einer Anwendung für mobile Plattformen (iOS und Android)|Mobile-Tutorial: Erstellen einer Anwendung für mobile Plattformen (iOS und Android)]]
* [[Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Mac (iOS)|Mobile-Tutorial: Konfigurieren der Entwicklungsumgebung auf dem Mac (iOS)]]
* [[Arbeiten mit einem Mac und einem PC|Arbeiten mit einem Mac und einem PC]]
* [[Ausführen von iOS-Anwendungen auf einem iOS-Gerät|Ausführen von iOS-Anwendungen auf einem iOS-Gerät]]
* [[Ausführen von iOS-Anwendungen auf dem iOS-Simulator|Ausführen von iOS-Anwendungen auf dem iOS-Simulator]]
* [[Plattformvoraussetzungen für FireMonkey|Plattformvoraussetzungen für FireMonkey]]
* [[Erstellen von iOS-Apps|Erstellen von iOS-Apps]]
* [[MacOS-Anwendungsentwicklung|MacOS-Anwendungsentwicklung]]
* [[Erstellen einer FireMonkey-Anwendung|Erstellen einer FireMonkey-Anwendung]]
* Seiten auf "Apple developer.apple.com"
** [http://developer.apple.com/library/ios/navigation/ iOS Developer Library]
** [http://developer.apple.com/library/ios/navigation/index.html?section=Resource+Types&topic=Getting+Started iOS Developer Library: Getting Started]
** [http://developer.apple.com/devcenter/ios/index.action iOS Dev Center]
** [https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/AppDistributionGuide/LaunchingYourApponDevices/LaunchingYourApponDevices.html Launching Your App on Devices]
** [https://developer.apple.com/library/ios/documentation/IDEs/Conceptual/AppDistributionGuide/Introduction/Introduction.html Preparing Your iOS App for Distribution in the App Store]
** [http://developer.apple.com/iad/ iAd Network]

[[Category:Delphi]]
[[Category:FMX]]
[[Category:IOS]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Mobile Tutorial: Set Up Your Development Environment on Windows PC (iOS)]]
[[fr:Tutoriel mobile : Définition de votre environnement de développement sur un PC Windows (iOS)]]
[[ja:モバイルチュートリアル：Windows PC に開発環境をセットアップする（iOS）]]

Datei:SDK profile selection.png

2022-08-17T20:27:19Z

Rrivero:

SDK profile selection screenshot

Datei:Add new SDK.png

2022-08-17T20:26:33Z

Rrivero:

Add new SDK profile selection screenshot

Datei:Add sdk.png

2022-08-17T20:25:16Z

Rrivero:

Add SDK screenshot

Datei:Remote machine information.png

2022-08-17T20:22:35Z

Rrivero:

Remote machine information screenshot

Datei:Create a connection profile.png

2022-08-17T20:21:30Z

Rrivero:

Create a connection profile screenshot

Datei:Connection profile manager.png

2022-08-17T20:17:25Z

Rrivero:

Connection profile manager screenshot