RAD Studio - Benutzerbeiträge [de]

Ein erster Blick auf die IDE - Index (IDE-Tutorial)

2014-09-23T14:42:44Z

Andreeah:

{{Parent|Tutorial: Die IDE für {{Delphi}} und {{CBuilder}} verwenden}}
{{f|radstudio|<blockquote>'''Hinweis:''' Lesen Sie auch das Hilfethema mit demselben Namen '''[[Ein erster Blick auf die IDE]]''' für einen Überblick der Elemente der IDE.</blockquote>}}

==Themen==
* [[Startansicht (IDE-Tutorial)|Startansicht und Willkommensseite]]
* [[Symbolleisten (IDE-Tutorial)|Symbolleisten]]
* [[Tools - Index (IDE-Tutorial)|Tools]]
** [[Optionen für eine erleichterte Bedienung (IDE-Tutorial)|Optionen für eine erleichterte Bedienung]]
** [[Formular-Designer (IDE-Tutorial)|Formular-Designer]]
** [[Tool-Palette (IDE-Tutorial)|Tool-Palette]]
** [[Objektinspektor (IDE-Tutorial)|Objektinspektor]]
** [[Projektverwaltung (IDE-Tutorial)|Projektverwaltung]]
** [[Datei-Browser (IDE-Tutorial)|Datei-Browser]]
** [[Strukturansicht (IDE-Tutorial)|Strukturansicht]]
** [[Der Quelltext-Editor - Index (IDE-Tutorial)|Der Quelltext-Editor]]
*** [[Navigation durch den Quelltext (IDE-Tutorial)|Navigation durch den Quelltext]]
*** [[Formatieren des Quellcodes (IDE-Tutorial)|Formatieren des Quellcodes]]
*** [[Code-Folding (IDE-Tutorial)|Code-Folding]]
*** [[Änderungsbalken (IDE-Tutorial)|Änderungsbalken]]
*** [[Blockkommentare (IDE-Tutorial)|Blockkommentare]]
*** [[Live-Vorlagen (IDE-Tutorial)|Live-Vorlagen]]
*** [[Sync-Bearbeitungsmodus (IDE-Tutorial)|Sync-Bearbeitungsmodus]]
*** [[Code Insight (IDE-Tutorial)|Code Insight]]
*** [[Refactoring (IDE-Tutorial)|Refactoring]]
*** [[Tastatur-Makros (IDE-Tutorial)|Tastatur-Makros]]
*** [[To-Do-Listen (IDE-Tutorial)|To-Do-Listen]]
* [[Versionsverwaltung (IDE-Tutorial)|Versionsverwaltung]]
* [[Integration von Versionskontrollsystemen in der IDE (IDE-Tutorial)|Subversion-Integration in der IDE]]
* [[Daten-Explorer (IDE-Tutorial)|Daten-Explorer]]
* [[Objektablage (IDE-Tutorial)|Objektablage]]
* [[IDE Insight (IDE-Tutorial)|IDE Insight]]

== Siehe auch ==
* [[{{Product}} – Interaktive Einführungen]] {{f|radstudio|
* '''[[Ein erster Blick auf die IDE]]''' in [[Einführung in {{Variables|Product}}]]}}
[[Category:{{Delphi}}]]
[[Category:C++]]
[[Category:AMMigrate]]

[[en:Tour of the IDE Index (IDE Tutorial)]]
[[fr:Présentation de l'EDI - Index (tutoriel de l'EDI)]]
[[ja:IDE の概要（IDE チュートリアル）：インデックス]]

FireMonkey-Funktion "Status speichern"

2014-09-23T14:27:45Z

Andreeah: Update LOC-16374

{{Parent|FireMonkey-Anwendungshandbuch}}

Die {{FM}}-Funktion '''Status speichern''' ermöglicht das Speichern von Daten, die den Status der Anwendung vor dem Schließen beschreiben. Mit den Daten des '''Speichern-Status''' kann der Zustand der Anwendung nach einem Neustart wiederhergestellt werden.

==Funktionsweise von Geräten ohne die Funktion "Status speichern"==

Wenn sich auf mobilen Geräten, insbesondere auf Android-Plattformen, eine Anwendung im Hintergrund befindet, könnte das Betriebssystem den Prozess abbrechen. Dies kann aufgrund bestimmter Bedingungen erfolgen, wie z. B. wenig Arbeitsspeicher oder einfach, weil zu viele Prozesse ausgeführt werden. In diesem Fall verbleiben die vom Benutzer eingegebenen Informationen nicht in der Anwendung.

Auf Android wird durch Aktivieren der Option '''Aktionen nicht speichern''' unter '''Einstellungen > Entwickleroptionen''' die Anwendung neu gestartet, wenn die Home-Taste gedrückt und dann zurück zur Anwendung gewechselt wird. Alle zuvor eingegeben Daten sind dann verloren.

Um dieses Problem zu beheben, stellt Android einen besonderen Speicher, "SaveState", zur Verfügung, in dem der Status der Anwendung gespeichert und wiederhergestellt werden kann, wenn die Anwendung neu gestartet wird. Die Speicherung dieses Status ist nur "temporär"; wenn Sie die Anwendung manuell oder über den Task-Manager schließen und dann erneut starten, ist der vorherige "temporäre" Status verloren.

Nach dem Neustart einer Anwendung wäre es praktisch, wenn die Anwendung in demselben Zustand verbliebe, in dem sie sich vor dem Versetzen in den Hintergrund befunden hat.

==Funktion "Status speichern" in {{FM}}==

Die {{FM}}-Funktion '''Status speichern''' ermöglicht das Speichern von Daten mit dem Status der Anwendung vor dem Schließen. Mit den Daten des '''Speichern-Status''' kann der Zustand der Anwendung nach einem Neustart wiederhergestellt werden.

Der '''Speichern-Status''' kann Informationen, wie aktive Registerkarte, in Steuerelementen enthaltener Text, Auswahl von Kontrollkästchen, Kalenderdatum, aktuell ausgewählter Eintrag usw., sowie weitere Daten enthalten.

Die {{FM}}-Funktion '''Status speichern''' implementiert einen Mechanismus zur Verarbeitung des temporären "SaveState"-Android-Mechanismus und des persistenten '''Speichern-Status''', indem Daten auf der Festplatte gespeichert werden. Auf Nicht-Android-Plattformen emuliert diese Funktion einen temporären '''Speichern-Status''', bei dem Dateien an temporären Speicherorten und der persistente Status an dem gewünschten Speicherort gespeichert werden.

Das Verhalten dieser Funktion auf Desktop-Plattformen entspricht dem Verhalten auf mobilen Plattformen, d. h., der '''Speichern-Status''' speichert den Anwendungsstatus. Es ist aber nicht gewährleistet, dass die Speicherung persistent ist; wenn Sie beispielsweise die temporäre Datei, in der diese Informationen gespeichert sind, auf Windows löschen, startet die Anwendung neu, ohne den Status wiederherzustellen, den sie vor dem Schließen hatte.

Für die Behandlung des Speicherns dieser Daten stellt TForm das Ereignis [[lib_de:FMX.Forms.TCommonCustomForm.OnSaveState|OnSaveState]] bereit: alle Formulardaten sollten während dieses Ereignisses gespeichert werden, damit sie beim Neustart der Anwendung wiederhergestellt werden können.

Von [[lib_de:FMX.Forms.TCommonCustomForm|TCommonCustomForm]] abgeleitete {{FM}}-Formulare, wie [[lib_de:FMX.Forms.TForm|TForm]] und [[lib_de:FMX.Forms3D.TForm3D|TForm3D]], verfügen über die Eigenschaft [[lib_de:FMX.Forms.TCommonCustomForm.SaveState|SaveState]] mit dem Typ [[lib_de:FMX.Forms.TFormSaveState|TFormSaveState]] zur Verwaltung des '''Speichern-Status'''. Die Klasse '''TFormSaveState''' stellt Methoden und Eigenschaften zur Verwaltung des '''Speichern-Status''' des Formulars bereit, Die Klasse verwendet den Dienst [[lib_de:FMX.Platform.IFMXSaveStateService|IFMXSaveStateService]], der die erforderliche Funktionalität für das [[lib_de:FMX.Platform.IFMXSaveStateService.GetBlock|Ermitteln]] und [[lib_de:FMX.Platform.IFMXSaveStateService.SetBlock|Setzen]] des '''Speichern-Status''' auf der Zielplattform definiert.

===Speicher-Stream===

In der Eigenschaft [[lib_de:FMX.Forms.TFormSaveState.Stream|SaveState.Stream]] wird der Speicher-Stream als [[lib_de:System.Classes.TMemoryStream|TMemoryStream]] gespeichert. Diese Eigenschaft kann jederzeit gelesen und/oder geschrieben werden, obwohl:

* Das '''Schreiben''' von Daten in den [[lib_de:FMX.Forms.TFormSaveState.Stream|Stream]] vorzugsweise während des Ereignisses [[lib_de:FMX.Forms.TCommonCustomForm.OnSaveState|OnSaveState]] erfolgen sollte.
* Das '''Lesen''' von Daten aus dem [[lib_de:FMX.Forms.TFormSaveState.Stream|Stream]] vorzugsweise während des Ereignisses [[lib_de:FMX.Forms.TCommonCustomForm.OnCreate|OnCreate]] erfolgen sollte.

Sie können Hilfsklassen, wie [[lib_de:System.Classes.TBinaryReader|TBinaryReader]] und [[lib_de:System.Classes.TBinaryWriter|TBinaryWriter]], mit diesem Stream als Parameter verwenden, um das Speichern von Informationen, wie numerische oder String-Werte, zu unterstützen.

Sie können auch global auf diese Funktion zugreifen, ohne das [[lib_de:FMX.Forms.TCommonCustomForm|TCommonCustomForm]] wiederherzustellen. Sie können von der Plattform den Dienst [[lib_de:FMX.Platform.IFMXSaveStateService|IFMXSaveStateService]] anfordern und mit dessen Methoden die '''Speichern-Status'''-Daten speichern und laden.

===Speicherort und -name===

Die Eigenschaft [[lib_de:FMX.Forms.TFormSaveState.StoragePath|SaveState.StoragePath]] ermöglicht die Angabe eines "Speicherpfades" für den '''Speichern-Status''':

* Wenn '''StoragePath''' leer ist (Vorgabe), ist der '''Speichern-Status''' temporär und verwendet entweder vom Betriebssystem bereitgestellte Funktionen (wie "SaveState" auf Android) oder einen temporären Speicherort.

Die Daten verbleiben dort, wenn die Aktivität vom Betriebssystem neu gestartet wird, gehen aber auf mobilen Plattformen verloren, wenn die Anwendung manuell vom Benutzer beendet wird. Auf anderen Plattformen werden die Daten an einem temporären Speicherort gespeichert und bleiben verfügbar, bis diese temporären Dateien gelöscht werden (auf Windows beispielsweise bei einer Festplattenbereinigung).

* Wenn '''StoragePath''' nicht leer ist (sondern beispielsweise auf [[lib_de:System.IOUtils.TPath.GetHomePath|TPath.GetHomePath]] gesetzt ist), dann ist der '''Speichern-Status''' persistent und wird auf der Festplatte an diesem Speicherort gespeichert.

Die '''Speichern-Status'''-Daten verbleiben während der Ausführung unverändert, und Sie können so lange Informationen daraus wiederherstellen, bis Sie diese Daten explizit mit [[lib_de:System.Classes.TMemoryStream.Clear|SaveState.Stream.Clear]] löschen. Wenn Sie die Daten mit '''SaveState.Stream.Clear''' löschen oder [[lib_de:FMX.Platform.IFMXSaveStateService.SetBlock|IFMXSaveStateService.SetBlock]] mit auf nil gesetzten Blockdaten aufrufen, werden die Daten aus dem temporären Speicher entfernt bzw. bei der persistenten Speicherung wird die Datei gelöscht.

Es wird empfohlen, für temporäre und persistente Status die Eigenschaft [[lib_de:FMX.Forms.TFormSaveState.Name|SaveState.Name]] auf einen gewünschten Namen oder Dateinamen, wenn sie sich auf der Festplatte befinden, zu setzen. Wenn die Eigenschaft '''Name''' leer gelassen wird, erstellt das Formular einen Namen und hängt eine Kombination aus Anwendungsnamen, Klassennamen und Formularnamen an.

==Hinzufügen des Speichern-Status zu Anwendungen==

So verwenden Sie die Funktion '''Status speichern''':

<ol><li> Erstellen Sie eine neue [[Geräteübergreifende Anwendung|geräteübergreifende Anwendung]]. </li>
<li> Ziehen Sie eine [[lib_de:FMX.Edit.TEdit|TEdit]]-Komponente auf das Formular.</li>
<li> Wählen Sie das Formular aus, doppelklicken Sie auf das Ereignis [[lib_de:FMX.Forms.TCommonCustomForm.OnCreate|OnCreate]], und fügen Sie den folgenden Code hinzu:

<l s="delphi" />'''{{Delphi}}:'''
<source lang="delphi">
procedure TForm1.FormCreate(Sender: TObject);
var
R: TBinaryReader;
begin
if SaveState.Stream.Size > 0 then
begin
// Recover previously typed text in Edit1 control.
R := TBinaryReader.Create(SaveState.Stream);
try
Edit1.Text := R.ReadString;
finally
R.Free;
end;
end;
end;
</source><l e="delphi" />

<l s="cpp" />'''C++:'''
<source lang="cpp">
void __fastcall TForm1::FormCreate(TObject *Sender)
{
TBinaryReader *R;
if (SaveState->Stream->Size >0) {
// Recover previously typed text in Edit1 control.
R = new TBinaryReader(SaveState->Stream, TEncoding::UTF8, false);
try {
Edit1->Text = R->ReadString();
} __finally {
R->Free();
}
}
}
</source><l e="cpp" />

</li>
<li> Wählen Sie im [[Formular-Designer|Formular-Designer]] das Formular aus, doppelklicken Sie auf das Ereignis [[lib_de:FMX.Forms.TCommonCustomForm.OnSaveState|OnSaveState]], und fügen Sie den folgenden Code hinzu:

<l s="delphi" />'''{{Delphi}}:'''
<source lang="delphi">
procedure TForm1.FormSaveState(Sender: TObject);
var
W: TBinaryWriter;
begin
SaveState.Stream.Clear;
// Current state is only saved when something was edited.
// If nothing has changed, the state will be removed this way.
if Edit1.Text.Length > 0 then
begin
// Save typed text in Edit1 control.
W := TBinaryWriter.Create(SaveState.Stream);
try
W.Write(Edit1.Text);
finally
W.Free;
end;
end;
end;
</source><l e="delphi" />

<l s="cpp" />'''C++:'''
<source lang="cpp">
void __fastcall TForm1::FormSaveState(TObject *Sender)
{
TBinaryWriter *W;
SaveState->Stream->Clear();
// Current state is only saved when something was edited.
// If nothing has changed, the state will be removed this way.
if (Edit1->Text.Length() >0) {
// Save typed text in Edit1 control.
W = new TBinaryWriter(SaveState->Stream);
try {
W->Write(Edit1->Text);
} __finally {
W->Free();
}
}
}
</source><l e="cpp" />

Im obigen Codefragment sind die Speichern-Daten temporär, und '''Edit1''' behält weiterhin seinen Text, auch wenn die Anwendung neu gestartet wird. Da dieser '''Speichern-Status''' temporär ist, werden die Speichern-Daten gelöscht, wenn die Anwendung auf mobilen Geräten (manuell) geschlossen wird.

</li>
<li>Damit diese Speichern-Daten persistent werden, fügen Sie die folgende Codezeile am Anfang des Ereignisses '''FormCreate''' ein:

<l s="delphi" />'''{{Delphi}}:'''
<source lang="delphi">
SaveState.StoragePath := TPath.GetHomePath;
</source>

:'''Hinweis:''' Stellen Sie sicher, dass '''System.IOUtils''' in der uses-Klausel enthalten ist.

<l e="delphi" />

<l s="cpp" />'''C++:'''
<source lang="cpp">
SaveState->StoragePath = System::Ioutils::TPath::GetHomePath();
</source>

:'''Hinweis:''' Stellen Sie sicher, dass '''#include <System.IOUtils.hpp>''' in der Header-Datei enthalten ist.

<l e="cpp" />

</li>
</ol>

Wenn Sie die Anwendung auf einer Windows Vista-Plattform oder später ausführen, wird eine temporäre Datei mit dem Namen '''~Anwendungsname_FM_Klassenname_Formularname.TMP''' (wie z. B. '''~SaveStateCodeSnippet_FM_TForm1_Form1.TMP''') in folgendem [[lib_de:System.IOUtils.TPath.GetHomePath|Stammpfad]] gespeichert: '''C:\Benutzer\<Benutzername>\AppData\Roaming'''.

==Siehe auch==

* [[Erstellen einer FireMonkey-Anwendung|Erstellen einer {{FM}}-Anwendung]]
* [[FireMonkey-Anwendungshandbuch|{{FM}}-Anwendungshandbuch]]
* [[lib_de:FMX.Forms.TCommonCustomForm.OnSaveState|OnSaveState]]
* [[lib_de:System.IOUtils.TPath.GetHomePath|GetHomePath]]
* [[lib_de:FMX.Platform.IFMXSaveStateService|IFMXSaveStateService]]

[[Category:XE7]]
[[Category:FMX]]
[[Category:Delphi]]
[[Category:C++]]
[[Category:AMMigrate]]

