RAD Studio - Benutzerbeiträge [de]

Optionen für das Ziel

2026-10-10T14:29:24Z

L10nBot: defaultsort

{{Parent|Projektoptionen (Dialogfeld)}}

Mit diesen Optionen können Sie die auf der aktuellen Seite festgelegten Projektoptionen für verschiedene Kombinationen aus [[Unterstützte Zielplattformen|Zielplattform]] und Build-Konfiguration (oder für alle Plattformen oder für alle Konfigurationen) übernehmen.

Zieloptionen werden in der obersten Zeile aller Compiler- und Build-bezogenen Seiten des Dialogfelds '''[[Projektoptionen (Dialogfeld)|Projektoptionen]]''', wie z. B. {{Menu | Projekt > Optionen > [[Delphi-Compiler|Delphi-Compiler]]}}, angezeigt.

{| border="1" frame="hsides" rules="rows"
|-
!'''Optionen für das Ziel'''
!'''Beschreibung'''
|- valign="top"
|
Ziel
|
Das '''Ziel''' ist der Name der Build-Konfiguration, die den aktivierten Optionen auf dieser Seite zugeordnet ist. Im Feld "Ziel" wird die Konfiguration und die zugehörige Zielplattform, wie z. B. '''Debug-Konfiguration - 32-Bit-Windows-Plattform''' (die Standardzielkonfiguration für 32-Bit-Windows-Anwendungen), angezeigt.
Integrierte Build-Konfigurationen, die Sie als Ziel auswählen können:
*'''Alle Konfigurationen'''
*'''Debug'''
*'''Release'''

Build-Konfigurationen, die Sie erstellt haben, werden zusätzlich zu den integrierten Konfigurationen aufgeführt. Die Vorgabe ist '''Debug'''.
Die diesen Build-Konfigurationen zugeordneten Zielplattformen werden im '''[[Projekte-Fenster|Projekte-Fenster]]''' unter dem Knoten [[Übersicht über Zielplattformen|Zielplattformen]] des Projektknotens angezeigt. Wenn Sie Ihrem Projekt eine Plattform hinzufügen oder daraus entfernen
:{{Note| Jedes Projekt muss mindestens eine Zielplattform enthalten.}}

'''Beispiele'''
Durch Auswahl eines '''Ziels''' werden die Optionen auf der aktuellen Seite für die ausgewählte Konfiguration auf der ausgewählten Plattform angewendet. Hier sind beispielsweise die Ergebnisse für die Auswahl der folgenden Werte in der Dropdown-Liste '''Ziel''':
*'''Alle Konfigurationen'''
**Wendet die Optionen auf der Seite für jede Kombination aus Plattform und Konfiguration an.
**Im Dialogfeld wird '''Alle Konfigurationen - Alle Plattformen''' angezeigt.
*'''Release-Konfiguration'''
**Wendet die Optionen auf der Seite auf die '''Release'''-Konfiguration für jede Kombination aus Plattform und Konfiguration an.
**Im Dialogfeld wird '''Debug-Konfiguration - Alle Plattformen''' angezeigt.
*'''Debug-Konfiguration > 32-Bit-Windows-Plattform'''
**Wendet die Optionen auf der Seite auf die '''Debug'''-Konfiguration für die '''32-Bit-Windows'''-Plattform an.
**Im Dialogfeld wird '''Debug-Konfiguration - 32-Bit-Windows-Plattform''' angezeigt.

Weitere Informationen über Build-Konfigurationen finden Sie unter [[Überblick zu Build-Konfigurationen|Überblick zu Build-Konfigurationen]].
|- valign="top"
|
Übernehmen...
|
Zeigt das Dialogfeld '''[[Optionsgruppe anwenden|Optionsgruppe anwenden]]''' an, in dem Sie die Optionen einer vorhandenen, benannten Optionsgruppe (<code>.optset</code>-Datei) für die aktuelle Konfiguration übernehmen können.
Weitere Informationen über Optionsgruppen finden Sie unter [[Übersicht über Optionsgruppen|Übersicht über Optionsgruppen]].
|- valign="top"
|
Speichern...
|
Zeigt das Dialogfeld '''[[Speichern-Befehle|Speichern-Befehle]]''' an, in dem Sie die aktuellen Einstellungen der '''Projektoptionen''' als Optionsgruppendatei (<code>.optset</code>-Datei) speichern können.
Weitere Informationen über Optionsgruppen finden Sie unter [[Übersicht über Optionsgruppen|Übersicht über Optionsgruppen]].
|}

Klicken Sie zum Ändern des Wertes einer Option im [[Projektoptionen (Dialogfeld)|Dialogfeld "Projektoptionen"]] auf das Wertefeld, und geben Sie dann einen Wert ein, oder klicken Sie auf [[Image:ProjectOptionsDownArrow2.jpg|Pfeil nach unten]], und wählen Sie den gewünschten Wert aus.

==Siehe auch==

*[[Projektoptionen (Dialogfeld)|Projektoptionen (Dialogfeld)]]
*[[Gemeinsame Elemente auf den Projektoptionsseiten|Gemeinsame Elemente auf den Projektoptionsseiten]]
*[[Aktivieren und Konfigurieren der Zielplattform|Hinzufügen einer Zielplattform zu einem Projekt]]

{{DEFAULTSORT:Optionen fur das Ziel}}
[[Category:IDE-Referenz]]
[[Category:XE2]]
[[Category:AMMigrate]]

[[en:Target Options]]
[[fr:Options de la cible]]
[[ja:［ターゲット］オプション]]

IDE-Optionen

2026-10-10T14:24:41Z

L10nBot: updated language links

{{Parent|Tools-Optionen (Dialogfeld)}}

{{Menu|Tools > Optionen > IDE}}

Legt die IDE-Konfigurationsvorgaben fest.

==Untergeordnete Seiten==

* [[Default Folders|Standardordner]]
*
[[Compilierung und Ausführung|Compilierung und Ausführung]]
** [[Build-Protokoll|Build-Protokoll]]
* [[Komponenten-Symbolleiste|Komponenten-Symbolleiste]]
* [[Umgebungsvariablen|Umgebungsvariablen]]
* [[Dateizuordnung|Dateizuordnung]]
* [[Desktop und Layout|Desktop und Layout]]
* [[Willkommensseite|Willkommensseite]]
* [[Optionen für Smart CodeInsight|Smart CodeInsight]]
* [[Projekt-Upgrade|Projekt-Upgrade]]
* [[LiveBindings-Optionen|LiveBindings]]
* [[Speichern und Desktop|Speichern und Wiederherstellen]]
* [[GetIt (Optionen)|GetIt-Package-Manager]]