[[en:FireMonkey Save State]]
[[fr:Fonctionnalité Enregistrer l'état de FireMonkey]]
[[ja:FireMonkey の状態保存]]

Tutorial: Implementieren Ihrer ersten RAD Server-Client-Anwendung

2014-09-19T09:08:50Z

Andreeah: Update LOC-16467

{{Parent|EMS-Client-Anwendung}}

Sie können eine EMS-Client-Anwendung für die Verbindung mit einem EMS-Server über die vom [[EMS-Server|EMS-Server]] bereitstellte REST-API erstellen. Um auf die EMS-Serverressourcen und -informationen aus der EMS-Datenbank zuzugreifen, können Sie die [[EMS Administrative API|integrierte API]] oder Ihre [[Erweitern des EMS-Servers|benutzerdefinierte API-Ressource ]] verwenden.

Für dieses Tutorial benötigen Sie in Ihrer EMS-Client-Anwendung die folgenden Komponenten:

* Mit der Komponente '''[[lib_de:REST.Backend.EMSProvider.TEMSProvider|TEMSProvider]]''' wird die Verbindung mit dem EMS-Server eingerichtet.
* Mit der Komponente '''[[lib_de:REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]]''' wird auf eine bestimmte Methode EMS-Ressourcenendpunkts aus Ihrer EMS-Client-Anwendung zugegriffen (eine der REST-API-Methoden des EMS-Servers). Eine EMS-Client-Anwendung ruft den [[lib_de:REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]] auf, um JSON vom EMS-Server abzurufen (GET) oder auf dem EMS-Server einzutragen (POST).

:'''Hinweis''': Jede [[lib_de: REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]]-Komponente ist für den Zugriff auf einen EMS-Ressourcenendpunkt konfiguriert. Fügen Sie genauso viele [[lib_de: REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]]-Komponenten hinzu wie Methoden der EMS-Ressourcenendpunkte vorhanden sind, auf die zugegriffen werden soll.

Um einen Aufruf eines REST-API-Endpunkts durchzuführen, müssen Sie in der Eigenschaft '''[[EMS-Client-Anwendung# Verwenden der Komponente TBackendEndpoint|Method]]''' der '''[[lib_de: REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]]'''-Komponente die passende Methode auswählen.

==Erstellen eines EMS-Clients==

# Erstellen Sie eine neue '''[[Geräteübergreifende Anwendung|geräteübergreifende Anwendung]]''':
#* Für '''{{Delphi}}''': Öffnen Sie {{Menu|Datei > Neu > Geräteübergreifende Anwendung - {{Delphi}}}}
#* Für '''C++''': Öffnen Sie {{Menu|Datei > Neu > Geräteübergreifende Anwendung - {{CBuilderUI}}}}
# Suchen Sie in der [[Tool-Palette|Tool-Palette]] die Komponente [[lib_de:REST.Backend.EMSProvider.TEMSProvider|TEMSProvider]], und ziehen Sie sie auf das [[lib_de:FMX.Forms.TForm|Formular]].
# Konfigurieren Sie im [[Objektinspektor|Objektinspektor]] die '''EMS-Serverparameter''' gemäß der '''[[Einrichten des EMS-Servers|EMS-Serverkonfiguration]]''':
#* '''URLHost''': <code>localhost</code>
#* '''URLPort''': <code>8080</code>
#* '''URLProtocol''': <code>http</code>
#:[[File:EMSServerConnection.png]]
# Klicken Sie auf die Schaltfläche '''Verbindung testen'''. Wenn die Verbindung erfolgreich hergestellt werden konnte, wird eine Meldung mit der aktuellen Version des EMS-Servers angezeigt.
#:[[File:InfoVersionEMSServer.png]]
# Im [[Fenster des EMS-Servers|Fenster des EMS-Servers]] wird im Protokollbereich die Versionsanforderung angezeigt.
#:[[File:InfoVersionEMSServerLog.png]]

==Aufrufen einer Methode eines Ressourcenendpunkts==

Sie können anhand von REST-API-Aufrufen aus Ihrer EMS-Client-Anwendung die Ressourcenendpunkte des EMS-Servers aufrufen, um Daten abzurufen oder festzulegen.

Verwenden Sie dazu entweder die Endpunktmethoden der [[EMS Administrative API|EMS Administrative API]] vom EMS-Server oder die [[Erweitern des EMS-Servers|benutzerdefinierten Ressourcenendpunkte]], die die Funktionalität des EMS-Servers erweitern.

# Legen Sie in Ihrer '''EMS-Client-Anwendung''' eine '''[[lib_de:REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]]'''-Komponente auf dem Formular ab.
# Legen Sie im [[Objektinspektor|Objektinspektor]] zur Verwendung der EMS-Serverressource die folgenden Parameter des '''[[lib_de:REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]]''' fest:
#* '''Provider'''. Wählen Sie in der Dropdown-Liste den Namen der '''TEMSProvider'''-Komponente (<code>EMSProvider1</code>) aus.
#* '''Resource''': <code>Version</code>
#* '''ResourceSuffix''': Belassen Sie dieses Feld für dieses Tutorial leer.
#* '''Method''': <code>rmGET</code>
#:[[File:TBackendEndpointConfiguration.png]]
# Wenn die Parameter ordnungsgemäß festgelegt sind, erhalten Sie beim Testen der Konfiguration der [[lib_de:REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]]-Komponente vom EMS-Server eine Erfolgsmeldung. Führen Sie eine der beiden Aktionen aus:
#* Klicken Sie im [[Objektinspektor|Objektinspektor]] auf '''Ausführen'''.
#* Klicken Sie mit der rechten Maustaste auf die Komponente [[lib_de: REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]], und wählen Sie '''Ausführen''' aus.
#:[[File:TBackendEndpointResponse.png]]
# Im Protokollbereich im [[Fenster des EMS-Servers|Fenster des EMS-Servers]] wird die Versionsanforderung angezeigt.
#:[[File:UsersGetEMSServerLog.png]]

==Visuelles Binden Ihrer Daten==

Sie können die Antwortdaten (vom EMS-Server) visuell an eine Komponente in Ihrer EMS-Client-Anwendung binden.

<ol><li>Öffnen Sie den [[LiveBindings-Designer|LiveBindings-Designer]], um die Antwortdaten für Ihre EMS-Client-Anwendung visuell zu binden. Wählen Sie {{Menu|Ansicht > LiveBindings-Designer}}.</li>
<li> Klicken Sie im [[LiveBindings-Designer|LiveBindings-Designer]] mit der rechten Maustaste auf die Eigenschaft Response.JSONText der [[lib_de: REST.Backend.EndPoint.TBackendEndpoint | TBackendEndpoint]]-Komponente, und wählen Sie die Option '''Mit neuem Steuerelement verknüpfen''' aus, um die Antwort an eine neue [[lib_de:FMX.Memo.TMemo|TMemo]]-Komponente zu binden.
:[[File:EMSClientDesignView.png|600px]] [[File:EMSClientLiveBindingDesigner.png|600px]]
</li>
<li> Ziehen Sie eine [[lib_de:FMX.StdCtrls.TLabel|TLabel]]-Komponente auf das Formular.
* Setzen Sie im [[Objektinspektor|Objektinspektor]] die Eigenschaft '''Text''' auf <code>EMS Server Version</code>.
</li>
<li> Legen Sie eine [[lib_de:FMX.StdCtrls.TButton|TButton]]-Komponente auf dem Formular ab.
* Setzen Sie im [[Objektinspektor|Objektinspektor]] die Eigenschaft '''Text''' auf <code>GetVersion</code>.
</li>
<li> Erstellen Sie das OnClick-Ereignis der TButton-Komponente (doppelklicken Sie darauf), und fügen Sie den folgenden Code hinzu:
<l s="delphi" />
* '''{{Delphi}}''':
<source lang="delphi">
procedure TForm1.Button1Click(Sender: TObject);
begin
BackendEndpoint1.Execute;
end;
</source><l e="delphi" /><l s="cpp" />
* '''C++''':
<source lang="cpp">
void __fastcall TForm1::Button1Click(TObject *Sender)
{
BackendEndpoint1->Execute();
}</source><l e="cpp" /></li>
<li> Erzeugen Sie Ihre Anwendung, und führen Sie sie aus.
:[[File:EMSClientExecution.png|500px]]
</li>
</ol>

==Siehe auch==

* [[EMS-Server|EMS-Server]]
* [[Erweitern des EMS-Servers|Erweitern des EMS-Servers]]
* [[EMS Administrative API|EMS Administrative API‎]]
* [[Übersicht über EMS-Ressourcen|Übersicht über EMS-Ressourcen]]
* [[JSON|JSON]]
* [[Überblick zu REST]]

[[Category:AMMigrate]]
[[Category:XE7]]

[[en:Tutorial: Implementing Your First EMS Client Application]]
[[fr:Tutoriel : Implémentation de votre première application client EMS]]
[[ja:チュートリアル：初めての EMS クライアントアプリケーションを実装する]]

DBMS-Umgebungsberichte (FireDAC)

2014-09-18T07:17:26Z

Andreeah: Update LOC-16453

{{Parent|Debuggen und Support (FireDAC)}}

In diesem Thema werden die verschiedenen '''FireDAC'''-Überprüfungs- und Berichtsoptionen in Datenbankmanagementsystemen (DBMS) erläutert. Diese '''FireDAC'''-Berichte stellen die Methoden zur Aufzeichnung aller notwendigen Details der Benutzerumgebung bereit, wodurch die vom Benutzer, Entwickler und Kundensupport benötigte Zeit zum Erkennen und Lösen von Problemen erheblich reduziert wird.

Möglichkeiten von '''FireDAC''':
* Verwenden von '''[[FDExplorer]]''' oder '''[[FDAdministrator]]''' – Erstellen eines Berichts über Ihre persistente Verbindungsdefinition.
* Verwenden des '''TFDConnection-Entwurfszeiteditors''' – Erstellen eines detaillierten Berichts über eine Verbindungsdefinition.
* Verwenden von '''Code''' – Integrieren von Berichtsfunktionen in Anwendungen mithilfe von {{Delphi}}-Code.

DBMS-Anwendungen schlagen im Allgemeinen aus folgenden Gründen fehlt:
* Fehlende DBMS-Client-Bibliotheken.
* Falsche Version des DBMS-Clients, -Servers oder von beidem.
* Falsche Konfiguration der Verbindungsdefinition.
* Kompatibilitätsprobleme, wie Unicode-Unterstützung.

Mit den Überprüfungs- und Berichtsoptionen von '''FireDAC''' können Sie die Ursache von Problemen schnell ermitteln.

==Verwenden von FDExplorer==

Das Hilfsprogramm '''[[FDExplorer]]''' ist das Haupttool zum Verwalten der zentralisierten persistenten Verbindungsdefinitionen.

Führen Sie '''[[FDExplorer]]''' , um einen detaillierten Bericht über Ihre persistente Verbindungsdefinition zu erstellen. Wählen Sie eine Verbindungsdefinition aus der Hierarchie auf der linken Seite aus. Klicken Sie rechts auf die Seite '''Info''', um den detaillierten Umgebungsbericht für die Verbindung anzuzeigen.

Der Bericht enthält die folgenden Abschnitte:
* '''Connection definition parameters''' – alle Parameter der Verbindungsdefinition.
* '''FireDAC info''' – Einzelheiten über das FireDAC-Build.
* '''Client info''' – Informationen über die DBMS-Client-Software, falls diese ordnungsgemäß installiert ist, sodass sie von FireDAC geladen werden kann. Andernfalls erhalten Sie eine Fehlermeldung.
* '''Session info''' – Informationen über den DBMS-Server und die Benutzersitzung, falls FireDAC die Verbindung erfolgreich öffnen kann. Andernfalls erhalten Sie eine Fehlermeldung.

Die folgende Abbildung zeigt den Bericht für eine SQLite-Verbindungsdefinition. In diesem Fall wurde die DBMS-Client-Software geladen, und die Verbindung wurde aktiviert.

[[File:Reports1.png|800px]]

==Verwenden des TFDConnection-Entwurfszeiteditors==
Der Entwurfszeit-Editor der Komponente '''TFDConnection''' stellt die Umgebung zum Verwalten von temporären Verbindungsparametern dar. Doppelklicken Sie beim Entwurf auf eine beliebige TFDConnection-Komponente. Daraufhin wird vom FireDAC-Package das Dialogfeld '''Connection Editor''' angezeigt.

Um einen detaillierten Bericht der Verbindungsdefinition anzuzeigen, wie weiter oben beschrieben, klicken Sie auf die Seite '''Info'''.

<blockquote>'''Hinweis:''' Wenn die '''TFDConnection'''-Komponente nicht verbunden ist, wird zum Abrufen der Serverdaten versucht, eine temporäre Verbindung zu einem DBMS herzustellen.</blockquote>

Die folgende Abbildung zeigt den Ergebnisbericht.

[[File:Reports2.png|500px]]



===Verwenden von {{Delphi}}-Code===

Sie können den DBMS-Bericht direkt durch Aufruf der Methode [[lib_de:FireDAC.Comp.Client.TFDCustomConnection.GetInfoReport|TFDConnection.GetInfoReport]] starten:
<source lang="delphi">
procedure TMainForm.Button1Click(Sender: TObject);
begin
FDConnection1.GetInfoReport(mmInfo.Lines);
end;
</source>

Diese Methode ist wie folgt deklariert:
<source lang="delphi">
procedure GetInfoReport(AList: TStrings; AItems: TFDInfoReportItems);
</source>

Die Werte des <code>AItems</code>-Flags bedeuten Folgendes:
* <code>riConnDef</code> – Verbindungsdefinitionsparameter in den Bericht einbeziehen.
* <code>riFireDAC</code> – FireDAC-Build-Info in den Bericht einbeziehen.
* <code>riClientLog</code> – Ladeprotokoll des DBMS-Clients einbeziehen.
* <code>riClient</code> – DBMS-Client-Info in den Bericht einbeziehen.
* <code>riSessionHints</code> – Potenzielle Inkompatibilitäten von FireDAC, DBMS-Client und Server einbeziehen.
* <code>riSession</code> – DBMS-Sitzungs-Info in den Bericht einbeziehen.
* <code>riTryConnect</code> – Verbindung zu einem DBMS versuchen, falls noch keine Verbindung besteht.
* <code>riKeepConnected</code> – Wenn die Methode eine Verbindung hergestellt hat, diese Verbindung aktiv halten.
* <code>AList</code> – Zielstringliste zum Anfügen an den Bericht.

Siehe das Demoprojekt <FireDAC>\Samples\Comp Layer\TFDConnection\InfoReport.

==Ermitteln der FireDAC-Build-Nummer==

Wenn Sie die FireDAC-Build-Nummer anzeigen möchten (z. B. im Dialogfeld "About"), verwenden Sie einfach <code>CONST C_FD_Version</code> aus der Unit '''<code>FireDAC.Stan.Const</code>'''. Beispiel:

C_FD_Version = '8.0.5 (Build 3365)';

==Ermitteln der DBMS-Version==

Um die Versionsnummer des DBMS-Clients und/oder -Servers zu ermitteln (z. B., um eine Funktion in Ihrer Anwendung zu aktivieren oder zu deaktivieren), verwenden Sie die Komponente '''TFDConnection''' und öffnen die Verbindung. Verwenden Sie dann das folgende Codebeispiel, das zeigt, wie auf die physischen Metadaten zugegriffen wird:

<source lang="delphi">
procedure TMainForm.Button2Click(Sender: TObject);
var
oMetaIntf: IFDPhysConnectionMetadata;
begin
// Get client and server versions
oMetaIntf := FDConnection1.ConnectionMetaDataIntf;
try
ShowMessage(Format('Client version: %.10d; Server version: %.10d',
[oMetaIntf.ClientVersion, oMetaIntf.ServerVersion]));
finally
oMetaIntf:= nil; // always release the interface before you close the connection
end;
end;
</source>

In der Unit '''<code>FireDAC.Stan.Const</code>''' finden Sie viele vordefinierte DBMS-Versionsnummern:

* '''cvOracleXXX''' – für Oracle
* '''mvMySQLXXX''' – für MySQL
* '''svMSSQLXXX''' – für MSSQL
* '''svSQLiteXXX''' – für SQLite
* '''svPGSQLXXX''' – für PostgreSQL
* '''ivIBXXX''' – für InterBase
* '''ivFBXXX''' – für Firebird

Die DBMS-Version wird in FireDAC durch einen LongWord-Wert dargestellt, der aus 5 Zifferngruppen besteht. Jede Gruppe umfasst 2 Ziffern (die äußerst linke Gruppe kann auch nur aus einer Ziffer bestehen).

mvMySQL032321 = 0323210000 entspricht zum Beispiel 3.23.21.0.0. Dadurch wird ein direkter Vergleich einer Client- oder Serverversion mit einer Konstante ermöglicht:

<source lang="delphi">
if oMetaIntf.ServerVersion >= mvMySQL050000 then begin
// execute MySQL 5.0 or higher specific SQL
end
else begin
// execute pre-MySQL 5.0 SQL
end;
</source>

==Siehe auch==

* [[Ablaufverfolgung und Überwachung (FireDAC)|Ablaufverfolgung und Überwachung]]
* [[FDExplorer]]

==Beispiel==
* <FireDAC>\Samples\Comp Layer\TFDConnection\InfoReport

[[Category:FireDAC]]
[[Category:AMMigrate]]

[[en:DBMS Environment Reports (FireDAC)]]
[[fr:Rapports d'environnement SGBD (FireDAC)]]
[[ja:DBMS 環境レポート（FireDAC）]]

Debuggen und Support (FireDAC)

2014-09-18T07:15:59Z

Andreeah: Update LOC-16453

{{Parent|FireDAC}}
In den folgenden Themen wird das Debuggen von FireDAC-Anwendungen beschrieben.

{| border="1" frame="hsides" rules="rows"
! '''Thema'''
! '''Beschreibung'''
|-
| align="left" valign="top" |[[DBMS-Umgebungsberichte (FireDAC)|DBMS-Umgebungsberichte]]
| align="left" valign="top" |In diesem Thema werden die verschiedenen FireDAC-Überprüfungs- und Berichtsoptionen in DBMS-Umgebungen erläutert. Derartige Berichte sind für den Kundensupport und das Entwicklungsteam äußerst wichtig.
|-
| align="left" valign="top" |[[Ablaufverfolgung und Überwachung (FireDAC)|Ablaufverfolgung und Überwachung]]
| align="left" valign="top" | In diesem Thema werden die Ablaufverfolgungs- und Überwachungsmöglichkeiten von FireDAC beschrieben, aus denen sich das Haupttool zum Debuggen von FireDAC-Anwendungen zusammensetzt und die zeigen, wie Anwendungen mit Datenbanken kommunizieren.
|}

[[Category:FireDAC]]
[[Category:AMMigrate]]

[[en:Debugging and Support (FireDAC)]]
[[fr:Débogage et support (FireDAC)]]
[[ja:デバッグとサポート（FireDAC）]]

Fragen zu MS Access (FireDAC)

2014-09-17T10:10:35Z

Andreeah: Update LOC-16451

{{Parent|FAQ (FireDAC)}}
Dieses Thema enthält eine Liste mit Fragen und Antworten zu MS Access.

==F1: Ich erhalte den Fehler "N Parameter wurden erwartet, aber es wurden zu wenig Parameter übergeben." Was bedeutet das?==

A: Höchstwahrscheinlich verweist Ihre SELECT-Abfrage auf Spalten, die in der Tabelle nicht vorhanden sind.

==F2: Ich kann [[lib_de:FireDAC.Phys.MSAcc.TFDPhysMSAccessDriverLink|TFDPhysMSAccessDriverLink]] in meiner Android-Datenbankanwendung nicht verwenden. Ich versuche, eine MS Access-Datenbank zu verwenden.==

A: MS Access-Datenbankverbindungen werden nur unter Windows unterstützt, und es gibt keine MS Access-Unterstützung für Android oder iOS. 
{{f|datasnap|Zurzeit unterstützt FireDAC auf Android nur InterBase-, SQLite- und DataSnap-Verbindungen.
|
Zurzeit unterstützt FireDAC auf Android nur InterBase und SQLite-Verbindungen.}}

Weitere Informationen finden Sie unter:
* [[Komponenten (FireDAC)]]
* [[Datenbanken (FireDAC)]]

[[Category:FireDAC]]
[[Category:AMMigrate]]

[[en:MS Access Questions (FireDAC)]]
[[fr:Questions relatives à MS Access (FireDAC)]]
[[ja:Microsoft Access に関する質問（FireDAC）]]

Einführung in die FireMonkey-Bibliothek

2014-09-17T09:55:29Z

Andreeah: Update LOC-16451

{{Parent|FireMonkey-Anwendungshandbuch}}

==FMX-Komponenten==

Die {{FM}}-Komponentenbibliothek und die {{FM}}-Laufzeitbibliothek können in sechs Hauptzweige unterteilt werden:

* '''{{FM}}-Grundelemente''', wie [[lib_de:FMX.Objects.TLine|TLine]] und [[lib_de:FMX.Objects.TText|TText]], sind von [[lib_de:FMX.Objects.TShape|TShape]] abgeleitet.
* '''Mit Stilen versehene {{FM}}-Steuerelemente''', wie [[lib_de:FMX.StdCtrls.TPanel|TPanel]] und [[lib_de:FMX.StdCtrls.TToolBar|TToolbar]], sind von [[lib_de:FMX.Controls.TStyledControl|TStyledControl]] abgeleitet.
* '''{{FM}}-3D-Steuerelemente''', wie [[lib_de:FMX.Controls3D.TCamera|TCamera]], [[lib_de:FMX.Objects3D.TMesh|TMesh]] und [[lib_de:FMX.Objects3D.TShape3D|TShape3D]], sind von [[lib_de:FMX.Controls3D.TControl3D|TControl3D]] abgeleitet.
*'''Nicht streambare Klassen''', wie [[lib_de:System.Classes.TList|TList]] und [[lib_de:System.Classes.TThread|TThread]], sind von [[lib_de:System.TObject|TObject]] abgeleitet.
*:Diese Klassen sind Teil der [[Verwenden der RTL (Laufzeitbibliothek)|RTL]].
*'''Streambare Klassen''', wie [[lib_de:FMX.Graphics.TGradient|TGradient]] und [[lib_de:System.Classes.TStrings|TStrings]], sind von [[lib_de:System.Classes.TPersistent|TPersistent]] abgeleitet.
*:Diese Klassen sind Teil der [[Verwenden der RTL (Laufzeitbibliothek)|RTL]].{{f|datasnap|
*'''Nicht visuelle Datenbankkomponenten''', wie [[lib_de:Datasnap.DBClient.TClientDataSet|TClientDataSet]] und [[lib_de:Data.Bind.DBScope.TBindScopeDB|TBindScopeDB]], sind von [[lib_de:System.Classes.TComponent|TComponent]] abgeleitet.
*:Diese Komponenten sind zur Entwurfszeit, aber nicht zur Laufzeit sichtbar. }}

==[[lib_de:FMX|Liste der FMX-Units]]==

Eine vollständige Liste der FMX-Units, die die {{FM}}-Bibliothek bilden, finden Sie unter '''[[lib_de:FMX|FMX-Unit-Liste]]'''.

==Siehe auch==

* [[FireMonkey-Anwendungsdesign|FireMonkey-Anwendungsdesign]]
* [[FireMonkey-Komponentenbibliothek|FireMonkey-Komponentenbibliothek]] (mit Diagrammen)

{{DEFAULTSORT:Einfuhrung in die FireMonkey-Bibliothek}}
[[Category:XE2]]
[[Category:FMX]]
[[Category:AMMigrate]]

[[en:Introducing the FireMonkey Library]]
[[fr:Introduction à la bibliothèque FireMonkey]]
[[ja:FireMonkey ライブラリの導入]]

Serialisieren von Benutzerobjekten

2014-09-05T10:27:47Z

Andreeah: Update LOC-16310

{{parent|DataSnap-Anwendungen entwickeln}}

Es ist jetzt möglich, mit JSON-Objekten benutzerdefinierte Objekte zwischen Client- und Servermethoden zu übergeben.

Das Paradigma basiert auf dem Marshaling von Benutzerobjekten in JSON-Objekte und dann auf der Gegenseite zurück in Benutzerobjekte. DataSnap stellt in der Unit ''DBXJSONReflect'' mit der Klasse [[lib_de:Data.DBXJSONReflect.TTypeMarshaller|TTypeMarshaller]] eine generische Serialisierungsfolge bereit. Benutzerobjekte können auf Basis einer Reihe von [[lib_de:Data.DBXJSONReflect.TConverter|Konverter]]- und [[lib_de:Data.DBXJSONReflect.TReverterEvent|Reverter]]-Klassen in eine äquivalente Repräsentation und dann zurück in Benutzerinstanzen umgewandelt werden.

[[lib_de:Data.DBXJSONReflect.TJSONMarshal|TJSONMarshal]] und [[lib_de:Data.DBXJSONReflect.TJSONUnMarshal|TJSONUnMarshal]] sind zwei Implementierungen der Serialisierung auf Basis von JSON-Objekten: Benutzerobjekte werden in äquivalente JSON-Objekte und diese wieder zurück in Benutzerobjekte umgewandelt.

Nicht alle benutzerdefinierten Objekte können nur auf Basis von Marshaling-Klassen serialisiert werden. Sie müssen eventuell mit benutzerdefinierten Konvertern für über RTTI nicht korrekt serialisierbare Benutzerfelder erweitert werden. Eine Konvertierung kann einem Typ oder einem Feld der Benutzerklasse zugeordnet werden. Es gibt vier Konvertertypen für jede Kategorie, die in der folgenden Tabelle aufgeführt sind:

{| border="1" frame="hsides" rules="rows" cellpadding="5"
! Beschreibung
! Feld
! Typ
|-
| Konvertierung in einen String
| [[lib_de:Data.DBXJSONReflect.TStringConverter|TStringConverter]]
| [[lib_de:Data.DBXJSONReflect.TTypeStringConverter|TTypeStringConverter]]
|-
| Konvertierung in ein Objekt
| [[lib_de:Data.DBXJSONReflect.TObjectConverter|TObjectConverter]]
| [[lib_de:Data.DBXJSONReflect.TTypeObjectConverter|TTypeObjectConverter]]
|-
| Konvertierung in ein String-Array
| [[lib_de:Data.DBXJSONReflect.TStringsConverter|TStringsConverter]]
| [[lib_de:Data.DBXJSONReflect.TTypeStringsConverter|TTypeStringsConverter]]
|-
| Konvertierung in ein Objekt-Array
| [[lib_de:Data.DBXJSONReflect.TObjectsConverter|TObjectsConverter]]
| [[lib_de:Data.DBXJSONReflect.TTypeObjectsConverter|TTypeObjectsConverter]]
|}

Das Konverter/Reverter-Prinzip basiert auf der Datenumwandlung in eine Repräsentation, aus der die Instanz wiederhergestellt werden kann. Sie können zwischen der Konvertierung einer komplexen Datenstruktur in einen einfachen String, der zerlegt und wieder zurückkonvertiert werden kann, oder einem komplizierteren aber effizienteren Verfahren auswählen. Angenommen, eine Objektkollektion soll serialisiert werden. Eine Möglichkeit dazu wäre, jedes Element in einen String umzuwandeln und alle Strings mit einem eindeutigen Trennzeichen zu verketten. Ein effizienterer Weg ist die Konvertierung der Kollektion in ein Objekt-Array. Der Reverter erhält dieses Array als Eingabe und kann die komplexe Kollektion wiederherstellen.

Das Codebeispiel auf dieser Seite wurde zum leichteren Verständnis in Blöcke unterteilt. Das Beispiel ist Teil eines {{Product}-Bibliothek-Projekts, das Sie erstellen müssen, damit das Beispiel ausgeführt werden kann, und Sie Ergebnisse sehen können. Der Code auf dieser Seite sollte im selben Quellcode (.pas-Datei) wie das Hauptformular des Projekts enthalten sein.

<source lang="Delphi">
{$R *.res}

uses
SysUtils, Classes,JSON,DBXJSON, DBXJSONReflect;
</source>

Das folgende Codebeispiel zum Serialisieren von benutzerdefinierten Typen veranschaulicht dieses Vorgehen.

<source lang="Delphi">
type
TForm1 = class(TForm)
Memo1: TMemo;
Button1: TButton;
procedure Button1Click(Sender: TObject);
procedure MainProc;

private
{ Private declarations }
public
{ Public declarations }
end;

TAddress = record
FStreet: String;
FCity: String;
FCode: String;
FCountry: String;
FDescription: TStringList;
end;

TPerson = class
private
FName: string;
FHeight: integer;
FAddress: TAddress;
FSex: char;
FRetired: boolean;
FChildren: array of TPerson;
FNumbers: set of 1..10;
public
constructor Create;
destructor Destroy; override;

procedure AddChild(kid: TPerson);
end;
</source>

In dem Beispiel werden die folgenden Variablen verwendet:
<source lang="Delphi">
var
m: TJSONMarshal;
unm: TJSONUnMarshal;
</source>

Die Deklarationen der ''TPerson''-Klassen-Member:

<source lang="Delphi">
constructor TPerson.Create;
begin
inherited;
FAddress.FDescription := TStringList.Create;
end;

destructor TPerson.Destroy;
begin

FAddress.FDescription.Free;
inherited;
end;

procedure TPerson.AddChild(kid: TPerson);
begin
SetLength(FChildren, Length(FChildren) + 1);
FChildren[Length(FChildren) - 1] := kid;
end;
</source>

Das Beispiel enthält komplexe Kollektionstypen ([[lib_de:System.Classes.TStringList|TStringList]]), Mengen, Arrays und Records. ''FNumbers'' soll ein transientes Feld (Vorgabe für Mengen) sein.

Die Hauptprogrammprozedur:

<source lang="Delphi">
procedure TForm1.MainProc;
var
person,newperson: TPerson;
kid: TPerson;
JSONString: String;

begin
m := TJSONMarshal.Create(TJSONConverter.Create);
unm := TJSONUnMarshal.Create;

{ For each complex field type, we will define a converter/reverter pair. We will individually deal
with the "FChildren" array, the "TStringList" type, and the "FAddress" record. We will transform
the array type into an actual array of "TPerson", as illustrated below. }

m.RegisterConverter(TPerson, 'FChildren', function(Data: TObject; Field: String): TListOfObjects
var
obj: TPerson;
I: Integer;

begin
SetLength(Result, Length(TPerson(Data).FChildren));
I := Low(Result);
for obj in TPerson(Data).FChildren do
begin
Result[I] := obj;
Inc(I);
end;
end);

{ The implementation is quite straightforward: each child "TPerson" is appended to a predefined
type instance "TListOfObjects". Later on, each of these objects will be serialized by the same
marshaller and added to a "TJSONArray" instance. The reverter will receive as argument a
"TListOfObjects" being oblivious of the "TJSONArray" used for that. }

{ For "TStringList", we will have a generic converter that can be reused for other marshal instances.
The converter simply returns the array of strings of the list. }

{ Note that this converter is not really needed here because the TStringList converter is already
implemented in the Marshaller. }

m.RegisterConverter(TStringList, function(Data: TObject): TListOfStrings
var
i, count: integer;

begin
count := TStringList(Data).Count;
SetLength(Result, count);
for I := 0 to count - 1 do
Result[i] := TStringList(Data)[i];
end);

{ Finally, the address record will be transformed into an array of strings, one for each record
field with the description content at the end of it. }

m.RegisterConverter(TPerson, 'FAddress', function(Data: TObject; Field: String): TListOfStrings
var
Person: TPerson;
I: Integer;
Count: Integer;

begin
Person := TPerson(Data);
if Person.FAddress.FDescription <> nil then
Count := Person.FAddress.FDescription.Count
else
Count := 0;
SetLength(Result, Count + 4);
Result[0] := Person.FAddress.FStreet;
Result[1] := Person.FAddress.FCity;
Result[2] := Person.FAddress.FCode;
Result[3] := Person.FAddress.FCountry;
for I := 0 to Count - 1 do
Result[4+I] := Person.FAddress.FDescription[I];
end);

{ It is easy to imagine the reverter's implementation, present below in bulk. }

unm.RegisterReverter(TPerson, 'FChildren', procedure(Data: TObject; Field: String; Args: TListOfObjects)
var
obj: TObject;
I: Integer;

begin
SetLength(TPerson(Data).FChildren, Length(Args));
I := Low(TPerson(Data).FChildren);
for obj in Args do
begin
TPerson(Data).FChildren[I] := TPerson(obj);
Inc(I);
end
end);

{ Note that this reverter is not really needed here because the TStringList reverter is already
implemented in the Unmarshaller. }

unm.RegisterReverter(TStringList, function(Data: TListOfStrings): TObject
var
StrList: TStringList;
Str: string;

begin
StrList := TStringList.Create;
for Str in Data do
StrList.Add(Str);
Result := StrList;
end);

unm.RegisterReverter(TPerson, 'FAddress', procedure(Data: TObject; Field: String; Args: TListOfStrings)
var
Person: TPerson;
I: Integer;

begin
Person := TPerson(Data);
if Person.FAddress.FDescription <> nil then
Person.FAddress.FDescription.Clear
else if Length(Args) > 4 then
Person.FAddress.FDescription := TStringList.Create;

Person.FAddress.FStreet := Args[0];
Person.FAddress.FCity := Args[1];
Person.FAddress.FCode := Args[2];
Person.FAddress.FCountry := args[3];
for I := 4 to Length(Args) - 1 do
Person.FAddress.FDescription.Add(Args[I]);
end);

{ The test code is as follows. }

person := TPerson.Create;
person.FName := 'John Doe';
person.FHeight := 167;
person.FSex := 'M';
person.FRetired := false;
person.FAddress.FStreet := '62 Peter St';
person.FAddress.FCity := 'TO';
person.FAddress.FCode := '1334566';
person.FAddress.FDescription.Add('Driving directions: exit 84 on highway 66');
person.FAddress.FDescription.Add('Entry code: 31415');

kid := TPerson.Create;
kid.FName := 'Jane Doe';
person.AddChild(kid);

{ Marshal the "person" as a JSONValue and display its contents. }

JSONString := m.Marshal(person).ToString;
Memo1.Lines.Clear;
Memo1.Lines.Add(JSONString);
Memo1.Lines.Add('-----------------------');

{ Unmarshal the JSONString to a TPerson class }

newperson := unm.Unmarshal(TJSONObject.ParseJSONValue(JSONString)) as TPerson;
Memo1.Lines.Add(newperson.FName);
Memo1.Lines.Add(IntToStr(newperson.FHeight));

{ and so on for the other fields }
end;
</source>

Und die Schaltfläche zum Aufrufen von '''MainProc''':

<source lang="Delphi">
procedure TForm1.Button1Click(Sender: TObject);
begin
MainProc;
end;
</source>

Die JSON-Zwischenrepräsentation für den Testcode in dem obigen Codebeispiel lautet:

<pre>
{"type":"Converter.TPerson",
"id":1,
"fields":{"FName":"John Doe",
"FHeight":167,
"FAddress":["62 Peter St","TO","1334566","","Driving directions: exit 84 on highway 66","Entry code: 31415"],
"FSex":"M",
"FRetired":false,
"FChildren":[{"type":"Converter.TPerson",
"id":2,
"fields":{"FName":"Jane Doe",
"FHeight":0,
"FAddress":["","","",""],
"FSex":"",
"FRetired":false,
"FChildren":[]
}
}
]
}
}
</pre>

Der Erfolg der Serialisierung kann durch Sicherstellung, dass alle Felder serialisiert wurden, überprüft werden. Dazu wird Marshal-Methode ''HasWarnings'' überprüft.

<blockquote>'''Hinweis:''' Die Serialisierung löst zirkuläre Referenzen auf.</blockquote>

==Siehe auch==

* [[lib_de:Data.DBXJSONReflect.TTypeMarshaller|TTypeMarshaller]]
* [[lib_de:Data.DBXJSONReflect.TConverter|TConverter]]
* [[lib_de:Data.DBXJSONReflect.TReverterEvent|TReverterEvent]]
* [[lib_de:Data.DBXJSONReflect.TJSONMarshal|TJSONMarshal]]
* [[lib_de:Data.DBXJSONReflect.TJSONUnMarshal|TJSONUnMarshal]]
* [[lib_de:Data.DBXJSONReflect.TMarshalUnmarshalBase.HasWarnings|HasWarnings]]

[[Category:{{Delphi}}]]
[[Category:DataSnap-Referenz]]

[[en:Serializing User Objects]]
[[fr:Sérialisation des objets utilisateur]]
[[ja:ユーザーオブジェクトのシリアル化]]

Codeintensive REST-Callback-Funktionen

2014-09-05T10:27:11Z

Andreeah: Update LOC-16310

{{Parent|DataSnap-REST}}

Mit Heavyweight-Callback-Funktionen können Sie von einer Webseite aus JavaScript-Funktionen beim Server registrieren und durch Angabe der ID des Empfangskanals festlegen, bei welcher Bedingung sie benachrichtigt werden sollen. Dies ermöglicht einem schlanken Client fast unverzüglich Benachrichtigungen vom Server zu erhalten, ohne dass ständig Anfragen gesendet werden müssten, um Änderungen festzustellen.

Für diese Benachrichtigungen vom Server müssen Sie zunächst die Serverkomponente und alle Serverklassenkomponenten in ein Datenmodulformular verschieben (oder an eine andere Position – außerhalb des Webmoduls –, wo diese Komponenten nur eine einzelne Instanz erstellen). Der Server hat Sende- und Benachrichtigungsfunktionen, die eine Kanal-ID und ein TJSONValue-"message"-Objekt übernehmen. Für die Benachrichtigung sind zusätzliche Parameter zum Festlegen der genauen Client-Callback-Funktion, an die die Meldung gesendet werden soll, erforderlich. Wenn Sie jedes Mal, wenn eine Memo-Komponente geändert wird, eine Meldung senden möchten, fügen Sie ein Ereignis für die Bearbeitung dieser Komponente hinzu und geben Folgendes in das Ereignis ein:

<pre>

Val := TJSONString.Create(Memo1.Text);
[DSServer].BroadcastMessage('MemoChannel', Val); //'MemoChannel' can be replaced by anything

</pre>

Fügen Sie dann im Client-Code ein Formular mit einem Textbereich mit der ID "tarea" (oder ähnlich) ein, fügen Sie diesen JavaScript-Code hinzu, und stellen Sie sicher, dass der Code ausgeführt wird (beim Übertragen, beim Laden der Seite usw.):

<pre>

var channel = new ClientChannel(null, "MemoChannel"); //this matches the server's Channel ID
var callback = new ClientCallback(channel, null,
function(jsonValue) {
if (jsonValue != null) {
document.getElementById("tarea").value = jsonValue;
}
return true;
});
channel.connect(callback);

</pre>

Dieser Beispielcode erstellt einen Textbereich in Ihrem Webbrowser, der immer mit dem in der Memo-Komponente auf dem Server eingegebenen Text synchron ist.

In XE2 kann jetzt für JavaScript REST-Callbacks zusätzlich zu dem '''ServerChannelName''' des Kanals eine Liste mit zu überwachenden '''ServerChannelNames''' angegeben werden. Für den '''ClientCallback'''-Konstruktor steht ein optionaler Abschlussparameter zur Verfügung, der ein JSON-Array mit Kanalnamen angibt. Dieser Parameter kann auf ein leeres Array oder auf '''null''' gesetzt werden, wenn Sie keine weiteren zu überwachenden Kanalnamen angeben wollen.

Dies ist wegen des von Browsern vorgeschriebenen Verbindungslimits besonders für JavaScript notwendig. Sie können ähnliches Verhalten anhand von Namenskonventionen für die Callback-IDs aller Clients simulieren. Der Server (nicht aber der Client) kann dann einen bestimmten Kanal UND eine Callback-ID weiterleiten. Das entspricht weitgehend Callbacks, die ihren eigenen Kanal überwachen. Es wird jedoch verhindert, dass Clients mehrere Callbacks auf demselben Kanal überwachen müssen. Zudem wird der Server eingeschränkt, da er den '''übergeordneten Kanal''' angeben muss.

==Siehe auch==

* [[DataSnap-REST]]

[[Category:{{Delphi}}]]
[[Category:DataSnap-Referenz]]

[[en:REST Heavyweight Callbacks]]
[[fr:Rappels avancés REST]]
[[ja:REST 重量コールバック]]

Schritt 6 - Hinzufügen von Eigenschaften zum Ändern des Erscheinungsbildes der Komponente

2014-08-28T11:57:39Z

Andreeah: Update LOC-16144

{{parent|Erstellen eines grundlegenden FireMonkey-Steuerelements}}
Sie können die '''TRegularPolygon'''-Komponente erweitern und Änderungen ihres Erscheinungsbildes ermöglichen. Sie können beispielsweise die Hintergrundfarbe ändern.

Andere grundlegende {{FM}}-Komponenten verfügen typischerweise über die folgenden '''Eigenschaften für das Erscheinungsbild''':
* '''Fill'''
* '''Stroke'''
* '''StrokeCap'''
* '''StrokeDash'''
* '''StrokeJoin'''
* '''StrokeThickness'''

Damit Sie diese Eigenschaften verwenden können, müssen Sie sie als published-Eigenschaften erneut einführen.

Der '''Interface'''-Abschnitt der '''TRegularPolygon'''-Komponente sollte folgendermaßen aussehen:
<source lang="delphi">
type
TRegularPolygon = class(TShape)
private
{ Private declarations }
FNumberOfSides: Integer;
FPath: TPathData;
procedure SetNumberOfSides(const Value: Integer);
protected
{ Protected declarations }
procedure CreatePath;
procedure Paint; override;
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
destructor Destroy; override;
function PointInObject(X, Y: Single): Boolean; override;
published
{ Published declarations }
property NumberOfSides: Integer read FNumberOfSides write SetNumberOfSides;
property Fill;
property Stroke;
property StrokeCap;
property StrokeDash;
property StrokeJoin;
property StrokeThickness;
end;
</source>
Erzeugen und installieren Sie das Package im '''Projektverwaltung'''. Kehren Sie zu '''TestRegularPolygonUnit''' zurück. Jetzt verfügen Sie über die Optionen zum Ändern des Erscheinungsbildes der neuen Komponente.

[[image:Resized1727.png]]

==Zurück==
* ''' [[Schritt 5 - Testen der grundlegenden FireMonkey-Komponente]]

{{DEFAULTSORT:Schritt 6 - Hinzufugen von Eigenschaften zum Andern des Erscheinungsbildes der Komponente}}
[[Category:FMX]]
[[Category:XE2]]
[[Category:AMMigrate]]

[[en:Step 6 - Add Properties to Change the Look and Feel]]
[[fr:Etape 6 - Ajouter des propriétés pour changer l'apparence]]
[[ja:ステップ 6 - ルックアンドフィールを変更するためのプロパティを追加する]]

Schritt 5 - Testen der grundlegenden FireMonkey-Komponente

2014-08-28T11:56:32Z

Andreeah: Update LOC-16144

{{parent|Erstellen eines grundlegenden FireMonkey-Steuerelements}}

Wenn Sie zurück zur Unit '''TestRegularPolygon''' wechseln, sehen Sie im '''[[Formular-Designer]]''', dass die Instanz der '''TRegularPolygon'''-Komponente ein Dreieck anzeigt.

[[image:1615.png]]

Wählen Sie im '''[[Formular-Designer]]''' die Komponente '''TRegularPolygon''' aus. Die neue Eigenschaft '''NumberOfSides''' (deren Standardwert <code>3</code> ist) erscheint jetzt im '''Objektinspektor'''. Ändern Sie den Wert von '''NumberOfSides''', um sicherzustellen, dass diese Komponente erwartungsgemäß arbeitet.

==Zurück==
* '''[[Schritt 4 - Implementieren der Methoden "Paint" und "PointInObject"]]'''

==Weiter==
* '''[[Schritt 6 - Hinzufügen von Eigenschaften zum Ändern des Erscheinungsbildes der Komponente]]'''

[[Category:FMX]][[Category:XE2]]
[[Category:AMMigrate]]

[[en:Step 5 - Test the FireMonkey Primitive Component]]
[[fr:Etape 5 - Tester le composant primitif FireMonkey]]
[[ja:ステップ 5 - FireMonkey プリミティブコンポーネントをテストする]]

Schritt 5 - Benutzerdefinierte Eigenschaften (C++)

2014-08-28T11:55:45Z

Andreeah: Update LOC-16144

{{Parent|Erstellen einer FireMonkey-Komponente (C++)}}

Die Komponente benötigt eine weitere Eigenschaft, damit das Verb der Dialogfeldaktion, wie z.B. "Speichern" auf der "Ausführen"-Schaltfläche angezeigt wird. Dieses Verb ist auch mit "Nicht ausführen" auf der "Nicht ausführen"-Schaltfläche verbunden. (Eine komplexere Internationalisierung würde den Rahmen dieses Themas überschreiten.)

Es wäre einfacher, wenn die Aufnahme des Verbs über die Eigenschaft '''Text''' der Schaltfläche durchgeführt werden könnte. Aber die Schaltflächen sind erst vorhanden, wenn der Stil übernommen wird, und bei erneuter Übernahme des Stils werden die vorhandenen Schaltflächen verworfen. Daher muss die Komponente diesen String bereitstellen. Deklarieren und implementieren Sie die Eigenschaft '''DoVerb''':

<source lang="cpp">
class PACKAGE TDialogButtonPanel : public TPanel
{
private:
String FDoVerb;
TAlignLayout FAlign;
void __fastcall SetDoVerb(String AString);
String __fastcall GetDoVerb();
protected:
TControl* __fastcall TDialogButtonPanel::GetStyleObject();
void __fastcall ApplyStyle();
public:
__fastcall TDialogButtonPanel(TComponent* Owner);
__published:
__property Align = { default = TAlignLayout::Bottom };
__property String DoVerb ={ read=GetDoVerb, write=SetDoVerb };
};
//---------------------------------------------------------------------------
const String DoButtonName = "DoButton";
const String DontButtonName = "DontButton";
const String CancelButtonName = "CancelButton";
</source>

<source lang="cpp">
// ---------------------------------------------------------------------------
__fastcall TDialogButtonPanel::TDialogButtonPanel(TComponent* Owner)
: TPanel(Owner) {
Height = 46;
Width = 300;
Align = TAlignLayout::Bottom;
DoVerb = "Verb";
}

// ---------------------------------------------------------------------------
void __fastcall TDialogButtonPanel::ApplyStyle() {
TStyledControl::ApplyStyle();
SetDoVerb(FDoVerb);
}

// ---------------------------------------------------------------------------
String __fastcall TDialogButtonPanel::GetDoVerb(){
TFmxObject* Base;
TTextControl* TextBase;
Base = FindStyleResource(DoButtonName);
if ((TextBase = dynamic_cast<TTextControl*>(Base)) != NULL) {
FDoVerb = TextBase->Text;
}
return FDoVerb;
}

// ---------------------------------------------------------------------------
void __fastcall TDialogButtonPanel::SetDoVerb(String AString) {
TFmxObject* Base;
TTextControl* TextBase;
Base = FindStyleResource(DoButtonName);
FDoVerb = AString;
if ((TextBase = dynamic_cast<TTextControl*>(Base)) != NULL) {
TextBase->Text = AString;
}
Base = FindStyleResource(DontButtonName);
if ((TextBase = dynamic_cast<TTextControl*>(Base)) != NULL) {
TextBase->Text = "Don't " + AString;
}
}
</source>

Der StyleName für jede der drei Schaltflächen wird zusammen mit dem modalen, "negativen OK"-Ergebniscodes für die "Nicht ausführen"-Schaltfläche als Konstante deklariert. Das Feld <code>FDoVerb</code> wird dem Objekt zur Aufnahme des Verb-Strings hinzugefügt.

Zur Laufzeit erfolgt der Zugriff folgendermaßen:
# Wenn die Anwendung ausgeführt wird, werden alle Formulare erstellt, einschließlich des Dialogfeldformulars mit dem Schaltflächenbereich (TPanel). Die TPanel-Komponente wird durch die <code>object</code>-Zeile beim Laden der <code>.fmx</code>-Datei instantiiert. Der Konstruktor schreibt mit <code>SetDoVerb</code> das Standardverb in die Eigenschaft. Das Feld wird gesetzt, und es werden keine Schaltflächen gefunden.
# Bei der Zuweisung der Eigenschaftswerte aus der Datei <code>.fmx</code> wird <code>SetDoVerb</code> erneut mit dem vom Designer gespeicherten String (z.B. "Speichern") aufgerufen und das Feld geändert.
# Beim Öffnen des Dialogfelds wird es gezeichnet, und einer der vorbereitenden Schritte beim Zeichnen eines Steuerelements ist die Übernahme des Stils (falls erforderlich), wozu auch das erste Zeichnen des Steuerelements gehört. Zum Schluss wird die Prozedur <code>ApplyStyle</code> aufgerufen, die hier überschrieben wird, um den Verb-String aus dem Feld erneut zu übernehmen. Die Prozedur weist das Feld redundant erneut zu, aber jetzt sind die Schaltflächen vorhanden, und zudem wird das Verb in der "Ausführen"-Schaltfläche und das Verb in der "Nicht ausführen"-Schaltfläche gesetzt.
# Das Rendern der Schaltflächen erfolgt nicht in der Funktion <code>GetDoVerb</code>, weil die Schaltflächen, die den Stil umfassen, direkt gerendert werden, und sie bereits über die Setter-Methode den passenden Text erhalten haben. Die Getter-Methode wird hauptsächlich vom Formular-Designer und von Laufzeitcode verwendet, der die Eigenschaften der TPanel-Komponente ermittelt. Die Methode versucht, das Feld aus der "Ausführen"-Schaltfläche (falls vorhanden) zu aktualisieren; aber wenn die Schaltfläche nicht direkt manipuliert wird (durch Umgehung der Kapselung), sollten ihr Text und das Feld bereits synchronisiert sein.

==Zurück==
* [[Schritt 4 - Festlegen der Größe und der Ausrichtung (C++)|Schritt 4 - Festlegen der Größe und der Ausrichtung (C++)]]

==Siehe auch==
* [[FireMonkey-Komponentendesign]]
* [[Verwenden des Experten für neue Komponenten]]
* [[Erstellen einer FireMonkey-Komponente (C++)]]
* [[Erstellen einer mit Stilen versehenen FireMonkey-Komponente durch Erweitern einer vorhandenen Komponente ]]
* [[Erstellen eines grundlegenden FireMonkey-Steuerelements]]
[[Category:XE3]][[Category:FMX]][[Category:C++]]
[[Category:AMMigrate]]

[[en:Step 5 - Custom Properties (C++)]]
[[fr:Etape 5 - Propriétés personnalisées (C++)]]
[[ja:ステップ 5 - カスタムプロパティ（C++）]]

Schritt 4 - Testen der mit FMX-Stilen versehenen Komponente

2014-08-28T11:54:42Z

Andreeah: Update LOC-16144

{{parent|Erstellen einer mit Stilen versehenen FireMonkey-Komponente durch Erweitern einer vorhandenen Komponente }}

Wenn Sie zurück zum Projekt '''TestClockLabelUnit''' wechseln, sehen Sie im '''[[Formular-Designer]]''', dass die Instanz der '''TClockLabel'''-Komponente die aktuelle Uhrzeit anzeigt.

[[image:TestClockLabelUnit.png|600px]]

Wählen Sie im '''[[Formular-Designer]]''' die Komponente '''TClockLabel''' aus. Die neue Eigenschaft '''Format''' (mit dem Standardwert <code>c</code>) der Komponente '''TClockLabel''' wird im '''Objektinspektor''' angezeigt.

Führen Sie das Projekt '''TestClockLabelUnit''' aus, indem Sie zum Beispiel den Menübefehl '''Start > Ohne Debugger ausführen''' auswählen. Das Formular mit der erstellten '''TClockLabel'''-Komponente wird angezeigt:

: [[image:ClockLabeInForm.png]]

Das '''ClockLabel'''-Steuerelement zeigt die aktuelle Uhrzeit an.

: '''Hinweis:''' Wenn der Standardpfad im Feld '''Unit-Name''' (im Schritt 4) nicht in der im '''[[Schritt 1 - Erstellen einer Komponente mit dem Experten "Neue Komponente"]]''' beschriebenen Prozedur angegeben wurde, dann müssen Sie der '''Suchpfad'''-Liste des Projekts den angegebenen Pfad hinzufügen. Wählen Sie dazu den Menübefehl '''Projekt > Optionen''', um das Dialogfeld '''Projektoptionen''' zu öffnen. Wählen Sie die Seite '''[[Delphi-Compiler]]''' aus, und fügen Sie den Pfad der Liste in der Option '''Suchpfad''' hinzu.

==Zurück==

* [[Schritt 3 - Verwenden von TTimer zum sekündlichen Aktualisieren von TClockLabel ]]
[[Category:FMX]][[Category:XE2]]
[[Category:AMMigrate]]

[[en:Step 4 - Test the FMX Styled Component]]
[[fr:Etape 4 - Tester le composant stylé FMX]]
[[ja:ステップ 4 - スタイル付き FMX コンポーネントをテストする]]

Schritt 4 - Implementieren der Methoden "Paint" und "PointInObject"

2014-08-28T11:53:00Z

Andreeah: Update LOC-16144

{{parent|Erstellen eines grundlegenden FireMonkey-Steuerelements}}
In diesem letzten Schritt wird die grundlegende Komponente fertig gestellt. Definieren Sie die folgenden zusätzlichen Member (Member, die zuvor erstellt wurden, sind hier nicht aufgeführt):
<source lang="delphi">
type
TRegularPolygon = class(TShape)
protected
procedure Paint; override;
public
function PointInObject(X, Y: Single): Boolean; override;
end;
</source>
Verwenden Sie wie in den vorherigen Schritten <code>STRG+UMSCHALT+C</code>, um Platzhalter für diese Methoden zu erstellen. Implementieren Sie diese Methoden folgendermaßen:
<source lang="delphi">
procedure TRegularPolygon.Paint;
begin
CreatePath;
Canvas.FillPath(FPath, AbsoluteOpacity);
Canvas.DrawPath(FPath, AbsoluteOpacity);
end;

function TRegularPolygon.PointInObject(X, Y: Single): Boolean;
begin
CreatePath;
Result := Canvas.PtInPath(AbsoluteToLocal(PointF(X, Y)), FPath);
end;
</source>

Die Komponente '''TRegularPolygon''' ist nun implementiert. Klicken Sie im '''Projektverwaltung''' mit der rechten Maustaste auf das Package TRegularPolygon.bpl, und wählen Sie im Kontextmenü '''Erzeugen'''. Wählen Sie anschließend '''Installieren''', um das entwickelte Komponenten-Package zu installieren und die entwickelte Komponente zu registrieren.

[[image:2657.png]]

Jetzt können Sie das neue Verhalten der '''TRegularPolygon'''-Komponente im '''[[Formular-Designer]]''' sehen.

==Zurück==
* '''[[Schritt 3 - Definieren eines Pfades zum Zeichnen des Polygons]]

==Weiter==
* '''[[Schritt 5 - Testen der grundlegenden FireMonkey-Komponente]]

[[Category:FMX]][[Category:XE2]]
[[Category:AMMigrate]]

[[en:Step 4 - Implement Paint and PointInObject Methods]]
[[fr:Etape 4 - Implémenter les méthodes Paint et PointInObject]]
[[ja:ステップ 4 - Paint メソッドと PointInObject メソッドを実装する]]

Schritt 3 - Verwenden von TTimer zum sekündlichen Aktualisieren von TClockLabel

2014-08-28T11:50:37Z

Andreeah: Update LOC-16144

{{parent|Erstellen einer mit Stilen versehenen FireMonkey-Komponente durch Erweitern einer vorhandenen Komponente }}

In diesem Tutorial wird die '''TTimer'''-Komponente intern verwendet, um '''TClockLabel''' sekundenweise zu aktualisieren. Zur Verwendung der '''TTimer'''-Komponente in der '''TClockLabel'''-Komponente müssen Sie:
* Ein Instanz von '''TTimer''' im Konstruktor von '''TClockLabel''' erstellen.
* Die '''TTimer'''-Komponente so konfigurieren, dass sie jede Sekunde das Ereignis '''OnTimer''' auslöst.
* Die Eigenschaft '''Text''' aktualisieren, wenn das Ereignis '''OnTimer''' ausgelöst wird.
* Die Instanz von '''TTimer''' im Destruktor von '''TClockLabel''' freigeben.
Definieren Sie dazu die folgenden zusätzlichen Member (Member, die zuvor erstellt wurden, sind hier nicht aufgeführt):

In '''{{Delphi}}''':
<source lang="delphi">
type
TClockLabel = class(TLabel)
private
FTimer: TTimer;
procedure OnTimer(Sender: TObject);
public
destructor Destroy; override;
end;
</source>

In '''C++''':

<source lang=cpp>
class PACKAGE TClockLabel : public TLabel {
private:

TTimer* FTimer;

void __fastcall OnTimer(TObject* Sender);

public:
__fastcall ~TClockLabel(void);
};
</source>
Wie in den vorherigen Schritten werden durch Drücken von <code>STRG+UMSCHALT+C</code> Platzhalter für diese Methoden erstellt.

Implementieren Sie diese Methoden folgendermaßen:

In '''{{Delphi}}''':
<source lang="delphi">
constructor TClockLabel.Create(AOwner: TComponent);
begin
FFormat := 'c';
inherited;

// No need to use TTimer compoment at design time.
if not (csDesigning in ComponentState) then
begin
FTimer := TTimer.Create(AOwner);
FTimer.OnTimer := OnTimer;
FTimer.Interval := 1000;
FTimer.Enabled := True;
end;

UpdateLabel;
end;

destructor TClockLabel.Destroy;
begin
FreeAndNil(FTimer);
inherited;
end;

procedure TClockLabel.OnTimer(Sender: TObject);
begin
UpdateLabel;
end;
</source>

In '''C++''':
<source lang=cpp>
__fastcall TClockLabel::TClockLabel(TComponent* Owner) : TLabel(Owner) {

FFormat = 'c';

FTimer = new TTimer(Owner);
FTimer->OnTimer = OnTimer;
FTimer->Interval = 1000;
FTimer->Enabled = true;

UpdateLabel();
}

__fastcall TClockLabel::~TClockLabel() {
FreeAndNil(FTimer);
}

void __fastcall TClockLabel::OnTimer(TObject* Sender) {
UpdateLabel();
}

</source>

Wie Sie wahrscheinlich bemerkt haben, ist die erstellte Instanz von '''TTimer''' von der Eigenschaft '''ComponentState''' abhängig. Und zwar, weil die '''Beschriftung (Label)''' zur Entwurfszeit (wenn Sie in der IDE ausgeführt wird) nicht aktualisiert werden muss. Dadurch wird die Erstellung der '''TTimer'''-Komponente auf die Ausführung der Komponente außerhalb der IDE (als Standardanwendung) beschränkt.

Jetzt wird die '''TClockLabel'''-Komponente implementiert. Klicken Sie im '''Projektverwaltung''' mit der rechten Maustaste auf das Package '''TClockLabel.bpl''' und wählen Sie im Kontextmenü '''Erzeugen''' aus. Wählen Sie dann '''Installieren''' aus, um das entwickelte Komponenten-Package zu installieren und die Komponente zu registrieren:

::[[image:ClockLabeIContextMenu.png]]

Jetzt können Sie das neue Verhalten der '''TClockLabel'''-Komponente im '''[[Formular-Designer]]''' sehen.

==Zurück==
* [[Schritt 2 - Implementieren einer Eigenschaft zum Angeben des Formats ]]

==Weiter==
* [[Schritt 4 - Testen der mit FMX-Stilen versehenen Komponente ]]

{{DEFAULTSORT:Schritt 3 - Verwenden von TTimer zum sekundlichen Aktualisieren von TClockLabel}}
[[Category:FMX]]
[[Category:XE2]]
[[Category:AMMigrate]]

[[en:Step 3 - Using TTimer to Refresh TClockLabel Every Second]]
[[fr:Etape 3 - Utilisation de TTimer pour actualiser TClockLabel à chaque seconde]]
[[ja:ステップ 3 - TTimer を使用して TClockLabel を毎秒更新する]]

Schritt 3 - Definieren eines Pfades zum Zeichnen des Polygons

2014-08-28T11:46:56Z

Andreeah: Update LOC-16144

{{Parent|Erstellen eines grundlegenden FireMonkey-Steuerelements}}
Zum Zeichnen eines Polygons müssen Sie einen Pfad für die Zeichenoperation definieren. Sobald ein Pfad definiert ist, kann das '''[[lib_de:FMX.Controls.TControl.Canvas|Canvas]]'''-Objekt den Pfad füllen und zeichnen.

=== So erstellen und schließen Sie einen Pfad: ===
# Erstellen Sie ein [[lib_de:FMX.Objects.TPath|TPath]]-Objekt.
# [[lib_de:FMX.Graphics.TPathData.MoveTo|Wechseln]] Sie zum Startpunkt (①).
# Gehen Sie mit der Prozedur '''[[lib_de:FMX.Graphics.TPathData.LineTo|LineTo]]''' alle Eckpunkte durch (②, ③ und ④).
# Schließen Sie den Pfad.

[[image:polgyongdrawing.png]]

Sie müssen die folgenden zusätzlichen Member definieren (Member, die zuvor erstellt wurden, sind hier nicht aufgeführt; siehe die vorherigen Schritte):
<source lang='delphi'>
type
TRegularPolygon = class(TShape)
private
FPath: TPathData;
protected
procedure CreatePath;
public
destructor Destroy; override;
end;
</source>
Damit soll Folgendes erreicht werden:
* Erstellen einer Instanz von '''[[lib_de:FMX.Graphics.TPathData|TPathData]]''' ('''FPath'''-Feld) im Konstruktor.
* Setzen der Pfadinformationen auf das '''FPath'''-Feld in '''[[lib_de:FMX.Objects.TCalloutRectangle.CreatePath|CreatePath]]'''.
* Verwenden der Pfadinformationen in den Methoden '''[[lib_de:FMX.Controls.TControl.Paint|Paint]]''' und '''[[lib_de:FMX.Objects.TCustomPath.PointInObject|PointInObject]]''' (wird später erläutert).
* Freigeben der Instanz des '''FPath'''-Feldes im Destruktor.
Wie in den vorherigen Schritten werden mit <code>STRG+UMSCHALT+C</code> Platzhalter für diese Methoden erstellt. Implementieren Sie diese Methoden folgendermaßen:
<source lang='delphi'>
constructor TRegularPolygon.Create(AOwner: TComponent);
begin
inherited;
FNumberOfSides := 3;
FPath := TPathData.Create;
end;

destructor TRegularPolygon.Destroy;
begin
FreeAndNil(FPath);
inherited;
end;

procedure TRegularPolygon.CreatePath;
procedure GoToAVertex(n: Integer; Angle, CircumRadius: Double;
IsLineTo: Boolean = True);
var
NewLocation: TPointF;
begin
NewLocation.X := Width / 2 + Cos(n * Angle) * CircumRadius;
NewLocation.Y := Height / 2 - Sin(n * Angle) * CircumRadius;

if IsLineTo then
FPath.LineTo(NewLocation)
else
FPath.MoveTo(NewLocation);
end;
var
i: Integer;
Angle, CircumRadius: Double;
begin
Angle := 2 * PI / FNumberOfSides;
CircumRadius := Min(ShapeRect.Width / 2, ShapeRect.Height / 2);

// Create a new Path
FPath.Clear;

// MoveTo the first point
GoToAVertex(0, Angle, CircumRadius, False);

// LineTo each Vertex
for i := 1 to FNumberOfSides do
GoToAVertex(i, Angle, CircumRadius);

FPath.ClosePath;
end;
</source>
Sie müssen die folgende '''uses'''-Klausel hinzufügen:
<source lang='delphi'>
uses
System.Math, System.Types;
</source>

== Zurück ==
*''' [[Schritt 2 - Implementieren einer Eigenschaft zum Angeben der Seitenanzahl]]

== Weiter ==
* '''[[Schritt 4 - Implementieren der Methoden "Paint" und "PointInObject"]]

[[Category:XE2]]
[[Category:FMX]]
[[Category:AMMigrate]]

[[en:Step 3 - Define a Path to Draw the Polygon]]
[[fr:Etape 3 - Définir un chemin pour dessiner le polygone]]
[[ja:ステップ 3 - 多角形を描画するパスを定義する]]

Schritt 2 - Implementieren einer Eigenschaft zum Angeben der Seitenanzahl

2014-08-28T11:45:00Z

Andreeah: Update LOC-16144

{{parent|Erstellen eines grundlegenden FireMonkey-Steuerelements}}

Für die '''TRegularPolygon'''-Komponente muss die Anzahl der Seiten als Eigenschaft definiert werden, damit Komponentenbenutzer die Seitenzahl festlegen können. Fügen Sie dem '''published'''-Abschnitt der Klasse '''TRegularPolygon''' die folgende Zeile hinzu, um eine Eigenschaft (namens '''NumbersOfSides''') zu implementieren:

<source lang='delphi'>
property NumberOfSides: Integer;
</source>

Fügen Sie außerdem dem '''public'''-Abschnitt eine Definition des Konstruktors wie folgt hinzu:

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

Der Code sollte nun wie folgt lauten:

<source lang='delphi'>
type
TRegularPolygon = class(TShape)
private
{ Private declarations }
protected
{ Protected declarations }
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
published
{ Published declarations }
property NumberOfSides: Integer;
end;
</source>

Drücken Sie nach Einfügen dieser Zeilen <code>STRG+UMSCHALT+C</code>. Die IDE fügt automatisch die Methode zum Setzen der Eigenschaft '''NumberOfSides''' und eine Struktur (Skeleton) für den Konstruktor hinzu. Der Code sollte nun wie folgt lauten:

<source lang='delphi'>
TRegularPolygon = class(TShape)
private
FNumberOfSides: Integer;
procedure SetNumberOfSides(const Value: Integer);
{ Private declarations }
protected
{ Protected declarations }
public
{ Public declarations }
constructor Create(AOwner: TComponent); override;
published
{ Published declarations }
property NumberOfSides: Integer read FNumberOfSides write SetNumberOfSides;
end;

constructor TRegularPolygon.Create(AOwner: TComponent);
begin
inherited;

end;

procedure TRegularPolygon.SetNumberOfSides(const Value: Integer);
begin
FNumberOfSides := Value;
end;
</source>

Wie bei jedem Polygon muss die Anzahl der Seiten mindestens 3 betragen. Ändern Sie daher die Implementierung der Methode '''SetNumberOfSides''' wie folgt:

<source lang='delphi'>
procedure TRegularPolygon.SetNumberOfSides(const Value: Integer);
begin
if (FNumberOfSides <> Value) and (Value >= 3) then
begin
FNumberOfSides := Value;
Repaint;
end;
end;
</source>

Durch die Methode '''Repaint''' wird dem {{FM}}-Framework mitgeteilt, dass diese Komponente neu gezeichnet werden muss, wenn sich die Seitenanzahl ändert. Im Konstruktor müssen Sie den Wert des Feldes '''FNumbersOfSides''' (mit 3, dem Minimum) initialisieren. Durch Ändern des Feldes (anstatt der Eigenschaft) vermeiden Sie unnötige Aufrufe der Methode '''Repaint'''. Fügen Sie dem Konstruktor den folgenden Code hinzu:

<source lang='delphi'>
constructor TRegularPolygon.Create(AOwner: TComponent);
begin
inherited;
FNumberOfSides := 3;
end;
</source>

== Zurück ==
* '''[[Schritt 1 - Erstellen einer neuen Komponente mit dem Experten "Neue Komponente"]]

== Weiter ==
* '''[[Schritt 3 - Definieren eines Pfades zum Zeichnen des Polygons]]

[[Category:XE2]][[Category:FMX]]
[[Category:AMMigrate]]

[[en:Step 2 - Implement a Property to Specify the Number of Sides]]
[[fr:Etape 2 - Implémenter une propriété pour spécifier le nombre de côtés]]
[[ja:ステップ 2 - 辺の数を指定するプロパティを実装する]]

Schritt 1 - Erstellen der Projekte (C++)

2014-08-28T11:30:58Z

Andreeah: Update LOC-16144

{{Parent|Erstellen einer FireMonkey-Komponente (C++)}}
Beginnen Sie das Projekt durch Schließen aller Dateien in der IDE ('''Datei > Alle schließen'''). Wählen Sie einen Speicherort und einen Namen für einen neuen Ordner aus, in dem alle Komponentendateien gespeichert werden.

===Package-Projekt===
# Wählen Sie '''Datei > Neu > Package - {{CBuilderUI}}'''
# Wählen Sie '''Datei > Projekt speichern unter''', und navigieren Sie zum Speicherort des Ordners. Erstellen Sie einen neuen Ordner, navigieren Sie zu diesem Ordner, und speichern Sie das Projekt als '''DialogButtonsPackage'''.
# Klicken Sie in der Projektverwaltung mit der rechten Maustaste auf die neu erzeugte Projektgruppe, und wählen Sie '''Projektgruppe speichern unter'''. Speichern Sie die Projektgruppe unter dem Namen '''DialogButtonsGroup''' im selben Verzeichnis wie das Projekt.

===Komponentengerüst===

Wählen Sie '''Komponente > Neue Komponente''', um den Experten [[Neue Komponente]] zu öffnen. Führen Sie in diesem Experten Folgendes aus:
# Wählen Sie als Framework und Personality '''{{FM}} für C++'''.
# Wählen Sie '''[[lib_de:FMX.Controls.TStyledControl|TStyledControl]]''' als Vorfahre aus.
# Legen Sie als Klassenname '''TDialogButtonPanel''' fest. Klicken Sie zum Festlegen des Unit-Namens auf die Ellipse, vergewissern Sie sich, dass der Komponentenordner geöffnet ist, und speichern Sie die Unit-Datei unter dem Namen '''DialogButtons'''.
# Wählen Sie '''Unit dem Projekt DialogButtonsPackage.cbproj hinzufügen''', und klicken Sie auf '''Fertig stellen'''.
# Klicken Sie bei der Aufforderung '''DialogButtons speichern unter''' auf '''Speichern'''.
# Wenn Sie zur Aktivierung des {{FM}}-Frameworks aufgefordert werden, klicken Sie auf '''Ja'''.
Mit diesen Schritten haben Sie eine Unit mit der Komponentenklasse und eine Register-Prozedur zum Hinzufügen der Klasse zur Komponentenpalette erstellt. Überprüfen Sie, ob die Datei '''DialogButtonsPackage.pas''' dem Package hinzugefügt wurde. Sie sollte in der Projekthierarchie unter dem Knoten '''Enthält''' angezeigt werden.

[[File:DialogButtons_in_project_three_C%2B%2B.png]]

===Arbeiten mit den Projekten/Testen der Projekte===

# Klicken Sie mit der rechten Maustaste auf die Projektgruppe, und wählen Sie '''Neues Projekt hinzufügen'''.
# Wählen Sie im Dialogfeld '''Objektgalerie''' den Eintrag '''{{CBuilderUI}}-Projekte > Geräteübergreifende Anwendung > Leere Anwendung'''.
# Wählen Sie '''Datei > Speichern unter''', navigieren Sie zu dem Komponentenordner, und speichern Sie die Formular-Unit als '''PanelTest'''.
# Wählen Sie '''Datei > Projekt speichern unter''', vergewissern Sie sich, dass der Komponentenordner geöffnet ist, und speichern Sie das Projekt unter dem Namen '''PanelTester'''.
# Klicken Sie mit der rechten Maustaste auf das Projekt, wählen Sie '''Neue hinzufügen > Geräteübergreifendes Formular > HD-Formular'''. Speichern Sie die Unit unter dem Namen '''TestDialog'''.
# Klicken Sie mit der rechten Maustaste auf das Projekt, wählen Sie '''Neue hinzufügen > Geräteübergreifendes Formular > HD-Formular'''. Speichern Sie die Unit unter dem Namen '''PanelDesign'''.

==Weiter==
* [[Schritt 2 - Entwerfen des Schaltflächenbereichs (C++)|Schritt 2 - Entwerfen des Schaltflächenbereichs (C++)]]

==Siehe auch==
* [[FireMonkey-Komponentendesign]]
* [[Verwenden des Experten für neue Komponenten]]
* [[Erstellen einer FireMonkey-Komponente (C++)]]
* [[Erstellen einer mit Stilen versehenen FireMonkey-Komponente durch Erweitern einer vorhandenen Komponente ]]
* [[Erstellen eines grundlegenden FireMonkey-Steuerelements]]
[[Category:XE3]][[Category:FMX]][[Category:C++]]
[[Category:AMMigrate]]

[[en:Step 1 - Create the Projects (C++)]]
[[fr:Etape 1 - Créer les projets (C++)]]
[[ja:ステップ 1 - プロジェクトを作成する（C++）]]

Schritt 1 - Erstellen einer Komponente mit dem Experten "Neue Komponente"

2014-08-28T11:30:11Z

Andreeah: Update LOC-16144

{{Parent|Erstellen einer mit Stilen versehenen FireMonkey-Komponente durch Erweitern einer vorhandenen Komponente}}

# Wählen Sie '''Komponente > [[Neue Komponente|Neue Komponente]]'''.
# Wählen Sie auf der ersten Seite des Experten [[Neue Komponente|Neue Komponente]] die Option '''{{FM}} für {{Delphi}}''' oder '''{{FM}} für C++''' aus: : 
#:[[Image:NewComponentPerson1.png]]
# Wählen Sie auf der Seite '''Vorfahrkomponente''' die Komponente '''[[lib_de:FMX.StdCtrls.TLabel|TLabel]]''' als Vorfahre der neuen Komponente aus: 
#:[[Image:AncestorComponentStep.png]]
# Geben Sie '''TClockLabel''' auf der Seite '''Neue Komponente''' als Name der Klasse ein. Geben Sie im Feld '''Unit-Name''' {{Path|{{ProjectsPath}}\ClockLabel.pas}} als Name der zu erstellenden Datei ein: 
#:[[Image:ComponentPage.png]] 
#: '''Hinweis:''' Merken Sie sich den angegebenen Pfad.
# Aktivieren Sie auf der Seite '''Unit erstellen''' das Optionsfeld '''In neues Package installieren''': 
#:[[Image:InstalltoNew.png]]
# Geben Sie auf der Seite '''Neues Package''' als Name des neuen Package, das erstellt werden soll, '''ClockLabel''' ein: 
#:[[Image:NewPackageClockLabel.png]]
# Der Experte öffnet das Dialogfeld ''''<Unit-Datei>' speichern unter''', in dem Sie den Namen und den Pfad der generierten Unit-Datei bestätigen müssen.
## Erstellen Sie ein neues Komponenten-Package, indem Sie auf '''Neuer Ordner''' klicken und einen Namen, wie z. B. '''ClockLabel''', angeben.
## Überprüfen Sie, ob {{Path|{{ProjectsPath}}\ClockLabel\ClockLabel.pas}} angezeigt wird. Überprüfen Sie genau, ob der angezeigte Pfad richtig ist!
#:[[Image:ConfirmTClockLabelUnitFile.png|600px| Unit-Datei bestätigen]]
# Sie haben nun ein neues Package-Projekt erstellt. Bestätigen Sie nach dem Speichern des Projekts mit '''Ja''', dass dieses Package für {{FM}} vorgesehen ist: 
#:[[Image:ConfirmUnitClockLabel.png]]
# Mit der folgenden Meldung wird bestätigt, dass die neue Komponente erzeugt, installiert und in {{Product}} registriert wurde: 
#:[[Image:InformationPage.png]]
#: '''Hinweis:''' Merken Sie sich den Pfad der erstellten <code>.BPL</code>-Datei.
# Erstellen Sie eine neue [[Geräteübergreifende Anwendung|geräteübergreifende Anwendung]], indem Sie in der '''Projektverwaltung''' mit der rechten Maustaste auf die Projektgruppe klicken und aus dem Kontextmenü '''Neues Projekt hinzufügen''' wählen. Wählen Sie '''Leere Anwendung'''. 
#:[[Image:AddNewProjectMenu.png]]
# Speichern Sie die neue geräteübergreifend Anwendung unter '''TestClockLabel.dproj''' und die Unit unter '''TestClockLabelUnit.pas'''. Speichern Sie die Projektgruppe unter '''ClockLabelProjectGroup.groupproj''', indem Sie in der '''Projektverwaltung''' mit der rechten Maustaste auf den Projektgruppeneintrag klicken und im Kontextmenü '''Projektgruppe speichern unter''' auswählen. Mit diesem Befehl werden zuerst nacheinander Dialogfelder zum Speichern jedes Projekts der Projektgruppe und zum Schluss das Dialogfeld zum Speichern der Projektgruppe angezeigt.
# Wenn '''Form1''' im '''Formular-Designer''' geöffnet ist, wird nun in der '''Tool-Platte''' die neue '''TClockLabel'''-Komponente angezeigt. Wenn Sie aber '''TClockLabel''' im '''Formular-Designer''' einfügen, werden Sie feststellen, dass '''TClockLabel''' genauso wie '''TLabel''' aussieht. Und zwar, weil noch keine neuen Funktionen implementiert wurden.
#:[[Image:LastOneHere.png|600px]]
# Als Nächstes wird die Komponente '''TClockLabel''' implementiert.

==Weiter==

* [[Schritt 2 - Implementieren einer Eigenschaft zum Angeben des Formats|Schritt 2 - Implementieren einer Eigenschaft zum Angeben des Formats]]

[[Category:XE2]]
[[Category:FMX]]
[[Category:AMMigrate]]

[[en:Step 1 - Create a Component Using the New Component Wizard]]
[[fr:Etape 1 - Créer un composant en utilisant l'expert Nouveau composant]]
[[ja:ステップ 1 - ［コンポーネントの新規作成］ウィザードを使ってコンポーネントを作成する]]

Installieren von Xcode auf einem Mac

2014-08-28T11:08:25Z

Andreeah: Update LOC-16144

{{Parent|Mac OS X-Anwendungsentwicklung}}
{{Parent|Mobile iOS-Anwendungsentwicklung}}

'''[http://developer.apple.com/xcode/ Xcode]''', die Entwicklungs- und Debug-Umgebung auf dem Mac, stellt die erforderlichen Entwicklungsdateien für [[Mac OS X-Anwendungsentwicklung|Mac OS X]]- und [[Mobile iOS-Anwendungsentwicklung|iOS]]-Anwendungen bereit.

Xcode kann von einer der folgenden Quellen installiert werden:

* Doppelklicken Sie zum Installieren von Xcode auf Ihrem System auf der Mac OS X-Installations-DVD unter dem Verzeichnis für optionale Installationen auf '''Xcode.mpkg'''.
* Laden Sie Xcode kostenlos aus dem [http://www.apple.com/mac/app-store/ Mac App Store] herunter.
* Als registrierter Apple-Entwickler können Sie die kostenlose Version von Xcode als Paket (<code>.dmg</code>) herunterladen. So registrieren Sie sich und laden Xcode herunter:
*# Registrieren Sie sich (kostenlos) als Apple-Entwickler unter [http://developer.apple.com/programs/register/ http://developer.apple.com/programs/register/].
*# Laden Sie Xcode als Paket von [https://developer.apple.com/downloads https://developer.apple.com/downloads] herunter.

==Siehe auch==

* [[Arbeiten mit einem Mac und einem PC]]
* [[Installieren der Xcode-Befehlszeilen-Tools auf einem Mac]]
* [[Plattformvoraussetzungen für FireMonkey]]

[[Category:IOS]]
[[Category:Mac OS X]]
[[Category:XE4]]
[[Category:AMMigrate]]

[[en:Installing Xcode on a Mac]]
[[fr:Installation de Xcode sur un Mac]]
[[ja:Mac での Xcode のインストール]]

FireMonkey Quick Start - Bild- und Animationseffekte

2014-08-28T11:02:29Z

Andreeah: Update LOC-16144

{{Parent|FireMonkey Quick Start - Einführung}}

[[File:FMQS_A2.png|link={{FM}} Quick Start - Einführung]][[File:FMQS_B2.png|link={{FM}} Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_C2.png|link={{FM}} Quick Start - Tutorials - Meine erste {{FM}}-Anwendung]][[File:FMQS_D2.png|link={{FM}} Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_E2.png|link={{FM}} Quick Start - Programmiersprachen {{Delphi}} und C++]][[File:FMQS_F2.png|link={{FM}} Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_G2.png|link={{FM}} Quick Start - Verbinden mit Daten]][[File:FMQS_H2.png|link={{FM}} Quick Start - Erstellen von 3D-Anwendungen]][[File:FMQS_I.png|link={{FM}} Quick Start - Bild- und Animationseffekte]][[File:FMQS_J2.png|link={{FM}} Quick Start - Weitere Informationen]] 

[[File:FMQS_12.png|link={{FM}} Quick Start - Einführung]][[File:FMQS_22.png|link={{FM}} Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_32.png|link={{FM}} Quick Start - Tutorials - Meine erste {{FM}}-Anwendung]][[File:FMQS_42.png|link={{FM}} Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_5.png|link={{FM}} Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_62.png|link={{FM}} Quick Start - Weitere Informationen]]

[[File:WhiteSpace50.png]] 

Die integrierte {{FM}} ImageFX-Engine bietet eine einfach zu verwendende schattierergestützte GPU-Bildverarbeitung ohne komplexe Programmierung. Mit der ImageFX-Engine können Bildumwandlungen, Echtzeiteffekte, UI-Effekte und vieles mehr durchgeführt werden. Wie Photoshop und CoreImage unterstützt ImageFX mehrere Filter und nutzt gleichzeitig eine einzelne dynamische GPU-Anweisungspipeline für eine zeitnahe, pixelgenaue Darstellung.

[[File:WhiteSpace50.png|16px]] 

[[File:Tiger no outline 2.png|219px]]

[[File:WhiteSpace50.png|16px]] 

* '''Tutorial: In [[Verwenden von FireMonkey-Bildeffekten]]''' erhalten Sie einen Überblick über Bildeffekte in {{FM}}-Anwendungen.

[[File:WhiteSpace50.png]] 

Alle HD- und 3D-Objekte von {{FM}} können über zeitbasierte Animationen zum Erstellen von Bewegung, Übergängen und Effekten animiert werden. Sie können Animationen zum Erstellen von hochinteraktiven Anwendungen, Kiosks und Demonstrationen an Benutzersteuerelemente und Eingabemethoden, wie Maus-, Touch- und Bewegungs-Controller, koppeln.

[[File:WhiteSpace50.png|16px]] 

[[File:Butterfly.png|300px]]

[[File:WhiteSpace50.png|16px]] 

* '''Tutorial: In [[Verwenden von FireMonkey-Animationseffekten]]''' erhalten Sie einen Überblick über Animationseffekte in {{FM}}-Anwendungen.

[[File:Next Page.png|right|100px|link={{FM}} Quick Start - Weitere Informationen]]

[[File:WhiteSpace50.png]] 

[[Category: {{FM}} Quick Start]]
[[Category:AMMigrate]]

[[en:FireMonkey Quick Start Guide - Using Image and Animation Effects]]
[[fr:Guide de prise en main FireMonkey - Utilisation des effets d'image et d'animation]]
[[ja:FireMonkey クイックスタートガイド - 画像効果とアニメーション効果の利用]]

FireMonkey Quick Start - Tutorials - Meine erste FireMonkey-Anwendung

2014-08-28T10:57:50Z

Andreeah: Update LOC-16144

{{Parent|FireMonkey Quick Start - Einführung}}

[[File:FMQS_A2.png|link={{FM}} Quick Start - Einführung]][[File:FMQS_B2.png|link={{FM}} Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_C.png|link={{FM}} Quick Start - Tutorials - Meine erste {{FM}}-Anwendung]][[File:FMQS_D2.png|link={{FM}} Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_E2.png|link={{FM}} Quick Start - Programmiersprachen {{Delphi}} und C++]][[File:FMQS_F2.png|link={{FM}} Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_G2.png|link={{FM}} Quick Start - Verbinden mit Daten]][[File:FMQS_H2.png|link={{FM}} Quick Start - Erstellen von 3D-Anwendungen]][[File:FMQS_I2.png|link={{FM}} Quick Start - Bild- und Animationseffekte]][[File:FMQS_J2.png|link={{FM}} Quick Start - Weitere Informationen]] 

[[File:FMQS_12.png|link={{FM}} Quick Start - Einführung]][[File:FMQS_22.png|link={{FM}} Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_3.png|link={{FM}} Quick Start - Tutorials - Meine erste {{FM}}-Anwendung]][[File:FMQS_42.png|link={{FM}} Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_52.png|link={{FM}} Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_62.png|link={{FM}} Quick Start - Weitere Informationen]]

[[File:WhiteSpace50.png]] 

Beginnen Sie nun mit der Entwicklung Ihrer ersten {{FM}}-Anwendung.

Diese Tutorials vermitteln Ihnen ein Grundverständnis über den Entwicklungsablauf auf der {{FM}}-Anwendungsplattform. Das erste Tutorial besteht aus einem einfach nachzuvollziehenden Tutorial für eine "Hello World"-Anwendung, in dem die wesentlichen Schritte beim Erstellen einer {{FM}}-Anwendung für Desktop-Plattformen (Windows, Mac OS X) gezeigt werden. Die grundlegenden Entwicklungsschritte sind für Windows und Mac gleich.

[[File:WhiteSpace50.png]] 

[[File:My_First_FireMonkey_Application_on_Windows.png]] [[File:My_First_FireMonkey_Application_on_Mac_OS_X.png]]

[[File:WhiteSpace50.png]] 

*'''Tutorial:''' In '''[[Erstellen einer FireMonkey-Anwendung für Desktop-Plattformen (C++)]]''' werden die grundlegenden Schritte bei der Entwicklung von C++-Anwendungen für Desktop-Plattformen (Windows und Mac OS X) beschrieben.
* '''Tutorial:''' In '''[[Erstellen einer FireMonkey-Anwendung für Desktop-Plattformen]] ({{Delphi}})''' werden die grundlegenden Schritte bei der Entwicklung von {{Delphi}}-Anwendungen für Desktop-Plattformen (Windows und Mac OS X) beschrieben.
* In '''[[Mobile-Tutorial: Erstellen einer Anwendung für mobile Plattformen (iOS und Android)]]''' wird die Entwicklung einer Anwendung für mobile Plattformen (iOS und Android) beschrieben.

[[File:Next Page.png|right|100px|link={{FM}} Quick Start - Die integrierte Entwicklungsumgebung (IDE)]]

[[File:WhiteSpace50.png]] 

[[Category: {{FM}} Quick Start]]
[[Category:AMMigrate]]

[[en:FireMonkey Quick Start Guide - Tutorials - My First FireMonkey Application]]
[[fr:Guide de prise en main FireMonkey - Tutoriels - Ma première application FireMonkey]]
[[ja:FireMonkey クイックスタートガイド - チュートリアル - 初めての FireMonkey アプリケーション]]

FireMonkey Quick Start - Die integrierte Entwicklungsumgebung (IDE)

2014-08-28T10:57:12Z

Andreeah: Update LOC-16144

{{Parent|FireMonkey Quick Start - Einführung}}

[[File:FMQS_A2.png|link={{FM}} Quick Start - Einführung]][[File:FMQS_B2.png|link={{FM}} Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_C2.png|link={{FM}} Quick Start - Tutorials - Meine erste {{FM}}-Anwendung]][[File:FMQS_D.png|link={{FM}} Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_E2.png|link={{FM}} Quick Start - Programmiersprachen {{Delphi}} und C++]][[File:FMQS_F2.png|link={{FM}} Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_G2.png|link={{FM}} Quick Start - Verbinden mit Daten]][[File:FMQS_H2.png|link={{FM}} Quick Start - Erstellen von 3D-Anwendungen]][[File:FMQS_I2.png|link={{FM}} Quick Start - Bild- und Animationseffekte]][[File:FMQS_J2.png|link={{FM}} Quick Start - Weitere Informationen]] 

[[File:FMQS_12.png|link={{FM}} Quick Start - Einführung]][[File:FMQS_22.png|link={{FM}} Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_32.png|link={{FM}} Quick Start - Tutorials - Meine erste {{FM}}-Anwendung]][[File:FMQS_4.png|link={{FM}} Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_52.png|link={{FM}} Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_62.png|link={{FM}} Quick Start - Weitere Informationen]]

[[File:WhiteSpace50.png]] 

Wenn Sie {{variables|Product}} starten, wird die integrierte Entwicklungsumgebung (Integrated Development Environment, IDE) geöffnet, in der zahlreiche Tools und Menüs zur Verfügung stehen. In der IDE können Sie Benutzeroberflächen entwickeln, Objekteigenschaften festlegen, Quelltext verfassen und Ihre Anwendung anzeigen und verwalten.

[[File:WhiteSpace50.png]] 

[[File:IDE_Overview.png]]

[[File:WhiteSpace50.png]] 

==== Hilfethemen ====
* [[Verwendung von Projektvorlagen aus der Objektablage (IDE-Tutorial)|Verwendung von Projektvorlagen aus der Objektablage]]
* [[Elementare Anpassungen des Hauptformulars (IDE-Tutorial)|Elementare Anpassungen des Hauptformulars]]
* [[Hinzufügen von Komponenten im Formular-Designer (IDE-Tutorial)|Hinzufügen von Komponenten im Formular-Designer]]
* [[Anpassen der Komponenten (IDE-Tutorial)|Anpassen der Komponenten]]
* [[Programmieren von Reaktionen auf Benutzeraktionen im Quelltext-Editor (IDE-Tutorial)|Programmieren von Reaktionen auf Benutzeraktionen im Quelltext-Editor]]
* [[Compilieren und Ausführen der Anwendung (IDE-Tutorial)|Compilieren und Ausführen der Anwendung]]
* [[Debuggen der Anwendung (IDE-Tutorial)|Debuggen der Anwendung]]

[[File:Next Page.png|right|100px|link={{FM}} Quick Start - Programmiersprachen {{Delphi}} und C++]]

[[File:WhiteSpace50.png]] 

[[Category: {{FM}} Quick Start]]
[[Category:AMMigrate]]

[[en:FireMonkey Quick Start Guide - The Integrated Development Environment (IDE)]]
[[fr:Guide de prise en main FireMonkey - L'environnement de développement intégré (EDI)]]
[[ja:FireMonkey クイックスタートガイド - 統合開発環境（IDE）]]

FireMonkey Quick Start - Entwerfen der Benutzeroberfläche

2014-08-28T10:55:06Z

Andreeah: Update LOC-16144

{{Parent|FireMonkey Quick Start - Einführung}}

[[File:FMQS_A2.png|link={{FM}} Quick Start - Einführung]][[File:FMQS_B2.png|link={{FM}} Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_C2.png|link={{FM}} Quick Start - Tutorials - Meine erste {{FM}}-Anwendung]][[File:FMQS_D2.png|link={{FM}} Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_E2.png|link={{FM}} Quick Start - Programmiersprachen {{Delphi}} und C++]][[File:FMQS_F.png|link={{FM}} Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_G2.png|link={{FM}} Quick Start - Verbinden mit Daten]][[File:FMQS_H2.png|link={{FM}} Quick Start - Erstellen von 3D-Anwendungen]][[File:FMQS_I2.png|link={{FM}} Quick Start - Bild- und Animationseffekte]][[File:FMQS_J2.png|link={{FM}} Quick Start - Weitere Informationen]] 

[[File:FMQS_12.png|link={{FM}} Quick Start - Einführung]][[File:FMQS_22.png|link={{FM}} Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_32.png|link={{FM}} Quick Start - Tutorials - Meine erste {{FM}}-Anwendung]][[File:FMQS_42.png|link={{FM}} Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_5.png|link={{FM}} Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_62.png|link={{FM}} Quick Start - Weitere Informationen]]

[[File:WhiteSpace50.png]] 

{{FM}} enthält einen umfangreichen Satz von Drag&Drop-Steuerelementen für die Benutzeroberfläche. Wählen Sie Schaltflächen, Menüs, HUDs, Text, Kombinationsfelder, Tabellen, Registerkarten, Bereiche und vieles mehr, um Benutzeroberflächen ansprechend zu gestalten. Steuerelemente können vollständig angepasst und mit {{FM}}-HD-Stilen Ihren Wünschen entsprechend dargestellt werden.

Mit {{FM}}-HD-Stilen können Sie das Aussehen und Verhalten von HD-Benutzeroberflächen vollständig steuern, ohne Programmierung und ohne ein Experte für Auszeichnungssprachen zu sein. Stile können von Entwicklern oder Designern erstellt oder geändert werden. Wählen Sie aus einer Bibliothek mit vorhandenen Stilen den gewünschten aus, oder erstellen Sie eigene Benutzeroberflächen (UIs) für Ihre Anwendungen. Falls Sie das traditionelle native Design des Betriebssystems bevorzugen, haben Sie mit {{FM}} die Möglichkeit, die Windows 7-, Windows 8-, Mac OS X-, iOS- und Android-UIs beizubehalten.

[[File:WhiteSpace50.png]] 

[[File:UI_Components.png]] [[File:WhiteSpace50.png]] [[File:Native_OS_layered400w.png]]

[[File:WhiteSpace50.png]] 

* '''Tutorial:''' In [[Anpassen des Designs einer FireMonkey-Anwendung]] werden die Schritte zum Auswählen von Stilen für Ihre Anwendungen beschrieben. Darüber hinaus wird in diesem Tutorial die Anpassung des Aussehens und Verhaltens einer bestimmten Komponente durch Ändern des Stils erläutert.

[[File:Next Page.png|right|100px|link={{FM}} Quick Start - Verbinden mit Daten]]

[[File:WhiteSpace50.png]] 

{{DEFAULTSORT:FireMonkey Quick Start - Entwerfen der Benutzeroberflache}}
[[Category:{{FM}} Quick Start]]
[[Category:AMMigrate]]

[[en:FireMonkey Quick Start Guide - Designing User Interface]]
[[fr:Guide de prise en main FireMonkey - Conception de l'interface utilisateur]]
[[ja:FireMonkey クイックスタートガイド - ユーザーインターフェイスの設計]]

FireMonkey Quick Start - Erstellen von 3D-Anwendungen

2014-08-28T10:52:54Z

Andreeah: Update LOC-16144

{{Parent|FireMonkey Quick Start - Einführung}}

[[File:FMQS_A2.png|link=FireMonkey Quick Start - Einführung]][[File:FMQS_B2.png|link=FireMonkey Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_C2.png|link=FireMonkey Quick Start - Tutorials - Meine erste FireMonkey-Anwendung]][[File:FMQS_D2.png|link=FireMonkey Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_E2.png|link=FireMonkey Quick Start - Programmiersprachen Delphi und C++]][[File:FMQS_F2.png|link=FireMonkey Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_G2.png|link=FireMonkey Quick Start - Verbinden mit Daten]][[File:FMQS_H.png|link=FireMonkey Quick Start - Erstellen von 3D-Anwendungen]][[File:FMQS_I2.png|link=FireMonkey Quick Start - Bild- und Animationseffekte]][[File:FMQS_J2.png|link=FireMonkey Quick Start - Weitere Informationen]] 

[[File:FMQS_12.png|link=FireMonkey Quick Start - Einführung]][[File:FMQS_22.png|link=FireMonkey Quick Start - Einrichten der Entwicklungsumgebung]][[File:FMQS_32.png|link=FireMonkey Quick Start - Tutorials - Meine erste FireMonkey-Anwendung]][[File:FMQS_42.png|link=FireMonkey Quick Start - Die integrierte Entwicklungsumgebung (IDE)]][[File:FMQS_5.png|link=FireMonkey Quick Start - Entwerfen der Benutzeroberfläche]][[File:FMQS_62.png|link=FireMonkey Quick Start - Weitere Informationen]]

[[File:WhiteSpace50.png]] 

FireMonkey 3D-Formulare stellen eine komplette GPU-gestützte 3D-Oberfläche mit Lichteinfall, Texturen und Animationen für hochinteraktive Benutzeroberflächen bereit.

Sie können 3D-Steuerelemente, -Objekte und -Netze aus 3D-Entwurfs-Packages, wie COLLADA, 3DS und anderen, importieren.

[[File:WhiteSpace50.png]] 

[[File:3dimage.png|300px]] [[File:WhiteSpace50.png]] [[File:3d_image2.png|300px]]

[[File:WhiteSpace50.png]] 

* '''Tutorial:''' In [[Erstellen der Benutzeroberfläche (FireMonkey 3D-Tutorial)|Erstellen der Benutzeroberfläche]] wird das schrittweise Erstellen einer einfachen FireMonkey-3D-Anwendung gezeigt.

[[File:Next Page.png|right|100px|link=FireMonkey Quick Start - Bild- und Animationseffekte]]

[[File:WhiteSpace50.png]] 
==Weitere Informationen==
* [[FireMonkey 3D]]

[[Category: {{FM}} Quick Start]]
[[Category:AMMigrate]]

[[en:FireMonkey Quick Start Guide - Creating a 3D Application]]
[[fr:Guide de prise en main FireMonkey - Création d'une application 3D]]
[[ja:FireMonkey クイックスタートガイド - 3D アプリケーションの作成]]

FireMonkey-Komponentenbibliothek

2014-08-28T10:49:46Z

Andreeah: Update LOC-16144

{{parent|FireMonkey-Komponentenhandbuch}}

Die folgende Abbildung zeigt die Beziehung zwischen einigen Hauptklassen, aus denen sich die {{FM}}-Hierarchie zusammensetzt. Beim Erstellen einer {{FM}}-Komponente müssen Sie entscheiden, welche Klasse als Vorfahr (Erweiterungspunkt) für die Implementierung eines bestimmten Features verwendet werden soll. Ein Beispiel finden Sie unter [[Erstellen einer mit Stilen versehenen FireMonkey-Komponente durch Erweitern einer vorhandenen Komponente]].

[[image:FireMonkeyHierarchy2.png]]

==[[lib_de:System.TObject|System.TObject]]==
Die Klasse '''TObject''' kapselt das grundlegende Verhalten, das allen Klassen in der Komponentenbibliothek gemeinsam ist, indem sie Methoden für Folgendes einführt:
* Die Möglichkeit zu reagieren, wenn Objektinstanzen erstellt oder freigegeben werden.
* Klassentyp- und Instanzinformationen zu einem Objekt, ebenso wie Laufzeittypinformationen (RTTI, Runtime Type Information) für seine published-Eigenschaften.

==[[lib_de:System.Classes.TPersistent|TPersistent]]==
Die ''Persistenz'' legt fest, was in einer Formulardatei oder in einem Datenmodul gespeichert wird und was beim Laden des Formulars oder des Datenmoduls aus dem Speicher abgerufen wird.

Klassen, die von '''TPersistent''' abstammen, können als published-Eigenschaft verwendet werden, damit auf diese Eigenschaften über den [[Objektinspektor]] zugegriffen werden kann.

==[[lib_de:System.Classes.TComponent|TComponent]] – Nicht visuelle Komponenten==
Nicht visuelle Komponenten werden in der [[Tool-Palette]] angezeigt und können auf Formularen während des Entwurfs bearbeitet werden, sind aber für den Benutzer zur Laufzeit nicht sichtbar.

Typische Anwendungszwecke von nicht visuellen Komponenten:
* Verwalten von Verbindungen mit Datenbanken
* Verwenden als Zeitgeber (zur Definition von Ereignissen für periodische Aktionen)

==[[lib_de:FMX.Types.TFmxObject|TFmxObject]]==
'''TFmxObject''' erweitert '''TComponent''', um für {{FM}}-Komponenten Low-Level-Funktionen wie die folgenden bereitzustellen:
* Erstellen, Auflösen und Freigeben von Objekten
* Klonen, Speichern und Laden von Objekten aus einem Stream
* Manipulationen von untergeordneten Objekten (Hinzufügen, Entfernen, Suchen)
* Freigabebenachrichtigungen

==[[lib_de:FMX.Controls.TControl|TControl]]==
'''TControl''' ist die Basisklasse für FMX-Bildschirmkomponenten. In der Regel erstellen Sie eine Klasse auf der Basis von [[lib_de:FMX.Objects.TShape|TShape]], [[lib_de:FMX.Controls.TStyledControl|TStyledControl]] oder [[lib_de:FMX.Controls3D.TControl3D|TControl3D]] anstatt auf der Basis von [[lib_de:FMX.Controls.TControl|TControl]].

===[[lib_de:FMX.Objects.TShape|TShape]] – {{FM}}-Grundelemente===
'''TShape''' ist die Basisklasse für grafische 2D-Grundelemente – [[lib_de:FMX.Objects.TLine|TLine]], [[lib_de:FMX.Objects.TRectangle|TRectangle]], [[lib_de:FMX.Objects.TPath|TPath]] und andere. Diese Klassen überschreiben die '''Paint'''-Methode, um sich selbst zu zeichnen. Diese Klassen ändern ihr Aussehen und Verhalten nicht selbst. Für verschiedene Stile können Sie Folgendes auswählen:
* Ein Grundelement mit unterschiedlichen, festgelegten Eigenschaften
* Unterschiedliche Grundelemente auf Basis eines Stils

===[[lib_de:FMX.Controls.TStyledControl|TStyledControl]] – Mit Stilen versehene Steuerelemente===
'''TStyledControl''' ist die Basisklasse für anpassbare und Benutzerinteraktions-Steuerelemente. Diese Klassen definieren ihr Aussehen und Verhalten durch eine Stilressource, die Sie jederzeit ändern können. Zum Erstellen der Benutzeroberfläche wird durch die Stilressource ein bestimmtes Grundelement (Menge von Grundelementen oder Menge von mit Stilen versehenen Steuerelementen) anhand einer Stildatei ausgewählt.

===[[lib_de:FMX.Controls3D.TControl3D|TControl3D]] – 3D-Steuerelemente===
'''TControl3D''' erweitert '''TFmxObject''', um Objekte bereitzustellen, die auf dem Bildschirm angezeigt werden können, indem Eigenschaften und Methoden für Folgendes hinzugefügt werden:
* [[lib_de:FMX.Controls3D.TControl3D.Opacity|Opazität]], [[lib_de:FMX.Controls3D.TControl3D.Scale|Skalierung]] und [[lib_de:FMX.Controls3D.TControl3D.Visible|Sichtbarkeit]]
* 3D-Größen:
** [[lib_de:FMX.Controls3D.TControl3D.Depth|Tiefe (Depth)]], [[lib_de:FMX.Controls3D.TControl3D.Height|Höhe (Height)]] und [[lib_de:FMX.Controls3D.TControl3D.Width|Breite (Width)]]
* 3D-Position relativ zu den X-, Y- und Z-Achsen:
** [[lib_de:FMX.Controls3D.TControl3D.Position|Position]]
* 3D-Drehung relativ zu den X-, Y- und Z-Achsen:
** [[lib_de:FMX.Controls3D.TControl3D.RotationAngle|RotationAngle]]
* Maus- und Tastaturinteraktion durch Ereignisse:
** [[lib_de:FMX.Controls3D.TControl3D.OnMouseDown|OnMouseDown]], [[lib_de:FMX.Controls3D.TControl3D.OnMouseMove|OnMouseMove]] oder [[lib_de:FMX.Controls3D.TControl3D.OnKeyDown|OnKeyDown]]
* Zeichnen und Rendern

==Siehe auch==
* [[Erstellen einer mit Stilen versehenen FireMonkey-Komponente durch Erweitern einer vorhandenen Komponente]]
[[Category:FMX]][[Category:XE2]]
[[Category:AMMigrate]]

[[en:FireMonkey Component Library]]
[[fr:Bibliothèque des composants FireMonkey]]
[[ja:FireMonkey コンポーネントライブラリ]]

Erstellen einer FireMonkey-Komponente (C++)

2014-08-28T10:31:11Z

Andreeah: Update LOC-16144

{{Parent|FireMonkey-Komponentenhandbuch}}
==Beispiel: Schaltflächenbereich (TPanel) in Dialogfeldern==
Windows und Mac OS X unterstützen Richtlinien für Benutzeroberflächen, die auch die Reihenfolge und Anordnung von Standardschaltflächen ('''"Ausführen"/"Nicht ausführen"/"Abbrechen"''') in Dialogfeldern umfassen. Die Richtlinien für diese beiden Plattformen unterscheiden sich geringfügig. Ein einfaches Beispiel dafür ist ein '''Speichern'''-Dialogfeld mit den Schaltflächen '''Speichern''', '''Nicht speichern''' und '''Abbrechen'''. Die hier erstellte benutzerdefinierte Komponente '''TDialogButtonPanel''' kapselt diese Unterschiede durch plattformspezifische, als RCDATA einbezogene Stildateien.

Folgende Schritte sind erforderlich:
* [[Schritt 1 - Erstellen der Projekte (C++)]]
* [[Schritt 2 - Entwerfen des Schaltflächenbereichs (C++)]]
* [[Schritt 3 - Hinzufügen von Stilressourcen als RCDATA (C++)]]
* [[Schritt 4 - Festlegen der Größe und der Ausrichtung (C++)]]
* [[Schritt 5 - Benutzerdefinierte Eigenschaften (C++)]]

==Siehe auch==
* [[FireMonkey-Komponentendesign]]
* [[Verwenden des Experten für neue Komponenten]]
* [[Erstellen einer FireMonkey-Komponente ({{Delphi}})]]
* [[Erstellen einer mit Stilen versehenen FireMonkey-Komponente durch Erweitern einer vorhandenen Komponente ]]
* [[Erstellen eines grundlegenden FireMonkey-Steuerelements]]
[[Category:XE3]][[Category:FMX]][[Category:C++]]
[[Category:AMMigrate]]

[[en:Creating a FireMonkey Component (C++)]]
[[fr:Création d'un composant FireMonkey (C++)]]
[[ja:FireMonkey コンポーネントの作成（C++）]]

Suchen von Definitionen von Klassen-, Interface-, Typ- und Klassen/Interface-Membern mit dem C++-Klassen-Explorer

2014-08-27T10:19:34Z

Andreeah: Update LOC-16061

{{parent|C++-Klassen-Explorer - Themen}}

Klassen und Interfaces erscheinen im C++-Klassen-Explorer automatisch. Die Deklarationen werden im Fenster '''Quelle''' angezeigt. Die Deklarationen oder die Definitionen lassen sich im '''Quelltext-Editor''' - wie im Folgenden beschrieben - suchen.

'''So suchen Sie die Definition eines in der Typliste angezeigten Elements:'''

Öffnen Sie in {{CBuilder}} ein C++-Projekt, das die verwaltete [[Unit]] (.cpp-/.h-Dateien) enthält, die die Klassen, Interfaces und Typen definiert, die Sie untersuchen möchten.
# Wählen Sie '''Ansicht > C++-Klassen-Explorer'''.
# Klicken Sie, nachdem sich die '''Typliste''' (linker Bereich) gefüllt hat, auf die gewünschte Klasse, das Interface, den Typ oder den Member.
#* Die '''Member-Ansicht''' zeigt die Member der Klasse oder des Interface an.
#* Im Fenster '''Quelle''' wird die Deklaration der Klasse oder des Interface schreibgeschützt angezeigt.
# Um die Definition eines Eintrags aus der '''Typliste''' anzuzeigen und optional zu bearbeiten, wählen Sie den Eintrag aus und führen einen der folgenden Schritte aus:
#* Klicken Sie mit der rechten Maustaste auf den Eintrag, und wählen Sie aus dem Kontextmenü '''Zur Definition wechseln'''.
#* Klicken Sie in der Symbolleiste auf die Schaltfläche '''Zur Definition dieser Deklaration wechseln'''[[image:ClExplGoToDef.png]].
:: Das Fenster des '''Quelltext-Editors''' wird geöffnet. Der Fokus befindet sich auf der Zeile mit der Definition, so dass Sie bei Bedarf den Quelltext ändern können.

==Siehe auch==
* [[Übersicht über den C++-Klassen-Explorer]]
* [[C++-Klassen-Explorer (Fenster)]]
* [[Suchen von Deklarationen von Klassen-, Interface-, Typ- und Klassen/Interface-Membern mit dem C++-Klassen-Explorer]]

[[Category:C++-Referenz]]
[[Category:C++]]

[[en:Locating Definitions of Classes, Interfaces, Types, and Class/Interface Members with the C++ Class Explorer]]
[[fr:Localisation des définitions de classes, interfaces, types et membres de classe/interface avec l'explorateur de classes C++]]
[[ja:C++ クラスエクスプローラでクラス、インターフェイス、型、クラスメンバ、およびインターフェイスメンバの定義を検索する]]

Ändern des lokalen Stammverzeichnisses von SDKs für Mac OS X, iOS-Geräte oder iOS-Simulatoren

2014-08-27T07:29:55Z

Andreeah: Andreeah verschob Seite Ändern des lokalen Stammverzeichnisses von SDKs für Mac OS X, iOS-Geräte oder iOS-Simulatoren nach Ändern des lokalen Stammverzeichnisses von SDKs für Mac OS X, iOS-Geräte oder den iOS-Simulator: LOC-16052

#WEITERLEITUNG [[Ändern des lokalen Stammverzeichnisses von SDKs für Mac OS X, iOS-Geräte oder den iOS-Simulator]]

Vorlage:TrueOption

2014-08-26T11:18:15Z

Andreeah: Created Template LOC-15995

[[File:NewerTrueCheckbox.png|true]]<noinclude>[[Category:Formatierungsvorlagen]]

Übertragen von Änderungen an die Versionskontrolle

2014-08-25T09:14:10Z

Andreeah: Update LOC-15897

{{Parent|Subversion-Integration in der IDE}}

Beim Übertragen wird eine Datei oder ein Projekt im Repository gespeichert. Alle Benutzer können dann auf die Änderungen zugreifen, indem Sie ihre lokalen Kopien der Datei oder des Projekts aktualisieren.

'''Commit''' überträgt Ihre Änderungen an das lokale oder Remote-Repository.

'''So übertragen Sie eine bestimmte Datei:'''
# Klicken Sie in der [[Projektverwaltung]] mit der rechten Maustaste auf die Datei, die Sie übertragen möchten.
# Wählen Sie im Kontextmenü {{Menu|Subversion > Übertragen}}. Der Bereich [[Übergeben (SVN)]] wird im Hauptfenster der IDE angezeigt.
# Geben Sie in das Feld '''Kommentar''' einen Kommentar für das Protokoll ein. Die Kommentare der zuvor übertragenen Versionen werden angezeigt (oder können ausgewählt werden).
# Klicken Sie auf '''Übertragen'''. Das Versionskontrollsystem zeigt die Ergebnisse im [[Fenster: Meldungen|Meldungsfenster]] an.

'''So übertragen Sie ein Verzeichnis oder ein gesamtes Projekt:'''
# Klicken Sie in der [[Projektverwaltung]] mit der rechten Maustaste auf den Ordner oder das Projekt, das Sie übertragen möchten.
# Wählen Sie im Kontextmenü {{Menu|Subversion > Übertragen}}.
# Wählen Sie im Untermenü '''Übertragen''' des Kontextmenüs einen der folgenden Befehle aus:
#* '''Aus Repository-Stammverzeichnis''' durchsucht die Verzeichnisstruktur nach dem letzten Verzeichnis, das von demselben Repository wie die Projektdatei verwaltet wird und fügt dann dem Bereich '''Übertragen''' alle Dateien aus diesem Verzeichnis und aus dessen Unterverzeichnissen hinzu.
#* '''Aus Projektverzeichnis''' fügt dem Bereich '''Übertragen''' alle Dateien aus dem Projektverzeichnis und aus dessen Unterverzeichnissen hinzu.
#* '''Dateien in diesem Projekt''' fügt dem Bereich '''Übertragen''' alle in der '''Projektverwaltung''' aufgelisteten Dateien (und zugehörige Dateien) hinzu.
# Der Bereich [[Übergeben (SVN)|Übergeben]] wird im Hauptfenster der IDE angezeigt. Wählen Sie im Feld '''Übertragen nach: Position''' die Dateien aus, die Sie übertragen möchten.
# Geben Sie in das Feld '''Kommentar''' einen Kommentar für das Protokoll ein. Die Kommentare der zuvor übertragenen Versionen werden angezeigt.
# Klicken Sie auf '''Übertragen'''. Das Versionskontrollsystem zeigt die Ergebnisse im [[Fenster: Meldungen|Meldungsfenster]] an.

:'''Hinweis''': Um Konflikte zwischen Versionen zu vermeiden, sollten Sie vor dem Ändern immer eine Aktualisierung Ihrer lokalen Dateien durchführen. Andernfalls besteht das Risiko, dass Sie eine veraltete Datei übertragen, was zu Sperrungen führen kann, die Sie mit dem Befehl '''Bereinigen''' (verfügbar in der [[Projektverwaltung]]) wieder beheben müssen. Für Subversion können Sie [[Aktualisieren (SVN)]] verwenden.

==Siehe auch==
* [[Subversion-Integration in der IDE]]
* [[Übergeben (SVN)]]
* [[Aktualisieren (SVN)]]
* [[Versionsverwaltung]]

{{DEFAULTSORT:Ubertragen von Anderungen an die Versionskontrolle}}
[[Category:{{Delphi}}]]
[[Category:C++]]
[[Category:AMMigrate]]

[[en:Committing Changes to Version Control]]
[[fr:Validation des modifications dans le contrôle de version]]
[[ja:変更をバージョン管理にコミットする]]

Auschecken einer Kopie eines Repository

2014-08-25T08:46:08Z

Andreeah: Update LOC-15897

{{Parent|Subversion-Integration in der IDE}}

An ein bestimmtes Subversion-Kontrollsystem übertragene Dateien holen Sie auf Ihren lokalen Computer, in dem Sie eine Kopie eines Remote-Repository herunterladen.

# Wählen Sie {{Menu|Datei > Aus der Versionskontrolle öffnen > Subversion}}. Das Dialogfeld [[Auschecken (SVN)|Auschecken]] wird angezeigt.
# Geben Sie die Adresse des Repository in das Feld '''URL des Repository''' ein oder klicken Sie auf die Ellipsen-Schaltfläche, um danach zu suchen. Beispiel: <nowiki>http://dtg-svn/myco.net/source/trunk</nowiki>)
# Geben Sie das Verzeichnis für die herunterladenen Dateien in das Feld '''Ziel''' ein, oder klicken Sie auf die Ellipsen-Schaltfläche [...], um danach zu suchen.
# Wählen Sie die Subversion-Optionen aus:
#* Aktivieren Sie '''Rekursiv''', wenn Sie auch alle Dateien auschecken möchten, die sich in Unterverzeichnissen der Repository-Adresse befinden.
#* Aktivieren Sie '''Externals einschließen''', wenn Dateien einbezogen werden sollen, die erforderlich aber eigentlich kein Bestandteil des Repository sind.
#* Aktivieren Sie das Kontrollkästchen '''Aktuelle Revision''', oder deaktivieren Sie es, und geben Sie eine Revisionsnummer ein.
# Klicken Sie auf '''OK''', um den Kopiervorgang zu starten, oder klicken Sie auf '''Abbrechen''', um das Herunterladen abzubrechen.

==Siehe auch==
* [[Subversion-Integration in der IDE]]
* [[Auschecken (SVN)]]
* [[Übergeben (SVN)]]
* [[Versionsverwaltung]]

[[Category:{{Delphi}}]]
[[Category:C++]]

[[en:Checking Out a Copy of a Repository]]
[[fr:Extraction d'une copie d'un référentiel]]
[[ja:リポジトリのコピーをチェックアウトする]]

Anzeigen von Subversion-Kommentaren

2014-08-25T08:37:44Z

Andreeah: Andreeah verschob Seite Anzeigen von Subversion-Kommentaren nach Anzeigen von Versionskontroll-Kommentaren: LOC-15897

#WEITERLEITUNG [[Anzeigen von Versionskontroll-Kommentaren]]

Subversion SSL-Server

2014-08-06T14:15:53Z

Andreeah: Update LOC-15900

{{parent|Subversion-Integration in der IDE}}

In diesem Dialogfeld werden Sie gefragt, ob ein bestimmtes, ebenfalls in dem Dialogfeld angezeigtes SSL-Server-Zertifikat verwendet werden darf.

Klicken Sie auf '''OK''', wenn Sie damit einverstanden sind, oder auf '''Abbrechen''', um es abzulehnen.

Wenn Sie '''OK''' wählen, können Sie diese Authentifizierung speichern, indem Sie das Kontrollkästchen '''Authentifizierungsdaten speichern''' aktivieren.

==Siehe auch==
* [[Subversion-Integration in der IDE]]
* [[Zu öffnendes Projekt oder Projektgruppe auswählen]]
* [[Subversion-Anmeldung]]
* [[Subversion SSL-Client-Zertifikat]]

[[Category:AMMigrate]]

[[en:Subversion SSL Server]]
[[fr:Subversion SSL Server]]
[[ja:［Subversion SSL サーバー］]]

Subversion SSL-Client-Zertifikat

2014-08-06T14:13:15Z

Andreeah: Update LOC-15900

{{Parent|Subversion-Integration in der IDE}}

{{Menu| Ansicht > Projektverwaltung > Rechtsklick auf eine Datei > Subversion > ... }}

Wenn der Server ein SSL-Zertifikat erfordert, wird nach dem klassischen [[Subversion-Anmeldung|Anmeldungsdialogfeld]] das Dialogfeld '''Subversion SSL-Client-Zertifikat''' angezeigt.

{| border="1" frame="hsides" rules="rows"
! '''Element'''
! '''Beschreibung '''
|- valign="top"
|
Zertifikatsdatei
|
Geben Sie den Pfad zu der für den Server erforderlichen Zertifikatsdatei ein, oder fügen Sie ihn mithilfe der Durchsuchen-Schaltfläche [[Image:BrowseForFile.jpg]] ein.
|- valign="top"
|
Zertifikat speichern
|
Aktivieren Sie dieses Kontrollkästchen, wenn dieses Zertifikat auf dem aktuellen Computer gespeichert werden soll.
|- valign="top"
|
Schaltfläche OK
|
Drücken Sie diese Schaltfläche, um das Zertifikat für den Server bereitzustellen.
|- valign="top"
|
Schaltfläche Abbrechen
|
Drücken Sie diese Schaltfläche, um den Vorgang abzubrechen.
|- valign="top"
|}

==Siehe auch==
* [[Subversion-Integration in der IDE]]
* [[Zu öffnendes Projekt oder Projektgruppe auswählen]]
* [[Subversion-Anmeldung]]
* [[Subversion SSL-Server]]

[[Category:AMMigrate]]

[[en:Subversion SSL Client Certificate]]
[[fr:Certificat Subversion SSL Client]]
[[ja:［Subversion SSL クライアント証明書］]]

Repository-Browser

2014-08-06T13:22:22Z

Andreeah: Update LOC-15897

{{parent|Projektverwaltung}}

'''[[Projektverwaltung]]''' | Rechtsklick auf eine Datei oder ein Projekt unter SVN | {{Menu|Subversion > Repository durchsuchen}}

'''[[Projektverwaltung]]''' | Rechtsklick auf ein Projekt | {{Menu|Subversion > Der Versionskontrolle hinzufügen}} | Klick auf [[Image:ProjectOptionsEllipsis.jpg|Ellipsen-Schaltfläche]] neben der URL des Repository

{{Menu|Datei > Aus der Versionskontrolle öffnen}} | Klick auf [[Image:ProjectOptionsEllipsis.jpg|Ellipsen-Schaltfläche]] neben der URL des Repository

'''[[Quelltext-Editor]]''' | Mit der rechten Maustaste auf eine Datei unter SVN klicken | {{Menu|Versionskontrolle > Subversion > Repository durchsuchen}}

Der '''Repository-Browser''' zeigt alle Dateien und Verzeichnisse in einem gegebenen Repository an.

{| border="1" frame="hsides" rules="rows"
! '''Element'''
! '''Beschreibung'''
|- valign="top"
|
Laden
|
Lädt die Verzeichnis- und Dateistruktur des angegebenen Repository. Wenn kein URL angegeben ist, wird das Haupt-Repository geladen.
|- valign="top"
|
URL
|
Das Stammverzeichnis des Repository, das angezeigt werden soll.
|- valign="top"
|
Revision
|
Zeigt die Dateien und Verzeichnisse mit einer angegebenen Revisionsnummer an. Die '''HEAD'''-Revision ist die zuletzt übertragene Revision.
|- valign="top"
|
Struktur
|
Hier wird die Verzeichnisstruktur des angegebenen Repository angezeigt.
|- valign="top"
|
Dateien
|
Hier werden alle Repository-Dateien und Verzeichnisse des in der Struktur ausgewählten Verzeichnisses angezeigt.
|}

==Siehe auch==
* [[Subversion-Integration in der IDE]]
* [[Auschecken (SVN)]]
* [[Importbereich]]
* [[Aktualisieren (SVN)]]

[[Category:{{Delphi}}]]
[[Category:C++]]
[[Category:AMMigrate]]

[[en:Repository Browser]]
[[fr:Navigateur de référentiel]]
[[ja:［リポジトリブラウザ］]]

Auschecken (SVN)

2014-08-06T12:21:27Z

Andreeah: Update LOC-15897

{{Parent|Menü Datei}}

{{Menu|Datei > Aus der Versionskontrolle öffnen}} | '''Subversion'''

Checkt eine lokale Kopie eines Repository aus, das sich unter der Kontrolle von Subversion (SVN) befindet.

{| border="1" frame="hsides" rules="rows"
! '''Element'''
! '''Beschreibung'''
|- valign="top"
|
URL des Repository
|
Geben Sie die Adresse des Repository ein, aus dem eine lokale Kopie ausgecheckt werden soll, oder wählen Sie die Adresse aus.

Zum Beispiel: {{Path|<nowiki>svn://svn.code.sf.net/p/radstudiodemos/code/trunk</nowiki>}}.

Klicken Sie auf die [[File:BrowseForFile.jpg|Ellipsen]]-Schaltfläche [...], um nach der Repository-Adresse zu suchen.
|- valign="top"
|
Ziel
|
Geben Sie das Verzeichnis auf Ihrem lokalen System ein, in das das Repository kopiert werden soll. Klicken Sie auf die [[File:BrowseForFile.jpg|Ellipsen]] -Schaltfläche [...], um nach dem Verzeichnis zu suchen oder einen neuen Ordner zu erstellen.
|- valign="top"
|
Rekursiv
|
Legt fest, ob beim Auschecken auch alle Unterverzeichnisse einbezogen werden sollen oder nur das Stammverzeichnis.
|- valign="top"
|
Externals einschließen
|
Wenn das Projekt, das Sie auschecken, externe Verweise (Verweise auf andere Repositories) enthält, legt diese Option fest, dass auch die Dateien aus dem externen Repository ausgecheckt werden.
|- valign="top"
|
Aktuelle Revision / Revision
|
Legt entweder fest:
* Dass für das Auschecken die aktuelle Revision des Repository verwendet wird (wenn '''Aktuelle Revision''' ausgewählt ist)
* Oder: Dass für das Auschecken die angegebene Revision verwendet wird (wenn Sie eine Revisions-ID eingeben)
|}

==Siehe auch==
* [[Subversion-Integration in der IDE]]
* [[Auschecken einer Kopie eines Repository]]
* [[Versionsverwaltung]]

[[Category:{{Delphi}}]]
[[Category:C++]]
[[Category:IDE-Referenz]]
[[Category:AMMigrate]]

[[en:Checkout (SVN)]]
[[fr:Extraire (SVN)]]
[[ja:［チェックアウト］（SVN）]]

Unterstützung für Ressourcendateien

2014-07-30T15:29:48Z

Andreeah: Update LOC-15761

{{Parent|Ressourcen|Ressourcen und Bilder}}

Ressourcendateien werden nur für Desktop-Plattformen unterstützt. Das Laden von Ressourcendateien wird auf mobilen Plattformen vom Betriebssystem nicht unterstützt. Verwenden Sie zum Laden von Dateien auf ein mobiles Gerät eine andere Methode, indem Sie die Dateien z. B. extern laden.

==Desktop-Plattformen==

In diesem Beispiel wird gezeigt, wie der Text aus einer TXT-Datei mithilfe einer Ressourcendatei geladen wird.

Um dieses Beispiel zu erzeugen und zu testen:
# Erstellen Sie eine [[Geräteübergreifende Anwendung]]
# Fügen dem Formular die folgenden Steuerelemente hinzu:
#* [[lib_de:FMX.StdCtrls.TButton|TButton]]
#* [[lib_de:FMX.StdCtrls.TLabel|TLabel]]

# Fügen Sie die TXT-Datei dem Ordner des Projekts hinzu.
# Wählen Sie {{menu | Projekt > [[Ressourcen|Ressourcen und Bilder...]]}}, und fügen Sie die TXT-Datei hinzu.
# Erzeugen Sie das Projekt, um die RC-Datei zu generieren, die die Referenz auf die TXT-Datei enthält.
# Öffnen Sie die Datei <Projektname>_<Ressourcen>.rc, in der der Name der Ressource, deren Typ und der Name der Datei enthalten ist.

Resource_1 RCDATA "<file_name>.txt"

:'''Hinweis:''' Im Fenster [[Ressourcen|Ressourcen und Bilder...]] werden diese Informationen angezeigt.
<l s="cpp" />
'''{{CBuilder}}'''
<source lang="cpp">
void __fastcall TForm1::Button1Click(TObject *Sender) {
TResourceStream *Stream = new TResourceStream((int)HInstance, "<Ressourcenbezeichner>", RT_RCDATA); //RT_RCDATA ist der Ressourcentyp.
__try {
TStringList *List = new TStringList;
__try {
List->LoadFromStream(Stream);
Label1->Text = List->Text;
}
__finally {
List->DisposeOf();
}
}
__finally {
Stream->DisposeOf();
}
}
</source>
<l e="cpp" />
<l s="delphi" />
'''{{Delphi}}'''
<source lang="Delphi">
procedure TForm1.Button1Click(Sender: TObject);
var
List: TStringList;
Stream: TResourceStream;
begin
Stream := TResourceStream.Create(HInstance, '<Ressourcenbezeichner>', RT_RCDATA);
try
List := TStringList.Create;
try
List.LoadFromStream(Stream);
Label1.Text := List.Text;
finally
List.Free;
end;
finally
Stream.Free;
end;
end;
</source>
<l e="delphi" />
Sie können dieses Beispiel auf mobilen Plattformen ausführen, aber Sie erhalten beim Versuch, die Ressourcen zu laden, die folgende Exception: '''class EResNotFound mit der Meldung "Ressource <Ressourcenname> nicht gefunden"'''.

==Mobile Plattformen==

In diesem Beispiel wird gezeigt, wie der Text aus einer TXT-Datei ohne eine Ressourcendatei geladen wird.

Um dieses Beispiel zu erzeugen und zu testen, erstellen Sie eine [[Geräteübergreifende Anwendung|mobile FireMonkey-Anwendung]], und fügen dem Formular die folgenden Steuerelemente hinzu:

* [[lib_de:FMX.StdCtrls.TButton|TButton]]
* [[lib_de:FMX.StdCtrls.TLabel|TLabel]]

# Kopieren Sie die TXT-Datei in den Ordner des Projekts.
# Verschieben Sie im '''[[Bereitstellungs-Manager|Bereitstellungs-Manager]]''' diese Dateien in den Ordner <code>assets\internal</code> (intern) oder <code>assets</code> (extern).
# Beziehen Sie die Unit [[lib_de:System.IOUtils|System.IOUtils]] in Ihr Projekt ein, damit [[lib_de:System.IOUtils.TPath.GetDocumentsPath|GetDocumentsPath]] verwendet werden kann.

<l s="cpp" />'''
'''In {{CBuilder}}'''
<source lang="cpp">
void __fastcall TForm1::Button1Click(TObject *Sender)
{
TStringList *List=new TStringList;
__try {
List->LoadFromFile(System::Ioutils::TPath::GetDocumentsPath + PathDelim + "example.txt"); // #include <System.IOUtils.hpp>
Label1->Text = List->Text;
}
__finally {
List->DisposeOf();
}
</source>
<l e="cpp" />
<l s="delphi" />
'''In {{Delphi}}'''
<source lang="Delphi">
procedure TForm6.Button1Click(Sender: TObject);
var
List: TStringList;
begin
List := TStringList.Create;
try
List.LoadFromFile(TPath.GetDocumentsPath + PathDelim + 'example.txt');
Label1.Text := List.Text;
finally
List.Free;
end;
end;
</source>
<l e="delphi" />

==Siehe auch==

*[[Ressourcen|Ressourcen]]
*[[Projektverwaltung|Projektverwaltung]]
*[[lib_de:System.IOUtils|System.IOUtils]]
*[[Erstellen einer Android-App|Erstellen einer Android-App]]
*[[Erstellen von iOS-Apps|Erstellen von iOS-Apps]]

{{DEFAULTSORT:Unterstutzung fur Ressourcendateien}}
[[Category:Delphi]]
[[Category:C++]]
[[Category:XE6]]

[[en:Resource Files Support]]
[[fr:Prise en charge des fichiers de ressources]]
[[ja:リソースファイルサポート]]

Schritt 5 - Benutzerdefinierte Eigenschaften (Delphi)

2014-06-24T10:38:26Z

Andreeah: Update LOC-15540

{{Parent|Erstellen einer {{FM}}-Komponente ({{Delphi}})}}

Die Komponente benötigt eine weitere Eigenschaft, damit das Verb der Dialogfeldaktion, wie z.B. "Speichern" auf der "Ausführen"-Schaltfläche angezeigt wird. Dieses Verb ist auch mit "Nicht ausführen" auf der "Nicht ausführen"-Schaltfläche verbunden. (Eine komplexere Internationalisierung würde den Rahmen dieses Themas überschreiten.)

Es wäre einfacher, wenn die Aufnahme des Verbs über die Eigenschaft '''Text''' der Schaltfläche durchgeführt werden könnte. Aber die Schaltflächen sind erst vorhanden, wenn der Stil übernommen wird, und bei erneuter Übernahme des Stils werden die vorhandenen Schaltflächen verworfen. Daher muss die Komponente diesen String bereitstellen. Deklarieren und implementieren Sie die Eigenschaft '''DoVerb''':

<source lang="Delphi">

uses
System.SysUtils, System.Classes, FMX.Types, FMX.Controls, System.UITypes;

type
TDialogButtonPanel = class(TPanel)
private
FDoVerb: string;
function GetDoVerb: string;
procedure SetDoVerb(AString: string);
protected
function GetStyleObject: TControl; override;
procedure ApplyStyle; override;
public
constructor Create(AOwner: TComponent); override;
published
property DoVerb: string read GetDoVerb write SetDoVerb;
property Align default TAlignLayout.Bottom;
end;

const
DoButtonName = 'DoButton';
DontButtonName = 'DontButton';
CancelButtonName = 'CancelButton';
mrDont = -mrOK;

</source>

<source lang="Delphi">

constructor TDialogButtonPanel.Create(AOwner: TComponent);
begin
inherited;
Height := 46;
Width := 300;
Align := TAlignLayout.Bottom;
DoVerb := 'Verb';
end;

function TDialogButtonPanel.GetDoVerb: string;
var
Base: TFmxObject;
begin
Base := FindStyleResource(DoButtonName);
if Base is TTextControl then
FDoVerb := TTextControl(Base).Text;
Result := FDoVerb;
end;

procedure TDialogButtonPanel.SetDoVerb(AString: string);
var
Base: TFmxObject;
resourcestring
Dont = 'Don'#39't %s';
begin
FDoVerb := AString;
Base := FindStyleResource(DoButtonName);
if Base is TTextControl then
TTextControl(Base).Text := AString;
Base := FindStyleResource(DontButtonName);
if Base is TTextControl then
TTextControl(Base).Text := Format(Dont, [AString]);
end;

procedure TDialogButtonPanel.ApplyStyle;
begin
inherited;
SetDoVerb(FDoVerb);
end;

</source>

Der StyleName für jede der drei Schaltflächen wird zusammen mit dem modalen, "negativen OK"-Ergebniscodes für die "Nicht ausführen"-Schaltfläche als Konstante deklariert. Das Feld <code>FDoVerb</code> wird dem Objekt zur Aufnahme des Verb-Strings hinzugefügt.

Zur Laufzeit erfolgt der Zugriff folgendermaßen:
# Wenn die Anwendung ausgeführt wird, werden alle Formulare erstellt, einschließlich des Dialogfeldformulars mit dem Schaltflächenbereich (TPanel). Die TPanel-Komponente wird durch die <code>object</code>-Zeile beim Laden der <code>.fmx</code>-Datei instantiiert. Der Konstruktor schreibt mit <code>SetDoVerb</code> das Standardverb in die Eigenschaft. Das Feld wird gesetzt, und es werden keine Schaltflächen gefunden.
# Bei der Zuweisung der Eigenschaftswerte aus der Datei <code>.fmx</code> wird <code>SetDoVerb</code> erneut mit dem vom Designer gespeicherten String (z.B. "Speichern") aufgerufen und das Feld geändert.
# Beim Öffnen des Dialogfelds wird es gezeichnet, und einer der vorbereitenden Schritte beim Zeichnen eines Steuerelements ist die Übernahme des Stils (falls erforderlich), wozu auch das erste Zeichnen des Steuerelements gehört. Zum Schluss wird die Prozedur <code>ApplyStyle</code> aufgerufen, die hier überschrieben wird, um den Verb-String aus dem Feld erneut zu übernehmen. Die Prozedur weist das Feld redundant erneut zu, aber jetzt sind die Schaltflächen vorhanden, und zudem wird das Verb in der "Ausführen"-Schaltfläche und das Verb in der "Nicht ausführen"-Schaltfläche gesetzt.
# Das Rendern der Schaltflächen erfolgt nicht in der Funktion <code>GetDoVerb</code>, weil die Schaltflächen, die den Stil umfassen, direkt gerendert werden, und sie bereits über die Setter-Methode den passenden Text erhalten haben. Die Getter-Methode wird hauptsächlich vom Formular-Designer und von Laufzeitcode verwendet, der die Eigenschaften der TPanel-Komponente ermittelt. Die Methode versucht, das Feld aus der "Ausführen"-Schaltfläche (falls vorhanden) zu aktualisieren; aber wenn die Schaltfläche nicht direkt manipuliert wird (durch Umgehung der Kapselung), sollten ihr Text und das Feld bereits synchronisiert sein.

== Zurück ==
* [[Schritt 4 - Festlegen der Größe und der Ausrichtung ({{Delphi}})]]

==Siehe auch==
* [[FireMonkey-Komponentendesign]]
* [[Verwenden des Experten für neue Komponenten]]
<l s="cpp" />
* [[Erstellen einer FireMonkey-Komponente (C++)]]
<l e="cpp" />
* [[Erstellen einer mit Stilen versehenen FireMonkey-Komponente durch Erweitern einer vorhandenen Komponente ]]
* [[Erstellen eines grundlegenden FireMonkey-Steuerelements]]
[[Category:XE3]][[Category:FMX]][[Category:{{Delphi}}]]
[[Category:AMMigrate]]

[[en:Step 5 - Custom Properties (Delphi)]]
[[fr:Etape 5 - Propriétés personnalisées (Delphi)]]
[[ja:ステップ 5 - カスタムプロパティ（Delphi）]]

OBJTYPENAME-Direktive (Delphi)

2014-06-23T14:20:21Z

Andreeah: Update LOC-15495

{{Parent|Liste der Delphi-Compiler-Direktiven - Index}}

{| border="1" frame="hsides" rules="rows"
| align="left" valign="top" |
'''Typ'''
| align="left" valign="top" |
Parameter
|-
| align="left" valign="top" |
'''Syntax'''
| align="left" valign="top" |
{$OBJTYPENAME typeIdent ['{B|N}typeNameInObj']}
|-
| align="left" valign="top" |
'''Vorgabe'''
| align="left" valign="top" |
{$APPTYPE GUI}
|-
| align="left" valign="top" |
'''Bereich'''
| align="left" valign="top" |
Global
|}

Für $OBJTYPENAME gibt es zwei Einsatzbereiche. Sie können $OBJTYPENAME folgendermaßen verwenden:
* Zum Definieren des Typnamens beim Erstellen von .obj-Dateien.
* Als interne Direktive, um dem {{Delphi}}-Compiler mitzuteilen, wie der Name eines Typs verkürzt werden soll. (Da die Verkürzung mit der des C++-Compilers übereinstimmen muss, müssen Sie diese Option nur in Fällen verwenden, in denen die Typverkürzung von {{Delphi}} und C++ unterschiedlich ist.)

In der Syntax muss "typeNameInObj" entweder das Präfix "B" oder "N" wie folgt vorangestellt werden:
* <source lang="delphi" enclose="none">{$OBJTYPENAME typeIdent} // typeIdent bei Bedarf mit Namespace ausgeben</source>
* <source lang="delphi" enclose="none">{$OBJTYPENAME typeIdent 'Bsss'} // "sss" ohne Namespace ausgeben</source>
* <source lang="delphi" enclose="none">{$OBJTYPENAME typeIdent 'Nsss'} // "sss" bei Bedarf mit Namespace ausgeben</source>

Die Form mit dem Präfix "B" wird zum Generieren von integrierten Typen verwendet. Zum Beispiel: Mit "Bul" wird für integrierte lange Typen ohne Vorzeichen "ul" ausgegeben.

Die Form mit dem Präfix "N" wird zum Generieren von symbolischen Typen, wie Klassen-, Struktur- und Enum-Typen, verwendet. Zum Beispiel: "NTColor" mit {$NODEFINE} in [[lib_de:System.UITypes|System.UITypes.pas]] gibt "15Graphics@TColor" aus.

Die Direktive OBJTYPENAME kann mit den Direktiven {$EXTERNALSYM} und {$NODEFINE} verwendet werden.

Diese Direktiven können nicht für Aliastypen verwendet werden:

<source lang="delphi">
type
TMyIntAlias = Integer; {$OBJTYPENAME TMyIntAlias 'Bl'} // error
type
TMyIntTyped = type Integer; {$OBJTYPENAME TMyIntTyped 'Bl'} // ok
TMyIntTyped2 = type TMyIntTyped; // 'Bl' is inherited from base type.
</source>

==Siehe auch==
* [[Externe Symbole (Delphi)]]
* [[NODEFINE-Direktive (Delphi)]]

[[Category:{{Delphi}}]]
[[Category:AMMigrate]]

[[en:OBJTYPENAME directive (Delphi)]]
[[fr:Directive OBJTYPENAME (Delphi)]]
[[ja:OBJTYPENAME 指令（Delphi）]]

Delphi-Compiler-Direktiven

2014-06-17T09:56:42Z

Andreeah: Update LOC-15444

{{Parent|Liste der {{Delphi}}-Compiler-Direktiven - Index}}
<ideTag id="FHXR10869"></ideTag>
<ideTag id="CompilerDirectives"></ideTag>
<ideTag id="CompilerDirectivesOverview"></ideTag>
<ideTag id="CompilerDirectivesTopics"></ideTag>
<ideTag id="compiler"></ideTag>
<ideTag id="DCC32"></ideTag>
<ideTag id="DELPHI32"></ideTag>
<ideTag id="builds"></ideTag>
<ideTag id="makes"></ideTag>
<ideTag id="directives"></ideTag>
<ideTag id="conditional"></ideTag>
<ideTag id="parameters"></ideTag>
<ideTag id="command"></ideTag>
<ideTag id="switches"></ideTag>
Die {{Delphi}}-Compiler-Direktiven sind folgendermaßen klassifiziert:
* [[#Schalter-Direktiven|Schalter-Direktiven]]
* [[#Parameter-Direktiven|Parameter-Direktiven]]
* [[#Bedingungsdirektiven|Direktiven für bedingte Compilierung]]

Eine Compiler-Direktive ist ein Kommentar mit einer speziellen Syntax. Die Compiler-Direktive beginnt mit einem $ (Dollar-Zeichen) als erstem Zeichen nach dem Kommentarzeichen. Darauf folgt der Name der Direktive (bestehend aus einem oder mehreren Buchstaben). Nach dem Namen und den erforderlichen Parametern können Kommentare folgen.

Compiler-Direktiven können deshalb überall dort verwendet werden, wo Kommentare erlaubt sind. Beachten Sie bitte, dass Kommentare, die mit dem doppelten Schrägstrich // beginnen, '''nicht''' für Compiler-Direktiven verwendet werden können. Zum Beispiel:
{$hints off} // a {{Delphi}} compiler directive
(*$hints off*) // a {{Delphi}} compiler directive
//$hints off // just a commentary, ignored

Bei allen Direktiven mit Ausnahme von Schalter-Direktiven muss zwischen dem Namen und den Parametern mindestens ein Leerzeichen stehen.

In den folgenden Absätzen werden die Arten von Direktiven beschrieben.

==Schalter-Direktiven==
'''Schalter-Direktiven''' aktivieren bzw. deaktivieren bestimmte Compiler-Funktionen. Sie können die Direktive entweder mit ihrem langen Namen oder dessen Äquivalent mit einem Buchstaben angeben:
* Bei Direktiven mit nur einem Buchstaben folgt unmittelbar auf den Buchstaben ein Minuszeichen (-) oder ein Pluszeichen (+). Zum Beispiel: {$A+}
* Bei Direktiven mit mehreren Buchstaben geben Sie das Wort "on" bzw. "off" an. Zum Beispiel: {$ALIGN ON}

Schalter-Direktiven sind entweder global oder lokal:
* '''Globale Direktiven''' beziehen sich auf die gesamte Compilierung und müssen vor dem Deklarationsabschnitt des zu compilierenden Programms oder der zu compilierenden Unit angegeben werden.
* '''Lokale Direktiven''' betreffen nur den Teil der Compilierung, der sich von der Direktive bis zum nächsten Auftreten derselben Direktive erstreckt. Diese Direktiven können an jeder beliebigen Position stehen.

Sie können mehrere Schalter-Direktiven zu einer einzigen Direktive zusammenfassen, indem Sie sie durch Komma ohne Leerzeichen davor oder danach voneinander trennen. Zum Beispiel:

{$B+,R-,S-}

Diese Gruppierung kann nicht für Direktiven mit langen Namen verwendet werden. Diese müssen einzeln eingegeben werden. Zum Beispiel:

{$optimization on,hints off} // everything starting with "," is treated like a comment here

==Parameter-Direktiven==
'''Parameter-Direktiven''' geben Parameter an, die die Compilierung betreffen, z.B. Dateinamen und Speicheradressen.

==Bedingungsdirektiven==
Mit '''[[Bedingte Compilierung ({{Delphi}})|Bedingungsdirektiven]]''' können Quelltextabschnitte anhand bestimmter Bedingungen (z. B. benutzerdefinierter Symbole) compiliert oder ignoriert werden.

==Beispiele==
Hier einige Beispiele für Compiler-Direktiven:
{$B+}
{$R- Turn off range checking}
{$I TYPES.INC}
{$M 32768,40960}
{$DEFINE Debug}
{$IFDEF Debug}
{$ENDIF}

==Verschiedene Möglichkeiten der Eingabe von Compiler-Direktiven==

<blockquote>'''Hinweis:'''
Im Quellcode eingebettete Direktiven haben Vorrang vor Direktiven, die in der Befehlszeile oder im Dialogfeld '''Projekt > Optionen > {{Delphi}}-Compiler > [[Compilieren]]''' angegeben werden.</blockquote>

===Im Quellcode===
Sie können Compiler-Direktiven direkt in den Quellcode einfügen.

Hier ist ein Beispiel der [[Bedingte Compilierung ({{Delphi}})|bedingten Compilierung]] aus der Datei Math.pas (im Produktverzeichnis \source):

procedure DivMod(Dividend: Cardinal; Divisor: Word;
var Result, Remainder: Word);
{$IFDEF PUREPASCAL}
begin
Result := Dividend div Divisor;
Remainder := Dividend mod Divisor;
end;
{$ELSE !PUREPASCAL}
{$IFDEF X86ASM}
asm // StackAlignSafe
PUSH EBX
MOV EBX,EDX
MOV EDX,EAX
SHR EDX,16
DIV BX
MOV EBX,Remainder
MOV [ECX],AX
MOV [EBX],DX
POP EBX
end;
{$ENDIF X86ASM}
{$ENDIF !PUREPASCAL}

===Verwenden von Befehlszeilenoptionen===
Sie können die Standarddirektiven auch mit dem Schalter <code>-$''Direktive''</code> mit dem Befehlszeilen-Compiler, [[DCC32.EXE: Der Delphi-Befehlszeilen-Compiler|dcc32]] und in der IDE mit bds.exe ändern.

Beim Befehlszeilen-Compiler können Sie Compiler-Direktiven in der Befehlszeile angeben:

DCC32 -$R+ MYPROG

===Verwenden der IDE===
Sie können viele der Compiler-Direktiven im Dialogfeld '''Projekt > Optionen > {{Delphi}}-Compiler > [[Compilieren]]''' setzen. Alle Änderungen, die Sie an den Einstellungen auf der Seite '''Compilieren''' vornehmen, wirken sich auf alle Units aus, wenn deren Quellcode erneut bei folgenden Compilierungen dieses Projekts compiliert wird. Wenn Sie eine Compiler-Option ändern und compilieren, werden alle Units, für die Quellcode vorhanden ist, mit den neuen Einstellungen erneut compiliert.

Wenn Sie im '''[[Quelltext-Editor]]''' arbeiten und sich schnell einen Überblick über die aktivierten Compiler-Direktiven verschaffen möchten, drücken Sie <code>Strg+O+O</code>. Die aktuellen Direktiven-Einstellungen werden in einer horizontalen Zeile am Beginn Ihrer Datei zusammen mit anderen aktuellen Einstellungen, wie z.B. Compiler-Warnungen (die Einstellungen für die [[Warnmeldungen ({{Delphi}})|Direktive $WARN]]) eingefügt. Diese Listen werden so lange am Beginn Ihrer Quelldatei eingefügt, bis Sie den Befehl rückgängig machen (<code>Strg+Z</code>) oder die Liste manuell löschen:

[[Image:directives.png]]

==Siehe auch==
{{f|radstudio|
* [[Liste der Delphi-Compiler-Direktiven - Index|Liste der Compiler-Direktiven]] }}
* [[Bedingte Compilierung ({{Delphi}})]]

[[Category:{{Delphi}}]]
[[Category:AMMigrate]]

[[en:Delphi compiler directives]]
[[fr:Directives de compilation Delphi]]
[[ja:Delphi コンパイラ指令]]

Diskussion:Installieren des Platform Assistant auf dem Mac

2014-06-12T10:16:16Z

Andreeah: Reviewed Imported Package : LOC-15400

Für XE6 Update 1:

{{Parent|PAServer: Die Platform Assistant Server-Anwendung}}
{{Parent|Mac OS X-Anwendungsentwicklung}}

Das Mac OS X-Installationsprogramm für den "Platform Assistant" heißt '''PAServer <version>.pkg'''.

Dieses Installationsprogramm befindet sich an zwei Orten:
* Im Ordner <code>PAServer</code> im {{Product}}-Installationsverzeichnis:
*: Beispiel: {{Path|{{InstallPath}}\PAServer\PAServer{{VersionNumber}}.pkg}}
* Im Web zum Herunterladen auf den Mac:
** <code>http://altd.embarcadero.com/release/studio/{{VersionNumber}}/PAServer/PAServer{{VersionNumber}}.pkg</code>
*: '''[mailto:?Subject=PAServerVersion&body=http://installers.codegear.com/release/studio/{{VersionNumber}}/PAServer/PAServer{{VersionNumber}}.pkg Senden Sie den URL per E-Mail]'''

==So installieren Sie den "Platform Assistant" auf einem Mac:==

# Laden Sie auf dem Mac die Datei '''PAServer<version>.pkg''' von einem der oben angegebenen Orte in ein lokales Verzeichnis herunter.
# Doppelklicken Sie im '''Finder''' auf die Datei <code>.pkg</code>. Damit wird das InstallAnywhere-Installationsprogramm für "Platform Assistant Server" aufgerufen: 
#: [[image:Installing PAServerXE6.png]]
# Wählen Sie Ihre Zielsprache (z. B. Deutsch) aus, und klicken Sie auf '''OK'''.
# Auf der Seite "Bitte wählen Sie einen Zielordner" können Sie das Installationsverzeichnis ändern oder die Vorgabe übernehmen. Standardmäßig wird der '''Platform Assistant''' im Verzeichnis '''Applications''' installiert.
# Fahren Sie mit dem Installationsprogramm fort, bis die Installation abgeschlossen ist.
Der "Platform Assistant" ist jetzt installiert, und Sie können den [[Ausführen des Platform Assistant auf dem Mac|Platform Assistant ausführen]].

==So deinstallieren Sie den "Platform Assistant" auf einem Mac:==

: '''Hinweis:''' Sie müssen eine vorherige Version des "Platform Assistant" nicht deinstallieren, um eine neuere Version zu installieren. Auf Ihrem System können unterschiedliche Versionen des "Platform Assistant" vorhanden sein und gleichzeitig ausgeführt werden, solange Sie verschiedene Ports für jede ausgeführte Instanz verwenden.

Zum Deinstallieren des '''Platform Assistant'''-Servers löschen Sie '''PAServer <version>.app'''. Verwenden Sie auf dem Mac "In den Papierkorb verschieben".

==Siehe auch==

* [[Installieren von PAServer]] ({{FM}} Quick Start)
* [[Installieren des Platform Assistant unter Windows]]
* [[Ausführen des Platform Assistant auf dem Mac]]
* [[Debuggen von geräteübergreifenden Anwendungen]]

[[Category:IOS]]
[[Category:Mac OS X]]
[[Category:XE4]]

[[de:Installieren des Platform Assistant auf dem Mac]]
[[fr:Installation de Platform Assistant sur un Mac]]
[[ja:Mac でのプラットフォームアシスタントのインストール]]

Was ist RAD Studio? (IDE-Tutorial)

2014-06-11T11:31:53Z

Andreeah:

{{Parent|Einführung - Index (IDE-Tutorial)}}

{{CompanyProduct}} ist eine objektorientierte, visuelle Programmierumgebung für die schnelle Anwendungsentwicklung (Rapid Application Development, RAD). Mit {{CompanyProduct}} können Sie hocheffiziente visuelle Anwendungen mit einem Minimum an manueller Programmierung entweder in der Programmiersprache {{Delphi}} oder C++ erstellen.

{{Product}} bietet alle erforderlichen Tools zum Modellieren von Anwendungen, zum Entwerfen von Benutzeroberflächen sowie zum automatischen Generieren und Bearbeiten von Quellcode. Es enthält darüberhinaus Tools zum Compilieren, Debuggen und Weitergeben von Anwendungen. Die Tools, die in der IDE angeboten werden, variieren je nach der Version von {{Product}}.

{{f|radstudio|Siehe [[Was ist {{Variables|Product}}?]] für weitere Informationen über {{Delphi}} und {{CBuilder}}.}}

==Weiter==
[[Suchen von Informationen (IDE-Tutorial)|Suchen von Informationen]]
[[Category:{{Delphi}}]]
[[Category:C++]][[Category:AMMigrate]]

[[en:What is RAD Studio? (IDE Tutorial)]]
[[fr:Qu'est-ce que RAD Studio ? (tutoriel de l'EDI)]]
[[ja:RAD Studio とは（IDE チュートリアル）]]

Weiterführende Themen - Index (IDE-Tutorial)

2014-06-03T13:37:50Z

Andreeah: Update LOC-15216

{{Parent|Tutorial: Die IDE für {{Delphi}} und {{CBuilder}} verwenden}}

==Themen==
* [[FireMonkey und die RTL (IDE-Tutorial)|{{FM}} und RTL]]
* [[Add-ins von Fremdherstellern (IDE-Tutorial)|Add-ins von Fremdherstellern]]

{{DEFAULTSORT:Weiterfuhrende Themen - Index (IDE-Tutorial)}}
[[Category:{{Delphi}}]]
[[Category:C++]]
[[Category:AMMigrate]]

[[en:More advanced topics Index (IDE Tutorial)]]
[[fr:Autres rubriques avancées - Index (tutoriel de l'EDI)]]
[[ja:応用トピック（IDE チュートリアル）：インデックス]]

Ihre erste Anwendung mit RAD Studio - Index (IDE-Tutorial)

2014-06-03T13:36:46Z

Andreeah: Update LOC-15216

{{Parent|Tutorial: Die IDE für {{Delphi}} und {{CBuilder}} verwenden}}

Dieser Abschnitt erläutert, wie Sie mit den RAD-Tools (Rapid Application Development, schnelle Anwendungsentwicklung) von {{CompanyProduct}} eine GUI-Anwendung (Graphical User Interface, grafische Benutzeroberfläche) erstellen. Sie beginnen mit dem Erstellen des Hauptformulars, passen es an und fügen die erforderlichen visuellen und nicht-visuellen Komponenten hinzu.

Die Quellcodeabschnitte in der Anwendung, die die Benutzeraktionen behandeln, werden ''Ereignisbehandlungsroutinen'' genannt. Diese müssen Sie auch implementieren. Zu den behandelten Benutzerereignissen zählen das Auswählen von Menüeinträgen und das Tippen oder Klicken in Bearbeitungsfenster.

Wenn Sie die Schritte ausführen, erhalten Sie einen einfachen Texteditor mit ein paar Zusatzfunktionen, wie Zeilenumbruch und das Anzeigen der aktuellen Cursorposition in der Statuszeile.

==Themen==
* [[Verwendung von Projektvorlagen aus der Objektablage (IDE-Tutorial)|Verwendung von Projektvorlagen aus der Objektablage]]
* [[Elementare Anpassungen des Hauptformulars (IDE-Tutorial)|Elementare Anpassungen des Hauptformulars]]
* [[Hinzufügen von Komponenten im Formular-Designer (IDE-Tutorial)|Hinzufügen von Komponenten im Formular-Designer]]
* [[Anpassen der Komponenten (IDE-Tutorial)|Anpassen der Komponenten]]
* [[Programmieren von Reaktionen auf Benutzeraktionen im Quelltext-Editor (IDE-Tutorial)|Programmieren von Reaktionen auf Benutzeraktionen im Quelltext-Editor]]
* [[Compilieren und Ausführen der Anwendung (IDE-Tutorial)|Compilieren und Ausführen der Anwendung]]
* [[Debuggen der Anwendung (IDE-Tutorial)|Debuggen der Anwendung]]
[[Category:Delphi]]
[[Category:C++]]
[[Category:XE6]]
[[Category:AMMigrate]]

[[en:Starting your first RAD Studio application Index (IDE Tutorial)]]
[[fr:Démarrage de votre première application RAD Studio - Index (tutoriel de l'EDI)]]
[[ja:RAD Studio アプリケーションを初めて作成する（IDE チュートリアル）：インデックス]]

Designer-Richtlinien für VCL-Komponenten verwenden

2014-06-03T08:49:11Z

Andreeah: Update LOC-15142

{{Parent|So erstellen Sie Formulare und Projekte und schreiben den Codebehind}}
Die VCL-Design-Richtlinien werden angezeigt, wenn Sie im [[Formular-Designer]] auf ein Element klicken und es in Relation zu einem anderen Element verschieben. Anhand der Richtlinien (für oben, unten, recht, links und zentriert) können Sie Elemente, einschließlich von Steuerelementen wie Schaltflächen und Listenfelder oder Textbeschriftungen, ausrichten. Mit den Design-Richtlinien und den zugehörigen Funktionen für {{Delphi}}- oder C++-Anwendungen können Sie Komponenten so definieren, dass sie sich "relativ" zu den anderen Komponenten im Formular verhalten.

'''So können Sie Design-Richtlinien anzeigen und verwenden:'''

# Aktivieren Sie die Design-Richtlinien im Dialogfeld '''Tools > Optionen > Umgebungsoptionen > [[Optionen für den Formular-Designer|Formular-Designer]]''' im Feld '''Designer-Richtlinien verwenden'''. (Design-Richtlinien sind standardmäßig aktiviert.)
# Beim Verschieben von visuellen Elementen im '''Formular-Designer''' können Sie die Ausrichtung von Elementen auf verschiedene Arten steuern:
#* Mithilfe der '''Design-Richtlinien''', die zwischen Elementen erscheinen. Mit Design-Richtlinien können Sie beispielsweise die untere Kante des ausgewählten Elements mit den unteren Kanten der benachbarten Elemente ausrichten oder ein Element relativ zu benachbarten Elementen zentrieren.
#* Mithilfe der Werte, die in einem Popup-Fenster angezeigt werden, wenn Sie den Mauszeiger über ein Steuerelement führen. Das Popup-Fenster enthält Folgendes:
#** '''Ursprung:''' die X- und Y-Koordinaten (horizontal, vertikal) der linken oberen Ecke
#** '''Größe:''' horizontale mal vertikale Koordinaten
#** '''[[lib_de:Vcl.Controls.TWinControl.TabStop|Tabstopp]]:''' True/False
#** '''Reihenfolge:''' relative Reihenfolge des ausgewählten Elements in seiner Gruppe
#* Mithilfe des [[Objektinspektor|Objektinspektors]]:
#** Zum Zuweisen von Werten zu der Eigenschaft [[lib_de:Vcl.Controls.TControl.Align|Align]] (alTop, alBottom, alLeft usw.).
#** Zum Zuweisen von Werten zu der Eigenschaft [[lib_de:Vcl.Controls.TAnchors|Anchors]] (akTop, akLeft, akRight oder akBottom).

==Siehe auch==

* [[Benutzeroberflächen entwerfen]]
* [[Ein erster Blick auf die IDE]]
* [[Komponente registrieren|Registrieren der Komponente]]
* [[Designrichtlinien (Nur VCL)]]

{{DEFAULTSORT:Designer-Richtlinien fur VCL-Komponenten verwenden}}
[[Category:Mit {{Product}} arbeiten]]

[[en:Using Design Guidelines with VCL Components]]
[[fr:Utilisation de directives du Concepteur avec des composants VCL]]
[[ja:VCL コンポーネントでデザインガイドラインを使用する]]

Verzeichnis auswählen

2014-05-27T09:22:09Z

Andreeah: Update LOC-15202

{{Parent|Menü Datei}}

Verwenden Sie dieses Dialogfeld, um ein Arbeitsverzeichnis für Ihr neues Projekt festzulegen.

{| border="1" frame="hsides" rules="rows"
! '''Element'''
! '''Beschreibung'''
|- valign="top"
|
Verzeichnisname
|
Zeigt das aktuelle Verzeichnis an. Wenn Sie ein noch nicht vorhandenes Verzeichnis eingeben, wird dieses automatisch erstellt.
|- valign="top"
|
Speichern in
|
Zeigt den Inhalt des aktuellen Verzeichnisses an.
|- valign="top"
|
Dateien: (*.*)
|
Listet alle Dateien in dem aktuellen Verzeichnis auf. Sie können von diesen Dateien keine auswählen. Die Liste wird nur angezeigt, damit Sie den Inhalt des aktuellen Verzeichnisses kennen.
|- valign="top"
|
Laufwerke
|
Listet alle verfügbaren Laufwerke auf. Sie können eines dieser Laufwerke auswählen.
|}

{{DEFAULTSORT:Verzeichnis auswahlen}}
[[Category:IDE-Referenz]]
[[Category:AMMigrate]]

[[en:Select Directory]]
[[fr:Sélection du répertoire]]
[[ja:［ディレクトリの選択］ダイアログボックス]]

Zuletzt verwendet

2014-05-27T08:56:32Z

Andreeah: Update LOC-15202

{{Parent|Menü Datei}}

{{Menu|Datei > Zuletzt verwendet}}

Führt die zuletzt geöffneten Projekte und Dateien auf, die Sie auswählen und erneut öffnen können.

Die Liste '''Zuletzt verwendet''' ist in zwei durch eine Linie getrennte Gruppen aufgeteilt:
* Projekte werden oberhalb der Linie aufgeführt (z.B. {{Path|MyBigApp.dproj}} oder {{Path|MyFastApp.cbproj}})
* Quelldateien werden unterhalb der Linie aufgeführt (z.B. {{Path|MyControl.pas}} oder {{Path|MyClass.cpp}})

Im Dialogfeld '''[[Eigenschaften für "Zuletzt verwendet"]]''' können Sie die Liste '''Zuletzt verwendet''' verwalten. Sie öffnen dieses Dialogfeld mit einem der beiden folgenden Befehle:
* {{Menu|Datei > Zuletzt verwendet > Eigenschaften}}
* {{Menu|Tools > Optionen > Umgebungsoptionen > Zuletzt verwendet}}

==Siehe auch==
* [[Eigenschaften für "Zuletzt verwendet"|Zuletzt verwendet, Eigenschaften für "Zuletzt verwendet"]]

[[Category:IDE-Referenz]]
[[Category:AMMigrate]]

[[en:Reopen]]
[[fr:Rouvrir]]
[[ja:［開き直す］]]

Druckauswahl

2014-05-27T08:48:13Z

Andreeah: Update LOC-15202

{{Parent|Menü Datei}}

{{Menu|Datei > Drucken}}

Verwenden Sie dieses Dialogfeld zum Drucken der aktuellen Datei.

{| border="1" frame="hsides" rules="rows"
! '''Element'''
! '''Beschreibung'''
|- valign="top"
|
Markierten Block drucken
|
Bewirkt, dass nur der markierte Textblock gedruckt wird.
|- valign="top"
|
Überschrift/Seitennummer
|
Bewirkt, dass auf jeder Seite eine Überschrift mit dem Dateipfad und dem Dateinamen sowie eine Seitennummer gedruckt wird.
|- valign="top"
|
Zeilennummer
|
Bewirkt die Ausgabe von Zeilennummern auf den gedruckten Seiten.
|- valign="top"
|
Syntaxhervorhebung
|
Bewirkt das Drucken von Syntaxhervorhebungen, z.B. von Schlüsselwörtern in Fettschrift.
|- valign="top"
|
Farben verwenden
|
Bewirkt die farbige Ausgabe von Syntaxhervorhebungen (bei Verwendung eines Farbdruckers).
|- valign="top"
|
Zeilen umbrechen
|
Bewirkt den Umbruch von Zeilen, die breiter als die Druckseite sind.
|- valign="top"
|
Linker Rand
|
Legt den linken Rand der Druckseiten fest. Der eingegebene Wert steht für eine bestimmte Anzahl von Leerzeichen am linken Rand.
|- valign="top"
|
Einstellungen
|
Öffnet das Dialogfeld '''Druckereinrichtung'''.
|}

[[Category:IDE-Referenz]]
[[Category:AMMigrate]]

[[en:Print Selection]]
[[fr:Sélection de l'impression]]
[[ja:［印刷］]]

Vorlage:Key

2014-05-27T08:24:23Z

Andreeah: Created Template LOC-15202

<code>{{{1}}}</code><noinclude>[[Category:Formatierungsvorlagen]]