[[en:IDE Options]]
[[fr:Options de l'EDI]]

Fokusmodus

2026-10-10T14:24:40Z

L10nBot: updated language links

{{Parent|Editor-Optionen}}

{{Menu|Tools > Optionen > Editor > Fokusmodus}}

Der [[Fokusmodus|Fokusmodus]] dient dem ablenkungsfreien Programmieren. Dabei sehen Sie nur den Quelltext-Editor, der Rest der Benutzeroberfläche ist ausgeblendet.

Klicken Sie zum Aktivieren der [[Fokusmodus|Fokusmodus]]-Ansicht mit der rechten Maustaste auf die Registerkarte und wählen Sie '''Fokusmodus''' aus oder verwenden Sie die Tastenkombination {{code|Strg+Alt+Z}}, wenn der Editor den Fokus hat. Wenn die restliche UI ausgeblendet ist, zeigt der Editor oben den Dateinamen an, verfügt über Schaltflächen zum Schließen und ist in einen linken und einen rechten Bereich unterteilt. Beachten Sie bei Verwendung der [[Fokusmodus|Fokusmodus]]-Ansicht Folgendes:

* Ein [[Fokusmodus|Fokusmodus]]-Editor kann eine beliebige Anzahl von Registerkarten enthalten und mehrere Editoren können als Spalten nebeneinander angezeigt werden.
* Die Anzahl der nebeneinander angezeigten Editoren ist durch den verfügbaren horizontalen Platz auf dem Bildschirm begrenzt. Die IDE lässt das Hinzufügen einer neuen Spalte nicht zu, wenn die in der Größe angepassten Editoren zu klein sind, um darin zu programmieren.
* Wenn Sie die Teilerleiste nach links oder rechts ziehen, wird die Größe des standardmäßig zentrierten Editors angepasst, wobei dieser weiterhin zentriert bleibt.
* Oben im Editor werden Schaltflächen angezeigt, mit denen Sie den aktuellen Editor links oder rechts teilen und eine Unit über das Dialogfeld '''Unit verwenden''' öffnen können (Sie können auch die Tastenkombination {{code|Strg+F12}} drücken). Aufgrund dieser Optionen können Sie mehrere Dateien im [[Fokusmodus|Fokusmodus]] anzeigen.
* Sie können die Bildlaufleisten des Editors in den Editorfarben darstellen.

{{Note|In Delphi ist nur die Unit-Quelltextdatei im Editor verfügbar. In C++ sind die C++- und die Header-Dateien für eine Unit im Editor verfügbar. Der Formular-Designer und andere Editor-Unteransichten sind nicht verfügbar.}}

Wenn die Option '''Fokusmodus aktivieren''' aktiviert ist, können Sie auswählen, welche der folgenden Features Sie mit dem Code anzeigen möchten:

* Positionsmarken
* Rechter Rand
* Navigationssymbolleiste
* Code-Folding
* Debug-Informationen (Haltepunkte, compilierte Zeilen)
* Geänderte Bereiche
* Keine Punkte in Zeilennummern

Standardmäßig zeigt der [[Fokusmodus|Fokusmodus]] nur die aktuelle Registerkarte an, wenn Sie aber die Option '''Alle Registerkarten im Fokusmodus klonen''' aktivieren, können Sie alle aktiven Ansichten laden.

[[File:Focus Mode.png|700px|link=]]

==Siehe auch==

* [[Editor-Optionen|Editor]]

[[en:Focus Mode]]
[[fr:Mode Concentration]]

Ollama für Smart CodeInsight konfigurieren

2026-10-10T14:24:39Z

L10nBot: updated language links

{{Parent|Smart CodeInsight}}

In einer der nächsten Versionen von {{Product}} werden eine oder mehrere vorkonfigurierte Docker-Images von Ollama mit Code Llama bereitgestellt, um das Setup und die Integration zu vereinfachen. In der Zwischenzeit können Sie die verfügbaren [https://ollama.com/ allgemeinen Schritte (EN)] ausführen.

{{Note| Ein Ollama-Docker-Image kann auf einem ausgewiesenen Linux-Server und dem Windows-Linux-Untersystem (WLS) installiert werden. Zur Erleichterung der Konfiguration können Sie den Einsatz von Docker Desktop in Betracht ziehen. Dieses Tool ist kostenlos und unterliegt lediglich einer bestimmten EULA: Größere Organisationen müssen eine Lizenz käuflich erwerben. Details dazu finden Sie auf [https://www.docker.com/products/docker-desktop/ dieser Seite (EN)].}}

{{Note| Lesen Sie für Nvidia-GPU- oder AMD-GPU-fähige Images die Anweisungen [https://hub.docker.com/r/ollama/ollama hier (EN)].}}

Im Folgenden finden Sie eine übersichtliche Anleitung zur Installation, zum Start und zur Nutzung von Ollama. Führen Sie die folgenden Schritte aus.

==Sicherstellen, dass Docker richtig installiert ist==

Stellen Sie sicher, dass Docker in den folgenden Fällen wie unten beschrieben installiert ist.

===Docker Desktop unter Windows===

<ol><li> Überprüfen Sie die Docker Desktop-Installation, indem Sie im '''Startmenü''' danach suchen.</li>
<li>Überprüfen Sie den Status der Docker-Engine, indem Sie sie öffnen.</li>
<li> Überprüfen Sie die '''Docker Desktop-Engine''' mit dem folgenden PowerShell-Befehl:
<source>docker --version</source></li>
</ol>

===Docker unter WSL2===

<ol><li> Öffnen Sie ein WSL2-Terminal.</li>
<li> Führen Sie die folgende Befehlszeile aus.
<source>docker --version</source></li>
<li> Überprüfen Sie den Status der Docker-Engine, indem Sie den folgenden Befehl ausführen:
<source>sudo service docker status</source>
{{Attention|Die Ausgabe sollte angeben, dass Docker aktiv ist (ausgeführt wird).}}
</li>
<li> Wenn Docker nicht ausgeführt wird, können Sie es mit dem folgenden Befehl starten:
<source>sudo service docker start</source></li>
</ol>

==Ollama ausführen und verwenden==

<ol><li>
[[Ollama für Smart CodeInsight konfigurieren#Sicherstellen, dass Docker richtig installiert ist|Stellen Sie sicher, dass Docker richtig installiert ist]] und dass die Docker-Engine ausgeführt wird.
</li>
<li>Öffnen Sie PowerShell oder CMD (Eingabeaufforderung) und führen Sie den folgenden Befehl aus:
<source>docker login</source></li>
<li>Melden Sie sich mit Ihrem Benutzernamen und Passwort für Ihren Docker Hub an.
</li>
<li>Installieren Sie das Embarcadero-Image und führen Sie es aus:
<source>docker run --name Embarcadero_Codellama -p 11434:11434 radstudio/codellama:latest</source>

{{Note|Bitte beachten Sie die folgenden Informationen, wenn Sie die obigen Schritte ausführen:
<ul><li>
<code>-name</code> ist falsch, und <code>--name</code> mit zwei Bindestrichen ist richtig.</li>
<li>Sie können den [https://docs.docker.com/reference/cli/docker/container/rename/ Container umbenennen (EN)], aber wenn Sie "Embarcadero_Codellama" ändern, müssen Sie auch die nachfolgenden Befehle ändern.</li>
<li>Sie können jede Portnummer im folgenden Format verwenden: '''‘-p 12345:54321’'''
<ul><li>
'''Linke Zahl (12345)''': Das ist der Host-Port. Er stellt den Port auf Ihrem lokalen Rechner dar (der Rechner, auf dem Docker ausgeführt wird), den Sie an den Container binden möchten.</li>
<li>
'''Rechte Zahl (54321)''': Das ist der Container-Port. Er stellt den Port im Docker-Container dar, über den Ihre Anwendung empfängt. </li>
</ul>
</li>
</ul>

}}

</li>
<li>Testen Sie Ollama in der Befehlszeile (optionaler Schritt).
<source>docker exec -it Embarcadero_Codellama ollama run codellama</source><ol><li>Stellen Sie eine beliebige Frage und überprüfen Sie die Antwort.</li>
<li>Beenden Sie den Chatmodus mit Strg+D oder /bye.</li>
<li>Sie können die Befehlszeile jetzt schließen.</li>
</ol>
</li>
<li>Verwenden Sie für die Seite "Optionen" der IDE die folgenden Anmeldeinformationen:
<ul><li>'''URL''': [http://localhost:11434/api/generate http://localhost:11434/api/generate]</li>
<li>
'''Modell''': codellama</li>
</ul>
</li>
</ol>

{{DEFAULTSORT:Ollama fur Smart CodeInsight konfigurieren}}

[[en:Configuring Ollama for Smart CodeInsight]]
[[fr:Configuration d'Ollama pour l'audit de code intelligent]]
[[ja:Smart CodeInsight 用 Ollama の設定]]

Unit-Initialisierung und -Finalisierung für die neue C++-Toolkette

2026-10-10T14:24:38Z

L10nBot: updated language links

{{Parent|Packages für die neue C++-Toolkette}}

Abhängigkeiten bei der Initialisierung und Finalisierung von Units können zu Problemen führen. Da dies ein wiederkehrendes Problem sein kann, wurden für {{Product}} erhebliche Anstrengungen unternommen, um die Funktionsweise von Packages zu verbessern und ein einheitliches Verhalten beim statischen und dynamischen Linken von Packages sicherzustellen. In diesem Artikel wird beides erklärt.

{{Note| Bitte beachten Sie, dass beim dynamischen Linken mit einem Package eine dynamische BPL-Datei verwendet wird, die mit der Anwendung weitergegeben werden muss. Eine BPL ist ein dynamisch geladenes Modul, d. h., es handelt sich im Grunde um eine DLL mit einigen Extras. 
Packages sind immer in zwei Versionen verfügbar, wobei die zweite als statische Standardbibliothek vorliegt. Beim statischen Linken eines Package wird es mit dieser statischen Standardbibliothek gelinkt. Das bedeutet, der Package-Inhalt wird in die Binärdatei übernommen, die Sie linken. Für das Package müssen keine Dateien weitergegeben werden. 
Früher wurden für dynamisches und statisches Linken unterschiedliche Methoden für die Initialisierung und Finalisierung von Units und Daten verwendet, was je nach Art des Linkens einer Anwendung zu unterschiedlichem Verhalten (und Fehlern) führte. Jetzt vereinfacht und beschleunigt ein einheitliches Verfahren die Behebung von Problemen und gewährleistet ein nahezu identisches Verhalten für beide Arten des Linkens.}}

In {{Delphi}} haben Units gegenseitige Abhängigkeiten. Das bedeutet, dass eine Unit eine andere Unit und die Typen aus dieser Unit verwendet. Abhängigkeiten bei der Initialisierung und Finalisierung von Units können vorkommen, wenn eine Unit initialisiert wird. Das heißt, wenn eine der folgenden Optionen verwendet wird:

* Die Schlüsselwörter [https://docwiki.embarcadero.com/RADStudio/Athens/en/Programs_and_Units_(Delphi)#The_Initialization_Section initialization] und [https://docwiki.embarcadero.com/RADStudio/Athens/en/Programs_and_Units_(Delphi)#The_Finalization_Section finalization]
* [https://docwiki.embarcadero.com/RADStudio/Athens/en/Methods_(Delphi)#Class_Constructors Klassenkonstruktoren oder -destruktoren]

Beispielsweise bei der Initialisierung eines Objekts, das von einer anderen Objektinstanz oder -zuweisung in einer anderen Unit abhängig ist. Dieses Verhalten führt dazu, dass Units auf Grundlage von Abhängigkeiten in der Graphenzuordnung initialisiert werden. Es gibt nicht unbedingt eine richtige Lösung für einen Abhängigkeitsgraphen, der zirkulär sein kann. Wenn dem so ist, dann werden wahrscheinlich Fehler auftreten.

Initialisierungsprobleme können z. B. häufig AVs beim Start oder beim Laden eines Package verursachen, hauptsächlich wenn sie von einer Unit abhängig sind, die noch nicht initialisiert wurde. In {{Product}} wurde versucht, diese Probleme zu vermeiden oder zu verringern.

{{Note|In diesem Artikel sprechen wir von "Initialisierung", doch dies gilt umgekehrt auch für die Finalisierung.}}

Beachten Sie, dass sowohl beim dynamischen als auch beim statischen Linken nur die verwendeten Units initialisiert und finalisiert werden. Im Gegensatz zu früheren Toolketten (Clang 5 und früher und klassisch) werden zirkuläre Unit-Referenzen behandelt und schwach gepackte Units werden korrekt verarbeitet.

==Wie werden Packages dynamisch initialisiert?==

Wenn ein Package dynamisch geladen wird, werden seine Units rekursiv mit einem Zähler initialisiert. Dadurch wird sichergestellt, dass ein zweites Package, das dieselben Units verwendet, nicht doppelt initialisiert wird und erst dann finalisiert wird, wenn das letzte Package entladen wurde.

Packages können auf zwei Arten dynamisch initialisiert werden:

<ul><li>
'''Über die [[Packages in Anwendungen laden|Package-Importbibliothek]], die <code>.BPI</code>-Datei'''. Dies ist das übliche Verfahren, und so funktioniert das automatische Linken. 
Diese Methode verwendet das Record-Initialisierungssystem und initialisiert konsequent nur die verwendeten Units. Dies kann zu einer unterschiedlichen Reihenfolge führen, in der Units initialisiert werden, wenn ein Package von zwei Stellen in derselben Anwendung abhängig ist. 
Lassen Sie uns das anhand eines Beispiels erläutern. Nehmen wir folgendes Szenario an:
<ul><li>
<code>App.exe</code> hängt von <code>A.bpl</code> und <code>B.bpl</code> ab.
</li>
<li>
<code>B.bpl</code> hängt von on <code>A.bpl</code> ab.</li>
</ul>

Wenn <code>App.exe</code> geladen wird, werden die Units initialisiert, die sie aus <code>A.bpl</code> sowie aus allen weiteren Units verwendet, von denen die Units selbst abhängig sind. Das bedeutet, der gesamte Unit-Abhängigkeitsgraph wird initialisiert. 

Die Units in <code>A.bpl</code>, von denen <code>B.bpl</code> abhängig ist, werden jedoch nicht initialisiert. Wenn <code>App.exe</code> <code>B.bpl</code> lädt, werden ihre Abhängigkeiten aus <code>A.bpl</code> initialisiert. Wenn eine davon Units in <code>A.bpl</code> einschließt, die bereits initialisiert wurden, werden diese Units nicht zweimal initialisiert. 

Das bedeutet, dass zwar jeder Graph bzw. jede Gruppe von Units korrekt initialisiert wird, es jedoch denkbar ist, dass durch das Laden von <code>A.bpl</code> durch <code>App.exe</code> vor <code>B.bpl</code> eine andere Initialisierungsreihenfolge der Units von A verursacht werden kann, als wenn <code>App.exe</code> nur von <code>B.bpl</code> abhängig wäre oder in der Reihenfolge <code>B.bpl</code> (-> <code>A.bpl</code>) dann <code>A.bpl</code> geladen worden wäre. Dies sollte keinerlei Auswirkungen auf die Stabilität haben, da alle verwendeten Units in der richtigen Reihenfolge initialisiert werden sollten, wie in den Initialisierungs-Records angegeben.

</li>
<li> '''Über [[Packages mit der Funktion LoadPackage laden|SysUtils::LoadPackage]]'''. Mit dieser Methode werden Packages vollständig dynamisch geladen. 

Alle abhängigen Package-Units werden rekursiv initialisiert, ob sie verwendet werden oder nicht. Und zwar deshalb, weil nicht bekannt ist, welche das ladende Modul aus dem Package verwendet. 

Wenn ein Package geladen wird, werden auch seine Abhängigkeiten geladen. Das bedeutet: Wenn Sie ein Package namens <code>Package1.bpl</code> laden, das von <code>rtl.bpl</code> abhängt – sei es durch dynamisches Linken oder mithilfe von <code>[[Packages mit der Funktion LoadPackage laden|LoadPackage]]</code> –, müssen weder Sie noch <code>Package1.bpl</code> <code>LoadPackage(“rtlXXX.bpl”)</code> aufrufen. Das liegt daran, dass beim Laden von <code>Package1.bpl</code> alle abhängigen Package-Units, die <code>Package1.bpl</code> verwendet, ebenfalls geladen und initialisiert werden, wozu auch die Behandlung von Abhängigkeiten zu Units in anderen Packages gehört, wie beispielsweise <code>rtl.bpl</code>.
</li>
</ul>

In einer Anwendung können die beiden Methoden zum dynamischen Laden eines Package kombiniert werden, aber statisches und dynamisches Linken sollten nicht miteinander vermischt werden.

Unit-Initialisierung und -Finalisierung sind naturgemäß komplexer, da es mehr Abhängigkeitsebenen als in einem Package und zwischen Packages gibt. Gute Tests prüfen komplexe Abhängigkeiten.

Beim statischen Linken werden nur die verwendeten Units initialisiert. Der Linker entfernt nicht verwendete Objekte. D. h. Units, auf die nicht verwiesen wird oder die nicht verwendet werden, sind in der endgültigen Binärdatei nicht enthalten.

===Siehe auch===

* [[Packages in Anwendungen laden|Packages in Anwendungen laden]]
* [[Packages mit der Funktion LoadPackage laden|Packages mit der Funktion LoadPackage laden]]
* [[Delphi-RTTI und C++Builder|Delphi-RTTI und C++Builder]]
* [[Verwendung des schwachen Packens|Verwendung des schwachen Packens]]

{{DEFAULTSORT:Unit-Initialisierung und -Finalisierung fur die neue C++-Toolkette}}

[[en:Unit Initialization and Finalization for C++ New Toolchain]]
[[fr:Initialisation et Finalisation d'unités pour la nouvelle chaîne d'outils C++]]

Packages für die neue C++-Toolkette

2026-10-10T14:24:37Z

L10nBot: updated language links

{{Parent|C++-Referenz}}
Packages sind im Grunde ein Konzept aus {{Delphi}} und lassen sich nicht eins zu eins auf C++ übertragen. Diese unvollständige Zuordnung führt bei der Verwendung von Packages zu Problemen und Komplikationen.

Beispielsweise arbeitet {{Delphi}} mit dem Konzept von Units: eine .pas-Datei. C++ nutzt Übersetzungs-Units, aber das ist nicht dasselbe. Code kann in einer Header-Datei stehen, ohne zu einer bestimmten .cpp-Datei zu gehören.

Um dies anzuwenden, müssen Sie in einer Unit [[Pragma package|#pragma package(smart_init)]] verwenden. Damit wird eine Compilierungs-Unit im Sinne der Verwendung des Begriffs "Unit" in diesem Dokument und den dazugehörigen Artikeln als Unit im {{Delphi}}-Stil gekennzeichnet (soweit sich die Konzepte zuordnen lassen).

Bitte lesen Sie die folgenden Abschnitte, um sich ein besseres Bild von diesem Thema zu machen.

==initialization- und finalization-Abschnitt einer Unit==

In der neuen Toolkette wurden für {{Product}} erhebliche Anstrengungen unternommen, um die Funktionsweise von Packages zu verbessern und ein einheitliches Verhalten beim statischen und dynamischen Linken von Packages sicherzustellen.

Weitere Informationen finden Sie im Artikel [[Unit-Initialisierung und -Finalisierung für die neue C++-Toolkette|Unit-Initialisierung und -Finalisierung für die neue C++-Toolkette]].

==Import und Export von Packages==

Die Wirkung des Modifizierers PACKAGE oder [[Declspec(package)|__declspec(package)]] ist mitunter nicht leicht zu verstehen: Weitere Informationen zu diesem Thema finden Sie im Artikel [[Import und Export von Packages für die neue C++-Toolkette|Import und Export von Packages]].

==Schwach gepackte Units==

Außerdem sollten Sie wissen, wie sich [[Verwendung des schwachen Packens|schwach gepackte Units von normalen Units unterscheiden]].

==Warnung zur Kompatibilität==

Von der alten Toolkette erstellte BPLs (C++-Packages) sind nicht mit Anwendungen kompatibel, die mit der neuen Toolkette erzeugt wurden, und umgekehrt. Stellen Sie daher für {{code|Windows 64 Bit (Modern)}}-Anwendungen sicher, dass sie mit {{code|Windows 64 Bit (Modern)}} compilierte C++Packages verwenden. Verwenden Sie keine unterschiedlichen Toolketten für die verschiedenen Dateien, aus denen Ihre Anwendung besteht.

Diese Einschränkung gilt nur für C++-Packages. Die mit Delphi erzeugten Packages sind mit beiden Toolketten kompatibel. Das heißt, Packages, die aus Delphi stammen, können von [[BCC64|Win64 (alt)]] und [[BCC64X|Win64 Modern]] verwendet werden. Das gilt auch umgekehrt: Delphi-Anwendungen können [[Packages mit der Funktion LoadPackage laden|Packages laden]], die entweder mit Win64 (alt) oder Win64 Modern erzeugt wurden. Allerdings kann Win64 (alt) keine Packages laden, die von Win64 Modern erzeugt wurden, und Win64 Modern kann keine Packages laden, die von der Win64 (alt) erzeugt wurden. Wenn Sie dies tun, werden Zugriffsverletzungen oder andere Fehler angezeigt.

===Siehe auch===

* [[Unit-Initialisierung und -Finalisierung für die neue C++-Toolkette|Unit-Initialisierung und -Finalisierung für die neue C++-Toolkette]]
* [[Import und Export von Packages für die neue C++-Toolkette|Import und Export von Packages für die neue C++-Toolkette]]
* [[Delphi-Packages für C++ erzeugen|Delphi-Packages für C++ erzeugen]]
* [[Verwendung des schwachen Packens|Verwendung des schwachen Packens]]
*[[BCC64X|BCC64X]]

{{DEFAULTSORT:Packages fur die neue C++-Toolkette}}

[[en:Packages for C++ New Toolchain]]
[[fr:Packages pour la nouvelle chaîne d'outils C++]]

Bildlaufleiste

2026-10-10T14:24:35Z

L10nBot: updated language links

{{Parent|Editor-Optionen}}

{{Menu|Tools > Optionen > Editor > Bildlaufleiste}}

Mithilfe der Anmerkungen der [[Bildlaufleiste|Bildlaufleiste]] erhalten Sie eine Übersicht über den Quelltext und können ein bestimmtes Element im Blick behalten.

Verwenden Sie diese Seite zum Konfigurieren der Anmerkungen.

{| border="1" frame="hsides" rules="rows"
|-
! '''Element'''
! '''Beschreibung'''
|- valign="top"
|
Farben des Editordesigns auf Bildlaufleiste anwenden
|
Ermöglicht, die IDE-Designfarben für die Editor-Bildlaufleiste zu verwenden.
|
|- valign="top"
|
Anmerkungen auf Bildlaufleiste aktivieren
|
Aktiviert die Optionen für die Bildlaufleisten-Anmerkungen.
|
|- valign="top"
|
Anmerkungen auf der Bildlaufleiste
|
{|
|- valign="top"
|
Aktiviert
|
Kontrollkästchen, mit dem alle Features zum Anzeigen von Markierungen auf der Bildlaufleiste aktiviert oder deaktiviert werden können.
|- valign="top"
|
Name
|
Anmerkungsoptionen: Fehlermarkierung, Geänderte Bereiche, Suchergebnisse und Positionsmarken.
|- valign="top"
|
Start (0-15)
|
Bereich von 0 bis 15, der definiert, wo die Bildlaufleiste beginnt.
|- valign="top"
|
Breite (0–15)
|
Bereich von 0 bis 15, der die Breite der Bildlaufleiste definiert.
|- valign="top"
|
Vorschau
|
Zeigt eine Vorschau an, wie die Bildlaufleiste entsprechend den Konfigurationen für '''Start''' und '''Breite''' aussieht.
|}
|- valign="top"
|
Auf Bildlaufleiste klicken, um zur Position zu springen
|
Springt direkt zur gewünschten Position, wenn Sie darauf klicken.
|}

==Siehe auch==

* [[Editor-Optionen|Editor]]

[[en:Scroll Bar]]
[[fr:Barre de défilement]]

Geteilter Editor

2026-10-10T14:24:34Z

L10nBot: updated language links

Mit der Ansicht [[Geteilter Editor|Geteilter Editor]] können Sie mehrere Editoren nebeneinander, über- und untereinander oder eine Kombination davon im selben Fenster verwenden. Sie können dazu auch ganze Sätze von Registerkarten aus frei platzierbaren Fenstern und zurück in die IDE ziehen.
Auf diese Weise sind komplexe benutzerdefinierte Layouts und Manipulationen möglich, d. h. Sie können ein einfaches zweispaltiges Layout, ein mehrzeiliges Layout oder ein genau auf Ihren Arbeitsablauf abgestimmtes Layout nutzen.
Es können mehrere Registerkarten mit derselben Unit geöffnet sein sowie mehrere Registerkarten mit einem Formular-Designer in einer Registerkarte und einer oder mehreren Code-Registerkarten für dieselbe Unit. So können Sie z. B. die Registerkarte, auf der der Designer angezeigt wird, verschieben.
Es gibt '''keine Begrenzung''' für die Anzahl der horizontal oder vertikal geteilten Editoren.

===Verwenden des geteilten Editors===

Sie können auf die Ansicht des geteilten Editors zugreifen, indem Sie mit der rechten Maustaste auf eine Registerkarte klicken und '''Teilen >''' oder '''Verschieben >''' auswählen. Mit "Teilen" wird eine andere Version der ausgewählten Registerkarte erstellt und mit "Verschieben" wird die Registerkarte geschlossen und an der ausgewählten Stelle in der IDE geöffnet.

[[File:Using-spliteditor.png|=link|400px|border]]

Für beide Optionen können Sie auch die folgenden Tastenkürzel verwenden:

*'''Oben teilen:''' Alt+Umschalt+T
*'''Unten teilen:''' Alt+Umschalt+B
*'''Rechts teilen:''' Alt+Umschalt+R
*'''Links teilen:''' Alt+Umschalt+L
*'''Nach oben verschieben:''' Strg+Alt+Umschalt+T
*'''Nach links verschieben:''' Strg+Alt+Umschalt+L
*'''Nach rechts verschieben:''' Strg+Alt+Umschalt+R
*'''Nach unten verschieben:''' Strg+Alt+Umschalt+B

Alternativ können Sie [[Geteilter Editor|Geteilter Editor]] verwenden, indem Sie eine Datei aus der Ansicht "Projekte" in eine geöffnete Editor-Registerkarte ziehen. Sie können auch mit der rechten Maustaste auf die Projektdatei klicken, die Option '''Öffnen in''' auswählen und die Editor-Registerkarte auswählen, in der Sie das Projekt öffnen möchten.

Sobald sich zwei Registerkarten in einem Fenster befinden, haben beide Titelleisten.

Mit "Geteilter Editor" können Sie Folgendes ausführen:

*Eine Editor-Registerkarte oder einen Registerkartensatz ziehen, indem Sie die Titelleiste an einer beliebigen Seite des IDE-Fensters andocken.
*Eine Editor-Registerkarte oder einen Registerkartensatz an einer beliebigen Seite (links, rechts, oben, unten) eines anderen Editors andocken.
*Eine Editor-Registerkarte oder einen Registerkartensatz mit einem vorhandenen Satz zusammenführen, indem Sie sie über die Mitte eines vorhandenen Editors ziehen. Auf diese Weise können auch frei platzierbare Fenster mit Registerkarten zusammengeführt werden.
*Eine Editor-Registerkarte oder einen Registerkartensatz ziehen, um ein separates Fenster zu erstellen.

Die meisten Operationen können für einzelne Registerkarten ausgeführt werden, wie das Verschieben einer Registerkarte zwischen angedockten Registerkartensätzen, indem sie die Registerkarte von einer Position an eine andere ziehen.

Jeder Registerkartensatz kann aus seinem Fenster gezogen und daraus ein eigenes Fenster erstellt werden. Ziehen Sie dazu die Titelleiste aus dem ursprünglichen Fenster.
{{Tip|Halten Sie die Strg-Taste beim Ziehen gedrückt, damit der Registerkartensatz sich nicht andockt.}}

Ebenso kann jedes Fenster an einen anderen Registerkartensatz angedockt werden. Ziehen Sie dazu die Titelleiste.

{{Note|Die meisten Editoren/Gruppen werden einfach ausgeblendet, wenn sie geschlossen werden. Aber der erste Editor, der früher der einzige Editor für das Hauptfenster war, schließt alle enthaltenen Registerkarten, wenn er mit der Schaltfläche "X" geschlossen wird. Der Platz für ihn bleibt jedoch erhalten. Der ursprüngliche Editor kann nicht geschlossen werden und nimmt immer Platz auf dem Bildschirm ein. Dies wirkt sich erst aus, wenn Sie die Registerkartengruppen schließen. Es gibt keine sichtbaren Auswirkungen, wenn Sie Registerkartengruppen bei der täglichen Arbeit erstellen, verschieben oder andocken.}}

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

''Dies ist eine der vielen Möglichkeiten, wie der "Geteilte Editor" konfiguriert werden kann.'' ''Ein Editor-Fenster befindet sich auf der linken Seite, zwei auf der rechten Seite und die Bereiche sind nicht sichtbar, aber sie werden angezeigt, wenn Sie den Mauszeiger darüber bewegen.''

===Designer und Code===

Mit geteilten Editoren können Sie die gleiche Datei nebeneinander bearbeiten. Beide Editoren zeigen denselben Dateiinhalt an. Wenn Sie in einem Editor etwas eingeben und zur dieser Stelle im anderen Editor scrollen, wird der Text dort angezeigt. Beide Ansichten lassen sich jedoch unabhängig voneinander verschieben, sodass Sie dieselbe Datei an mehreren Stellen bearbeiten können.
Sie können eine beliebige Anzahl von Registerkarten zur Bearbeitung derselben Datei verwenden.
{{Note|Denken Sie daran, dass es nur eine Datei (Modul oder Dateipuffer) gibt, aber mehrere Editor-Ansichten für diese Datei. Eine Änderung, die Sie in einem Editor vornehmen, wird daher immer in jedem anderen Editor für dieselbe Datei widergespiegelt. Eine in einem Editor vorgenommene Änderung wird nicht "kopiert" oder "dupliziert" oder ähnlich: Es gibt nur eine Datei und einen Inhalt für diese Datei, auch wenn Sie diese Datei in mehreren Editoren anzeigen/bearbeiten.
Anders ausgedrückt: Wenn Sie eine Datei in einem Editor bearbeiten, erfolgt diese Änderung in der Datei selbst, nicht im Editor. Das bedeutet, dass diese Änderung immer auch in den anderen Editoren vorhanden ist, die dieselbe Datei anzeigen.}}

===Tipps und Tricks===

*'''Speichern''' Sie die Konfiguration der Editoren als Desktop-Layout. Andernfalls kann es passieren, dass Sie viel Zeit mit der Einrichtung eines Layouts verbringen und es dann verlieren.

{{Notes|

*Wenn sich das Desktop-Layout ändert, ändert sich auch die Konfiguration, z. B. wenn die IDE mit dem Debuggen beginnt und zum '''Debug-Layout''' wechselt.
*Wenn Sie zu einem anderen Layout wechseln, wird jede Registerkartengruppe, die nicht im Layout platziert ist, zu einem frei platzierbaren Fenster abgedockt.}}
*Aktivieren Sie '''Optionen''' > '''Speichern und Wiederherstellen''' > '''Projekt-Desktop beim Schließen speichern''' und '''Editorstatus beim Schließen einer Registerkarte immer speichern'''.
*Das Speichern des Editorstatus bedeutet, dass gespeichert wird, wohin gescrollt wurde, welche Bereiche ausgeblendet und erweitert wurden usw. Dies ist sehr nützlich, wenn mehrere Editoren für dieselbe Datei geöffnet sind. Wenn Sie Ihren Desktop wieder öffnen und das Projekt erneut öffnen (oder wenn Sie einen Editor, den Sie zuvor geschlossen haben, erneut öffnen), wird der neu angezeigte Editor so dargestellt, wie er beim Schließen war.
*Ziehen Sie in Erwägung, die andockbaren Fenster im alten Stil abzupinnen. Das bedeutet, dass sie in eine kleine Registerkarte auf einer beliebigen Seite des Hauptfensters verschoben werden. Sie können sie wieder anzeigen, indem Sie auf die Registerkarte klicken, und sie bleiben sichtbar, solange sie den Fokus haben. Klicken Sie dazu auf die Schaltfläche "Anpinnen" in der Titelleiste des andockbaren Fensters neben dem X. Dieses Feature gibt es schon seit vielen Jahren, aber es war vor allem dann nützlich, wenn der Platz auf dem Bildschirm begrenzt war. Jetzt, da mehrere Editoren geteilt und aneinander angedockt werden können, kann es sehr nützlich sein, die Seitenbereiche abzupinnen, um horizontalen Platz zu schaffen.
*Gewöhnen Sie sich an, mit der rechten Maustaste auf eine Registerkarte '''> Teilen > Rechts''' (oder '''Links''') zu klicken. Die Verwendung mehrerer Spalten ist wahrscheinlich die gebräuchlichste Einstellung für geteilte Editoren. Diese Methode ist unglaublich leistungsfähig.

==Siehe auch==

*[[Ein erster Blick auf die IDE|Ein erster Blick auf die IDE]]
*[[Startansicht und Willkommensseite|Startansicht und Willkommensseite]]

[[en:Split Editor]]
[[fr:Fractionnement de l'éditeur]]
[[ja:分割エディタ]]

Deklaration von Inline-Variablen

2026-10-10T14:24:32Z

L10nBot: updated language links

In der Version 10.3 lässt die Delphi-Sprache größere Flexibilität bei der Deklaration lokaler Variablen zu. Entsprechend den Pascal-Sprachregeln mussten bis jetzt alle Variablendeklarationen in einem "var"-Block vor dem Beginn einer Funktion, Prozedur oder Methode erfolgen:<source lang="Delphi">
procedure Test;
var
I: Integer;
begin
I := 22;
ShowMessage (I.ToString);
end;</source>

Mit der neuen Syntax für die Deklaration von Inline-Variablen können Sie die Variable direkt in einem Codeblock deklarieren (und auch wie üblich mehrere Symbole verwenden):<source lang="Delphi">
procedure Test;
begin
var I: Integer;
I := 22;
ShowMessage (I.ToString);
end;

procedure Test2;
begin
var I, K: Integer;
I := 22;
K := I + 10;
ShowMessage (K.ToString);
end;</source>

Dies scheint nur ein kleiner Unterschied zu sein, aber es gibt mehrere Nebenwirkungen dieser Änderung. Erstens: Die Deklaration und Initialisierung kann in einer Anweisung vorgenommen werden. Zweitens: Sie können bei Bedarf Variablen in komplexen Codeblöcken mit begrenztem Gültigkeitsbereich deklarieren (da die Variable nur ab der Position ihrer Deklaration sichtbar ist, und sie nicht deklariert, aber nicht initialisiert in anderen Codeteilen vorhanden sein muss).

==Gültigkeitsbereich von Inline-Variablen==

Ein dritter Nebeneffekt ist, dass die Deklaration auch innerhalb eines begin-end-Blocks der zweiten Ebene zulässig ist und der Gültigkeitsbereich auf diesen Block beschränkt ist.<source lang="Delphi">
procedure Test; // declaration and initialization in a single statement
begin
var I: Integer := 22;
ShowMessage (I.ToString);
end;

procedure Test1; // multiple inline declarations (symbols declared when used)
begin
var I: Integer := 22;
var J: Integer;
J := 22 + I;
var K: Integer := I + J;
ShowMessage (K.ToString);
end;

procedure Test2; // scope limited to local block
begin
var I: Integer := 22;
if I > 10 then
begin
var J: Integer := 3;
ShowMessage (J.ToString);
end
else
begin
var K: Integer := 3;
ShowMessage (J.ToString); // COMPILER ERROR: “Undeclared identifier: ‘J’”
end;
end;</source>

Wie Sie dem letzten Codefragment oben entnehmen können, ist eine in einem begin-end-Block deklarierte Variable nur in diesem Block sichtbar und nicht nachdem der Block beendet wurde. Am Ende der if-Anweisungen sind J und K nicht mehr sichtbar.

Der Effekt bezieht sich nicht nur auf die Sichtbarkeit. Eine verwaltete Variable, wie eine Interface-Referenz oder ein Record, wird am Ende des Blocks ordnungsgemäß bereinigt, nicht erst am Ende der Prozedur oder Methode:<source lang="Delphi">
procedure Test99;
begin

// some code

if (something) then
begin
var Intf: IInterface = GetInterface; // Intf.AddRef
var MRec: TManagedRecord = GetMRecValue; // MRec.Create + MRec.Assign
UseIntf(Intf);
UseMRec(MRec);
end; // Intf.Release and MRec.Destroy are implicitly called at end of scope

// more code

end; // no additional cleanup</source>

==Typableitung für Inline-Variablen==

Außerdem kann der Compiler jetzt in verschiedenen Situationen an der Position ihrer Deklaration den Typ einer Variable vom Typ des zugewiesenen Werts ableiten.<source lang="Delphi">
procedure Test;
begin
var I := 22;
ShowMessage (I.ToString);
end;</source>

Der Typ des R-Wertausdrucks (das ist das, was nach dem := steht) wird analysiert, um den Typ der Variable zu ermitteln. Einige Datentypen werden auf größere Typen "erweitert", wie in dem oben dargestellten Beispiel, in dem der numerische Wert 22 (ein ShortInt) auf Integer erweitert wird. Als allgemeine Regel gilt: Wenn der Typ des Ausdrucks auf der rechten Seite ein integraler Typ und kleiner als 32 Bit ist, dann wird die Variable als 32-Bit-Integer deklariert. Sie können einen expliziten Typ verwenden, wenn Sie einen bestimmten, kleineren, numerischen Typ haben möchten.

Beachten Sie auch, dass nur ein einziger Bezeichner ohne Wertetyp deklariert werden kann (abweichend von allgemeinen Variablendeklarationen und Inline-Deklarationen).

Diese Funktion erspart Ihnen ein paar Tastenanschläge bei einem Integer oder String, aber die Typableitung von Variablen bei komplexen Typen, wie z. B. Instanzen von generischen Typen, wird erheblich einfacher. Im folgenden Codefragment sind die abgeleiteten Typen "TDictionary<string, Integer>" für die Variable MyDictionary und "TPair<string, Integer>" für die Variable APair.

<source lang="Delphi">
procedure NewTest;
begin
var MyDictionary := TDictionary<string, Integer>.Create;
MyDictionary.Add ('one', 1);
var APair := MyDictionary.ExtractPair('one');
ShowMessage (APair.Value.ToString)
end;</source>

==Inline-Konstanten==

Neben Variablen können Sie jetzt auch Konstantenwerte inline deklarieren. Dies kann sowohl für typisierte Konstanten als auch für nicht typisierte Konstanten angewendet werden. Im letzteren Fall wird der Typ abgeleitet (ein Feature, das seit langem für Konstanten verfügbar ist). Hier ist ein einfaches Beispiel:<source lang="Delphi">
const M: Integer = (L + H) div 2; // single identifier, with type specifier
const M = (L + H) div 2; // single identifier, without type specifier</source>

==For-Schleifen mit Variablendeklaration==

Ein spezieller Fall, in dem Sie die Vorteile von Inline-Variablendeklarationen nutzen können, sind Schleifenanweisungen, einschließlich for-to-Schleifen und for-in-Schleifen.<source lang="Delphi">
for var I: Integer := 1 to 10 do ...
for var Item: TItemType in Collection do...</source>Sie können den Code durch Typableitung weiter vereinfachen:<source lang="Delphi">
for var I := 1 to 10 do ...
for var Item in Collection do ...</source>Im folgenden Code ist eine Variable mit begrenztem Gültigkeitsbereich besonders nützlich: Durch Verwendung der Variable 'I' außerhalb der Schleife wird ein Compiler-Fehler verursacht (früher wurde meistens nur eine Warnung ausgegeben):<source lang="Delphi">
procedure ForTest;
begin
var total := 0;
for var I: Integer := 1 to 10 do
Inc (Total, I);
ShowMessage (total.ToString);
ShowMessage (I.ToString); // compiler error: Undeclared Identifier ‘I’</source>

==Wiederholte Inline-Variablen==

Der Delphi-Debugger kann wiederholte Inline-Variablen mit demselben Namen verarbeiten. Dies erfolgt dadurch, dass der Compiler für jede Variable Gültigkeitsbereichsinformationen ausgibt, sodass sie separat behandelt wird.

<source lang="Delphi">
procedure Foo;
begin
if Length(Caption) < 5 then begin
var X := 5; // First ‘X’ variable
ShowMessage(IntToStr(X));
end else begin
var X := Length(Caption); // Different ‘X’ variable
ShowMessage(‘Length is:’ + IntToStr(X));
end;
end;
</source>

Der obige Beispielcode zeigt zwei Blöcke in derselben Methode, die eine Variable mit lokalem Gültigkeitsbereich und dem Namen "X" enthalten. Der Debugger erkennt diese als unterschiedliche Variablen und der Compiler kennt den Gültigkeitsbereich der Variablen, sodass die Variablen nicht gleichzeitig angezeigt werden.

{{Note| Benutzer müssen einen erneuten Build durchführen, um diese neuen Information in DCUs oder Packages-/Debug-Informationen zu erhalten. DCUs bleiben im Release 12.x Athens ABI-kompatibel; 12.1 und 12.0 laden die Informationen zum Gültigkeitsbereich nicht.}}

[[Category:Rio]]

[[en:Inline Variable Declaration]]
[[fr:Déclaration de variable inline]]
[[ja:インライン変数宣言]]

Optionen für das Ziel

2026-10-10T14:24:30Z

L10nBot: updated language links

{{Parent|Projektoptionen (Dialogfeld)}}

Mit diesen Optionen können Sie die auf der aktuellen Seite festgelegten Projektoptionen für verschiedene Kombinationen aus [[Unterstützte Zielplattformen|Zielplattform]] und Build-Konfiguration (oder für alle Plattformen oder für alle Konfigurationen) übernehmen.

Zieloptionen werden in der obersten Zeile aller Compiler- und Build-bezogenen Seiten des Dialogfelds '''[[Projektoptionen (Dialogfeld)|Projektoptionen]]''', wie z. B. {{Menu | Projekt > Optionen > [[Delphi-Compiler|Delphi-Compiler]]}}, angezeigt.

{| border="1" frame="hsides" rules="rows"
|-
!'''Optionen für das Ziel'''
!'''Beschreibung'''
|- valign="top"
|
Ziel
|
Das '''Ziel''' ist der Name der Build-Konfiguration, die den aktivierten Optionen auf dieser Seite zugeordnet ist. Im Feld "Ziel" wird die Konfiguration und die zugehörige Zielplattform, wie z. B. '''Debug-Konfiguration - 32-Bit-Windows-Plattform''' (die Standardzielkonfiguration für 32-Bit-Windows-Anwendungen), angezeigt.
Integrierte Build-Konfigurationen, die Sie als Ziel auswählen können:
*'''Alle Konfigurationen'''
*'''Debug'''
*'''Release'''

Build-Konfigurationen, die Sie erstellt haben, werden zusätzlich zu den integrierten Konfigurationen aufgeführt. Die Vorgabe ist '''Debug'''.
Die diesen Build-Konfigurationen zugeordneten Zielplattformen werden im '''[[Projekte-Fenster|Projekte-Fenster]]''' unter dem Knoten [[Übersicht über Zielplattformen|Zielplattformen]] des Projektknotens angezeigt. Wenn Sie Ihrem Projekt eine Plattform hinzufügen oder daraus entfernen
:{{Note| Jedes Projekt muss mindestens eine Zielplattform enthalten.}}

'''Beispiele'''
Durch Auswahl eines '''Ziels''' werden die Optionen auf der aktuellen Seite für die ausgewählte Konfiguration auf der ausgewählten Plattform angewendet. Hier sind beispielsweise die Ergebnisse für die Auswahl der folgenden Werte in der Dropdown-Liste '''Ziel''':
*'''Alle Konfigurationen'''
**Wendet die Optionen auf der Seite für jede Kombination aus Plattform und Konfiguration an.
**Im Dialogfeld wird '''Alle Konfigurationen - Alle Plattformen''' angezeigt.
*'''Release-Konfiguration'''
**Wendet die Optionen auf der Seite auf die '''Release'''-Konfiguration für jede Kombination aus Plattform und Konfiguration an.
**Im Dialogfeld wird '''Debug-Konfiguration - Alle Plattformen''' angezeigt.
*'''Debug-Konfiguration > 32-Bit-Windows-Plattform'''
**Wendet die Optionen auf der Seite auf die '''Debug'''-Konfiguration für die '''32-Bit-Windows'''-Plattform an.
**Im Dialogfeld wird '''Debug-Konfiguration - 32-Bit-Windows-Plattform''' angezeigt.

Weitere Informationen über Build-Konfigurationen finden Sie unter [[Überblick zu Build-Konfigurationen|Überblick zu Build-Konfigurationen]].
|- valign="top"
|
Übernehmen...
|
Zeigt das Dialogfeld '''[[Optionsgruppe anwenden|Optionsgruppe anwenden]]''' an, in dem Sie die Optionen einer vorhandenen, benannten Optionsgruppe (<code>.optset</code>-Datei) für die aktuelle Konfiguration übernehmen können.
Weitere Informationen über Optionsgruppen finden Sie unter [[Übersicht über Optionsgruppen|Übersicht über Optionsgruppen]].
|- valign="top"
|
Speichern...
|
Zeigt das Dialogfeld '''[[Speichern-Befehle|Speichern-Befehle]]''' an, in dem Sie die aktuellen Einstellungen der '''Projektoptionen''' als Optionsgruppendatei (<code>.optset</code>-Datei) speichern können.
Weitere Informationen über Optionsgruppen finden Sie unter [[Übersicht über Optionsgruppen|Übersicht über Optionsgruppen]].
|}

Klicken Sie zum Ändern des Wertes einer Option im [[Projektoptionen (Dialogfeld)|Dialogfeld "Projektoptionen"]] auf das Wertefeld, und geben Sie dann einen Wert ein, oder klicken Sie auf [[Image:ProjectOptionsDownArrow2.jpg|Pfeil nach unten]], und wählen Sie den gewünschten Wert aus.

==Siehe auch==

*[[Projektoptionen (Dialogfeld)|Projektoptionen (Dialogfeld)]]
*[[Gemeinsame Elemente auf den Projektoptionsseiten|Gemeinsame Elemente auf den Projektoptionsseiten]]
*[[Aktivieren und Konfigurieren der Zielplattform|Hinzufügen einer Zielplattform zu einem Projekt]]

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

[[en:Target Options]]
[[fr:Options de la cible]]
[[ja:［ターゲット］オプション]]

Packages in Anwendungen laden

2026-10-10T14:24:29Z

L10nBot: updated language links

{{Parent|Laufzeit-Packages}}

Sie können Packages mit einem der folgenden Verfahren dynamisch laden:

<ul><li>
Durch Auswahl von '''Mit Laufzeit-Packages linken''' im Dialogfeld '''Projektoptionen''' (wie in diesem Thema beschrieben)

</li>
<li>
'''
[[Packages mit der Funktion LoadPackage laden|Packages mit der Funktion LoadPackage laden]]'''</li>
</ul>

'''So laden Sie Packages mit dem Dialogfeld "Projekt > Optionen"'''

<ol><li> Öffnen oder erstellen Sie ein Projekt in der IDE.</li>
<li> Wählen Sie {{Menu|Projekt > Optionen > Packages > [[Laufzeit-Packages (Optionen)|Laufzeit-Packages]]}} aus.</li>
<li> Aktivieren Sie das Kontrollkästchen '''Mit Laufzeit-Packages linken'''. </li>
<li> Überprüfen Sie im Feld '''Laufzeit-Package-Importbibliotheken''' die Liste der bekannten Laufzeit-Packages.

{{Note|Beachten Sie, dass installierten Entwurfszeit-Packages zugeordnete Laufzeit-Package bereits aufgeführt sind.

 Außerdem werden Laufzeit-Packages implizit nur bei Bedarf geladen (wenn also auf ein Objekt Bezug genommen wird, das in einer Unit des Package definiert ist).}}

</li>
<li> Um weitere Bibliotheksnamen hinzuzufügen, klicken in das Eingabefeld '''Laufzeit-Package-Importbibliotheken''', und gehen Sie wie folgt vor:

<ul><li>
Klicken Sie auf die am rechten Ende des Feldes angezeigte [[Image:ProjectOptionsEllipsis.jpg|Ellipse]]. Im Dialogfeld '''Laufzeit-Package-Importbibliotheken''' können Sie:
<ul><li>Den Namen des neuen Package eingeben und auf '''OK''' klicken.</li>
<li>
Eine Liste der verfügbaren Packages durch Klicken auf die Schaltfläche '''Ordner suchen''' im Dialogfeld '''Laufzeit-Package-Importbibliotheken''' durchsuchen. Klicken Sie dann im Dialogfeld [[Laufzeit-Package hinzufügen|Laufzeit-Package hinzufügen]] neben '''Package-Name''' auf die Schaltfläche '''Durchsuchen'''. 
{{Note|Wenn Sie im Dialogfeld [[Laufzeit-Package hinzufügen|Laufzeit-Package hinzufügen]] das Eingabefeld '''Suchpfad''' bearbeiten, ändern Sie den '''globalen Bibliothekspfad'''.}}
</li>
</ul>
</li>
<li>
Geben Sie in das Eingabefeld einen oder mehrere Package-Namen ein. 
{{Tip|Die Namen der Packages müssen keine Dateinamenserweiterungen (oder Versionsnummern, die das {{Delphi}}-Release angeben) enthalten. Das heißt, in einer VCL-Anwendung wird vcl90.bpl als vcl angegeben. Trennen Sie bei der Eingabe mehrerer Namen in das Feld '''Laufzeit-Package''' die Namen durch Semikolon. Zum Beispiel: <source lang="cpp">
rtl;vcl;vcldb;vclado;vclbde;</source>}}</li>
</ul>
</li>
</ol>

Die im Eingabefeld aufgelisteten '''Laufzeit-Packages''' werden beim Compilieren automatisch mit Ihrer Anwendung gelinkt. Dabei werden doppelt vorhandene Package-Namen ignoriert und bei deaktiviertem Kontrollkästchen '''Mit Laufzeit-Packages linken''' wird die Anwendung ohne Packages compiliert.
{{Tip| Für C++ müssen Sie die Einstellungen für dynamische Packages beibehalten und die dynamische RTL verwenden. Die Toolkette nutzt die dynamische Laufzeit, wenn Sie Packages verwenden. Wir empfehlen jedoch, dass Sie unter {{Menu| Projekt > Optionen > Packages > [[Laufzeit-Packages (Optionen)|Laufzeit-Packages]]}} überprüfen, ob sie synchron sind.}}
Laufzeit-Packages werden jeweils nur für das laufende Projekt ausgewählt. Sie haben die Möglichkeit, die aktuelle Auswahl als Standardeinstellung für neue Projekte zu speichern, indem Sie das Kontrollfeld '''Standard ''' unten auf der Seite "Projektoptionen" aktivieren.
{{Note| Bei der Erstellung von Anwendungen, die Packages verwenden, müssen die Namen der ursprünglichen {{Delphi}}-Units in der '''uses'''-Klausel der Quelldateien angegeben werden. Eine Quelldatei für das Hauptformular einer Anwendung könnte also wie folgt beginnen:
<source lang="delphi">
unit MainForm;
interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms, Dialogs;</source><source lang="cpp">
#include "vcldb.h"</source>}}
The units referenced in this VCL example are contained in the VCL and RTL packages. Nonetheless, you must keep these references in the '''uses''' clause, even if you use VCL and RTL in your application, or you will get compiler errors. In generated source files, the Form Designer automatically adds these units to the uses clause.

==Siehe auch==

*
[[Benötigte Laufzeit-Packages auswählen|Benötigte Laufzeit-Packages auswählen]]
*
[[Packages und Komponenten: Übersicht|Packages und Komponenten: Übersicht]]
*
[[Packages weitergeben|Packages weitergeben]]
*
[[Packages mit der Funktion LoadPackage laden|Packages mit der Funktion LoadPackage laden (Erzeugen mit Laufzeit-Packages)]]

[[Category:Windows-Entwicklerhandbuch]]
[[Category:Delphi]]

[[en:Loading Packages in an Application]]
[[fr:Chargement des packages dans une application]]
[[ja:アプリケーションでのパッケージの読み込み]]

Import und Export von Packages für die neue C++-Toolkette

2026-10-10T14:20:21Z

L10nBot: updated language links

{{Parent|Packages für die neue C++-Toolkette}}

Bei Verwendung des Modifizierers PACKAGE oder [[Declspec(package)|__declspec(package)]] kann es schwierig sein, zu erkennen, wann Elemente importiert oder exportiert werden. In {{Product}} werden Heuristiken angewendet und es wurde festgelegt, dass eine Klasse als [[Declspec(dllexport)|__declspec(dllexport)]] behandelt wird, wenn die folgenden Bedingungen erfüllt sind:

* Die Klasse ist als <code>[[Declspec(package)|__declspec(package)]]</code> gekennzeichnet und enthält eine Nicht-Inline-Funktionsdeklaration.
* Die Datei, die die Klasse enthält, wird mit der Option <code>-tP</code> compiliert.

Ansonsten wird die Klasse als [[Declspec(dllimport)|__declspec(dllimport)]] betrachtet.

Mit anderen Worten: Es handelt sich um eine '''Vermutung'''. Es gibt keine zuverlässige Methode, um anhand einer Deklaration in einer {{CBuilder}}-Header-Datei festzustellen, ob exportiert oder importiert werden soll. Daher greifen wir auf Heuristiken zurück. Im Allgemeinen wird bei einem [[Declspec(package)|PACKAGE-Makro]] davon ausgegangen, dass das Package beim Erzeugen eines Package-Projekts versucht, zu exportieren, andernfalls wird importiert.

Beachten Sie, dass wir auch Inline-Methoden in unseren HPP-Dateien verwenden. Diese Methoden sind aufgrund von Unterschieden in der Verfügbarkeit von Konstruktoren in abgeleiteten Klassen ({{Delphi}} erbt alle Konstruktoren) normalerweise für Konstruktoren vorgesehen. Diese Methoden verhindern jedoch nicht, dass eine Klasse gemäß der Heuristik importiert wird. Das Fazit hier ist also, dass Heuristiken bei der Verwendung von [[Declspec(package)|__declspec(package)]] herangezogen werden.

Das liegt daran, dass Packages versuchen, ein {{Delphi}}-Konzept auf {{CBuilder}} abzubilden, was jedoch nicht perfekt gelingen kann. Im Allgemeinen empfiehlt {{Product}} Ihnen, Packages mit Bedacht zu verwenden. Anwendungsfälle, die auf {{Delphi}} abzielen (wie beispielsweise Komponenten), sind weitaus erfolgversprechender als die Verwendung eines Package als eine Art DLL, wenn stattdessen eine DLL oder eine statische Bibliothek verwendet werden sollte.

===Codebeispiel===

<syntaxhighlight lang="c++">
class PACKAGE TMyComponent : public TComponent {
public:

__fastcall TMyComponent(TComponent* Owner);
void __fastcall DoSomething();

};

</syntaxhighlight>In diesem Beispiel verfügt die Klasse TMyComponent über das Makro PACKAGE (das zu decspec(package) erweitert wird). Als Ergebnis wendet der Compiler Heuristiken an, um festzustellen, ob Sie versuchen, die Klasse zu exportieren oder zu importieren.

==Empfehlungen==

Bitte beachten Sie bei der Verwendung des Package-Imports und -Exports für die neue C++-Toolkette die folgenden Empfehlungen, um Probleme zu vermeiden.

* Wir raten dringend davon ab, für Ihre als Package gekennzeichnete Klasse Compiler-Standard- oder vom Compiler generierte Methoden zu verwenden. Beachten Sie die [https://en.cppreference.com/w/cpp/language/rule_of_three Rule of Three/Five (EN)].
* Verwenden Sie unter keinen Umständen Inline-Methoden in Ihren importierten oder exportierten Package-Typen, auch keine einfachen. Platzieren Sie ausdrücklich und gezielt alle Methoden (einschließlich Konstruktor, Destruktor, Kopierkonstruktor und [https://en.cppreference.com/w/cpp/language/rule_of_three andere (EN)]) in die .cpp-Datei.
* Wir empfehlen Ihnen ausdrücklich, keine Template-Typen zu exportieren, da diese per Definition inline sind und zu Mehrfachdefinitionen führen können.
* Seien Sie bei Abhängigkeiten zwischen Units vorsichtig und machen Sie sich mit der [[Unit-Initialisierung und -Finalisierung für die neue C++-Toolkette|Unit -Initialisierung und -Finalisierung]] vertraut.
* Wir empfehlen dringend, PACKAGE oder [[Declspec(package)|__declspec(package)]] generell nur in ganz einfachen Fällen zu verwenden. Kennzeichen Sie stattdessen Ihre Typen manuell mit [[Declspec(dllimport)|__declspec(dllimport)]] und [[Declspec(dllexport)|__declspec(dllexport)]]. {{Tip|Ein möglicher Ansatz besteht darin, die Modifizierer in ein Makro einzubinden, dessen Wert von der Position des Headers abhängt. Mit anderen Worten: Ihr EXE-Projekt könnte ein Makro so definieren, dass es immer importiert wird, wenn der Header einbezogen wird.}}
* Packages sind erweiterte DLLs, daher gelten diese dllimport/dllexport-Direktiven. Entscheidend ist dabei, dass durch die explizite Kennzeichnung keine Spekulationen seitens des Compilers stattfinden, sondern eine klare Anweisung des Programmierers vorliegt, den Export oder Import zu versuchen. Packages sind gut für Komponenten geeignet und für auf {{Delphi}} basierende Typen, aber im Allgemeinen sollten Sie DLLs mit der dynamischen Laufzeit verwenden. {{Attention|Beachten Sie, dass es in C++ kein modulübergreifendes Typ-Rooting gibt.}}

===Siehe auch===

* [[Packages für die neue C++-Toolkette|Packages für die neue C++-Toolkette]]
* [[Unit-Initialisierung und -Finalisierung für die neue C++-Toolkette|Unit-Initialisierung und -Finalisierung für die neue C++-Toolkette]]
*[[Declspec(dllimport)|__declspec(dllimport)]]
*[[Declspec(dllexport)|__declspec(dllexport)]]
*[[BCC64X|BCC64X]]

{{DEFAULTSORT:Import und Export von Packages fur die neue C++-Toolkette}}

[[en:Package Import and Export for C++ New Toolchain]]
[[fr:Importation et exportation de package pour la nouvelle chaîne d'outils C++]]

Subversion-Farben

2026-10-08T14:27:21Z

L10nBot: updated language links

{{Parent|Optionen für die Versionskontrolle: Subversion}}

{{Menu|Tools > Optionen > Versionskontrolle > Subversion > Farben}}

Für die Formatierung von Versionskontrollvorgängen im [[Protokollbereich|Protokollbereich]] können Sie verschiedene Farbformatierungsoptionen verwenden.

Sie können die Farbe für folgende Status der Dateien unter einem Versionskontrollsystem festlegen:

* '''Konflikte'''
* '''Hinzugefügt'''
* '''Fehlt/Gelöscht/Ersetzt'''
* '''Zusammengeführt'''
* '''Geändert'''

[[Image:Subversion Colors.png|link=|border]]

==Siehe auch==

* [[Version Control Options: Subversion|Optionen für die Versionskontrolle: Subversion]]
* [[Version Control Options: Git|Optionen für die Versionskontrolle: Git]]
* [[Version Control Options: Mercurial|Optionen für die Versionskontrolle: Mercurial]]
* [[Subversion-Integration in der IDE|Subversion-Integration in der IDE]]
* [[Git-Integration in der IDE|Git-Integration in der IDE]]
* [[Mercurial-Integration in der IDE|Mercurial-Integration in der IDE]]

[[en:Subversion Colors]]
[[fr:Couleurs Subversion]]
[[ja:Subversion の色]]

Mercurial-Farben

2026-10-08T14:27:20Z

L10nBot: updated language links

{{Parent|Optionen für die Versionskontrolle: Mercurial}}

{{Menu|Tools > Optionen > Versionskontrolle > Mercurial > Farben}}

Für die Formatierung von Versionskontrollvorgängen im [[Protokollbereich|Protokollbereich]] können Sie verschiedene Farbformatierungsoptionen verwenden.

Sie können die Farbe für folgende Status der Dateien unter einem Versionskontrollsystem festlegen:

* '''Konflikte'''
* '''Hinzugefügt'''
* '''Fehlt/Gelöscht/Ersetzt'''
* '''Zusammengeführt'''
* '''Geändert'''

[[Image:Mercurial Colors.png|link=|border]]

==Siehe auch==

* [[Version Control Options: Mercurial|Optionen für die Versionskontrolle: Mercurial]]
* [[Version Control Options: Git|Optionen für die Versionskontrolle: Git]]
* [[Version Control Options: Subversion|Optionen für die Versionskontrolle: Subversion]]
* [[Subversion-Integration in der IDE|Subversion-Integration in der IDE]]
* [[Git-Integration in der IDE|Git-Integration in der IDE]]
* [[Mercurial-Integration in der IDE|Mercurial-Integration in der IDE]]

[[en:Mercurial Colors]]
[[fr:Couleurs Mercurial]]
[[ja:Mercurial の色]]

Git-Farben

2026-10-08T14:27:17Z

L10nBot: updated language links

{{Parent|Optionen für die Versionskontrolle: Git}}

{{Menu|Tools > Optionen > Versionskontrolle > Git > Farben}}

Für die Formatierung von Versionskontrollvorgängen im [[Protokollbereich|Protokollbereich]] können Sie verschiedene Farbformatierungsoptionen verwenden.

Sie können die Farbe für folgende Status der Dateien unter einem Versionskontrollsystem festlegen:

* '''Konflikte'''
* '''Hinzugefügt'''
* '''Fehlt/Gelöscht/Ersetzt'''
* '''Zusammengeführt'''
* '''Geändert'''

[[Image:Git Colors.png|link= |border]]

==Siehe auch==

* [[Version Control Options: Git|Optionen für die Versionskontrolle: Git]]
* [[Version Control Options: Mercurial|Optionen für die Versionskontrolle: Mercurial]]
* [[Version Control Options: Subversion|Optionen für die Versionskontrolle: Subversion]]
* [[Subversion-Integration in der IDE|Subversion-Integration in der IDE]]
* [[Git-Integration in der IDE|Git-Integration in der IDE]]
* [[Mercurial-Integration in der IDE|Mercurial-Integration in der IDE]]

[[en:Git Colors]]
[[fr:Couleurs Git]]
[[ja:Git の色]]

Verwenden von DelphiLSP Code Insight mit anderen Editoren

2026-10-05T14:24:49Z

L10nBot: Interlanguage links

==DelphiLSP – Sprachserver für Delphi==

DelphiLSP.exe ist ein Delphi-Sprachserver, der das [https://langserver.org Language Server Protocol (LSP)] implementiert. Es kapselt die Sprach-Features wie Programmierhilfe und Fehlermarkierung. Es wird [[Code Insight (Referenz)|in der IDE]], verwendet, kann aber auch mit Visual Studio Code oder anderen Editoren, die das LSP unterstützen, verwendet werden.

==Verwenden von DelphiLSP in Visual Studio Code==

Verwenden Sie die DelphiLSP-Erweiterung in Visual Studio Code, um RAD Studio-Projekte zu öffnen und Operationen durchzuführen.
Führen Sie die folgenden Schritte aus, um Ihre Projekte zu öffnen:
Installieren Sie die DelphiLSP-Erweiterung für VSCode:

*Installieren Sie RAD Studio 11.0 oder höher auf Ihrem lokalen Computer.
*Installieren Sie [https://code.visualstudio.com Visual Studio Code].
*Laden Sie die '''DelphiLSP'''-Erweiterung von '''Visual Studio Code Marketplace''' herunter, und installieren Sie sie.
**Laden Sie das Fenster '''Visual Studio Code''' erneut, oder verwenden Sie die Befehlspalette <F1>, und geben Sie ''„reload window“'' ein.

So öffnen Sie ein Projekt:

*Erstellen Sie in Delphi eine .delphilsp.json-Datei für das Delphi-Projekt, mit dem Sie in Visual Studio Code arbeiten möchten. Detaillierte Informationen dazu finden Sie unter [[Code Insight (Referenz)#Erstellen_von_.delphilsp.json-Dateien|Code Insight (Referenz)]].

{{Note| Überprüfen Sie die .delphilsp.json-Dateien nicht in die Versionskontrolle, da sie die für die lokale Computerkonfiguration geltenden Einstellungen enthalten.}}

*Öffnen Sie einen Ordner in Visual Studio Code, der mindestens ein Delphi-Projekt enthält.
**Öffnen Sie {{Menu|File > Open Folder}}, um Ihre Projekte zu laden.

{{Note| Öffnen Sie das gesamte Projekt, nicht nur einzelne Dateien.}}

[[File:Loaded project.png|border|link=|500px]]

Die DelphiLSP-Erweiterung verwendet die .delphilsp.json-Datei in dem Ordner, den Sie öffnen. Wenn keine oder mehrere vorhanden sind, wird eine Meldung angezeigt, in der Sie aufgefordert werden, die zu verwendende .delphilsp.json-Datei auszuwählen. Siehe [[Verwenden von DelphiLSP Code Insight mit anderen Editoren#Manuelles_Festlegen_der_Projektkonfigurationsdateien|Manuelles Festlegen der Projektkonfigurationsdateien]] unten.
{{Note| Die DelphiLSP-Erweiterung wird erst aktiviert, wenn Sie ein Delphi-Projekt (.pas- oder .dpr-Datei) öffnen.}}

*Nun können Sie mit der Verwendung der LSP-Features mit Ihrem Delphi-Code in Visual Studio Code beginnen. Die Features von Code Insight sind verfügbar und mit denen in RAD Studio identisch. Weitere Informationen finden Sie unter [[Code Insight (Referenz)|Code Insight (Referenz)]].

[[File:Delphi code.png|border|link=]]

===Fehlerbehebung===

====Manuelle Installation der DelphiLSP-Erweiterung in Visual Studio Code====

Installieren Sie die '''DelphiLSP'''-Erweiterung manuell in '''Visual Studio Code''' anhand der folgenden Schritte:

*Wählen Sie '''Extensions''', '''Install from VSIX''' und dann die DelphiLSP-Erweiterungsdatei (z. B. delphiLsp-x.x.x.vsix) aus.

[[File:Install from VSIX.png|border|link=]]

* Öffnen Sie [https://code.visualstudio.com/docs/getstarted/settings User Settings], und legen Sie Delphi-Lsp:Executable fest:
**Wählen Sie {{Menu|File > Preferences > Settings}} aus.
**Geben Sie in der Suchleiste „delphilsp“ ein.
**Achten Sie darauf, dass die Registerkarte „User“ geöffnet ist.
**Legen Sie '''Delphi Lsp:Executable''' mit „Path to DelphiLSP.exe“ fest.

[[File:SETTINGS.png|border|link=|800px]]

====Manuelles Festlegen der Projektkonfigurationsdateien====

Wenn keine oder mehrere Konfigurationsdateien in Visual Studio Code gefunden werden, wird eine kleine Eingabeaufforderung angezeigt. Klicken Sie darauf, um die Plugin-Einstellungen anzuzeigen.

[[File:Workspace settings.png|border|link=|800px]]

Die Einstellungsdatei (Settings File) muss auf die .delphilsp.json-Konfiguration Ihres Projekts zeigen.

{{Note| Konfigurieren Sie Ihr Projekt auf der Registerkarte „Workspace Settings“. Weitere Informationen zu User- und Workspace-Einstellungen finden Sie in der [https://code.visualstudio.com/docs/getstarted/settings Visual Studio Code Documentation (Englisch)].}}

===Ausfüllen von Bug-Reports===

Die .log- und .trace-Dateien enthalten wichtige Informationen über Systemoperationen. Es ist hilfreich, sie zu überprüfen und zu analysieren, wenn Fehler oder unerwünschtes Verhalten auftreten.

So debuggen Sie Probleme und füllen Bug-Reports aus:

*Aktivieren Sie in den DelphiLSP-Einstellungen die Protokollierung. Legen Sie „Log Modes“ auf 255 (eine Bitmaske für alle Informationen) fest.
*Befolgen Sie die gleichen Schritte wie für das Senden von [[Code Insight (Referenz)#Senden_von_Fehlern_und_Protokolldateien|DelphiLSP-Bug-Berichten]].
*Vergessen Sie nicht, die verwendete .delphilsp.json-Datei anzuhängen.

{{Note| Die .trace- und .log-Dateien werden nur erstellt, wenn die Protokollierung aktiviert ist.}}

====Debuggen in Visual Studio Code====

In DelphiLSP-Projekten werden die .log-Dateien nicht erstellt, aber mit der DelphiLSP-Erweiterung können Sie sie in Visual Studio Code prüfen.

So debuggen Sie Probleme in Visual Studio Code:

*Öffnen Sie über das Fenster „Visual Studio Code“ die '''Output View''' oder verwenden Sie die Befehlspalette <F1>, und geben Sie ''„focus output view“'' ein.
*Wählen Sie im Dropdown-Menü '''DelphiLSP''' aus.
*Es wird in Echtzeit eine Meldung vom Server an den Client gesendet.

[[File:Log Message.png|border|link=|998px]]

==Verwenden von DelphiLSP mit anderen Editoren==

Die folgende Dokumentation kann nützlich sein, wenn Sie DelphiLSP mit anderen Editoren testen möchten. DelphiLSP kommuniziert nur über Standard-I/O (Konsole). Der LSP-Server sucht nach einer .delphilsp.json-Datei, genauso wie wenn sie in VSCode verwendet wird.

===Initialisierung===

LSP ermöglicht benutzerdefinierte initializationOptions in der Initialisierungsanforderung.
Hier ist ein Beispiel einer gültigen Initialisierungsanforderung:<source lang="json">
{
"jsonrpc":"2.0",
"id":1,
"method":"initialize",
"params":{
"processId":4711,
"rootUri":"file:///C%3A/Test",
"initializationOptions":{
"serverType":"controller",
"agentCount":2,
"returnDccFlags":true,
"returnHoverModel":true,
"storeProjectSettings":false
}
}
}
</source>Folgende Felder werden verwendet:

'''serverType'''

:Definiert den Operationsmodus von DelphiLSP:
::● '''„controller“''': Der Server erzeugt '''agentCount'''-DelphiLSP-Unterprozesse (Agents), die mit dem Controller zusammenarbeiten, um Anforderungen zu beantworten. Der Controller fungiert als Proxy zwischen der IDE und den Agents. Wenn ein Agent beendet wird oder nicht mehr auf Anforderungen antwortet, ersetzt der Controller ihn durch einen neuen, frischen Agent. Anforderungen können von mehreren Agents parallel verarbeitet werden. {{Note| Wir unterstützen nur Konfigurationen mit bis zu zwei Agent-Prozessen und haben auch nur diese getestet. Einer wird für die Fehlermarkierung verwendet, der andere für alle anderen LSP-Anforderungen, wie z. B. die Programmierhilfe. Dies ist ein Agent und ein Linter.}}
::● '''„agent“''': Der Server wird im Einzelprozessmodus ausgeführt. Der Server kann jeweils nur eine Anforderung bearbeiten. In diesem Modus ist es nicht möglich, Fehlermarkierung (Diagnosen) zu erhalten.
::● '''„linter“''': Der Server wird im Einzelprozessmodus ausgeführt. Der Server kann keine Anforderungen für Sprach-Features wie die Programmierhilfe verarbeiten. Er ist für die Fehlersuche zuständig. Fehler, Warnungen und Hinweise werden über die <code>textDocument/publishDiagnostics</code>-Benachrichtigung bereitgestellt.
:Der Vorgabewert lautet „agent“. Verwenden Sie „controller“ gemeinsam mit einem agentCount von 2, um dasselbe Verhalten wie in der Delphi-IDE und das Standardverhalten der VSCode-Erweiterung zu erhalten.

'''agentCount'''

:Definiert die Anzahl der Unterprozesse, die gestartet werden, wenn serverType = „controller“.
::●'''agentCount <= 0''': agentCount wird auf 1 festgelegt
::●'''agentCount = 1''': Ein Unterprozess mit serverType = „agent“ wird gestartet
::●'''agentCount > 1''': [agentCount - 1] Unterprozesse mit serverType = „agent“ werden gestartet. Ein Unterprozess mit serverType = „linter“ wird gestartet.
:Der Vorgabewert ist 2.

'''returnDccFlags'''

:Bei „true“ übernehmen die Programmierhilfe-Elemente einige zusätzliche Informationen vom Compiler. Die IDE verwendet diese Daten, um Typen der Programmierhilfe anzuzeigen, die nicht in der LSP-Spezifikation definiert sind, wie Prozedur oder Typ.
:Der Vorgabewert ist „false“.

'''returnHoverModel'''

:Bei „true“ gibt <code>textDocument/hover</code> ein JSON-Objekt anstatt von Text/Markdown zurück.
:Der Vorgabewert ist „false“.

'''storeProjectSettings'''

:Bei „true“ werden die über <code>workspace/didChangeConfiguration</code> gesendeten Einstellungen generiert und in <code>%currentDelphiProject%.delphilsp.json</code> gespeichert. Wenn DelphiLSP mit einem Editor eines Drittanbieters verwendet wird, dann kann es diese Datei verwenden, um Projekteinstellungen abzurufen. Siehe die Eigenschaft configuration.settingsFile.
:Dieses Flag wird nur ausgewertet, wenn es von RAD Studio verwendet wird, und bewirkt, dass Delphi die Datei .delphilsp.json erstellt.
:Der Vorgabewert ist „false“.

'''enableFileWatcher'''

:Bei „true“ überwacht DelphiLSP Verzeichnisse auf Änderungen, um Dateiänderungen zu erkennen. Wenn Änderungen erkannt werden, wird die Datei auf Grundlage des neuen Inhalts aktualisiert. Dies wirkt sich nur auf Dateien aus, die nicht im Editor geöffnet sind. Bei Dateien, die im Editor geöffnet sind, ist der Editor dafür verantwortlich, dass der LSP-Server über den aktuellen Dateiinhalt verfügt.
:Der Vorgabewert ist „true“.

===Konfigurationen===

LSP lässt benutzerdefinierte Einstellungen in der <code>workspace/didChangeConfiguration</code>-Benachrichtigung zu. Im Folgenden finden Sie ein Beispiel für eine gültige Benachrichtigung:<source lang="json">
{
"jsonrpc": "2.0",
"method": "workspace/didChangeConfiguration",
"params": {
"settings": {
"settingsFile": "file:///C%3A/Test/SampleProject.delphilsp.json"
}
}
}
</source>'''settingsFile'''

:Es handelt sich um den URI einer .delphilsp.json-Einstellungsdatei, die zuvor mit aktiviertem storeProjectSettings erstellt wurde. Dies geschieht, wenn die Delphi-IDE-Einstellung „LSP-Konfiguration generieren“ in den Code Insight-Optionen aktiviert ist.
:Die Möglichkeit, Einstellungen aus einer Konfigurationsdatei zu laden, ist nur aktiv, wenn DelphiLSP von Drittanbieter-Editoren verwendet wird. Bei der Verwendung in Delphi kommuniziert die IDE direkt mit dem Compiler.

==Siehe auch==

* [[Code Insight (Referenz)|Code Insight (Referenz)]]

[[Category:Olympus]]

[[en:Using DelphiLSP Code Insight with Other Editors]]
[[fr:Utilisation de l'audit de code DelphiLSP avec d'autres éditeurs]]
[[ja:他のエディタで DelphiLSP コード支援を使用する]]

BCC64X.EXE: Der C++-Compiler für 64-Bit-Windows

2026-10-04T14:39:28Z

L10nBot: defaultsort

{{Parent|Befehlszeilenoberflächen von C++-Compilern, die durch Clang erweitert wurden}}

{{Path|BCC64X.EXE}} ist die Befehlszeilenoberfläche für [[BCC64X|BCC64X]], den C++-Compiler für 64-Bit-Windows.

Weitere Informationen zu dem Compiler finden Sie unter [[BCC64X|BCC64X]].

Informationen, die die {{Path|BCC64X.EXE}}-Befehlszeilenoberfläche mit anderen Befehlszeilenoberflächen von C++-Compilern teilt, die durch Clang erweitert wurden, finden Sie unter '''[[Befehlszeilenoberflächen von C++-Compilern, die durch Clang erweitert wurden|Befehlszeilenoberflächen von C++-Compilern, die durch Clang erweitert wurden]]'''.

==Siehe auch==

*[[BCC64X|BCC64X]]
*[[C++Builder-Anwendungsentwicklung für 64-Bit-Windows (Modern)|C++Builder-Anwendungsentwicklung für 64-Bit-Windows (Modern)]]
** [[Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows|Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows]]
** [[Debuggen von C++Builder-Anwendungen für 64-Bit-Windows|Debuggen von C++Builder-Anwendungen für 64-Bit-Windows]]
* [[64-Bit-Windows-Anwendung Hello World (Delphi und C++)|64-Bit-Windows-Anwendung "Hello World" ({{Delphi}} und C++)]]
* [[Linken der C++-Anwendung "Hello World" für 64-Bit-Windows|Linken der C++-Anwendung "Hello World" für 64-Bit-Windows]]
* [[CPP64: Der Präprozessor für 64-Bit-Windows|CPP64: Der Präprozessor für 64-Bit-Windows]]
* [[MKEXP.EXE: Das C++-Hilfsprogramm für Importbibliotheken für 64-Bit-Windows|MKEXP.EXE: Das C++-Hilfsprogramm für Importbibliotheken für 64-Bit-Windows]]

{{DEFAULTSORT:BCC64X.EXE: Der C++-Compiler fur 64-Bit-Windows}}

[[en:BCC64X.EXE, the C++ 64-bit Windows Compiler]]
[[fr:BCC64X.EXE, le compilateur C++ Windows 64 bits]]
[[ja:BCC64X.EXE - C++ 64 ビット Windows 版コンパイラ]]

BCC64X.EXE: Der C++-Compiler für 64-Bit-Windows

2026-10-04T14:31:50Z

L10nBot: updated language links

{{Parent|Befehlszeilenoberflächen von C++-Compilern, die durch Clang erweitert wurden}}

{{Path|BCC64X.EXE}} ist die Befehlszeilenoberfläche für [[BCC64X|BCC64X]], den C++-Compiler für 64-Bit-Windows.

Weitere Informationen zu dem Compiler finden Sie unter [[BCC64X|BCC64X]].

Informationen, die die {{Path|BCC64X.EXE}}-Befehlszeilenoberfläche mit anderen Befehlszeilenoberflächen von C++-Compilern teilt, die durch Clang erweitert wurden, finden Sie unter '''[[Befehlszeilenoberflächen von C++-Compilern, die durch Clang erweitert wurden|Befehlszeilenoberflächen von C++-Compilern, die durch Clang erweitert wurden]]'''.

==Siehe auch==

*[[BCC64X|BCC64X]]
*[[C++Builder-Anwendungsentwicklung für 64-Bit-Windows (Modern)|C++Builder-Anwendungsentwicklung für 64-Bit-Windows (Modern)]]
** [[Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows|Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows]]
** [[Debuggen von C++Builder-Anwendungen für 64-Bit-Windows|Debuggen von C++Builder-Anwendungen für 64-Bit-Windows]]
* [[64-Bit-Windows-Anwendung Hello World (Delphi und C++)|64-Bit-Windows-Anwendung "Hello World" ({{Delphi}} und C++)]]
* [[Linken der C++-Anwendung "Hello World" für 64-Bit-Windows|Linken der C++-Anwendung "Hello World" für 64-Bit-Windows]]
* [[CPP64: Der Präprozessor für 64-Bit-Windows|CPP64: Der Präprozessor für 64-Bit-Windows]]
* [[MKEXP.EXE: Das C++-Hilfsprogramm für Importbibliotheken für 64-Bit-Windows|MKEXP.EXE: Das C++-Hilfsprogramm für Importbibliotheken für 64-Bit-Windows]]

[[en:BCC64X.EXE, the C++ 64-bit Windows Compiler]]
[[fr:BCC64X.EXE, le compilateur C++ Windows 64 bits]]
[[ja:BCC64X.EXE - C++ 64 ビット Windows 版コンパイラ]]

Import und Export von Packages für die neue C++-Toolkette

2026-10-03T14:58:58Z

L10nBot: defaultsort

C++Builder-Anwendungsentwicklung für 64-Bit-Windows (Modern)

2026-10-03T14:58:57Z

L10nBot: defaultsort

{{Parent|64-Bit-Windows-Anwendungsentwicklung}}

C++Builder unterstützt 64-Bit-Windows (Modern):

*[[BCC64X|BCC64X]]
*[[C++-Toolkette|Toolkette für C++-64-Bit-Windows]]

==Themen==

*[[Unterschiede von C++Builder für 64-Bit-Windows|Unterschiede von C++Builder für 64-Bit-Windows]]
*[[Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows|Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows]]
*[[Striktere C++-Compiler (Durch Clang erweiterte C++-Compiler)|Striktere C++-Compiler (Durch Clang erweiterte C++-Compiler)]]
*[[Debuggen von C++Builder-Anwendungen für 64-Bit-Windows|Debuggen von C++Builder-Anwendungen für 64-Bit-Windows]]
*[[Erstellen einer einfachen C++-Anwendung zur Verwendung moderner C++-Features|Erstellen einer einfachen C++-Anwendung zur Verwendung moderner C++-Features]]
*[[64-Bit-Windows-Anwendung Hello World (Delphi und C++)|64-Bit-Windows-Anwendung "Hello World" (Delphi und C++)]]
*[[Statische Laufzeitbibliotheken#Unterverzeichnis LIB.5CWIN64X – LIB_Dateien|Win64x-Packages]]

==Siehe auch==

*[[C++Builder-Anwendungsentwicklung für 64-Bit-Windows|C++Builder-Anwendungsentwicklung für 64-Bit-Windows]]
*[[BCC64X.EXE: Der C++-Compiler für 64-Bit-Windows|BCC64X.EXE: Der C++-Compiler für 64-Bit-Windows]]
*[[Von C++-Compilern, die durch Clang erweitert wurden, unterstützte Projektoptionen|Von C++-Compilern, die durch Clang erweitert wurden, unterstützte Projektoptionen]]
*[[Von C++-Compilern, die durch Clang erweitert wurden, nicht unterstützte Optionen|Von C++-Compilern, die durch Clang erweitert wurden, nicht unterstützte Optionen]]
*[[Technische Details zu LLD|lld: Der 64-Bit-Linker]]
*[[Verwenden von vorcompilierten Headern mit C++-Compilern, die durch Clang erweitert wurden|Verwenden von vorcompilierten Headern mit C++-Compilern, die durch Clang erweitert wurden]]
*[[Moderne C++-Features, die von durch Clang erweiterte C++-Compiler in RAD Studio unterstützt werden|Moderne C++-Features, die von durch Clang erweiterte C++-Compiler in RAD Studio unterstützt werden]]
*[[Überlegungen zur Anwendungsentwicklung für 64-Bit-Windows|Überlegungen zur Anwendungsentwicklung für 64-Bit-Windows]]
*Blog: Introducing BCC64X (EN)

{{DEFAULTSORT:C++Builder-Anwendungsentwicklung fur 64-Bit-Windows (Modern)}}

[[en:C++Builder 64-bit Windows (Modern) Application Development]]
[[fr:Développement d'applications C++ Builder Windows 64 bits (Moderne)]]
[[ja:C++Builder 64 ビット Windows (Modern) アプリケーションの開発]]

Windows MSIX-Unterstützung

2026-10-03T14:58:57Z

L10nBot: defaultsort

Ab {{Product}} Version 10.4.2 wurde die Unterstützung für [https://docs.microsoft.com/en-us/windows/msix/overview MSIX]-Pakete von Windows-Anwendungen für die Bereitstellung im Microsoft Store und in Unternehmen eingeführt.

=Projektkonfiguration=

Die MSIX-Unterstützung durch {{Product}} ersetzt die APPX-Unterstützung und basiert auf einer sehr ähnlichen Konfiguration in den Projektoptionen für die Distributionstypen '''Ad hoc''' und '''Store'''.

==Ad-hoc-Distributionstyp==

Zum Testen oder für eine direkte Distribution ohne Übermittlung an den Windows Store erstellen Sie am besten ein Ad-hoc-Bereitstellungsprofil für die Distribution.

Für den Ad-hoc-Distributionstyp benötigen Sie eine Zertifikatsdatei, die Sie erstellen oder durch Klicken auf die Ellipse ('''...''') suchen können.

[[Image:Provisioning.png|700px|link=|Ad-hoc-Bereitstellung]]

==Store-Distributionstyp==

Um Ihre Anwendung an den Windows Store zu übertragen, erstellen Sie ein Store-Bereitstellungsprofil für die Distribution.

[[Image:Provisioning Store.png|700px|link=|Store-Bereitstellung]]

Wenn Sie die Konfiguration abgeschlossen haben, können Sie mit dem Befehl "Projekt bereitstellen" eine MSIX-Datei im Unterordner '''WinXX\Debug\Projektname\bin''' des Projektordners erstellen.

=Lokale MSIX-Installation und Installation des Zertifikats=

Wenn Sie die MSIX-Datei aktivieren, werden Sie aufgefordert, sie lokal zu installieren. Falls Sie das Zertifikat nicht aktiviert haben, wird Folgendes angezeigt:

[[Image:Untrusted App.png|700px|link=|Nicht vertrauenswürdige App]]

{{Note|Um das MSIX-Paket zu installieren, benötigen Sie ein geeignetes Zertifikat oder Sie müssen Ihrem selbstsignierten Entwicklerzertifikat die Berechtigung erteilen.}}

===Installation des Zertifikats===

Suchen Sie zur Zertifikatsdatei auf Ihrer Festplatte und führen Sie die folgenden Schritte aus:

# Wechseln Sie zu dem Ordner, in dem Sie Ihr Zertifikat gespeichert haben.
# Klicken Sie mit der rechten Maustaste auf das Zertifikat und wählen Sie "PFX installieren" aus. [[Image:Install Certificate.png|500px|link=|Installation des Zertifikats]]
# Wenn der "Zertifikatimport-Assistent" angezeigt wird, wählen Sie "Lokaler Computer" als "Speicherort" aus. [[Image:Certificate Wizard.png|500px|link=|Zertifikat-Assistent]]
# Bestätigen Sie die zu importierende Datei.
# Geben Sie das Passwort des Zertifikats ein.
# Wählen Sie '''Alle Zertifikate in folgendem Speicher speichern''' aus.
# Klicken Sie auf die Schaltfläche '''Durchsuchen...''' und wählen Sie "Vertrauenswürdige Stammzertifizierungsstellen" aus. [[Image:Certificate Store.png|500px|link=|Zertifikatspeicher]]
# Schließen Sie den Vorgang ab.

===Installation der MSIX-Datei===

Um die MSIX-Konfiguration zu aktivieren, müssen Sie die Konfiguration '''Anwendungs-Store''' aktivieren.

{{Note|Speichern und erzeugen Sie Ihr Projekt, nachdem Sie Ihre Anwendung konfiguriert haben.}}

Nach der erfolgreichen Installation des Zertifikats und der Konfiguration der Anwendung können Sie die MSIX-Datei beim Öffnen installieren:

[[Image:Project Installation.png|700px|link=|Projektinstallation]]

Beachten Sie, dass außerdem das Querladen von Apps in der Windows 10-Konfiguration aktiviert sein muss.
Andernfalls zeigt das MSIX-Installationsprogramm einen Link zum Konfigurations-Dialogfeld an:

[[Image:Windows DevSet.png|700px|link=|Projektinstallation]]

=MSIX und Microsoft Store=

In der IDE können Sie [https://docs.microsoft.com/en-us/windows/msix/overview MSIX]-Dateien erstellen, die direkt in den Microsoft Store für Windows hochgeladen werden können. In diesem Fall muss die Projektkonfiguration die Anwendungs-ID und die Benutzer-ID enthalten, die von der Microsoft Store-Konfiguration bereitgestellt werden. Sobald Sie ein (kostenpflichtiges) Konto haben, können Sie ein neues Projekt erstellen.

{{Warning| Sie benötigen eine Zielversion von mindestens 10.0.17763.0. Das ist die aktuelle Standardversion in RAD Studio. Andernfalls wird eine Fehlermeldung angezeigt:

[[Image:Validation Error.png|700px|link=|Fehler bei der Validierung]]

}}

=Win-SDK-Anforderungen für MSIX=

Die MSIX-Unterstützung erfordert die Installation einer aktuellen Version des Microsoft Windows SDK, das Teil der RAD Studio-Installation ist. Wenn Sie eine ältere Version installiert haben, erhalten Sie in der Bereitstellungsphase eine Fehlermeldung wie die folgende:

<code>[PAClient-Fehler] Fehler: E5384 SignTool-Fehler:</code> <code>Dieses Dateiformat kann nicht signiert werden, da es nicht erkannt wurde.</code> <code>[PAClient-Fehler] Fehler: E5384 SignTool-Fehler:</code> <code>Beim Versuch C:\...\vcldemo\bin\MSIXDemo.msix zu signieren, ist ein Fehler aufgetreten. </code>

{{Note|Sie können das [https://developer.microsoft.com/en-us/windows/downloads/windows-10-sdk/ Windows SDK-Installationsprogramm] auch direkt von Microsoft herunterladen.}}

{{DEFAULTSORT:Windows MSIX-Unterstutzung}}

[[en:Windows MSIX Support]]
[[fr:Prise en charge du format MSIX Windows]]
[[ja:Windows MSIX サポート]]

Benutzerdefinierte Titelleiste für VCL-Formulare

2026-10-03T14:58:57Z

L10nBot: defaultsort

==Übersicht==

Mit der Eigenschaft [[lib_de:Vcl.Forms.TForm.CustomTitleBar|TForm.CustomTitleBar]] und dem neuen Steuerelement [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] können Sie die native Titelleiste eines VCL-Formulars ähnlich wie bei Windows-Explorer, Google Chrome oder anderen Anwendungen anpassen. Sie können VCL-Steuerelemente auf der Titelleiste platzieren und benutzerdefiniertes Zeichnen in der Titelleiste ausführen sowie das standardmäßige Zeichnen von Elementen wie das Fenstersymbol und die Beschriftung steuern.

[[File:CustomTitleBarVCL.png|border]]

{{Note| Die benutzerdefinierte Titelleiste wird ab Windows 7 unterstützt.}}

Die Unterstützung für die [[lib_de:Vcl.Forms.TForm.CustomTitleBar|benutzerdefinierte Titelleiste]] verwendet die echte native Windows-Titelleiste und erfordert, dass DWM (Desktop Window Manager) aktiviert ist. Wenn Sie Aero in Windows 7 oder in Situationen deaktivieren, in denen der DWM nicht zum Rendern von Fenstern verwendet wird, wird die Anpassung der Titelleiste nicht unterstützt. Dies wird vom Steuerelement korrekt gehandhabt, aber um diese Situation in Ihrem Code zu überprüfen, prüfen Sie den Wert von TForm.CustomTitleBar.Supported. Dieser Wert ist True, wenn Sie die benutzerdefinierte Titelleiste verwenden können.

Um die volle Leistungsfähigkeit der benutzerdefinierten Titelleiste zu nutzen, müssen Sie eine Kombination der Eigenschaft [[lib_de:Vcl.Forms.TForm.CustomTitleBar|TForm.CustomTitleBar]] und einem auf dem Formular platzierten [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] verwenden. TTitleBarPanel wird zum Hosten von VCL-Steuerelementen verwendet, aber es ist auch erforderlich, um erweiterte Funktionen, wie Anpassen das Zeichnens, zu unterstützen, selbst wenn sich in der Titelleiste keine benutzerdefinierten Steuerelemente befinden. Im Wesentlichen stellt die Eigenschaft [[lib_de:Vcl.Forms.TForm.CustomTitleBar|TForm.CustomTitleBar]] die Einstellungen für die Titelleiste des Formulars dar und [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] ist ein VCL-Steuerelement, mit dem erweiterte Funktionen in der Titelleiste selbst repräsentiert werden und darauf zugegriffen wird.

{{Attention| Nur die '''Plattform'''-VCL-Stile funktionieren in der Titelleiste.}}

==Grundlegende Anpassung==

Die Klasse [[lib_de:Vcl.Forms.TForm Properties|VCL TForm]] hat eine neue Eigenschaft, [[lib_de:Vcl.Forms.TForm.CustomTitleBar|CustomTitleBar]]. Damit können grundlegende Eigenschaften, wie die Anzeige des Titels oder Symbols geändert werden sowie die erweiterten Funktionen, darunter die Platzierung von Steuerelementen, gesteuert werden.

Setzen Sie TForm.CustomTitleBar.Enabled auf True, um die Anpassung der Titelleiste zu aktivieren. Beachten Sie, dass oben in Ihrem VCL-Formular im Designer jetzt ein schattierter blauer Bereich angezeigt wird. Dieser Bereich im Formular wird für die Titelleiste verwendet.

==Position der VCL-Steuerelemente==

Die Titelleiste wird mit der [https://docs.microsoft.com/en-us/windows/win32/api/dwmapi/nf-dwmapi-dwmextendframeintoclientarea Funktion "DwmExtendFrameIntoClientArea"] implementiert. Das bedeutet, dass es keinen Nicht-Client-Bereich im Formular gibt, und die Titelleiste sowohl im Client- als auch im Nicht-Client-Bereich gerendert wird. (Der Client-Bereich ist der Bereich, in dem Sie normalerweise VCL-Steuerelemente platzieren, und der Nicht-Client-Bereich ist der Bereich, der normalerweise von der Systemtitelleiste, dem vom System bereitgestellten und von einem TMainMenu gekapselten Hauptmenü, den Bildlaufleisten und dem Größenänderungsrahmen verwendet wird. Weitere Informationen finden Sie unter [[lib_de:Vcl.Controls.TControl.ClientRect|ClientRect]], [[lib_de:Vcl.Controls.TControl.ClientWidth|ClientWidth]] und [[lib_de:Vcl.Controls.TControl.ClientHeight|ClientHeight]].)

Alle dem Formular untergeordneten Steuerelemente mit einer "Align"-Eigenschaft, wie z. B. "alTop", werden korrekt an den Bereich der Titelleiste angepasst. Jedes Steuerelement, das über die Eigenschaften "Left" und "Top" platziert wird, d. h. absolut positioniert ist, verbleibt jedoch an der Stelle, an der es sich befindet, und kann daher die Titelleiste überlappen, sodass seine Position angepasst werden muss, wenn die benutzerdefinierte Titelleiste aktiviert ist.

Wir empfehlen, Steuerelemente im Formular auf einem am Client ausgerichteten TPanel zu platzieren. Beachten Sie, dass Sie möglicherweise auch die Eigenschaft Height des Formulars vergrößern sollten, um den Platz zu berücksichtigen, der zuvor von der Titelleiste verwendet wurde.

==Einstellungen und teilweise benutzerdefinierte Farbgebung==

Die folgenden Einstellungen steuern das Verhalten der Titelleiste sowie häufige Szenarien für die Farbgebung (wie etwa den Titel der Titelleiste ohne Farbe), mit denen Sie diese Szenarien berücksichtigen können, ohne eine vollständige benutzerdefinierte Farbgebung zu implementieren.

*'''[[lib_de:Vcl.Forms.TTitleBar.CaptionAlignment|CaptionAlignment]]:''' Damit geben Sie an, wo der Titel gezeichnet werden soll. Windows 10 zeichnet standardmäßig links. Sie können den Titel zentriert, wie in Windows 8, oder rechtsbündig zeichnen.
*'''[[lib_de:Vcl.Forms.TTitleBar.Control|Control]]:''' Legen Sie diese Eigenschaft auf ein TTitleBarPanel fest, das auf dem Formular platziert ist. Siehe den folgenden Abschnitt über benutzerdefinierte Steuerelemente in einer Titelleiste.
*'''[[lib_de:Vcl.Forms.TTitleBar.Enabled|Enabled]]:''' Aktiviert oder deaktiviert die Verwendung der benutzerdefinierten Titelleiste.
*'''[[lib_de:Vcl.Forms.TTitleBar.Height|Height]]:''' Höhe der Titelleiste in Pixel. Um die Höhe der Titelleiste zu ändern, deaktivieren Sie '''[[lib_de:Vcl.Forms.TTitleBar.SystemHeight|SystemHeight]]'''. Dadurch wird die Titelleiste auf die Standardhöhe des Systems beschränkt. Sie können die Eigenschaft Height auf einen beliebigen Wert festlegen.
*'''[[lib_de:Vcl.Forms.TTitleBar.ShowCaption|ShowCaption]]:''' Steuert, ob der Titel gezeichnet wird.
*'''[[lib_de:Vcl.Forms.TTitleBar.ShowIcon|ShowIcon]]:''' Steuert, ob das Symbol des Formulars an der linken Ecke der Titelleiste gezeichnet wird.
*'''[[lib_de:Vcl.Forms.TTitleBar.SystemHeight|SystemHeight]]''': Bei True hat die Höhe der Titelleiste immer den Wert, der auch von anderen Fenstern auf dem aktuellen Bildschirm verwendet wird. Um die Höhe der Titelleiste anzupassen, deaktivieren Sie '''[[lib_de:Vcl.Forms.TTitleBar.SystemHeight|SystemHeight]]''' und geben dann einen Wert für die Eigenschaft Height ein.
*'''[[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]:''' Steuert, ob für den aktiven oder inaktiven Status des Titels der Titelleiste und der Schaltflächen die Systemfarben oder benutzerdefinierte Farben verwendet werden. Das ist nützlich, wenn Sie die Titelleiste mit anderen Hinter- und Vordergrundfarben als denjenigen des Systems ohne vollständige benutzerdefinierte Farbgebung darstellen möchten.

:Bei True erhalten der Hintergrund, der Titel und die Systemschaltflächen, wie andere Anwendungen, die Standardfarben des Systems. Bei False werden die Farben verwendet, die Sie in den Farbeigenschaften (siehe unten) angeben.
:Damit benutzerdefinierte Farben verwendet werden, müssen Sie ein [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] auf dem Formular platzieren und die Eigenschaft CustomTitleBar.Control darauf festlegen, genau so, als ob Sie Steuerelemente in der Titelleiste zu platzieren wollten, auch wenn der Titelleistenbereich leer ist und keine Steuerelemente enthält.

*Mit '''[[lib_de:Vcl.Forms.TTitleBar.BackgroundColor|BackgroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ForegroundColor|ForegroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveBackgroundColor|InactiveBackgroundColor]]''' und '''[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveForegroundColor|InactiveForegroundColor]]''' werden die Farben für die Titelleiste festgelegt. Legen Sie '''[[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]''' auf True fest, um diese Werte zu ignorieren und die aktuellen Systemfarben zu verwenden.
*'''[[lib_de:Vcl.Forms.TTitleBar.ButtonBackgroundColor|ButtonBackgroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonForegroundColor|ButtonForegroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonHoverBackgroundColor|ButtonHoverBackgroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonHoverForegroundColor|ButtonHoverForegroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveBackgroundColor|ButtonInactiveBackgroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveForegroundColor|ButtonInactiveForegroundColor]]''', '''[[lib_de:Vcl.Forms.TTitleBar.ButtonPressedBackgroundColor|ButtonPressedBackgroundColor]]''' und '''[[lib_de:Vcl.Forms.TTitleBar.ButtonPressedForegroundColor|ButtonPressedForegroundColor]]''' geben die Farben an, die für Systemschaltflächen verwendet werden sollen, wenn es sich um benutzerdefinierte Schaltflächen handelt oder wenn die Titelleiste benutzerdefiniert gezeichnet wird. Legen Sie '''[[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]''' auf True fest, um dieser Wert zu ignorieren und die aktuellen Systemfarben zu verwenden.

==Vollständige benutzerdefinierte Farbgebung==

Sie können vollständig anpassen, wie die Titelleise gerendert wird, indem Sie die Titelleiste mit Farbe füllen und darauf zeichnen. Dazu müssen Sie ein [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] auf dem Formular platzieren und die Eigenschaft CustomTitleBar.Control darauf festlegen, genau so, als ob Sie Steuerelemente in der Titelleiste platzieren wollten, auch wenn der Titelleistenbereich leer ist und keine Steuerelemente enthält. Sie können dann eine Ereignisbehandlungsroutine für das Ereignis [[lib_de:Vcl.ExtCtrls.TCustomTitleBarPanel.OnPaint|TTitleBarPanel.OnPaint]] erstellen.

Das Ereignis [[lib_de:Vcl.ExtCtrls.TCustomTitleBarPanel.OnPaint|TTitleBarPanel.OnPaint]] wird als allerletzter Schritt bei der Farbgebung aufgerufen. Die Farbe wird über alles gelegt, was bereits in der Titelleiste mit Farbe versehen wurde, z. B. Beschriftungen oder Systemschaltflächen. Sie können zudem mit den Rect-Eigenschaften das Zeichnen anpassen. Mit den Eigenschaften [[lib_de:Vcl.Forms.TTitleBar.IconRect|IconRect]], [[lib_de:Vcl.Forms.TTitleBar.FrameRect|FrameRect]], [[lib_de:Vcl.Forms.TTitleBar.ClientRect|ClientRect]] und [[lib_de:Vcl.Forms.TTitleBar.CaptionButtonsRect|CaptionButtonsRect]] können Sie ermitteln, wo sich Systemschaltflächen, Titel usw. befinden.

Die Farbe ist eine 32-Bit-Oberfläche. Sie hat dieselben Anforderungen wie die Farbgebung auf Glas in Windows 7.

==Titelschaltflächen==

Sie können der Titelleiste Titelschaltflächen hinzufügen. Dies wird auch in der
IDE verwendet, um die Schaltflächen "Hilfe" und "Desktop" links neben den Schaltflächen "Minimieren"/"Maximieren"/"Schließen" hinzuzufügen, die in der Regel in der Titelleiste angezeigt werden.

Platzieren Sie dazu ein [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] auf dem Formular und legen Sie es auf die Eigenschaft "CustomTitleBar.Control" des Formulars fest (wie oben beschrieben). Anschließend können Sie benutzerdefinierte Schaltflächen über die Eigenschaft "CustomButtons" hinzufügen. Diese Eigenschaft ist eine Sammlung von TCaptionButtonItem. Schaltflächen werden automatisch von rechts nach links angeordnet, beginnend links von der Schaltfläche "Minimieren". Die 0. Schaltfläche in der Sammlung ist die äußerst rechte und die letzte Schaltfläche die äußerst linke. Unter Windows 7 befindet sich ein kleiner
Zwischenraum zwischen der Schaltfläche "Minimieren" und der ersten benutzerdefinierten Schaltfläche.

Die Komponente TCaptionButtonItem repräsentiert eine Schaltfläche in der Titelleiste. Sie verfügt über die folgenden Eigenschaften:

* '''ButtonType''': Ermöglicht die Verwendung einer Systemschaltfläche, wie "Schließen", "Minimieren" oder "Wiederherstellen", und das Hinzufügen eines Zwischenraums oder einer vollständig benutzerdefinierten Schaltfläche. In der Regel verwenden Sie die benutzerdefinierte Schaltfläche.
*'''Enabled''': wenn deaktiviert, wird die Schaltfläche gezeichnet und reagiert nicht auf Mausbewegungen oder Klicks.
*''' Hint''': ermöglicht das Festlegen eines Kurzhinweises, der angezeigt werden soll, wenn die Maus über die Schaltfläche geführt wird.
*'''Visible''': steuert, ob die Schaltfläche in der Titelleiste angezeigt wird.
*'''Width''': legt die Breite des Steuerelements fest.
*'''OnClick''': eine Ereignisbehandlungsroutine für das Klicken auf die Schaltfläche.
*'''OnPaint''': eine Ereignisbehandlungsroutine zum Zeichnen auf der Schaltfläche, wie ein Schaltflächensymbol. Schaltflächen sind nicht mit einer Bilderliste verbunden.

{{Note|Verwenden Sie [[lib_de:Vcl.Forms.TCustomForm.Active|TForm.Active]], um sicherzustellen, dass der Status des Formulars und der benutzerdefinierten Schaltfläche synchron bleiben. {{Product}} empfiehlt zum Erzielen einer besseren Leistung [[lib_de:Vcl.Forms.TTitleBar.SystemColors|CustomTitleBar.SystemColors]] [[lib_de:Vcl.Forms.TTitleBar.SystemButtons|CustomTitleBar.SystemButtons]] auf {{code|False}} festzulegen, wenn Sie benutzerdefinierte Schaltflächen in der Titelleiste verwenden.}}

{{Tip| Weitere Information finden Sie in unserer TitlebarPanel-Demo, die eine Schaltfläche mit benutzerdefinierten Farben im Bereich der Titelleiste enthält. 
Sie finden die Demo hier: {{code|ObjectPascal\VCL\Titlebar\TitlebarPanel}}}}

==Unterstützung für Windows 7 und 10==

Die benutzerdefinierte Titelleiste unterstützt Windows 7 und Windows 10 vollständig, einschließlich der Titelschaltflächen:

[[File:TTitleBar.png]]

Die RAD Studio-Titelleiste unter Windows 7.

{{Note|
Die Plattformen Windows Vista oder früher werden nicht unterstützt.

Die benutzerdefinierte Titelleiste wird unter Windows 8 unterstützt, es können aber optische Unterschiede im Vergleich zu anderen Anwendungen auftreten, etwa wie Systemschaltflächen mit Farbe gefüllt werden, wenn die Farben angepasst werden (sie werden wie Windows 10-Schaltflächen gerendert).}}

==Benutzerdefinierte Steuerelemente==

Mit dem Steuerelement [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] werden Steuerelemente im Titelleistenbereich auf dem VCL-Formular platziert. Es dient als Container, der beim Entwurf Unterstützung für die Steuerelemente bereitstellt. Außerdem stellt es eine Beziehung zwischen dem Formular und dem benutzerdefinierten Titelleistenbereich her.

In der Titelleiste platzierte Steuerelemente müssen das Zeichnen auf eine 32-Bit-Oberfläche unterstützen, wie auf Glas unter Windows 7. Als allgemeine Richtlinie gilt: Wenn ein Steuerelement auf Glas unter Windows 7 korrekt gerendert wird, wird es unter Windows 7 und 10 vermutlich korrekt in der Titelleiste angezeigt. Es kommt häufig vor, dass ein Steuerelement platziert wird und dann festgestellt wird, dass es nicht richtig gerendert wird, selbst im Designer. Möglicherweise müssen Sie Eigenschaften wie DoubleBuffered für normale VCL-Steuerelemente verwenden.

So platzieren Sie Steuerelemente in der Titelleiste:

*Suchen Sie in der Palette das Steuerelement [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] und platzieren Sie es auf dem Formular. Es wird oben auf dem Formular angezeigt.
*Legen Sie die Eigenschaft CustomTitleBar.Control des Formulars auf den Titelleistenbereich fest. Der Titelleistenbereich hat eine blaue Hintergrundfarbe und rechts werden Systemschaltflächen angezeigt.
*Ändern Sie optional die Eigenschaft Height der Titelleiste, damit sie mit der Eigenschaft CustomTitleBar.Height übereinstimmt. Nur Steuerelemente, die sich innerhalb der Höhe der Titelleiste befinden, werden in der Titelleiste selbst gerendert.
*Suchen Sie in der Palette ein Steuerelement, z. B. TEdit, und platzieren Sie es auf [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] mit diesen Einstellungen:
**Legen Sie im Objektinspektor die Eigenschaftt DoubleBuffered des neuen Steuerelements auf True fest.
**Da es sich bei [[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]] um ein normales VCL-Steuerelement handelt, können Sie Align, Anchors und andere Positionierungseigenschaften für darauf befindliche Steuerelemente festlegen. Damit das TEdit-Steuerelement rechts neben den Systemschaltflächen ausgerichtet wird, wie etwa für ein Sucheingabefeld, ziehen Sie es an die gewünschte Position und ändern Sie die Eigenschaft Anchors von akLeft in akRight.

:
::[[File:VCL control.png]]

:
:*Fügen Sie dem Formular das Ereignis OnShow hinzu oder verwenden Sie OnResize, wenn Sie Steuerelemente manuell anstatt über Anker in der Titelleiste platzieren möchten. (Wir empfehlen die Verwendung der Ausrichtung und von Ankern, da die Positionierung über [[lib_de:Vcl.Controls.TControl.OnResize|OnResize]] eine visuelle Verzögerung in Bezug auf die Fenstergröße erzeugen kann). Sie können sich auf die Eigenschaften [[lib_de:Vcl.Forms.TTitleBar.IconRect|IconRect]], [[lib_de:Vcl.Forms.TTitleBar.FrameRect|FrameRect]], [[lib_de:Vcl.Forms.TTitleBar.ClientRect|ClientRect]] und [[lib_de:Vcl.Forms.TTitleBar.CaptionButtonsRect|CaptionButtonsRect]] von CustomTitleBar beziehen, um Ihre Steuerelemente im Verhältnis zu bekannten Titelleistenelementen zu positionieren. Hier legen Sie die Eigenschaft Left des Eingabesteuerelements auf CaptionButtonsRect.Left minus der Breite für einen schmalen Rand (nur aus optischen Gründen) fest, indem Sie der Ereignisbehandlungsroutine die folgende Zeile hinzufügen:

:
::<source lang="delphi"> Edit1.Left := CustomTitleBar.CaptionButtonsRect.Left - Edit1.Width - 8; </source>

:
::[[File:TForm.png]]

==Siehe auch==

*[[lib_de:Vcl.Forms.TForm.CustomTitleBar|CustomTitleBar]]
*[[lib_de:Vcl.ExtCtrls.TTitleBarPanel|TTitleBarPanel]]
*[[lib_de:Vcl.Forms.TTitleBar.CaptionAlignment|CaptionAlignment]]
*[[lib_de:Vcl.Forms.TTitleBar.Control|Control]]
*[[lib_de:Vcl.Forms.TTitleBar.Enabled|Enabled]]
*[[lib_de:Vcl.Forms.TTitleBar.Height|Height]]
*[[lib_de:Vcl.Forms.TTitleBar.SystemHeight|SystemHeight]]
*[[lib_de:Vcl.Forms.TTitleBar.ShowCaption|ShowCaption]]
*[[lib_de:Vcl.Forms.TTitleBar.ShowIcon|ShowIcon]]
*[[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]
*[[lib_de:Vcl.Forms.TTitleBar.BackgroundColor|BackgroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ForegroundColor|ForegroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveBackgroundColor|InactiveBackgroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveForegroundColor|InactiveForegroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.SystemColors|SystemColors]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonBackgroundColor|ButtonBackgroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonForegroundColor|ButtonForegroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonHoverBackgroundColor|ButtonHoverBackgroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonHoverForegroundColor|ButtonHoverForegroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveBackgroundColor|ButtonInactiveBackgroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonInactiveForegroundColor|ButtonInactiveForegroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonPressedBackgroundColor|ButtonPressedBackgroundColor]]
*[[lib_de:Vcl.Forms.TTitleBar.ButtonPressedForegroundColor|ButtonPressedForegroundColor]]
*[[lib_de:Vcl.ExtCtrls.TCustomTitleBarPanel.OnPaint|TTitleBarPanel.OnPaint]]
*[[lib_de:Vcl.Forms.TTitleBar.IconRect|IconRect]]
*[[lib_de:Vcl.Forms.TTitleBar.FrameRect|FrameRect]]
*[[lib_de:Vcl.Forms.TTitleBar.ClientRect|ClientRect]]
*[[lib_de:Vcl.Forms.TTitleBar.CaptionButtonsRect|CaptionButtonsRect]]

{{DEFAULTSORT:Benutzerdefinierte Titelleiste fur VCL-Formulare}}
[[Category:Sydney]]
[[Category:Mit Delphi für Windows arbeiten]]
[[Category:Delphi]]

[[en:Custom Title Bar for VCL Forms]]
[[fr:Barre de titre personnalisée pour les fiches VCL]]
[[ja:VCL フォームのカスタムタイトルバー]]

Makros und Variablen für CMake

2026-10-03T14:58:57Z

L10nBot: defaultsort

{{Parent|Verwenden von CMake mit C++Builder}}

==Makros und Variablen für Windows==

===Windows-Makro===

{| class="wikitable"
|-
!Makro
!Beschreibung
!Gültige Eingaben
|-
|
set_embt_target(Ziel)
|
Wählt den Typ der zu erzeugenden Anwendung aus.
 <code>Ziel</code>: Typ der Anwendung.
|
"VCL", "FMX", "Package", "DynamicRuntime"
|}

Verwenden Sie die folgenden CMake-Optionen, wenn Sie einen Build mit einer vorhandenen CMakeList.txt-Datei erzeugen:

<source lang="cpp">
-DCMAKE_SYSTEM_NAME=Windows

-DCMAKE_SYSTEM_PROCESSOR=x86_64

-DCMAKE_CROSSCOMPILING=OFF

-DCMAKE_BUILD_TYPE=Release

-DCMAKE_INSTALL_PREFIX=<install dir>

-DCMAKE_ASM_COMPILER=bcc64x

-DCMAKE_C_COMPILER=bcc64x

-DCMAKE_CXX_COMPILER=bcc64x</source>

===Windows-Variable===

{| class="wikitable"
|-
!Variable
!Beschreibung
|-
|
EMBT_TARGET
|
'''Fester Wert:''' "Windows" für Windows-Embarcadero.cmake
|}

==Siehe auch==

[[Verwenden von CMake mit C++Builder|Verwenden von CMake mit C++Builder]]

{{DEFAULTSORT:Makros und Variablen fur CMake}}

[[en:CMake Macros and Variables]]
[[fr:Macros et variables CMake]]
[[ja:CMake のマクロと変数]]

Hinzufügen und Entfernen von Features mit dem Offline-Installationsprogramm

2026-10-03T14:58:57Z

L10nBot: defaultsort

{{Parent|Installation}}

Nach der Installation einer ersten Gruppe von {{Product}}-Features mit dem '''Offline-Installationsprogramm''' können Sie das Installationsprogramm erneut aufrufen, um {{Product}}-Features hinzufügen oder zu entfernen.

So fügen Sie Ihrer {{Product}}-Installation Features hinzu oder entfernen sie:

# Führen Sie das '''[[Offline-Installationsprogramm|Offline-Installationsprogramm]]''' aus.
# Aktivieren Sie auf der Seite '''Willkommen''' die Option '''Ändern''', und klicken Sie auf '''Weiter'''.
# Konfigurieren Sie auf den folgenden Seiten die Features, die Sie Ihrer Installation hinzufügen oder daraus entfernen möchten.

==Siehe auch==

* [[Verwenden des Installationsprogramms|Verwenden des Online-Installationsprogramms]]

* [[Hinzufügen und Entfernen von Features mit dem Feature-Manager|Feature-Manager verwenden]]

* [[Feature-Manager|Feature-Manager (Dialogfeld)]]

{{DEFAULTSORT:Hinzufugen und Entfernen von Features mit dem Offline-Installationsprogramm}}
[[Category:Berlin]]

[[en:Adding or Removing Features Using the Offline Installer]]
[[fr:Ajout ou suppression de fonctionnalités à l'aide de l'installateur hors ligne]]
[[ja:オフラインインストーラを使った機能の追加または削除]]

Compiler für C++

2026-10-03T14:58:56Z

L10nBot: defaultsort

{{Parent|C++-Toolkette}}

{{Product}} enthält Compiler für alle [[Unterstützte Zielplattformen|unterstützten Zielplattformen]].

Jeder Compiler gehört zu einer der folgenden Compilergenerationen:

* Compiler der vorherigen Generation, zu denen der originale {{CBuilder}}-32-Bit-Windows-Compiler ([[BCC32|BCC32]]) sowie Compiler mit einer ähnlichen Codebasis zählen.
* [[Durch Clang erweiterte C++-Compiler|Durch Clang erweiterte C++-Compiler]], die Compiler sind, die auf dem Clang-Compiler basiert sind.

{{Product}} stellt die folgenden C++-Compiler bereit:

{| class="wikitable"
|-
! Plattform
! Compiler
! Generation
|- valign="center"
| rowspan="3" | 32-Bit-Windows
| [[Win32-Compiler, die durch Clang erweitert wurden|BCC32C]]
| Clang
|- valign="top"
| [[Win32-Compiler, die durch Clang erweitert wurden|BCC32X]]
| Clang
|- valign="top"
| [[BCC32|BCC32]]
| Frühere
|- valign="top"
| rowspan="2" | 64-Bit-Windows
| [[BCC64|BCC64]]
| Clang
|- valign="top"
|[[BCC64X|BCC64X]]
| Clang
|- valign="top"
| 64-Bit-iOS
| [[BCCIOSARM64|BCCIOSARM64]]
| Clang
|- valign="top"
| Android
| [[BCCAARM|BCCAARM]]
| Clang
|}

{{Attention| Wenn die 32-Bit-Windows-Compiler für mehrere, voneinander abhängige C++-Projekte verwendet werden, kann der von einem Compiler compilierte Code nicht statisch mit Code gelinkt werden, der mit einem anderen Compiler erzeugt wurde, da sie nicht ABI-kompatibel sind. Um zwei verschiedene Compiler zu verwenden, muss der Code in einer separaten DLL vorhanden sein und ein flaches '''C'''-Interface aufweisen, andernfalls können Sie nur einen der Compiler für eine erfolgreiche Compilierung auswählen.}}

==Siehe auch==

{{f|cmd|

* [[Befehlszeilenoberflächen von C++-Compilern|Befehlszeilenoberflächen von C++-Compilern]] }}
* [[Linker für C++|Linker für C++]]
* [[Delphi-Toolkette|{{Delphi}}-Toolkette]]

{{DEFAULTSORT:Compiler fur C++}}
[[Category:AMMigrate]]

[[en:C++ Compilers]]
[[fr:Compilateurs C++]]
[[ja:C++ コンパイラ]]

Linker für C++

2026-10-03T14:58:56Z

L10nBot: defaultsort

{{Parent|C++-Toolkette}}

{{Product}} stellt die folgenden Linker bereit:

{| class="wikitable"
|-
! Plattform
! Linker
|- valign="top"
|
32-Bit-Windows
|
[[Technische Details zu ILINK32 und ILINK64|ILINK32]]
|- valign="top"
|
64-Bit-Windows
|
[[Technische Details zu ILINK32 und ILINK64|ILINK64]]
|- valign="top"
|
64-Bit-Windows (Modern)
|
[[Technische Details zu LLD|LLD]]
|- valign="top"
|
64-Bit-iOS
|
[http://www.opensource.apple.com/source/ld64/ Apple LD64 (EN)]
|- valign="top"
|
Android
|
[https://en.wikipedia.org/wiki/Gold_(linker)%7CGold Linker des Android NDK (EN)]
|- valign="top"
|
64-Bit-Linux
|
[https://en.wikipedia.org/wiki/Gold_(linker)%7CGold linker (ld-linux.exe) (EN)]
|}

Eine Liste mit Fehlermeldungen und Warnungen finden Sie unter [[C++-Linker-Fehler und -Warnungen|C++-Linker-Fehlermeldungen und -Warnungen]].

{{DEFAULTSORT:Linker fur C++}}
[[Category:AMMigrate]]

[[en:C++ Linkers]]
[[fr:Lieurs C++]]
[[ja:C++ リンカ]]

Debuggen von C++Builder-Anwendungen für 64-Bit-Windows

2026-10-03T14:58:55Z

L10nBot: defaultsort

{{Parent|C++Builder-Anwendungsentwicklung für 64-Bit-Windows}}

__TOC__

==LLDB-basierter C++-Debugger für WIN64==

In {{Product}} 10.4 wurde ein neuer, auf LLDB basierter Debugger für C++ für Win64 eingeführt. Der Compiler verwendet das Format von [http://www.dwarfstd.org/ DWARF] Version 4 für Debug-Informationen.

Der neue LLDB-basierte Debugger von {{Product}} bietet eine verbesserte Stabilität beim Debuggen und ermöglicht durch eine neue Debugger-Technologie und die generierten Debug-Informationen eine verbesserte Auswertung, Untersuchung und andere Debugger-Funktionen. Außerdem unterstützt der Debugger die Auswertung komplexer Typen, wie STL-Sammlungen oder Strings, über Formatierer.

==Formatierer==

Ein häufiges Problem beim Debuggen von C++-Anwendungen ist die Untersuchung oder Auswertung komplexer Typen. Für die Auswertung des Inhalts einer std::map (zum Beispiel) ist die Kenntnis des Layouts des Typs erforderlich, und der Array-Zugriffsoperator [] ist möglicherweise für den Debugger nicht verfügbar, wenn er im Code nie aufgerufen wurde oder immer Inline angegeben wurde und daher nicht aufrufbar ist. Ähnliche Probleme gibt es bei anderen Typen, einschließlich Strings, und möglicherweise sogar bei Ihren eigenen Typen.

Dies wird durch die Verwendung von Formatierern gelöst. Ein Formatierer ist ein kleines Python-Skript, das beim Debuggen eines bestimmten Typs hilft. RAD Studio wird mit Formatierern für gängige Typen ausgeliefert, und Sie können bei Bedarf eigene Formatierer für Ihre Typen hinzufügen.

Die folgenden Formatierer sind für gängige STL- und Delphi-Typen verfügbar.

* std::string and std::wstring
* String (UnicodeString), AnsiString, UTF8String, WideString.
* std::vector
* std::deque
* std::stack
* std::map
* std::shared_ptr

====Benutzerdefinierte Formatierer====

Um einen eigenen Formatierer hinzuzufügen, erstellen Sie eine neue Python-Datei und fügen der Datei '''bin\Windows\lldb\.lldbinit''' eine Zeile mit einem Verweis auf Ihr neues Python-Skript hinzu. Weitere Informationen zum Schreiben eigener Formatierer finden Sie hier:

*[http://lldb.llvm.org/use/variable.html LLDB’s formatting documentation (EN)]
*[https://pspdfkit.com/blog/2018/how-to-extend-lldb-to-provide-a-better-debugging-experience/ How to extend LLDB to provide a better debugging experience (EN)]
*[https://stackoverflow.com/questions/52013282/custom-data-formatter-in-lldb This Stack Overflow question about writing a custom data formatter (EN)]

==C++Builder für 64-Bit-Windows==

Der {{CBuilder}}-Compiler für 64-Bit-Windows ([[BCC64.EXE: Der C++-Compiler für 64-Bit-Windows|BCC64]]) erzeugt Debug-Informationen im [http://www.dwarfstd.org/ DWARF]-Format, das sich von dem Format, das von BCC32 und BCCOSX verwendet wird, unterscheidet. Im Allgemeinen entspricht das Debuggen von C++-Anwendungen für 64-Bit-Windows jedoch dem Debuggen von C++-Anwendungen für 32-Bit-Windows. Es gibt einige Unterschiede, die im Folgenden beschrieben werden:

* Einige Debugger-Funktionen werden nicht unterstützt. Das Debuggen von Eigenschaften, Closures, Klassenmethoden und anderen Erweiterungen der {{Delphi}}-Sprache wird derzeit nicht unterstützt.
*: Beispielsweise werden im [[Debug-Inspektor|Debug-Inspektor]] die Registerkarten '''Methoden''' und '''Eigenschaften''' für C++-Anwendungen für 64-Bit-Windows nicht angezeigt.
* Unicode, Codeseiten und Lokalisierung werden nicht vollständig unterstützt.
*: Beispielsweise wird Unicode nicht in Bezeichnernamen unterstützt, und Codeseiten werden nicht vom C++-Debugger für 64-Bit-Windows unterstützt.
* Bei der Auswertung eines 64-Bit-Windows-Registers muss dem Registernamen ein $ (z.B. <code>$rax</code>) vorangestellt werden.
*:Siehe [[Auswerten/Ändern|Auswerten/Ändern]].
* Funktionsaufrufe, die Exceptions auslösen, werden folgendermaßen behandelt:
** Wenn eine Funktion einen "try/except/catch"-Block enthält und während der Ausführung eine C++- oder OS/SEH-Exception ausgelöst wird, wird der Funktionsaufruf korrekt beendet, aber das Ergebnis ist undefiniert oder 0. In diesem Fall wird der interne Exception-Block nicht ausgeführt, weil die Exception direkt vom Debugger behandelt wird.
** Wenn eine Funktion einen "try/except/catch"-Block enthält und keine Sprach- oder OS/SEH-Exceptions ausgelöst werden, wird der Funktionsaufruf ordnungsgemäß beendet und das Ergebnis ist – abhängig von der Funktion – korrekt.

{{Note|In {{Product}} können Sie '''BCC64X'''-Anwendungen wie jede andere '''BCC64'''- oder '''BCC32'''-Anwendung debuggen.
}}

==Unterschiede beim Aufruf-Stack==

Manche Werte werden eventuell bei der 64-Bit-Auswertung anders als bei der 32-Bit-Auswertung angezeigt. Beispielsweise wird der [[Fenster Aufruf-Stack|Aufruf-Stack]] ohne Funktionsparameter und Werte angezeigt.

Der [[Fenster Aufruf-Stack|Aufruf-Stack]] enthält normalerweise zwei Kopien von jedem Konstruktor und Destruktor.
Der Aufruf-Stack könnte z.B. Folgendes enthalten:

:<code> :0000000000401244 ; MyClass::~MyClass
</code>
:<code> :0000000000401229 ; MyClass::~MyClass
</code>
:<code> :0000000000401187 ; main
</code>
:<code> :000000000040ef90 ; _startup</code>

{{Note| Clang implementiert das Itanium-ABI, das drei Konstruktoren und drei Destruktoren beschreibt, die sich nacheinander gegenseitig aufrufen. Clang implementiert aber nur zwei der drei Konstruktoren. Der dritte wird von {{CBuilder}} für Klassen im {{Delphi}}-Stil hinzugefügt. Siehe [http://www.uclibc.org/docs/psABI-ia64.pdf Itanium ABI doc] oder diesen Beitrag: [http://stackoverflow.com/questions/6921295/dual-emission-of-constructor-symbols.}} http://stackoverflow.com/questions/6921295/dual-emission-of-constructor-symbols.}}]

==Reduzieren des Linker-Speicherverbrauchs mit Split DWARF==

{{Note| Das Feature "Split DWARF" wird nur unter C++ für Windows 64 Bit unterstützt. Dieses Feature reduziert die zu verarbeitende Datenmenge und reduziert daher Linker-Fehler im Linker. Weitere Informationen zum Umgang mit Linker-Fehlern finden Sie unter [[Behandeln von Linker-Fehlern aufgrund nicht ausreichendem Arbeitsspeicher|Behandeln von Linker-Fehlern aufgrund nicht ausreichendem Arbeitsspeicher]].}}

In {{Product}} 10.4.2 wurde ein neues Feature eingeführt, um die zu verarbeitende Datenmenge zu reduzieren, insbesondere beim Linken von Anwendungen, die im Debug-Modus erstellt wurden. Dieses Feature, Split DWARF genannt, schreibt die Debug-Informationen in eine separate .dwo-Datei (DWARF-Objekt), die parallel zur normalen Objektdatei mit dem compilierten Code platziert wird. Der Linker verknüpft dann den ausführbaren Code mit nur wenigen anderen Informationen, was die Speicherbelastung reduziert.

{{Note|Das Feature "Split DWARF" ist standardmäßig deaktiviert.}}

===Aktivieren von Split DWARF in der IDE oder in MSBuild===

Öffnen Sie das Dialogfeld "C++-Projektoptionen". Navigieren Sie zu "Erzeugen > C++-Compiler > Debuggen", und vergewissern Sie sich, dass "Zielplattform" auf eins der Windows-64-Bit-Ziele festgelegt ist.

# Aktivieren Sie das Kontrollkästchen "Split DWARF verwenden".
# Geben Sie in der Einstellung "DWO-Ausgabeverzeichnis" einen Ordner für die Debug-Informationsdateien an. Dies muss ein absoluter Pfad, kein relativer Pfad und kein Pfad mit Umgebungsvariablen sein.

Zum Beispiel ist '''c:\myproject\win64debug''' geeignet, aber '''..\win64debug''' nicht.

Um dieses Feature zu deaktivieren, heben Sie die Markierung des Kontrollkästchens unter "Projektoptionen > Erzeugen > C++-Compiler > Debuggen" auf.
Diese Einstellungen werden beim Erzeugen in der IDE oder beim Erzeugen mit MSBuild in der Befehlszeile verwendet.

===Aktivieren von Split DWARF in der Befehlszeile===

So aktivieren Sie Split DWARF manuell für ein reines Befehlszeilen-Build, z. B. eins, das [[BCC64|BCC64]] verwendet:

1. Geben Sie die Split DWARF-Einstellung in der Befehlszeile des Compilers an.

"-enable-split-dwarf"
AND
"-split-dwarf-file AFilename.dwo"

Dadurch erstellt der Compiler die Datei AFilename.dwo und gibt den Speicherort dieser .dwo-Datei in der .o-Objektdatei aus. Beachten Sie, dass dieser Schritt noch nicht bedeutet, dass die .dwo-Datei die Debug-Informationen enthält.

2. Verwenden Sie "-dwo-dir <Verzeichnis>", um das Verzeichnis anzugeben, in das der Compiler die .dwo-Datei schreibt. Achten Sie darauf, dass es sich um einen absoluten Pfad handelt.

3. Führen Sie das Tool objcopy.exe für die .o-Datei aus. Durch diese Aktion werden alle DWARF-Abschnitte aus der normalen Objektdatei (.o) entfernt und in eine separate .dwo-Datei platziert. Dies muss für jede Objektdatei (.o) ausgeführt werden und muss mit dem in '''Schritt 1''' angegebenen Namen übereinstimmen.

objcopy --split-dwo=AFilename.dwo AFilename.o

4. Zum Schluss linken Sie die .o-Dateien, um Ihre EXE oder DLL wie gewohnt zu erstellen – dieser Schritt ist nicht geändert. Die Dateien sind kleiner als normal, da sie weniger Debug-Informationen enthalten. Jedes Objekt enthält den Namen und den Speicherort der .dwo-Datei. Wie in Schritt 2 beschrieben, ist dies der Speicherort für Ihren Computer und muss ein bestimmter absoluter Pfad sein.

====Probleme beim Laden von Debug-Informationen bei Verwendung von Split DWARF====

Bei der Verwendung von Split DWARF für das Debuggen unter Win64 kann es vorkommen, dass für Quelldateien, die sich nicht im selben Verzeichnis wie die Projektdatei befinden, falsche Verzeichnisinformationen in der Objektdatei generiert werden. Das bedeutet, dass Symbole aus diesen Dateien (Typen, lokale Variablen und Parameter) nicht verfügbar sind. Sie erkennen dies beim Debuggen daran, dass die blauen Punkte im Editor, die Zeilennummern angeben, sichtbar sind, und Sie einen Haltepunkt setzen können, aber keine Ausdrücke oder Symbole auswerten oder untersuchen können.

Um dies zu umgehen, geben Sie einen absoluten Pfad im Feld "DWO-Ausgabeverzeichnis" der Projektoption {{Menu|C++-Compiler > Debuggen > Split DWARF verwenden}} an oder die Befehlszeilenoption -dwo-dir, wenn Sie ein Build in der Befehlszeile erzeugen. Informationen zu diesen Einstellungen finden Sie oben.

==Auswerten von Funktionsaufrufen wie strcmp()==

Die Auswertung eines Funktionsaufrufs, wie strcmp(str, "ABC"), könnte einen Fehler wie den folgenden zurückgeben:

#include <system.hpp>
int main()
{
char *str = "ABC";
return strcmp(str, "ABC");
}

error: 'strcmp' has unknown return type; cast the call to its declared return type
error: 1 errors parsing expression

Sie müssen im Fenster [[Auswerten/Ändern|Auswerten/Ändern]] den Rückgabetyp für strcmp() umwandeln:

(int) strcmp(str, "ABC");

Siehe [[Strcmp, mbscmp, wcscmp|strcmp, _mbscmp, wcscmp]].

{{Note| Wenn Sie Probleme beim Debuggen haben, kann unser Support-Team Sie bitten, Debugger-Protokolle zur Verfügung zu stellen. Hier finden Sie Informationen dazu, [[Aktivieren der Protokollierung für die RAD Studio-Debugger|wie Sie die Protokollierung für {{Product}}-Debugger aktivieren]].}}

==Siehe auch==

* [[Überblick zum Debuggen|Überblick zum Debuggen]]
* [[Anwendungen debuggen - Index|Verwendung des Debuggers]]
* [[Debuggen von geräteübergreifenden Anwendungen|Debuggen von geräteübergreifenden Anwendungen]]
* [[Unterschiede von C++Builder für 64-Bit-Windows|Unterschiede von C++Builder für 64-Bit-Windows]]
* [[Behandeln von Linker-Fehlern aufgrund nicht ausreichendem Arbeitsspeicher|Behandeln von Linker-Fehlern aufgrund nicht ausreichendem Arbeitsspeicher]]
* [[Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows|Upgrade von vorhandenen C++-Projekten nach 64-Bit-Windows]]
* [[Striktere C++-Compiler (Durch Clang erweiterte C++-Compiler)|Striktere C++-Compiler (Durch Clang erweiterte C++-Compiler)]]
* [[Auswerten/Ändern|Auswerten/Ändern]]
* [[Erweiterungen von mit RAD Studio erzeugten Dateien|Erweiterungen von mit RAD Studio erzeugten Dateien]]

{{DEFAULTSORT:Debuggen von C++Builder-Anwendungen fur 64-Bit-Windows}}
[[Category:C++]]
[[Category:XE3]]
[[Category:64Bit]]
[[Category:AMMigrate]]

[[en:Debugging C++Builder 64-Bit Windows Applications]]
[[fr:Débogage des applications C++ Builder Windows 64 bits]]
[[ja:C++Builder 64 ビット Windows アプリケーションのデバッグ]]

Übersicht über Zielplattformen

2026-10-03T14:58:55Z

L10nBot: defaultsort

{{Parent|Geräteübergreifende Anwendungen entwickeln}}
{{Parent|Compilieren, Build erstellen und Anwendungen ausführen - Index}}
__TOC__

In dem Knoten '''[[Projekte-Fenster#Kontextmenü für Zielplattformen|Zielplattformen]]''' im [[Projekte-Fenster|Projekte-Fenster]] wird die [[Unterstützte Zielplattformen|Zielplattform]] für ein Projekt festgelegt.

[[File:Projects1updated.png|link=|400px|thumb|right]]

Der Knoten '''Zielplattformen''' wird nur für Projekttypen angezeigt, die mehr als eine Plattform unterstützen, z. B.:

* [[Geräteübergreifende Anwendung|Geräteübergreifende Anwendungen]] (die alle [[Unterstützte Zielplattformen|verfügbaren Zielplattformen]] unterstützen){{f|vcl|
* VCL-Anwendungen (die Win32 und Win64 unterstützen)}}
* Konsolenanwendungen (die alle verfügbaren Zielplattformen unterstützen)

==Mit Zielplattformen auszuführende grundlegende Aufgaben==

* '''Hinzufügen einer Zielplattform''' zum aktuellen Projekt: Öffnen Sie das [[Projekte-Fenster|Projekte-Fenster]], klicken Sie mit der rechten Maustaste auf den Knoten '''Zielplattformen''', und wählen Sie dann im Kontextmenü '''Plattform hinzufügen''' aus.
* '''Aktivieren einer Zielplattform''' für das aktuelle Projekt: Doppelklicken Sie auf die Zielplattform (oder klicken Sie mit der rechten Maustaste, und wählen Sie im Kontextmenü den Befehl '''Aktivieren''' aus).
* '''Zuweisen eines Verbindungsprofils und eines SDK''': Klicken Sie mit der rechten Maustaste auf eine Plattform, und wählen Sie im Kontextmenü '''Eigenschaften''' aus. Führen Sie dann im Dialogfeld '''[[Plattformeigenschaften|Plattformeigenschaften]]''' einen der beiden folgenden Schritte aus:
** Wählen Sie das Verbindungsprofil aus, oder wählen Sie im Kombinationsfeld '''Neue hinzufügen''', um ein neues Profil zu erstellen.
**:{{Note|Ein Verbindungsprofil wird nur benötigt, wenn die Zielplattform eine der folgenden ist:
**:*macOS
**:* iOS
**:*Android
**:* 64-Bit-Windows und ein 32-Bit-Windows-Entwicklungssystem
**:*Linux}}
** Wählen Sie das SDK aus, oder wählen Sie im Kombinationsfeld '''Neue hinzufügen''', um ein neues SDK zu installieren.
**:{{Note|Ein SDK wird nur für mobile Projekte und für C++-Projekte für macOS und Linux benötigt.}}
* Anzeigen der [[Projekte-Fenster#Kontextmenü für Zielplattformen|Kontextmenübefehle für eine Zielplattform]]: Klicken Sie im Knoten '''Zielplattformen''' mit der rechten Maustaste auf den Namen eines bestimmten geräteübergreifenden Ziels (wie '''64-Bit-Windows''').

Nach Zuweisung eines Verbindungsprofils zu der aktiven Plattform wird der Name des Verbindungsprofils und des zugewiesenen SDK in der '''Projektverwaltung''' neben der aktiven Plattform angezeigt. Zum Beispiel:

:[[Image:target platforms updated.png|link=]]

Unter '''[[Aktivieren und Konfigurieren der Zielplattform|Aktivieren und Konfigurieren der Zielplattform]]''' finden Sie eine Beschreibung der zur Konfiguration eines Projekts, das mehrere Plattformen unterstützt, in {{Product}} auszuführenden Schritte.

==Verwenden der Ziel- und Konfigurationsknoten==

Knoten der Zielplattformen können keinen, einen oder zwei der folgenden untergeordneten Knoten bereitstellen:

* '''[[#Verwenden des Zielknotens|Ziel]]'''. Führt die verfügbaren Geräte und Simulatoren auf, die auf der Zielplattform ausgeführt werden.
* '''[[#Verwenden des Konfigurationsknotens|Konfiguration]]'''. Führt die für die Zielplattform spezifischen Build-Konfigurationen auf.

Um '''eine Zielplattform oder Konfiguration zu aktivieren''', doppelklicken Sie auf den Knoten für die betreffende Zielplattform oder Konfiguration (oder klicken Sie mit der rechten Maustaste, und wählen Sie im Kontextmenü den Befehl '''Aktivieren''').

===Verwenden des Zielknotens===

Im Knoten '''Ziel''' eines Zielplattformknotens wird eine Liste der verfügbaren Zielgeräte und Simulatoren (iOS) angezeigt.

Die in dieser Liste angezeigten Namen hängen von der Zielplattform und dem Typ des Zielgeräts oder Simulators ab:

* Für die Zielplattform '''iOS-Gerät - 64 Bit''' werden die Geräte nach Gerätenamen aufgeführt. Zum Beispiel: "Janes iPhone".
* Für die Zielplattformen '''Android - 32 Bit''' und '''Android - 64 Bit''' werden die Geräte nach Gerätemodell aufgeführt. Zum Beispiel: "GT-I9505".

Im Knoten '''Ziel''' der Zielplattformknoten '''Android - 32 Bit''' und '''Android - 64 Bit''' werden die an Ihr Entwicklungssystem angeschlossenen Android-Geräte angezeigt. Wenn Sie Android-Geräte an Ihr Entwicklungssystem anschließen oder davon trennen, erkennt {{Variables|Product}} dies automatisch und aktualisiert die Einträge in der Projektverwaltung entsprechend. 
Der Knoten '''Ziel''' der Zielplattformknoten '''iOS-Gerät - 64 Bit''' und '''iOS-Simulator ARM 64 Bit''' zeigt die an Ihren Mac angeschlossenen iOS-Geräte an. 

Um die '''Liste verfügbarer Ziele''' für eine Zielplattform manuell zu aktualisieren, klicken Sie mit der rechten Maustaste auf den Knoten '''Ziel''' und wählen '''Aktualisieren''' aus. Wenn im Knoten '''Ziel''' nach der Aktualisierung der Liste der Ziele nicht die erwarteten Einträge angezeigt werden, finden Sie Informationen dazu unter [[Fehlerbehebung: In der Projektverwaltung werden keine Android-Ziele aufgeführt|Fehlerbehebung: In der Projektverwaltung werden keine Android-Ziele aufgeführt]].

Wenn das aktive Zielgerät oder der Zielsimulator nicht mehr in der Liste der Ziele angezeigt wird, wählt {{Variables|Product}} automatisch das erste verfügbare Zielgerät oder den ersten verfügbaren Zielsimulator aus. Wenn keine Zielgeräte oder Simulatoren für die aktive Zielplattform verfügbar sind, können Sie die Anwendung nicht auf der Zielplattform ausführen.

===Verwenden des Konfigurationsknotens===

Im Knoten '''Konfiguration''' wird eine Liste der plattformspezifischen Build-Konfigurationen angezeigt, die Sie zum Erstellen der Anwendung verwenden können.

Dieser Knoten ist nur für die Zielplattformen '''macOS''', '''iOS-Gerät''', '''iOS-Simulator''' und '''Android''' verfügbar:

*'''Android - 32 Bit'''
** '''Entwicklung'''. Für Entwicklungszyklen.
** '''Anwendungs-Store'''. Für das letzte Build vor der Übermittlung der App an den Anwendungs-Store.

*'''Android - 64 Bit'''
** '''Entwicklung'''. Für Entwicklungszyklen.
** '''Anwendungs-Store'''. Für das letzte Build vor der Übermittlung der App an den Anwendungs-Store.

*'''iOS-Gerät - 64 Bit'''
** '''Entwicklung'''. Für Entwicklungszyklen.
** '''Ad-hoc'''. Für die private interne Distribution; weitere Informationen finden Sie unter [https://developer.apple.com/programs/ios/enterprise/ https://developer.apple.com/programs/ios/enterprise/ (EN)].
** '''Anwendungs-Store'''. Für das letzte Build vor der Übermittlung der App an den App Store.

* '''iOS-Simulator ARM 64 Bit'''

*'''macOS - 64 Bit'''
** '''Developer ID'''. Ermöglicht Ihnen, die Software Zulassungsprüfung an Apple zu übermitteln.
** '''Normal'''. Für Entwicklungszyklen.
** '''Anwendungs-Store'''. Für das letzte Build vor der Übermittlung der App an den Mac App Store.

*'''macOS ARM 64 Bit'''
** '''Developer ID'''. Ermöglicht Ihnen, die Software Zulassungsprüfung an Apple zu übermitteln.
** '''Normal'''. Für Entwicklungszyklen.
** '''Anwendungs-Store'''. Für das letzte Build vor der Übermittlung der App an den Mac App Store.

*'''Windows - 32 Bit'''
** '''Normal'''. Für Entwicklungszyklen.
** '''Anwendungs-Store'''. Für das letzte Build vor der Übermittlung der App an den Windows Store.

*'''Windows - 64 Bit'''
** '''Normal'''. Für Entwicklungszyklen.
** '''Anwendungs-Store'''. Für das letzte Build vor der Übermittlung der App an den Windows Store.

*'''Windows - 64 Bit (Modern)'''
** '''Normal'''. Für Entwicklungszyklen.
** '''Anwendungs-Store'''. Für das letzte Build vor der Übermittlung der App an den Windows Store.

{{Note| Das Ziel '''Windows - 64 Bit (Modern)''' ist nur für C++Builder verfügbar.}}

* '''Linux'''

==Verwenden des Android-Knotens "Bibliotheken"==

:[[Image:android libraries.png|link=]]

Der Knoten der '''Android'''-Plattform enthält einen weiteren Knoten, '''Bibliotheken''', mit dem Sie Folgendes ausführen können:

* [[Verwenden der in RAD Studio integrierten Java-Bibliotheken für Android#Deaktivieren nicht benötigter in {{Product}} integrierter Java-Bibliotheken, um die Größe Ihrer Anwendung zu reduzieren|Deaktivieren von in {{Product}} integrierten Java-Bibliotheken]], die für Ihre Anwendung nicht erforderlich sind.
* [[Hinzufügen von Java-Bibliotheken zu Ihren Anwendungen in der Projektverwaltung|Hinzufügen benutzerdefinierter Java-Bibliotheken zu Ihrer Anwendung]].

==Siehe auch==

* [[Projekte-Fenster#Kontextmenü für Zielplattformen|Kontextmenü für Zielplattformen]]
* [[Symbolleiste zur Auswahl des Plattformgeräts|Symbolleiste zur Auswahl des Plattformgeräts]]
* [[Unterstützte Zielplattformen|Unterstützte Zielplattformen]]
* [[Überblick zu Build-Konfigurationen|Überblick zu Build-Konfigurationen]]
* [[Schritte bei der Entwicklung von geräteübergreifenden Anwendungen|Schritte bei der Entwicklung von geräteübergreifenden Anwendungen]]
* [[Verbindungsprofil erstellen|Verbindungsprofil erstellen (Experte)]]
* [[Erstellen und Testen eines Verbindungsprofils auf dem Entwicklungs-PC|Erstellen und Testen eines Verbindungsprofils auf dem Entwicklungs-PC]]
* [[Hinzufügen von SDKs für macOS oder iOS|Hinzufügen von SDKs für macOS oder iOS]]
* [[Hinzufügen von Android-SDKs|Hinzufügen von Android-SDKs]]
* [[Aktivieren einer Konfiguration und einer Zielplattform für eine Projektgruppe|Aktivieren einer Konfiguration und einer Zielplattform für eine Projektgruppe]]
* [[PAServer: Die Platform Assistant Server-Anwendung|PAServer: Die Platform Assistant Server-Anwendung]]
* [[Geräteübergreifende Anwendung|Geräteübergreifende Anwendung]]
* [[Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)|Mobile-Tutorials: Mobile Anwendungsentwicklung (iOS und Android)]]

{{DEFAULTSORT:Ubersicht uber Zielplattformen}}
[[Category:XE5]]
[[Category:AMMigrate]]

[[en:Target Platforms Overview]]
[[fr:Présentation des plates-formes cible]]
[[ja:［ターゲットプラットフォーム］の概要]]

Überblick zum Debuggen

2026-10-03T14:58:52Z

L10nBot: defaultsort

{{Parent|Anwendungen debuggen - Index}}

{{Variables|Product}} enthält integrierte Debugger für jede [[Unterstützte Zielplattformen|unterstützte Zielplattform]]. Die IDE verwendet automatisch für den aktiven Projekttyp den korrekten Debugger. Das Debuggen für geräteübergreifende Anwendungen innerhalb eines Projekts wird unterstützt. Die Benutzeroberfläche der Debugger ist größtenteils identisch.

Mit Hilfe der integrierten Debugger lassen sich sowohl Laufzeitfehler als auch Fehler in der Logik einer {{Variables|Product}}-Anwendung finden. Bei der Arbeit mit den Debuggern können Sie den Quelltext schrittweise durchlaufen, Haltepunkte und überwachte Ausdrücke festlegen sowie Programmwerte prüfen und bearbeiten. Wenn Sie eine Anwendung debuggen, unterstützen Sie die Debug-Fenster bei der Verwaltung der Debug-Sitzung und zeigen Informationen über den Status Ihrer Anwendung an.

Mit dem '''[[Debug-Inspektor|Debug-Inspektor]]''' können Sie verschiedene Datentypen, wie z. B. Arrays, Klassen, Konstanten, Funktionen, Zeiger, skalare Variablen und Interfaces, untersuchen. Sie öffnen den '''Debug-Inspektor''' mit '''Start > Untersuchen'''.

Diese [http://video.codegear.com/CodeRage2007EncoreArchives/CodeRageEncoreDebugger/CodeRageEncoreDebugger.html Video-Demo des Debuggers (EN)] bietet eine hilfreiche Übersicht.

==Fehlersuche im Quelltext schrittweise ausführen==

Wenn Sie Ihren Quelltext beim Debuggen schrittweise durchlaufen, führen Sie das Programm Codezeile für Codezeile aus. Sie können bei jedem Schritt den Programmstatus überprüfen, die Programmausgabe anzeigen, Datenwerte des Programms ändern und dann mit der Ausführung der nächsten Codezeile fortfahren. Die nächste Codezeile wird erst dann ausgeführt, wenn Sie den Debugger dazu anweisen.

Das [[Menü "Start"|Menü Start]] enthält die Befehle [[Einzelne Anweisung|Einzelne Anweisung]] und [[Gesamte Routine|Gesamte Routine]]. Beide Befehle weisen den Debugger an, die nächste Codezeile auszuführen. Enthält die Zeile jedoch einen Funktionsaufruf, führt der Befehl '''Einzelne Anweisung''' die Funktion aus und hält an der ersten Codezeile ''innerhalb'' dieser Funktion an. Der Befehl '''Gesamte Routine''' führt die Funktion aus und hält an der ersten Zeile ''nach'' der Funktion an.

==Auswerten/Ändern==

Mit '''[[Auswerten/Ändern|Auswerten/Ändern]]''' können Sie Ausdrücke auswerten. Sie können auch einen Wert für eine Variable ändern und diesen Wert in die Variable einfügen. '''Auswerten/Ändern''' variiert je nach verwendeter Sprache:

* Bei einem C++-Projekt können im Dialogfeld '''Auswerten/Ändern''' nur C++-Ausdrücke eingegeben werden.
* Bei Delphi-Projekten sind im Dialogfeld '''Auswerten/Ändern''' nur {{Delphi}}-Ausdrücke zulässig.

==Haltepunkte==

Haltepunkte unterbrechen die Programmausführung an einem bestimmten Punkt im Programm oder bei Auftreten einer bestimmten Bedingung. Sie können dann mit dem Debugger den Status des Programms untersuchen oder die gesamte Routine oder einzelne Anweisungen ausführen. Der Debugger unterstützt vier Arten von Haltepunkten:

* '''Quelltexthaltepunkte''' unterbrechen die Ausführung an einer bestimmten Position im Quelltext.
* '''Adresshaltepunkte''' unterbrechen die Ausführung an einer bestimmten Speicheradresse.
* '''Datenhaltepunkte''' unterbrechen die Ausführung, wenn sich der Speicher an einer bestimmten Adresse ändert. Datenhaltepunkte werden automatisch deaktiviert, wenn eine Debugger-Sitzung beendet ist, weil sich die Adresse einer Variablen von einer Debugger-Sitzung zur nächsten ändern kann. Um einen Datenhaltepunkt in einer nachfolgenden Debugger-Sitzung wiederzuverwenden, müssen Sie den Datenhaltepunkt nach Beginn der Debugger-Sitzung erneut aktivieren.
* '''Modulhaltepunkte''' unterbrechen die Ausführung, wenn das angegebene Modul geladen wird.

Informationen über das Erstellen, Ändern und Beibehalten von Haltepunkten finden Sie unter [[Haltepunkte setzen und bearbeiten|Haltepunkte setzen und bearbeiten]].

==Überwachte Ausdrücke==

Überwachte Ausdrücke ermöglichen Ihnen, die Werte von Programmvariablen oder -ausdrücken zu verfolgen, während Sie mit dem Befehl Gesamte Routine oder Einzelne Anweisung den Quelltext durchlaufen. Während das Programm im Debugger läuft, ändert sich der Wert des überwachten Ausdrucks, sobald das Programm die Variablen der überwachten Ausdrücke aktualisiert.

Sie können Ihre überwachten Elemente im [[Fenster Liste überwachter Ausdrücke|Fenster Liste überwachter Ausdrücke]] überwachen.

==Fenster zur Fehlersuche==

Die folgenden Debug-Fenster unterstützen Sie bei der Fehlersuche in einem Programm. Die meisten dieser Fenster werden automatisch angezeigt, wenn Sie eine Debug-Sitzung beginnen. Sie können die Fenster aber auch einzeln mithilfe der Optionen des Untermenüs '''Ansicht > Debug-Fenster''' anzeigen.

In jedem Fenster stehen ein oder mehrere Kontextmenüs zur Verfügung. Mit der Hilfe-Taste <code>F1</code> können Sie detaillierte Informationen sowohl zu dem Fenster als auch zu den Kontextmenüs anzeigen.

{| border="1" frame="hsides" rules="rows"
|-
! '''Debug-Fenster'''
! '''Beschreibung'''
|-
| style="text-align: left; vertical-align: top;" |
'''[[Fenster Liste der Haltepunkte|Liste der Haltepunkte]]'''
| style="text-align: left; vertical-align: top;" |
Zeigt alle aktuell im '''Quelltext-Editor''' oder im Fenster '''CPU''' gesetzten Haltepunkte an.
|-
| style="text-align: left; vertical-align: top;" |
'''[[Fenster Aufruf-Stack|Aufruf-Stack]]'''
| style="text-align: left; vertical-align: top;" |
Zeigt die aktuelle Sequenz der Funktionsaufrufe an.
|-
| style="text-align: left; vertical-align: top;" |
'''[[Fenster Liste überwachter Ausdrücke|Liste überwachter Ausdrücke]]'''
| style="text-align: left; vertical-align: top;" |
Zeigt den aktuellen Wert überwachter Ausdrücke im Bereich des Ausführungspunkts an.
|-
| style="text-align: left; vertical-align: top;" |
'''[[Lokale Variablen|Lokale Variablen]]'''
| style="text-align: left; vertical-align: top;" |
Zeigt die lokalen Variablen der aktuellen Funktion an. Damit lässt sich überwachen, wie das Programm Variablenwerte während der Programmausführung aktualisiert.
|-
| style="text-align: left; vertical-align: top;" |
'''[[Fenster Module|Module]]'''
| style="text-align: left; vertical-align: top;" |
Zeigt Prozesse unter der Kontrolle des Debuggers und die aktuell von jedem Prozess geladenen Module an. Darüber hinaus wird eine hierarchische Darstellung der in der Anwendung benutzten Namespaces, Klassen und Methoden angezeigt.
|-
| style="text-align: left; vertical-align: top;" |
'''[[Threads|Thread-Status]]'''
| style="text-align: left; vertical-align: top;" |
Zeigt den Status aller Prozesse und Ausführungs-Threads an, die beim Debuggen in einer Anwendung ausgeführt werden. Dies ist besonders beim Debuggen von Multithread-Anwendungen hilfreich. In Windows Vista enthält die Ansicht [[Threads|Threads-Status]] die Spalte "Wait Chain", die Blockierungen und Deadlocks von Threads aufführt.
|-
| style="text-align: left; vertical-align: top;" |
'''[[Fenster Ereignisprotokoll|Ereignisprotokoll]]'''
| style="text-align: left; vertical-align: top;" |
Zeigt Meldungen zur Prozess-Steuerung, zu Haltepunkten, Ausgabe, Threads und Modulen an.
|-
| style="text-align: left; vertical-align: top;" |
'''[[CPU-Fenster - Index|CPU-Fenster - Index]]'''
| style="text-align: left; vertical-align: top;" |
Zeigt den Low-Level-Status eines Programms an, einschließlich der Assembly-Anweisungen für jede Zeile des Quelltextes und des Inhalts bestimmter Register.
|-
| style="text-align: left; vertical-align: top;" |
'''[[FPU|FPU]]'''
| style="text-align: left; vertical-align: top;" |
Zeigt den Inhalt der Gleitkommaeinheit und der SSE-Register des Prozessors an.
|}

==Debug-Desktop einstellen==

Der '''Debug-Desktop''' ist das von der IDE verwendete Layout für das Ausführen einer Anwendung im Debug-Modus (durch Drücken der Taste <code>F9</code> bei der [[Tastaturbelegung|Standardtastaturbelegung]]). Es gibt einen Standard-Debug-Desktop, aber Sie können alternativ einen beliebigen gespeicherten Desktop als Debug-Desktop auswählen.

'''So legen Sie den Debug-Desktop fest:'''

# Wählen Sie einen der folgenden Befehle aus:
#* '''Ansicht > Desktops > [[Debug-Desktop auswählen|Debug-Desktop einstellen]]'''
#* [[Image:DebugDesktop.png]] in der [[Symbolleiste Desktop|Symbolleiste "Desktop"]]
# Klicken Sie im Dialogfeld '''Debug-Desktop einstellen''' auf den Abwärtspfeil, und wählen Sie das gewünschte Layout als Debug-Desktop aus.
# Klicken Sie auf '''OK'''.

{{f|vcl|

==Remote-Debuggen==

Mit dem Remote-Debuggen können Sie eine Anwendung debuggen, die sich auf einem Remote-Computer befindet. Ihr Computer muss mit dem Remote-Computer über TCP/IP verbunden sein.

Es stehen nun zwei Lösungen für das Remote-Debugging zur Verfügung:

* Mit der '''[[Debuggen von geräteübergreifenden Anwendungen|neuen Remote-Debugging-Lösung]]''' wird auch das geräteübergreifende Debuggen durchgeführt.
* Für die '''[[Remote-Debuggen - Alte Verfahren|alte Debuggen-Lösung]]''' ist die Installation eines Remote-Debuggers auf dem Remote-Computer erforderlich. Nachdem die erforderlichen Anwendungsdateien erstellt und auf den Remote-Computer kopiert wurden, können Sie eine Verbindung zu diesem Computer herstellen und mit dem Debuggen beginnen.

{{Note|Die alte Debugging-Lösung kann nicht für geräteübergreifende Anwendungen verwendet werden.}}
}}

==Geräteübergreifendes Debuggen==

Geräteübergreifendes Debuggen bezieht sich auf die Verwendung einer '''Zielplattform''', die nicht die native 32-Bit-Windows-Plattform ist. Ihre Interaktion mit dem Debugger ist praktisch dieselbe beim geräteübergreifenden Debuggen und beim Windows-Debuggen.

* Für die macOS- und iOS-Plattformen müssen Sie den [[PAServer: Die Platform Assistant Server-Anwendung|Platform Assistant]] auf dem Zielcomputer installieren und ausführen und ein funktionierendes [[Verbindungsprofil-Manager|Verbindungsprofil]] auf dem Entwicklungssystem erstellen.

* Für '''Android'''-Anwendungen benötigen Sie weder den Platform Assistant noch ein Verbindungsprofil, aber Sie müssen den USB-Treiber für Ihr Android-Gerät herunterladen, das USB-Debugging aktivieren und {{Product}} [[Hinzufügen von Android-SDKs|ein Android SDK hinzufügen]].

Weitere Einzelheiten finden Sie unter [[Debuggen von geräteübergreifenden Anwendungen|Debuggen von geräteübergreifenden Anwendungen]].

==Exceptions==

Um den Stacktrace der von der '''Objektive-C-Laufzeit''' ausgelösten Exception anzuzeigen, müssen Sie die Umgebungsvariable OBJC_PRINT_EXCEPTION_THROW festlegen, bevor Sie den [[PAServer: Die Platform Assistant Server-Anwendung|'''PAServer''']] aufrufen.

Geben Sie beispielsweise im <code>Terminal</code>-Fenster Folgendes an:

env OBJC_PRINT_EXCEPTION_THROW=YES open /Applications/PAServer-22.0.app

==Siehe auch==

*[[Debugger-Optionen|Debugger-Optionen]]
*[[Debuggen von geräteübergreifenden Anwendungen|Debuggen von geräteübergreifenden Anwendungen]]
*[[Aktivieren der Protokollierung für die RAD Studio-Debugger|Aktivieren der Protokollierung für die RAD Studio-Debugger]]
*[[Überblick zum externen Debugger|Überblick zum externen Debugger]]
*[[Starten des Debuggers|Starten des Debuggers]]
*[[Das Projekt zum Debuggen vorbereiten|Das Projekt zum Debuggen vorbereiten]]
*[[Haltepunkte setzen und bearbeiten|Haltepunkte setzen und bearbeiten]]
*[[Ausdruck hinzufügen|Ausdruck hinzufügen]]
*[[Variablenausdrücke bearbeiten|Variablenausdrücke bearbeiten]]
*[[Werte von Datenelementen untersuchen und ändern|Werte von Datenelementen untersuchen und ändern]]
*[[Remote-Debuggen - Alte Verfahren|Debuggen externer Anwendungen]]
*[[Mit einem ausgeführten Prozess verbinden|Mit einem ausgeführten Prozess verbinden]]
*[[Beenden einer Debug-Sitzung|Beenden einer Debug-Sitzung]]

{{DEFAULTSORT:Uberblick zum Debuggen}}
[[Category:Mit RAD Studio arbeiten]]
[[Category:AMMigrate]]

[[en:Overview of Debugging]]
[[fr:Présentation du débogage]]
[[ja:デバッグの概要]]

Modellelemente ausrichten

2026-10-03T14:56:24Z

L10nBot: updated language links

{{DISPLAYTITLE:Ausrichten von Diagrammelementen}}
{{Parent|Anleitungen zum Anpassen der Diagrammdarstellung - Index|Anpassen der Diagrammdarstellung und Anzeige von Diagrammen}}
Mit den Kontextmenübefehlen '''Ausrichtung''' können Sie ausgewählte Modellelemente im Diagramm ausrichten.

===So richten Sie Modellelemente im Diagramm aus:===

# Öffnen Sie das Diagramm in der '''Diagrammansicht'''.
# Wählen Sie mehrere Knoten oder innere Klassifizierer im Diagramm aus.
# Klicken Sie mit der rechten Maustaste auf einen ausgewählten Knoten, und wählen Sie im Kontextmenü den gewünschten Befehl '''Ausrichtung > ''Auszurichtendes_Element'''''. Die folgenden Ausrichtungsbefehle stehen zur Verfügung:
#* '''Oben''' – richtet die oberen Kanten der ausgewählten Knoten aus.
#* '''Unten''' – richtet die unteren Kanten der ausgewählten Knoten aus.
#* '''Rechts''' – richtet die rechten Seiten der ausgewählten Knoten aus.
#* '''Links''' – richtet die linken Seiten der ausgewählten Knoten aus.
#* '''X zentrieren''' – richtet die Mittelpunkte der X-Koordinaten der ausgewählten Knoten aus.
#* '''Y zentrieren''' – richtet die Mittelpunkte der Y-Koordinaten der ausgewählten Knoten aus.

==Siehe auch==

* [[Automatisches Layout für Diagramme|Automatisches Layout für Diagramme]]

[[Category:Mit RAD Studio arbeiten]]

[[fr:Alignement des éléments de modèle]]
[[ja:モデル要素の位置を揃える]]

UML 1.5-Beziehungen in Klassendiagrammen

2026-10-03T14:56:09Z

L10nBot: updated language links

{{DISPLAYTITLE: Beziehungen zwischen Elementen in Klassendiagrammen}}
{{Parent|UML 1.5-Klassendiagramm - Index|UML 1.5-Klassendiagramm}}
Eine Beziehung ist eine Verbindung zwischen Elementen. In der Modellierung sind die drei wichtigsten Beziehungen Abhängigkeiten, Generalisierungen und Assoziationen. Grafisch wird eine Beziehung mit für den jeweiligen Beziehungstyp unterschiedlichen Linien dargestellt.

==Beziehungstypen zwischen Elementen in Klassendiagrammen==

Für Elemente in Klassendiagrammen können die folgenden Beziehungstypen verwendet werden:

* Generalisierung und Implementierung
* Abhängigkeit
* Assoziation (einfache Assoziation, n-fache Assoziation, Aggregation und Komposition)
* Bereitgestellte und erforderliche Schnittstellen (UML 2.0)

===Generalisierung und Implementierung===

* '''Generalisierung''' - Eine '''Generalisierung''' ist eine Beziehung zwischen einem allgemeinen Element (Oberklasse oder übergeordnete Klasse) und einem spezielleren Element dieses Typs (Unterklasse oder untergeordnete Klasse). Mit einer '''Generalisierung''' wird auch auf die Vererbungsbeziehung zwischen zwei Schnittstellen (untergeordneter und übergeordneter) gezeigt.

: Generalisierung bedeutet, dass das untergeordnete Element die Eigenschaften (Attribute, Operationen usw.) des übergeordneten Elements erbt und dass Objekte des untergeordneten Elements überall dort verwendet werden können, wo das übergeordnete Objekt auftritt.
: Grafisch wird eine Generalisierung als einfache Linie mit einem gefüllten Pfeil am Ende dargestellt, der auf das übergeordnete Element zeigt: 
: [[Image:DV Generalization.png|Generalisierungsbeziehung]]

* '''Implementierung''' - Eine '''Implementierungsbeziehung''' ist eine spezielle Art der '''Generalisierungsbeziehung'''. Eine Implementierung it eine Vererbungsbeziehung, die angibt, dass eine untergeordnete Klasse eine übergeordnete Schnittstelle implementiert.

: Grafisch wird eine Implementierung als gestrichelte Linie mit einem gefüllten Pfeil am Ende dargestellt, der auf die übergeordnete Schnittstelle zeigt: 
: [[Image:DV Implementation.png|Implementierungsbeziehung]]

===Abhängigkeit===

Eine Abhängigkeit ist eine Beziehung zwischen zwei Elementen, bei der eine Änderung eines Elements (des unabhängigen Elements - '''Anbieter''') Änderungen des anderen Elements (des abhängigen Elements - '''Client''') bewirken kann.

: Grafisch wird eine Abhängigkeit als gestrichelte Linie dargestellt, die auf das unabhängige Element ('''Anbieter ''') gerichtet ist: 
: [[Image:DV Dependency.png|Abhängigkeitsbeziehung]]

===Assoziation===

Eine Beziehung zwischen Instanzen zweier Klassen. Assoziationen zwischen zwei Klassen bestehen, wenn eine Instanz der einen Klasse ('''Client''') von der anderen ('''Anbieter''') wissen muss, um ihre Aufgaben durchzuführen.

In einem Diagramm wird eine Assoziation durch eine einfache Linie zwischen zwei Klassen dargestellt.

Navigation, Rollen und Multiplizität sind optionale Elemente, die die Interpretation der Assoziation vereinfachen:

* '''Assoziationsnavigation'''. Assoziationen können gerichtet oder ungerichtet sein. Eine gerichtete Beziehung zeigt auf die '''Anbieterklasse''' (das Ziel). Ein Navigationspfeil auf einer Assoziation zeigt die Richtung an, in der die Assoziation abgefragt werden kann. Eine Klasse kann bezüglich ihrer "Elemente" abgefragt werden. Abfragen in entgegengesetzter Richtung sind nicht möglich. Am Pfeil lässt sich auch der "Eigentümer" der Implementierung der Assoziation erkennen. Assoziationen ohne Navigationspfeil sind bidirektional. Beispielsweise gibt eine bidirektionale Assoziation zwischen den Klassen <code>Bibliothek</code> und <code>Buch</code> an, dass Objekte des Typs <code>Bibliothek</code> über Objekte des Typs <code>Buch</code> abgefragt werden können und umgekehrt.

* '''Rollen'''. Eine Assoziation besitzt zwei Enden. Jedes Ende kann mit einem Rollennamen versehen sein, der den Charakter der Assoziation beschreibt.

* '''Multiplizität'''. Ein Assoziationsende kann eine Multiplizität besitzen. Die Multiplizität eines Assoziationsendes bestimmt, wie viele Instanzen der Klasse mit einer einzelnen Instanz am anderen Ende verbunden sein können. Die Multiplizität kann als einzelne Werte oder als Wertebereich angegeben werden.

: In der folgenden Tabelle sind die gängigsten Arten der Multiplizität aufgeführt:

:
{| border="1" frame="hsides" rules="rows"
|-
! ''' Multiplizität'''
! ''' Bedeutung '''
|-
| style="text-align: left; vertical-align: top;" |
<code>0..1</code>
| style="text-align: left; vertical-align: top;" |
Keine oder eine Instanz. Die Notation <code>n..m</code> steht für <code>n</code> bis <code>m</code> Instanzen.
|-
| style="text-align: left; vertical-align: top;" |
<code>1</code> or <code>n</code>
| style="text-align: left; vertical-align: top;" |
Genau eine Instanz oder genau <code>n</code> Instanzen.
|-
| style="text-align: left; vertical-align: top;" |
<code>0..*</code> or <code>*</code>
| style="text-align: left; vertical-align: top;" |
Keine Beschränkung bezüglich der Anzahl der Instanzen (auch keine Instanz ist möglich).
|-
| style="text-align: left; vertical-align: top;" |
<code>1..*</code>
| style="text-align: left; vertical-align: top;" |
Mindestens eine Instanz.
|}

===Assoziationstypen===

Es gibt verschiedene Untertypen von Assoziationsbeziehungen:

# '''Assoziation''' ('''Einfache Assoziation''') - Eine Assoziation ("einfache Assoziation") zwischen zwei gleichgeordneten Klassen. Die Assoziation repräsentiert eine rein strukturelle Beziehung zwischen zwei gleichgeordneten Klassen. Beide Klassen befinden sich konzeptuell auf derselben Ebene, keine ist wichtiger als die andere.

:
::Grafisch wird eine Assoziation durch eine einfache Linie zwischen zwei Klassen dargestellt:
:: [[Image:DV Association.png|Assoziationsbeziehung]]
:: Diese Abbildung zeigt die "einfache Assoziationsbeziehung", mit einer Eigentümerrolle (<code>owner</code>), der Multiplizität <code>1</code> und <code>0..*</code> und legt die Assoziationsnavigation von der Rolle <code>Client</code> zu der Rolle <code>Password</code> fest.

<ol start="2"><li> '''Assoziation''' ('''n-fache Assoziation''') - Die n-fache Assoziation kann soviel Assoziationsendklassen (Teilnehmer) wie erforderlich verbinden. Erstellen Sie n-fache Assoziationen mit einer Assoziationsklasse.</li>
</ol>

:
:: Assoziationsklassen werden in Diagrammen durch drei Elemente dargestellt:
:: * Assoziationsklasse ([[Image:DV AssociationClassNode.png|Assoziationsklassenelement]]), dargestellt durch ein Klassensymbol.
:: * N-fache Assoziationsklassenbeziehung ([[Image:DV AssociationEndLinks.png|Assoziationsendbeziehung]]), dargestellt durch eine Raute.
:: * Assoziationskonnektor ([[Image:DV AssociationClass.png|Assoziationsklassenkonnektor]]), dargestellt durch eine Linie zwischen einem Assoziationsklassensymbol und einer Assoziationsraute.

:
:: Im '''Objektinspektor''' für eine Assoziationsklasse, eine Assoziationsbeziehung und einen Konnektor wird zusätzlich die Registerkarte '''Assoziation''' angezeigt. Sie enthält lediglich die Eigenschaft '''label''', die automatisch den Namen der Assoziationsklasse enthält. Bei Assoziationsklassen und Assoziationsendebeziehungen enthält der Eintrag '''Custom''' des '''Objektinspektors''' weitere Eigenschaften, die der Rolle dieses Bestandteils der n-fachen Assoziation entsprechen (<code>associationClass</code> bzw. <code>associationEnd</code>).
::Sie können beliebige Assoziationsendebeziehungen oder Teilnehmerklassen löschen, ohne dass die gesamte n-fache Assoziation entfernt wird. Wenn Sie jedoch die Assoziationsklasse löschen, werden alle Bestandteile der n-fachen Assoziation entfernt.
::Siehe auch: [[Assoziationsklasse erstellen|Assoziationsklasse erstellen]].

<ol start="3"><li> '''Aggregation''' - Eine Aggregation ist ein spezieller Assoziationstyp, der eine "Teil-zum-Ganzen"-Beziehung darstellt, in der eine Klasse ein größeres Element ("Ganzes") repräsentiert, das kleinere Elemente ("Teile") enthält. Eine separate Aggregationsbeziehung wird zwischen allen Klassen, die einen Teil repräsentieren, und einer Klasse, die das Ganze repräsentiert, verwendet.</li>
</ol>

:
:: Grafisch wird eine Komposition als einfache Linie zwischen zwei Klassen mit einer gefüllten Raute am Kompositionsende dargestellt:
:: [[Image:DV Composition.png|Kompositionsbeziehung]]

:
:: Diese Abbildung zeigt die Aggregationsbeziehung. Die Klasse <code>Group</code> repräsentiert das "Ganze" und die Klasse <code>Person</code> "Teile". Eine Multiplizität von <code>0..*</code> an beiden Enden und die Rollen <code>union</code> und <code>member</code> geben an, dass jede <code>union</code> (des Typs <code>Group</code>) eine beliebige Anzahl von <code>member</code>-Rollen (des Typs <code>Person</code>) enthalten kann, und im Gegenzug jedes Typobjekt <code>Person</code> ein <code>member</code> einer beliebigen Anzahl von <code>union</code>-Rollen (des Typs <code>Group</code>) sein kann. Die bidirektionale Aggregationsnavigation legt fest, dass ein <code>Group</code>-Typobjekt seine <code>Person</code>-Typ-Member und ein <code>Person</code>-Typobjekt Unions (des Typs <code>Group</code>), deren Member es ist, abfragen kann.

<ol start="4"><li> '''Komposition''' - Eine Komposition ist eine spezielle "starke" Form einer '''Aggregation''', bei der das "Kompositionsende" die komplette Verantwortung für die Verwaltung seiner "Teileenden" hat (z.B. das Erstellen und Freigeben seiner Teile).</li>
</ol>

:
::Grafisch wird eine Komposition als einfache Linie zwischen zwei Klassen mit einer gefüllten Raute am Kompositionsende dargestellt:
:: [[Image:DV Composition.png|Kompositionsbeziehung]]

:
:: Diese Abbildung zeigt die Kompositionsbeziehung. Die Klasse <code>Order</code> repräsentiert die "Komposition" und die Klassen <code>Customer</code> und <code>LifeItem</code> "Teile".

==Bereitgestellte und erforderliche Schnittstellen==

UML 2.0-Klassendiagramme führen die ''bereitgestellten'' und ''erforderlichen Schnittstellen'' ein.

In UML 2.0-Klassendiagrammen werden bereitgestellte Schnittstellen mit [[Image:DV ProvidedInterfaceLollipopLink.png|Bereitgestellte Schnittstellenbeziehung]] ("Lollipop"-Notation) und erforderliche Schnittstellen mit [[Image:DV RequiredInterfaceLink.png|Erforderliche Schnittstellenbeziehung]] ("Sockel"-Notation) gekennzeichnet (siehe [[Elemente in einem UML 2.0-Klassendiagramm|Elemente in einem UML 2.0-Klassendiagramm]]).

==Siehe auch==

* [[UML 2.0-Klassendiagramm - Index|UML 2.0-Klassendiagramme]]
* [[Anleitungen für Klassendiagramme|Anleitungen für Klassendiagramme]]

[[Category:RAD Studio – Referenz]]

[[fr:Relations des diagrammes de classes (UML 1.5)]]
[[ja:クラス図の関係（UML 1.5）]]

Eine Diagrammabfolge erstellen

2026-10-03T14:56:08Z

L10nBot: updated language links

{{Parent|Anleitungen für Anwendungsfalldiagramme}}
Sie können ein gesamtes Diagramm auf einer Detailebene mit dem nächsten Diagramm auf einer niedrigeren bzw. höheren Ebene verknüpfen oder eine Beziehung zwischen den Hauptanwendungsfällen oder -akteuren und dem nächsten Diagramm erstellen.

===So erstellen Sie eine Diagrammabfolge:===

# Überlegen Sie sich die folgenden Fragen:
#* Warum möchten Sie mehrere Diagramme miteinander verknüpfen? Was ist der Grundgedanke dabei?
#* Welche Diagrammtypen möchten Sie verknüpfen? In der Regel werden Anwendungsfalldiagramme verknüpft, aber Sie können auch andere Diagrammtypen in die Abfolge aufnehmen.
#* Möchten Sie "vertikale" Beziehungen von oben nach unten oder "horizontale" Beziehungen für Diagramme auf einer Ebene erstellen?
#* Möchten Sie gesamte Diagramme oder bestimmte Diagrammelemente verknüpfen?
# Öffnen Sie das Hauptdiagramm der Abfolge, die Sie erstellen möchten.
# Klicken Sie mit der rechten Maustaste auf das Diagrammelement oder, wenn Sie das gesamte Diagramm verknüpfen möchten, auf den Diagrammhintergrund.

:
:: '''Hinweis:''' Wenn Sie einen Hyperlink zu einem neuen Diagramm auswählen, wird diese Verknüpfung im Quelldiagramm angezeigt.
:: '''Tipp:''' Es wird empfohlen, dass Sie für alle Beziehungen in der Abfolge dieselbe Methode verwenden.

<ol start="4"><li>Erstellen Sie einen Hyperlink zu dem nächsten Diagramm. Die Titel der Quell- und Zielelemente werden blau angezeigt.</li>
<li> Öffnen Sie das Zieldiagramm.</li>
<li> Wiederholen Sie die Schritte 3 - 5 für alle Bestandteile der Abfolge.</li>
<li> Erstellen Sie optional Hyperlinks in der entgegengesetzten Richtung.</li>
</ol>

==Siehe auch==

* [[Hyperlinks in UML-Modellen|Hyperlinks in UML-Modellen]]
* [[UML 1.5-Anwendungsfalldiagramm - Index|UML 1.5-Anwendungsfalldiagramm - Index]]
* [[UML 2.0-Anwendungsfalldiagramm - Index|UML 2.0-Anwendungsfalldiagramm - Index]]

[[Category:Mit RAD Studio arbeiten]]

[[fr:Création d'une séquence de navigation]]
[[ja:ダイアグラム群に目を通すためのシーケンスを作成する]]

Experte zum Erstellen von Pattern

2026-10-03T14:56:07Z

L10nBot: updated language links

{{Parent|GUI-Komponenten für Pattern - Index}}
__TOC__
Mit dem '''Experten zum Erstellen von Pattern''' können Sie ein vorhandenes Fragment eines Modells als Pattern speichern und später wieder verwenden. Öffnen Sie den '''Experten zum Erstellen von Pattern''', indem Sie in einem Klassendiagramm einen oder mehrere Knoten und Beziehungen auswählen und im Kontextmenü den Befehl '''Als Pattern speichern''' wählen.

Der '''Experten zum Erstellen von Pattern''' enthält drei Seiten:

# '''Allgemein'''
# '''Pattern-Parameter'''
# '''Hierarchieordner auswählen'''

===Seite "Allgemein"===

Die Seite '''Allgemein''' enthält die folgenden Steuerelemente:

{| border="1" frame="hsides" rules="rows"
|-
! Steuerelement
! Beschreibung
|- valign="top"
|
'''Name'''
|
Legt den Namen des neuen Pattern fest.
|- valign="top"
|
'''Datei'''
|
Legt den Namen der Datei fest, in der das neue Pattern gespeichert wird.
|- valign="top"
|
'''Pattern-Objekt erstellen'''
|
Gibt an, ob die Designvorlage das Pattern-Objekt enthält. Wählen Sie dieses Kontrollkästchen, damit das Pattern als [[Pattern|First Class Citizen]] fungieren kann. Das heißt, dass nach der Zuweisung des Pattern in Diagrammen ein ovales Pattern-Element angezeigt wird.
|}

===Seite "Pattern Parameter"===

Die Seite '''Pattern Parameter''' enthält die folgenden Steuerelemente:

{| border="1" frame="hsides" rules="rows"
|-
! Steuerelement
! Beschreibung
|- valign="top"
|
'''Name'''
|
Der Elementname.
|- valign="top"
|
'''Anzeigename'''
|
Der Elementname und der Elementtyp.
|- valign="top"
|
'''Vorgabewert'''
|
Der Standardwert.
|- valign="top"
|
'''Beschreibung'''
|
Kurzbeschreibung.
|- valign="top"
|
'''Vorhandene verwenden'''
|
Wenn '''Vorhandene verwenden''' für das Pattern aktiviert ist und sich im Zielcontainer bereits ein Element mit dem gleichen Namen und Metatyp befindet, wird bei der Anwendung des Pattern kein neues Element erstellt. Das bedeutet, dass in einem Diagramm vorhandene Elemente bei Anwendung des Pattern wiederverwendet werden. Wenn Sie die Einstellung '''Vorhandene verwenden''' deaktivieren, werden neue Elemente erstellt.
|}

===Seite "Hierarchieordner auswählen"===

Die Seite '''Hierarchieordner auswählen''' enthält die folgenden Steuerelemente:

{| border="1" frame="hsides" rules="rows"
|-
! Steuerelement
! Beschreibung
|- valign="top"
|
'''Hierarchieordner auswählen'''
|
Dieser Bereich zeigt die virtuelle Pattern-Hierarchie. Hier können Sie den virtuellen Ordner auswählen, in den das zu erstellende Pattern gespeichert werden soll.
|- valign="top"
|
'''Fertig stellen'''
|
Erstellt das neue Pattern. Das neue Pattern wird in dem angegebenen virtuellen Ordner gespeichert. Das Pattern wird in der Pattern-Hierarchie aufgeführt und kann zur Erstellung neuer Designelemente verwendet werden.
|}

==Siehe auch==

* [[Pattern|Pattern]]
* [[Ein Pattern erstellen|Ein Pattern erstellen]]

[[Category:RAD Studio – Referenz]]

[[fr:Expert Créer un pattern]]
[[ja:［パターンの作成ウィザード］]]

Eigenschaften von Diagrammelementen ändern

2026-10-03T14:56:06Z

L10nBot: updated language links

{{DISPLAYTITLE:Eigenschaften von Diagrammelementen ändern}}
{{Parent|Anleitungen für die Bearbeitung von Diagrammen - Index|Bearbeiten von Diagrammen}}
Sie können die Eigenschaften von ausgewählten Diagrammelementen ändern.

===So ändern Sie die Eigenschaften eines Diagrammelements:===

# Wählen Sie in der '''Diagrammansicht''' oder der '''Modellansicht''' ein Element aus.
# Drücken Sie die Taste F11, um den '''Objektinspektor''' zu öffnen. Im '''Objektinspektor''' werden die Eigenschaften des ausgewählten Elements angezeigt.
# Ändern Sie im '''Objektinspektor''' die gewünschten Eigenschaften des Elements.

==Siehe auch==

* [[Objektinspektor (Modellierung)|Objektinspektor]]

{{DEFAULTSORT:Eigenschaften von Diagrammelementen andern}}
[[Category:Mit RAD Studio arbeiten]]

[[fr:Modification des propriétés des éléments de diagrammes]]
[[ja:ダイアグラム要素のプロパティを変更する]]

Navigation im Diagramm mit der Übersicht

2026-10-03T14:56:06Z

L10nBot: updated language links

{{Parent|Anleitungen zum Anpassen der Diagrammdarstellung - Index|Anpassen der Diagrammdarstellung und Anzeige von Diagrammen}}
Große, reale Modelle passen nicht in die '''Diagrammansicht'''. Mit dem Fenster '''Übersicht''' lässt sich der angezeigte Bereich solcher Diagramme verschieben.

===So verschieben Sie Diagramme mit dem Fenster Übersicht:===

# Öffnen Sie in der '''Diagrammansicht''' ein Diagramm. Klicken Sie in der rechten, unteren Ecke der '''Diagrammansicht''' auf die Schaltfläche '''Übersicht'''. Das Fenster '''Übersicht''' wird geöffnet und zeigt eine Miniaturansicht des aktuellen Diagramms an.

:
:: Das markierte Rechteck im Fenster '''Übersicht''' enthält den Bereich des Modells, der aktuell im Diagramm angezeigt wird.

<ol start="2"><li> Sie können die Größe des Fensters '''Übersicht''' ändern, indem Sie auf die obere linke Ecke klicken und ziehen.</li>
<li> Ziehen Sie im Fenster '''Übersicht''' das markierte Rechteck, um dynamisch den gewünschten Teil des Diagramms anzuzeigen.</li>
<li> Schließen Sie das Fenster '''Übersicht''', indem Sie auf eine beliebige Position außerhalb des Fensters '''Übersicht''' klicken.</li>
</ol>

: '''Tipp:''' In der oberen, rechten Ecke des Fensters '''Übersicht''' wird ein Griffsymbol zum Ändern der Größe angezeigt. Ziehen Sie zum Ändern der Größe des Fensters '''Übersicht''' an diesem Griff. Beim Ändern der Größe des Fensters wird der Inhalt an die neue Größe angepasst. Das Ändern der Größe ist dann sinnvoll, wenn das Modell so groß ist, dass Sie den Text auf den Miniaturdarstellungen im Fenster '''Übersicht''' nicht lesen können.

==Siehe auch==

* [[Verwenden des Modellansichtfensters und des Code-Visualisierungsdiagramms|Verwenden der Modellansicht und der Diagrammansicht]]
* [[Diagramme zoomen|Diagramme zoomen]]

{{DEFAULTSORT:Navigation im Diagramm mit der Ubersicht}}
[[Category:Mit RAD Studio arbeiten]]

[[fr:Navigation dans un diagramme avec la vue globale]]
[[ja:［概要］ペインでダイアグラムを参照する]]

Element-Stereotyp zuweisen

2026-10-03T14:56:05Z

L10nBot: updated language links

{{Parent|Anleitungen für die Bearbeitung von Diagrammen - Index|Bearbeiten von Diagrammen}}
Zu Klassen, Beziehungen, Packages, Beziehungsenden und anderen UML-Elementen können verschiedene Stereotype zugewiesen werden. In der Regel wird ein Element, dem ein Stereotyp zugeordnet ist, folgendermaßen gekennzeichnet: der Stereotypname wird in französische Anführungszeichen (<code>«type»</code>) gesetzt und über dem Elementnamen angezeigt.

Ein Stereotyp kann mit dem In-Place-Editor (in der '''Diagrammansicht''') oder im '''Objektinspektor''' mit der Eigenschaft '''Stereotype''' (in der '''Diagrammansicht''' und der '''Modellansicht''') zugewiesen werden.

===So weisen Sie ein Stereotyp im In-Place-Editor zu:===

# Doppelklicken Sie in der '''Diagrammansicht''' auf den Namen des Stereotyps, um den In-Place-Editor Editor zu aktivieren.
# Geben Sie den neuen Namen ein.
# Drücken Sie die Taste EINGABE.

===So weisen Sie ein Stereotyp im Objektinspektor zu:===

# Wählen Sie in der '''Diagrammansicht''' oder der '''Modellansicht''' ein UML-Element (z.B. eine Klasse) aus, dessen Stereotyp Sie ändern möchten.
# Wählen Sie im '''Objektinspektor''' die Eigenschaft '''Stereotype''' aus.
# Geben Sie in das Feld '''Stereotype''' den Namen des gewünschten Stereotyps ein, oder klicken Sie auf den Dropdown-Pfeil, um einen Namen aus der Liste der vordefinierten Stereotype auszuwählen.

:
:: Ergebnis: Der angegebene Stereotypname wird in der '''Diagrammansicht''' über dem Namen des ausgewählten Objekts (am oberen Ende des Klassenknotens) in französischen Anführungszeichen angezeigt.

==Siehe auch==

* [[Das Profil "UML in Farbe" verwenden|Das Profil "UML in Farbe" verwenden]]

[[Category:Mit RAD Studio arbeiten]]

[[fr:Affectation du stéréotype d'un élément]]
[[ja:要素にステレオタイプを割り当てる]]

Benutzereigenschaften hinzufügen/entfernen (Dialogfeld)

2026-10-03T14:56:04Z

L10nBot: updated language links

{{Parent|Dialogfelder für die Modellierung - Index|Dialogfelder für die Modellierung}}
'''Kontextmenü > Benutzereigenschaften'''

Zum Öffnen dieses Dialogfelds klicken Sie in der '''Modellansicht''' oder der '''Diagrammansicht''' mit der rechten Maustaste auf das Diagramm oder Modellelement und wählen '''Benutzereigenschaften''' aus dem Kontextmenü.

Mit diesem Dialogfeld werden Benutzereigenschaften erstellt und verwaltet. Es enthält eine Liste der vorhandenen Benutzereigenschaften. Jeder Eintrag in der Liste besteht aus dem Paar <code>Name</code> und <code>Wert</code>.

Sie können <code>Benutzereigenschaften</code> hinzufügen und löschen sowie die Einträge <code>Name</code> und <code>Wert</code> bearbeiten. Standardmäßig erhält <code>Name</code> die Werte <code>property1</code>, <code>property2</code> usw. Die Namen aller vorhandenen <code>Benutzereigenschaften</code> werden im [[Objektinspektor (Modellierung)|'''Objektinspektor''']] als Namen der Benutzereigenschaften angezeigt.

{| border="1" frame="hsides" rules="rows"
|-
! Steuerelement
! Beschreibung
|- valign="top"
|
Hinzufügen
|
Erzeugt in der Liste der Benutzereigenschaften eine neue <code>Benutzereigenschaft</code>.
|- valign="top"
|
Entfernen
|
Löscht die ausgewählte <code>Benutzereigenschaft</code> aus der Liste der Benutzereigenschaften.
|- valign="top"
|
OK
|
Speichert die Änderungen und schließt das Dialogfeld.
|- valign="top"
|
Abbrechen
|
Verwirft die Änderungen und schließt das Dialogfeld.
|- valign="top"
|
Hilfe
|
Zeigt dieses Hilfethema an.
|}

==Siehe auch==

* [[Benutzereigenschaften verwenden|Benutzereigenschaften verwenden]]

{{DEFAULTSORT:Benutzereigenschaften hinzufugen/entfernen (Dialogfeld)}}
[[Category:RAD Studio – Referenz]]

[[fr:Boîte de dialogue Ajouter/retirer des propriétés utilisateur]]
[[ja:［ユーザープロパティの追加/削除］ダイアログボックス]]

Hinzufügen von Teilnehmern zu FCC-Pattern

2026-10-03T14:56:04Z

L10nBot: updated language links

{{Parent|Modellierungs-Pattern – Anleitungen|Modellierungs-Pattern – Anleitungen}}
Pattern, wie [[Pattern|First Class Citizens (FCC)]], werden durch die '''GoF'''-Pattern repräsentiert. Die Elemente dieser Pattern werden mit einer vorgegebenen Anzahl von Teilnehmern erstellt. Sie können einem vorhandenen Pattern-Objekt aber zulässige Teilnehmer hinzufügen. Dadurch werden Beziehungen zwischen dem Pattern-Objekt und den neuen Teilnehmern erstellt. Ein FCC-Pattern wird in einem Diagramm als Oval mit dem Pattern-Namen und einer erweiterbaren Liste der Teilnehmer angezeigt.

'''So fügen Sie einem GoF-Pattern einen Teilnehmer hinzu:'''

# Klicken Sie in der '''Diagrammansicht''' oder der '''Modellansicht''' mit der rechten Maustaste auf ein FCC-Pattern-Element. (In der '''Diagrammansicht''' wird dieses Element als ovales Pattern dargestellt.) Das Kontextmenü wird geöffnet.
# Wählen Sie im Kontextmenü '''Hinzufügen''' aus. Ein Untermenü mit einer Liste der zulässigen Teilnehmer wird angezeigt.
# Wählen Sie den gewünschten Teilnehmer aus.
# Geben Sie im '''Experten für Pattern-Aktionen''' den Namen des neuen Teilnehmers ein, und klicken Sie auf '''OK'''.

:
:: '''Tipp:''' Wenn das Pattern [[Ein Pattern erstellen|mit der Eigenschaft '''Use Existent''' erstellt wurde]] und bereits ein Teilnehmer mit dem angegebenen Namen vorhanden ist, wird dieser verwendet.

==Siehe auch==

* [[Pattern|Pattern]]
* [[Pattern-Organizer|Pattern-Organizer]]
* [[Pattern-Registrierung|Pattern-Registrierung]]

{{DEFAULTSORT:Hinzufugen von Teilnehmern zu FCC-Pattern}}
[[Category:Mit RAD Studio arbeiten]]

[[fr:Ajout de participants aux patterns de première classe (FCC, First Class Citizens)]]
[[ja:FCC（ファーストクラス要素）としてのパターンに構成要素を追加する]]

Anpassen der Darstellung von Diagrammknoten

2026-10-03T14:55:47Z

L10nBot: updated language links

{{Parent|Anleitungen zum Anpassen der Diagrammdarstellung - Index|Anpassen der Diagrammdarstellung und Anzeige von Diagrammen}}

Sie können die folgenden Darstellungsaspekte von Konten in einem Diagramm steuern:

===So runden Sie die Ecken von rechteckigen Knoten ab:===

# Öffnen Sie die '''Diagrammansicht'''.
# Wählen Sie '''Tools > Optionen'''. Wählen Sie im Dialogfeld '''Optionen''' die Optionskategorie '''Modellierung > Vorgabe > Diagramm > Erscheinungsbild > Knoten'''.
# Setzen Sie die Option '''Ecken von Rechtecken abrunden''' auf <code>True</code>. Rechteckige Knoten werden daraufhin mit abgerundeten Ecken angezeigt.

===So blenden Sie alle Abschnitte in Knoten ein oder aus:===

# Öffnen Sie die '''Diagrammansicht'''.
# Klicken Sie mit der rechten Maustaste auf einen Knoten.
#* Wählen Sie im Kontextmenü den Befehl '''Layout > Alle ausblenden''', um alle Abschnitte in dem ausgewählten Knoten zu schließen.
#* Wählen Sie den Befehl '''Layout > Alle einblenden''', um alle Abschnitte im ausgewählten Knoten zu öffnen.
# Klicken Sie mit der rechten Maustaste auf den Diagrammhintergrund.
#* Wählen Sie im Kontextmenü den Befehl '''Layout > Alle ausblenden''', um alle Abschnitte in allen Knoten zu schließen.
#* Wählen Sie den Befehl '''Layout > Alle einblenden''', um alle Abschnitte in allen Knoten zu öffnen.

===So verbergen Sie alle Abschnitte eines Knotens:===

# Öffnen Sie die '''Diagrammansicht'''.
# Klicken Sie mit der rechten Maustaste auf einen Knoten.
# Wählen Sie im Kontextmenü den Befehl '''Layout > Kurzansicht''', um den ausgewählten Knoten ohne Abschnitte anzuzeigen.

==Siehe auch==

* [[Modellelemente aus- und einblenden|Modellelemente aus- und einblenden]]
[[Category:Mit RAD Studio arbeiten]]

[[fr:Personnalisation de la présentation des noeuds de diagrammes]]
[[ja:ダイアグラムノードの表示をカスタマイズする]]

Ordner erstellen

2026-10-03T14:55:46Z

L10nBot: updated language links

{{Parent|Verwendung des Pattern-Organizers|Verwendung des Pattern-Organizers}}
Mit Hilfe von virtuellen Ordnern können Sie die Pattern in den Pattern-Hierarchien logisch anordnen.

===So erstellen Sie einen neuen virtuellen Ordner im Pattern-Organizer:===

# Wählen Sie '''Tools > Pattern-Organizer''', um den '''[[Pattern-Organizer|Pattern-Organizer]]''' zu öffnen.
# Im '''Pattern-Organizer''' klicken Sie mit der rechten Maustaste auf den Ordner im Bereich '''Virtuelle Pattern-Hierarchie''' in dem einen neuen virtuellen Ordner erstellt wird.
# Wählen Sie '''Neuer Ordner''' aus dem Kontextmenü. Der Knoten <code>Neuer Ordner</code> wird hinzugefügt.
# Im Bereich '''Eigenschaften''' bearbeiten Sie die Eigenschaften '''Name''' und '''Sichtbar''' nach Bedarf.

==Siehe auch==

* [[Verknüpfung zu einem Pattern erstellen|Verknüpfung zu einem Pattern erstellen]]
* [[Virtuelle Pattern-Hierarchie erstellen|Hierarchie erstellen]]
* [[Pattern-Organizer|Pattern-Organizer]]
*[[Pattern-Registrierung|Pattern-Registrierung]]

[[Category:Mit RAD Studio arbeiten]]

[[fr:Création d'un dossier dans le gestionnaire de patterns]]
[[ja:［パターンオーガナイザ］にフォルダを作成する]]

Verknüpfungen, Ordner und Pattern-Hierarchien kopieren und einfügen

2026-10-03T14:55:46Z

L10nBot: updated language links

{{Parent|Verwendung des Pattern-Organizers|Verwendung des Pattern-Organizers}}
Dieses Thema beschreibt, wie Verknüpfungen, Ordner und Pattern-Hierarchien im '''[[Pattern-Organizer|Pattern-Organizer]]''' kopiert und eingefügt werden.

===So können Sie einen Ordner oder eine Verknüpfung kopieren und einfügen:===

# Wählen Sie '''Tools > Pattern-Organizer''', um den '''Pattern-Organizer''' zu öffnen.
# Klicken Sie im Bereich '''Virtuelle Pattern-Hierarchien''' mit der rechten Maustaste auf die zu kopierende Verknüpfung, den Ordner oder die Pattern-Hierarchie.
# Wählen Sie im Kontextmenü '''Kopieren'''. Oder drücken Sie STRG+C.
# Klicken Sie mit der rechten Maustaste auf den Zielknoten, und wählen Sie '''Einfügen'''. Oder drücken Sie STRG+V. Der in der Zwischenablage gespeicherte Eintrag wird in den ausgewählten Zielknoten eingefügt.
# Klicken Sie zum Speichern der Änderungen auf '''OK'''.

==Siehe auch==

* [[Pattern-Organizer|Pattern-Organizer]]
* [[Pattern-Registrierung|Pattern-Registrierung]]

{{DEFAULTSORT:Verknupfungen, Ordner und Pattern-Hierarchien kopieren und einfugen}}
[[Category:Mit RAD Studio arbeiten]]

[[fr:Copier/coller des raccourcis, des dossiers ou des arborescences de patterns]]
[[ja:ショートカット、フォルダ、およびパターンツリーをコピーして貼り付ける]]

Zielprojekt auswählen (oder Quellprojekt auswählen) (Dialogfeld)

2026-10-03T14:55:39Z

L10nBot: updated language links

{{Parent|Dialogfelder für die Modellierung - Index}}
 '''Kontextmenü der Modellansicht > In Quelltext umwandeln (oder: Quelltext aus Designprojekt umwandeln)''' 

Dieses Dialogfeld wird über das Kontextmenü eines Projekts in der '''Modellansicht''' aufgerufen. Wählen Sie das gewünschte Zielprojekt aus, und klicken Sie auf '''Umwandeln'''.

{| border="1" frame="hsides" rules="rows"
|-
! '''Element'''
! '''Beschreibung'''
|- valign="top"
|
Vorhandene Projekte
|
Zeigt die Projekte in der aktuellen Projektgruppe an. Bei Implementierungsprojekten sind die Designprojekte grau dargestellt (nicht verfügbar). Bei Designprojekten sind die Implementierungsprojekte grau dargestellt (nicht verfügbar).
|- valign="top"
|
Zuordnungsdateien für die Codeerzeugung verwenden
|
Mit diesem Kontrollkästchen wird die Unterstützung der '''Namenszuordnung''' aktiviert oder deaktiviert.
|- valign="top"
|
Umwandeln
|
Klicken Sie auf diese Schaltfläche, um die Umwandlung des Designprojekts in Quelltext zu starten. Die Schaltfläche steht erst zur Verfügung, nachdem in der Liste ein gültiges Quelltextprojekt ausgewählt wurde.
|- valign="top"
|
Abbrechen
|
Klicken Sie auf diese Schaltfläche, um Ihre Auswahlen zu verwerfen und das Dialogfeld zu schließen.
|- valign="top"
|
Hilfe
|
Öffnet dieses Thema.
|}

==Siehe auch==

* [[Umwandlung in Quelltext|Umwandlung in Quelltext]]
* [[Designprojekte in Quelltext umwandeln|Designprojekte in Quelltext umwandeln]]

{{DEFAULTSORT:Zielprojekt auswahlen (oder Quellprojekt auswahlen) (Dialogfeld)}}
[[Category:RAD Studio – Referenz]]

[[fr:Boîte de dialogue Choisir le projet de destination (ou source)]]
[[ja:［出力先プロジェクトの選択］/［変換するプロジェクトの選択］ダイアログボックス]]

Neues Diagramm hinzufügen (Dialogfeld)

2026-10-03T14:54:56Z

L10nBot: updated language links

{{Parent|Dialogfelder für die Modellierung - Index}}
'''Kontextmenü > Hinzufügen > Anderes Diagramm'''

Klicken Sie zum Öffnen dieses Dialogfelds mit der rechten Maustaste in der '''Diagrammansicht''' oder der '''Modellansicht''' auf ein Projektstamm- oder ein Namespace-Element, und wählen Sie aus dem Kontextmenü '''Hinzufügen > Anderes Diagramm'''. Alternativ können Sie in der '''Diagrammansicht''' oder der '''Modellansicht''' (bei ausgewähltem Projektstamm- oder Namespace-Element) STRG+UMSCHT+D drücken.

Das Dialogfeld '''Neues Diagramm hinzufügen''' erstellt neue Diagramme.

In diesem Dialogfeld werden die verfügbaren Diagrammtypen angezeigt, die Sie in Ihrem Projekt erstellen können.

{| border="1" frame="hsides" rules="rows"
|-
! '''Steuerelement'''
! '''Beschreibung'''
|- valign="top"
|
'''Diagramme'''
|
Im Bereich '''Diagramme''' sind die verfügbaren UML-Diagrammtypen aufgeführt. Mit den Schaltflächen [[Image:DB SmallIcons.png|Kleine Symbole]] '''Kleine Symbole''' und [[Image:DB LargeIcons.png|Große Symbole]] '''Große Symbole''' können Sie die Darstellung der UML-Diagrammsymbole ändern. Standardmäßig werden im Bereich '''Diagramme''' große Symbole verwendet.
|- valign="top"
|
'''Name'''
|
Zeigt den Namen für das zu erstellende Diagramm an. Wenn Sie im Bereich '''Diagramme''' einen Diagrammtyp auswählen, erstellt '''Neues Diagramm hinzufügen''' anhand des Diagrammtyps den im Feld '''Name''' angezeigten Namen. Sie können diesen Diagrammnamen bearbeiten oder einen anderen Namen für das zu erstellende Diagramm eingeben. Die '''Modellansicht''' und die '''Diagrammansicht''' verwenden diesen Diagrammnamen.
|- valign="top"
|
'''Große Symbole'''
|
Mit der Schaltfläche [[Image:DB LargeIcons.png|Große Symbole]] werden große Symbole für die Diagrammtypen im Bereich '''Diagramme''' dargestellt. Das ist die Vorgabe.
|- valign="top"
|
'''Kleine Symbole'''
|
Mit der Schaltfläche [[Image:DB LargeIcons.png|Kleine Symbole]] werden kleine Symbole für die Diagrammtypen im Bereich '''Diagramme''' dargestellt.
|- valign="top"
|
'''OK'''
|
Erstellt das neue Diagramm mit dem ausgewählten Typ und dem angegebenen Diagrammnamen, öffnet es in der '''Diagrammansicht''' und schließt das Dialogfeld '''Neues Diagramm hinzufügen'''.
|- valign="top"
|
'''Abbrechen'''
|
Verwirft alle Änderungen und schließt das Dialogfeld '''Neues Diagramm hinzufügen'''.
|- valign="top"
|
'''Hilfe'''
|
Zeigt dieses Hilfethema an.
|}

==Siehe auch==

* [[Modellierungsdiagramm|Modellierungsdiagramme]]
* [[Diagramme erstellen|Diagramme erstellen]]

{{DEFAULTSORT:Neues Diagramm hinzufugen (Dialogfeld)}}
[[Category:RAD Studio – Referenz]]

[[fr:Boîte de dialogue Ajouter un nouveau diagramme]]
[[ja:［新しいダイアグラムの追加］ダイアログボックス]]

Aktivierungsleiste

2026-10-03T14:54:39Z

L10nBot: updated language links

{{Parent|UML 1.5-Interaktionsdiagramm - Index|UML 1.5-Interaktionsdiagramm}}
Die Aktivitätsdauer von Nachrichten wird automatisch im Diagramm angezeigt. Wenn Sie eine Nachrichtenbeziehung zum Zielobjekt herstellen, wird die Aktivierungsleiste automatisch erstellt.

Sie können die Aktivitätsdauer einer Nachricht verlängern oder verkürzen, indem Sie die obere bzw. untere Linie der Leiste nach oben oder unten ziehen. Je länger die Leiste ist, desto länger ist die betreffende Nachricht aktiv.

==Siehe auch==

* [[UML 2.0-Interaktionsdiagramm - Index|UML 2.0-Interaktionsdiagramm]]
* [[Anleitungen für Interaktionsdiagramme - Index|Anleitungen für Interaktionsdiagramme]]

[[Category:RAD Studio – Referenz]]

[[fr:Barre d'activation (UML 1.5)]]
[[ja:活性区間 (UML 1.5)]]

Parameter für Operation hinzufügen/entfernen (Dialogfeld)

2026-10-03T14:54:20Z

L10nBot: updated language links

{{Parent|Dialogfelder für die Modellierung - Index|Dialogfelder für die Modellierung}}
Zum Öffnen dieses Dialogfeldes markieren Sie in einem Diagramm in der '''Modellansicht''' oder der '''Diagrammansicht''' eine Funktion oder Prozedur und klicken im '''Objektinspektor''' auf die Ellipse rechts neben der Eigenschaft '''Params'''.

In diesem Dialogfeld können Sie Parameter für Funktionen oder Prozeduren festlegen. Sie können Einträge hinzufügen, bearbeiten und löschen.

{| border="1" frame="hsides" rules="rows"
|- valign="top"
|
Hinzufügen
|
In der Liste der Parameter wird ein neuer Eintrag erzeugt.
|- valign="top"
|
Entfernen
|
Der ausgewählte Eintrag wird aus der Liste der Parameter entfernt.
|- valign="top"
|
OK
|
Die Änderungen werden gespeichert, und das Dialogfeld wird geschlossen.
|- valign="top"
|
Abbrechen
|
Die Änderungen werden verworfen, und das Dialogfeld wird geschlossen.
|- valign="top"
|
Hilfe
|
Dieses Thema wird angezeigt.
|}

{{DEFAULTSORT:Parameter fur Operation hinzufugen/entfernen (Dialogfeld)}}
[[Category:RAD Studio – Referenz]]

[[fr:Boîte de dialogue Ajouter/retirer des paramètres]]
[[ja:［オペレーションのパラメータの追加/削除］ダイアログボックス]]

Modellierungsoptionen (Dialogfeld)

2026-10-03T14:54:13Z

L10nBot: updated language links

{{DISPLAYTITLE: Modellierungsoptionen (Dialogfeld)}}
{{Parent|Modellierungsreferenz - Index|Modellierungsreferenz}}
{{Parent|Tools-Optionen (Dialogfeld)}}

'''Tools > Optionen >Modellierung'''

Die folgenden Seiten legen die '''Modellierungsoptionen''' fest:

:
:*Optionen für das [[Modellierung - Diagrammoptionen (Erscheinungsbild)|'''Erscheinungsbild eines Diagramms''']]
:*Optionen für das [[Modellierung - Diagrammoptionen (Layout)|'''Layout des Diagramms''']]
:*Optionen für das [[Modellierung - Diagrammoptionen (Drucken)|'''Drucken des Diagramms''']]
:*Optionen für die [[Modellierung - Diagrammoptionen (Ansichtsverwaltung)|'''Ansichtsverwaltung des Diagramms''']]
:*[[Modellierung - Allgemeine Optionen|'''Allgemeine''']] Optionen
:*Optionen für das [[Modellierung - Optionen für die Dokumentationserzeugung|'''Generieren der Dokumentation''']]
:*Optionen für die [[Optionen für die Modellansicht|'''Modellansicht''']]
:*Optionen für den [[Modellierung - Quelltextoptionen|'''Quelltext''']]
:*Optionen zum [[Modellierung - Optionen zum Erzeugen von Sequenzdiagrammen|'''Erzeugen von Sequenzdiagrammen''']]

__TOC__

==Einführung==

Wählen Sie zum Öffnen dieses Dialogfeldes '''Tools > Optionen''' und dann aus der Hierarchie links im Dialogfeld '''Optionen''' den Knoten '''Modellierung'''.

Der Knoten '''Modellierung''' enthält eine hierarchische Struktur der Modellierungsoptionen:

* Diese Hierarchie der '''Modellierungsoptionen''' enthält vier Zweige: '''Diagramm''', '''Projekt''', '''Projektgruppe''' und '''Vorgabe'''. Diese Zweige definieren vier ''hierarchische Ebenen der Modellierungsoptionen'' (siehe '''[[#Hierarchische Ebenen der Modellierungsoptionen|Hierarchische Ebenen der Modellierungsoptionen]]''' weiter unten).

* Diese Modellierungsoptionszweige enthalten die folgenden Seiten: [[Modellierung - Diagrammoptionen (Erscheinungsbild)|'''Erscheinungsbild''']], [[Modellierung - Diagrammoptionen (Layout)|'''Layout''']], [[Modellierung - Diagrammoptionen (Drucken)|'''Drucken''']], [[Modellierung - Diagrammoptionen (Ansichtsverwaltung)|'''Ansichtsverwaltung''']], [[Modellierung - Allgemeine Optionen|'''Allgemein''']], [[Modellierung - Optionen für die Dokumentationserzeugung|'''Dokumentation generieren''']], [[Optionen für die Modellansicht|'''Modellansicht''']], [[Modellierung - Quelltextoptionen|'''Quelltext''']], [[Modellierung - Optionen zum Erzeugen von Sequenzdiagrammen|'''Sequenzdiagramm erzeugen''']]. Jede Seite enthält ''Modellierungsoptionsgruppen'' (siehe '''[[#Modellierungsoptionsgruppen|Modellierungsoptionsgruppen]]''' weiter unten).

Mit den Optionen der '''Modellierungsoptionsseiten''' passen Sie das Verhalten der Modellierung an.

Für jede Option steht eine eigene detaillierte Beschreibung zur Verfügung. Wenn Sie eine Option auswählen, wird ihre Beschreibung im unteren, rechten Bereich des Dialogfelds '''Optionen''' angezeigt.

==<big>(Ebene)</big> in Menüs der Modellierungsoptionen ==

<big>Mit '''(Ebene)'''</big> wird in Menüs, z.B. '''Tools > Optionen > Modellierung > <big>(Ebene)</big> > Allgemein''', angegeben, dass die Optionsseite '''Allgemein''' in den Zweigen '''Diagramm''', '''Projekt''', '''Projektgruppe''' oder '''Vorgabe''' der {{Variables|Together}}-Optionshierarchie ausgewählt werden kann. Im Zweig '''Diagramm''' setzt diese Seite Optionen für das aktuelle Diagramm, im Zweig '''Projekt''' Optionen für das aktuelle Projekt, in Zweig '''Projektgruppe''' Optionen für die aktuelle Projektgruppe und im Zweig '''Vorgabe''' Optionen für die IDE. (Siehe den nächsten Abschnitt [[# Hierarchische Ebenen der Modellierungsoptionen | ''' Hierarchische Ebenen der Modellierungsoptionen''']] für weitere Informationen).

==Hierarchische Ebenen der Modellierungsoptionen==

Die Hierarchie der {{Variables|Together}}-Optionen enthält vier Zweige: '''Diagramm''', '''Projekt''', '''Projektgruppe''' und '''Vorgabe'''. Die folgende Liste verdeutlicht, dass diese Zweige vier hierarchische Ebenen definieren. Für diese Ebenen lassen sich {{Variables|Together}}-Optionen festlegen:

# '''Diagramm''' - Die unterste Ebene. Das ist die Unterebene aller anderen Ebenen.

:
:: Der Zweig '''Diagramm''' definiert Modellierungsoptionen nur für das aktuelle Diagramm.

:
:: Der Zweig '''Diagramm''' enthält nur die Optionsgruppen [[Modellierung - Diagrammoptionen (Erscheinungsbild)|'''Erscheinungsbild''']], [[Modellierung - Diagrammoptionen (Layout)|'''Layout''']], [[Modellierung - Diagrammoptionen (Drucken)|'''Drucken''']] und [[Modellierung - Diagrammoptionen (Ansichtsverwaltung)|'''Ansichtsverwaltung''']]. Diese Optionen steuern das Verhalten, das Erscheinungsbild und das Drucken eines bestimmten Diagramms. 

:
:: Die im Zweig '''Diagramm''' definierten Optionen überschreiben die entsprechenden Optionen, die auf den anderen, allgemeineren Ebenen - '''Projekt''', '''Projektgruppe''' und '''Vorgabe''' - definiert sind.

<ol start="2"><li>'''Projekt''' - Dem '''Diagramm''' übergeordnete Ebene und Unterebene der Ebenen '''Projektgruppe''' und '''Vorgabe'''.</li>
</ol>

:
:: Der Zweig '''Projekt''' definiert Modellierungsoptionen, die als Standardoptionen für alle Diagramme im aktuellen Projekt verwendet werden.

:
:: Die auf der Ebene '''Projekt''' festgelegten Optionen überschreiben die entsprechenden Optionen, die auf den beiden allgemeineren Ebenen - '''Projektgruppe''' und '''Vorgabe''' - definiert sind, werden aber für jedes Diagramm von den entsprechenden Optionen überschrieben, die auf der Ebene '''Diagramm''' für dieses Diagramm definiert sind.

<ol start="3"><li>'''Projektgruppe''' - Den Ebenen '''Diagramm''' und '''Projekt''' übergeordnete Ebene und Unterebene der Ebene '''Vorgabe'''.</li>
</ol>

:
:: Der Zweig '''Projektgruppe''' definiert Modellierungsoptionen, die als Standardoptionen für alle Diagramme in der aktuellen Projektgruppe verwendet werden.

:
:: Die auf der Ebene '''Projektgruppe''' festgelegten Optionen überschreiben die entsprechenden Optionen, die auf der allgemeineren Ebene '''Vorgabe''' definiert sind, werden aber für bestimmte Diagramme von den entsprechenden Optionen überschrieben, die auf den Ebenen '''Diagramm''' und '''Projekt''' für diese Diagramme definiert sind.

<ol start="4"><li>'''Vorgabe''' - Die oberste Ebene. Das ist die allen anderen Ebenen übergeordnete Ebene.</li>
</ol>

:
:: Der Zweig '''Vorgabe''' definiert Optionen, die als Standardoptionen für die Modellierung von der IDE verwendet werden.

:
:: Die auf dieser Ebene definierten Optionen dienen als Standardoptionen für jedes in der IDE geöffnete oder erstellte Diagramm. Wenn aber für eine bestimmte Option auf den Ebenen '''Diagramm''', '''Projekt''' oder '''Projektgruppe''' eine abweichende Einstellung definiert ist, dann überschreibt diese Einstellung die auf der Ebene '''Vorgabe''' definierte Einstellung.

: Sie können die Einstellungen einer Optionsgruppe für eine bestimmte Ebene endgültig festlegen und mögliche Änderungen in dieser Gruppe in den unteren Ebenen deaktivieren. (Siehe '''So deaktivieren Sie Gruppen von Modellierungsoptionen in Unterebenen:''' in '''[[Konfigurieren der UML-Modellierung|Konfigurieren der UML-Modellierung]]'''.)

Die Hierarchie der '''Modellierungsoptionen''' enthält vier Zweige: '''Diagramm''', '''Projekt''', '''Projektgruppe''' und '''Vorgabe'''. Die folgende Liste verdeutlicht, dass diese Zweige vier hierarchische Ebenen definieren. Für diese Ebenen lassen sich Modellierungsoptionen festlegen:

==Modellierungsoptionsgruppen==

Die folgenden Optionsgruppen stehen für die Modellierung zur Verfügung:

{| border="1" frame="hsides" rules="rows"
|-
! '''Optionsgruppe'''
! '''Beschreibung'''
|- valign="top"
|
'''Diagramm:'''
* [[Modellierung - Diagrammoptionen (Erscheinungsbild)|'''Erscheinungsbild''']]
* [[Modellierung - Diagrammoptionen (Layout)|'''Layout''']]
* [[Modellierung - Diagrammoptionen (Drucken)|'''Drucken''']]
* [[Modellierung - Diagrammoptionen (Ansichtsverwaltung)|'''Ansichtsverwaltung''']]
|
Die Gruppe '''Diagramm''' enthält die folgenden Untergruppen:
* '''Erscheinungsbild''' - Die Optionen in dieser Gruppe steuern das Verhalten und Erscheinungsbild des Diagramms.
* '''Layout''' - Die Optionen in dieser Gruppe steuern die Ausrichtung und Positionierung von Diagrammelementen.
* '''Drucken''' - Die Optionen in dieser Gruppe steuern, wie Diagramme gedruckt werden.
* '''Ansichtsverwaltung''' - Die Optionen in dieser Gruppe stellen Filter bereit, die die auf verschiedenen Diagrammen angezeigten Elementtypen steuern.

Die Optionen in der Gruppe '''Diagramm''' definieren das Verhalten und Erscheinungsbild von Diagrammen, in Diagrammen angezeigten Elementtypen und wie Diagramme gedruckt werden. 
|- valign="top"
|
[[Modellierung - Allgemeine Optionen|'''Allgemein''']]
|
Die Optionen in der Gruppe '''Allgemein''' passen bestimmtes Verhalten in der Benutzeroberfläche der Modellierung an, das keine anderen Optionsgruppen, wie z.B. die Gruppe '''Diagramm''', betrifft.
|- valign="top"
|
[[Modellierung - Optionen für die Dokumentationserzeugung|'''Dokumentation generieren''']]
|
Die Optionen in der Gruppe '''Dokumentation generieren''' steuern die Elementtypen, die in die erzeugte HTML-Dokumentation zur Beschreibung der Diagramme ein- oder ausgeschlossen werden sollen.
|- valign="top"
|
[[Optionen für die Modellansicht|'''Modellansicht''']]
|
Die Optionen in der Gruppe '''Modellansicht''' steuern, wie Elemente von Diagrammen in der '''Modellansicht''' angezeigt werden sollen.
|- valign="top"
|
[[Modellierung - Quelltextoptionen|'''Quelltext''']]
|
Die Optionen in der Gruppe '''Quelltext''' steuern verschiedene Parameter der Echtzeit-Synchronisierung zwischen UML-Modellen und Quelltext.
|- valign="top"
|
[[Modellierung - Optionen zum Erzeugen von Sequenzdiagrammen|'''Sequenzdiagramm erzeugen''']]
|
Die Optionen in der Gruppe '''Sequenzdiagramm erzeugen''' steuern das Erzeugen von Sequenzdiagrammen aus dem Quelltext.
|}

==Siehe auch==

*[[Konfigurieren der UML-Modellierung|Konfigurieren der UML-Modellierung]]

[[Category:RAD Studio – Referenz]]

[[fr:Fenêtre de dialogue Options de modélisation]]
[[ja:［モデリングオプション］ダイアログウィンドウ]]

Konditionaler Block (UML 1.5)

2026-10-03T14:54:06Z

L10nBot: updated language links

{{Parent|UML 1.5-Interaktionsdiagramm - Index|UML 1.5-Interaktionsdiagramm}}
Die konditionale Blockanweisung ist eine flexible Möglichkeit, ein Sequenzdiagramm zu erweitern. Folgende Anweisungen werden unterstützt:

* if
* else
* for
* foreach
* while
* do while
* try
* catch
* finally
* switch
* case
* default

==Siehe auch==

* [[UML 2.0-Interaktionsdiagramm - Index|UML 2.0-Interaktionsdiagramm]]
* [[Anleitungen für Interaktionsdiagramme - Index|Anleitungen für Interaktionsdiagramme]]

[[Category:RAD Studio – Referenz]]

[[fr:Bloc conditionnel (UML 1.5)]]
[[ja:条件ブロック (UML 1.5)]]

Überblick zum Extrahieren von Methoden (Delphi)

2026-10-03T14:53:59Z

L10nBot: updated language links

{{Parent|Refactoring von Anwendungen - Index}}
Mit dem Refactoring-Befehl '''Methode extrahieren''' kann ein Codefragment in eine Methode geändert werden, deren Name den Zweck der Methode beschreibt. Der zuvor ausgewählte Quelltext wird dazu analysiert. Kann dieser Quelltext nicht zu einer Methode extrahiert werden, gibt die Refactoring-Engine eine Warnung aus. Ist ein Refactoring möglich, erzeugt die Engine außerhalb der aktuellen Methode eine neue Methode. Anschließend definiert die Engine die erforderlichen Parameter, generiert lokale Variablen, bestimmt den Rückgabetyp und fordert den Benutzer zur Eingabe eines Namens auf. Die Refactoring-Engine fügt einen Aufruf der neuen Methode an der Position der alten Methode ein.

Beim Extrahieren von Methoden sind einige Einschränkungen zu beachten. Dies sind:

* Es können nur Anweisungen, aber keine Ausdrücke extrahiert werden.
* In {{Delphi}} können keine Anweisungen extrahiert werden, die einen Aufruf von '''inherited''' enthalten.
* Es können keine Anweisungen innerhalb eines '''with'''-Blocks extrahiert werden.
* Anweisungen, die Aufrufe einer lokalen Prozedur oder Funktion enthalten, können nicht extrahiert werden.

Wenn Sie einen Ausdruck auswählen und den Befehl '''Methode extrahieren''' aufrufen, wird die Auswahl auf die gesamte Anweisung erweitert. Dient der Ausdruck in der Anweisung als Ergebnis, gibt der extrahierte Quelltext anstelle des Ausdrucks ein Funktionsergebnis zurück.

{{Note| In {{Delphi}} können Sie den Befehl '''Methode extrahieren''' für Code mit [[Übersicht über Generics|Generics]] anwenden.}}

==Siehe auch==

* [[Überblick zum Refactoring|Überblick zum Refactoring]]
* [[Refactoring von Quelltext|Refactoring von Quelltext]]
* [[Ein Symbol umbenennen|Ein Symbol umbenennen]]

{{DEFAULTSORT:Uberblick zum Extrahieren von Methoden (Delphi)}}
[[Category:Mit RAD Studio arbeiten]]
[[Category:AMMigrate]]

[[fr:Présentation de l'extraction d'une méthode (Delphi)]]
[[ja:メソッドの抽出の概要（Delphi）]]

Delegationskonnektoren erstellen

2026-10-03T14:53:56Z

L10nBot: updated language links

{{Parent|Anleitungen für UML 2.0-Kompositionsstrukturdiagramme|Anleitungen für UML 2.0-Kompositionsstrukturdiagramme}}
Dieses Thema erläutert das Erstellen eines Delegationskonnektors.

'''So erstellen Sie einen Delegationskonnektor:'''

# Klicken Sie mit der rechten Maustaste auf eine Schnittstelle, und wählen Sie im Kontextmenü '''Neu > Delegationskonnektor'''.
# Wählen Sie im Dialogfeld '''Ziel auswählen''' das Ziel-Interface im '''Modell oder Favoriten''' aus.
# Klicken Sie auf '''OK'''.

==Siehe auch==

* [[UML 2.0-Kompositionsstrukturdiagramm - Index|UML 2.0-Kompositionsstrukturdiagramm]]

[[Category:Mit RAD Studio arbeiten]]

[[fr:Création d'un connecteur de délégation]]
[[ja:委譲コネクタを作成する]]

Erweiterungspunkte erstellen

2026-10-03T14:53:55Z

L10nBot: updated language links

{{Parent|Anleitungen für Anwendungsfalldiagramme|Anleitungen für Anwendungsfalldiagramme}}
Dieses Thema erläutert das Erstellen eines Erweiterungspunkts.

===So erstellen Sie einen Erweiterungspunkt:===

# Klicken Sie in der '''Diagrammansicht''' oder der '''Modellansicht''' mit der rechten Maustaste auf das Anwendungsfallelement, in das Sie einen Erweiterungspunkt einfügen möchten.
# Wählen Sie im Kontextmenü '''Hinzufügen > Erweiterungspunkt'''.
# Geben Sie im In-Place-Editor den Namen des Erweiterungspunkts ein.
# Klicken Sie in der '''Tool-Palette''' auf '''Erweiterung'''.
# Führen Sie den Cursor über denjenigen Anwendungsfall, mit dem der Anwendungsfall erweitert werden soll. Wenn der Rahmen des Anwendungsfalls hervorgehoben wird, klicken Sie und ziehen den Cursor zum Basisanwendungsfall. Wenn der Rahmen des Basisanwendungsfalls markiert ist, lassen Sie die Maustaste los.
# Die Beziehung mit dem Stereotyp <code><<extend>></code>, die zwei ausgewählte Anwendungsfälle verbindet, wird angezeigt. Wählen Sie diese Beziehung aus. Geben Sie im '''Objektinspektor''' in die Eigenschaft '''Label''' den (zuvor festgelegten) Namen des Erweiterungspunkts ein.

==Siehe auch==

*[[UML 1.5-Anwendungsfalldiagramm - Index|UML 1.5-Anwendungsfalldiagramm]]
*[[UML 2.0-Anwendungsfalldiagramm - Index|UML 2.0-Anwendungsfalldiagramm]]

[[Category:Mit RAD Studio arbeiten]]

[[fr:Création d'un point d'extension]]
[[ja:拡張点を作成する]]